dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Dotgnu-pnet-commits] CVS: pnetlib/I18N/CJK CP51932.cs, 1.1, 1.2 CP932.c


From: Rhys Weatherley <address@hidden>
Subject: [Dotgnu-pnet-commits] CVS: pnetlib/I18N/CJK CP51932.cs, 1.1, 1.2 CP932.cs, 1.6, 1.7
Date: Thu, 14 Aug 2003 21:26:38 -0400

Update of /cvsroot/dotgnu-pnet/pnetlib/I18N/CJK
In directory subversions:/tmp/cvs-serv1483/I18N/CJK

Modified Files:
        CP51932.cs CP932.cs 
Log Message:


Changes to the "shift_jis" and "euc-jp" decoders to better match MS behaviour.


Index: CP51932.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/I18N/CJK/CP51932.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** CP51932.cs  13 Aug 2003 04:08:45 -0000      1.1
--- CP51932.cs  15 Aug 2003 01:26:36 -0000      1.2
***************
*** 353,357 ****
                                        --count;
                                        ++length;
!                                       if(byteval < 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character, or the
--- 353,357 ----
                                        --count;
                                        ++length;
!                                       if(byteval <= 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character, or the
***************
*** 364,367 ****
--- 364,368 ----
                                                if(count == 0)
                                                {
+                                                       --length;
                                                        continue;
                                                }
***************
*** 374,377 ****
--- 375,379 ----
                                                if(count == 0)
                                                {
+                                                       --length;
                                                        continue;
                                                }
***************
*** 384,387 ****
--- 386,390 ----
                                                if(count <= 1)
                                                {
+                                                       --length;
                                                        count = 0;
                                                        continue;
***************
*** 392,396 ****
                                        else
                                        {
!                                               // Invalid first byte.
                                                continue;
                                        }
--- 395,399 ----
                                        else
                                        {
!                                               // Invalid first byte: map to 
NUL.
                                                continue;
                                        }
***************
*** 448,462 ****
                                                         "chars");
                                        }
!                                       if(byteval == 0x5C)
!                                       {
!                                               // Yen sign.
!                                               chars[posn++] = '\u00A5';
!                                       }
!                                       else if(byteval == 0x7E)
!                                       {
!                                               // Overline symbol.
!                                               chars[posn++] = '\u203E';
!                                       }
!                                       else if(byteval < 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character.
--- 451,455 ----
                                                         "chars");
                                        }
!                                       if(byteval <= 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character.
***************
*** 474,478 ****
                                                else
                                                {
!                                                       byteval = 0;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
--- 467,471 ----
                                                else
                                                {
!                                                       break;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
***************
*** 488,492 ****
                                                        else
                                                        {
!                                                               chars[posn++] = 
'?';
                                                        }
                                                }
--- 481,485 ----
                                                        else
                                                        {
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                }
***************
*** 494,498 ****
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '?';
                                                }
                                        }
--- 487,491 ----
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '\0';
                                                }
                                        }
***************
*** 507,511 ****
                                                else
                                                {
!                                                       byteval = 0;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
--- 500,504 ----
                                                else
                                                {
!                                                       break;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
***************
*** 516,520 ****
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '?';
                                                }
                                        }
--- 509,513 ----
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '\0';
                                                }
                                        }
***************
*** 529,533 ****
                                                else
                                                {
!                                                       byteval = 0;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
--- 522,526 ----
                                                else
                                                {
!                                                       break;
                                                }
                                                if(byteval >= 0xA1 && byteval 
<= 0xFE)
***************
*** 541,545 ****
                                                        else
                                                        {
!                                                               byteval = 0;
                                                        }
                                                        if(byteval >= 0xA1 && 
byteval <= 0xFE)
--- 534,538 ----
                                                        else
                                                        {
!                                                               break;
                                                        }
                                                        if(byteval >= 0xA1 && 
byteval <= 0xFE)
***************
*** 555,559 ****
                                                                else
                                                                {
!                                                                       
chars[posn++] = '?';
                                                                }
                                                        }
--- 548,552 ----
                                                                else
                                                                {
!                                                                       
chars[posn++] = '\0';
                                                                }
                                                        }
***************
*** 561,565 ****
                                                        {
                                                                // Invalid 
third byte.
!                                                               chars[posn++] = 
'?';
                                                        }
                                                }
--- 554,558 ----
                                                        {
                                                                // Invalid 
third byte.
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                }
***************
*** 567,577 ****
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '?';
                                                }
                                        }
                                        else
                                        {
                                                // Invalid first byte.
!                                               chars[posn++] = '?';
                                        }
                                }
--- 560,578 ----
                                                {
                                                        // Invalid second byte.
!                                                       chars[posn++] = '\0';
                                                }
                                        }
+                                       else if(byteval == 0xA0)
+                                       {
+                                               chars[posn++] = '\uF8F0';
+                                       }
+                                       else if(byteval == 0xFF)
+                                       {
+                                               chars[posn++] = '\uF8F3';
+                                       }
                                        else
                                        {
                                                // Invalid first byte.
!                                               chars[posn++] = '\0';
                                        }
                                }
***************
*** 749,753 ****
                                                                last1 = byteval;
                                                        }
!                                                       ++length;
                                                }
                                                else if(last1 == 0x8F)
--- 750,757 ----
                                                                last1 = byteval;
                                                        }
!                                                       else
!                                                       {
!                                                               ++length;
!                                                       }
                                                }
                                                else if(last1 == 0x8F)
***************
*** 770,773 ****
--- 774,778 ----
                                                                last1 = 0;
                                                                last2 = 0;
+                                                               ++length;
                                                        }
                                                }
***************
*** 777,780 ****
--- 782,786 ----
                                                        last1 = 0;
                                                        last2 = 0;
+                                                       ++length;
                                                }
                                        }
***************
*** 838,860 ****
                                                                last1 = byteval;
                                                        }
!                                                       else if(byteval == 0x5C)
                                                        {
!                                                               // Yen sign.
!                                                               chars[posn++] 
='\u00A5';
                                                        }
!                                                       else if(byteval == 0x7E)
                                                        {
!                                                               // Overline 
symbol.
!                                                               chars[posn++] 
='\u203E';
                                                        }
!                                                       else if(byteval < 0x80)
                                                        {
!                                                               // Ordinary 
ASCII/Latin1 character.
!                                                               chars[posn++] = 
(char)byteval;
                                                        }
                                                        else
                                                        {
                                                                // Invalid 
first byte.
!                                                               chars[posn++] = 
'?';
                                                        }
                                                }
--- 844,864 ----
                                                                last1 = byteval;
                                                        }
!                                                       else if(byteval <= 0x80)
                                                        {
!                                                               // Ordinary 
ASCII/Latin1 character.
!                                                               chars[posn++] = 
(char)byteval;
                                                        }
!                                                       else if(byteval == 0xA0)
                                                        {
!                                                               chars[posn++] = 
'\uF8F0';
                                                        }
!                                                       else if(byteval == 0xFF)
                                                        {
!                                                               chars[posn++] = 
'\uF8F3';
                                                        }
                                                        else
                                                        {
                                                                // Invalid 
first byte.
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                }
***************
*** 864,883 ****
                                                        {
                                                                // Second byte 
in a triple-byte sequence.
!                                                               if(byteval < 
0xA1 || byteval > 0xFE)
                                                                {
!                                                                       // 
Invalid second byte.
!                                                                       
chars[posn++] = '?';
!                                                                       last1 = 
0;
!                                                                       
continue;
                                                                }
-                                                               last2 = byteval;
                                                        }
                                                        else
                                                        {
                                                                // Third byte 
in a triple-byte sequence.
!                                                               if(byteval < 
0xA1 || byteval > 0xFE)
                                                                {
                                                                        // 
Invalid second byte.
!                                                                       
chars[posn++] = '?';
                                                                        last1 = 
0;
                                                                        last2 = 
0;
--- 868,895 ----
                                                        {
                                                                // Second byte 
in a triple-byte sequence.
!                                                               if(byteval != 0)
                                                                {
!                                                                       last2 = 
byteval;
!                                                               }
!                                                               else
!                                                               {
!                                                                       last2 = 
1;
                                                                }
                                                        }
                                                        else
                                                        {
                                                                // Third byte 
in a triple-byte sequence.
!                                                               if(last2 < 0xA1 
|| last2 > 0xFE)
                                                                {
                                                                        // 
Invalid second byte.
!                                                                       
chars[posn++] = '\0';
!                                                                       last1 = 
0;
!                                                                       last2 = 
0;
!                                                                       
continue;
!                                                               }
!                                                               if(byteval < 
0xA1 || byteval > 0xFE)
!                                                               {
!                                                                       // 
Invalid third byte.
!                                                                       
chars[posn++] = '\0';
                                                                        last1 = 
0;
                                                                        last2 = 
0;
***************
*** 894,898 ****
                                                                else
                                                                {
!                                                                       
chars[posn++] = '?';
                                                                }
                                                                last1 = 0;
--- 906,910 ----
                                                                else
                                                                {
!                                                                       
chars[posn++] = '\0';
                                                                }
                                                                last1 = 0;
***************
*** 910,914 ****
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'?';
                                                        }
                                                        last1 = 0;
--- 922,926 ----
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                        last1 = 0;
***************
*** 920,924 ****
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'?';
                                                                last1 = 0;
                                                                continue;
--- 932,936 ----
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'\0';
                                                                last1 = 0;
                                                                continue;
***************
*** 934,938 ****
                                                        else
                                                        {
!                                                               chars[posn++] = 
'?';
                                                        }
                                                        last1 = 0;
--- 946,950 ----
                                                        else
                                                        {
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                        last1 = 0;

Index: CP932.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/I18N/CJK/CP932.cs,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -r1.6 -r1.7
*** CP932.cs    13 Aug 2003 04:08:45 -0000      1.6
--- CP932.cs    15 Aug 2003 01:26:36 -0000      1.7
***************
*** 359,363 ****
                                        --count;
                                        ++length;
!                                       if(byteval < 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character, or the
--- 359,363 ----
                                        --count;
                                        ++length;
!                                       if(byteval <= 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character, or the
***************
*** 436,452 ****
                                                         "chars");
                                        }
!                                       if(byteval == 0x5C)
!                                       {
!                                               // Yen sign.
!                                               chars[posn++] = '\u00A5';
!                                               continue;
!                                       }
!                                       else if(byteval == 0x7E)
!                                       {
!                                               // Overline symbol.
!                                               chars[posn++] = '\u203E';
!                                               continue;
!                                       }
!                                       else if(byteval < 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character.
--- 436,440 ----
                                                         "chars");
                                        }
!                                       if(byteval <= 0x80)
                                        {
                                                // Ordinary ASCII/Latin1 
character.
***************
*** 468,475 ****
                                                value = (byteval - 0xE0 + (0xA0 
- 0x81)) * 0xBC;
                                        }
                                        else
                                        {
                                                // Invalid first byte.
!                                               chars[posn++] = '?';
                                                continue;
                                        }
--- 456,473 ----
                                                value = (byteval - 0xE0 + (0xA0 
- 0x81)) * 0xBC;
                                        }
+                                       else if(byteval == 0xA0)
+                                       {
+                                               chars[posn++] = '\uF8F0';
+                                               continue;
+                                       }
+                                       else if(byteval >= 0xFD && byteval <= 
0xFF)
+                                       {
+                                               chars[posn++] = (char)(byteval 
- 0xFD + 0xF8F1);
+                                               continue;
+                                       }
                                        else
                                        {
                                                // Invalid first byte.
!                                               chars[posn++] = '\0';
                                                continue;
                                        }
***************
*** 477,481 ****
                                        {
                                                // Missing second byte.
!                                               chars[posn++] = '?';
                                                continue;
                                        }
--- 475,479 ----
                                        {
                                                // Missing second byte.
!                                               chars[posn++] = '\0';
                                                continue;
                                        }
***************
*** 493,497 ****
                                        {
                                                // Invalid second byte.
!                                               chars[posn++] = '?';
                                                continue;
                                        }
--- 491,495 ----
                                        {
                                                // Invalid second byte.
!                                               chars[posn++] = '\0';
                                                continue;
                                        }
***************
*** 505,509 ****
                                        else
                                        {
!                                               chars[posn++] = '?';
                                        }
                                }
--- 503,507 ----
                                        else
                                        {
!                                               chars[posn++] = '\0';
                                        }
                                }
***************
*** 743,757 ****
                                                                last = byteval;
                                                        }
!                                                       else if(byteval == 0x5C)
!                                                       {
!                                                               // Yen sign.
!                                                               chars[posn++] 
='\u00A5';
!                                                       }
!                                                       else if(byteval == 0x7E)
!                                                       {
!                                                               // Overline 
symbol.
!                                                               chars[posn++] 
='\u203E';
!                                                       }
!                                                       else if(byteval < 0x80)
                                                        {
                                                                // Ordinary 
ASCII/Latin1 character.
--- 741,745 ----
                                                                last = byteval;
                                                        }
!                                                       else if(byteval <= 0x80)
                                                        {
                                                                // Ordinary 
ASCII/Latin1 character.
***************
*** 763,770 ****
                                                                chars[posn++] = 
(char)(byteval - 0xA1 + 0xFF61);
                                                        }
                                                        else
                                                        {
                                                                // Invalid 
first byte.
!                                                               chars[posn++] = 
'?';
                                                        }
                                                }
--- 751,766 ----
                                                                chars[posn++] = 
(char)(byteval - 0xA1 + 0xFF61);
                                                        }
+                                                       else if(byteval == 0xA0)
+                                                       {
+                                                               chars[posn++] = 
'\uF8F0';
+                                                       }
+                                                       else if(byteval >= 0xFD 
&& byteval <= 0xFF)
+                                                       {
+                                                               chars[posn++] = 
(char)(byteval - 0xFD + 0xF8F1);
+                                                       }
                                                        else
                                                        {
                                                                // Invalid 
first byte.
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                }
***************
*** 792,796 ****
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'?';
                                                                continue;
                                                        }
--- 788,792 ----
                                                        {
                                                                // Invalid 
second byte.
!                                                               chars[posn++] = 
'\0';
                                                                continue;
                                                        }
***************
*** 804,808 ****
                                                        else
                                                        {
!                                                               chars[posn++] = 
'?';
                                                        }
                                                }
--- 800,804 ----
                                                        else
                                                        {
!                                                               chars[posn++] = 
'\0';
                                                        }
                                                }





reply via email to

[Prev in Thread] Current Thread [Next in Thread]