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 5117 by doda, Mon Feb 4 13:04:22 2013 UTC revision 5118 by doda, Wed Feb 6 03:46:10 2013 UTC
# Line 3291  void ControlSequence(BYTE b) Line 3291  void ControlSequence(BYTE b)
3291          FirstPrm = FALSE;          FirstPrm = FALSE;
3292  }  }
3293    
3294    int CheckUTF8Seq(BYTE b, int utf8_stat)
3295    {
3296            if (ts.Language == IdUtf8 || (ts.Language==IdJapanese && (ts.KanjiCode==IdUTF8 || ts.KanjiCode==IdUTF8m))) {
3297                    if (utf8_stat > 0) {
3298                            if (b >= 0x80 && b < 0xc0) {
3299                                    utf8_stat -= 1;
3300                            }
3301                            else { // Invalid UTF-8 sequence
3302                                    utf8_stat = 0;
3303                            }
3304                    }
3305                    else if (b < 0xc0) {
3306                            ; // nothing to do
3307                    }
3308                    else if (b < 0xe0) { // 2byte sequence
3309                            utf8_stat = 1;
3310                    }
3311                    else if (b < 0xf0) { // 3byte sequence
3312                            utf8_stat = 2;
3313                    }
3314                    else if (b < 0xf8) { // 4byte sequence
3315                            utf8_stat = 3;
3316                    }
3317            }
3318            return utf8_stat;
3319    }
3320    
3321    void IgnoreString(BYTE b)
3322    {
3323            static int utf8_stat = 0;
3324    
3325            if ((ESCFlag && (b=='\\')) ||
3326                (b<=US && b!=ESC && b!=HT) ||
3327                (b==ST && ts.KanjiCode!=IdSJIS && utf8_stat == 0)) {
3328                    ParseMode = ModeFirst;
3329            }
3330    
3331            if (b==ESC) {
3332                    ESCFlag = TRUE;
3333            }
3334            else {
3335                    ESCFlag = FALSE;
3336            }
3337    
3338            utf8_stat = CheckUTF8Seq(b, utf8_stat);
3339    }
3340    
3341  void RequestStatusString(unsigned char *StrBuff, int StrLen)    // DECRQSS  void RequestStatusString(unsigned char *StrBuff, int StrLen)    // DECRQSS
3342  {  {
3343          unsigned char RepStr[256];          unsigned char RepStr[256];
# Line 3448  void DeviceControl(BYTE b) Line 3495  void DeviceControl(BYTE b)
3495          static unsigned char StrBuff[256];          static unsigned char StrBuff[256];
3496          static int DcsParseMode = ModeDcsFirst;          static int DcsParseMode = ModeDcsFirst;
3497          static int StrLen;          static int StrLen;
3498            static int utf8_stat = 0;
3499          static BYTE Cmd;          static BYTE Cmd;
3500    
3501          if ((ESCFlag && (b=='\\')) || (b==ST && ts.KanjiCode!=IdSJIS)) {          if ((ESCFlag && (b=='\\')) || (b==ST && ts.KanjiCode!=IdSJIS && utf8_stat == 0)) {
3502                  if (DcsParseMode == ModeDcsString) {                  if (DcsParseMode == ModeDcsString) {
3503                          StrBuff[StrLen] = 0;                          StrBuff[StrLen] = 0;
3504                          ParseDCS(Cmd, StrBuff, StrLen);                          ParseDCS(Cmd, StrBuff, StrLen);
# Line 3459  void DeviceControl(BYTE b) Line 3507  void DeviceControl(BYTE b)
3507                  ParseMode = ModeFirst;                  ParseMode = ModeFirst;
3508                  DcsParseMode = ModeDcsFirst;                  DcsParseMode = ModeDcsFirst;
3509                  StrLen = 0;                  StrLen = 0;
3510                    utf8_stat = 0;
3511                  return;                  return;
3512          }          }
3513    
3514          if (b==ESC) {          if (b==ESC) {
3515                  ESCFlag = TRUE;                  ESCFlag = TRUE;
3516                    utf8_stat = 0;
3517                  return;                  return;
3518          }          }
3519          else {          else {
3520                  ESCFlag = FALSE;                  ESCFlag = FALSE;
3521          }          }
3522    
3523            utf8_stat = CheckUTF8Seq(b, utf8_stat);
3524    
3525          switch (DcsParseMode) {          switch (DcsParseMode) {
3526          case ModeDcsFirst:          case ModeDcsFirst:
3527                  if (b<=US) {                  if (b<=US) {
# Line 3502  void DeviceControl(BYTE b) Line 3554  void DeviceControl(BYTE b)
3554                  }                  }
3555                  else {                  else {
3556                          ParseMode = ModeSOS;                          ParseMode = ModeSOS;
3557                            utf8_stat = 0;
3558                            IgnoreString(b);
3559                  }                  }
3560                  break;                  break;
3561    
# Line 3521  void DeviceControl(BYTE b) Line 3575  void DeviceControl(BYTE b)
3575    
3576  void DCUserKey(BYTE b)  void DCUserKey(BYTE b)
3577  {  {
3578          if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS)) {          static int utf8_stat = 0;
3579    
3580            if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS && utf8_stat == 0)) {
3581                  if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);                  if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
3582                  ESCFlag = FALSE;                  ESCFlag = FALSE;
3583                  ParseMode = ModeFirst;                  ParseMode = ModeFirst;
# Line 3534  void DCUserKey(BYTE b) Line 3590  void DCUserKey(BYTE b)
3590          }          }
3591          else ESCFlag = FALSE;          else ESCFlag = FALSE;
3592    
3593            utf8_stat = CheckUTF8Seq(b, utf8_stat);
3594    
3595          if (WaitKeyId) {          if (WaitKeyId) {
3596                  if ((b>=0x30) && (b<=0x39)) {                  if ((b>=0x30) && (b<=0x39)) {
3597                          if (NewKeyId<1000)                          if (NewKeyId<1000)
# Line 3567  void DCUserKey(BYTE b) Line 3625  void DCUserKey(BYTE b)
3625          }          }
3626  }  }
3627    
 void IgnoreString(BYTE b)  
 {  
         if ((ESCFlag && (b=='\\')) ||  
             (b<=US && b!=ESC && b!=HT) ||  
             (b==ST && ts.KanjiCode!=IdSJIS)) {  
                 ParseMode = ModeFirst;  
         }  
   
         if (b==ESC) {  
                 ESCFlag = TRUE;  
         }  
         else {  
                 ESCFlag = FALSE;  
         }  
 }  
   
3628  BOOL XsParseColor(char *colspec, COLORREF *color)  BOOL XsParseColor(char *colspec, COLORREF *color)
3629  {  {
3630          unsigned int r, g, b;          unsigned int r, g, b;
# Line 3843  void XsProcClipboard(PCHAR buff) Line 3885  void XsProcClipboard(PCHAR buff)
3885  #define ModeXsColorSpec 4  #define ModeXsColorSpec 4
3886  #define ModeXsEsc       5  #define ModeXsEsc       5
3887  #define ModeXsIgnore    6  #define ModeXsIgnore    6
3888    
3889    #define CheckST(b,uf)   (((b)==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS) && (uf)==0) || (b)==BEL)
3890    
3891  void XSequence(BYTE b)  void XSequence(BYTE b)
3892  {  {
3893          static BYTE XsParseMode = ModeXsFirst, PrevMode;          static BYTE XsParseMode = ModeXsFirst, PrevMode;
3894          static char StrBuff[sizeof(ts.Title)];          static char StrBuff[sizeof(ts.Title)];
3895          static unsigned int ColorNumber, StrLen;          static unsigned int ColorNumber, StrLen;
3896            static int utf8_stat = 0;
3897          static char realloc_failed = FALSE;          static char realloc_failed = FALSE;
3898          char *p;          char *p;
3899          unsigned int new_size;          unsigned int new_size;
3900    
3901          switch (XsParseMode) {          switch (XsParseMode) {
3902            case ModeXsFirst:            case ModeXsFirst:
3903                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */                  if (CheckST(b, utf8_stat)) {
3904                          switch (Param[1]) {                          switch (Param[1]) {
3905                          case 104:                          case 104:
3906                                  DispResetColor(CS_ALL);                                  DispResetColor(CS_ALL);
# Line 3868  void XSequence(BYTE b) Line 3914  void XSequence(BYTE b)
3914                          }                          }
3915                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
3916                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
3917                            utf8_stat = 0;
3918                  }                  }
3919                  else if (b == ESC) { /* Escape */                  else if (b == ESC) { /* Escape */
3920                          PrevMode = ModeXsFirst;                          PrevMode = ModeXsFirst;
3921                          XsParseMode = ModeXsEsc;                          XsParseMode = ModeXsEsc;
3922                            utf8_stat = 0;
3923                  }                  }
3924                  else if (b <= US) { /* Other control character -- invalid sequence */                  else if (b <= US) { /* Other control character -- invalid sequence */
3925                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
3926                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
3927                            utf8_stat = 0;
3928                  }                  }
3929                  else if (isdigit(b)) {                  else if (isdigit(b)) {
3930                          Param[1] = Param[1]*10 + b - '0';                          Param[1] = Param[1]*10 + b - '0';
# Line 3929  void XSequence(BYTE b) Line 3978  void XSequence(BYTE b)
3978                  }                  }
3979                  break;                  break;
3980            case ModeXsString:            case ModeXsString:
3981                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */                  if (CheckST(b, utf8_stat)) {
3982                          switch (Param[1]) {                          switch (Param[1]) {
3983                            case 0: /* Change window title and icon name */                            case 0: /* Change window title and icon name */
3984                            case 1: /* Change icon name */                            case 1: /* Change icon name */
# Line 3952  void XSequence(BYTE b) Line 4001  void XSequence(BYTE b)
4001                          }                          }
4002                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
4003                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4004                            utf8_stat = 0;
4005                  }                  }
4006                  else if (b == ESC) { /* Escape */                  else if (b == ESC) { /* Escape */
4007                          PrevMode = ModeXsString;                          PrevMode = ModeXsString;
4008                          XsParseMode = ModeXsEsc;                          XsParseMode = ModeXsEsc;
4009                            utf8_stat = 0;
4010                  }                  }
4011                  else if (b <= US) { /* Other control character -- invalid sequence */                  else if (b <= US) { /* Other control character -- invalid sequence */
4012                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
4013                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4014                            utf8_stat = 0;
4015                  }                  }
4016                  else if (Param[1] == 52) {                  else {
4017                          if (StrLen < OSCStrBuffSize - 1) {                          utf8_stat = CheckUTF8Seq(b, utf8_stat);
4018                                  OSCStrBuff[StrLen++] = b;                          if (Param[1] == 52) {
4019                          }                                  if (StrLen < OSCStrBuffSize - 1) {
4020                          else if (!realloc_failed && OSCStrBuffSize < MAXOSCBUFFSIZE) {                                          OSCStrBuff[StrLen++] = b;
4021                                  new_size = OSCStrBuffSize * 2;                                  }
4022                                  if (new_size > MAXOSCBUFFSIZE) {                                  else if (!realloc_failed && OSCStrBuffSize < MAXOSCBUFFSIZE) {
4023                                          new_size = MAXOSCBUFFSIZE;                                          new_size = OSCStrBuffSize * 2;
4024                                  }                                          if (new_size > MAXOSCBUFFSIZE) {
4025                                                    new_size = MAXOSCBUFFSIZE;
4026                                            }
4027    
4028                                  p = realloc(OSCStrBuff, new_size);                                          p = realloc(OSCStrBuff, new_size);
4029                                  if (p == NULL) {                                          if (p == NULL) {
4030                                          realloc_failed = TRUE;                                                  realloc_failed = TRUE;
4031                                  }                                          }
4032                                  else {                                          else {
4033                                          OSCStrBuff = p;                                                  OSCStrBuff = p;
4034                                          OSCStrBuffSize = new_size;                                                  OSCStrBuffSize = new_size;
4035                                          if (StrLen < OSCStrBuffSize - 1) {                                                  if (StrLen < OSCStrBuffSize - 1) {
4036                                                  OSCStrBuff[StrLen++] = b;                                                          OSCStrBuff[StrLen++] = b;
4037                                                    }
4038                                          }                                          }
4039                                  }                                  }
4040                          }                          }
4041                  }                          else if (StrLen < sizeof(StrBuff) - 1) {
4042                  else if (StrLen < sizeof(StrBuff) - 1) {                                  StrBuff[StrLen++] = b;
4043                          StrBuff[StrLen++] = b;                          }
4044                  }                  }
4045                  break;                  break;
4046            case ModeXsColorNum:            case ModeXsColorNum:
4047                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */                  if (CheckST(b, utf8_stat)) {
4048                          if (Param[1] == 104 || Param[1] == 105) {                          if (Param[1] == 104 || Param[1] == 105) {
4049                                  XsResetColor(Param[1], ColorNumber);                                  XsResetColor(Param[1], ColorNumber);
4050                          }                          }
4051                          ColorNumber = 0;                          ColorNumber = 0;
4052                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
4053                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4054                            utf8_stat = 0;
4055                  }                  }
4056                  else if (b == ESC) { /* Escape */                  else if (b == ESC) { /* Escape */
4057                          PrevMode = ModeXsColorNum;                          PrevMode = ModeXsColorNum;
4058                          XsParseMode = ModeXsEsc;                          XsParseMode = ModeXsEsc;
4059                            utf8_stat = 0;
4060                  }                  }
4061                  else if (b <= US) { /* Other control character -- invalid sequence */                  else if (b <= US) { /* Other control character -- invalid sequence */
4062                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
4063                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4064                            utf8_stat = 0;
4065                  }                  }
4066                  else if (isdigit(b)) {                  else if (isdigit(b)) {
4067                          ColorNumber = ColorNumber*10 + b - '0';                          ColorNumber = ColorNumber*10 + b - '0';
# Line 4023  void XSequence(BYTE b) Line 4081  void XSequence(BYTE b)
4081                  }                  }
4082                  break;                  break;
4083            case ModeXsColorSpec:            case ModeXsColorSpec:
4084                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */                  if (CheckST(b, utf8_stat)) {
4085                          StrBuff[StrLen] = '\0';                          StrBuff[StrLen] = '\0';
4086                          XsProcColor(Param[1], ColorNumber, StrBuff);                          XsProcColor(Param[1], ColorNumber, StrBuff);
4087                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
# Line 4066  void XSequence(BYTE b) Line 4124  void XSequence(BYTE b)
4124                                  break;                                  break;
4125                          }                          }
4126                  }                  }
4127                    else if (b >= 0x80) {
4128                    }
4129                  else if (StrLen < sizeof(StrBuff) - 1) {                  else if (StrLen < sizeof(StrBuff) - 1) {
4130                          StrBuff[StrLen++] = b;                          StrBuff[StrLen++] = b;
4131                  }                  }
# Line 4080  void XSequence(BYTE b) Line 4140  void XSequence(BYTE b)
4140                          JustAfterESC = TRUE;                          JustAfterESC = TRUE;
4141                          ParseMode = ModeESC;                          ParseMode = ModeESC;
4142                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4143                            utf8_stat = 0;
4144                          EscapeSequence(b);                          EscapeSequence(b);
4145                  }                  }
4146                  break;                  break;
4147            case ModeXsIgnore:            case ModeXsIgnore:
4148                  if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */                  if (CheckST(b, utf8_stat)) {
4149                          ParseMode = ModeFirst;                          ParseMode = ModeFirst;
4150                          XsParseMode = ModeXsFirst;                          XsParseMode = ModeXsFirst;
4151                  }                  }
4152                  else if (b == ESC) {                  else if (b == ESC) {
4153                            utf8_stat = 0;
4154                          PrevMode = ModeXsIgnore;                          PrevMode = ModeXsIgnore;
4155                          XsParseMode = ModeXsEsc;                          XsParseMode = ModeXsEsc;
4156                  }                  }
4157                    else {
4158                            utf8_stat = CheckUTF8Seq(b, utf8_stat);
4159                    }
4160                  break;                  break;
4161          }          }
4162  }  }
Legend:
Removed from v.5117  
changed lines
  Added in v.5118
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help