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 8860 by zmatsuo, Sat Jul 25 16:00:24 2020 UTC revision 8861 by zmatsuo, Sat Jul 25 16:00:36 2020 UTC
# Line 452  void MoveToMainScreen() Line 452  void MoveToMainScreen()
452          MoveCursor(MainX, MainY); // move to main screen          MoveCursor(MainX, MainY); // move to main screen
453  }  }
454    
455  static void Log1Byte(BYTE b)  /*
456     *      ログに1キャラクタ(BYTE)出力
457     */
458    static void Log1Char(vtterm_work_t *vtterm, char c)
459  {  {
460          LogPut1(b);          switch (vtterm->log_code) {
461          DDEPut1(b);          case 0:
462            default:
463                    // UTF-8
464                    LogPut1(c);
465                    break;
466            case 1:
467                    // UTF-16LE
468                    LogPut1(c);
469                    LogPut1(0);
470                    break;
471            case 2:
472                    // UTF-16LE
473                    LogPut1(0);
474                    LogPut1(c);
475                    break;
476            }
477  }  }
478    
479  static void Log1UTF32(vtterm_work_t *vtterm, unsigned int u32)  /**
480     *      1キャラクタ(unsigned int, char32_t)をログ(or/and macro送信バッファ)へ出力
481     *      New Line 以外
482     */
483    static void OutputLogUTF32WONL(vtterm_work_t *vtterm, unsigned int u32)
484  {  {
485          switch(vtterm->log_code) {          size_t i;
486          default:          BOOL log_available = (cv.HLogBuf != 0);
487          case 0: {  
488                  // UTF-8          if (!DDELog && !log_available) {
489                  char u8[4];                  // ログにも macro にも出力不要
490                  size_t u8_len = UTF32ToUTF8(u32, u8, _countof(u8));                  return;
491                  size_t i;          }
492    
493            // UTF-8 で出力する Log or/and macro
494            if (DDELog || (log_available && vtterm->log_code == 0)) {
495                    char u8_buf[4];
496                    size_t u8_len = UTF32ToUTF8(u32, u8_buf, _countof(u8_buf));
497                  for (i = 0; i < u8_len; i++) {                  for (i = 0; i < u8_len; i++) {
498                          Log1Byte(u8[i]);                          BYTE b = u8_buf[i];
499                            if (DDELog)
500                                    DDEPut1(b);
501                            if (log_available && vtterm->log_code == 0)
502                                    LogPut1(b);
503                  }                  }
504            }
505    
506            if (!log_available) {
507                    // ログには出力しない(macro出力だけだった)
508                    return;
509            }
510    
511            switch(vtterm->log_code) {
512            case 0: {
513                    // UTF-8, 出力済み
514                  break;                  break;
515          }          }
516          case 1:          case 1:
# Line 481  static void Log1UTF32(vtterm_work_t *vtt Line 522  static void Log1UTF32(vtterm_work_t *vtt
522                  for (i = 0; i < u16_len; i++) {                  for (i = 0; i < u16_len; i++) {
523                          if (vtterm->log_code == 1) {                          if (vtterm->log_code == 1) {
524                                  // UTF-16LE                                  // UTF-16LE
525                                  Log1Byte(u16[i] & 0xff);                                  LogPut1(u16[i] & 0xff);
526                                  Log1Byte((u16[i] >> 8) & 0xff);                                  LogPut1((u16[i] >> 8) & 0xff);
527                          }                          }
528                          else {                          else {
529                                  // UTF-16BE                                  // UTF-16BE
530                                  Log1Byte(u16[i] & 0xff);                                  LogPut1(u16[i] & 0xff);
531                                  Log1Byte((u16[i] >> 8) & 0xff);                                  LogPut1((u16[i] >> 8) & 0xff);
532                          }                          }
533                  }                  }
534          }          }
535          }          }
536  }  }
537    
538  static void Log1NewLine(vtterm_work_t *vtterm)  /**
539     *      改行をログ(or/and macro送信バッファ)へ出力
540     *      ログには設定された改行コードを出力
541     *      macro用には CR+LF を出力
542     */
543    static void OutputLogNewLine(vtterm_work_t *vtterm)
544  {  {
545          switch(vtterm->log_cr_type) {          // ログ出力
546          case 0:          if (cv.HLogBuf != 0) {
547                  // CR + LF                  // ログは取っている
548                  Log1UTF32(vtterm, CR);                  switch(vtterm->log_cr_type) {
549                  Log1UTF32(vtterm, LF);                  case 0:
550                  break;                          // CR + LF
551          case 1:                          Log1Char(vtterm, CR);
552                  // CR                          Log1Char(vtterm, LF);
553                  Log1UTF32(vtterm, CR);                          break;
554                  break;                  case 1:
555          case 2:                          // CR
556                  // LF                          Log1Char(vtterm, CR);
557                  Log1UTF32(vtterm, LF);                          break;
558                  break;                  case 2:
559                            // LF
560                            Log1Char(vtterm, LF);
561                            break;
562                    }
563          }          }
564    
565            // マクロ出力
566            DDEPut1(CR);
567            DDEPut1(LF);
568  }  }
569    
570    /**
571     *      1キャラクタ(unsigned int, char32_t)をログ(or/and macro送信バッファ)へ出力
572     */
573  static void OutputLogUTF32(unsigned int u32)  static void OutputLogUTF32(unsigned int u32)
574  {  {
575          vtterm_work_t *vtterm = &vtterm_work;          vtterm_work_t *vtterm = &vtterm_work;
576    
577          if (cv.HLogBuf == 0) {          // 入力が改行(CR or LF)の場合、
578                  // ログは取っていない, 何もしない          // 改行の種類(CR or LF or CR+LF)を自動で判定して
579                  return;          // OutputLogNewLine() で改行を出力する
580          }          //              入力    CR hold     改行出力    CR hold 変更
581            //              +-------+-----------+-----------+------------
582          // 改行コードをチェック          //              CR      なし        しない              セットする
583          //              CR hold         入力    改行出力        CR hold 変更          //              LF      なし        する                変化なし
584          //              ------------+-------+-----------+------------          //              その他  なし        しない              変化なし
585          //              なし            CR              0                       セットする          //              CR      あり        する                変化なし(ホールドしたまま)
586          //              なし            LF              1                       変化なし          //              LF      あり        する                クリアする
587          //              なし            その他  0                       変化なし          //              その他  あり        する                クリアする
         //              あり            CR              1                       変化なし(ホールドしたまま)  
         //              あり            LF              1                       クリアする  
         //              あり            その他  1                       クリアする  
588          if (vtterm->log_cr_hold == FALSE) {          if (vtterm->log_cr_hold == FALSE) {
589                  if (u32 == CR) {                  if (u32 == CR) {
590                          vtterm->log_cr_hold = TRUE;                          vtterm->log_cr_hold = TRUE;
591                          return;                          return;
592                  }                  }
593                  else if (u32 == LF) {                  else if (u32 == LF) {
594                          Log1NewLine(vtterm);                          OutputLogNewLine(vtterm);
595                          return;                          return;
596                  }                  }
597                  else {                  else {
# Line 546  static void OutputLogUTF32(unsigned int Line 600  static void OutputLogUTF32(unsigned int
600          }          }
601          else {          else {
602                  if (u32 == CR) {                  if (u32 == CR) {
603                          Log1NewLine(vtterm);                          OutputLogNewLine(vtterm);
604                          return;                          return;
605                  }                  }
606                  else if (u32 == LF) {                  else if (u32 == LF) {
607                          vtterm->log_cr_hold = FALSE;                          vtterm->log_cr_hold = FALSE;
608                          Log1NewLine(vtterm);                          OutputLogNewLine(vtterm);
609                          return;                          return;
610                  }                  }
611                  else {                  else {
612                          vtterm->log_cr_hold = FALSE;                          vtterm->log_cr_hold = FALSE;
613                          Log1NewLine(vtterm);                          OutputLogNewLine(vtterm);
614                  }                  }
615          }          }
616    
617          Log1UTF32(vtterm, u32);          // 改行以外を出力
618            OutputLogUTF32WONL(vtterm, u32);
619  }  }
620    
621    /**
622     *      1キャラクタ(BYTE)をログ(or/and macro送信バッファ)へ出力
623     */
624  static void OutputLogByte(BYTE b)  static void OutputLogByte(BYTE b)
625  {  {
626          if (cv.HLogBuf!=0) {          OutputLogUTF32(b);
627                  OutputLogUTF32(b);  }
628          }  
629    /**
630     *      ログ(or/and Macro送信バッファ)出力の必要があるか?
631     */
632    static BOOL NeedsOutputBufs(void)
633    {
634            return cv.HLogBuf != 0 || DDELog;
635  }  }
636    
637  void MoveToStatusLine()  void MoveToStatusLine()
# Line 689  void BackSpace() Line 753  void BackSpace()
753          if (CursorX == CursorLeftM || CursorX == 0) {          if (CursorX == CursorLeftM || CursorX == 0) {
754                  if (CursorY > 0 && (ts.TermFlag & TF_BACKWRAP)) {                  if (CursorY > 0 && (ts.TermFlag & TF_BACKWRAP)) {
755                          MoveCursor(CursorRightM, CursorY-1);                          MoveCursor(CursorRightM, CursorY-1);
756                          if (cv.HLogBuf!=0 && !ts.LogTypePlainText) OutputLogByte(BS);                          if (NeedsOutputBufs() && !ts.LogTypePlainText) OutputLogByte(BS);
757                  }                  }
758          }          }
759          else if (CursorX > 0) {          else if (CursorX > 0) {
760                  MoveCursor(CursorX-1, CursorY);                  MoveCursor(CursorX-1, CursorY);
761                  if (cv.HLogBuf!=0 && !ts.LogTypePlainText) OutputLogByte(BS);                  if (NeedsOutputBufs() && !ts.LogTypePlainText) OutputLogByte(BS);
762          }          }
763  }  }
764    
765  static void CarriageReturn(BOOL logFlag)  static void CarriageReturn(BOOL logFlag)
766  {  {
767          if (!ts.EnableContinuedLineCopy || logFlag)          if (!ts.EnableContinuedLineCopy || logFlag)
768                  if (cv.HLogBuf!=0) OutputLogByte(CR);                  if (NeedsOutputBufs()) OutputLogByte(CR);
769    
770          if (RelativeOrgMode || CursorX > CursorLeftM)          if (RelativeOrgMode || CursorX > CursorLeftM)
771                  MoveCursor(CursorLeftM, CursorY);                  MoveCursor(CursorLeftM, CursorY);
# Line 719  static void LineFeed(BYTE b, BOOL logFla Line 783  static void LineFeed(BYTE b, BOOL logFla
783                  BuffDumpCurrentLine(b);                  BuffDumpCurrentLine(b);
784    
785          if (!ts.EnableContinuedLineCopy || logFlag)          if (!ts.EnableContinuedLineCopy || logFlag)
786                  if (cv.HLogBuf!=0) OutputLogByte(LF);                  if (NeedsOutputBufs()) OutputLogByte(LF);
787    
788          if (CursorY < CursorBottom)          if (CursorY < CursorBottom)
789                  MoveCursor(CursorX,CursorY+1);                  MoveCursor(CursorX,CursorY+1);
# Line 745  void Tab() Line 809  void Tab()
809                  Wrap = FALSE;                  Wrap = FALSE;
810          }          }
811          CursorForwardTab(1, AutoWrapMode);          CursorForwardTab(1, AutoWrapMode);
812          if (cv.HLogBuf!=0) OutputLogByte(HT);          if (NeedsOutputBufs()) OutputLogByte(HT);
813  }  }
814    
815  void RepeatChar(BYTE b, int count)  void RepeatChar(BYTE b, int count)
# Line 840  static void PutChar(BYTE b) Line 904  static void PutChar(BYTE b)
904  #endif  #endif
905          }          }
906    
907          if (cv.HLogBuf !=0) {          if (NeedsOutputBufs()) {
908                  // (2005.2.20 yutaka)                  // (2005.2.20 yutaka)
909                  if (ts.LogTypePlainText) {                  if (ts.LogTypePlainText) {
910                          if (__isascii(b) && !isprint(b)) {                          if (__isascii(b) && !isprint(b)) {
# Line 942  static void PutDecSp(BYTE b) Line 1006  static void PutDecSp(BYTE b)
1006                  CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;                  CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
1007          }          }
1008    
1009          if (cv.HLogBuf!=0) OutputLogByte(b);          if (NeedsOutputBufs()) OutputLogByte(b);
1010  /*  /*
1011          if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {          if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
1012                  // ASCII文字で、非表示な文字はログ採取しない。                  // ASCII文字で、非表示な文字はログ採取しない。
1013          } else {          } else {
1014                  if (cv.HLogBuf!=0) OutputLogByte(b);                  if (NeedsOutputBufs()) OutputLogByte(b);
1015          }          }
1016   */   */
1017    
# Line 1037  static void PutKanji(BYTE b) Line 1101  static void PutKanji(BYTE b)
1101    
1102          Wrap = FALSE;          Wrap = FALSE;
1103    
1104          if (cv.HLogBuf!=0) {          if (NeedsOutputBufs()) {
1105                  OutputLogByte(HIBYTE(Kanji));                  OutputLogByte(HIBYTE(Kanji));
1106                  OutputLogByte(LOBYTE(Kanji));                  OutputLogByte(LOBYTE(Kanji));
1107          }          }
Legend:
Removed from v.8860  
changed lines
  Added in v.8861
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help