We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Text \ DecoderFallbackBuffer

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //
  16. using System;
  17. using System.Threading;
  18. using System.Globalization;
  20. namespace System.Text
  21. {
  22.     [Serializable()]
  23.     public abstract class DecoderFallback
  24.     {
  25.         internal bool bIsMicrosoftBestFitFallback = false;
  26.        
  27.         private static DecoderFallback replacementFallback;
  28.         // Default fallback, uses no best fit & "?"
  29.         private static DecoderFallback exceptionFallback;
  30.        
  31.         // Private object for locking instead of locking on a internal type for SQL reliability work.
  32.         private static object s_InternalSyncObject;
  33.         private static object InternalSyncObject {
  34.             get {
  35.                 if (s_InternalSyncObject == null) {
  36.                     object o = new object();
  37.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  38.                 }
  39.                 return s_InternalSyncObject;
  40.             }
  41.         }
  42.        
  43.         // Get each of our generic fallbacks.
  44.        
  45.         public static DecoderFallback ReplacementFallback {
  46.             get {
  47.                 if (replacementFallback == null)
  48.                     lock (InternalSyncObject)
  49.                         if (replacementFallback == null)
  50.                             replacementFallback = new DecoderReplacementFallback();
  53.                
  54.                 return replacementFallback;
  55.             }
  56.         }
  57.        
  58.        
  59.         public static DecoderFallback ExceptionFallback {
  60.             get {
  61.                 if (exceptionFallback == null)
  62.                     lock (InternalSyncObject)
  63.                         if (exceptionFallback == null)
  64.                             exceptionFallback = new DecoderExceptionFallback();
  67.                
  68.                 return exceptionFallback;
  69.             }
  70.         }
  71.        
  72.         // Fallback
  73.         //
  74.         // Return the appropriate unicode string alternative to the character that need to fall back.
  75.         // Most implimentations will be:
  76.         // return new MyCustomDecoderFallbackBuffer(this);
  77.        
  78.         public abstract DecoderFallbackBuffer CreateFallbackBuffer();
  79.        
  80.         // Maximum number of characters that this instance of this fallback could return
  81.        
  82.         public abstract int MaxCharCount {
  83.             get;
  84.         }
  85.        
  86.         internal bool IsMicrosoftBestFitFallback {
  87.             get { return bIsMicrosoftBestFitFallback; }
  88.         }
  89.     }
  90.    
  91.    
  92.     public abstract class DecoderFallbackBuffer
  93.     {
  94.        
  95.        
  96.         public abstract bool Fallback(byte[] bytesUnknown, int index);
  97.        
  98.         // Get next character
  99.        
  100.         public abstract char GetNextChar();
  101.        
  102.         // Back up a character
  103.        
  104.         public abstract bool MovePrevious();
  105.        
  106.         // How many chars left in this fallback?
  107.        
  108.         public abstract int Remaining {
  109.             get;
  110.         }
  111.        
  112.         // Clear the buffer
  113.        
  114.         public virtual void Reset()
  115.         {
  116.             while (GetNextChar() != (char)0)
  117.                 ;
  118.         }
  119.        
  120.         // Internal items to help us figure out what we're doing as far as error messages, etc.
  121.         // These help us with our performance and messages internally
  122.         unsafe internal byte* byteStart = null;
  123.         unsafe internal char* charEnd = null;
  124.        
  125.         // Internal Reset
  126.         unsafe internal void InternalReset()
  127.         {
  128.             byteStart = null;
  129.             Reset();
  130.         }
  131.        
  132.         // Set the above values
  133.         // This can't be part of the constructor because DecoderFallbacks would have to know how to impliment these.
  134.         unsafe internal void InternalInitialize(byte* byteStart, char* charEnd)
  135.         {
  136.             this.byteStart = byteStart;
  137.             this.charEnd = charEnd;
  138.         }
  139.        
  140.         unsafe internal virtual bool InternalFallback(byte[] bytes, byte* pBytes, ref char* chars)
  141.         {
  142.             // Copy bytes to array (slow, but right now that's what we get to do.
  143.             // byte[] bytesUnknown = new byte[count];
  144.             // for (int i = 0; i < count; i++)
  145.             // bytesUnknown[i] = *(bytes++);
  146.            
  147.             BCLDebug.Assert(byteStart != null, "[DecoderFallback.InternalFallback]Used InternalFallback without calling InternalInitialize");
  148.            
  149.             // See if there's a fallback character and we have an output buffer then copy our string.
  150.             if (this.Fallback(bytes, (int)(pBytes - byteStart - bytes.Length))) {
  151.                 // Copy the chars to our output
  152.                 char ch;
  153.                 char* charTemp = chars;
  154.                 bool bHighSurrogate = false;
  155.                 while ((ch = GetNextChar()) != 0) {
  156.                     // Make sure no mixed up surrogates
  157.                     if (Char.IsSurrogate(ch)) {
  158.                         if (Char.IsHighSurrogate(ch)) {
  159.                             // High Surrogate
  160.                             if (bHighSurrogate)
  161.                                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  162.                             bHighSurrogate = true;
  163.                         }
  164.                         else {
  165.                             // Low surrogate
  166.                             if (bHighSurrogate == false)
  167.                                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  168.                             bHighSurrogate = false;
  169.                         }
  170.                     }
  171.                    
  172.                     if (charTemp >= charEnd) {
  173.                         // No buffer space
  174.                         return false;
  175.                     }
  176.                    
  177.                     *(charTemp++) = ch;
  178.                 }
  179.                
  180.                 // Need to make sure that bHighSurrogate isn't true
  181.                 if (bHighSurrogate)
  182.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  183.                
  184.                 // Now we aren't going to be false, so its OK to update chars
  185.                 chars = charTemp;
  186.             }
  187.            
  188.             return true;
  189.         }
  190.        
  191.         // This version just counts the fallback and doesn't actually copy anything.
  192.         unsafe internal virtual int InternalFallback(byte[] bytes, byte* pBytes)
  193.         {
  194.             // Copy bytes to array (slow, but right now that's what we get to do.
  195.             // byte[] bytesUnknown = new byte[count];
  196.             // for (int i = 0; i < count; i++)
  197.             // bytesUnknown[i] = *(bytes++);
  198.            
  199.             BCLDebug.Assert(byteStart != null, "[DecoderFallback.InternalFallback]Used InternalFallback without calling InternalInitialize");
  200.            
  201.             // See if there's a fallback character and we have an output buffer then copy our string.
  202.             if (this.Fallback(bytes, (int)(pBytes - byteStart - bytes.Length))) {
  203.                 int count = 0;
  204.                
  205.                 char ch;
  206.                 bool bHighSurrogate = false;
  207.                 while ((ch = GetNextChar()) != 0) {
  208.                     // Make sure no mixed up surrogates
  209.                     if (Char.IsSurrogate(ch)) {
  210.                         if (Char.IsHighSurrogate(ch)) {
  211.                             // High Surrogate
  212.                             if (bHighSurrogate)
  213.                                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  214.                             bHighSurrogate = true;
  215.                         }
  216.                         else {
  217.                             // Low surrogate
  218.                             if (bHighSurrogate == false)
  219.                                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  220.                             bHighSurrogate = false;
  221.                         }
  222.                     }
  223.                    
  224.                     count++;
  225.                 }
  226.                
  227.                 // Need to make sure that bHighSurrogate isn't true
  228.                 if (bHighSurrogate)
  229.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequenceNoIndex"));
  230.                
  231.                 return count;
  232.             }
  233.            
  234.             // If no fallback return 0
  235.             return 0;
  236.         }
  237.        
  238.         // private helper methods
  239.         internal void ThrowLastBytesRecursive(byte[] bytesUnknown)
  240.         {
  241.             // Create a string representation of our bytes.
  242.             StringBuilder strBytes = new StringBuilder(bytesUnknown.Length * 3);
  243.             int i;
  244.             for (i = 0; i < bytesUnknown.Length && i < 20; i++) {
  245.                 if (strBytes.Length > 0)
  246.                     strBytes.Append(" ");
  247.                 strBytes.Append(String.Format(CultureInfo.InvariantCulture, "\\x{0:X2}", bytesUnknown[i]));
  248.             }
  249.             // In case the string's really long
  250.             if (i == 20)
  251.                 strBytes.Append(" ...");
  252.            
  253.             // Throw it, using our complete bytes
  254.             throw new ArgumentException(Environment.GetResourceString("Argument_RecursiveFallbackBytes", strBytes.ToString()), "bytesUnknown");
  255.         }
  256.        
  257.     }
  258. }

Developer Fusion