Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
DBCSCodePageEncoding.cs
Go to the documentation of this file.
1using System.Buffers.Binary;
2using System.IO;
3using System.Runtime.CompilerServices;
4using System.Threading;
5
6namespace System.Text;
7
8internal class DBCSCodePageEncoding : BaseCodePageEncoding
9{
10 internal sealed class DBCSDecoder : System.Text.DecoderNLS
11 {
12 internal byte bLeftOver;
13
14 internal override bool HasState => bLeftOver != 0;
15
16 public DBCSDecoder(DBCSCodePageEncoding encoding)
17 : base(encoding)
18 {
19 }
20
21 public override void Reset()
22 {
23 bLeftOver = 0;
24 if (m_fallbackBuffer != null)
25 {
26 m_fallbackBuffer.Reset();
27 }
28 }
29 }
30
31 protected unsafe char* mapBytesToUnicode = null;
32
33 protected unsafe ushort* mapUnicodeToBytes = null;
34
35 private ushort _bytesUnknown;
36
37 private int _byteCountUnknown;
38
39 protected char charUnknown;
40
41 private static object s_InternalSyncObject;
42
43 private static object InternalSyncObject
44 {
45 get
46 {
47 if (s_InternalSyncObject == null)
48 {
49 object value = new object();
50 Interlocked.CompareExchange<object>(ref s_InternalSyncObject, value, (object)null);
51 }
52 return s_InternalSyncObject;
53 }
54 }
55
56 public DBCSCodePageEncoding(int codePage)
57 : this(codePage, codePage)
58 {
59 }
60
61 internal unsafe DBCSCodePageEncoding(int codePage, int dataCodePage)
62 : base(codePage, dataCodePage)
63 {
64 }
65
66 internal unsafe DBCSCodePageEncoding(int codePage, int dataCodePage, EncoderFallback enc, DecoderFallback dec)
67 : base(codePage, dataCodePage, enc, dec)
68 {
69 }
70
71 internal unsafe static char ReadChar(char* pChar)
72 {
73 if (BitConverter.IsLittleEndian)
74 {
75 return *pChar;
76 }
77 return (char)BinaryPrimitives.ReverseEndianness(*pChar);
78 }
79
80 protected unsafe override void LoadManagedCodePage()
81 {
82 fixed (byte* ptr = &m_codePageHeader[0])
83 {
84 CodePageHeader* ptr2 = (CodePageHeader*)ptr;
85 if (ptr2->ByteCount != 2)
86 {
87 throw new NotSupportedException(System.SR.Format(System.SR.NotSupported_NoCodepageData, CodePage));
88 }
89 _bytesUnknown = ptr2->ByteReplace;
90 charUnknown = ptr2->UnicodeReplace;
91 if (base.DecoderFallback is InternalDecoderBestFitFallback)
92 {
93 ((InternalDecoderBestFitFallback)base.DecoderFallback).cReplacement = charUnknown;
94 }
95 _byteCountUnknown = 1;
96 if (_bytesUnknown > 255)
97 {
98 _byteCountUnknown++;
99 }
100 int num = 262148 + iExtraBytes;
101 byte* nativeMemory = GetNativeMemory(num);
102 Unsafe.InitBlockUnaligned(nativeMemory, 0, (uint)num);
103 mapBytesToUnicode = (char*)nativeMemory;
104 mapUnicodeToBytes = (ushort*)(nativeMemory + 131072);
105 byte[] array = new byte[m_dataSize];
106 lock (BaseCodePageEncoding.s_streamLock)
107 {
108 BaseCodePageEncoding.s_codePagesEncodingDataStream.Seek(m_firstDataWordOffset, SeekOrigin.Begin);
109 BaseCodePageEncoding.s_codePagesEncodingDataStream.Read(array, 0, m_dataSize);
110 }
111 fixed (byte* ptr3 = array)
112 {
113 char* ptr4 = (char*)ptr3;
114 int num2 = 0;
115 int num3 = 0;
116 while (num2 < 65536)
117 {
118 char c = ReadChar(ptr4);
119 ptr4++;
120 switch (c)
121 {
122 case '\u0001':
123 num2 = ReadChar(ptr4);
124 ptr4++;
125 continue;
126 case '\u0002':
127 case '\u0003':
128 case '\u0004':
129 case '\u0005':
130 case '\u0006':
131 case '\a':
132 case '\b':
133 case '\t':
134 case '\n':
135 case '\v':
136 case '\f':
137 case '\r':
138 case '\u000e':
139 case '\u000f':
140 case '\u0010':
141 case '\u0011':
142 case '\u0012':
143 case '\u0013':
144 case '\u0014':
145 case '\u0015':
146 case '\u0016':
147 case '\u0017':
148 case '\u0018':
149 case '\u0019':
150 case '\u001a':
151 case '\u001b':
152 case '\u001c':
153 case '\u001d':
154 case '\u001e':
155 case '\u001f':
156 num2 += c;
157 continue;
158 }
159 switch (c)
160 {
161 case '\uffff':
162 num3 = num2;
163 c = (char)num2;
164 break;
165 case '\ufffe':
166 num3 = num2;
167 break;
168 case '\ufffd':
169 num2++;
170 continue;
171 default:
172 num3 = num2;
173 break;
174 }
175 if (CleanUpBytes(ref num3))
176 {
177 if (c != '\ufffe')
178 {
179 mapUnicodeToBytes[(int)c] = (ushort)num3;
180 }
181 mapBytesToUnicode[num3] = c;
182 }
183 num2++;
184 }
185 }
186 CleanUpEndBytes(mapBytesToUnicode);
187 }
188 }
189
190 protected virtual bool CleanUpBytes(ref int bytes)
191 {
192 return true;
193 }
194
195 protected unsafe virtual void CleanUpEndBytes(char* chars)
196 {
197 }
198
199 protected unsafe override void ReadBestFitTable()
200 {
201 lock (InternalSyncObject)
202 {
203 if (arrayUnicodeBestFit != null)
204 {
205 return;
206 }
207 byte[] array = new byte[m_dataSize];
208 lock (BaseCodePageEncoding.s_streamLock)
209 {
210 BaseCodePageEncoding.s_codePagesEncodingDataStream.Seek(m_firstDataWordOffset, SeekOrigin.Begin);
211 BaseCodePageEncoding.s_codePagesEncodingDataStream.Read(array, 0, m_dataSize);
212 }
213 fixed (byte* ptr = array)
214 {
215 char* ptr2 = (char*)ptr;
216 int num = 0;
217 while (num < 65536)
218 {
219 char c = ReadChar(ptr2);
220 ptr2++;
221 switch (c)
222 {
223 case '\u0001':
224 num = ReadChar(ptr2);
225 ptr2++;
226 break;
227 case '\u0002':
228 case '\u0003':
229 case '\u0004':
230 case '\u0005':
231 case '\u0006':
232 case '\a':
233 case '\b':
234 case '\t':
235 case '\n':
236 case '\v':
237 case '\f':
238 case '\r':
239 case '\u000e':
240 case '\u000f':
241 case '\u0010':
242 case '\u0011':
243 case '\u0012':
244 case '\u0013':
245 case '\u0014':
246 case '\u0015':
247 case '\u0016':
248 case '\u0017':
249 case '\u0018':
250 case '\u0019':
251 case '\u001a':
252 case '\u001b':
253 case '\u001c':
254 case '\u001d':
255 case '\u001e':
256 case '\u001f':
257 num += c;
258 break;
259 default:
260 num++;
261 break;
262 }
263 }
264 char* ptr3 = ptr2;
265 int num2 = 0;
266 num = ReadChar(ptr2);
267 ptr2++;
268 while (num < 65536)
269 {
270 char c2 = ReadChar(ptr2);
271 ptr2++;
272 switch (c2)
273 {
274 case '\u0001':
275 num = ReadChar(ptr2);
276 ptr2++;
277 continue;
278 case '\u0002':
279 case '\u0003':
280 case '\u0004':
281 case '\u0005':
282 case '\u0006':
283 case '\a':
284 case '\b':
285 case '\t':
286 case '\n':
287 case '\v':
288 case '\f':
289 case '\r':
290 case '\u000e':
291 case '\u000f':
292 case '\u0010':
293 case '\u0011':
294 case '\u0012':
295 case '\u0013':
296 case '\u0014':
297 case '\u0015':
298 case '\u0016':
299 case '\u0017':
300 case '\u0018':
301 case '\u0019':
302 case '\u001a':
303 case '\u001b':
304 case '\u001c':
305 case '\u001d':
306 case '\u001e':
307 case '\u001f':
308 num += c2;
309 continue;
310 }
311 if (c2 != '\ufffd')
312 {
313 int bytes = num;
314 if (CleanUpBytes(ref bytes) && mapBytesToUnicode[bytes] != c2)
315 {
316 num2++;
317 }
318 }
319 num++;
320 }
321 char[] array2 = new char[num2 * 2];
322 num2 = 0;
323 ptr2 = ptr3;
324 num = ReadChar(ptr2);
325 ptr2++;
326 bool flag = false;
327 while (num < 65536)
328 {
329 char c3 = ReadChar(ptr2);
330 ptr2++;
331 switch (c3)
332 {
333 case '\u0001':
334 num = ReadChar(ptr2);
335 ptr2++;
336 continue;
337 case '\u0002':
338 case '\u0003':
339 case '\u0004':
340 case '\u0005':
341 case '\u0006':
342 case '\a':
343 case '\b':
344 case '\t':
345 case '\n':
346 case '\v':
347 case '\f':
348 case '\r':
349 case '\u000e':
350 case '\u000f':
351 case '\u0010':
352 case '\u0011':
353 case '\u0012':
354 case '\u0013':
355 case '\u0014':
356 case '\u0015':
357 case '\u0016':
358 case '\u0017':
359 case '\u0018':
360 case '\u0019':
361 case '\u001a':
362 case '\u001b':
363 case '\u001c':
364 case '\u001d':
365 case '\u001e':
366 case '\u001f':
367 num += c3;
368 continue;
369 }
370 if (c3 != '\ufffd')
371 {
372 int bytes2 = num;
373 if (CleanUpBytes(ref bytes2) && mapBytesToUnicode[bytes2] != c3)
374 {
375 if (bytes2 != num)
376 {
377 flag = true;
378 }
379 array2[num2++] = (char)bytes2;
380 array2[num2++] = c3;
381 }
382 }
383 num++;
384 }
385 if (flag)
386 {
387 for (int i = 0; i < array2.Length - 2; i += 2)
388 {
389 int num3 = i;
390 char c4 = array2[i];
391 for (int j = i + 2; j < array2.Length; j += 2)
392 {
393 if (c4 > array2[j])
394 {
395 c4 = array2[j];
396 num3 = j;
397 }
398 }
399 if (num3 != i)
400 {
401 char c5 = array2[num3];
402 array2[num3] = array2[i];
403 array2[i] = c5;
404 c5 = array2[num3 + 1];
405 array2[num3 + 1] = array2[i + 1];
406 array2[i + 1] = c5;
407 }
408 }
409 }
410 arrayBytesBestFit = array2;
411 char* ptr4 = ptr2;
412 int num4 = ReadChar(ptr2++);
413 num2 = 0;
414 while (num4 < 65536)
415 {
416 char c6 = ReadChar(ptr2);
417 ptr2++;
418 switch (c6)
419 {
420 case '\u0001':
421 num4 = ReadChar(ptr2);
422 ptr2++;
423 continue;
424 case '\u0002':
425 case '\u0003':
426 case '\u0004':
427 case '\u0005':
428 case '\u0006':
429 case '\a':
430 case '\b':
431 case '\t':
432 case '\n':
433 case '\v':
434 case '\f':
435 case '\r':
436 case '\u000e':
437 case '\u000f':
438 case '\u0010':
439 case '\u0011':
440 case '\u0012':
441 case '\u0013':
442 case '\u0014':
443 case '\u0015':
444 case '\u0016':
445 case '\u0017':
446 case '\u0018':
447 case '\u0019':
448 case '\u001a':
449 case '\u001b':
450 case '\u001c':
451 case '\u001d':
452 case '\u001e':
453 case '\u001f':
454 num4 += c6;
455 continue;
456 }
457 if (c6 > '\0')
458 {
459 num2++;
460 }
461 num4++;
462 }
463 array2 = new char[num2 * 2];
464 ptr2 = ptr4;
465 num4 = ReadChar(ptr2++);
466 num2 = 0;
467 while (num4 < 65536)
468 {
469 char c7 = ReadChar(ptr2);
470 ptr2++;
471 switch (c7)
472 {
473 case '\u0001':
474 num4 = ReadChar(ptr2);
475 ptr2++;
476 continue;
477 case '\u0002':
478 case '\u0003':
479 case '\u0004':
480 case '\u0005':
481 case '\u0006':
482 case '\a':
483 case '\b':
484 case '\t':
485 case '\n':
486 case '\v':
487 case '\f':
488 case '\r':
489 case '\u000e':
490 case '\u000f':
491 case '\u0010':
492 case '\u0011':
493 case '\u0012':
494 case '\u0013':
495 case '\u0014':
496 case '\u0015':
497 case '\u0016':
498 case '\u0017':
499 case '\u0018':
500 case '\u0019':
501 case '\u001a':
502 case '\u001b':
503 case '\u001c':
504 case '\u001d':
505 case '\u001e':
506 case '\u001f':
507 num4 += c7;
508 continue;
509 }
510 if (c7 > '\0')
511 {
512 int bytes3 = c7;
513 if (CleanUpBytes(ref bytes3))
514 {
515 array2[num2++] = (char)num4;
516 array2[num2++] = mapBytesToUnicode[bytes3];
517 }
518 }
519 num4++;
520 }
521 arrayUnicodeBestFit = array2;
522 }
523 }
524 }
525
526 public unsafe override int GetByteCount(char* chars, int count, System.Text.EncoderNLS encoder)
527 {
528 CheckMemorySection();
529 char c = '\0';
530 if (encoder != null)
531 {
532 c = encoder.charLeftOver;
533 if (encoder.InternalHasFallbackBuffer && encoder.FallbackBuffer.Remaining > 0)
534 {
535 throw new ArgumentException(System.SR.Format(System.SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback.GetType()));
536 }
537 }
538 int num = 0;
539 char* ptr = chars + count;
540 EncoderFallbackBuffer encoderFallbackBuffer = null;
541 EncoderFallbackBufferHelper encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
542 if (c > '\0')
543 {
544 encoderFallbackBuffer = encoder.FallbackBuffer;
545 encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
546 encoderFallbackBufferHelper.InternalInitialize(chars, ptr, encoder, _setEncoder: false);
547 encoderFallbackBufferHelper.InternalFallback(c, ref chars);
548 }
549 char c2;
550 while ((c2 = ((encoderFallbackBuffer != null) ? encoderFallbackBufferHelper.InternalGetNextChar() : '\0')) != 0 || chars < ptr)
551 {
552 if (c2 == '\0')
553 {
554 c2 = *chars;
555 chars++;
556 }
557 ushort num2 = mapUnicodeToBytes[(int)c2];
558 if (num2 == 0 && c2 != 0)
559 {
560 if (encoderFallbackBuffer == null)
561 {
562 encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : base.EncoderFallback.CreateFallbackBuffer());
563 encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
564 encoderFallbackBufferHelper.InternalInitialize(ptr - count, ptr, encoder, _setEncoder: false);
565 }
566 encoderFallbackBufferHelper.InternalFallback(c2, ref chars);
567 }
568 else
569 {
570 num++;
571 if (num2 >= 256)
572 {
573 num++;
574 }
575 }
576 }
577 return num;
578 }
579
580 public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, System.Text.EncoderNLS encoder)
581 {
582 CheckMemorySection();
583 EncoderFallbackBuffer encoderFallbackBuffer = null;
584 char* ptr = chars + charCount;
585 char* ptr2 = chars;
586 byte* ptr3 = bytes;
587 byte* ptr4 = bytes + byteCount;
588 EncoderFallbackBufferHelper encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
589 char c = '\0';
590 if (encoder != null)
591 {
592 c = encoder.charLeftOver;
593 encoderFallbackBuffer = encoder.FallbackBuffer;
594 encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
595 encoderFallbackBufferHelper.InternalInitialize(chars, ptr, encoder, _setEncoder: true);
596 if (encoder.m_throwOnOverflow && encoderFallbackBuffer.Remaining > 0)
597 {
598 throw new ArgumentException(System.SR.Format(System.SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback.GetType()));
599 }
600 if (c > '\0')
601 {
602 encoderFallbackBufferHelper.InternalFallback(c, ref chars);
603 }
604 }
605 char c2;
606 while ((c2 = ((encoderFallbackBuffer != null) ? encoderFallbackBufferHelper.InternalGetNextChar() : '\0')) != 0 || chars < ptr)
607 {
608 if (c2 == '\0')
609 {
610 c2 = *chars;
611 chars++;
612 }
613 ushort num = mapUnicodeToBytes[(int)c2];
614 if (num == 0 && c2 != 0)
615 {
616 if (encoderFallbackBuffer == null)
617 {
618 encoderFallbackBuffer = base.EncoderFallback.CreateFallbackBuffer();
619 encoderFallbackBufferHelper = new EncoderFallbackBufferHelper(encoderFallbackBuffer);
620 encoderFallbackBufferHelper.InternalInitialize(ptr - charCount, ptr, encoder, _setEncoder: true);
621 }
622 encoderFallbackBufferHelper.InternalFallback(c2, ref chars);
623 continue;
624 }
625 if (num >= 256)
626 {
627 if (bytes + 1 >= ptr4)
628 {
629 if (encoderFallbackBuffer == null || !encoderFallbackBufferHelper.bFallingBack)
630 {
631 chars--;
632 }
633 else
634 {
635 encoderFallbackBuffer.MovePrevious();
636 }
637 ThrowBytesOverflow(encoder, chars == ptr2);
638 break;
639 }
640 *bytes = (byte)(num >> 8);
641 bytes++;
642 }
643 else if (bytes >= ptr4)
644 {
645 if (encoderFallbackBuffer == null || !encoderFallbackBufferHelper.bFallingBack)
646 {
647 chars--;
648 }
649 else
650 {
651 encoderFallbackBuffer.MovePrevious();
652 }
653 ThrowBytesOverflow(encoder, chars == ptr2);
654 break;
655 }
656 *bytes = (byte)(num & 0xFFu);
657 bytes++;
658 }
659 if (encoder != null)
660 {
661 if (encoderFallbackBuffer != null && !encoderFallbackBufferHelper.bUsedEncoder)
662 {
663 encoder.charLeftOver = '\0';
664 }
665 encoder.m_charsUsed = (int)(chars - ptr2);
666 }
667 return (int)(bytes - ptr3);
668 }
669
670 public unsafe override int GetCharCount(byte* bytes, int count, System.Text.DecoderNLS baseDecoder)
671 {
672 CheckMemorySection();
673 DBCSDecoder dBCSDecoder = (DBCSDecoder)baseDecoder;
674 DecoderFallbackBuffer decoderFallbackBuffer = null;
675 byte* ptr = bytes + count;
676 int num = count;
677 DecoderFallbackBufferHelper decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
678 if (dBCSDecoder != null && dBCSDecoder.bLeftOver > 0)
679 {
680 if (count == 0)
681 {
682 if (!dBCSDecoder.MustFlush)
683 {
684 return 0;
685 }
686 decoderFallbackBuffer = dBCSDecoder.FallbackBuffer;
687 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
688 decoderFallbackBufferHelper.InternalInitialize(bytes, null);
689 byte[] bytes2 = new byte[1] { dBCSDecoder.bLeftOver };
690 return decoderFallbackBufferHelper.InternalFallback(bytes2, bytes);
691 }
692 int num2 = dBCSDecoder.bLeftOver << 8;
693 num2 |= *bytes;
694 bytes++;
695 if (mapBytesToUnicode[num2] == '\0' && num2 != 0)
696 {
697 num--;
698 decoderFallbackBuffer = dBCSDecoder.FallbackBuffer;
699 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
700 decoderFallbackBufferHelper.InternalInitialize(ptr - count, null);
701 byte[] bytes3 = new byte[2]
702 {
703 (byte)(num2 >> 8),
704 (byte)num2
705 };
706 num += decoderFallbackBufferHelper.InternalFallback(bytes3, bytes);
707 }
708 }
709 while (bytes < ptr)
710 {
711 int num3 = *bytes;
712 bytes++;
713 char c = mapBytesToUnicode[num3];
714 if (c == '\ufffe')
715 {
716 num--;
717 if (bytes < ptr)
718 {
719 num3 <<= 8;
720 num3 |= *bytes;
721 bytes++;
722 c = mapBytesToUnicode[num3];
723 }
724 else
725 {
726 if (dBCSDecoder != null && !dBCSDecoder.MustFlush)
727 {
728 break;
729 }
730 num++;
731 c = '\0';
732 }
733 }
734 if (c == '\0' && num3 != 0)
735 {
736 if (decoderFallbackBuffer == null)
737 {
738 decoderFallbackBuffer = ((dBCSDecoder != null) ? dBCSDecoder.FallbackBuffer : base.DecoderFallback.CreateFallbackBuffer());
739 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
740 decoderFallbackBufferHelper.InternalInitialize(ptr - count, null);
741 }
742 num--;
743 byte[] bytes4 = ((num3 >= 256) ? new byte[2]
744 {
745 (byte)(num3 >> 8),
746 (byte)num3
747 } : new byte[1] { (byte)num3 });
748 num += decoderFallbackBufferHelper.InternalFallback(bytes4, bytes);
749 }
750 }
751 return num;
752 }
753
754 public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, System.Text.DecoderNLS baseDecoder)
755 {
756 CheckMemorySection();
757 DBCSDecoder dBCSDecoder = (DBCSDecoder)baseDecoder;
758 byte* ptr = bytes;
759 byte* ptr2 = bytes + byteCount;
760 char* ptr3 = chars;
761 char* ptr4 = chars + charCount;
762 bool flag = false;
763 DecoderFallbackBuffer decoderFallbackBuffer = null;
764 DecoderFallbackBufferHelper decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
765 if (dBCSDecoder != null && dBCSDecoder.bLeftOver > 0)
766 {
767 if (byteCount == 0)
768 {
769 if (!dBCSDecoder.MustFlush)
770 {
771 return 0;
772 }
773 decoderFallbackBuffer = dBCSDecoder.FallbackBuffer;
774 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
775 decoderFallbackBufferHelper.InternalInitialize(bytes, ptr4);
776 byte[] bytes2 = new byte[1] { dBCSDecoder.bLeftOver };
777 if (!decoderFallbackBufferHelper.InternalFallback(bytes2, bytes, ref chars))
778 {
779 ThrowCharsOverflow(dBCSDecoder, nothingDecoded: true);
780 }
781 dBCSDecoder.bLeftOver = 0;
782 return (int)(chars - ptr3);
783 }
784 int num = dBCSDecoder.bLeftOver << 8;
785 num |= *bytes;
786 bytes++;
787 char c = mapBytesToUnicode[num];
788 if (c == '\0' && num != 0)
789 {
790 decoderFallbackBuffer = dBCSDecoder.FallbackBuffer;
791 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
792 decoderFallbackBufferHelper.InternalInitialize(ptr2 - byteCount, ptr4);
793 byte[] bytes3 = new byte[2]
794 {
795 (byte)(num >> 8),
796 (byte)num
797 };
798 if (!decoderFallbackBufferHelper.InternalFallback(bytes3, bytes, ref chars))
799 {
800 ThrowCharsOverflow(dBCSDecoder, nothingDecoded: true);
801 }
802 }
803 else
804 {
805 if (chars >= ptr4)
806 {
807 ThrowCharsOverflow(dBCSDecoder, nothingDecoded: true);
808 }
809 *(chars++) = c;
810 }
811 }
812 while (bytes < ptr2)
813 {
814 int num2 = *bytes;
815 bytes++;
816 char c2 = mapBytesToUnicode[num2];
817 if (c2 == '\ufffe')
818 {
819 if (bytes < ptr2)
820 {
821 num2 <<= 8;
822 num2 |= *bytes;
823 bytes++;
824 c2 = mapBytesToUnicode[num2];
825 }
826 else
827 {
828 if (dBCSDecoder != null && !dBCSDecoder.MustFlush)
829 {
830 flag = true;
831 dBCSDecoder.bLeftOver = (byte)num2;
832 break;
833 }
834 c2 = '\0';
835 }
836 }
837 if (c2 == '\0' && num2 != 0)
838 {
839 if (decoderFallbackBuffer == null)
840 {
841 decoderFallbackBuffer = ((dBCSDecoder != null) ? dBCSDecoder.FallbackBuffer : base.DecoderFallback.CreateFallbackBuffer());
842 decoderFallbackBufferHelper = new DecoderFallbackBufferHelper(decoderFallbackBuffer);
843 decoderFallbackBufferHelper.InternalInitialize(ptr2 - byteCount, ptr4);
844 }
845 byte[] array = ((num2 >= 256) ? new byte[2]
846 {
847 (byte)(num2 >> 8),
848 (byte)num2
849 } : new byte[1] { (byte)num2 });
850 if (!decoderFallbackBufferHelper.InternalFallback(array, bytes, ref chars))
851 {
852 bytes -= array.Length;
853 decoderFallbackBufferHelper.InternalReset();
854 ThrowCharsOverflow(dBCSDecoder, bytes == ptr);
855 break;
856 }
857 continue;
858 }
859 if (chars >= ptr4)
860 {
861 bytes--;
862 if (num2 >= 256)
863 {
864 bytes--;
865 }
866 ThrowCharsOverflow(dBCSDecoder, bytes == ptr);
867 break;
868 }
869 *(chars++) = c2;
870 }
871 if (dBCSDecoder != null)
872 {
873 if (!flag)
874 {
875 dBCSDecoder.bLeftOver = 0;
876 }
877 dBCSDecoder.m_bytesUsed = (int)(bytes - ptr);
878 }
879 return (int)(chars - ptr3);
880 }
881
882 public override int GetMaxByteCount(int charCount)
883 {
884 if (charCount < 0)
885 {
886 throw new ArgumentOutOfRangeException("charCount", System.SR.ArgumentOutOfRange_NeedNonNegNum);
887 }
888 long num = (long)charCount + 1L;
889 if (base.EncoderFallback.MaxCharCount > 1)
890 {
891 num *= base.EncoderFallback.MaxCharCount;
892 }
893 num *= 2;
894 if (num > int.MaxValue)
895 {
896 throw new ArgumentOutOfRangeException("charCount", System.SR.ArgumentOutOfRange_GetByteCountOverflow);
897 }
898 return (int)num;
899 }
900
901 public override int GetMaxCharCount(int byteCount)
902 {
903 if (byteCount < 0)
904 {
905 throw new ArgumentOutOfRangeException("byteCount", System.SR.ArgumentOutOfRange_NeedNonNegNum);
906 }
907 long num = (long)byteCount + 1L;
908 if (base.DecoderFallback.MaxCharCount > 1)
909 {
910 num *= base.DecoderFallback.MaxCharCount;
911 }
912 if (num > int.MaxValue)
913 {
914 throw new ArgumentOutOfRangeException("byteCount", System.SR.ArgumentOutOfRange_GetCharCountOverflow);
915 }
916 return (int)num;
917 }
918
919 public override Decoder GetDecoder()
920 {
921 return new DBCSDecoder(this);
922 }
923}
System.BitConverter.IsLittleEndian
static readonly bool IsLittleEndian
Definition BitConverter.cs:12
System.Buffers.Binary.BinaryPrimitives.ReverseEndianness
static sbyte ReverseEndianness(sbyte value)
Definition BinaryPrimitives.cs:11
System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned
static unsafe void InitBlockUnaligned(void *startAddress, byte value, uint byteCount)
Definition Unsafe.cs:133
System.SR.NotSupported_NoCodepageData
static string NotSupported_NoCodepageData
Definition SR.cs:1688
System.SR.Argument_EncoderFallbackNotEmpty
static string Argument_EncoderFallbackNotEmpty
Definition SR.cs:590
System.SR.ArgumentOutOfRange_GetCharCountOverflow
static string ArgumentOutOfRange_GetCharCountOverflow
Definition SR.cs:90
System.SR.ArgumentOutOfRange_GetByteCountOverflow
static string ArgumentOutOfRange_GetByteCountOverflow
Definition SR.cs:88
System.SR.Format
static string Format(string resourceFormat, object p1)
Definition SR.cs:118
System.SR.ArgumentOutOfRange_NeedNonNegNum
static string ArgumentOutOfRange_NeedNonNegNum
Definition SR.cs:32
System.SR
Definition SR.cs:7
System.Text.BaseCodePageEncoding.GetNativeMemory
unsafe byte * GetNativeMemory(int iSize)
Definition BaseCodePageEncoding.cs:282
System.Text.DBCSCodePageEncoding.GetBytes
unsafe override int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, System.Text.EncoderNLS encoder)
Definition DBCSCodePageEncoding.cs:580
System.Text.DBCSCodePageEncoding.LoadManagedCodePage
unsafe override void LoadManagedCodePage()
Definition DBCSCodePageEncoding.cs:80
System.Text.DBCSCodePageEncoding.GetByteCount
unsafe override int GetByteCount(char *chars, int count, System.Text.EncoderNLS encoder)
Definition DBCSCodePageEncoding.cs:526
System.Text.DBCSCodePageEncoding.ReadChar
static unsafe char ReadChar(char *pChar)
Definition DBCSCodePageEncoding.cs:71
System.Text.DBCSCodePageEncoding.CleanUpBytes
virtual bool CleanUpBytes(ref int bytes)
Definition DBCSCodePageEncoding.cs:190
System.Text.DBCSCodePageEncoding.CleanUpEndBytes
virtual unsafe void CleanUpEndBytes(char *chars)
Definition DBCSCodePageEncoding.cs:195
System.Text.DBCSCodePageEncoding.DBCSCodePageEncoding
unsafe DBCSCodePageEncoding(int codePage, int dataCodePage, EncoderFallback enc, DecoderFallback dec)
Definition DBCSCodePageEncoding.cs:66
System.Text.DBCSCodePageEncoding.DBCSCodePageEncoding
unsafe DBCSCodePageEncoding(int codePage, int dataCodePage)
Definition DBCSCodePageEncoding.cs:61
System.Text.DBCSCodePageEncoding.GetMaxCharCount
override int GetMaxCharCount(int byteCount)
Definition DBCSCodePageEncoding.cs:901
System.Text.DBCSCodePageEncoding.GetMaxByteCount
override int GetMaxByteCount(int charCount)
Definition DBCSCodePageEncoding.cs:882
System.Text.DBCSCodePageEncoding.GetCharCount
unsafe override int GetCharCount(byte *bytes, int count, System.Text.DecoderNLS baseDecoder)
Definition DBCSCodePageEncoding.cs:670
System.Text.DBCSCodePageEncoding.GetChars
unsafe override int GetChars(byte *bytes, int byteCount, char *chars, int charCount, System.Text.DecoderNLS baseDecoder)
Definition DBCSCodePageEncoding.cs:754
System.Text.DecoderNLS.m_fallbackBuffer
DecoderFallbackBuffer m_fallbackBuffer
Definition DecoderNLS.cs:17
System.Text.DecoderNLS.FallbackBuffer
new DecoderFallbackBuffer FallbackBuffer
Definition DecoderNLS.cs:24
System.Text.EncodingNLS.EncodingName
override string EncodingName
Definition EncodingNLS.cs:12
System.Text.Encoding.CodePage
virtual int CodePage
Definition Encoding.cs:515
System.Threading.Interlocked.CompareExchange
static int CompareExchange(ref int location1, int value, int comparand)
System.Text.DecoderFallbackBufferHelper.InternalFallback
unsafe bool InternalFallback(byte[] bytes, byte *pBytes, ref char *chars)
Definition DecoderFallbackBufferHelper.cs:30
System.Text.DecoderFallbackBufferHelper.InternalInitialize
unsafe void InternalInitialize(byte *_byteStart, char *_charEnd)
Definition DecoderFallbackBufferHelper.cs:24
System.Text.EncoderFallbackBufferHelper.InternalInitialize
unsafe void InternalInitialize(char *_charStart, char *_charEnd, System.Text.EncoderNLS _encoder, bool _setEncoder)
Definition EncoderFallbackBufferHelper.cs:38
System.Text.EncoderFallbackBufferHelper.InternalFallback
unsafe bool InternalFallback(char ch, ref char *chars)
Definition EncoderFallbackBufferHelper.cs:60