netcore/System.Private.CoreLib/shared/System/Text/ASCIIEncoding.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.CompilerServices;
   8 using System.Runtime.InteropServices;
   9
  10 namespace System.Text
  11 {
  12     // ASCIIEncoding
  13     //
  14     // Note that ASCIIEncoding is optimized with no best fit and ? for fallback.
  15     // It doesn't come in other flavors.
  16     //
  17     // Note: ASCIIEncoding is the only encoding that doesn't do best fit (windows has best fit).
  18     //
  19     // Note: IsAlwaysNormalized remains false because 1/2 the code points are unassigned, so they'd
  20     //       use fallbacks, and we cannot guarantee that fallbacks are normalized.
  21
  22     public partial class ASCIIEncoding : Encoding
  23     {
  24         // This specialized sealed type has two benefits:
  25         // 1) it allows for devirtualization (see https://github.com/dotnet/coreclr/pull/9230), and
  26         // 2) it allows us to provide highly optimized implementations of certain routines because
  27         //    we can make assumptions about the fallback mechanisms in use (in particular, always
  28         //    replace with "?").
  29         //
  30         // (We don't take advantage of #2 yet, but we can do so in the future because the implementation
  31         // of cloning below allows us to make assumptions about the behaviors of the sealed type.)
  32         internal sealed class ASCIIEncodingSealed : ASCIIEncoding
  33         {
  34             public override object Clone()
  35             {
  36                 // The base implementation of Encoding.Clone calls object.MemberwiseClone and marks the new object mutable.
  37                 // We don't want to do this because it violates the invariants we have set for the sealed type.
  38                 // Instead, we'll create a new instance of the base ASCIIEncoding type and mark it mutable.
  39
  40                 return new ASCIIEncoding()
  41                 {
  42                     IsReadOnly = false
  43                 };
  44             }
  45         }
  46
  47         // Used by Encoding.ASCII for lazy initialization
  48         // The initialization code will not be run until a static member of the class is referenced
  49         internal static readonly ASCIIEncodingSealed s_default = new ASCIIEncodingSealed();
  50
  51         public ASCIIEncoding() : base(Encoding.CodePageASCII)
  52         {
  53         }
  54
  55         internal sealed override void SetDefaultFallbacks()
  56         {
  57             // For ASCIIEncoding we just use default replacement fallback
  58             this.encoderFallback = EncoderFallback.ReplacementFallback;
  59             this.decoderFallback = DecoderFallback.ReplacementFallback;
  60         }
  61
  62         // WARNING: GetByteCount(string chars), GetBytes(string chars,...), and GetString(byte[] byteIndex...)
  63         // WARNING: have different variable names than EncodingNLS.cs, so this can't just be cut & pasted,
  64         // WARNING: or it'll break VB's way of calling these.
  65         //
  66         // The following methods are copied from EncodingNLS.cs.
  67         // Unfortunately EncodingNLS.cs is internal and we're public, so we have to re-implement them here.
  68         // These should be kept in sync for the following classes:
  69         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
  70
  71         // Returns the number of bytes required to encode a range of characters in
  72         // a character array.
  73         //
  74         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
  75         // So if you fix this, fix the others.  Currently those include:
  76         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
  77         // parent method is safe
  78
  79         public override unsafe int GetByteCount(char[] chars, int index, int count)
  80         {
  81             // Validate input parameters
  82
  83             if (chars is null)
  84             {
  85                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
  86             }
  87
  88             if ((index | count) < 0)
  89             {
  90                 ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
  91             }
  92
  93             if (chars!.Length - index < count)
  94             {
  95                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
  96             }
  97
  98             fixed (char* pChars = chars)
  99             {
 100                 return GetByteCountCommon(pChars + index, count);
 101             }
 102         }
 103
 104         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 105         // So if you fix this, fix the others.  Currently those include:
 106         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 107         // parent method is safe
 108
 109         public override unsafe int GetByteCount(string chars)
 110         {
 111             // Validate input parameters
 112
 113             if (chars is null)
 114             {
 115                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
 116             }
 117
 118             fixed (char* pChars = chars)
 119             {
 120                 return GetByteCountCommon(pChars, chars!.Length);
 121             }
 122         }
 123
 124         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 125         // So if you fix this, fix the others.  Currently those include:
 126         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 127
 128         [CLSCompliant(false)]
 129         public override unsafe int GetByteCount(char* chars, int count)
 130         {
 131             // Validate Parameters
 132
 133             if (chars == null)
 134             {
 135                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
 136             }
 137
 138             if (count < 0)
 139             {
 140                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 141             }
 142
 143             return GetByteCountCommon(chars, count);
 144         }
 145
 146         public override unsafe int GetByteCount(ReadOnlySpan<char> chars)
 147         {
 148             // It's ok for us to pass null pointers down to the workhorse below.
 149
 150             fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))
 151             {
 152                 return GetByteCountCommon(charsPtr, chars.Length);
 153             }
 154         }
 155
 156         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 157         private unsafe int GetByteCountCommon(char* pChars, int charCount)
 158         {
 159             // Common helper method for all non-EncoderNLS entry points to GetByteCount.
 160             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 161
 162             Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
 163             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 164
 165             // First call into the fast path.
 166
 167             int totalByteCount = GetByteCountFast(pChars, charCount, EncoderFallback, out int charsConsumed);
 168
 169             if (charsConsumed != charCount)
 170             {
 171                 // If there's still data remaining in the source buffer, go down the fallback path.
 172                 // We need to check for integer overflow since the fallback could change the required
 173                 // output count in unexpected ways.
 174
 175                 totalByteCount += GetByteCountWithFallback(pChars, charCount, charsConsumed);
 176                 if (totalByteCount < 0)
 177                 {
 178                     ThrowConversionOverflow();
 179                 }
 180             }
 181
 182             return totalByteCount;
 183         }
 184
 185         [MethodImpl(MethodImplOptions.AggressiveInlining)] // called directly by GetByteCountCommon
 186         private protected sealed override unsafe int GetByteCountFast(char* pChars, int charsLength, EncoderFallback? fallback, out int charsConsumed)
 187         {
 188             // First: Can we short-circuit the entire calculation?
 189             // If an EncoderReplacementFallback is in use, all non-ASCII chars
 190             // (including surrogate halves) are replaced with the default string.
 191             // If the default string consists of a single ASCII value, then we
 192             // know there's a 1:1 char->byte transcoding in all cases.
 193
 194             int byteCount = charsLength;
 195
 196             if (!(fallback is EncoderReplacementFallback replacementFallback
 197                 && replacementFallback.MaxCharCount == 1
 198                 && replacementFallback.DefaultString[0] <= 0x7F))
 199             {
 200                 // Unrecognized fallback mechanism - count chars manually.
 201
 202                 byteCount = (int)ASCIIUtility.GetIndexOfFirstNonAsciiChar(pChars, (uint)charsLength);
 203             }
 204
 205             charsConsumed = byteCount;
 206             return byteCount;
 207         }
 208
 209         // Parent method is safe.
 210         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 211         // So if you fix this, fix the others.  Currently those include:
 212         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 213
 214         public override unsafe int GetBytes(string chars, int charIndex, int charCount,
 215                                               byte[] bytes, int byteIndex)
 216         {
 217             // Validate Parameters
 218
 219             if (chars is null || bytes is null)
 220             {
 221                 ThrowHelper.ThrowArgumentNullException(
 222                     argument: (chars is null) ? ExceptionArgument.chars : ExceptionArgument.bytes,
 223                     resource: ExceptionResource.ArgumentNull_Array);
 224             }
 225
 226             if ((charIndex | charCount) < 0)
 227             {
 228                 ThrowHelper.ThrowArgumentOutOfRangeException(
 229                     argument: (charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount,
 230                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 231             }
 232
 233             if (chars!.Length - charIndex < charCount)
 234             {
 235                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
 236             }
 237
 238             if ((uint)byteIndex > bytes!.Length)
 239             {
 240                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
 241             }
 242
 243             fixed (char* pChars = chars)
 244             fixed (byte* pBytes = bytes)
 245             {
 246                 return GetBytesCommon(pChars + charIndex, charCount, pBytes + byteIndex, bytes.Length - byteIndex);
 247             }
 248         }
 249
 250         // Encodes a range of characters in a character array into a range of bytes
 251         // in a byte array. An exception occurs if the byte array is not large
 252         // enough to hold the complete encoding of the characters. The
 253         // GetByteCount method can be used to determine the exact number of
 254         // bytes that will be produced for a given range of characters.
 255         // Alternatively, the GetMaxByteCount method can be used to
 256         // determine the maximum number of bytes that will be produced for a given
 257         // number of characters, regardless of the actual character values.
 258         //
 259         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 260         // So if you fix this, fix the others.  Currently those include:
 261         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 262         // parent method is safe
 263
 264         public override unsafe int GetBytes(char[] chars, int charIndex, int charCount,
 265                                                byte[] bytes, int byteIndex)
 266         {
 267             // Validate parameters
 268
 269             if (chars is null || bytes is null)
 270             {
 271                 ThrowHelper.ThrowArgumentNullException(
 272                     argument: (chars is null) ? ExceptionArgument.chars : ExceptionArgument.bytes,
 273                     resource: ExceptionResource.ArgumentNull_Array);
 274             }
 275
 276             if ((charIndex | charCount) < 0)
 277             {
 278                 ThrowHelper.ThrowArgumentOutOfRangeException(
 279                     argument: (charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount,
 280                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 281             }
 282
 283             if (chars!.Length - charIndex < charCount)
 284             {
 285                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
 286             }
 287
 288             if ((uint)byteIndex > bytes!.Length)
 289             {
 290                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
 291             }
 292
 293             fixed (char* pChars = chars)
 294             fixed (byte* pBytes = bytes)
 295             {
 296                 return GetBytesCommon(pChars + charIndex, charCount, pBytes + byteIndex, bytes.Length - byteIndex);
 297             }
 298         }
 299
 300         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 301         // So if you fix this, fix the others.  Currently those include:
 302         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 303
 304         [CLSCompliant(false)]
 305         public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
 306         {
 307             // Validate Parameters
 308
 309             if (chars == null || bytes == null)
 310             {
 311                 ThrowHelper.ThrowArgumentNullException(
 312                     argument: (chars is null) ? ExceptionArgument.chars : ExceptionArgument.bytes,
 313                     resource: ExceptionResource.ArgumentNull_Array);
 314             }
 315
 316             if ((charCount | byteCount) < 0)
 317             {
 318                 ThrowHelper.ThrowArgumentOutOfRangeException(
 319                     argument: (charCount < 0) ? ExceptionArgument.charCount : ExceptionArgument.byteCount,
 320                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 321             }
 322
 323             return GetBytesCommon(chars, charCount, bytes, byteCount);
 324         }
 325
 326         public override unsafe int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
 327         {
 328             // It's ok for us to operate on null / empty spans.
 329
 330             fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))
 331             fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes))
 332             {
 333                 return GetBytesCommon(charsPtr, chars.Length, bytesPtr, bytes.Length);
 334             }
 335         }
 336
 337         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 338         private unsafe int GetBytesCommon(char* pChars, int charCount, byte* pBytes, int byteCount)
 339         {
 340             // Common helper method for all non-EncoderNLS entry points to GetBytes.
 341             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 342
 343             Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
 344             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 345             Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
 346             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 347
 348             // First call into the fast path.
 349
 350             int bytesWritten = GetBytesFast(pChars, charCount, pBytes, byteCount, out int charsConsumed);
 351
 352             if (charsConsumed == charCount)
 353             {
 354                 // All elements converted - return immediately.
 355
 356                 return bytesWritten;
 357             }
 358             else
 359             {
 360                 // Simple narrowing conversion couldn't operate on entire buffer - invoke fallback.
 361
 362                 return GetBytesWithFallback(pChars, charCount, pBytes, byteCount, charsConsumed, bytesWritten);
 363             }
 364         }
 365
 366         [MethodImpl(MethodImplOptions.AggressiveInlining)] // called directly by GetBytesCommon
 367         private protected sealed override unsafe int GetBytesFast(char* pChars, int charsLength, byte* pBytes, int bytesLength, out int charsConsumed)
 368         {
 369             int bytesWritten = (int)ASCIIUtility.NarrowUtf16ToAscii(pChars, pBytes, (uint)Math.Min(charsLength, bytesLength));
 370
 371             charsConsumed = bytesWritten;
 372             return bytesWritten;
 373         }
 374
 375         private protected sealed override unsafe int GetBytesWithFallback(ReadOnlySpan<char> chars, int originalCharsLength, Span<byte> bytes, int originalBytesLength, EncoderNLS? encoder)
 376         {
 377             // We special-case EncoderReplacementFallback if it's telling us to write a single ASCII char,
 378             // since we believe this to be relatively common and we can handle it more efficiently than
 379             // the base implementation.
 380
 381             if (((encoder is null) ? this.EncoderFallback : encoder.Fallback) is EncoderReplacementFallback replacementFallback
 382                 && replacementFallback.MaxCharCount == 1
 383                 && replacementFallback.DefaultString[0] <= 0x7F)
 384             {
 385                 byte replacementByte = (byte)replacementFallback.DefaultString[0];
 386
 387                 int numElementsToConvert = Math.Min(chars.Length, bytes.Length);
 388                 int idx = 0;
 389
 390                 fixed (char* pChars = &MemoryMarshal.GetReference(chars))
 391                 fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
 392                 {
 393                     // In a loop, replace the non-convertible data, then bulk-convert as much as we can.
 394
 395                     while (idx < numElementsToConvert)
 396                     {
 397                         pBytes[idx++] = replacementByte;
 398
 399                         if (idx < numElementsToConvert)
 400                         {
 401                             idx += (int)ASCIIUtility.NarrowUtf16ToAscii(&pChars[idx], &pBytes[idx], (uint)(numElementsToConvert - idx));
 402                         }
 403
 404                         Debug.Assert(idx <= numElementsToConvert, "Somehow went beyond bounds of source or destination buffer?");
 405                     }
 406                 }
 407
 408                 // Slice off how much we consumed / wrote.
 409
 410                 chars = chars.Slice(numElementsToConvert);
 411                 bytes = bytes.Slice(numElementsToConvert);
 412             }
 413
 414             // If we couldn't go through our fast fallback mechanism, or if we still have leftover
 415             // data because we couldn't consume everything in the loop above, we need to go down the
 416             // slow fallback path.
 417
 418             if (chars.IsEmpty)
 419             {
 420                 return originalBytesLength - bytes.Length; // total number of bytes written
 421             }
 422             else
 423             {
 424                 return base.GetBytesWithFallback(chars, originalCharsLength, bytes, originalBytesLength, encoder);
 425             }
 426         }
 427
 428         // Returns the number of characters produced by decoding a range of bytes
 429         // in a byte array.
 430         //
 431         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 432         // So if you fix this, fix the others.  Currently those include:
 433         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 434         // parent method is safe
 435
 436         public override unsafe int GetCharCount(byte[] bytes, int index, int count)
 437         {
 438             // Validate Parameters
 439
 440             if (bytes is null)
 441             {
 442                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
 443             }
 444
 445             if ((index | count) < 0)
 446             {
 447                 ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 448             }
 449
 450             if (bytes!.Length - index < count)
 451             {
 452                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
 453             }
 454
 455             fixed (byte* pBytes = bytes)
 456             {
 457                 return GetCharCountCommon(pBytes + index, count);
 458             }
 459         }
 460
 461         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 462         // So if you fix this, fix the others.  Currently those include:
 463         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 464
 465         [CLSCompliant(false)]
 466         public override unsafe int GetCharCount(byte* bytes, int count)
 467         {
 468             // Validate Parameters
 469
 470             if (bytes == null)
 471             {
 472                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
 473             }
 474
 475             if (count < 0)
 476             {
 477                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 478             }
 479
 480             return GetCharCountCommon(bytes, count);
 481         }
 482
 483         public override unsafe int GetCharCount(ReadOnlySpan<byte> bytes)
 484         {
 485             // It's ok for us to pass null pointers down to the workhorse routine.
 486
 487             fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes))
 488             {
 489                 return GetCharCountCommon(bytesPtr, bytes.Length);
 490             }
 491         }
 492
 493         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 494         private unsafe int GetCharCountCommon(byte* pBytes, int byteCount)
 495         {
 496             // Common helper method for all non-DecoderNLS entry points to GetCharCount.
 497             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 498
 499             Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
 500             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 501
 502             // First call into the fast path.
 503
 504             int totalCharCount = GetCharCountFast(pBytes, byteCount, DecoderFallback, out int bytesConsumed);
 505
 506             if (bytesConsumed != byteCount)
 507             {
 508                 // If there's still data remaining in the source buffer, go down the fallback path.
 509                 // We need to check for integer overflow since the fallback could change the required
 510                 // output count in unexpected ways.
 511
 512                 totalCharCount += GetCharCountWithFallback(pBytes, byteCount, bytesConsumed);
 513                 if (totalCharCount < 0)
 514                 {
 515                     ThrowConversionOverflow();
 516                 }
 517             }
 518
 519             return totalCharCount;
 520         }
 521
 522         [MethodImpl(MethodImplOptions.AggressiveInlining)] // called directly by GetCharCountCommon
 523         private protected sealed override unsafe int GetCharCountFast(byte* pBytes, int bytesLength, DecoderFallback? fallback, out int bytesConsumed)
 524         {
 525             // First: Can we short-circuit the entire calculation?
 526             // If a DecoderReplacementFallback is in use, all non-ASCII bytes are replaced with
 527             // the default string. If the default string consists of a single BMP value, then we
 528             // know there's a 1:1 byte->char transcoding in all cases.
 529
 530             int charCount = bytesLength;
 531
 532             if (!(fallback is DecoderReplacementFallback replacementFallback) || replacementFallback.MaxCharCount != 1)
 533             {
 534                 // Unrecognized fallback mechanism - count bytes manually.
 535
 536                 charCount = (int)ASCIIUtility.GetIndexOfFirstNonAsciiByte(pBytes, (uint)bytesLength);
 537             }
 538
 539             bytesConsumed = charCount;
 540             return charCount;
 541         }
 542
 543         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 544         // So if you fix this, fix the others.  Currently those include:
 545         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 546         // parent method is safe
 547
 548         public override unsafe int GetChars(byte[] bytes, int byteIndex, int byteCount,
 549                                               char[] chars, int charIndex)
 550         {
 551             // Validate Parameters
 552
 553             if (bytes is null || chars is null)
 554             {
 555                 ThrowHelper.ThrowArgumentNullException(
 556                     argument: (bytes is null) ? ExceptionArgument.bytes : ExceptionArgument.chars,
 557                     resource: ExceptionResource.ArgumentNull_Array);
 558             }
 559
 560             if ((byteIndex | byteCount) < 0)
 561             {
 562                 ThrowHelper.ThrowArgumentOutOfRangeException(
 563                     argument: (byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount,
 564                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 565             }
 566
 567             if (bytes!.Length - byteIndex < byteCount)
 568             {
 569                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
 570             }
 571
 572             if ((uint)charIndex > (uint)chars!.Length)
 573             {
 574                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.charIndex, ExceptionResource.ArgumentOutOfRange_Index);
 575             }
 576
 577             fixed (byte* pBytes = bytes)
 578             fixed (char* pChars = chars)
 579             {
 580                 return GetCharsCommon(pBytes + byteIndex, byteCount, pChars + charIndex, chars.Length - charIndex);
 581             }
 582         }
 583
 584         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 585         // So if you fix this, fix the others.  Currently those include:
 586         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 587
 588         [CLSCompliant(false)]
 589         public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
 590         {
 591             // Validate Parameters
 592
 593             if (bytes is null || chars is null)
 594             {
 595                 ThrowHelper.ThrowArgumentNullException(
 596                     argument: (bytes is null) ? ExceptionArgument.bytes : ExceptionArgument.chars,
 597                     resource: ExceptionResource.ArgumentNull_Array);
 598             }
 599
 600             if ((byteCount | charCount) < 0)
 601             {
 602                 ThrowHelper.ThrowArgumentOutOfRangeException(
 603                     argument: (byteCount < 0) ? ExceptionArgument.byteCount : ExceptionArgument.charCount,
 604                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 605             }
 606
 607             return GetCharsCommon(bytes, byteCount, chars, charCount);
 608         }
 609
 610         public override unsafe int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars)
 611         {
 612             // It's ok for us to pass null pointers down to the workhorse below.
 613
 614             fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes))
 615             fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))
 616             {
 617                 return GetCharsCommon(bytesPtr, bytes.Length, charsPtr, chars.Length);
 618             }
 619         }
 620
 621         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 622         private unsafe int GetCharsCommon(byte* pBytes, int byteCount, char* pChars, int charCount)
 623         {
 624             // Common helper method for all non-DecoderNLS entry points to GetChars.
 625             // A modification of this method should be copied in to each of the supported encodings: ASCII, UTF8, UTF16, UTF32.
 626
 627             Debug.Assert(byteCount >= 0, "Caller shouldn't specify negative length buffer.");
 628             Debug.Assert(pBytes != null || byteCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 629             Debug.Assert(charCount >= 0, "Caller shouldn't specify negative length buffer.");
 630             Debug.Assert(pChars != null || charCount == 0, "Input pointer shouldn't be null if non-zero length specified.");
 631
 632             // First call into the fast path.
 633
 634             int charsWritten = GetCharsFast(pBytes, byteCount, pChars, charCount, out int bytesConsumed);
 635
 636             if (bytesConsumed == byteCount)
 637             {
 638                 // All elements converted - return immediately.
 639
 640                 return charsWritten;
 641             }
 642             else
 643             {
 644                 // Simple narrowing conversion couldn't operate on entire buffer - invoke fallback.
 645
 646                 return GetCharsWithFallback(pBytes, byteCount, pChars, charCount, bytesConsumed, charsWritten);
 647             }
 648         }
 649
 650         [MethodImpl(MethodImplOptions.AggressiveInlining)] // called directly by GetCharsCommon
 651         private protected sealed override unsafe int GetCharsFast(byte* pBytes, int bytesLength, char* pChars, int charsLength, out int bytesConsumed)
 652         {
 653             int charsWritten = (int)ASCIIUtility.WidenAsciiToUtf16(pBytes, pChars, (uint)Math.Min(bytesLength, charsLength));
 654
 655             bytesConsumed = charsWritten;
 656             return charsWritten;
 657         }
 658
 659         private protected sealed override unsafe int GetCharsWithFallback(ReadOnlySpan<byte> bytes, int originalBytesLength, Span<char> chars, int originalCharsLength, DecoderNLS? decoder)
 660         {
 661             // We special-case DecoderReplacementFallback if it's telling us to write a single BMP char,
 662             // since we believe this to be relatively common and we can handle it more efficiently than
 663             // the base implementation.
 664
 665             if (((decoder is null) ? this.DecoderFallback: decoder.Fallback) is DecoderReplacementFallback replacementFallback
 666                 && replacementFallback.MaxCharCount == 1)
 667             {
 668                 char replacementChar = replacementFallback.DefaultString[0];
 669
 670                 int numElementsToConvert = Math.Min(bytes.Length, chars.Length);
 671                 int idx = 0;
 672
 673                 fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
 674                 fixed (char* pChars = &MemoryMarshal.GetReference(chars))
 675                 {
 676                     // In a loop, replace the non-convertible data, then bulk-convert as much as we can.
 677
 678                     while (idx < numElementsToConvert)
 679                     {
 680                         pChars[idx++] = replacementChar;
 681
 682                         if (idx < numElementsToConvert)
 683                         {
 684                             idx += (int)ASCIIUtility.WidenAsciiToUtf16(&pBytes[idx], &pChars[idx], (uint)(numElementsToConvert - idx));
 685                         }
 686
 687                         Debug.Assert(idx <= numElementsToConvert, "Somehow went beyond bounds of source or destination buffer?");
 688                     }
 689                 }
 690
 691                 // Slice off how much we consumed / wrote.
 692
 693                 bytes = bytes.Slice(numElementsToConvert);
 694                 chars = chars.Slice(numElementsToConvert);
 695             }
 696
 697             // If we couldn't go through our fast fallback mechanism, or if we still have leftover
 698             // data because we couldn't consume everything in the loop above, we need to go down the
 699             // slow fallback path.
 700
 701             if (bytes.IsEmpty)
 702             {
 703                 return originalCharsLength - chars.Length; // total number of chars written
 704             }
 705             else
 706             {
 707                 return base.GetCharsWithFallback(bytes, originalBytesLength, chars, originalCharsLength, decoder);
 708             }
 709         }
 710
 711         // Returns a string containing the decoded representation of a range of
 712         // bytes in a byte array.
 713         //
 714         // All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
 715         // So if you fix this, fix the others.  Currently those include:
 716         // EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
 717         // parent method is safe
 718
 719         public override unsafe string GetString(byte[] bytes, int byteIndex, int byteCount)
 720         {
 721             // Validate Parameters
 722
 723             if (bytes is null)
 724             {
 725                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
 726             }
 727
 728             if ((byteIndex | byteCount) < 0)
 729             {
 730                 ThrowHelper.ThrowArgumentOutOfRangeException(
 731                     argument: (byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount,
 732                     resource: ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 733             }
 734
 735             if (bytes!.Length - byteIndex < byteCount)
 736             {
 737                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
 738             }
 739
 740             // Avoid problems with empty input buffer
 741             if (byteCount == 0)
 742                 return string.Empty;
 743
 744             fixed (byte* pBytes = bytes)
 745             {
 746                 return string.CreateStringFromEncoding(pBytes + byteIndex, byteCount, this);
 747             }
 748         }
 749
 750         //
 751         // End of standard methods copied from EncodingNLS.cs
 752         //
 753
 754         //
 755         // Beginning of methods used by shared fallback logic.
 756         //
 757
 758         internal sealed override bool TryGetByteCount(Rune value, out int byteCount)
 759         {
 760             if (value.IsAscii)
 761             {
 762                 byteCount = 1;
 763                 return true;
 764             }
 765             else
 766             {
 767                 byteCount = default;
 768                 return false;
 769             }
 770         }
 771
 772         internal sealed override OperationStatus EncodeRune(Rune value, Span<byte> bytes, out int bytesWritten)
 773         {
 774             if (value.IsAscii)
 775             {
 776                 if (!bytes.IsEmpty)
 777                 {
 778                     bytes[0] = (byte)value.Value;
 779                     bytesWritten = 1;
 780                     return OperationStatus.Done;
 781                 }
 782                 else
 783                 {
 784                     bytesWritten = 0;
 785                     return OperationStatus.DestinationTooSmall;
 786                 }
 787             }
 788             else
 789             {
 790                 bytesWritten = 0;
 791                 return OperationStatus.InvalidData;
 792             }
 793         }
 794
 795         internal sealed override OperationStatus DecodeFirstRune(ReadOnlySpan<byte> bytes, out Rune value, out int bytesConsumed)
 796         {
 797             if (!bytes.IsEmpty)
 798             {
 799                 byte b = bytes[0];
 800                 if (b <= 0x7F)
 801                 {
 802                     // ASCII byte
 803
 804                     value = new Rune(b);
 805                     bytesConsumed = 1;
 806                     return OperationStatus.Done;
 807                 }
 808                 else
 809                 {
 810                     // Non-ASCII byte
 811
 812                     value = Rune.ReplacementChar;
 813                     bytesConsumed = 1;
 814                     return OperationStatus.InvalidData;
 815                 }
 816             }
 817             else
 818             {
 819                 // No data to decode
 820
 821                 value = Rune.ReplacementChar;
 822                 bytesConsumed = 0;
 823                 return OperationStatus.NeedMoreData;
 824             }
 825         }
 826
 827         //
 828         // End of methods used by shared fallback logic.
 829         //
 830
 831         public override int GetMaxByteCount(int charCount)
 832         {
 833             if (charCount < 0)
 834                 throw new ArgumentOutOfRangeException(nameof(charCount),
 835                      SR.ArgumentOutOfRange_NeedNonNegNum);
 836
 837             // Characters would be # of characters + 1 in case high surrogate is ? * max fallback
 838             long byteCount = (long)charCount + 1;
 839
 840             if (EncoderFallback.MaxCharCount > 1)
 841                 byteCount *= EncoderFallback.MaxCharCount;
 842
 843             // 1 to 1 for most characters.  Only surrogates with fallbacks have less.
 844
 845             if (byteCount > 0x7fffffff)
 846                 throw new ArgumentOutOfRangeException(nameof(charCount), SR.ArgumentOutOfRange_GetByteCountOverflow);
 847             return (int)byteCount;
 848         }
 849
 850
 851         public override int GetMaxCharCount(int byteCount)
 852         {
 853             if (byteCount < 0)
 854                 throw new ArgumentOutOfRangeException(nameof(byteCount),
 855                      SR.ArgumentOutOfRange_NeedNonNegNum);
 856
 857             // Just return length, SBCS stay the same length because they don't map to surrogate
 858             long charCount = (long)byteCount;
 859
 860             // 1 to 1 for most characters.  Only surrogates with fallbacks have less, unknown fallbacks could be longer.
 861             if (DecoderFallback.MaxCharCount > 1)
 862                 charCount *= DecoderFallback.MaxCharCount;
 863
 864             if (charCount > 0x7fffffff)
 865                 throw new ArgumentOutOfRangeException(nameof(byteCount), SR.ArgumentOutOfRange_GetCharCountOverflow);
 866
 867             return (int)charCount;
 868         }
 869
 870         // True if and only if the encoding only uses single byte code points.  (Ie, ASCII, 1252, etc)
 871
 872         public override bool IsSingleByte => true;
 873
 874         public override Decoder GetDecoder() => new DecoderNLS(this);
 875
 876
 877         public override Encoder GetEncoder() => new EncoderNLS(this);
 878     }
 879 }