netcore/System.Private.CoreLib/shared/System/Globalization/CompareInfo.Windows.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Buffers;
   6 using System.Diagnostics;
   7 using System.Runtime.InteropServices;
   8
   9 using Internal.Runtime.CompilerServices;
  10
  11 namespace System.Globalization
  12 {
  13     public partial class CompareInfo
  14     {
  15         private unsafe void InitSort(CultureInfo culture)
  16         {
  17             _sortName = culture.SortName;
  18
  19             if (GlobalizationMode.Invariant)
  20             {
  21                 _sortHandle = IntPtr.Zero;
  22             }
  23             else
  24             {
  25                 const uint LCMAP_SORTHANDLE = 0x20000000;
  26
  27                 IntPtr handle;
  28                 int ret = Interop.Kernel32.LCMapStringEx(_sortName, LCMAP_SORTHANDLE, null, 0, &handle, IntPtr.Size, null, null, IntPtr.Zero);
  29                 _sortHandle = ret > 0 ? handle : IntPtr.Zero;
  30             }
  31         }
  32
  33         private static unsafe int FindStringOrdinal(
  34             uint dwFindStringOrdinalFlags,
  35             string stringSource,
  36             int offset,
  37             int cchSource,
  38             string value,
  39             int cchValue,
  40             bool bIgnoreCase)
  41         {
  42             Debug.Assert(!GlobalizationMode.Invariant);
  43             Debug.Assert(stringSource != null);
  44             Debug.Assert(value != null);
  45
  46             fixed (char* pSource = stringSource)
  47             fixed (char* pValue = value)
  48             {
  49                 int ret = Interop.Kernel32.FindStringOrdinal(
  50                             dwFindStringOrdinalFlags,
  51                             pSource + offset,
  52                             cchSource,
  53                             pValue,
  54                             cchValue,
  55                             bIgnoreCase ? 1 : 0);
  56                 return ret < 0 ? ret : ret + offset;
  57             }
  58         }
  59
  60         private static unsafe int FindStringOrdinal(
  61             uint dwFindStringOrdinalFlags,
  62             ReadOnlySpan<char> source,
  63             ReadOnlySpan<char> value,
  64             bool bIgnoreCase)
  65         {
  66             Debug.Assert(!GlobalizationMode.Invariant);
  67             Debug.Assert(!source.IsEmpty);
  68             Debug.Assert(!value.IsEmpty);
  69
  70             fixed (char* pSource = &MemoryMarshal.GetReference(source))
  71             fixed (char* pValue = &MemoryMarshal.GetReference(value))
  72             {
  73                 int ret = Interop.Kernel32.FindStringOrdinal(
  74                             dwFindStringOrdinalFlags,
  75                             pSource,
  76                             source.Length,
  77                             pValue,
  78                             value.Length,
  79                             bIgnoreCase ? 1 : 0);
  80                 return ret;
  81             }
  82         }
  83
  84         internal static int IndexOfOrdinalCore(string source, string value, int startIndex, int count, bool ignoreCase)
  85         {
  86             Debug.Assert(!GlobalizationMode.Invariant);
  87
  88             Debug.Assert(source != null);
  89             Debug.Assert(value != null);
  90
  91             return FindStringOrdinal(FIND_FROMSTART, source, startIndex, count, value, value.Length, ignoreCase);
  92         }
  93
  94         internal static int IndexOfOrdinalCore(ReadOnlySpan<char> source, ReadOnlySpan<char> value, bool ignoreCase, bool fromBeginning)
  95         {
  96             Debug.Assert(!GlobalizationMode.Invariant);
  97
  98             Debug.Assert(source.Length != 0);
  99             Debug.Assert(value.Length != 0);
 100
 101             uint positionFlag = fromBeginning ? (uint)FIND_FROMSTART : FIND_FROMEND;
 102             return FindStringOrdinal(positionFlag, source, value, ignoreCase);
 103         }
 104
 105         internal static int LastIndexOfOrdinalCore(string source, string value, int startIndex, int count, bool ignoreCase)
 106         {
 107             Debug.Assert(!GlobalizationMode.Invariant);
 108
 109             Debug.Assert(source != null);
 110             Debug.Assert(value != null);
 111
 112             return FindStringOrdinal(FIND_FROMEND, source, startIndex - count + 1, count, value, value.Length, ignoreCase);
 113         }
 114
 115         private unsafe int GetHashCodeOfStringCore(ReadOnlySpan<char> source, CompareOptions options)
 116         {
 117             Debug.Assert(!GlobalizationMode.Invariant);
 118             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 119
 120             if (source.Length == 0)
 121             {
 122                 return 0;
 123             }
 124
 125             uint flags = LCMAP_SORTKEY | (uint)GetNativeCompareFlags(options);
 126
 127             fixed (char* pSource = source)
 128             {
 129                 int sortKeyLength = Interop.Kernel32.LCMapStringEx(_sortHandle != IntPtr.Zero ? null : _sortName,
 130                                                   flags,
 131                                                   pSource, source.Length /* in chars */,
 132                                                   null, 0,
 133                                                   null, null, _sortHandle);
 134                 if (sortKeyLength == 0)
 135                 {
 136                     throw new ArgumentException(SR.Arg_ExternalException);
 137                 }
 138
 139                 // Note in calls to LCMapStringEx below, the input buffer is specified in wchars (and wchar count),
 140                 // but the output buffer is specified in bytes (and byte count). This is because when generating
 141                 // sort keys, LCMapStringEx treats the output buffer as containing opaque binary data.
 142                 // See https://docs.microsoft.com/en-us/windows/desktop/api/winnls/nf-winnls-lcmapstringex.
 143
 144                 byte[]? borrowedArr = null;
 145                 Span<byte> span = sortKeyLength <= 512 ?
 146                     stackalloc byte[512] :
 147                     (borrowedArr = ArrayPool<byte>.Shared.Rent(sortKeyLength));
 148
 149                 fixed (byte* pSortKey = &MemoryMarshal.GetReference(span))
 150                 {
 151                     if (Interop.Kernel32.LCMapStringEx(_sortHandle != IntPtr.Zero ? null : _sortName,
 152                                                       flags,
 153                                                       pSource, source.Length /* in chars */,
 154                                                       pSortKey, sortKeyLength,
 155                                                       null, null, _sortHandle) != sortKeyLength)
 156                     {
 157                         throw new ArgumentException(SR.Arg_ExternalException);
 158                     }
 159                 }
 160
 161                 int hash = Marvin.ComputeHash32(span.Slice(0, sortKeyLength), Marvin.DefaultSeed);
 162
 163                 // Return the borrowed array if necessary.
 164                 if (borrowedArr != null)
 165                 {
 166                     ArrayPool<byte>.Shared.Return(borrowedArr);
 167                 }
 168
 169                 return hash;
 170             }
 171         }
 172
 173         private static unsafe int CompareStringOrdinalIgnoreCase(ref char string1, int count1, ref char string2, int count2)
 174         {
 175             Debug.Assert(!GlobalizationMode.Invariant);
 176
 177             fixed (char* char1 = &string1)
 178             fixed (char* char2 = &string2)
 179             {
 180                 // Use the OS to compare and then convert the result to expected value by subtracting 2
 181                 return Interop.Kernel32.CompareStringOrdinal(char1, count1, char2, count2, true) - 2;
 182             }
 183         }
 184
 185         // TODO https://github.com/dotnet/coreclr/issues/13827:
 186         // This method shouldn't be necessary, as we should be able to just use the overload
 187         // that takes two spans.  But due to this issue, that's adding significant overhead.
 188         private unsafe int CompareString(ReadOnlySpan<char> string1, string string2, CompareOptions options)
 189         {
 190             Debug.Assert(string2 != null);
 191             Debug.Assert(!GlobalizationMode.Invariant);
 192             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 193
 194             string? localeName = _sortHandle != IntPtr.Zero ? null : _sortName;
 195
 196             fixed (char* pLocaleName = localeName)
 197             fixed (char* pString1 = &MemoryMarshal.GetReference(string1))
 198             fixed (char* pString2 = &string2.GetRawStringData())
 199             {
 200                 Debug.Assert(pString1 != null);
 201                 int result = Interop.Kernel32.CompareStringEx(
 202                                     pLocaleName,
 203                                     (uint)GetNativeCompareFlags(options),
 204                                     pString1,
 205                                     string1.Length,
 206                                     pString2,
 207                                     string2.Length,
 208                                     null,
 209                                     null,
 210                                     _sortHandle);
 211
 212                 if (result == 0)
 213                 {
 214                     throw new ArgumentException(SR.Arg_ExternalException);
 215                 }
 216
 217                 // Map CompareStringEx return value to -1, 0, 1.
 218                 return result - 2;
 219             }
 220         }
 221
 222         private unsafe int CompareString(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
 223         {
 224             Debug.Assert(!GlobalizationMode.Invariant);
 225             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 226
 227             string? localeName = _sortHandle != IntPtr.Zero ? null : _sortName;
 228
 229             fixed (char* pLocaleName = localeName)
 230             fixed (char* pString1 = &MemoryMarshal.GetReference(string1))
 231             fixed (char* pString2 = &MemoryMarshal.GetReference(string2))
 232             {
 233                 Debug.Assert(pString1 != null);
 234                 Debug.Assert(pString2 != null);
 235                 int result = Interop.Kernel32.CompareStringEx(
 236                                     pLocaleName,
 237                                     (uint)GetNativeCompareFlags(options),
 238                                     pString1,
 239                                     string1.Length,
 240                                     pString2,
 241                                     string2.Length,
 242                                     null,
 243                                     null,
 244                                     _sortHandle);
 245
 246                 if (result == 0)
 247                 {
 248                     throw new ArgumentException(SR.Arg_ExternalException);
 249                 }
 250
 251                 // Map CompareStringEx return value to -1, 0, 1.
 252                 return result - 2;
 253             }
 254         }
 255
 256         private unsafe int FindString(
 257                     uint dwFindNLSStringFlags,
 258                     ReadOnlySpan<char> lpStringSource,
 259                     ReadOnlySpan<char> lpStringValue,
 260                     int* pcchFound)
 261         {
 262             Debug.Assert(!GlobalizationMode.Invariant);
 263             Debug.Assert(!lpStringSource.IsEmpty);
 264             Debug.Assert(!lpStringValue.IsEmpty);
 265
 266             string? localeName = _sortHandle != IntPtr.Zero ? null : _sortName;
 267
 268             fixed (char* pLocaleName = localeName)
 269             fixed (char* pSource = &MemoryMarshal.GetReference(lpStringSource))
 270             fixed (char* pValue = &MemoryMarshal.GetReference(lpStringValue))
 271             {
 272                 return Interop.Kernel32.FindNLSStringEx(
 273                                     pLocaleName,
 274                                     dwFindNLSStringFlags,
 275                                     pSource,
 276                                     lpStringSource.Length,
 277                                     pValue,
 278                                     lpStringValue.Length,
 279                                     pcchFound,
 280                                     null,
 281                                     null,
 282                                     _sortHandle);
 283             }
 284         }
 285
 286         private unsafe int FindString(
 287             uint dwFindNLSStringFlags,
 288             string lpStringSource,
 289             int startSource,
 290             int cchSource,
 291             string lpStringValue,
 292             int startValue,
 293             int cchValue,
 294             int* pcchFound)
 295         {
 296             Debug.Assert(!GlobalizationMode.Invariant);
 297             Debug.Assert(lpStringSource != null);
 298             Debug.Assert(lpStringValue != null);
 299
 300             string? localeName = _sortHandle != IntPtr.Zero ? null : _sortName;
 301
 302             fixed (char* pLocaleName = localeName)
 303             fixed (char* pSource = lpStringSource)
 304             fixed (char* pValue = lpStringValue)
 305             {
 306                 char* pS = pSource + startSource;
 307                 char* pV = pValue + startValue;
 308
 309                 return Interop.Kernel32.FindNLSStringEx(
 310                                     pLocaleName,
 311                                     dwFindNLSStringFlags,
 312                                     pS,
 313                                     cchSource,
 314                                     pV,
 315                                     cchValue,
 316                                     pcchFound,
 317                                     null,
 318                                     null,
 319                                     _sortHandle);
 320             }
 321         }
 322
 323         internal unsafe int IndexOfCore(string source, string target, int startIndex, int count, CompareOptions options, int* matchLengthPtr)
 324         {
 325             Debug.Assert(!GlobalizationMode.Invariant);
 326
 327             Debug.Assert(source != null);
 328             Debug.Assert(target != null);
 329             Debug.Assert((options & CompareOptions.OrdinalIgnoreCase) == 0);
 330             Debug.Assert((options & CompareOptions.Ordinal) == 0);
 331
 332             int retValue = FindString(FIND_FROMSTART | (uint)GetNativeCompareFlags(options), source, startIndex, count,
 333                                                             target, 0, target.Length, matchLengthPtr);
 334             if (retValue >= 0)
 335             {
 336                 return retValue + startIndex;
 337             }
 338
 339             return -1;
 340         }
 341
 342         internal unsafe int IndexOfCore(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
 343         {
 344             Debug.Assert(!GlobalizationMode.Invariant);
 345
 346             Debug.Assert(source.Length != 0);
 347             Debug.Assert(target.Length != 0);
 348             Debug.Assert((options == CompareOptions.None || options == CompareOptions.IgnoreCase));
 349
 350             uint positionFlag = fromBeginning ? (uint)FIND_FROMSTART : FIND_FROMEND;
 351             return FindString(positionFlag | (uint)GetNativeCompareFlags(options), source, target, matchLengthPtr);
 352         }
 353
 354         private unsafe int LastIndexOfCore(string source, string target, int startIndex, int count, CompareOptions options)
 355         {
 356             Debug.Assert(!GlobalizationMode.Invariant);
 357
 358             Debug.Assert(!string.IsNullOrEmpty(source));
 359             Debug.Assert(target != null);
 360             Debug.Assert((options & CompareOptions.OrdinalIgnoreCase) == 0);
 361
 362             if (target.Length == 0)
 363                 return startIndex;
 364
 365             if ((options & CompareOptions.Ordinal) != 0)
 366             {
 367                 return FastLastIndexOfString(source, target, startIndex, count, target.Length);
 368             }
 369             else
 370             {
 371                 int retValue = FindString(FIND_FROMEND | (uint)GetNativeCompareFlags(options), source, startIndex - count + 1,
 372                                                                count, target, 0, target.Length, null);
 373
 374                 if (retValue >= 0)
 375                 {
 376                     return retValue + startIndex - (count - 1);
 377                 }
 378             }
 379
 380             return -1;
 381         }
 382
 383         private unsafe bool StartsWith(string source, string prefix, CompareOptions options)
 384         {
 385             Debug.Assert(!GlobalizationMode.Invariant);
 386
 387             Debug.Assert(!string.IsNullOrEmpty(source));
 388             Debug.Assert(!string.IsNullOrEmpty(prefix));
 389             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 390
 391             return FindString(FIND_STARTSWITH | (uint)GetNativeCompareFlags(options), source, 0, source.Length,
 392                                                    prefix, 0, prefix.Length, null) >= 0;
 393         }
 394
 395         private unsafe bool StartsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options)
 396         {
 397             Debug.Assert(!GlobalizationMode.Invariant);
 398
 399             Debug.Assert(!source.IsEmpty);
 400             Debug.Assert(!prefix.IsEmpty);
 401             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 402
 403             return FindString(FIND_STARTSWITH | (uint)GetNativeCompareFlags(options), source, prefix, null) >= 0;
 404         }
 405
 406         private unsafe bool EndsWith(string source, string suffix, CompareOptions options)
 407         {
 408             Debug.Assert(!GlobalizationMode.Invariant);
 409
 410             Debug.Assert(!string.IsNullOrEmpty(source));
 411             Debug.Assert(!string.IsNullOrEmpty(suffix));
 412             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 413
 414             return FindString(FIND_ENDSWITH | (uint)GetNativeCompareFlags(options), source, 0, source.Length,
 415                                                    suffix, 0, suffix.Length, null) >= 0;
 416         }
 417
 418         private unsafe bool EndsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options)
 419         {
 420             Debug.Assert(!GlobalizationMode.Invariant);
 421
 422             Debug.Assert(!source.IsEmpty);
 423             Debug.Assert(!suffix.IsEmpty);
 424             Debug.Assert((options & (CompareOptions.Ordinal | CompareOptions.OrdinalIgnoreCase)) == 0);
 425
 426             return FindString(FIND_ENDSWITH | (uint)GetNativeCompareFlags(options), source, suffix, null) >= 0;
 427         }
 428
 429         // PAL ends here
 430         private const uint LCMAP_SORTKEY = 0x00000400;
 431         private const uint LCMAP_HASH    = 0x00040000;
 432
 433         private const int FIND_STARTSWITH = 0x00100000;
 434         private const int FIND_ENDSWITH = 0x00200000;
 435         private const int FIND_FROMSTART = 0x00400000;
 436         private const int FIND_FROMEND = 0x00800000;
 437
 438         // TODO: Instead of this method could we just have upstack code call LastIndexOfOrdinal with ignoreCase = false?
 439         private static unsafe int FastLastIndexOfString(string source, string target, int startIndex, int sourceCount, int targetCount)
 440         {
 441             int retValue = -1;
 442
 443             int sourceStartIndex = startIndex - sourceCount + 1;
 444
 445             fixed (char* pSource = source, spTarget = target)
 446             {
 447                 char* spSubSource = pSource + sourceStartIndex;
 448
 449                 int endPattern = sourceCount - targetCount;
 450                 if (endPattern < 0)
 451                     return -1;
 452
 453                 Debug.Assert(target.Length >= 1);
 454                 char patternChar0 = spTarget[0];
 455                 for (int ctrSrc = endPattern; ctrSrc >= 0; ctrSrc--)
 456                 {
 457                     if (spSubSource[ctrSrc] != patternChar0)
 458                         continue;
 459
 460                     int ctrPat;
 461                     for (ctrPat = 1; ctrPat < targetCount; ctrPat++)
 462                     {
 463                         if (spSubSource[ctrSrc + ctrPat] != spTarget[ctrPat])
 464                             break;
 465                     }
 466                     if (ctrPat == targetCount)
 467                     {
 468                         retValue = ctrSrc;
 469                         break;
 470                     }
 471                 }
 472
 473                 if (retValue >= 0)
 474                 {
 475                     retValue += startIndex - sourceCount + 1;
 476                 }
 477             }
 478
 479             return retValue;
 480         }
 481
 482         private unsafe SortKey CreateSortKey(string source, CompareOptions options)
 483         {
 484             Debug.Assert(!GlobalizationMode.Invariant);
 485
 486             if (source == null) { throw new ArgumentNullException(nameof(source)); }
 487
 488             if ((options & ValidSortkeyCtorMaskOffFlags) != 0)
 489             {
 490                 throw new ArgumentException(SR.Argument_InvalidFlag, nameof(options));
 491             }
 492
 493             byte [] keyData;
 494             if (source.Length == 0)
 495             {
 496                 keyData = Array.Empty<byte>();
 497             }
 498             else
 499             {
 500                 uint flags = LCMAP_SORTKEY | (uint)GetNativeCompareFlags(options);
 501
 502                 fixed (char *pSource = source)
 503                 {
 504                     int sortKeyLength = Interop.Kernel32.LCMapStringEx(_sortHandle != IntPtr.Zero ? null : _sortName,
 505                                                 flags,
 506                                                 pSource, source.Length,
 507                                                 null, 0,
 508                                                 null, null, _sortHandle);
 509                     if (sortKeyLength == 0)
 510                     {
 511                         throw new ArgumentException(SR.Arg_ExternalException);
 512                     }
 513
 514                     keyData = new byte[sortKeyLength];
 515
 516                     fixed (byte* pBytes =  keyData)
 517                     {
 518                         if (Interop.Kernel32.LCMapStringEx(_sortHandle != IntPtr.Zero ? null : _sortName,
 519                                                 flags,
 520                                                 pSource, source.Length,
 521                                                 pBytes, keyData.Length,
 522                                                 null, null, _sortHandle) != sortKeyLength)
 523                         {
 524                             throw new ArgumentException(SR.Arg_ExternalException);
 525                         }
 526                     }
 527                 }
 528             }
 529
 530             return new SortKey(Name, source, options, keyData);
 531         }
 532
 533         private static unsafe bool IsSortable(char* text, int length)
 534         {
 535             Debug.Assert(!GlobalizationMode.Invariant);
 536             Debug.Assert(text != null);
 537
 538             return Interop.Kernel32.IsNLSDefinedString(Interop.Kernel32.COMPARE_STRING, 0, IntPtr.Zero, text, length);
 539         }
 540
 541         private const int COMPARE_OPTIONS_ORDINAL = 0x40000000;       // Ordinal
 542         private const int NORM_IGNORECASE = 0x00000001;       // Ignores case.  (use LINGUISTIC_IGNORECASE instead)
 543         private const int NORM_IGNOREKANATYPE = 0x00010000;       // Does not differentiate between Hiragana and Katakana characters. Corresponding Hiragana and Katakana will compare as equal.
 544         private const int NORM_IGNORENONSPACE = 0x00000002;       // Ignores nonspacing. This flag also removes Japanese accent characters.  (use LINGUISTIC_IGNOREDIACRITIC instead)
 545         private const int NORM_IGNORESYMBOLS = 0x00000004;       // Ignores symbols.
 546         private const int NORM_IGNOREWIDTH = 0x00020000;       // Does not differentiate between a single-byte character and the same character as a double-byte character.
 547         private const int NORM_LINGUISTIC_CASING = 0x08000000;       // use linguistic rules for casing
 548         private const int SORT_STRINGSORT = 0x00001000;       // Treats punctuation the same as symbols.
 549
 550         private static int GetNativeCompareFlags(CompareOptions options)
 551         {
 552             // Use "linguistic casing" by default (load the culture's casing exception tables)
 553             int nativeCompareFlags = NORM_LINGUISTIC_CASING;
 554
 555             if ((options & CompareOptions.IgnoreCase) != 0) { nativeCompareFlags |= NORM_IGNORECASE; }
 556             if ((options & CompareOptions.IgnoreKanaType) != 0) { nativeCompareFlags |= NORM_IGNOREKANATYPE; }
 557             if ((options & CompareOptions.IgnoreNonSpace) != 0) { nativeCompareFlags |= NORM_IGNORENONSPACE; }
 558             if ((options & CompareOptions.IgnoreSymbols) != 0) { nativeCompareFlags |= NORM_IGNORESYMBOLS; }
 559             if ((options & CompareOptions.IgnoreWidth) != 0) { nativeCompareFlags |= NORM_IGNOREWIDTH; }
 560             if ((options & CompareOptions.StringSort) != 0) { nativeCompareFlags |= SORT_STRINGSORT; }
 561
 562             // TODO: Can we try for GetNativeCompareFlags to never
 563             // take Ordinal or OrdinalIgnoreCase.  This value is not part of Win32, we just handle it special
 564             // in some places.
 565             // Suffix & Prefix shouldn't use this, make sure to turn off the NORM_LINGUISTIC_CASING flag
 566             if (options == CompareOptions.Ordinal) { nativeCompareFlags = COMPARE_OPTIONS_ORDINAL; }
 567
 568             Debug.Assert(((options & ~(CompareOptions.IgnoreCase |
 569                                           CompareOptions.IgnoreKanaType |
 570                                           CompareOptions.IgnoreNonSpace |
 571                                           CompareOptions.IgnoreSymbols |
 572                                           CompareOptions.IgnoreWidth |
 573                                           CompareOptions.StringSort)) == 0) ||
 574                              (options == CompareOptions.Ordinal), "[CompareInfo.GetNativeCompareFlags]Expected all flags to be handled");
 575
 576             return nativeCompareFlags;
 577         }
 578
 579         private unsafe SortVersion GetSortVersion()
 580         {
 581             Debug.Assert(!GlobalizationMode.Invariant);
 582
 583             Interop.Kernel32.NlsVersionInfoEx nlsVersion = new Interop.Kernel32.NlsVersionInfoEx();
 584             nlsVersion.dwNLSVersionInfoSize = sizeof(Interop.Kernel32.NlsVersionInfoEx);
 585             Interop.Kernel32.GetNLSVersionEx(Interop.Kernel32.COMPARE_STRING, _sortName, &nlsVersion);
 586             return new SortVersion(
 587                         nlsVersion.dwNLSVersion,
 588                         nlsVersion.dwEffectiveId == 0 ? LCID : nlsVersion.dwEffectiveId,
 589                         nlsVersion.guidCustomVersion);
 590         }
 591     }
 592 }