netcore/System.Private.CoreLib/shared/System/Marvin.OrdinalIgnoreCase.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 using System.Text.Unicode;
   9 using Internal.Runtime.CompilerServices;
  10
  11 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
  12 #if BIT64
  13 using nuint = System.UInt64;
  14 #else
  15 using nuint = System.UInt32;
  16 #endif
  17
  18 namespace System
  19 {
  20     internal static partial class Marvin
  21     {
  22         /// <summary>
  23         /// Compute a Marvin OrdinalIgnoreCase hash and collapse it into a 32-bit hash.
  24         /// n.b. <paramref name="count"/> is specified as char count, not byte count.
  25         /// </summary>
  26         public static int ComputeHash32OrdinalIgnoreCase(ref char data, int count, uint p0, uint p1)
  27         {
  28             uint ucount = (uint)count; // in chars
  29             nuint byteOffset = 0; // in bytes
  30             uint tempValue;
  31
  32             // We operate on 32-bit integers (two chars) at a time.
  33
  34             while (ucount >= 2)
  35             {
  36                 tempValue = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref data, byteOffset)));
  37                 if (!Utf16Utility.AllCharsInUInt32AreAscii(tempValue))
  38                 {
  39                     goto NotAscii;
  40                 }
  41                 p0 += Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(tempValue);
  42                 Block(ref p0, ref p1);
  43
  44                 byteOffset += 4;
  45                 ucount -= 2;
  46             }
  47
  48             // We have either one char (16 bits) or zero chars left over.
  49             Debug.Assert(ucount < 2);
  50
  51             if (ucount > 0)
  52             {
  53                 tempValue = Unsafe.AddByteOffset(ref data, byteOffset);
  54                 if (tempValue > 0x7Fu)
  55                 {
  56                     goto NotAscii;
  57                 }
  58
  59                 // addition is written with -0x80u to allow fall-through to next statement rather than jmp past it
  60                 p0 += Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(tempValue) + (0x800000u - 0x80u);
  61             }
  62             p0 += 0x80u;
  63
  64             Block(ref p0, ref p1);
  65             Block(ref p0, ref p1);
  66
  67             return (int)(p1 ^ p0);
  68
  69         NotAscii:
  70             Debug.Assert(0 <= ucount && ucount <= Int32.MaxValue); // this should fit into a signed int
  71             return ComputeHash32OrdinalIgnoreCaseSlow(ref Unsafe.AddByteOffset(ref data, byteOffset), (int)ucount, p0, p1);
  72         }
  73
  74         private static int ComputeHash32OrdinalIgnoreCaseSlow(ref char data, int count, uint p0, uint p1)
  75         {
  76             Debug.Assert(count > 0);
  77
  78             char[]? borrowedArr = null;
  79             Span<char> scratch = (uint)count <= 64 ? stackalloc char[64] : (borrowedArr = ArrayPool<char>.Shared.Rent(count));
  80
  81             int charsWritten = new ReadOnlySpan<char>(ref data, count).ToUpperInvariant(scratch);
  82             Debug.Assert(charsWritten == count); // invariant case conversion should involve simple folding; preserve code unit count
  83
  84             // Slice the array to the size returned by ToUpperInvariant.
  85             // Multiplication below will not overflow since going from positive Int32 to UInt32.
  86             int hash = ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(scratch)), (uint)charsWritten * 2, p0, p1);
  87
  88             // Return the borrowed array if necessary.
  89             if (borrowedArr != null)
  90             {
  91                 ArrayPool<char>.Shared.Return(borrowedArr);
  92             }
  93
  94             return hash;
  95         }
  96     }
  97 }