Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/vtterm.c

Diff of /trunk/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 8750 by zmatsuo, Sun Apr 26 14:35:40 2020 UTC revision 8766 by zmatsuo, Wed May 6 14:52:04 2020 UTC
# Line 63  Line 63 
63    
64  #include "unicode_test.h"  #include "unicode_test.h"
65    
66  void ParseFirst(BYTE b);  static void ParseFirst(BYTE b);
67    
68  #define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))  #define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))
69    
# Line 921  static void PutKanji(BYTE b) Line 921  static void PutKanji(BYTE b)
921                  // codepage一覧                  // codepage一覧
922                  // https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ucoderef/28fefe92-d66c-4b03-90a9-97b473223d43                  // https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ucoderef/28fefe92-d66c-4b03-90a9-97b473223d43
923                  unsigned long u32 = 0;                  unsigned long u32 = 0;
924                  if (ts.Language == IdKorean && ts.CodePage == 51949) {                  switch (ts.Language) {
925  #if 0                  case IdJapanese:
                         unsigned char buf[2];  
                         int ret;  
                         wchar_t wchar;  
                         buf[0] = Kanji >> 8;  
                         buf[1] = Kanji & 0xff;  
                         ret = MultiByteToWideChar(51949, MB_ERR_INVALID_CHARS, (char *)buf, 2, &wchar, 1);  
                         u32 = wchar;  
 #endif  
                         u32 = MBCP_UTF32(Kanji, ts.CodePage);  
                 } else if (ts.Language == IdJapanese && ts.CodePage == 932) {  
926                          // ここに来た時点でCP932になっている                          // ここに来た時点でCP932になっている
                         //} else if (ts.KanjiCode == IdSJIS || ts.KanjiCode == IdEUC || ts.KanjiCode == IdJIS) {  
927                          u32 = CP932ToUTF32(Kanji);                          u32 = CP932ToUTF32(Kanji);
928                  } else {                          break;
929                    case IdKorean:
930                            if (ts.KanjiCode == IdKoreanCP51949) {
931                                    // CP51949
932                                    u32 = MBCP_UTF32(Kanji, 51949);
933                            }
934                            else {
935                                    assert(FALSE);
936                                    goto default_;
937                            }
938                            break;
939                    case IdChinese:
940                            if (ts.KanjiCode == IdCnGB2312) {
941                                    // CP936 GB2312
942                                    u32 = MBCP_UTF32(Kanji, 936);
943                            }
944                            else if (ts.KanjiCode == IdCnBig5) {
945                                    // CP950 Big5
946                                    u32 = MBCP_UTF32(Kanji, 950);
947                            }
948                            else {
949                                    assert(FALSE);
950                                    goto default_;
951                            }
952                            break;
953                    default:
954                    default_:
955                            assert(FALSE);
956                          u32 = MBCP_UTF32(Kanji, ts.CodePage);                          u32 = MBCP_UTF32(Kanji, ts.CodePage);
957                            break;
958                  }                  }
959                  CharAttrTmp.AttrEx = CharAttrTmp.Attr;                  CharAttrTmp.AttrEx = CharAttrTmp.Attr;
960                  BuffPutUnicode(u32, CharAttrTmp, InsertMode);                  BuffPutUnicode(u32, CharAttrTmp, InsertMode);
# Line 5391  void CANSeen(BYTE b) Line 5408  void CANSeen(BYTE b)
5408  }  }
5409    
5410  /**  /**
5411   *      dbcsの1byte目チェック?   *      IsDBCSLeadByteEx() とほぼ同じ
5412     *      ismbblead() の拡張
5413   */   */
5414  static BOOL CheckKanji(BYTE b)  int __ismbblead(BYTE b, int code_page)
5415  {  {
5416          BOOL Check;          switch (code_page) {
5417                    case 932:
5418                            // 日本語 shift jis
5419                            if (((0x81 <= b) && (b <= 0x9f)) || ((0xe0 <= b) && (b <= 0xfc))) {
5420                                    return TRUE;
5421                            }
5422                            return FALSE;
5423                    case 51949:
5424                            // Korean CP51949
5425                            if ((0xA1 <= b) && (b <= 0xFE)) {
5426                                    return TRUE;
5427                            }
5428                            return FALSE;
5429                    case 936:
5430                            // CP936 GB2312
5431                            if ((0xA1 <= b) && (b <= 0xFE)) {
5432                                    return TRUE;
5433                            }
5434                            return FALSE;
5435                    case 950:
5436                            // CP950 Big5
5437                            if (((0xA1 <= b) && (b <= 0xc6)) || ((0xc9 <= b) && (b <= 0xf9))) {
5438                                    return TRUE;
5439                            }
5440                            return FALSE;
5441                    default:
5442                            break;
5443            }
5444            return FALSE;
5445    }
5446    
5447  #if UNICODE_INTERNAL_BUFF  /**
5448          if (ts.CodePage != 932) {   *      ismbbtrail() の拡張
5449                  // TODO ちゃんとチェックする   */
5450                  // IsDBCSLeadByteEx() が妥当?  int __ismbbtrail(BYTE b, int code_page)
5451                  if (ts.CodePage == 936) {  {
5452                          // chs          switch (code_page) {
5453                          return ((0x81 <= b) && (b <= 0xfe));                  case 932:
5454                  }                          if (((0x40 <= b) && (b <= 0x7E)) || ((0x80 <= b) && (b <= 0xFC))) {
5455                  if (ts.CodePage == 950) {                                  return TRUE;
5456                          // cht                          }
5457                          return ((0x88 <= b) && (b <= 0xfe));                          return FALSE;
5458                  }                  case 51949:
5459                            // Korean CP51949
5460                            if ((0xA1 <= b) && (b <= 0xFE)) {
5461                                    return TRUE;
5462                            }
5463                            return FALSE;
5464                    case 936:
5465                            // CP936 GB2312
5466                            if ((0xA1 <= b) && (b <= 0xFE)) {
5467                                    return TRUE;
5468                            }
5469                            return FALSE;
5470                    case 950:
5471                            // CP950 Big5
5472                            if (((0x40 <= b) && (b <= 0x7e)) || ((0xa1 <= b) && (b <= 0xfe))) {
5473                                    return TRUE;
5474                            }
5475                            return FALSE;
5476                    default:
5477                            break;
5478            }
5479            return FALSE;
5480    }
5481    
5482    /**
5483     *      1byte目チェック
5484     */
5485    static BOOL CheckFirstByte(BYTE b, int lang, int kanji_code)
5486    {
5487            switch (lang) {
5488                    case IdKorean:
5489                            return __ismbblead(b, 51949);
5490                    case IdChinese:
5491                            if (kanji_code == IdCnGB2312) {
5492                                    return __ismbblead(b, 936);
5493                            }
5494                            else if (ts.KanjiCode == IdCnBig5) {
5495                                    return __ismbblead(b, 950);
5496                            }
5497                            break;
5498                    default:
5499                            assert(FALSE);
5500                            break;
5501          }          }
5502  #endif          assert(FALSE);
5503            return FALSE;
5504    }
5505    
5506    /**
5507     *      ts.Language == IdJapanese 時
5508     *      1byte目チェック
5509     */
5510    static BOOL CheckKanji(BYTE b)
5511    {
5512            BOOL Check;
5513    
5514          if (ts.Language!=IdJapanese)          if (ts.Language!=IdJapanese)
5515                  return FALSE;                  return FALSE;
5516    
# Line 5449  static BOOL CheckKanji(BYTE b) Line 5548  static BOOL CheckKanji(BYTE b)
5548          return Check;          return Check;
5549  }  }
5550    
 BOOL CheckKorean(BYTE b)  
 {  
         BOOL Check;  
         if (ts.Language!=IdKorean)  
                 return FALSE;  
   
         if (ts.KanjiCode == IdSJIS) {  
                 if ((0xA1<=b) && (b<=0xFE)) {  
                         Check = TRUE;  
                 }  
                 else {  
                         Check = FALSE;  
                 }  
         }  
   
         return Check;  
 }  
   
5551  static BOOL ParseFirstJP(BYTE b)  static BOOL ParseFirstJP(BYTE b)
5552  // returns TRUE if b is processed  // returns TRUE if b is processed
5553  //  (actually allways returns TRUE)  //  (actually allways returns TRUE)
# Line 5617  static BOOL ParseFirstJP(BYTE b) Line 5698  static BOOL ParseFirstJP(BYTE b)
5698          return TRUE;          return TRUE;
5699  }  }
5700    
5701  BOOL ParseFirstKR(BYTE b)  static BOOL ParseFirstKR(BYTE b)
5702  // returns TRUE if b is processed  // returns TRUE if b is processed
5703  //  (actually allways returns TRUE)  //  (actually allways returns TRUE)
5704  {  {
# Line 5640  BOOL ParseFirstKR(BYTE b) Line 5721  BOOL ParseFirstKR(BYTE b)
5721                  }                  }
5722          }          }
5723    
5724          if ((!KanjiIn) && CheckKorean(b)) {          if ((!KanjiIn) && CheckFirstByte(b, ts.Language, ts.KanjiCode)) {
5725                    Kanji = b << 8;
5726                    KanjiIn = TRUE;
5727                    return TRUE;
5728            }
5729    
5730            if (b<=US) {
5731                    ParseControl(b);
5732            }
5733            else if (b==0x20) {
5734                    PutChar(b);
5735            }
5736            else if ((b>=0x21) && (b<=0x7E)) {
5737    //              if (Gn[Glr[0]] == IdKatakana) {
5738    //                      b = b | 0x80;
5739    //              }
5740                    PutChar(b);
5741            }
5742            else if (b==0x7f) {
5743                    return TRUE;
5744            }
5745            else if ((0x80<=b) && (b<=0x9F)) {
5746                    ParseControl(b);
5747            }
5748            else if (b==0xA0) {
5749                    PutChar(0x20);
5750            }
5751            else if ((b>=0xA1) && (b<=0xFE)) {
5752                    if (Gn[Glr[1]] == IdASCII) {
5753                            b = b & 0x7f;
5754                    }
5755                    PutChar(b);
5756            }
5757            else {
5758                    PutChar(b);
5759            }
5760    
5761            return TRUE;
5762    }
5763    
5764    static BOOL ParseFirstCn(BYTE b)
5765    // returns TRUE if b is processed
5766    //  (actually allways returns TRUE)
5767    {
5768            if (KanjiIn) {
5769                    // TODO
5770                    if ((0x40<=b) && (b<=0x7e) ||
5771                        (0xa1<=b) && (b<=0xFE))
5772                    {
5773                            PutKanji(b);
5774                            KanjiIn = FALSE;
5775                            return TRUE;
5776                    }
5777                    else if ((ts.TermFlag & TF_CTRLINKANJI)==0) {
5778                            KanjiIn = FALSE;
5779                    }
5780                    else if ((b==CR) && Wrap) {
5781                            CarriageReturn(FALSE);
5782                            LineFeed(LF,FALSE);
5783                            Wrap = FALSE;
5784                    }
5785            }
5786    
5787            if ((!KanjiIn) && CheckFirstByte(b, ts.Language, ts.KanjiCode)) {
5788                  Kanji = b << 8;                  Kanji = b << 8;
5789                  KanjiIn = TRUE;                  KanjiIn = TRUE;
5790                  return TRUE;                  return TRUE;
# Line 6099  static BOOL ParseFirstRus(BYTE b) Line 6243  static BOOL ParseFirstRus(BYTE b)
6243          return FALSE;          return FALSE;
6244  }  }
6245    
6246  void ParseFirst(BYTE b)  static void ParseFirst(BYTE b)
6247  {  {
6248          switch (ts.Language) {          switch (ts.Language) {
6249            case IdUtf8:            case IdUtf8:
# Line 6144  void ParseFirst(BYTE b) Line 6288  void ParseFirst(BYTE b)
6288                  }                  }
6289                  break;                  break;
6290    
   
6291            case IdRussian:            case IdRussian:
6292                  if (ParseFirstRus(b)) {                  if (ParseFirstRus(b)) {
6293                          return;                          return;
6294                  }                  }
6295                  break;                  break;
6296    
6297            case IdChinese:
6298                    if (ParseFirstCn(b)) {
6299                            return;
6300                    }
6301                    break;
6302          }          }
6303    
6304          if (SSflag) {          if (SSflag) {
Legend:
Removed from v.8750  
changed lines
  Added in v.8766
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help