Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

Contents of /trunk/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3904 - (show annotations) (download) (as text)
Sat May 22 06:57:02 2010 UTC (13 years, 10 months ago) by doda
File MIME type: text/x-csrc
File size: 86299 byte(s) 
ファイル送信も Bracketed Paste Mode の適用対象に。
1 /* Tera Term
2 Copyright(C) 1994-1998 T. Teranishi
3 All rights reserved. */
4
5 /* TERATERM.EXE, VT terminal emulation */
6 #include "teraterm.h"
7 #include "tttypes.h"
8 #include <stdio.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <mbstring.h>
12 #include <locale.h>
13
14 #include "buffer.h"
15 #include "ttwinman.h"
16 #include "ttcommon.h"
17 #include "commlib.h"
18 #include "vtdisp.h"
19 #include "keyboard.h"
20 #include "ttlib.h"
21 #include "ttftypes.h"
22 #include "filesys.h"
23 #include "teraprn.h"
24 #include "telnet.h"
25
26 #include "vtterm.h"
27
28 #define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
29 #define Accept8BitCtrl ((ts.TerminalID>=IdVT220J) && (ts.TermFlag & TF_ACCEPT8BITCTRL))
30
31 /* Parsing modes */
32 #define ModeFirst 0
33 #define ModeESC 1
34 #define ModeDCS 2
35 #define ModeDCUserKey 3
36 #define ModeSOS 4
37 #define ModeCSI 5
38 #define ModeXS 6
39 #define ModeDLE 7
40 #define ModeCAN 8
41
42 #define NParamMax 16
43 #define IntCharMax 5
44
45 void VisualBell();
46
47 /* character attribute */
48 static TCharAttr CharAttr;
49
50 /* various modes of VT emulation */
51 static BOOL RelativeOrgMode;
52 static BOOL InsertMode;
53 static BOOL LFMode;
54 static BOOL AutoWrapMode;
55 static BOOL FocusReportMode;
56 static BOOL AltScr;
57 BOOL BracketedPaste;
58 int MouseReportMode;
59
60 // save/restore cursor
61 typedef struct {
62 int CursorX, CursorY;
63 TCharAttr Attr;
64 int Glr[2], Gn[4]; // G0-G3, GL & GR
65 BOOL AutoWrapMode;
66 BOOL RelativeOrgMode;
67 } TStatusBuff;
68 typedef TStatusBuff *PStatusBuff;
69
70 // status buffer for main screen & status line
71 static TStatusBuff SBuff1, SBuff2, SBuff3;
72
73 static BOOL ESCFlag, JustAfterESC;
74 static BOOL KanjiIn;
75 static BOOL EUCkanaIn, EUCsupIn;
76 static int EUCcount;
77 static BOOL Special;
78
79 static int Param[NParamMax+1];
80 static int NParam;
81 static BOOL FirstPrm;
82 static BYTE IntChar[IntCharMax+1];
83 static int ICount;
84 static BYTE Prv;
85 static int ParseMode, SavedMode;
86 static int ChangeEmu;
87
88 /* user defined keys */
89 static BOOL WaitKeyId, WaitHi;
90
91 /* GL, GR code group */
92 static int Glr[2];
93 /* G0, G1, G2, G3 code group */
94 static int Gn[4];
95 /* GL for single shift 2/3 */
96 static int GLtmp;
97 /* single shift 2/3 flag */
98 static BOOL SSflag;
99 /* JIS -> SJIS conversion flag */
100 static BOOL ConvJIS;
101 static WORD Kanji;
102
103 // variables for status line mode
104 static int StatusX=0;
105 static BOOL StatusWrap=FALSE;
106 static BOOL StatusCursor=TRUE;
107 static int MainX, MainY; //cursor registers
108 static int MainTop, MainBottom; // scroll region registers
109 static BOOL MainWrap;
110 static BOOL MainCursor=TRUE;
111
112 /* status for printer escape sequences */
113 static BOOL PrintEX = TRUE; // printing extent
114 // (TRUE: screen, FALSE: scroll region)
115 static BOOL AutoPrintMode = FALSE;
116 static BOOL PrinterMode = FALSE;
117 static BOOL DirectPrn = FALSE;
118
119 /* User key */
120 static BYTE NewKeyStr[FuncKeyStrMax];
121 static int NewKeyId, NewKeyLen;
122
123 static _locale_t CLocale = NULL;
124
125 void ResetSBuffers()
126 {
127 SBuff1.CursorX = 0;
128 SBuff1.CursorY = 0;
129 SBuff1.Attr = DefCharAttr;
130 if (ts.Language==IdJapanese)
131 {
132 SBuff1.Gn[0] = IdASCII;
133 SBuff1.Gn[1] = IdKatakana;
134 SBuff1.Gn[2] = IdKatakana;
135 SBuff1.Gn[3] = IdKanji;
136 SBuff1.Glr[0] = 0;
137 if ((ts.KanjiCode==IdJIS) &&
138 (ts.JIS7Katakana==0))
139 SBuff1.Glr[1] = 2; // 8-bit katakana
140 else
141 SBuff1.Glr[1] = 3;
142 }
143 else {
144 SBuff1.Gn[0] = IdASCII;
145 SBuff1.Gn[1] = IdSpecial;
146 SBuff1.Gn[2] = IdASCII;
147 SBuff1.Gn[3] = IdASCII;
148 SBuff1.Glr[0] = 0;
149 SBuff1.Glr[1] = 0;
150 }
151 SBuff1.AutoWrapMode = TRUE;
152 SBuff1.RelativeOrgMode = FALSE;
153 // copy SBuff1 to SBuff2
154 SBuff2 = SBuff1;
155 SBuff3 = SBuff1;
156 }
157
158 void ResetTerminal() /*reset variables but don't update screen */
159 {
160 DispReset();
161 BuffReset();
162
163 /* Attribute */
164 CharAttr = DefCharAttr;
165 Special = FALSE;
166 BuffSetCurCharAttr(CharAttr);
167
168 /* Various modes */
169 InsertMode = FALSE;
170 LFMode = (ts.CRSend == IdCRLF);
171 AutoWrapMode = TRUE;
172 AppliKeyMode = FALSE;
173 AppliCursorMode = FALSE;
174 RelativeOrgMode = FALSE;
175 ts.ColorFlag &= ~CF_REVERSEVIDEO;
176 AutoRepeatMode = TRUE;
177 Send8BitMode = ts.Send8BitCtrl;
178 FocusReportMode = FALSE;
179 MouseReportMode = IdMouseTrackNone;
180
181 if (CLocale == NULL) {
182 CLocale = _create_locale(LC_ALL, "C");
183 }
184
185 /* Character sets */
186 ResetCharSet();
187
188 /* ESC flag for device control sequence */
189 ESCFlag = FALSE;
190 /* for TEK sequence */
191 JustAfterESC = FALSE;
192
193 /* Parse mode */
194 ParseMode = ModeFirst;
195
196 /* Clear printer mode */
197 PrinterMode = FALSE;
198
199 // status buffers
200 ResetSBuffers();
201
202 // Alternate Screen Buffer
203 AltScr = FALSE;
204
205 // Bracketed Paste Mode
206 BracketedPaste = FALSE;
207 }
208
209 void ResetCharSet()
210 {
211 if (ts.Language==IdJapanese)
212 {
213 Gn[0] = IdASCII;
214 Gn[1] = IdKatakana;
215 Gn[2] = IdKatakana;
216 Gn[3] = IdKanji;
217 Glr[0] = 0;
218 if ((ts.KanjiCode==IdJIS) &&
219 (ts.JIS7Katakana==0))
220 Glr[1] = 2; // 8-bit katakana
221 else
222 Glr[1] = 3;
223 }
224 else {
225 Gn[0] = IdASCII;
226 Gn[1] = IdSpecial;
227 Gn[2] = IdASCII;
228 Gn[3] = IdASCII;
229 Glr[0] = 0;
230 Glr[1] = 0;
231 cv.SendCode = IdASCII;
232 cv.SendKanjiFlag = FALSE;
233 cv.EchoCode = IdASCII;
234 cv.EchoKanjiFlag = FALSE;
235 }
236 /* Kanji flag */
237 KanjiIn = FALSE;
238 EUCkanaIn = FALSE;
239 EUCsupIn = FALSE;
240 SSflag = FALSE;
241
242 cv.Language = ts.Language;
243 cv.CRSend = ts.CRSend;
244 cv.KanjiCodeEcho = ts.KanjiCode;
245 cv.JIS7KatakanaEcho = ts.JIS7Katakana;
246 cv.KanjiCodeSend = ts.KanjiCodeSend;
247 cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
248 cv.KanjiIn = ts.KanjiIn;
249 cv.KanjiOut = ts.KanjiOut;
250 }
251
252 void ResetKeypadMode(BOOL DisabledModeOnly)
253 {
254 if (!DisabledModeOnly || ts.DisableAppKeypad) AppliKeyMode = FALSE;
255 if (!DisabledModeOnly || ts.DisableAppCursor) AppliCursorMode = FALSE;
256 }
257
258 void MoveToMainScreen()
259 {
260 StatusX = CursorX;
261 StatusWrap = Wrap;
262 StatusCursor = IsCaretEnabled();
263
264 CursorTop = MainTop;
265 CursorBottom = MainBottom;
266 Wrap = MainWrap;
267 DispEnableCaret(MainCursor);
268 MoveCursor(MainX,MainY); // move to main screen
269 }
270
271 void MoveToStatusLine()
272 {
273 MainX = CursorX;
274 MainY = CursorY;
275 MainTop = CursorTop;
276 MainBottom = CursorBottom;
277 MainWrap = Wrap;
278 MainCursor = IsCaretEnabled();
279
280 DispEnableCaret(StatusCursor);
281 MoveCursor(StatusX,NumOfLines-1); // move to status line
282 CursorTop = NumOfLines-1;
283 CursorBottom = CursorTop;
284 Wrap = StatusWrap;
285 }
286
287 void HideStatusLine()
288 {
289 if ((StatusLine>0) &&
290 (CursorY==NumOfLines-1))
291 MoveToMainScreen();
292 StatusX = 0;
293 StatusWrap = FALSE;
294 StatusCursor = TRUE;
295 ShowStatusLine(0); //hide
296 }
297
298 void ChangeTerminalSize(int Nx, int Ny)
299 {
300 BuffChangeTerminalSize(Nx,Ny);
301 StatusX = 0;
302 MainX = 0;
303 MainY = 0;
304 MainTop = 0;
305 MainBottom = NumOfColumns-1;
306 }
307
308 void SendCSIstr(char *str, int len) {
309 if (str == NULL || len <= 0)
310 return;
311
312 if (Send8BitMode)
313 CommBinaryOut(&cv,"\233", 1);
314 else
315 CommBinaryOut(&cv,"\033[", 2);
316
317 CommBinaryOut(&cv, str, len);
318 }
319
320 void SendOSCstr(char *str, int len) {
321 if (str == NULL || len <= 0)
322 return;
323
324 if (Send8BitMode) {
325 CommBinaryOut(&cv,"\235", 1);
326 CommBinaryOut(&cv, str, len);
327 CommBinaryOut(&cv,"\234", 1);
328 }
329 else {
330 CommBinaryOut(&cv,"\033]", 2);
331 CommBinaryOut(&cv, str, len);
332 CommBinaryOut(&cv,"\033\\", 2);
333 }
334
335 }
336
337 void BackSpace()
338 {
339 if (CursorX == 0)
340 {
341 if ((CursorY>0) &&
342 ((ts.TermFlag & TF_BACKWRAP)!=0))
343 {
344 MoveCursor(NumOfColumns-1,CursorY-1);
345 // if (cv.HLogBuf!=0) Log1Byte(BS);
346 // (2005.2.20 yutaka)
347 if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
348 }
349 }
350 else if (CursorX > 0)
351 {
352 MoveCursor(CursorX-1,CursorY);
353 // if (cv.HLogBuf!=0) Log1Byte(BS);
354 // (2005.2.20 yutaka)
355 if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
356 }
357 }
358
359 void CarriageReturn(BOOL logFlag)
360 {
361 #ifndef NO_COPYLINE_FIX
362 if (!ts.EnableContinuedLineCopy || logFlag)
363 #endif /* NO_COPYLINE_FIX */
364 if (cv.HLogBuf!=0) Log1Byte(CR);
365
366 if (CursorX>0)
367 MoveCursor(0,CursorY);
368 }
369
370 void LineFeed(BYTE b, BOOL logFlag)
371 {
372 /* for auto print mode */
373 if ((AutoPrintMode) &&
374 (b>=LF) && (b<=FF))
375 BuffDumpCurrentLine(b);
376
377 #ifndef NO_COPYLINE_FIX
378 if (!ts.EnableContinuedLineCopy || logFlag)
379 #endif /* NO_COPYLINE_FIX */
380 if (cv.HLogBuf!=0) Log1Byte(LF);
381
382 if (CursorY < CursorBottom)
383 MoveCursor(CursorX,CursorY+1);
384 else if (CursorY == CursorBottom) BuffScrollNLines(1);
385 else if (CursorY < NumOfLines-StatusLine-1)
386 MoveCursor(CursorX,CursorY+1);
387
388 #ifndef NO_COPYLINE_FIX
389 ClearLineContinued();
390 #endif /* NO_COPYLINE_FIX */
391
392 if (LFMode) CarriageReturn(logFlag);
393 }
394
395 void Tab()
396 {
397 if (Wrap && !ts.VTCompatTab) {
398 CarriageReturn(FALSE);
399 LineFeed(LF,FALSE);
400 #ifndef NO_COPYLINE_FIX
401 if (ts.EnableContinuedLineCopy) {
402 SetLineContinued();
403 }
404 #endif /* NO_COPYLINE_FIX */
405 Wrap = FALSE;
406 }
407 CursorForwardTab(1, AutoWrapMode);
408 if (cv.HLogBuf!=0) Log1Byte(HT);
409 }
410
411 void PutChar(BYTE b)
412 {
413 BOOL SpecialNew;
414 TCharAttr CharAttrTmp;
415
416 CharAttrTmp = CharAttr;
417
418 if (PrinterMode) { // printer mode
419 WriteToPrnFile(b,TRUE);
420 return;
421 }
422
423 if (Wrap)
424 {
425 CarriageReturn(FALSE);
426 LineFeed(LF,FALSE);
427 #ifndef NO_COPYLINE_FIX
428 CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
429 #endif /* NO_COPYLINE_FIX */
430 }
431
432 // if (cv.HLogBuf!=0) Log1Byte(b);
433 // (2005.2.20 yutaka)
434 if (ts.LogTypePlainText) {
435 if (__isascii(b) && !isprint(b)) {
436 // ASCII�������A���\�������������O�����������B
437 } else {
438 if (cv.HLogBuf!=0) Log1Byte(b);
439 }
440 } else {
441 if (cv.HLogBuf!=0) Log1Byte(b);
442 }
443
444 Wrap = FALSE;
445
446 SpecialNew = FALSE;
447 if ((b>0x5F) && (b<0x80))
448 {
449 if (SSflag)
450 SpecialNew = (Gn[GLtmp]==IdSpecial);
451 else
452 SpecialNew = (Gn[Glr[0]]==IdSpecial);
453 }
454 else if (b>0xDF)
455 {
456 if (SSflag)
457 SpecialNew = (Gn[GLtmp]==IdSpecial);
458 else
459 SpecialNew = (Gn[Glr[1]]==IdSpecial);
460 }
461
462 if (SpecialNew != Special)
463 {
464 UpdateStr();
465 Special = SpecialNew;
466 }
467
468 if (Special)
469 {
470 b = b & 0x7F;
471 CharAttrTmp.Attr |= AttrSpecial;
472 }
473 else
474 CharAttrTmp.Attr |= CharAttr.Attr;
475
476 BuffPutChar(b, CharAttrTmp, InsertMode);
477
478 if (CursorX < NumOfColumns-1)
479 MoveRight();
480 else {
481 UpdateStr();
482 Wrap = AutoWrapMode;
483 }
484 }
485
486 void PutDecSp(BYTE b)
487 {
488 TCharAttr CharAttrTmp;
489
490 CharAttrTmp = CharAttr;
491
492 if (PrinterMode) { // printer mode
493 WriteToPrnFile(b, TRUE);
494 return;
495 }
496
497 if (Wrap) {
498 CarriageReturn(FALSE);
499 LineFeed(LF, FALSE);
500 #ifndef NO_COPYLINE_FIX
501 CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
502 #endif /* NO_COPYLINE_FIX */
503 }
504
505 if (cv.HLogBuf!=0) Log1Byte(b);
506 /*
507 if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
508 // ASCII�������A���\�������������O�����������B
509 } else {
510 if (cv.HLogBuf!=0) Log1Byte(b);
511 }
512 */
513
514 Wrap = FALSE;
515
516 if (!Special) {
517 UpdateStr();
518 Special = TRUE;
519 }
520
521 CharAttrTmp.Attr |= AttrSpecial;
522 BuffPutChar(b, CharAttrTmp, InsertMode);
523
524 if (CursorX < NumOfColumns-1)
525 MoveRight();
526 else {
527 UpdateStr();
528 Wrap = AutoWrapMode;
529 }
530 }
531
532 void PutKanji(BYTE b)
533 {
534 #ifndef NO_COPYLINE_FIX
535 TCharAttr CharAttrTmp;
536
537 CharAttrTmp = CharAttr;
538 #endif /* NO_COPYLINE_FIX */
539 Kanji = Kanji + b;
540
541 if (PrinterMode && DirectPrn)
542 {
543 WriteToPrnFile(HIBYTE(Kanji),FALSE);
544 WriteToPrnFile(LOBYTE(Kanji),TRUE);
545 return;
546 }
547
548 if (ConvJIS)
549 Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));
550
551 if (PrinterMode) { // printer mode
552 WriteToPrnFile(HIBYTE(Kanji),FALSE);
553 WriteToPrnFile(LOBYTE(Kanji),TRUE);
554 return;
555 }
556
557 if (Wrap)
558 {
559 CarriageReturn(FALSE);
560 LineFeed(LF,FALSE);
561 #ifndef NO_COPYLINE_FIX
562 if (ts.EnableContinuedLineCopy)
563 CharAttrTmp.Attr |= AttrLineContinued;
564 #endif /* NO_COPYLINE_FIX */
565 }
566 else if (CursorX > NumOfColumns-2)
567 if (AutoWrapMode)
568 {
569 #ifndef NO_COPYLINE_FIX
570 if (ts.EnableContinuedLineCopy)
571 {
572 CharAttrTmp.Attr |= AttrLineContinued;
573 if (CursorX == NumOfColumns-1)
574 BuffPutChar(0x20, CharAttr, FALSE);
575 }
576 #endif /* NO_COPYLINE_FIX */
577 CarriageReturn(FALSE);
578 LineFeed(LF,FALSE);
579 }
580 else return;
581
582 Wrap = FALSE;
583
584 if (cv.HLogBuf!=0)
585 {
586 Log1Byte(HIBYTE(Kanji));
587 Log1Byte(LOBYTE(Kanji));
588 }
589
590 if (Special)
591 {
592 UpdateStr();
593 Special = FALSE;
594 }
595
596 #ifndef NO_COPYLINE_FIX
597 BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
598 #else
599 BuffPutKanji(Kanji, CharAttr, InsertMode);
600 #endif /* NO_COPYLINE_FIX */
601
602 if (CursorX < NumOfColumns-2)
603 {
604 MoveRight();
605 MoveRight();
606 }
607 else {
608 UpdateStr();
609 Wrap = AutoWrapMode;
610 }
611 }
612
613 void PutDebugChar(BYTE b)
614 {
615 static BYTE buff[3];
616 int i = 0;
617
618 if (DebugFlag!=DEBUG_FLAG_NONE) {
619 InsertMode = FALSE;
620 AutoWrapMode = TRUE;
621
622 if (DebugFlag==DEBUG_FLAG_HEXD) {
623 _snprintf(buff,3,"%02X",(unsigned int) b);
624
625 for (;i<2;i++)
626 PutChar(buff[i]);
627 PutChar(' ');
628 }
629 else if (DebugFlag==DEBUG_FLAG_NORM) {
630
631 if ((b & 0x80) == 0x80)
632 {
633 UpdateStr();
634 CharAttr.Attr = AttrReverse;
635 b = b & 0x7f;
636 }
637
638 if (b<=US)
639 {
640 PutChar('^');
641 PutChar((char)(b+0x40));
642 }
643 else if (b==DEL)
644 {
645 PutChar('<');
646 PutChar('D');
647 PutChar('E');
648 PutChar('L');
649 PutChar('>');
650 }
651 else
652 PutChar(b);
653 }
654
655 if (CharAttr.Attr != AttrDefault)
656 {
657 UpdateStr();
658 CharAttr.Attr = AttrDefault;
659 }
660 }
661 }
662
663 void PrnParseControl(BYTE b) // printer mode
664 {
665 switch (b) {
666 case NUL: return;
667 case SO:
668 if (! DirectPrn)
669 {
670 if ((ts.Language==IdJapanese) &&
671 (ts.KanjiCode==IdJIS) &&
672 (ts.JIS7Katakana==1) &&
673 ((ts.TermFlag & TF_FIXEDJIS)!=0))
674 Gn[1] = IdKatakana;
675 Glr[0] = 1; /* LS1 */
676 return;
677 }
678 break;
679 case SI:
680 if (! DirectPrn)
681 {
682 Glr[0] = 0; /* LS0 */
683 return;
684 }
685 break;
686 case DC1:
687 case DC3: return;
688 case ESC:
689 ICount = 0;
690 JustAfterESC = TRUE;
691 ParseMode = ModeESC;
692 WriteToPrnFile(0,TRUE); // flush prn buff
693 return;
694 case CSI:
695 if (! Accept8BitCtrl) {
696 PutChar(b); /* Disp C1 char in VT100 mode */
697 return;
698 }
699 ICount = 0;
700 FirstPrm = TRUE;
701 NParam = 1;
702 Param[1] = -1;
703 Prv = 0;
704 ParseMode = ModeCSI;
705 WriteToPrnFile(0,TRUE); // flush prn buff
706 WriteToPrnFile(b,FALSE);
707 return;
708 }
709 /* send the uninterpreted character to printer */
710 WriteToPrnFile(b,TRUE);
711 }
712
713 void ParseControl(BYTE b)
714 {
715 if (PrinterMode) { // printer mode
716 PrnParseControl(b);
717 return;
718 }
719
720 if (b>=0x80) /* C1 char */
721 {
722 /* English mode */
723 if (ts.Language==IdEnglish)
724 {
725 if (!Accept8BitCtrl) {
726 PutChar(b); /* Disp C1 char in VT100 mode */
727 return;
728 }
729 }
730 else { /* Japanese mode */
731 if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0)
732 return; /* ignore C1 char */
733 /* C1 chars are interpreted as C0 chars in VT100 mode */
734 if (ts.TerminalID<IdVT220J)
735 b = b & 0x7F;
736 }
737 }
738 switch (b) {
739 /* C0 group */
740 case ENQ:
741 CommBinaryOut(&cv,&(ts.Answerback[0]),ts.AnswerbackLen);
742 break;
743 case BEL:
744 switch (ts.Beep) {
745 case IdBeepOff:
746 /* nothing to do */
747 break;
748 case IdBeepOn:
749 MessageBeep(0);
750 break;
751 case IdBeepVisual:
752 VisualBell();
753 break;
754 }
755 break;
756 case BS: BackSpace(); break;
757 case HT: Tab(); break;
758
759 case LF:
760 // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
761 // CR+LF���������������������B
762 // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
763 // (2007.1.21 yutaka)
764 if (ts.CRReceive == IdLF) {
765 CarriageReturn(TRUE);
766 LineFeed(b, TRUE);
767 break;
768 }
769
770 case VT: LineFeed(b,TRUE); break;
771
772 case FF:
773 if ((ts.AutoWinSwitch>0) && JustAfterESC)
774 {
775 CommInsert1Byte(&cv,b);
776 CommInsert1Byte(&cv,ESC);
777 ChangeEmu = IdTEK; /* Enter TEK Mode */
778 }
779 else
780 LineFeed(b,TRUE);
781 break;
782 case CR:
783 CarriageReturn(TRUE);
784 if (ts.CRReceive==IdCRLF)
785 CommInsert1Byte(&cv,LF);
786 break;
787 case SO:
788 if ((ts.Language==IdJapanese) &&
789 (ts.KanjiCode==IdJIS) &&
790 (ts.JIS7Katakana==1) &&
791 ((ts.TermFlag & TF_FIXEDJIS)!=0))
792 Gn[1] = IdKatakana;
793
794 Glr[0] = 1; /* LS1 */
795 break;
796 case SI: Glr[0] = 0; break; /* LS0 */
797 case DLE:
798 if ((ts.FTFlag & FT_BPAUTO)!=0)
799 ParseMode = ModeDLE; /* Auto B-Plus activation */
800 break;
801 case CAN:
802 if ((ts.FTFlag & FT_ZAUTO)!=0)
803 ParseMode = ModeCAN; /* Auto ZMODEM activation */
804 // else if (ts.AutoWinSwitch>0)
805 // ChangeEmu = IdTEK; /* Enter TEK Mode */
806 else
807 ParseMode = ModeFirst;
808 break;
809 case SUB: ParseMode = ModeFirst; break;
810 case ESC:
811 ICount = 0;
812 JustAfterESC = TRUE;
813 ParseMode = ModeESC;
814 break;
815 case FS:
816 case GS:
817 case RS:
818 case US:
819 if (ts.AutoWinSwitch>0)
820 {
821 CommInsert1Byte(&cv,b);
822 ChangeEmu = IdTEK; /* Enter TEK Mode */
823 }
824 break;
825
826 /* C1 char */
827 case IND: LineFeed(0,TRUE); break;
828 case NEL:
829 LineFeed(0,TRUE);
830 CarriageReturn(TRUE);
831 break;
832 case HTS: SetTabStop(); break;
833 case RI: CursorUpWithScroll(); break;
834 case SS2:
835 GLtmp = 2;
836 SSflag = TRUE;
837 break;
838 case SS3:
839 GLtmp = 3;
840 SSflag = TRUE;
841 break;
842 case DCS:
843 SavedMode = ParseMode;
844 ESCFlag = FALSE;
845 NParam = 1;
846 Param[1] = -1;
847 ParseMode = ModeDCS;
848 break;
849 case SOS:
850 SavedMode = ParseMode;
851 ESCFlag = FALSE;
852 ParseMode = ModeSOS;
853 break;
854 case CSI:
855 ICount = 0;
856 FirstPrm = TRUE;
857 NParam = 1;
858 Param[1] = -1;
859 Prv = 0;
860 ParseMode = ModeCSI;
861 break;
862 case OSC:
863 Param[1] = 0;
864 ParseMode = ModeXS;
865 break;
866 case PM:
867 case APC:
868 SavedMode = ParseMode;
869 ESCFlag = FALSE;
870 ParseMode = ModeSOS;
871 break;
872 }
873 }
874
875 void SaveCursor()
876 {
877 int i;
878 PStatusBuff Buff;
879
880 if ((StatusLine>0) &&
881 (CursorY==NumOfLines-1))
882 Buff = &SBuff2; // for status line
883 else if (AltScr)
884 Buff = &SBuff3; // for alternate screen
885 else
886 Buff = &SBuff1; // for main screen
887
888 Buff->CursorX = CursorX;
889 Buff->CursorY = CursorY;
890 Buff->Attr = CharAttr;
891 Buff->Glr[0] = Glr[0];
892 Buff->Glr[1] = Glr[1];
893 for (i=0 ; i<=3; i++)
894 Buff->Gn[i] = Gn[i];
895 Buff->AutoWrapMode = AutoWrapMode;
896 Buff->RelativeOrgMode = RelativeOrgMode;
897 }
898
899 void RestoreCursor()
900 {
901 int i;
902 PStatusBuff Buff;
903 UpdateStr();
904
905 if ((StatusLine>0) &&
906 (CursorY==NumOfLines-1))
907 Buff = &SBuff2; // for status line
908 else if (AltScr)
909 Buff = &SBuff3; // for alternate screen
910 else
911 Buff = &SBuff1; // for main screen
912
913 if (Buff->CursorX > NumOfColumns-1)
914 Buff->CursorX = NumOfColumns-1;
915 if (Buff->CursorY > NumOfLines-1-StatusLine)
916 Buff->CursorY = NumOfLines-1-StatusLine;
917 MoveCursor(Buff->CursorX,Buff->CursorY);
918 CharAttr = Buff->Attr;
919 Glr[0] = Buff->Glr[0];
920 Glr[1] = Buff->Glr[1];
921 for (i=0 ; i<=3; i++)
922 Gn[i] = Buff->Gn[i];
923 AutoWrapMode = Buff->AutoWrapMode;
924 RelativeOrgMode = Buff->RelativeOrgMode;
925 }
926
927 void AnswerTerminalType()
928 {
929 char Tmp[31];
930
931 if (ts.TerminalID<IdVT320)
932 strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
933 else
934 strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);
935
936 switch (ts.TerminalID) {
937 case IdVT100:
938 strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
939 break;
940 case IdVT100J:
941 strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
942 break;
943 case IdVT101:
944 strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
945 break;
946 case IdVT102:
947 strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
948 break;
949 case IdVT102J:
950 strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
951 break;
952 case IdVT220J:
953 strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
954 break;
955 case IdVT282:
956 strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
957 break;
958 case IdVT320:
959 strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
960 break;
961 case IdVT382:
962 strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
963 break;
964 }
965 strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);
966
967 CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
968 }
969
970 void ESCSpace(BYTE b)
971 {
972 switch (b) {
973 case 'F': Send8BitMode = FALSE; break; // S7C1T
974 case 'G': Send8BitMode = TRUE; break; // S8C1T
975 }
976 }
977
978 void ESCSharp(BYTE b)
979 {
980 switch (b) {
981 case '8': /* Fill screen with "E" */
982 BuffUpdateScroll();
983 BuffFillWithE();
984 MoveCursor(0,0);
985 ParseMode = ModeFirst;
986 break;
987 }
988 }
989
990 /* select double byte code set */
991 void ESCDBCSSelect(BYTE b)
992 {
993 int Dist;
994
995 if (ts.Language!=IdJapanese) return;
996
997 switch (ICount) {
998 case 1:
999 if ((b=='@') || (b=='B'))
1000 {
1001 Gn[0] = IdKanji; /* Kanji -> G0 */
1002 if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
1003 Glr[0] = 0; /* G0->GL */
1004 }
1005 break;
1006 case 2:
1007 /* Second intermediate char must be
1008 '(' or ')' or '*' or '+'. */
1009 Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
1010 if ((b=='1') || (b=='3') ||
1011 (b=='@') || (b=='B'))
1012 {
1013 Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
1014 if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1015 (Dist==0))
1016 Glr[0] = 0; /* G0->GL */
1017 }
1018 break;
1019 }
1020 }
1021
1022 void ESCSelectCode(BYTE b)
1023 {
1024 switch (b) {
1025 case '0':
1026 if (ts.AutoWinSwitch>0)
1027 ChangeEmu = IdTEK; /* enter TEK mode */
1028 break;
1029 }
1030 }
1031
1032 /* select single byte code set */
1033 void ESCSBCSSelect(BYTE b)
1034 {
1035 int Dist;
1036
1037 /* Intermediate char must be
1038 '(' or ')' or '*' or '+'. */
1039 Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */
1040
1041 switch (b) {
1042 case '0': Gn[Dist] = IdSpecial; break;
1043 case '<': Gn[Dist] = IdASCII; break;
1044 case '>': Gn[Dist] = IdASCII; break;
1045 case 'A': Gn[Dist] = IdASCII; break;
1046 case 'B': Gn[Dist] = IdASCII; break;
1047 case 'H': Gn[Dist] = IdASCII; break;
1048 case 'I':
1049 if (ts.Language==IdJapanese)
1050 Gn[Dist] = IdKatakana;
1051 break;
1052 case 'J': Gn[Dist] = IdASCII; break;
1053 }
1054
1055 if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1056 (Dist==0))
1057 Glr[0] = 0; /* G0->GL */
1058 }
1059
1060 void PrnParseEscape(BYTE b) // printer mode
1061 {
1062 int i;
1063
1064 ParseMode = ModeFirst;
1065 switch (ICount) {
1066 /* no intermediate char */
1067 case 0:
1068 switch (b) {
1069 case '[': /* CSI */
1070 ICount = 0;
1071 FirstPrm = TRUE;
1072 NParam = 1;
1073 Param[1] = -1;
1074 Prv = 0;
1075 WriteToPrnFile(ESC,FALSE);
1076 WriteToPrnFile('[',FALSE);
1077 ParseMode = ModeCSI;
1078 return;
1079 } /* end of case Icount=0 */
1080 break;
1081 /* one intermediate char */
1082 case 1:
1083 switch (IntChar[1]) {
1084 case '$':
1085 if (! DirectPrn)
1086 {
1087 ESCDBCSSelect(b);
1088 return;
1089 }
1090 break;
1091 case '(':
1092 case ')':
1093 case '*':
1094 case '+':
1095 if (! DirectPrn)
1096 {
1097 ESCSBCSSelect(b);
1098 return;
1099 }
1100 break;
1101 }
1102 break;
1103 /* two intermediate char */
1104 case 2:
1105 if ((! DirectPrn) &&
1106 (IntChar[1]=='$') &&
1107 ('('<=IntChar[2]) &&
1108 (IntChar[2]<='+'))
1109 {
1110 ESCDBCSSelect(b);
1111 return;
1112 }
1113 break;
1114 }
1115 // send the uninterpreted sequence to printer
1116 WriteToPrnFile(ESC,FALSE);
1117 for (i=1; i<=ICount; i++)
1118 WriteToPrnFile(IntChar[i],FALSE);
1119 WriteToPrnFile(b,TRUE);
1120 }
1121
1122 void ParseEscape(BYTE b) /* b is the final char */
1123 {
1124 if (PrinterMode) { // printer mode
1125 PrnParseEscape(b);
1126 return;
1127 }
1128
1129 switch (ICount) {
1130 /* no intermediate char */
1131 case 0:
1132 switch (b) {
1133 case '7': SaveCursor(); break;
1134 case '8': RestoreCursor(); break;
1135 case '=': AppliKeyMode = TRUE; break;
1136 case '>': AppliKeyMode = FALSE; break;
1137 case 'D': /* IND */
1138 LineFeed(0,TRUE);
1139 break;
1140 case 'E': /* NEL */
1141 MoveCursor(0,CursorY);
1142 LineFeed(0,TRUE);
1143 break;
1144 case 'H': /* HTS */
1145 SetTabStop();
1146 break;
1147 case 'M': /* RI */
1148 CursorUpWithScroll();
1149 break;
1150 case 'N': /* SS2 */
1151 GLtmp = 2;
1152 SSflag = TRUE;
1153 break;
1154 case 'O': /* SS3 */
1155 GLtmp = 3;
1156 SSflag = TRUE;
1157 break;
1158 case 'P': /* DCS */
1159 SavedMode = ParseMode;
1160 ESCFlag = FALSE;
1161 NParam = 1;
1162 Param[1] = -1;
1163 ParseMode = ModeDCS;
1164 return;
1165 case 'X': /* SOS */
1166 SavedMode = ParseMode;
1167 ESCFlag = FALSE;
1168 ParseMode = ModeSOS;
1169 return;
1170 case 'Z': AnswerTerminalType(); break;
1171 case '[': /* CSI */
1172 ICount = 0;
1173 FirstPrm = TRUE;
1174 NParam = 1;
1175 Param[1] = -1;
1176 Prv = 0;
1177 ParseMode = ModeCSI;
1178 return;
1179 case '\\': break; /* ST */
1180 case ']': /* XTERM sequence (OSC) */
1181 NParam = 1;
1182 Param[1] = 0;
1183 ParseMode = ModeXS;
1184 return;
1185 case '^':
1186 case '_': /* PM, APC */
1187 SavedMode = ParseMode;
1188 ESCFlag = FALSE;
1189 ParseMode = ModeSOS;
1190 return;
1191 case 'c': /* Hardware reset */
1192 HideStatusLine();
1193 ResetTerminal();
1194 ClearUserKey();
1195 ClearBuffer();
1196 if (ts.PortType==IdSerial) // reset serial port
1197 CommResetSerial(&ts, &cv, TRUE);
1198 break;
1199 case 'g': /* Visual Bell (screen original?) */
1200 VisualBell();
1201 break;
1202 case 'n': Glr[0] = 2; break; /* LS2 */
1203 case 'o': Glr[0] = 3; break; /* LS3 */
1204 case '|': Glr[1] = 3; break; /* LS3R */
1205 case '}': Glr[1] = 2; break; /* LS2R */
1206 case '~': Glr[1] = 1; break; /* LS1R */
1207 } /* end of case Icount=0 */
1208 break;
1209 /* one intermediate char */
1210 case 1:
1211 switch (IntChar[1]) {
1212 case ' ': ESCSpace(b); break;
1213 case '#': ESCSharp(b); break;
1214 case '$': ESCDBCSSelect(b); break;
1215 case '%': break;
1216 case '(':
1217 case ')':
1218 case '*':
1219 case '+':
1220 ESCSBCSSelect(b);
1221 break;
1222 }
1223 break;
1224 /* two intermediate char */
1225 case 2:
1226 if ((IntChar[1]=='$') &&
1227 ('('<=IntChar[2]) &&
1228 (IntChar[2]<='+'))
1229 ESCDBCSSelect(b);
1230 else if ((IntChar[1]=='%') &&
1231 (IntChar[2]=='!'))
1232 ESCSelectCode(b);
1233 break;
1234 }
1235 ParseMode = ModeFirst;
1236 }
1237
1238 void EscapeSequence(BYTE b)
1239 {
1240 if (b<=US)
1241 ParseControl(b);
1242 else if ((b>=0x20) && (b<=0x2F))
1243 {
1244 if (ICount<IntCharMax) ICount++;
1245 IntChar[ICount] = b;
1246 }
1247 else if ((b>=0x30) && (b<=0x7E))
1248 ParseEscape(b);
1249 else if ((b>=0x80) && (b<=0x9F))
1250 ParseControl(b);
1251
1252 JustAfterESC = FALSE;
1253 }
1254
1255 void CSInsertCharacter()
1256 {
1257 // Insert space characters at cursor
1258 int Count;
1259
1260 BuffUpdateScroll();
1261 if (Param[1]<1) Param[1] = 1;
1262 Count = Param[1];
1263 BuffInsertSpace(Count);
1264 }
1265
1266 void CSCursorUp()
1267 {
1268 if (Param[1]<1) Param[1] = 1;
1269
1270 if (CursorY >= CursorTop)
1271 {
1272 if (CursorY-Param[1] > CursorTop)
1273 MoveCursor(CursorX,CursorY-Param[1]);
1274 else
1275 MoveCursor(CursorX,CursorTop);
1276 }
1277 else {
1278 if (CursorY > 0)
1279 MoveCursor(CursorX,CursorY-Param[1]);
1280 else
1281 MoveCursor(CursorX,0);
1282 }
1283 }
1284
1285 void CSCursorUp1()
1286 {
1287 MoveCursor(0,CursorY);
1288 CSCursorUp();
1289 }
1290
1291 void CSCursorDown()
1292 {
1293 if (Param[1]<1) Param[1] = 1;
1294
1295 if (CursorY <= CursorBottom)
1296 {
1297 if (CursorY+Param[1] < CursorBottom)
1298 MoveCursor(CursorX,CursorY+Param[1]);
1299 else
1300 MoveCursor(CursorX,CursorBottom);
1301 }
1302 else {
1303 if (CursorY < NumOfLines-StatusLine-1)
1304 MoveCursor(CursorX,CursorY+Param[1]);
1305 else
1306 MoveCursor(CursorX,NumOfLines-StatusLine);
1307 }
1308 }
1309
1310 void CSCursorDown1()
1311 {
1312 MoveCursor(0,CursorY);
1313 CSCursorDown();
1314 }
1315
1316 void CSScreenErase()
1317 {
1318 if (Param[1] == -1) Param[1] = 0;
1319 BuffUpdateScroll();
1320 switch (Param[1]) {
1321 case 0:
1322 // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
1323 // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
1324 // �����������������B(2005.5.29 yutaka)
1325 // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
1326 if (ts.ScrollWindowClearScreen &&
1327 (CursorX == 0 && CursorY == 0)) {
1328 // Erase screen (scroll out)
1329 BuffClearScreen();
1330 UpdateWindow(HVTWin);
1331
1332 } else {
1333 // Erase characters from cursor to the end of screen
1334 BuffEraseCurToEnd();
1335 }
1336 break;
1337
1338 case 1:
1339 // Erase characters from home to cursor
1340 BuffEraseHomeToCur();
1341 break;
1342
1343 case 2:
1344 // Erase screen (scroll out)
1345 BuffClearScreen();
1346 UpdateWindow(HVTWin);
1347 break;
1348 }
1349 }
1350
1351 void CSInsertLine()
1352 {
1353 // Insert lines at current position
1354 int Count, YEnd;
1355
1356 if (CursorY < CursorTop) return;
1357 if (CursorY > CursorBottom) return;
1358 if (Param[1]<1) Param[1] = 1;
1359 Count = Param[1];
1360
1361 YEnd = CursorBottom;
1362 if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1363 if (Count > YEnd+1 - CursorY) Count = YEnd+1 - CursorY;
1364
1365 BuffInsertLines(Count,YEnd);
1366 }
1367
1368 void CSLineErase()
1369 {
1370 if (Param[1] == -1) Param[1] = 0;
1371 BuffUpdateScroll();
1372 switch (Param[1]) {
1373 /* erase char from cursor to end of line */
1374 case 0:
1375 BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1376 break;
1377 /* erase char from start of line to cursor */
1378 case 1:
1379 BuffEraseCharsInLine(0,CursorX+1);
1380 break;
1381 /* erase entire line */
1382 case 2:
1383 BuffEraseCharsInLine(0,NumOfColumns);
1384 break;
1385 }
1386 }
1387
1388 void CSDeleteNLines()
1389 // Delete lines from current line
1390 {
1391 int Count, YEnd;
1392
1393 if (CursorY < CursorTop) return;
1394 if (CursorY > CursorBottom) return;
1395 Count = Param[1];
1396 if (Count<1) Count = 1;
1397
1398 YEnd = CursorBottom;
1399 if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1400 if (Count > YEnd+1-CursorY) Count = YEnd+1-CursorY;
1401 BuffDeleteLines(Count,YEnd);
1402 }
1403
1404 void CSDeleteCharacter()
1405 {
1406 // Delete characters in current line from cursor
1407
1408 if (Param[1]<1) Param[1] = 1;
1409 BuffUpdateScroll();
1410 BuffDeleteChars(Param[1]);
1411 }
1412
1413 void CSEraseCharacter()
1414 {
1415 if (Param[1]<1) Param[1] = 1;
1416 BuffUpdateScroll();
1417 BuffEraseChars(Param[1]);
1418 }
1419
1420 void CSScrollUP()
1421 {
1422 if (Param[1]<1) Param[1] = 1;
1423 BuffUpdateScroll();
1424 BuffRegionScrollUpNLines(Param[1]);
1425 }
1426
1427 void CSScrollDown()
1428 {
1429 if (Param[1]<1) Param[1] = 1;
1430 BuffUpdateScroll();
1431 BuffRegionScrollDownNLines(Param[1]);
1432 }
1433
1434 void CSForwardTab()
1435 {
1436 if (Param[1]<1) Param[1] = 1;
1437 CursorForwardTab(Param[1], AutoWrapMode);
1438 }
1439
1440 void CSBackwardTab()
1441 {
1442 if (Param[1]<1) Param[1] = 1;
1443 CursorBackwardTab(Param[1]);
1444 }
1445
1446 void CSMoveToColumnN()
1447 {
1448 if (Param[1]<1) Param[1] = 1;
1449 Param[1]--;
1450 if (Param[1] < 0) Param[1] = 0;
1451 if (Param[1] > NumOfColumns-1) Param[1] = NumOfColumns-1;
1452 MoveCursor(Param[1],CursorY);
1453 }
1454
1455 void CSCursorRight()
1456 {
1457 if (Param[1]<1) Param[1] = 1;
1458 if (CursorX + Param[1] > NumOfColumns-1)
1459 MoveCursor(NumOfColumns-1,CursorY);
1460 else
1461 MoveCursor(CursorX+Param[1],CursorY);
1462 }
1463
1464 void CSCursorLeft()
1465 {
1466 if (Param[1]<1) Param[1] = 1;
1467 if (CursorX-Param[1] < 0)
1468 MoveCursor(0,CursorY);
1469 else
1470 MoveCursor(CursorX-Param[1],CursorY);
1471 }
1472
1473 void CSMoveToLineN()
1474 {
1475 if (Param[1]<1) Param[1] = 1;
1476 if (RelativeOrgMode)
1477 {
1478 if (CursorTop+Param[1]-1 > CursorBottom)
1479 MoveCursor(CursorX,CursorBottom);
1480 else
1481 MoveCursor(CursorX,CursorTop+Param[1]-1);
1482 }
1483 else {
1484 if (Param[1] > NumOfLines-StatusLine)
1485 MoveCursor(CursorX,NumOfLines-1-StatusLine);
1486 else
1487 MoveCursor(CursorX,Param[1]-1);
1488 }
1489 }
1490
1491 void CSMoveToXY()
1492 {
1493 int NewX, NewY;
1494
1495 if (Param[1]<1) Param[1] = 1;
1496 if ((NParam < 2) || (Param[2]<1)) Param[2] = 1;
1497 NewX = Param[2] - 1;
1498 if (NewX > NumOfColumns-1) NewX = NumOfColumns-1;
1499
1500 if ((StatusLine>0) && (CursorY==NumOfLines-1))
1501 NewY = CursorY;
1502 else if (RelativeOrgMode)
1503 {
1504 NewY = CursorTop + Param[1] - 1;
1505 if (NewY > CursorBottom) NewY = CursorBottom;
1506 }
1507 else {
1508 NewY = Param[1] - 1;
1509 if (NewY > NumOfLines-1-StatusLine)
1510 NewY = NumOfLines-1-StatusLine;
1511 }
1512 MoveCursor(NewX,NewY);
1513 }
1514
1515 void CSDeleteTabStop()
1516 {
1517 if (Param[1]==-1) Param[1] = 0;
1518 ClearTabStop(Param[1]);
1519 }
1520
1521 void CS_h_Mode() // SM
1522 {
1523 switch (Param[1]) {
1524 case 2: // KAM
1525 KeybEnabled = FALSE; break;
1526 case 4: // IRM
1527 InsertMode = TRUE; break;
1528 case 12: // SRM
1529 ts.LocalEcho = 0;
1530 if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1531 TelChangeEcho();
1532 break;
1533 case 20: // LF/NL
1534 LFMode = TRUE;
1535 ts.CRSend = IdCRLF;
1536 cv.CRSend = IdCRLF;
1537 break;
1538 case 33: // WYSTCURM
1539 if (ts.WindowFlag & WF_CURSORCHANGE) {
1540 ts.NonblinkingCursor = TRUE;
1541 ChangeCaret();
1542 }
1543 break;
1544 case 34: // WYULCURM
1545 if (ts.WindowFlag & WF_CURSORCHANGE) {
1546 ts.CursorShape = IdHCur;
1547 ChangeCaret();
1548 }
1549 break;
1550 }
1551 }
1552
1553 void CS_i_Mode() // MC
1554 {
1555 if (Param[1]==-1) Param[1] = 0;
1556 switch (Param[1]) {
1557 /* print screen */
1558 // PrintEX -- TRUE: print screen
1559 // FALSE: scroll region
1560 case 0: BuffPrint(! PrintEX); break;
1561 /* printer controller mode off */
1562 case 4: break; /* See PrnParseCS() */
1563 /* printer controller mode on */
1564 case 5:
1565 if (! AutoPrintMode)
1566 OpenPrnFile();
1567 DirectPrn = (ts.PrnDev[0]!=0);
1568 PrinterMode = TRUE;
1569 break;
1570 }
1571 }
1572
1573 void CS_l_Mode() // RM
1574 {
1575 switch (Param[1]) {
1576 case 2: // KAM
1577 KeybEnabled = TRUE; break;
1578 case 4: // IRM
1579 InsertMode = FALSE; break;
1580 case 12: // SRM
1581 ts.LocalEcho = 1;
1582 if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1583 TelChangeEcho();
1584 break;
1585 case 20: // LF/NL
1586 LFMode = FALSE;
1587 ts.CRSend = IdCR;
1588 cv.CRSend = IdCR;
1589 break;
1590 case 33: // WYSTCURM
1591 if (ts.WindowFlag & WF_CURSORCHANGE) {
1592 ts.NonblinkingCursor = FALSE;
1593 ChangeCaret();
1594 }
1595 break;
1596 case 34: // WYULCURM
1597 if (ts.WindowFlag & WF_CURSORCHANGE) {
1598 ts.CursorShape = IdBlkCur;
1599 ChangeCaret();
1600 }
1601 break;
1602 }
1603 }
1604
1605 void CS_n_Mode() // DSR
1606 {
1607 char Report[16];
1608 int Y, len;
1609
1610 switch (Param[1]) {
1611 case 5:
1612 /* Device Status Report -> Ready */
1613 SendCSIstr("0n", 2);
1614 break;
1615 case 6:
1616 /* Cursor Position Report */
1617 Y = CursorY+1;
1618 if ((StatusLine>0) &&
1619 (Y==NumOfLines))
1620 Y = 1;
1621 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%u;%uR", CLocale, Y, CursorX+1);
1622 SendCSIstr(Report, len);
1623 break;
1624 }
1625 }
1626
1627 void CSSetAttr() // SGR
1628 {
1629 int i, P;
1630
1631 UpdateStr();
1632 for (i=1 ; i<=NParam ; i++)
1633 {
1634 P = Param[i];
1635 if (P<0) P = 0;
1636 switch (P) {
1637 case 0: /* Clear all */
1638 CharAttr = DefCharAttr;
1639 BuffSetCurCharAttr(CharAttr);
1640 break;
1641
1642 case 1: /* Bold */
1643 CharAttr.Attr |= AttrBold;
1644 BuffSetCurCharAttr(CharAttr);
1645 break;
1646
1647 case 4: /* Under line */
1648 CharAttr.Attr |= AttrUnder;
1649 BuffSetCurCharAttr(CharAttr);
1650 break;
1651
1652 case 5: /* Blink */
1653 CharAttr.Attr |= AttrBlink;
1654 BuffSetCurCharAttr(CharAttr);
1655 break;
1656
1657 case 7: /* Reverse */
1658 CharAttr.Attr |= AttrReverse;
1659 BuffSetCurCharAttr(CharAttr);
1660 break;
1661
1662 case 22: /* Bold off */
1663 CharAttr.Attr &= ~ AttrBold;
1664 BuffSetCurCharAttr(CharAttr);
1665 break;
1666
1667 case 24: /* Under line off */
1668 CharAttr.Attr &= ~ AttrUnder;
1669 BuffSetCurCharAttr(CharAttr);
1670 break;
1671
1672 case 25: /* Blink off */
1673 CharAttr.Attr &= ~ AttrBlink;
1674 BuffSetCurCharAttr(CharAttr);
1675 break;
1676
1677 case 27: /* Reverse off */
1678 CharAttr.Attr &= ~ AttrReverse;
1679 BuffSetCurCharAttr(CharAttr);
1680 break;
1681
1682 case 30:
1683 case 31:
1684 case 32:
1685 case 33:
1686 case 34:
1687 case 35:
1688 case 36:
1689 case 37: /* text color */
1690 CharAttr.Attr2 |= Attr2Fore;
1691 CharAttr.Fore = P - 30;
1692 BuffSetCurCharAttr(CharAttr);
1693 break;
1694
1695 case 38: /* text color (256color mode) */
1696 if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1697 i++;
1698 if (i < NParam) {
1699 P = Param[++i];
1700 if (P<0) {
1701 P = 0;
1702 }
1703 CharAttr.Attr2 |= Attr2Fore;
1704 CharAttr.Fore = P;
1705 BuffSetCurCharAttr(CharAttr);
1706 }
1707 }
1708 break;
1709
1710 case 39: /* Reset text color */
1711 CharAttr.Attr2 &= ~ Attr2Fore;
1712 CharAttr.Fore = AttrDefaultFG;
1713 BuffSetCurCharAttr(CharAttr);
1714 break;
1715
1716 case 40:
1717 case 41:
1718 case 42:
1719 case 43:
1720 case 44:
1721 case 45:
1722 case 46:
1723 case 47: /* Back color */
1724 CharAttr.Attr2 |= Attr2Back;
1725 CharAttr.Back = P - 40;
1726 BuffSetCurCharAttr(CharAttr);
1727 break;
1728
1729 case 48: /* Back color (256color mode) */
1730 if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1731 i++;
1732 if (i < NParam) {
1733 P = Param[++i];
1734 if (P<0) {
1735 P = 0;
1736 }
1737 CharAttr.Attr2 |= Attr2Back;
1738 CharAttr.Back = P;
1739 BuffSetCurCharAttr(CharAttr);
1740 }
1741 }
1742 break;
1743
1744 case 49: /* Reset back color */
1745 CharAttr.Attr2 &= ~ Attr2Back;
1746 CharAttr.Back = AttrDefaultBG;
1747 BuffSetCurCharAttr(CharAttr);
1748 break;
1749
1750 case 90:
1751 case 91:
1752 case 92:
1753 case 93:
1754 case 94:
1755 case 95:
1756 case 96:
1757 case 97: /* aixterm style text color */
1758 if (ts.ColorFlag & CF_AIXTERM16) {
1759 CharAttr.Attr2 |= Attr2Fore;
1760 CharAttr.Fore = P - 90 + 8;
1761 BuffSetCurCharAttr(CharAttr);
1762 }
1763 break;
1764
1765 case 100:
1766 if (! (ts.ColorFlag & CF_AIXTERM16)) {
1767 /* Reset text and back color */
1768 CharAttr.Attr2 &= ~ (Attr2Fore | Attr2Back);
1769 CharAttr.Fore = AttrDefaultFG;
1770 CharAttr.Back = AttrDefaultBG;
1771 BuffSetCurCharAttr(CharAttr);
1772 break;
1773 }
1774 /* fall through to aixterm style back color */
1775
1776 case 101:
1777 case 102:
1778 case 103:
1779 case 104:
1780 case 105:
1781 case 106:
1782 case 107: /* aixterm style back color */
1783 if (ts.ColorFlag & CF_AIXTERM16) {
1784 CharAttr.Attr2 |= Attr2Back;
1785 CharAttr.Back = P - 100 + 8;
1786 BuffSetCurCharAttr(CharAttr);
1787 }
1788 break;
1789 }
1790 }
1791 }
1792
1793 void CSSetScrollRegion()
1794 {
1795 if ((StatusLine>0) &&
1796 (CursorY==NumOfLines-1))
1797 {
1798 MoveCursor(0,CursorY);
1799 return;
1800 }
1801 if (Param[1]<1) Param[1] =1;
1802 if ((NParam < 2) | (Param[2]<1))
1803 Param[2] = NumOfLines-StatusLine;
1804 Param[1]--;
1805 Param[2]--;
1806 if (Param[1] > NumOfLines-1-StatusLine)
1807 Param[1] = NumOfLines-1-StatusLine;
1808 if (Param[2] > NumOfLines-1-StatusLine)
1809 Param[2] = NumOfLines-1-StatusLine;
1810 if (Param[1] >= Param[2]) return;
1811 CursorTop = Param[1];
1812 CursorBottom = Param[2];
1813 if (RelativeOrgMode) MoveCursor(0,CursorTop);
1814 else MoveCursor(0,0);
1815 }
1816
1817 void CSSunSequence() /* Sun terminal private sequences */
1818 {
1819 int x, y, len;
1820 char Report[TitleBuffSize*2+10];
1821
1822 switch (Param[1]) {
1823 case 1: // De-iconify window
1824 if (ts.WindowFlag & WF_WINDOWCHANGE)
1825 DispShowWindow(WINDOW_RESTORE);
1826 break;
1827 case 2: // Iconify window
1828 if (ts.WindowFlag & WF_WINDOWCHANGE)
1829 DispShowWindow(WINDOW_MINIMIZE);
1830 break;
1831 case 3: // set window position
1832 if (ts.WindowFlag & WF_WINDOWCHANGE) {
1833 if (NParam < 2) Param[2] = 0;
1834 if (NParam < 3) Param[3] = 0;
1835 DispMoveWindow(Param[2], Param[3]);
1836 }
1837 break;
1838 case 4: // set window size
1839 if (ts.WindowFlag & WF_WINDOWCHANGE) {
1840 if (NParam < 2) Param[2] = 0;
1841 if (NParam < 3) Param[3] = 0;
1842 DispResizeWin(Param[3], Param[2]);
1843 }
1844 break;
1845 case 5: // Raise window
1846 if (ts.WindowFlag & WF_WINDOWCHANGE)
1847 DispShowWindow(WINDOW_RAISE);
1848 break;
1849 case 6: // Lower window
1850 if (ts.WindowFlag & WF_WINDOWCHANGE)
1851 DispShowWindow(WINDOW_LOWER);
1852 break;
1853 case 7: // Refresh window
1854 if (ts.WindowFlag & WF_WINDOWCHANGE)
1855 DispShowWindow(WINDOW_REFRESH);
1856 break;
1857 case 8: /* set terminal size */
1858 if (ts.WindowFlag & WF_WINDOWCHANGE) {
1859 if ((Param[2]<=1) || (NParam<2)) Param[2] = 24;
1860 if ((Param[3]<=1) || (NParam<3)) Param[3] = 80;
1861 ChangeTerminalSize(Param[3],Param[2]);
1862 }
1863 break;
1864 case 9: // Maximize/Restore window
1865 if (ts.WindowFlag & WF_WINDOWCHANGE) {
1866 if (NParam < 2 || Param[2] == 0) {
1867 DispShowWindow(WINDOW_RESTORE);
1868 }
1869 else if (Param[2] == 1) {
1870 DispShowWindow(WINDOW_MAXIMIZE);
1871 }
1872 }
1873 break;
1874 case 11: // Report window state
1875 if (ts.WindowFlag & WF_WINDOWREPORT) {
1876 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%dt", CLocale, DispWindowIconified()?2:1);
1877 SendCSIstr(Report, len);
1878 }
1879 break;
1880 case 13: // Report window position
1881 if (ts.WindowFlag & WF_WINDOWREPORT) {
1882 DispGetWindowPos(&x, &y);
1883 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "3;%d;%dt", CLocale, x, y);
1884 SendCSIstr(Report, len);
1885 }
1886 break;
1887 case 14: /* get window size??? */
1888 if (ts.WindowFlag & WF_WINDOWREPORT) {
1889 /* this is not actual window size */
1890 SendCSIstr("4;640;480t", 10);
1891 }
1892 break;
1893 case 18: /* get terminal size */
1894 if (ts.WindowFlag & WF_WINDOWREPORT) {
1895 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "8;%u;%u;t", CLocale,
1896 NumOfLines-StatusLine, NumOfColumns);
1897 SendCSIstr(Report, len);
1898 }
1899 break;
1900 case 19: // Report display size (character)
1901 if (ts.WindowFlag & WF_WINDOWREPORT) {
1902 DispGetRootWinSize(&x, &y);
1903 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "9;%d;%dt", CLocale, y, x);
1904 SendCSIstr(Report, len);
1905 }
1906 break;
1907 case 20: // Report icon label
1908 switch (ts.WindowFlag & WF_TITLEREPORT) {
1909 case IdTitleReportIgnore:
1910 // nothing to do
1911 break;
1912 case IdTitleReportAccept:
1913 switch (ts.AcceptTitleChangeRequest) {
1914 case IdTitleChangeRequestOff:
1915 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
1916 break;
1917 case IdTitleChangeRequestAhead:
1918 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, cv.TitleRemote, ts.Title);
1919 break;
1920 case IdTitleChangeRequestLast:
1921 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, ts.Title, cv.TitleRemote);
1922 break;
1923 default:
1924 if (cv.TitleRemote[0] == 0) {
1925 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
1926 }
1927 else {
1928 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, cv.TitleRemote);
1929 }
1930 }
1931 SendOSCstr(Report, len);
1932 break;
1933 default: // IdTitleReportEmpty:
1934 SendOSCstr("L", 1);
1935 break;
1936 }
1937 break;
1938 case 21: // Report window title
1939 switch (ts.WindowFlag & WF_TITLEREPORT) {
1940 case IdTitleReportIgnore:
1941 // nothing to do
1942 break;
1943 case IdTitleReportAccept:
1944 switch (ts.AcceptTitleChangeRequest) {
1945 case IdTitleChangeRequestOff:
1946 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
1947 break;
1948 case IdTitleChangeRequestAhead:
1949 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, cv.TitleRemote, ts.Title);
1950 break;
1951 case IdTitleChangeRequestLast:
1952 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, ts.Title, cv.TitleRemote);
1953 break;
1954 default:
1955 if (cv.TitleRemote[0] == 0) {
1956 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
1957 }
1958 else {
1959 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, cv.TitleRemote);
1960 }
1961 }
1962 SendOSCstr(Report, len);
1963 break;
1964 default: // IdTitleReportEmpty:
1965 SendOSCstr("l", 1);
1966 break;
1967 }
1968 break;
1969 }
1970 }
1971
1972 void CSGT(BYTE b)
1973 {
1974 switch (b) {
1975 case 'c': /* second terminal report (Secondary DA) */
1976 if (Param[1] < 1) {
1977 SendCSIstr(">32;10;2c", 9); /* VT382 */
1978 }
1979 break;
1980 case 'J':
1981 if (Param[1]==3) // IO-8256 terminal
1982 {
1983 if (Param[2]<1) Param[2]=1;
1984 if (Param[3]<1) Param[3]=1;
1985 if (Param[4]<1) Param[4]=1;
1986 if (Param[5]<1) Param[5]=1;
1987 BuffEraseBox(Param[3]-1,Param[2]-1,
1988 Param[5]-1,Param[4]-1);
1989 }
1990 break;
1991 case 'K':
1992 if ((NParam>=2) && (Param[1]==5))
1993 { // IO-8256 terminal
1994 switch (Param[2]) {
1995 case 3:
1996 case 4:
1997 case 5:
1998 case 6:
1999 BuffDrawLine(CharAttr, Param[2], Param[3]);
2000 break;
2001 case 12:
2002 /* Text color */
2003 if ((Param[3]>=0) && (Param[3]<=7))
2004 {
2005 switch (Param[3]) {
2006 case 3: CharAttr.Fore = IdBlue; break;
2007 case 4: CharAttr.Fore = IdCyan; break;
2008 case 5: CharAttr.Fore = IdYellow; break;
2009 case 6: CharAttr.Fore = IdMagenta; break;
2010 default: CharAttr.Fore = Param[3]; break;
2011 }
2012 CharAttr.Attr2 |= Attr2Fore;
2013 BuffSetCurCharAttr(CharAttr);
2014 }
2015 break;
2016 }
2017 }
2018 else if (Param[1]==3)
2019 {// IO-8256 terminal
2020 if (Param[2]<1) Param[2] = 1;
2021 if (Param[3]<1) Param[2] = 1;
2022 BuffEraseCharsInLine(Param[2]-1,Param[3]-Param[2]+1);
2023 }
2024 break;
2025 }
2026 }
2027
2028 void CSQExchangeColor() // DECSCNM / Visual Bell
2029 {
2030 COLORREF ColorRef;
2031
2032 BuffUpdateScroll();
2033
2034 if (ts.ColorFlag & CF_REVERSECOLOR) {
2035 ColorRef = ts.VTColor[0];
2036 ts.VTColor[0] = ts.VTReverseColor[0];
2037 ts.VTReverseColor[0] = ColorRef;
2038 ColorRef = ts.VTColor[1];
2039 ts.VTColor[1] = ts.VTReverseColor[1];
2040 ts.VTReverseColor[1] = ColorRef;
2041 }
2042 else {
2043 ColorRef = ts.VTColor[0];
2044 ts.VTColor[0] = ts.VTColor[1];
2045 ts.VTColor[1] = ColorRef;
2046 }
2047
2048 ColorRef = ts.VTBoldColor[0];
2049 ts.VTBoldColor[0] = ts.VTBoldColor[1];
2050 ts.VTBoldColor[1] = ColorRef;
2051
2052 ColorRef = ts.VTBlinkColor[0];
2053 ts.VTBlinkColor[0] = ts.VTBlinkColor[1];
2054 ts.VTBlinkColor[1] = ColorRef;
2055
2056 ColorRef = ts.URLColor[0];
2057 ts.URLColor[0] = ts.URLColor[1];
2058 ts.URLColor[1] = ColorRef;
2059
2060 ts.ColorFlag ^= CF_REVERSEVIDEO;
2061
2062 #ifdef ALPHABLEND_TYPE2
2063 // BGInitialize();
2064 BGExchangeColor();
2065 #endif
2066 DispChangeBackground();
2067 UpdateWindow(HVTWin);
2068 }
2069
2070 void CSQChangeColumnMode(int width) // DECCOLM
2071 {
2072 ChangeTerminalSize(width, NumOfLines-StatusLine);
2073 if ((ts.TermFlag & TF_CLEARONRESIZE) == 0) {
2074 MoveCursor(0, 0);
2075 BuffClearScreen();
2076 UpdateWindow(HVTWin);
2077 }
2078 }
2079
2080 void CSQ_h_Mode() // DECSET
2081 {
2082 int i;
2083
2084 for (i = 1 ; i<=NParam ; i++)
2085 switch (Param[i]) {
2086 case 1: AppliCursorMode = TRUE; break; // DECCKM
2087 case 3: CSQChangeColumnMode(132); break; // DECCOLM
2088 case 5: /* Reverse Video (DECSCNM) */
2089 if (!(ts.ColorFlag & CF_REVERSEVIDEO))
2090 CSQExchangeColor(); /* Exchange text/back color */
2091 break;
2092 case 6: // DECOM
2093 if ((StatusLine>0) && (CursorY==NumOfLines-1))
2094 MoveCursor(0,CursorY);
2095 else {
2096 RelativeOrgMode = TRUE;
2097 MoveCursor(0,CursorTop);
2098 }
2099 break;
2100 case 7: AutoWrapMode = TRUE; break; // DECAWM
2101 case 8: AutoRepeatMode = TRUE; break; // DECARM
2102 case 9: /* X10 Mouse Tracking */
2103 if (ts.MouseEventTracking)
2104 MouseReportMode = IdMouseTrackX10;
2105 break;
2106 case 12: /* att610 cursor blinking */
2107 if (ts.WindowFlag & WF_CURSORCHANGE) {
2108 ts.NonblinkingCursor = FALSE;
2109 ChangeCaret();
2110 }
2111 break;
2112 case 19: PrintEX = TRUE; break; // DECPEX
2113 case 25: DispEnableCaret(TRUE); break; // cursor on (DECTCEM)
2114 case 38: // DECTEK
2115 if (ts.AutoWinSwitch>0)
2116 ChangeEmu = IdTEK; /* Enter TEK Mode */
2117 break;
2118 case 47: // Alternate Screen Buffer
2119 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2120 BuffSaveScreen();
2121 AltScr = TRUE;
2122 }
2123 break;
2124 case 59:
2125 if (ts.Language==IdJapanese)
2126 { /* kanji terminal */
2127 Gn[0] = IdASCII;
2128 Gn[1] = IdKatakana;
2129 Gn[2] = IdKatakana;
2130 Gn[3] = IdKanji;
2131 Glr[0] = 0;
2132 if ((ts.KanjiCode==IdJIS) &&
2133 (ts.JIS7Katakana==0))
2134 Glr[1] = 2; // 8-bit katakana
2135 else
2136 Glr[1] = 3;
2137 }
2138 break;
2139 case 66: AppliKeyMode = TRUE; break; // DECNKM
2140 case 67: ts.BSKey = IdBS; break; // DECBKM
2141 case 1000: // Mouse Tracking
2142 if (ts.MouseEventTracking)
2143 MouseReportMode = IdMouseTrackVT200;
2144 break;
2145 case 1001: // Hilite Mouse Tracking
2146 if (ts.MouseEventTracking)
2147 MouseReportMode = IdMouseTrackVT200Hl;
2148 break;
2149 case 1002: // Button-Event Mouse Tracking
2150 if (ts.MouseEventTracking)
2151 MouseReportMode = IdMouseTrackBtnEvent;
2152 break;
2153 case 1003: // Any-Event Mouse Tracking
2154 if (ts.MouseEventTracking)
2155 MouseReportMode = IdMouseTrackAllEvent;
2156 break;
2157 case 1004: // Focus Report
2158 if (ts.MouseEventTracking)
2159 FocusReportMode = TRUE;
2160 break;
2161 case 1047: // Alternate Screen Buffer
2162 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2163 BuffSaveScreen();
2164 AltScr = TRUE;
2165 }
2166 break;
2167 case 1048: // Save Cursor Position (Alternate Screen Buffer)
2168 if (ts.TermFlag & TF_ALTSCR) {
2169 SaveCursor();
2170 }
2171 break;
2172 case 1049: // Alternate Screen Buffer
2173 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2174 SaveCursor();
2175 BuffSaveScreen();
2176 BuffClearScreen();
2177 AltScr = TRUE;
2178 }
2179 break;
2180 case 2004: // Bracketed Paste Mode
2181 BracketedPaste = TRUE;
2182 break;
2183 }
2184 }
2185
2186 void CSQ_i_Mode() // MC (DEC)
2187 {
2188 if (Param[1]==-1) Param[1] = 0;
2189 switch (Param[1]) {
2190 case 1:
2191 OpenPrnFile();
2192 BuffDumpCurrentLine(LF);
2193 if (! AutoPrintMode)
2194 ClosePrnFile();
2195 break;
2196 /* auto print mode off */
2197 case 4:
2198 if (AutoPrintMode)
2199 {
2200 ClosePrnFile();
2201 AutoPrintMode = FALSE;
2202 }
2203 break;
2204 /* auto print mode on */
2205 case 5:
2206 if (! AutoPrintMode)
2207 {
2208 OpenPrnFile();
2209 AutoPrintMode = TRUE;
2210 }
2211 break;
2212 }
2213 }
2214
2215 void CSQ_l_Mode() // DECRST
2216 {
2217 int i;
2218
2219 for (i = 1 ; i <= NParam ; i++)
2220 switch (Param[i]) {
2221 case 1: AppliCursorMode = FALSE; break; // DECCKM
2222 case 3: CSQChangeColumnMode(80); break; // DECCOLM
2223 case 5: /* Normal Video (DECSCNM) */
2224 if (ts.ColorFlag & CF_REVERSEVIDEO)
2225 CSQExchangeColor(); /* Exchange text/back color */
2226 break;
2227 case 6: // DECOM
2228 if ((StatusLine>0) && (CursorY==NumOfLines-1))
2229 MoveCursor(0,CursorY);
2230 else {
2231 RelativeOrgMode = FALSE;
2232 MoveCursor(0,0);
2233 }
2234 break;
2235 case 7: AutoWrapMode = FALSE; break; // DECAWM
2236 case 8: AutoRepeatMode = FALSE; break; // DECARM
2237 case 9: MouseReportMode = IdMouseTrackNone; break; /* X10 Mouse Tracking */
2238 case 12: /* att610 cursor blinking */
2239 if (ts.WindowFlag & WF_CURSORCHANGE) {
2240 ts.NonblinkingCursor = TRUE;
2241 ChangeCaret();
2242 }
2243 break;
2244 case 19: PrintEX = FALSE; break; // DECPEX
2245 case 25: DispEnableCaret(FALSE); break; // cursor off (DECTCEM)
2246 case 47: // Alternate Screen Buffer
2247 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2248 BuffRestoreScreen();
2249 AltScr = FALSE;
2250 }
2251 break;
2252 case 59:
2253 if (ts.Language==IdJapanese)
2254 { /* katakana terminal */
2255 Gn[0] = IdASCII;
2256 Gn[1] = IdKatakana;
2257 Gn[2] = IdKatakana;
2258 Gn[3] = IdKanji;
2259 Glr[0] = 0;
2260 if ((ts.KanjiCode==IdJIS) &&
2261 (ts.JIS7Katakana==0))
2262 Glr[1] = 2; // 8-bit katakana
2263 else
2264 Glr[1] = 3;
2265 }
2266 break;
2267 case 66: AppliKeyMode = FALSE; break; // DECNKM
2268 case 67: ts.BSKey = IdDEL; break; // DECBKM
2269 case 1000: // Mouse Tracking
2270 case 1001: // Hilite Mouse Tracking
2271 case 1002: // Button-Event Mouse Tracking
2272 case 1003: MouseReportMode = IdMouseTrackNone; break; // Any-Event Mouse Tracking
2273 case 1004: FocusReportMode = FALSE; break; // Focus Report
2274 case 1047: // Alternate Screen Buffer
2275 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2276 BuffClearScreen();
2277 BuffRestoreScreen();
2278 AltScr = FALSE;
2279 }
2280 break;
2281 case 1048: // Save Cursor Position (Alternate Screen Buffer)
2282 if (ts.TermFlag & TF_ALTSCR) {
2283 RestoreCursor();
2284 }
2285 break;
2286 case 1049: // Alternate Screen Buffer
2287 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2288 BuffClearScreen();
2289 BuffRestoreScreen();
2290 AltScr = FALSE;
2291 RestoreCursor();
2292 }
2293 break;
2294 case 2004: // Bracketed Paste Mode
2295 BracketedPaste = FALSE;
2296 break;
2297 }
2298 }
2299
2300 void CSQ_n_Mode() // DSR (DEC)
2301 {
2302 }
2303
2304 void CSQuest(BYTE b)
2305 {
2306 switch (b) {
2307 case 'K': CSLineErase(); break; // DECSEL
2308 case 'h': CSQ_h_Mode(); break; // DECSET
2309 case 'i': CSQ_i_Mode(); break; // MC (DEC)
2310 case 'l': CSQ_l_Mode(); break; // DECRST
2311 case 'n': CSQ_n_Mode(); break; // DSR (DEC)
2312 }
2313 }
2314
2315 void SoftReset()
2316 // called by software-reset escape sequence handler
2317 {
2318 UpdateStr();
2319 AutoRepeatMode = TRUE;
2320 DispEnableCaret(TRUE); // cursor on
2321 InsertMode = FALSE;
2322 RelativeOrgMode = FALSE;
2323 AppliKeyMode = FALSE;
2324 AppliCursorMode = FALSE;
2325 if ((StatusLine>0) &&
2326 (CursorY == NumOfLines-1))
2327 MoveToMainScreen();
2328 CursorTop = 0;
2329 CursorBottom = NumOfLines-1-StatusLine;
2330 ResetCharSet();
2331
2332 Send8BitMode = ts.Send8BitCtrl;
2333
2334 /* Attribute */
2335 CharAttr = DefCharAttr;
2336 Special = FALSE;
2337 BuffSetCurCharAttr(CharAttr);
2338
2339 // status buffers
2340 ResetSBuffers();
2341 }
2342
2343 void CSExc(BYTE b)
2344 {
2345 switch (b) {
2346 case 'p':
2347 /* Software reset */
2348 SoftReset();
2349 break;
2350 }
2351 }
2352
2353 void CSDouble(BYTE b)
2354 {
2355 switch (b) {
2356 case 'p':
2357 /* Select terminal mode (software reset) */
2358 SoftReset();
2359 if (NParam > 0) {
2360 switch (Param[1]) {
2361 case 61: // VT100 Mode
2362 Send8BitMode = FALSE; break;
2363 case 62: // VT200 Mode
2364 case 63: // VT300 Mode
2365 case 64: // VT400 Mode
2366 if (NParam > 1 && Param[2] == 1)
2367 Send8BitMode = FALSE;
2368 else
2369 Send8BitMode = TRUE;
2370 break;
2371 }
2372 }
2373 break;
2374 }
2375 }
2376
2377 void CSDol(BYTE b)
2378 {
2379 switch (b) {
2380 case '}':
2381 if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2382 if (StatusLine==0) return;
2383 if ((Param[1]<1) && (CursorY==NumOfLines-1))
2384 MoveToMainScreen();
2385 else if ((Param[1]==1) && (CursorY<NumOfLines-1))
2386 MoveToStatusLine();
2387 break;
2388 case '~':
2389 if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2390 if (Param[1]<=1)
2391 HideStatusLine();
2392 else if ((StatusLine==0) && (Param[1]==2))
2393 ShowStatusLine(1); // show
2394 break;
2395 }
2396 }
2397
2398 void CSSpace(BYTE b) {
2399 switch (b) {
2400 case 'q':
2401 if (ts.WindowFlag & WF_CURSORCHANGE) {
2402 if (NParam > 0) {
2403 if (Param[1] < 0) Param[1] = 0;
2404 switch (Param[1]) {
2405 case 0:
2406 case 1:
2407 ts.CursorShape = IdBlkCur;
2408 ts.NonblinkingCursor = FALSE;
2409 break;
2410 case 2:
2411 ts.CursorShape = IdBlkCur;
2412 ts.NonblinkingCursor = TRUE;
2413 break;
2414 case 3:
2415 ts.CursorShape = IdHCur;
2416 ts.NonblinkingCursor = FALSE;
2417 break;
2418 case 4:
2419 ts.CursorShape = IdHCur;
2420 ts.NonblinkingCursor = TRUE;
2421 break;
2422 case 5:
2423 ts.CursorShape = IdVCur;
2424 ts.NonblinkingCursor = FALSE;
2425 break;
2426 case 6:
2427 ts.CursorShape = IdVCur;
2428 ts.NonblinkingCursor = TRUE;
2429 break;
2430 default:
2431 return;
2432 }
2433 ChangeCaret();
2434 }
2435 }
2436 break;
2437 }
2438 }
2439
2440 void PrnParseCS(BYTE b) // printer mode
2441 {
2442 ParseMode = ModeFirst;
2443 switch (ICount) {
2444 /* no intermediate char */
2445 case 0:
2446 switch (Prv) {
2447 /* no private parameter */
2448 case 0:
2449 switch (b) {
2450 case 'i':
2451 if (Param[1]==4)
2452 {
2453 PrinterMode = FALSE;
2454 // clear prn buff
2455 WriteToPrnFile(0,FALSE);
2456 if (! AutoPrintMode)
2457 ClosePrnFile();
2458 return;
2459 }
2460 break;
2461 } /* of case Prv=0 */
2462 break;
2463 }
2464 break;
2465 /* one intermediate char */
2466 case 1: break;
2467 } /* of case Icount */
2468
2469 WriteToPrnFile(b,TRUE);
2470 }
2471
2472 void ParseCS(BYTE b) /* b is the final char */
2473 {
2474 if (PrinterMode) { // printer mode
2475 PrnParseCS(b);
2476 return;
2477 }
2478
2479 switch (ICount) {
2480 /* no intermediate char */
2481 case 0:
2482 switch (Prv) {
2483 /* no private parameter */
2484 case 0:
2485 switch (b) {
2486 // ISO/IEC 6429 / ECMA-48 Sequence
2487 case '@': CSInsertCharacter(); break; // ICH
2488 case 'A': CSCursorUp(); break; // CUU
2489 case 'B': CSCursorDown(); break; // CUD
2490 case 'C': CSCursorRight(); break; // CUF
2491 case 'D': CSCursorLeft(); break; // CUB
2492 case 'E': CSCursorDown1(); break; // CNL
2493 case 'F': CSCursorUp1(); break; // CPL
2494 case 'G': CSMoveToColumnN(); break; // CHA
2495 case 'H': CSMoveToXY(); break; // CUP
2496 case 'I': CSForwardTab(); break; // CHT
2497 case 'J': CSScreenErase(); break; // ED
2498 case 'K': CSLineErase(); break; // EL
2499 case 'L': CSInsertLine(); break; // IL
2500 case 'M': CSDeleteNLines(); break; // DL
2501 // case 'N': break; // EF -- Not support
2502 // case 'O': break; // EA -- Not support
2503 case 'P': CSDeleteCharacter(); break; // DCH
2504 // case 'Q': break; // SEE -- Not support
2505 // case 'R': break; // CPR -- Not support
2506 case 'S': CSScrollUP(); break; // SU
2507 case 'T': CSScrollDown(); break; // SD
2508 // case 'U': break; // NP -- Not support
2509 // case 'V': break; // PP -- Not support
2510 // case 'W': break; // CTC -- Not support
2511 case 'X': CSEraseCharacter(); break; // ECH
2512 // case 'Y': break; // CVT -- Not support
2513 case 'Z': CSBackwardTab(); break; // CBT
2514 // case '[': break; // SRS -- Not support
2515 // case '\\': break; // PTX -- Not support
2516 // case ']': break; // SDS -- Not support
2517 // case '^': break; // SIMD -- Not support
2518 case '`': CSMoveToColumnN(); break; // HPA
2519 case 'a': CSCursorRight(); break; // HPR
2520 // case 'b': break; // REP -- Not support
2521 case 'c': AnswerTerminalType(); break; // DA
2522 case 'd': CSMoveToLineN(); break; // VPA
2523 case 'e': CSCursorDown(); break; // VPR
2524 case 'f': CSMoveToXY(); break; // HVP
2525 case 'g': CSDeleteTabStop(); break; // TBC
2526 case 'h': CS_h_Mode(); break; // SM
2527 case 'i': CS_i_Mode(); break; // MC
2528 case 'j': CSCursorLeft(); break; // HPB
2529 case 'k': CSCursorUp(); // VPB
2530 case 'l': CS_l_Mode(); break; // RM
2531 case 'm': CSSetAttr(); break; // SGR
2532 case 'n': CS_n_Mode(); break; // DSR
2533 // case 'o': break; // DAQ -- Not support
2534
2535 // Private Sequence
2536 case 'r': CSSetScrollRegion(); break; // DECSTBM
2537 case 's': SaveCursor(); break; // SCP (Save cursor (ANSI.SYS/SCO?))
2538 case 't': CSSunSequence(); break; // DECSLPP / Window manipulation(dtterm?)
2539 case 'u': RestoreCursor(); break; // RCP (Restore cursor (ANSI.SYS/SCO))
2540 } /* of case Prv=0 */
2541 break;
2542 /* private parameter = '>' */
2543 case '>': CSGT(b); break;
2544 /* private parameter = '?' */
2545 case '?': CSQuest(b); break;
2546 } /* end of siwtch (Prv) */
2547 break;
2548 /* one intermediate char */
2549 case 1:
2550 switch (IntChar[1]) {
2551 /* intermediate char = ' ' */
2552 case ' ': CSSpace(b); break;
2553 /* intermediate char = '!' */
2554 case '!': CSExc(b); break;
2555 /* intermediate char = '"' */
2556 case '"': CSDouble(b); break;
2557 /* intermediate char = '$' */
2558 case '$': CSDol(b); break;
2559 }
2560 break;
2561 } /* of case Icount */
2562
2563 ParseMode = ModeFirst;
2564 }
2565
2566 void ControlSequence(BYTE b)
2567 {
2568 if ((b<=US) || (b>=0x80) && (b<=0x9F))
2569 ParseControl(b); /* ctrl char */
2570 else if ((b>=0x40) && (b<=0x7E))
2571 ParseCS(b); /* terminate char */
2572 else {
2573 if (PrinterMode)
2574 WriteToPrnFile(b,FALSE);
2575
2576 if ((b>=0x20) && (b<=0x2F))
2577 { /* intermediate char */
2578 if (ICount<IntCharMax) ICount++;
2579 IntChar[ICount] = b;
2580 }
2581 else if ((b>=0x30) && (b<=0x39))
2582 {
2583 if (Param[NParam] < 0)
2584 Param[NParam] = 0;
2585 if (Param[NParam]<1000)
2586 Param[NParam] = Param[NParam]*10 + b - 0x30;
2587 }
2588 else if (b==0x3B)
2589 {
2590 if (NParam < NParamMax)
2591 {
2592 NParam++;
2593 Param[NParam] = -1;
2594 }
2595 }
2596 else if ((b>=0x3C) && (b<=0x3F))
2597 { /* private char */
2598 if (FirstPrm) Prv = b;
2599 }
2600 }
2601 FirstPrm = FALSE;
2602 }
2603
2604 void DeviceControl(BYTE b)
2605 {
2606 if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2607 {
2608 ESCFlag = FALSE;
2609 ParseMode = SavedMode;
2610 return;
2611 }
2612
2613 if (b==ESC)
2614 {
2615 ESCFlag = TRUE;
2616 return;
2617 }
2618 else ESCFlag = FALSE;
2619
2620 if (b<=US)
2621 ParseControl(b);
2622 else if ((b>=0x30) && (b<=0x39))
2623 {
2624 if (Param[NParam] < 0) Param[NParam] = 0;
2625 if (Param[NParam]<1000)
2626 Param[NParam] = Param[NParam]*10 + b - 0x30;
2627 }
2628 else if (b==0x3B)
2629 {
2630 if (NParam < NParamMax)
2631 {
2632 NParam++;
2633 Param[NParam] = -1;
2634 }
2635 }
2636 else if ((b>=0x40) && (b<=0x7E))
2637 {
2638 if (b=='|')
2639 {
2640 ParseMode = ModeDCUserKey;
2641 if (Param[1] < 1) ClearUserKey();
2642 WaitKeyId = TRUE;
2643 NewKeyId = 0;
2644 }
2645 else ParseMode = ModeSOS;
2646 }
2647 }
2648
2649 void DCUserKey(BYTE b)
2650 {
2651 if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2652 {
2653 if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2654 ESCFlag = FALSE;
2655 ParseMode = SavedMode;
2656 return;
2657 }
2658
2659 if (b==ESC)
2660 {
2661 ESCFlag = TRUE;
2662 return;
2663 }
2664 else ESCFlag = FALSE;
2665
2666 if (WaitKeyId)
2667 {
2668 if ((b>=0x30) && (b<=0x39))
2669 {
2670 if (NewKeyId<1000)
2671 NewKeyId = NewKeyId*10 + b - 0x30;
2672 }
2673 else if (b==0x2F)
2674 {
2675 WaitKeyId = FALSE;
2676 WaitHi = TRUE;
2677 NewKeyLen = 0;
2678 }
2679 }
2680 else {
2681 if (b==0x3B)
2682 {
2683 DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2684 WaitKeyId = TRUE;
2685 NewKeyId = 0;
2686 }
2687 else {
2688 if (NewKeyLen < FuncKeyStrMax)
2689 {
2690 if (WaitHi)
2691 {
2692 NewKeyStr[NewKeyLen] = ConvHexChar(b) << 4;
2693 WaitHi = FALSE;
2694 }
2695 else {
2696 NewKeyStr[NewKeyLen] = NewKeyStr[NewKeyLen] +
2697 ConvHexChar(b);
2698 WaitHi = TRUE;
2699 NewKeyLen++;
2700 }
2701 }
2702 }
2703 }
2704 }
2705
2706 void IgnoreString(BYTE b)
2707 {
2708 if ((ESCFlag && (b=='\\')) ||
2709 (b<=US && b!=ESC && b!=HT) ||
2710 (b==ST && ts.KanjiCode!=IdSJIS))
2711 ParseMode = SavedMode;
2712
2713 if (b==ESC) ESCFlag = TRUE;
2714 else ESCFlag = FALSE;
2715 }
2716
2717 BOOL XsParseColor(char *colspec, COLORREF *color)
2718 {
2719 unsigned int r, g, b;
2720 // double dr, dg, db;
2721
2722 r = g = b = 255;
2723
2724 if (colspec == NULL || color == NULL) {
2725 return FALSE;
2726 }
2727
2728 if (_strnicmp(colspec, "rgb:", 4) == 0) {
2729 switch (strlen(colspec)) {
2730 case 9: // rgb:R/G/B
2731 if (sscanf(colspec, "rgb:%1x/%1x/%1x", &r, &g, &b) != 3) {
2732 return FALSE;
2733 }
2734 r *= 17; g *= 17; b *= 17;
2735 break;
2736 case 12: // rgb:RR/GG/BB
2737 if (sscanf(colspec, "rgb:%2x/%2x/%2x", &r, &g, &b) != 3) {
2738 return FALSE;
2739 }
2740 break;
2741 case 15: // rgb:RRR/GGG/BBB
2742 if (sscanf(colspec, "rgb:%3x/%3x/%3x", &r, &g, &b) != 3) {
2743 return FALSE;
2744 }
2745 r >>= 4; g >>= 4; b >>= 4;
2746 break;
2747 case 18: // rgb:RRRR/GGGG/BBBB
2748 if (sscanf(colspec, "rgb:%4x/%4x/%4x", &r, &g, &b) != 3) {
2749 return FALSE;
2750 }
2751 r >>= 8; g >>= 8; b >>= 8;
2752 break;
2753 default:
2754 return FALSE;
2755 }
2756 }
2757 // else if (_strnicmp(colspec, "rgbi:", 5) == 0) {
2758 // ; /* nothing to do */
2759 // }
2760 else if (colspec[0] == '#') {
2761 switch (strlen(colspec)) {
2762 case 4: // #RGB
2763 if (sscanf(colspec, "#%1x%1x%1x", &r, &g, &b) != 3) {
2764 return FALSE;
2765 }
2766 r <<= 4; g <<= 4; b <<= 4;
2767 break;
2768 case 7: // #RRGGBB
2769 if (sscanf(colspec, "#%2x%2x%2x", &r, &g, &b) != 3) {
2770 return FALSE;
2771 }
2772 break;
2773 case 10: // #RRRGGGBBB
2774 if (sscanf(colspec, "#%3x%3x%3x", &r, &g, &b) != 3) {
2775 return FALSE;
2776 }
2777 r >>= 4; g >>= 4; b >>= 4;
2778 break;
2779 case 13: // #RRRRGGGGBBBB
2780 if (sscanf(colspec, "#%4x%4x%4x", &r, &g, &b) != 3) {
2781 return FALSE;
2782 }
2783 r >>= 8; g >>= 8; b >>= 8;
2784 break;
2785 default:
2786 return FALSE;
2787 }
2788 }
2789 else {
2790 return FALSE;
2791 }
2792
2793 if (r > 255 || g > 255 || b > 255) {
2794 return FALSE;
2795 }
2796
2797 *color = RGB(r, g, b);
2798 return TRUE;
2799 }
2800
2801 #define ModeXsFirst 1
2802 #define ModeXsString 2
2803 #define ModeXsColorNum 3
2804 #define ModeXsColorSpec 4
2805 #define ModeXsEsc 5
2806 void XSequence(BYTE b)
2807 {
2808 static BYTE XsParseMode = ModeXsFirst, PrevMode;
2809 static char StrBuff[sizeof(ts.Title)];
2810 static unsigned int ColorNumber, StrLen;
2811 int len;
2812 COLORREF color;
2813
2814 switch (XsParseMode) {
2815 case ModeXsFirst:
2816 if (isdigit(b)) {
2817 if (Param[1] < 1000) {
2818 Param[1] = Param[1]*10 + b - '0';
2819 }
2820 }
2821 else if (b == ';') {
2822 StrBuff[0] = '\0';
2823 StrLen = 0;
2824 if (Param[1] == 4) {
2825 ColorNumber = 0;
2826 XsParseMode = ModeXsColorNum;
2827 }
2828 else {
2829 XsParseMode = ModeXsString;
2830 }
2831 }
2832 else {
2833 ParseMode = ModeFirst;
2834 }
2835 break;
2836 case ModeXsString:
2837 if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */
2838 StrBuff[StrLen] = '\0';
2839 switch (Param[1]) {
2840 case 0: /* Change window title and icon name */
2841 case 1: /* Change icon name */
2842 case 2: /* Change window title */
2843 if (ts.AcceptTitleChangeRequest) {
2844 strncpy_s(cv.TitleRemote, sizeof(cv.TitleRemote), StrBuff, _TRUNCATE);
2845 // (2006.6.15 maya) �^�C�g�����n����������SJIS������
2846 ConvertToCP932(cv.TitleRemote, sizeof(cv.TitleRemote));
2847 ChangeTitle();
2848 }
2849 break;
2850 default:
2851 /* nothing to do */;
2852 }
2853 ParseMode = ModeFirst;
2854 XsParseMode = ModeXsFirst;
2855 }
2856 else if (b == ESC) { /* Escape */
2857 PrevMode = ModeXsString;
2858 XsParseMode = ModeXsEsc;
2859 }
2860 else if (b <= US) { /* Other control character -- invalid sequence */
2861 ParseMode = ModeFirst;
2862 XsParseMode = ModeXsFirst;
2863 }
2864 else if (StrLen < sizeof(StrBuff) - 1) {
2865 StrBuff[StrLen++] = b;
2866 }
2867 break;
2868 case ModeXsColorNum:
2869 if (isdigit(b)) {
2870 ColorNumber = ColorNumber*10 + b - '0';
2871 }
2872 else if (b == ';') {
2873 XsParseMode = ModeXsColorSpec;
2874 StrBuff[0] = '\0';
2875 StrLen = 0;
2876 }
2877 else {
2878 ParseMode = ModeFirst;
2879 XsParseMode = ModeXsFirst;
2880 }
2881 break;
2882 case ModeXsColorSpec:
2883 if ((b==ST && Accept8BitCtrl && !(ts.Language==IdJapanese && ts.KanjiCode==IdSJIS)) || b==BEL) { /* String Terminator */
2884 StrBuff[StrLen] = '\0';
2885 if ((ts.ColorFlag & CF_XTERM256) && ColorNumber <= 255) {
2886 if (strcmp(StrBuff, "?") == 0) {
2887 color = DispGetANSIColor(ColorNumber);
2888 len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,
2889 "4;%d;rgb:%02x/%02x/%02x", CLocale, ColorNumber,
2890 GetRValue(color), GetGValue(color), GetBValue(color));
2891 ParseMode = ModeFirst;
2892 XsParseMode = ModeXsFirst;
2893 SendOSCstr(StrBuff, len);
2894 break;
2895 }
2896 else if (XsParseColor(StrBuff, &color)) {
2897 DispSetANSIColor(ColorNumber, color);
2898 }
2899 }
2900 ParseMode = ModeFirst;
2901 XsParseMode = ModeXsFirst;
2902 }
2903 else if (b == ESC) {
2904 PrevMode = ModeXsColorSpec;
2905 XsParseMode = ModeXsEsc;
2906 }
2907 else if (b <= US) { /* Other control character -- invalid sequence */
2908 ParseMode = ModeFirst;
2909 XsParseMode = ModeXsFirst;
2910 }
2911 else if (b == ';') {
2912 if ((ts.ColorFlag & CF_XTERM256) && ColorNumber <= 255) {
2913 if (strcmp(StrBuff, "?") == 0) {
2914 color = DispGetANSIColor(ColorNumber);
2915 len =_snprintf_s_l(StrBuff, sizeof(StrBuff), _TRUNCATE,
2916 "4;%d;rgb:%02x/%02x/%02x", CLocale, ColorNumber,
2917 GetRValue(color), GetGValue(color), GetBValue(color));
2918 XsParseMode = ModeXsColorNum;
2919 SendOSCstr(StrBuff, len);
2920 }
2921 else if (XsParseColor(StrBuff, &color)) {
2922 DispSetANSIColor(ColorNumber, color);
2923 }
2924 }
2925 ColorNumber = 0;
2926 StrBuff[0] = '\0';
2927 StrLen = 0;
2928 XsParseMode = ModeXsColorNum;
2929 }
2930 else if (StrLen < sizeof(StrBuff) - 1) {
2931 StrBuff[StrLen++] = b;
2932 }
2933 break;
2934 case ModeXsEsc:
2935 if (b == '\\') { /* String Terminator */
2936 XsParseMode = PrevMode;
2937 // XSequence(ST);
2938 XSequence(BEL);
2939 }
2940 else { /* Other character -- invalid sequence */
2941 ParseMode = ModeFirst;
2942 XsParseMode = ModeXsFirst;
2943 }
2944 break;
2945 // default:
2946 // ParseMode = ModeFirst;
2947 // XsParseMode = ModeXsFirst;
2948 }
2949 }
2950
2951 void DLESeen(BYTE b)
2952 {
2953 ParseMode = ModeFirst;
2954 if (((ts.FTFlag & FT_BPAUTO)!=0) && (b=='B'))
2955 BPStart(IdBPAuto); /* Auto B-Plus activation */
2956 ChangeEmu = -1;
2957 }
2958
2959 void CANSeen(BYTE b)
2960 {
2961 ParseMode = ModeFirst;
2962 if (((ts.FTFlag & FT_ZAUTO)!=0) && (b=='B'))
2963 ZMODEMStart(IdZAuto); /* Auto ZMODEM activation */
2964 ChangeEmu = -1;
2965 }
2966
2967 BOOL CheckKanji(BYTE b)
2968 {
2969 BOOL Check;
2970
2971 if (ts.Language!=IdJapanese) return FALSE;
2972
2973 ConvJIS = FALSE;
2974
2975 if (ts.KanjiCode==IdSJIS)
2976 {
2977 if ((0x80<b) && (b<0xa0) || (0xdf<b) && (b<0xfd))
2978 return TRUE; // SJIS kanji
2979 if ((0xa1<=b) && (b<=0xdf))
2980 return FALSE; // SJIS katakana
2981 }
2982
2983 if ((b>=0x21) && (b<=0x7e))
2984 {
2985 Check = (Gn[Glr[0]]==IdKanji);
2986 ConvJIS = Check;
2987 }
2988 else if ((b>=0xA1) && (b<=0xFE))
2989 {
2990 Check = (Gn[Glr[1]]==IdKanji);
2991 if (ts.KanjiCode==IdEUC)
2992 Check = TRUE;
2993 else if (ts.KanjiCode==IdJIS)
2994 {
2995 if (((ts.TermFlag & TF_FIXEDJIS)!=0) &&
2996 (ts.JIS7Katakana==0))
2997 Check = FALSE; // 8-bit katakana
2998 }
2999 ConvJIS = Check;
3000 }
3001 else
3002 Check = FALSE;
3003
3004 return Check;
3005 }
3006
3007 BOOL CheckKorean(BYTE b)
3008 {
3009 BOOL Check;
3010 if (ts.Language!=IdKorean)
3011 return FALSE;
3012
3013 if (ts.KanjiCode == IdSJIS) {
3014 if ((0xA1<=b) && (b<=0xFE)) {
3015 Check = TRUE;
3016 }
3017 else {
3018 Check = FALSE;
3019 }
3020 }
3021
3022 return Check;
3023 }
3024
3025 BOOL ParseFirstJP(BYTE b)
3026 // returns TRUE if b is processed
3027 // (actually allways returns TRUE)
3028 {
3029 if (KanjiIn) {
3030 if ((! ConvJIS) && (0x3F<b) && (b<0xFD) ||
3031 ConvJIS && ( (0x20<b) && (b<0x7f) ||
3032 (0xa0<b) && (b<0xff) ))
3033 {
3034 PutKanji(b);
3035 KanjiIn = FALSE;
3036 return TRUE;
3037 }
3038 else if ((ts.TermFlag & TF_CTRLINKANJI)==0) {
3039 KanjiIn = FALSE;
3040 }
3041 else if ((b==CR) && Wrap) {
3042 CarriageReturn(FALSE);
3043 LineFeed(LF,FALSE);
3044 Wrap = FALSE;
3045 }
3046 }
3047
3048 if (SSflag) {
3049 if (Gn[GLtmp] == IdKanji) {
3050 Kanji = b << 8;
3051 KanjiIn = TRUE;
3052 SSflag = FALSE;
3053 return TRUE;
3054 }
3055 else if (Gn[GLtmp] == IdKatakana) {
3056 b = b | 0x80;
3057 }
3058
3059 PutChar(b);
3060 SSflag = FALSE;
3061 return TRUE;
3062 }
3063
3064 if ((!EUCsupIn) && (!EUCkanaIn) && (!KanjiIn) && CheckKanji(b)) {
3065 Kanji = b << 8;
3066 KanjiIn = TRUE;
3067 return TRUE;
3068 }
3069
3070 if (b<=US) {
3071 ParseControl(b);
3072 }
3073 else if (b==0x20) {
3074 PutChar(b);
3075 }
3076 else if ((b>=0x21) && (b<=0x7E)) {
3077 if (EUCsupIn) {
3078 EUCcount--;
3079 EUCsupIn = (EUCcount==0);
3080 return TRUE;
3081 }
3082
3083 if ((Gn[Glr[0]] == IdKatakana) || EUCkanaIn) {
3084 b = b | 0x80;
3085 EUCkanaIn = FALSE;
3086 }
3087 PutChar(b);
3088 }
3089 else if (b==0x7f) {
3090 return TRUE;
3091 }
3092 else if ((b>=0x80) && (b<=0x8D)) {
3093 ParseControl(b);
3094 }
3095 else if (b==0x8E) { // SS2
3096 if (ts.KanjiCode==IdEUC) {
3097 EUCkanaIn = TRUE;
3098 }
3099 else {
3100 ParseControl(b);
3101 }
3102 }
3103 else if (b==0x8F) { // SS3
3104 if (ts.KanjiCode==IdEUC) {
3105 EUCcount = 2;
3106 EUCsupIn = TRUE;
3107 }
3108 else {
3109 ParseControl(b);
3110 }
3111 }
3112 else if ((b>=0x90) && (b<=0x9F)) {
3113 ParseControl(b);
3114 }
3115 else if (b==0xA0) {
3116 PutChar(0x20);
3117 }
3118 else if ((b>=0xA1) && (b<=0xFE)) {
3119 if (EUCsupIn) {
3120 EUCcount--;
3121 EUCsupIn = (EUCcount==0);
3122 return TRUE;
3123 }
3124
3125 if ((Gn[Glr[1]] != IdASCII) ||
3126 (ts.KanjiCode==IdEUC) && EUCkanaIn ||
3127 (ts.KanjiCode==IdSJIS) ||
3128 (ts.KanjiCode==IdJIS) &&
3129 (ts.JIS7Katakana==0) &&
3130 ((ts.TermFlag & TF_FIXEDJIS)!=0))
3131 PutChar(b); // katakana
3132 else {
3133 if (Gn[Glr[1]] == IdASCII) {
3134 b = b & 0x7f;
3135 }
3136 PutChar(b);
3137 }
3138 EUCkanaIn = FALSE;
3139 }
3140 else {
3141 PutChar(b);
3142 }
3143
3144 return TRUE;
3145 }
3146
3147 BOOL ParseFirstKR(BYTE b)
3148 // returns TRUE if b is processed
3149 // (actually allways returns TRUE)
3150 {
3151 if (KanjiIn) {
3152 if ((0x41<=b) && (b<=0x5A) ||
3153 (0x61<=b) && (b<=0x7A) ||
3154 (0x81<=b) && (b<=0xFE))
3155 {
3156 PutKanji(b);
3157 KanjiIn = FALSE;
3158 return TRUE;
3159 }
3160 else if ((ts.TermFlag & TF_CTRLINKANJI)==0) {
3161 KanjiIn = FALSE;
3162 }
3163 else if ((b==CR) && Wrap) {
3164 CarriageReturn(FALSE);
3165 LineFeed(LF,FALSE);
3166 Wrap = FALSE;
3167 }
3168 }
3169
3170 if ((!KanjiIn) && CheckKorean(b)) {
3171 Kanji = b << 8;
3172 KanjiIn = TRUE;
3173 return TRUE;
3174 }
3175
3176 if (b<=US) {
3177 ParseControl(b);
3178 }
3179 else if (b==0x20) {
3180 PutChar(b);
3181 }
3182 else if ((b>=0x21) && (b<=0x7E)) {
3183 // if (Gn[Glr[0]] == IdKatakana) {
3184 // b = b | 0x80;
3185 // }
3186 PutChar(b);
3187 }
3188 else if (b==0x7f) {
3189 return TRUE;
3190 }
3191 else if ((0x80<=b) && (b<=0x9F)) {
3192 ParseControl(b);
3193 }
3194 else if (b==0xA0) {
3195 PutChar(0x20);
3196 }
3197 else if ((b>=0xA1) && (b<=0xFE)) {
3198 if (Gn[Glr[1]] == IdASCII) {
3199 b = b & 0x7f;
3200 }
3201 PutChar(b);
3202 }
3203 else {
3204 PutChar(b);
3205 }
3206
3207 return TRUE;
3208 }
3209
3210 static void ParseASCII(BYTE b)
3211 {
3212 if (SSflag) {
3213 PutChar(b);
3214 SSflag = FALSE;
3215 return;
3216 }
3217
3218 if (b<=US) {
3219 ParseControl(b);
3220 } else if ((b>=0x20) && (b<=0x7E)) {
3221 //Kanji = 0;
3222 //PutKanji(b);
3223 PutChar(b);
3224 } else if ((b>=0x80) && (b<=0x9F)) {
3225 ParseControl(b);
3226 } else if (b>=0xA0) {
3227 //Kanji = 0;
3228 //PutKanji(b);
3229 PutChar(b);
3230 }
3231 }
3232
3233 //
3234 // UTF-8
3235 //
3236 #include "uni2sjis.map"
3237 #include "unisym2decsp.map"
3238 extern unsigned short ConvertUnicode(unsigned short code, codemap_t *table, int tmax);
3239
3240
3241 //
3242 // UTF-8 for Mac OS X(HFS plus)
3243 //
3244 #include "hfs_plus.map"
3245
3246 unsigned short GetIllegalUnicode(int start_index, unsigned short first_code, unsigned short code,
3247 hfsplus_codemap_t *table, int tmax)
3248 {
3249 unsigned short result = 0;
3250 int i;
3251
3252 for (i = start_index ; i < tmax ; i++) {
3253 if (table[i].first_code != first_code) { // 1�������������������A���~���������������������B
3254 break;
3255 }
3256
3257 if (table[i].second_code == code) {
3258 result = table[i].illegal_code;
3259 break;
3260 }
3261 }
3262
3263 return (result);
3264 }
3265
3266 int GetIndexOfHFSPlusFirstCode(unsigned short code, hfsplus_codemap_t *table, int tmax)
3267 {
3268 int low, mid, high;
3269 int index = -1;
3270
3271 low = 0;
3272 high = tmax - 1;
3273
3274 // binary search
3275 while (low < high) {
3276 mid = (low + high) / 2;
3277 if (table[mid].first_code < code) {
3278 low = mid + 1;
3279 } else {
3280 high = mid;
3281 }
3282 }
3283
3284 if (table[low].first_code == code) {
3285 while (low >= 0 && table[low].first_code == code) {
3286 index = low;
3287 low--;
3288 }
3289 }
3290
3291 return (index);
3292 }
3293
3294
3295 static void UnicodeToCP932(unsigned int code)
3296 {
3297 int ret;
3298 char mbchar[32];
3299 unsigned char wchar[32];
3300 unsigned short cset = 0;
3301
3302 #if 0
3303 Kanji = code & 0xff00;
3304 PutKanji(code & 0x00ff);
3305 return;
3306 #else
3307
3308 wchar[0] = code & 0xff;
3309 wchar[1] = (code >> 8) & 0xff;
3310
3311 if (ts.UnicodeDecSpMapping) {
3312 cset = ConvertUnicode(code, mapUnicodeSymbolToDecSp, MAPSIZE(mapUnicodeSymbolToDecSp));
3313 }
3314 if (((cset >> 8) & ts.UnicodeDecSpMapping) != 0) {
3315 PutDecSp(cset & 0xff);
3316 }
3317 else {
3318 // Unicode -> CP932
3319 ret = wctomb(mbchar, ((wchar_t *)wchar)[0]);
3320 switch (ret) {
3321 case -1:
3322 if (_stricmp(ts.Locale, DEFAULT_LOCALE) == 0) {
3323 // U+301C�������������������BUnicode -> Shift_JIS���������������B
3324 cset = ConvertUnicode(code, mapUnicodeToSJIS, MAPSIZE(mapUnicodeToSJIS));
3325 if (cset != 0) {
3326 Kanji = cset & 0xff00;
3327 PutKanji(cset & 0x00ff);
3328 }
3329 }
3330
3331 if (cset == 0) {
3332 PutChar('?');
3333 if (ts.UnknownUnicodeCharaAsWide) {
3334 PutChar('?');
3335 }
3336 }