Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches

◆ TranscodeToUtf16()

static unsafe OperationStatus System.Text.Unicode.Utf8Utility.TranscodeToUtf16 ( byte * pInputBuffer,
int inputLength,
char * pOutputBuffer,
int outputCharsRemaining,
out byte * pInputBufferRemaining,
out char * pOutputBufferRemaining )
inlinestatic

Definition at line 387 of file Utf8Utility.cs.

388 {
389 nuint num = ASCIIUtility.WidenAsciiToUtf16(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputCharsRemaining));
390 pInputBuffer += num;
391 pOutputBuffer += num;
392 if ((int)num == inputLength)
393 {
394 pInputBufferRemaining = pInputBuffer;
395 pOutputBufferRemaining = pOutputBuffer;
396 return OperationStatus.Done;
397 }
398 inputLength -= (int)num;
399 outputCharsRemaining -= (int)num;
400 if (inputLength < 4)
401 {
402 goto IL_0690;
403 }
404 byte* ptr = pInputBuffer + (uint)inputLength - 4;
405 while (true)
406 {
407 IL_004a:
408 uint num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
409 while (true)
410 {
411 IL_0051:
412 if (!ASCIIUtility.AllBytesInUInt32AreAscii(num2))
413 {
414 goto IL_0120;
415 }
416 int num4;
417 uint num5;
418 if (outputCharsRemaining >= 4)
419 {
420 ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
421 pInputBuffer += 4;
422 pOutputBuffer += 4;
423 outputCharsRemaining -= 4;
424 uint val = (uint)((int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4);
425 uint num3 = Math.Min(val, (uint)outputCharsRemaining) / 8;
426 num4 = 0;
427 while ((uint)num4 < num3)
428 {
429 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
430 num5 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 4);
431 if (ASCIIUtility.AllBytesInUInt32AreAscii(num2 | num5))
432 {
433 pInputBuffer += 8;
434 ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
435 ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref pOutputBuffer[4], num5);
436 pOutputBuffer += 8;
437 num4++;
438 continue;
439 }
440 goto IL_00f4;
441 }
442 outputCharsRemaining -= 8 * num4;
443 goto IL_04aa;
444 }
445 goto IL_04b1;
446 IL_04b1:
447 inputLength = (int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4;
448 goto IL_0690;
449 IL_04aa:
450 if (pInputBuffer <= ptr)
451 {
452 goto IL_004a;
453 }
454 goto IL_04b1;
455 IL_0120:
456 if (UInt32FirstByteIsAscii(num2))
457 {
458 if (outputCharsRemaining >= 3)
459 {
460 uint num6 = ToLittleEndian(num2);
461 nuint num7 = 1u;
462 *pOutputBuffer = (char)(byte)num6;
463 if (UInt32SecondByteIsAscii(num2))
464 {
465 num7++;
466 num6 >>= 8;
467 pOutputBuffer[1] = (char)(byte)num6;
468 if (UInt32ThirdByteIsAscii(num2))
469 {
470 num7++;
471 num6 >>= 8;
472 pOutputBuffer[2] = (char)(byte)num6;
473 }
474 }
475 pInputBuffer += num7;
476 pOutputBuffer += num7;
477 outputCharsRemaining -= (int)num7;
478 }
479 else
480 {
481 if (outputCharsRemaining == 0)
482 {
483 break;
484 }
485 uint num8 = ToLittleEndian(num2);
486 pInputBuffer++;
487 *(pOutputBuffer++) = (char)(byte)num8;
488 outputCharsRemaining--;
489 if (UInt32SecondByteIsAscii(num2))
490 {
491 if (outputCharsRemaining == 0)
492 {
493 break;
494 }
495 pInputBuffer++;
496 num8 >>= 8;
497 *(pOutputBuffer++) = (char)(byte)num8;
498 if (UInt32ThirdByteIsAscii(num2))
499 {
500 break;
501 }
502 outputCharsRemaining = 0;
503 }
504 }
505 if (pInputBuffer > ptr)
506 {
507 goto IL_04b1;
508 }
509 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
510 }
511 uint num9;
512 while (UInt32BeginsWithUtf8TwoByteMask(num2))
513 {
514 if (!UInt32BeginsWithOverlongUtf8TwoByteSequence(num2))
515 {
516 while (true)
517 {
518 _ = BitConverter.IsLittleEndian;
519 if (!UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(num2) && BitConverter.IsLittleEndian)
520 {
521 break;
522 }
523 if (outputCharsRemaining >= 2)
524 {
525 Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(num2));
526 pInputBuffer += 4;
527 pOutputBuffer += 2;
528 outputCharsRemaining -= 2;
529 if (pInputBuffer <= ptr)
530 {
531 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
532 _ = BitConverter.IsLittleEndian;
533 if (!UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(num2))
534 {
535 goto IL_0051;
536 }
537 continue;
538 }
539 }
540 goto IL_04b1;
541 }
542 num9 = ExtractCharFromFirstTwoByteSequence(num2);
543 if (UInt32ThirdByteIsAscii(num2))
544 {
545 if (UInt32FourthByteIsAscii(num2))
546 {
547 goto IL_0282;
548 }
549 if (outputCharsRemaining >= 2)
550 {
551 *pOutputBuffer = (char)num9;
552 char* num10 = pOutputBuffer + 1;
553 uint num11 = num2;
554 if (!BitConverter.IsLittleEndian)
555 {
556 }
557 *num10 = (char)(byte)(num11 >> 16);
558 pInputBuffer += 3;
559 pOutputBuffer += 2;
560 outputCharsRemaining -= 2;
561 if (ptr >= pInputBuffer)
562 {
563 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
564 continue;
565 }
566 }
567 }
568 else if (outputCharsRemaining != 0)
569 {
570 *pOutputBuffer = (char)num9;
571 pInputBuffer += 2;
572 pOutputBuffer++;
573 outputCharsRemaining--;
574 if (ptr >= pInputBuffer)
575 {
576 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
577 break;
578 }
579 }
580 goto IL_04b1;
581 }
582 goto IL_06a3;
583 }
584 if (UInt32BeginsWithUtf8ThreeByteMask(num2))
585 {
586 while (true)
587 {
588 _ = BitConverter.IsLittleEndian;
589 if ((num2 & 0x200F) == 0 || ((num2 - 8205) & 0x200F) == 0)
590 {
591 break;
592 }
593 if (outputCharsRemaining == 0)
594 {
595 goto end_IL_0051;
596 }
597 _ = BitConverter.IsLittleEndian;
598 if ((((int)num2 - -536870912) & -268435456) == 0 && outputCharsRemaining > 1 && (nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) >= (nint)3)
599 {
600 uint num12 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 3);
601 if (UInt32BeginsWithUtf8ThreeByteMask(num12) && (num12 & 0x200Fu) != 0 && ((num12 - 8205) & 0x200Fu) != 0)
602 {
603 *pOutputBuffer = (char)ExtractCharFromFirstThreeByteSequence(num2);
604 pOutputBuffer[1] = (char)ExtractCharFromFirstThreeByteSequence(num12);
605 pInputBuffer += 6;
606 pOutputBuffer += 2;
607 outputCharsRemaining -= 2;
608 goto IL_03ff;
609 }
610 }
611 *pOutputBuffer = (char)ExtractCharFromFirstThreeByteSequence(num2);
612 pInputBuffer += 3;
613 pOutputBuffer++;
614 outputCharsRemaining--;
615 goto IL_03ff;
616 IL_03ff:
617 if (UInt32FourthByteIsAscii(num2))
618 {
619 if (outputCharsRemaining == 0)
620 {
621 goto end_IL_0051;
622 }
623 _ = BitConverter.IsLittleEndian;
624 *pOutputBuffer = (char)(num2 >> 24);
625 pInputBuffer++;
626 pOutputBuffer++;
627 outputCharsRemaining--;
628 }
629 if (pInputBuffer <= ptr)
630 {
631 num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
632 if (!UInt32BeginsWithUtf8ThreeByteMask(num2))
633 {
634 goto IL_0051;
635 }
636 continue;
637 }
638 goto IL_04b1;
639 }
640 }
641 else if (UInt32BeginsWithUtf8FourByteMask(num2))
642 {
643 _ = BitConverter.IsLittleEndian;
644 uint value = num2 & 0xFFFFu;
645 value = BitOperations.RotateRight(value, 8);
646 if (UnicodeUtility.IsInRangeInclusive(value, 4026531984u, 4093640847u))
647 {
648 if (outputCharsRemaining < 2)
649 {
650 break;
651 }
652 Unsafe.WriteUnaligned(pOutputBuffer, ExtractCharsFromFourByteSequence(num2));
653 pInputBuffer += 4;
654 pOutputBuffer += 2;
655 outputCharsRemaining -= 2;
656 goto IL_04aa;
657 }
658 }
659 goto IL_06a3;
660 IL_0282:
661 if (outputCharsRemaining >= 3)
662 {
663 *pOutputBuffer = (char)num9;
664 _ = BitConverter.IsLittleEndian;
665 num2 >>= 16;
666 pOutputBuffer[1] = (char)(byte)num2;
667 num2 >>= 8;
668 pOutputBuffer[2] = (char)num2;
669 pInputBuffer += 4;
670 pOutputBuffer += 3;
671 outputCharsRemaining -= 3;
672 goto IL_04aa;
673 }
674 goto IL_04b1;
675 IL_00f4:
676 if (ASCIIUtility.AllBytesInUInt32AreAscii(num2))
677 {
678 ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
679 num2 = num5;
680 pInputBuffer += 4;
681 pOutputBuffer += 4;
682 outputCharsRemaining -= 4;
683 }
684 outputCharsRemaining -= 8 * num4;
685 goto IL_0120;
686 continue;
687 end_IL_0051:
688 break;
689 }
690 break;
691 }
692 goto IL_069f;
693 IL_06a3:
694 OperationStatus result = OperationStatus.InvalidData;
695 goto IL_06a5;
696 IL_069f:
697 result = OperationStatus.DestinationTooSmall;
698 goto IL_06a5;
699 IL_06a5:
700 pInputBufferRemaining = pInputBuffer;
701 pOutputBufferRemaining = pOutputBuffer;
702 return result;
703 IL_0690:
704 while (true)
705 {
706 if (inputLength > 0)
707 {
708 uint num13 = *pInputBuffer;
709 if (num13 <= 127)
710 {
711 if (outputCharsRemaining != 0)
712 {
713 *pOutputBuffer = (char)num13;
714 pInputBuffer++;
715 pOutputBuffer++;
716 inputLength--;
717 outputCharsRemaining--;
718 continue;
719 }
720 goto IL_069f;
721 }
722 num13 -= 194;
723 if ((uint)(byte)num13 <= 29u)
724 {
725 if (inputLength < 2)
726 {
727 goto IL_069b;
728 }
729 uint num14 = pInputBuffer[1];
730 if (IsLowByteUtf8ContinuationByte(num14))
731 {
732 if (outputCharsRemaining != 0)
733 {
734 uint num15 = (num13 << 6) + num14 + 128 - 128;
735 *pOutputBuffer = (char)num15;
736 pInputBuffer += 2;
737 pOutputBuffer++;
738 inputLength -= 2;
739 outputCharsRemaining--;
740 continue;
741 }
742 goto IL_069f;
743 }
744 }
745 else if ((uint)(byte)num13 <= 45u)
746 {
747 if (inputLength >= 3)
748 {
749 uint num16 = pInputBuffer[1];
750 uint num17 = pInputBuffer[2];
751 if (IsLowByteUtf8ContinuationByte(num16) && IsLowByteUtf8ContinuationByte(num17))
752 {
753 uint num18 = (num13 << 12) + (num16 << 6);
754 if (num18 >= 133120)
755 {
756 num18 -= 186368;
757 if (num18 >= 2048)
758 {
759 if (outputCharsRemaining != 0)
760 {
761 num18 += num17;
762 num18 += 55296;
763 num18 -= 128;
764 *pOutputBuffer = (char)num18;
765 pInputBuffer += 3;
766 pOutputBuffer++;
767 inputLength -= 3;
768 outputCharsRemaining--;
769 continue;
770 }
771 goto IL_069f;
772 }
773 }
774 }
775 }
776 else
777 {
778 if (inputLength < 2)
779 {
780 goto IL_069b;
781 }
782 uint num19 = pInputBuffer[1];
783 if (IsLowByteUtf8ContinuationByte(num19))
784 {
785 uint num20 = (num13 << 6) + num19;
786 if (num20 >= 2080 && !UnicodeUtility.IsInRangeInclusive(num20, 2912u, 2943u))
787 {
788 goto IL_069b;
789 }
790 }
791 }
792 }
793 else if ((uint)(byte)num13 <= 50u)
794 {
795 if (inputLength < 2)
796 {
797 goto IL_069b;
798 }
799 uint num21 = pInputBuffer[1];
800 if (IsLowByteUtf8ContinuationByte(num21))
801 {
802 uint value2 = (num13 << 6) + num21;
803 if (UnicodeUtility.IsInRangeInclusive(value2, 3088u, 3343u))
804 {
805 if (inputLength < 3)
806 {
807 goto IL_069b;
808 }
809 if (IsLowByteUtf8ContinuationByte(pInputBuffer[2]))
810 {
811 if (inputLength < 4)
812 {
813 goto IL_069b;
814 }
815 if (IsLowByteUtf8ContinuationByte(pInputBuffer[3]))
816 {
817 goto IL_069f;
818 }
819 }
820 }
821 }
822 }
823 goto IL_06a3;
824 }
825 result = OperationStatus.Done;
826 break;
827 IL_069b:
828 result = OperationStatus.NeedMoreData;
829 break;
830 }
831 goto IL_06a5;
832 }
System.Numerics.BitOperations.RotateRight
static uint RotateRight(uint value, int offset)
Definition BitOperations.cs:374
System.Text.Unicode.Utf8Utility.UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian
static bool UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(uint value)
Definition Utf8Utility.cs:284
System.Text.Unicode.Utf8Utility.UInt32FourthByteIsAscii
static bool UInt32FourthByteIsAscii(uint value)
Definition Utf8Utility.cs:326
System.Text.Unicode.Utf8Utility.ExtractCharsFromFourByteSequence
static uint ExtractCharsFromFourByteSequence(uint value)
Definition Utf8Utility.cs:30
System.Text.Unicode.Utf8Utility.ToLittleEndian
static uint ToLittleEndian(uint value)
Definition Utf8Utility.cs:221
System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8ThreeByteMask
static bool UInt32BeginsWithUtf8ThreeByteMask(uint value)
Definition Utf8Utility.cs:256
System.Text.Unicode.Utf8Utility.ExtractCharFromFirstTwoByteSequence
static uint ExtractCharFromFirstTwoByteSequence(uint value)
Definition Utf8Utility.cs:22
System.Text.Unicode.Utf8Utility.ExtractCharFromFirstThreeByteSequence
static uint ExtractCharFromFirstThreeByteSequence(uint value)
Definition Utf8Utility.cs:15
System.Text.Unicode.Utf8Utility.ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences
static uint ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(uint value)
Definition Utf8Utility.cs:60
System.Text.Unicode.Utf8Utility.UInt32FirstByteIsAscii
static bool UInt32FirstByteIsAscii(uint value)
Definition Utf8Utility.cs:312
System.Text.Unicode.Utf8Utility.IsLowByteUtf8ContinuationByte
static bool IsLowByteUtf8ContinuationByte(uint value)
Definition Utf8Utility.cs:139
System.Text.Unicode.Utf8Utility.UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian
static bool UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(uint value)
Definition Utf8Utility.cs:298
System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8TwoByteMask
static bool UInt32BeginsWithUtf8TwoByteMask(uint value)
Definition Utf8Utility.cs:270
System.Text.Unicode.Utf8Utility.UInt32ThirdByteIsAscii
static bool UInt32ThirdByteIsAscii(uint value)
Definition Utf8Utility.cs:354
System.Text.Unicode.Utf8Utility.UInt32BeginsWithOverlongUtf8TwoByteSequence
static bool UInt32BeginsWithOverlongUtf8TwoByteSequence(uint value)
Definition Utf8Utility.cs:228
System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8FourByteMask
static bool UInt32BeginsWithUtf8FourByteMask(uint value)
Definition Utf8Utility.cs:242
System.Text.Unicode.Utf8Utility.UInt32SecondByteIsAscii
static bool UInt32SecondByteIsAscii(uint value)
Definition Utf8Utility.cs:340

References System.Text.ASCIIUtility.AllBytesInUInt32AreAscii(), System.Text.Unicode.Utf8Utility.ExtractCharFromFirstThreeByteSequence(), System.Text.Unicode.Utf8Utility.ExtractCharFromFirstTwoByteSequence(), System.Text.Unicode.Utf8Utility.ExtractCharsFromFourByteSequence(), System.Text.Unicode.Utf8Utility.ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(), System.Text.UnicodeUtility.IsInRangeInclusive(), System.BitConverter.IsLittleEndian, System.Text.Unicode.Utf8Utility.IsLowByteUtf8ContinuationByte(), System.Math.Min(), System.Numerics.BitOperations.RotateRight(), System.Text.Unicode.Utf8Utility.ToLittleEndian(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithOverlongUtf8TwoByteSequence(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8FourByteMask(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8ThreeByteMask(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8TwoByteMask(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(), System.Text.Unicode.Utf8Utility.UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(), System.Text.Unicode.Utf8Utility.UInt32FirstByteIsAscii(), System.Text.Unicode.Utf8Utility.UInt32FourthByteIsAscii(), System.Text.Unicode.Utf8Utility.UInt32SecondByteIsAscii(), System.Text.Unicode.Utf8Utility.UInt32ThirdByteIsAscii(), System.value, System.Text.ASCIIUtility.WidenAsciiToUtf16(), and System.Text.ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer().

Referenced by System.Text.UTF8Encoding.GetCharsFast(), and System.Text.Unicode.Utf8.ToUtf16().