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.Globalization \ ExceptionTableItem

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. //
  17. // Class: TextInfo
  18. //
  19. // Purpose: This Class defines behaviors specific to a writing system.
  20. // A writing system is the collection of scripts and
  21. // orthographic rules required to represent a language as text.
  22. //
  23. // Date: March 31, 1999
  24. //
  25. ////////////////////////////////////////////////////////////////////////////
  27. namespace System.Globalization
  28. {
  29.     using System;
  30.     using System.Text;
  31.     using System.Threading;
  32.     using System.Runtime.InteropServices;
  33.     using System.Runtime.CompilerServices;
  34.     using System.Runtime.Serialization;
  35.     using System.Security.Permissions;
  36.    
  37.    
  38.     [Serializable()]
  39.     [System.Runtime.InteropServices.ComVisible(true)]
  40.     public class TextInfo : ICloneable, IDeserializationCallback
  41.     {
  42.         //--------------------------------------------------------------------//
  43.         // Internal Information //
  44.         //--------------------------------------------------------------------//
  45.        
  46.        
  47.         //
  48.         // Variables.
  49.         //
  50.        
  51.         [OptionalField(VersionAdded = 2)]
  52.         private string m_listSeparator;
  53.        
  54.         [OptionalField(VersionAdded = 2)]
  55.         private bool m_isReadOnly = false;
  56.        
  57.         //
  58.         // Basically, this is the language ID (LANGID) used to call Win32 NLS APIs except that
  59.         // the value can be zero for the invariant culture.
  60.         // The reason for this data member to exist is that Win32 APIs
  61.         // doesn't take all of the culture IDs supported in NLS+.
  62.         // For example, NLS+ support culture IDs like 0x0000, 0x0009.
  63.         // However, these are not valid locale IDs in Win32. Therefore,
  64.         // we use a table to map a culutre ID like
  65.         // 0x0009 to 0x0409.
  66.         //
  67.        
  68.         // m_textInfoID should be either 0 or a supported language ID. See TextInfo(m_textInfoID)
  69.         // for comments.
  70.         [NonSerialized()]
  71.         private int m_textInfoID;
  72.         [NonSerialized()]
  73.         private string m_name = null;
  74.         [NonSerialized()]
  75.         private CultureTableRecord m_cultureTableRecord;
  76.         [NonSerialized()]
  77.         private TextInfo m_casingTextInfo;
  78.        
  79.         //
  80.         // m_pNativeTextInfo is a 32-bit pointer value pointing to a native C++ NativeTextInfo object.
  81.         // The C++ NativeTextInfo is providing the implemenation of uppercasing/lowercasing.
  82.         //
  83.         // Note: m_pNativeTextInfo is intialized with invariant in case of synthetic cultuers
  84.         [NonSerialized()]
  85.         unsafe private void* m_pNativeTextInfo;
  86.         unsafe private static void* m_pInvariantNativeTextInfo;
  87.         unsafe private static void* m_pDefaultCasingTable;
  88.        
  89.         // This file contains the default casing data (uppercasing/lowercasing/titlecasing), and the table to
  90.         // map cultures with exceptions to an exception sub-table in CASING_EXCEPTIONS_FILE_NAME.
  91.         private const string CASING_FILE_NAME = "l_intl.nlp";
  92.         // This file contains the casing data for cultures with exceptions.
  93.         private const string CASING_EXCEPTIONS_FILE_NAME = "l_except.nlp";
  94.        
  95.         //
  96.         // This is the header for the native data table that we load from charinfo.nlp.
  97.         //
  98.         [StructLayout(LayoutKind.Explicit)]
  99.         unsafe internal struct TextInfoDataHeader
  100.         {
  101.             [FieldOffset(0)]
  102.             internal char TableName;
  103.             // WCHAR[16]
  104.             [FieldOffset(32)]
  105.             internal ushort version;
  106.             // WORD[4]
  107.             [FieldOffset(40)]
  108.             internal uint OffsetToUpperCasingTable;
  109.             // DWORD
  110.             [FieldOffset(44)]
  111.             internal uint OffsetToLowerCasingTable;
  112.             // DWORD
  113.             [FieldOffset(48)]
  114.             internal uint OffsetToTitleCaseTable;
  115.             // DWORD
  116.             [FieldOffset(52)]
  117.             internal uint PlaneOffset;
  118.             // Each plane has DWORD offset for uppercase and DWORD offset for lowercase.
  119.             // 0xb4 = 0x34 + 8*16
  120.             [FieldOffset(180)]
  121.             internal ushort exceptionCount;
  122.             [FieldOffset(182)]
  123.             internal ushort exceptionLangId;
  124.         }
  125.        
  126.         [StructLayout(LayoutKind.Sequential, Pack = 2)]
  127.         internal struct ExceptionTableItem
  128.         {
  129.             internal ushort langID;
  130.             // The lcid that contains the exceptions.
  131.             internal ushort exceptIndex;
  132.             // The name of the exception tables.
  133.         }
  134.        
  135.        
  136.         // The base pointer of the defult casing table
  137.         unsafe static byte* m_pDataTable;
  138.         // The total count of cultures with exceptions.
  139.         static int m_exceptionCount;
  140.         // The pointer to the exception index table. This table maps a culture with exceptions
  141.         // to a sub-table in the exception data table.
  142.         unsafe static ExceptionTableItem* m_exceptionTable;
  143.        
  144.         // The base pointer for exception data file.
  145.         unsafe static byte* m_pExceptionFile;
  146.         // This array caches the native pointer of the NativeTextInfo get by calling InternalAllocateCasingTable.
  147.        
  148.         // NOTE: use long to hold native pointers.
  149.         //static unsafe void*[] m_exceptionNativeTextInfo;
  150.         unsafe static long[] m_exceptionNativeTextInfo;
  151.        
  152.         ////////////////////////////////////////////////////////////////////////
  153.         //
  154.         // Actions:
  155.         // This is the static ctor for TextInfo. It does the following items:
  156.         // * Get the total count of cultures with exceptions.
  157.         // * Set up an exception index table so that we can check if a culture has exception. If yes, which sub-table
  158.         // in the exception table file we should use for this culture.
  159.         // * Set up a cache for NativeTextInfo that we create for cultures with exceptions.
  160.         //
  161.         ////////////////////////////////////////////////////////////////////////
  162.        
  163.         unsafe static TextInfo()
  164.         {
  165.             //with AppDomains active, the static initializer is no longer good enough to ensure that only one
  166.             //thread is ever in AllocateDefaultCasingTable at a given time.
  167.             //We use InterlockedExchangePointer in the native side to ensure that only one instance of native CasingTable instance
  168.             //is created per process.
  169.            
  170.             //We check if the table is already allocated in native, so we only need to synchronize
  171.             //access in managed.
  172.             byte* temp = GlobalizationAssembly.GetGlobalizationResourceBytePtr(typeof(TextInfo).Assembly, CASING_FILE_NAME);
  173.             System.Threading.Thread.MemoryBarrier();
  174.             m_pDataTable = temp;
  175.            
  176.             TextInfoDataHeader* pHeader = (TextInfoDataHeader*)m_pDataTable;
  177.             m_exceptionCount = pHeader->exceptionCount;
  178.             // Setup exception tables
  179.             m_exceptionTable = (ExceptionTableItem*)&(pHeader->exceptionLangId);
  180.             m_exceptionNativeTextInfo = new long[m_exceptionCount];
  181.            
  182.             // Create the native NativeTextInfo for the default linguistic casing table.
  183.             m_pDefaultCasingTable = AllocateDefaultCasingTable(m_pDataTable);
  184.            
  185.             BCLDebug.Assert(m_pDataTable != null, "Error in reading the table.");
  186.             BCLDebug.Assert(m_pDefaultCasingTable != null, "m_pDefaultCasingTable != null");
  187.         }
  188.        
  189.         // Private object for locking instead of locking on a public type for SQL reliability work.
  190.         private static object s_InternalSyncObject;
  191.         private static object InternalSyncObject {
  192.             get {
  193.                 if (s_InternalSyncObject == null) {
  194.                     object o = new object();
  195.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  196.                 }
  197.                 return s_InternalSyncObject;
  198.             }
  199.         }
  200.        
  201.         ////////////////////////////////////////////////////////////////////////
  202.         //
  203.         // TextInfo Constructors
  204.         //
  205.         // Implements CultureInfo.TextInfo.
  206.         //
  207.         ////////////////////////////////////////////////////////////////////////
  208.         unsafe internal TextInfo(CultureTableRecord table)
  209.         {
  210.             this.m_cultureTableRecord = table;
  211.             this.m_textInfoID = this.m_cultureTableRecord.ITEXTINFO;
  212.            
  213.             if (table.IsSynthetic) {
  214.                 // <SyntheticSupport/>
  215.                 //
  216.                 // we just initialize m_pNativeTextInfo with variant to make the synthetic TextInfo works when
  217.                 // GetCaseInsensitiveHashCode and ChangeCaseSurrogate get called. otherwise m_pNativeTextInfo
  218.                 // is not used at all in TextInfo with synthetic cultures.
  219.                 //
  220.                 m_pNativeTextInfo = InvariantNativeTextInfo;
  221.             }
  222.             else {
  223.                 this.m_pNativeTextInfo = GetNativeTextInfo(this.m_textInfoID);
  224.             }
  225.         }
  226.        
  227.        
  228.         ////////////////////////////////////////////////////////////////////////
  229.         //
  230.         // Return the native TextInfo instance for the invariant culture.
  231.         //
  232.         ////////////////////////////////////////////////////////////////////////
  233.        
  234.         unsafe static internal void* InvariantNativeTextInfo {
  235.             get {
  236.                 if (m_pInvariantNativeTextInfo == null) {
  237.                     lock (InternalSyncObject) {
  238.                         if (m_pInvariantNativeTextInfo == null) {
  239.                             m_pInvariantNativeTextInfo = GetNativeTextInfo(CultureInfo.LOCALE_INVARIANT);
  240.                         }
  241.                     }
  242.                 }
  243.                 BCLDebug.Assert(m_pInvariantNativeTextInfo != null, "TextInfo.InvariantNativeTextInfo: m_pInvariantNativeTextInfo != null");
  244.                 return (m_pInvariantNativeTextInfo);
  245.             }
  246.         }
  247.        
  248.         #region Serialization
  249.         // The following field is used only for the supplemental custom culture serialization to remember
  250.         // the name of the custom culture so we can reconstruct the text info properly during the deserialization.
  251.        
  252.         [OptionalField(VersionAdded = 2)]
  253.         private string customCultureName;
  254.        
  255.        
  256.         internal int m_nDataItem;
  257.         internal bool m_useUserOverride;
  258.         internal int m_win32LangID;
  259.        
  260.        
  261.         [OnDeserializing()]
  262.         private void OnDeserializing(StreamingContext ctx)
  263.         {
  264.             m_cultureTableRecord = null;
  265.             m_win32LangID = 0;
  266.         }
  267.        
  268.         unsafe private void OnDeserialized()
  269.         {
  270.             // this method will be called twice because of the support of IDeserializationCallback
  271.             if (m_cultureTableRecord == null) {
  272.                 if (m_win32LangID == 0) {
  273.                     m_win32LangID = CultureTableRecord.IdFromEverettDataItem(m_nDataItem);
  274.                 }
  275.                
  276.                 if (customCultureName != null) {
  277.                     m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(customCultureName, m_useUserOverride);
  278.                 }
  279.                 else {
  280.                     m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(m_win32LangID, m_useUserOverride);
  281.                 }
  282.                
  283.                 m_textInfoID = m_cultureTableRecord.ITEXTINFO;
  284.                
  285.                 if (m_cultureTableRecord.IsSynthetic) {
  286.                     // <SyntheticSupport/>
  287.                     m_pNativeTextInfo = InvariantNativeTextInfo;
  288.                 }
  289.                 else {
  290.                     m_pNativeTextInfo = GetNativeTextInfo(m_textInfoID);
  291.                 }
  292.             }
  293.         }
  294.        
  295.        
  296.         [OnDeserialized()]
  297.         private void OnDeserialized(StreamingContext ctx)
  298.         {
  299.             OnDeserialized();
  300.         }
  301.        
  302.         [OnSerializing()]
  303.         private void OnSerializing(StreamingContext ctx)
  304.         {
  305.             m_nDataItem = m_cultureTableRecord.EverettDataItem();
  306.             m_useUserOverride = m_cultureTableRecord.UseUserOverride;
  307.            
  308.             if (CultureTableRecord.IsCustomCultureId(m_cultureTableRecord.CultureID)) {
  309.                 customCultureName = m_cultureTableRecord.SNAME;
  310.                 m_win32LangID = m_textInfoID;
  311.             }
  312.             else {
  313.                 customCultureName = null;
  314.                 m_win32LangID = m_cultureTableRecord.CultureID;
  315.             }
  316.            
  317.         }
  318.        
  319.         #endregion Serialization
  320.        
  321.        
  322.         unsafe static internal void* GetNativeTextInfo(int cultureID)
  323.         {
  324.         }
  325.        
  326.        
  327.         // First, assume this culture does not has exceptions. I.e. we should use the default casingg table.
  328.         // So we assign the native NativeTextInfo for the default casing table to it.
  329.         void* pNativeTextInfo = m_pDefaultCasingTable;
  330.     }
  331. }
  333. // Now, go thru the exception table to see if it has exception or not.

Developer Fusion