Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ttcomtester/teraterm/teraterm/vtterm.c

Annotation of /branches/ttcomtester/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3311 - (hide annotations) (download) (as text)
Wed Apr 15 09:38:47 2009 UTC (15 years ago) by doda
Original Path: trunk/teraterm/teraterm/vtterm.c
File MIME type: text/x-csrc
File size: 78050 byte(s) 
コメント追加
1 maya 3227 /* 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     /* Parsing modes */
29     #define ModeFirst 0
30     #define ModeESC 1
31     #define ModeDCS 2
32     #define ModeDCUserKey 3
33     #define ModeSOS 4
34     #define ModeCSI 5
35     #define ModeXS 6
36     #define ModeDLE 7
37     #define ModeCAN 8
38    
39     #define NParamMax 16
40     #define IntCharMax 5
41    
42     void VisualBell();
43    
44     /* character attribute */
45     static TCharAttr CharAttr;
46    
47     /* various modes of VT emulation */
48     static BOOL RelativeOrgMode;
49     static BOOL InsertMode;
50     static BOOL LFMode;
51     static BOOL AutoWrapMode;
52     static BOOL FocusReportMode;
53     int MouseReportMode;
54    
55     // save/restore cursor
56     typedef struct {
57     int CursorX, CursorY;
58     TCharAttr Attr;
59     int Glr[2], Gn[4]; // G0-G3, GL & GR
60     BOOL AutoWrapMode;
61     BOOL RelativeOrgMode;
62     } TStatusBuff;
63     typedef TStatusBuff *PStatusBuff;
64    
65     // status buffer for main screen & status line
66     static TStatusBuff SBuff1, SBuff2;
67    
68     static BOOL ESCFlag, JustAfterESC;
69     static BOOL KanjiIn;
70     static BOOL EUCkanaIn, EUCsupIn;
71     static int EUCcount;
72     static BOOL Special;
73    
74     static int Param[NParamMax+1];
75     static int NParam;
76     static BOOL FirstPrm;
77     static BYTE IntChar[IntCharMax+1];
78     static int ICount;
79     static BYTE Prv;
80     static int ParseMode, SavedMode;
81     static int ChangeEmu;
82    
83     /* user defined keys */
84     static BOOL WaitKeyId, WaitHi;
85    
86     /* GL, GR code group */
87     static int Glr[2];
88     /* G0, G1, G2, G3 code group */
89     static int Gn[4];
90     /* GL for single shift 2/3 */
91     static int GLtmp;
92     /* single shift 2/3 flag */
93     static BOOL SSflag;
94     /* JIS -> SJIS conversion flag */
95     static BOOL ConvJIS;
96     static WORD Kanji;
97    
98     // variables for status line mode
99     static int StatusX=0;
100     static BOOL StatusWrap=FALSE;
101     static BOOL StatusCursor=TRUE;
102     static int MainX, MainY; //cursor registers
103     static int MainTop, MainBottom; // scroll region registers
104     static BOOL MainWrap;
105     static BOOL MainCursor=TRUE;
106    
107     /* status for printer escape sequences */
108     static BOOL PrintEX = TRUE; // printing extent
109     // (TRUE: screen, FALSE: scroll region)
110     static BOOL AutoPrintMode = FALSE;
111     static BOOL PrinterMode = FALSE;
112     static BOOL DirectPrn = FALSE;
113    
114     /* User key */
115     static BYTE NewKeyStr[FuncKeyStrMax];
116     static int NewKeyId, NewKeyLen;
117    
118     static _locale_t CLocale;
119    
120     void ResetSBuffers()
121     {
122     SBuff1.CursorX = 0;
123     SBuff1.CursorY = 0;
124     SBuff1.Attr = DefCharAttr;
125     if (ts.Language==IdJapanese)
126     {
127     SBuff1.Gn[0] = IdASCII;
128     SBuff1.Gn[1] = IdKatakana;
129     SBuff1.Gn[2] = IdKatakana;
130     SBuff1.Gn[3] = IdKanji;
131     SBuff1.Glr[0] = 0;
132     if ((ts.KanjiCode==IdJIS) &&
133     (ts.JIS7Katakana==0))
134     SBuff1.Glr[1] = 2; // 8-bit katakana
135     else
136     SBuff1.Glr[1] = 3;
137     }
138     else {
139     SBuff1.Gn[0] = IdASCII;
140     SBuff1.Gn[1] = IdSpecial;
141     SBuff1.Gn[2] = IdASCII;
142     SBuff1.Gn[3] = IdASCII;
143     SBuff1.Glr[0] = 0;
144     SBuff1.Glr[1] = 0;
145     }
146     SBuff1.AutoWrapMode = TRUE;
147     SBuff1.RelativeOrgMode = FALSE;
148     // copy SBuff1 to SBuff2
149     SBuff2 = SBuff1;
150     }
151    
152     void ResetTerminal() /*reset variables but don't update screen */
153     {
154     DispReset();
155     BuffReset();
156    
157     /* Attribute */
158     CharAttr = DefCharAttr;
159     Special = FALSE;
160     BuffSetCurCharAttr(CharAttr);
161    
162     /* Various modes */
163     InsertMode = FALSE;
164     LFMode = (ts.CRSend == IdCRLF);
165     AutoWrapMode = TRUE;
166     AppliKeyMode = FALSE;
167     AppliCursorMode = FALSE;
168     RelativeOrgMode = FALSE;
169     ts.ColorFlag &= ~CF_REVERSEVIDEO;
170     AutoRepeatMode = TRUE;
171     Send8BitMode = ts.Send8BitCtrl;
172     FocusReportMode = FALSE;
173     MouseReportMode = IdMouseTrackNone;
174    
175     CLocale = _create_locale(LC_ALL, "C");
176    
177     /* Character sets */
178     ResetCharSet();
179    
180     /* ESC flag for device control sequence */
181     ESCFlag = FALSE;
182     /* for TEK sequence */
183     JustAfterESC = FALSE;
184    
185     /* Parse mode */
186     ParseMode = ModeFirst;
187    
188     /* Clear printer mode */
189     PrinterMode = FALSE;
190    
191     // status buffers
192     ResetSBuffers();
193     }
194    
195     void ResetCharSet()
196     {
197     if (ts.Language==IdJapanese)
198     {
199     Gn[0] = IdASCII;
200     Gn[1] = IdKatakana;
201     Gn[2] = IdKatakana;
202     Gn[3] = IdKanji;
203     Glr[0] = 0;
204     if ((ts.KanjiCode==IdJIS) &&
205     (ts.JIS7Katakana==0))
206     Glr[1] = 2; // 8-bit katakana
207     else
208     Glr[1] = 3;
209     }
210     else {
211     Gn[0] = IdASCII;
212     Gn[1] = IdSpecial;
213     Gn[2] = IdASCII;
214     Gn[3] = IdASCII;
215     Glr[0] = 0;
216     Glr[1] = 0;
217     cv.SendCode = IdASCII;
218     cv.SendKanjiFlag = FALSE;
219     cv.EchoCode = IdASCII;
220     cv.EchoKanjiFlag = FALSE;
221     }
222     /* Kanji flag */
223     KanjiIn = FALSE;
224     EUCkanaIn = FALSE;
225     EUCsupIn = FALSE;
226     SSflag = FALSE;
227    
228     cv.Language = ts.Language;
229     cv.CRSend = ts.CRSend;
230     cv.KanjiCodeEcho = ts.KanjiCode;
231     cv.JIS7KatakanaEcho = ts.JIS7Katakana;
232     cv.KanjiCodeSend = ts.KanjiCodeSend;
233     cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
234     cv.KanjiIn = ts.KanjiIn;
235     cv.KanjiOut = ts.KanjiOut;
236     }
237    
238     void ResetKeypadMode(BOOL DisabledModeOnly)
239     {
240     if (!DisabledModeOnly || ts.DisableAppKeypad) AppliKeyMode = FALSE;
241     if (!DisabledModeOnly || ts.DisableAppCursor) AppliCursorMode = FALSE;
242     }
243    
244     void MoveToMainScreen()
245     {
246     StatusX = CursorX;
247     StatusWrap = Wrap;
248     StatusCursor = IsCaretEnabled();
249    
250     CursorTop = MainTop;
251     CursorBottom = MainBottom;
252     Wrap = MainWrap;
253     DispEnableCaret(MainCursor);
254     MoveCursor(MainX,MainY); // move to main screen
255     }
256    
257     void MoveToStatusLine()
258     {
259     MainX = CursorX;
260     MainY = CursorY;
261     MainTop = CursorTop;
262     MainBottom = CursorBottom;
263     MainWrap = Wrap;
264     MainCursor = IsCaretEnabled();
265    
266     DispEnableCaret(StatusCursor);
267     MoveCursor(StatusX,NumOfLines-1); // move to status line
268     CursorTop = NumOfLines-1;
269     CursorBottom = CursorTop;
270     Wrap = StatusWrap;
271     }
272    
273     void HideStatusLine()
274     {
275     if ((StatusLine>0) &&
276     (CursorY==NumOfLines-1))
277     MoveToMainScreen();
278     StatusX = 0;
279     StatusWrap = FALSE;
280     StatusCursor = TRUE;
281     ShowStatusLine(0); //hide
282     }
283    
284     void ChangeTerminalSize(int Nx, int Ny)
285     {
286     BuffChangeTerminalSize(Nx,Ny);
287     StatusX = 0;
288     MainX = 0;
289     MainY = 0;
290     MainTop = 0;
291     MainBottom = NumOfColumns-1;
292     }
293    
294     void BackSpace()
295     {
296     if (CursorX == 0)
297     {
298     if ((CursorY>0) &&
299     ((ts.TermFlag & TF_BACKWRAP)!=0))
300     {
301     MoveCursor(NumOfColumns-1,CursorY-1);
302     // if (cv.HLogBuf!=0) Log1Byte(BS);
303     // (2005.2.20 yutaka)
304     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
305     }
306     }
307     else if (CursorX > 0)
308     {
309     MoveCursor(CursorX-1,CursorY);
310     // if (cv.HLogBuf!=0) Log1Byte(BS);
311     // (2005.2.20 yutaka)
312     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
313     }
314     }
315    
316     void CarriageReturn(BOOL logFlag)
317     {
318     #ifndef NO_COPYLINE_FIX
319     if (!ts.EnableContinuedLineCopy || logFlag)
320     #endif /* NO_COPYLINE_FIX */
321     if (cv.HLogBuf!=0) Log1Byte(CR);
322    
323     if (CursorX>0)
324     MoveCursor(0,CursorY);
325     }
326    
327     void LineFeed(BYTE b, BOOL logFlag)
328     {
329     /* for auto print mode */
330     if ((AutoPrintMode) &&
331     (b>=LF) && (b<=FF))
332     BuffDumpCurrentLine(b);
333    
334     #ifndef NO_COPYLINE_FIX
335     if (!ts.EnableContinuedLineCopy || logFlag)
336     #endif /* NO_COPYLINE_FIX */
337     if (cv.HLogBuf!=0) Log1Byte(LF);
338    
339     if (CursorY < CursorBottom)
340     MoveCursor(CursorX,CursorY+1);
341     else if (CursorY == CursorBottom) BuffScrollNLines(1);
342     else if (CursorY < NumOfLines-StatusLine-1)
343     MoveCursor(CursorX,CursorY+1);
344    
345     if (LFMode) CarriageReturn(logFlag);
346     }
347    
348     void Tab()
349     {
350     if (Wrap && !ts.VTCompatTab) {
351     CarriageReturn(FALSE);
352     LineFeed(LF,FALSE);
353     #ifndef NO_COPYLINE_FIX
354     if (ts.EnableContinuedLineCopy) {
355     SetLineContinued();
356     }
357     #endif /* NO_COPYLINE_FIX */
358     Wrap = FALSE;
359     }
360     CursorForwardTab(1, AutoWrapMode);
361     if (cv.HLogBuf!=0) Log1Byte(HT);
362     }
363    
364     void PutChar(BYTE b)
365     {
366     BOOL SpecialNew;
367     TCharAttr CharAttrTmp;
368    
369     CharAttrTmp = CharAttr;
370    
371     if (PrinterMode) { // printer mode
372     WriteToPrnFile(b,TRUE);
373     return;
374     }
375    
376     if (Wrap)
377     {
378     CarriageReturn(FALSE);
379     LineFeed(LF,FALSE);
380     #ifndef NO_COPYLINE_FIX
381     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
382     #endif /* NO_COPYLINE_FIX */
383     }
384    
385     // if (cv.HLogBuf!=0) Log1Byte(b);
386     // (2005.2.20 yutaka)
387     if (ts.LogTypePlainText) {
388     if (__isascii(b) && !isprint(b)) {
389     // ASCII�������A���\�������������O�����������B
390     } else {
391     if (cv.HLogBuf!=0) Log1Byte(b);
392     }
393     } else {
394     if (cv.HLogBuf!=0) Log1Byte(b);
395     }
396    
397     Wrap = FALSE;
398    
399     SpecialNew = FALSE;
400     if ((b>0x5F) && (b<0x80))
401     {
402     if (SSflag)
403     SpecialNew = (Gn[GLtmp]==IdSpecial);
404     else
405     SpecialNew = (Gn[Glr[0]]==IdSpecial);
406     }
407     else if (b>0xDF)
408     {
409     if (SSflag)
410     SpecialNew = (Gn[GLtmp]==IdSpecial);
411     else
412     SpecialNew = (Gn[Glr[1]]==IdSpecial);
413     }
414    
415     if (SpecialNew != Special)
416     {
417     UpdateStr();
418     Special = SpecialNew;
419     }
420    
421     if (Special)
422     {
423     b = b & 0x7F;
424     CharAttrTmp.Attr |= AttrSpecial;
425     }
426     else
427     CharAttrTmp.Attr |= CharAttr.Attr;
428    
429     BuffPutChar(b, CharAttrTmp, InsertMode);
430    
431     if (CursorX < NumOfColumns-1)
432     MoveRight();
433     else {
434     UpdateStr();
435     Wrap = AutoWrapMode;
436     }
437     }
438    
439     void PutDecSp(BYTE b)
440     {
441     TCharAttr CharAttrTmp;
442    
443     CharAttrTmp = CharAttr;
444    
445     if (PrinterMode) { // printer mode
446     WriteToPrnFile(b, TRUE);
447     return;
448     }
449    
450     if (Wrap) {
451     CarriageReturn(FALSE);
452     LineFeed(LF, FALSE);
453     #ifndef NO_COPYLINE_FIX
454     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
455     #endif /* NO_COPYLINE_FIX */
456     }
457    
458     if (cv.HLogBuf!=0) Log1Byte(b);
459     /*
460     if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
461     // ASCII�������A���\�������������O�����������B
462     } else {
463     if (cv.HLogBuf!=0) Log1Byte(b);
464     }
465     */
466    
467     Wrap = FALSE;
468    
469     if (!Special) {
470     UpdateStr();
471     Special = TRUE;
472     }
473    
474     CharAttrTmp.Attr |= AttrSpecial;
475     BuffPutChar(b, CharAttrTmp, InsertMode);
476    
477     if (CursorX < NumOfColumns-1)
478     MoveRight();
479     else {
480     UpdateStr();
481     Wrap = AutoWrapMode;
482     }
483     }
484    
485     void PutKanji(BYTE b)
486     {
487     #ifndef NO_COPYLINE_FIX
488     TCharAttr CharAttrTmp;
489    
490     CharAttrTmp = CharAttr;
491     #endif /* NO_COPYLINE_FIX */
492     Kanji = Kanji + b;
493    
494     if (PrinterMode && DirectPrn)
495     {
496     WriteToPrnFile(HIBYTE(Kanji),FALSE);
497     WriteToPrnFile(LOBYTE(Kanji),TRUE);
498     return;
499     }
500    
501     if (ConvJIS)
502     Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));
503    
504     if (PrinterMode) { // printer mode
505     WriteToPrnFile(HIBYTE(Kanji),FALSE);
506     WriteToPrnFile(LOBYTE(Kanji),TRUE);
507     return;
508     }
509    
510     if (Wrap)
511     {
512     CarriageReturn(FALSE);
513     LineFeed(LF,FALSE);
514     #ifndef NO_COPYLINE_FIX
515     if (ts.EnableContinuedLineCopy)
516     CharAttrTmp.Attr |= AttrLineContinued;
517     #endif /* NO_COPYLINE_FIX */
518     }
519     else if (CursorX > NumOfColumns-2)
520     if (AutoWrapMode)
521     {
522     #ifndef NO_COPYLINE_FIX
523     if (ts.EnableContinuedLineCopy)
524     {
525     CharAttrTmp.Attr |= AttrLineContinued;
526     if (CursorX == NumOfColumns-1)
527     BuffPutChar(0x20, CharAttr, FALSE);
528     }
529     #endif /* NO_COPYLINE_FIX */
530     CarriageReturn(FALSE);
531     LineFeed(LF,FALSE);
532     }
533     else return;
534    
535     Wrap = FALSE;
536    
537     if (cv.HLogBuf!=0)
538     {
539     Log1Byte(HIBYTE(Kanji));
540     Log1Byte(LOBYTE(Kanji));
541     }
542    
543     if (Special)
544     {
545     UpdateStr();
546     Special = FALSE;
547     }
548    
549     #ifndef NO_COPYLINE_FIX
550     BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
551     #else
552     BuffPutKanji(Kanji, CharAttr, InsertMode);
553     #endif /* NO_COPYLINE_FIX */
554    
555     if (CursorX < NumOfColumns-2)
556     {
557     MoveRight();
558     MoveRight();
559     }
560     else {
561     UpdateStr();
562     Wrap = AutoWrapMode;
563     }
564     }
565    
566     void PutDebugChar(BYTE b)
567     {
568     InsertMode = FALSE;
569     AutoWrapMode = TRUE;
570    
571     if ((b & 0x80) == 0x80)
572     {
573     UpdateStr();
574     CharAttr.Attr = AttrReverse;
575     b = b & 0x7f;
576     }
577    
578     if (b<=US)
579     {
580     PutChar('^');
581     PutChar((char)(b+0x40));
582     }
583     else if (b==DEL)
584     {
585     PutChar('<');
586     PutChar('D');
587     PutChar('E');
588     PutChar('L');
589     PutChar('>');
590     }
591     else
592     PutChar(b);
593    
594     if (CharAttr.Attr != AttrDefault)
595     {
596     UpdateStr();
597     CharAttr.Attr = AttrDefault;
598     }
599     }
600    
601     void PrnParseControl(BYTE b) // printer mode
602     {
603     switch (b) {
604     case NUL: return;
605     case SO:
606     if (! DirectPrn)
607     {
608     if ((ts.Language==IdJapanese) &&
609     (ts.KanjiCode==IdJIS) &&
610     (ts.JIS7Katakana==1) &&
611     ((ts.TermFlag & TF_FIXEDJIS)!=0))
612     Gn[1] = IdKatakana;
613     Glr[0] = 1; /* LS1 */
614     return;
615     }
616     break;
617     case SI:
618     if (! DirectPrn)
619     {
620     Glr[0] = 0; /* LS0 */
621     return;
622     }
623     break;
624     case DC1:
625     case DC3: return;
626     case ESC:
627     ICount = 0;
628     JustAfterESC = TRUE;
629     ParseMode = ModeESC;
630     WriteToPrnFile(0,TRUE); // flush prn buff
631     return;
632     case CSI:
633     if ((ts.TerminalID<IdVT220J) ||
634     ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0))
635     {
636     PutChar(b); /* Disp C1 char in VT100 mode */
637     return;
638     }
639     ICount = 0;
640     FirstPrm = TRUE;
641     NParam = 1;
642     Param[1] = -1;
643     Prv = 0;
644     ParseMode = ModeCSI;
645     WriteToPrnFile(0,TRUE); // flush prn buff
646     WriteToPrnFile(b,FALSE);
647     return;
648     }
649     /* send the uninterpreted character to printer */
650     WriteToPrnFile(b,TRUE);
651     }
652    
653     void ParseControl(BYTE b)
654     {
655     if (PrinterMode) { // printer mode
656     PrnParseControl(b);
657     return;
658     }
659    
660     if (b>=0x80) /* C1 char */
661     {
662     /* English mode */
663     if (ts.Language==IdEnglish)
664     {
665     if ((ts.TerminalID<IdVT220J) ||
666     ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0))
667     {
668     PutChar(b); /* Disp C1 char in VT100 mode */
669     return;
670     }
671     }
672     else { /* Japanese mode */
673     if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0)
674     return; /* ignore C1 char */
675     /* C1 chars are interpreted as C0 chars in VT100 mode */
676     if (ts.TerminalID<IdVT220J)
677     b = b & 0x7F;
678     }
679     }
680     switch (b) {
681     /* C0 group */
682     case ENQ:
683     CommBinaryOut(&cv,&(ts.Answerback[0]),ts.AnswerbackLen);
684     break;
685     case BEL:
686     switch (ts.Beep) {
687     case IdBeepOff:
688     /* nothing to do */
689     break;
690     case IdBeepOn:
691     MessageBeep(0);
692     break;
693     case IdBeepVisual:
694     VisualBell();
695     break;
696     }
697     break;
698     case BS: BackSpace(); break;
699     case HT: Tab(); break;
700    
701     case LF:
702     // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
703     // CR+LF���������������������B
704     // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
705     // (2007.1.21 yutaka)
706     if (ts.CRReceive == IdLF) {
707     CarriageReturn(TRUE);
708     LineFeed(b, TRUE);
709     break;
710     }
711    
712     case VT: LineFeed(b,TRUE); break;
713    
714     case FF:
715     if ((ts.AutoWinSwitch>0) && JustAfterESC)
716     {
717     CommInsert1Byte(&cv,b);
718     CommInsert1Byte(&cv,ESC);
719     ChangeEmu = IdTEK; /* Enter TEK Mode */
720     }
721     else
722     LineFeed(b,TRUE);
723     break;
724     case CR:
725     CarriageReturn(TRUE);
726     if (ts.CRReceive==IdCRLF)
727     CommInsert1Byte(&cv,LF);
728     break;
729     case SO:
730     if ((ts.Language==IdJapanese) &&
731     (ts.KanjiCode==IdJIS) &&
732     (ts.JIS7Katakana==1) &&
733     ((ts.TermFlag & TF_FIXEDJIS)!=0))
734     Gn[1] = IdKatakana;
735    
736     Glr[0] = 1; /* LS1 */
737     break;
738     case SI: Glr[0] = 0; break; /* LS0 */
739     case DLE:
740     if ((ts.FTFlag & FT_BPAUTO)!=0)
741     ParseMode = ModeDLE; /* Auto B-Plus activation */
742     break;
743     case CAN:
744     if ((ts.FTFlag & FT_ZAUTO)!=0)
745     ParseMode = ModeCAN; /* Auto ZMODEM activation */
746     // else if (ts.AutoWinSwitch>0)
747     // ChangeEmu = IdTEK; /* Enter TEK Mode */
748     else
749     ParseMode = ModeFirst;
750     break;
751     case SUB: ParseMode = ModeFirst; break;
752     case ESC:
753     ICount = 0;
754     JustAfterESC = TRUE;
755     ParseMode = ModeESC;
756     break;
757     case FS:
758     case GS:
759     case RS:
760     case US:
761     if (ts.AutoWinSwitch>0)
762     {
763     CommInsert1Byte(&cv,b);
764     ChangeEmu = IdTEK; /* Enter TEK Mode */
765     }
766     break;
767    
768     /* C1 char */
769     case IND: LineFeed(0,TRUE); break;
770     case NEL:
771     LineFeed(0,TRUE);
772     CarriageReturn(TRUE);
773     break;
774     case HTS: SetTabStop(); break;
775     case RI: CursorUpWithScroll(); break;
776     case SS2:
777     GLtmp = 2;
778     SSflag = TRUE;
779     break;
780     case SS3:
781     GLtmp = 3;
782     SSflag = TRUE;
783     break;
784     case DCS:
785     SavedMode = ParseMode;
786     ESCFlag = FALSE;
787     NParam = 1;
788     Param[1] = -1;
789     ParseMode = ModeDCS;
790     break;
791     case SOS:
792     SavedMode = ParseMode;
793     ESCFlag = FALSE;
794     ParseMode = ModeSOS;
795     break;
796     case CSI:
797     ICount = 0;
798     FirstPrm = TRUE;
799     NParam = 1;
800     Param[1] = -1;
801     Prv = 0;
802     ParseMode = ModeCSI;
803     break;
804     case OSC:
805     Param[1] = 0;
806     ParseMode = ModeXS;
807     break;
808     case PM:
809     case APC:
810     SavedMode = ParseMode;
811     ESCFlag = FALSE;
812     ParseMode = ModeSOS;
813     break;
814     }
815     }
816    
817     void SaveCursor()
818     {
819     int i;
820     PStatusBuff Buff;
821    
822     if ((StatusLine>0) &&
823     (CursorY==NumOfLines-1))
824     Buff = &SBuff2; // for status line
825     else
826     Buff = &SBuff1; // for main screen
827    
828     Buff->CursorX = CursorX;
829     Buff->CursorY = CursorY;
830     Buff->Attr = CharAttr;
831     Buff->Glr[0] = Glr[0];
832     Buff->Glr[1] = Glr[1];
833     for (i=0 ; i<=3; i++)
834     Buff->Gn[i] = Gn[i];
835     Buff->AutoWrapMode = AutoWrapMode;
836     Buff->RelativeOrgMode = RelativeOrgMode;
837     }
838    
839     void RestoreCursor()
840     {
841     int i;
842     PStatusBuff Buff;
843     UpdateStr();
844    
845     if ((StatusLine>0) &&
846     (CursorY==NumOfLines-1))
847     Buff = &SBuff2; // for status line
848     else
849     Buff = &SBuff1; // for main screen
850    
851     if (Buff->CursorX > NumOfColumns-1)
852     Buff->CursorX = NumOfColumns-1;
853     if (Buff->CursorY > NumOfLines-1-StatusLine)
854     Buff->CursorY = NumOfLines-1-StatusLine;
855     MoveCursor(Buff->CursorX,Buff->CursorY);
856     CharAttr = Buff->Attr;
857     Glr[0] = Buff->Glr[0];
858     Glr[1] = Buff->Glr[1];
859     for (i=0 ; i<=3; i++)
860     Gn[i] = Buff->Gn[i];
861     AutoWrapMode = Buff->AutoWrapMode;
862     RelativeOrgMode = Buff->RelativeOrgMode;
863     }
864    
865     void AnswerTerminalType()
866     {
867     char Tmp[31];
868    
869     if (ts.TerminalID<IdVT320)
870     strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
871     else
872     strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);
873    
874     switch (ts.TerminalID) {
875     case IdVT100:
876     strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
877     break;
878     case IdVT100J:
879     strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
880     break;
881     case IdVT101:
882     strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
883     break;
884     case IdVT102:
885     strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
886     break;
887     case IdVT102J:
888     strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
889     break;
890     case IdVT220J:
891     strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
892     break;
893     case IdVT282:
894     strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
895     break;
896     case IdVT320:
897     strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
898     break;
899     case IdVT382:
900     strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
901     break;
902     }
903     strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);
904    
905     CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
906     }
907    
908     void ESCSpace(BYTE b)
909     {
910     switch (b) {
911     case 'F': Send8BitMode = FALSE; break; // S7C1T
912     case 'G': Send8BitMode = TRUE; break; // S8C1T
913     }
914     }
915    
916     void ESCSharp(BYTE b)
917     {
918     switch (b) {
919     case '8': /* Fill screen with "E" */
920     BuffUpdateScroll();
921     BuffFillWithE();
922     MoveCursor(0,0);
923     ParseMode = ModeFirst;
924     break;
925     }
926     }
927    
928     /* select double byte code set */
929     void ESCDBCSSelect(BYTE b)
930     {
931     int Dist;
932    
933     if (ts.Language!=IdJapanese) return;
934    
935     switch (ICount) {
936     case 1:
937     if ((b=='@') || (b=='B'))
938     {
939     Gn[0] = IdKanji; /* Kanji -> G0 */
940     if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
941     Glr[0] = 0; /* G0->GL */
942     }
943     break;
944     case 2:
945     /* Second intermediate char must be
946     '(' or ')' or '*' or '+'. */
947     Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
948     if ((b=='1') || (b=='3') ||
949     (b=='@') || (b=='B'))
950     {
951     Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
952     if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
953     (Dist==0))
954     Glr[0] = 0; /* G0->GL */
955     }
956     break;
957     }
958     }
959    
960     void ESCSelectCode(BYTE b)
961     {
962     switch (b) {
963     case '0':
964     if (ts.AutoWinSwitch>0)
965     ChangeEmu = IdTEK; /* enter TEK mode */
966     break;
967     }
968     }
969    
970     /* select single byte code set */
971     void ESCSBCSSelect(BYTE b)
972     {
973     int Dist;
974    
975     /* Intermediate char must be
976     '(' or ')' or '*' or '+'. */
977     Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */
978    
979     switch (b) {
980     case '0': Gn[Dist] = IdSpecial; break;
981     case '<': Gn[Dist] = IdASCII; break;
982     case '>': Gn[Dist] = IdASCII; break;
983     case 'A': Gn[Dist] = IdASCII; break;
984     case 'B': Gn[Dist] = IdASCII; break;
985     case 'H': Gn[Dist] = IdASCII; break;
986     case 'I':
987     if (ts.Language==IdJapanese)
988     Gn[Dist] = IdKatakana;
989     break;
990     case 'J': Gn[Dist] = IdASCII; break;
991     }
992    
993     if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
994     (Dist==0))
995     Glr[0] = 0; /* G0->GL */
996     }
997    
998     void PrnParseEscape(BYTE b) // printer mode
999     {
1000     int i;
1001    
1002     ParseMode = ModeFirst;
1003     switch (ICount) {
1004     /* no intermediate char */
1005     case 0:
1006     switch (b) {
1007     case '[': /* CSI */
1008     ICount = 0;
1009     FirstPrm = TRUE;
1010     NParam = 1;
1011     Param[1] = -1;
1012     Prv = 0;
1013     WriteToPrnFile(ESC,FALSE);
1014     WriteToPrnFile('[',FALSE);
1015     ParseMode = ModeCSI;
1016     return;
1017     } /* end of case Icount=0 */
1018     break;
1019     /* one intermediate char */
1020     case 1:
1021     switch (IntChar[1]) {
1022     case '$':
1023     if (! DirectPrn)
1024     {
1025     ESCDBCSSelect(b);
1026     return;
1027     }
1028     break;
1029     case '(':
1030     case ')':
1031     case '*':
1032     case '+':
1033     if (! DirectPrn)
1034     {
1035     ESCSBCSSelect(b);
1036     return;
1037     }
1038     break;
1039     }
1040     break;
1041     /* two intermediate char */
1042     case 2:
1043     if ((! DirectPrn) &&
1044     (IntChar[1]=='$') &&
1045     ('('<=IntChar[2]) &&
1046     (IntChar[2]<='+'))
1047     {
1048     ESCDBCSSelect(b);
1049     return;
1050     }
1051     break;
1052     }
1053     // send the uninterpreted sequence to printer
1054     WriteToPrnFile(ESC,FALSE);
1055     for (i=1; i<=ICount; i++)
1056     WriteToPrnFile(IntChar[i],FALSE);
1057     WriteToPrnFile(b,TRUE);
1058     }
1059    
1060     void ParseEscape(BYTE b) /* b is the final char */
1061     {
1062     if (PrinterMode) { // printer mode
1063     PrnParseEscape(b);
1064     return;
1065     }
1066    
1067     switch (ICount) {
1068     /* no intermediate char */
1069     case 0:
1070     switch (b) {
1071     case '7': SaveCursor(); break;
1072     case '8': RestoreCursor(); break;
1073     case '=': AppliKeyMode = TRUE; break;
1074     case '>': AppliKeyMode = FALSE; break;
1075     case 'D': /* IND */
1076     LineFeed(0,TRUE);
1077     break;
1078     case 'E': /* NEL */
1079     MoveCursor(0,CursorY);
1080     LineFeed(0,TRUE);
1081     break;
1082     case 'H': /* HTS */
1083     SetTabStop();
1084     break;
1085     case 'M': /* RI */
1086     CursorUpWithScroll();
1087     break;
1088     case 'N': /* SS2 */
1089     GLtmp = 2;
1090     SSflag = TRUE;
1091     break;
1092     case 'O': /* SS3 */
1093     GLtmp = 3;
1094     SSflag = TRUE;
1095     break;
1096     case 'P': /* DCS */
1097     SavedMode = ParseMode;
1098     ESCFlag = FALSE;
1099     NParam = 1;
1100     Param[1] = -1;
1101     ParseMode = ModeDCS;
1102     return;
1103     case 'X': /* SOS */
1104     SavedMode = ParseMode;
1105     ESCFlag = FALSE;
1106     ParseMode = ModeSOS;
1107     return;
1108     case 'Z': AnswerTerminalType(); break;
1109     case '[': /* CSI */
1110     ICount = 0;
1111     FirstPrm = TRUE;
1112     NParam = 1;
1113     Param[1] = -1;
1114     Prv = 0;
1115     ParseMode = ModeCSI;
1116     return;
1117     case '\\': break; /* ST */
1118     case ']': /* XTERM sequence (OSC) */
1119     NParam = 1;
1120     Param[1] = 0;
1121     ParseMode = ModeXS;
1122     return;
1123     case '^':
1124     case '_': /* PM, APC */
1125     SavedMode = ParseMode;
1126     ESCFlag = FALSE;
1127     ParseMode = ModeSOS;
1128     return;
1129     case 'c': /* Hardware reset */
1130     HideStatusLine();
1131     ResetTerminal();
1132     ClearUserKey();
1133     ClearBuffer();
1134     if (ts.PortType==IdSerial) // reset serial port
1135     CommResetSerial(&ts, &cv, TRUE);
1136     break;
1137     case 'g': /* Visual Bell (screen original?) */
1138     VisualBell();
1139     break;
1140     case 'n': Glr[0] = 2; break; /* LS2 */
1141     case 'o': Glr[0] = 3; break; /* LS3 */
1142     case '|': Glr[1] = 3; break; /* LS3R */
1143     case '}': Glr[1] = 2; break; /* LS2R */
1144     case '~': Glr[1] = 1; break; /* LS1R */
1145     } /* end of case Icount=0 */
1146     break;
1147     /* one intermediate char */
1148     case 1:
1149     switch (IntChar[1]) {
1150     case ' ': ESCSpace(b); break;
1151     case '#': ESCSharp(b); break;
1152     case '$': ESCDBCSSelect(b); break;
1153     case '%': break;
1154     case '(':
1155     case ')':
1156     case '*':
1157     case '+':
1158     ESCSBCSSelect(b);
1159     break;
1160     }
1161     break;
1162     /* two intermediate char */
1163     case 2:
1164     if ((IntChar[1]=='$') &&
1165     ('('<=IntChar[2]) &&
1166     (IntChar[2]<='+'))
1167     ESCDBCSSelect(b);
1168     else if ((IntChar[1]=='%') &&
1169     (IntChar[2]=='!'))
1170     ESCSelectCode(b);
1171     break;
1172     }
1173     ParseMode = ModeFirst;
1174     }
1175    
1176     void EscapeSequence(BYTE b)
1177     {
1178     if (b<=US)
1179     ParseControl(b);
1180     else if ((b>=0x20) && (b<=0x2F))
1181     {
1182     if (ICount<IntCharMax) ICount++;
1183     IntChar[ICount] = b;
1184     }
1185     else if ((b>=0x30) && (b<=0x7E))
1186     ParseEscape(b);
1187     else if ((b>=0x80) && (b<=0x9F))
1188     ParseControl(b);
1189    
1190     JustAfterESC = FALSE;
1191     }
1192    
1193     void CSInsertCharacter()
1194     {
1195     // Insert space characters at cursor
1196     int Count;
1197    
1198     BuffUpdateScroll();
1199     if (Param[1]<1) Param[1] = 1;
1200     Count = Param[1];
1201     BuffInsertSpace(Count);
1202     }
1203    
1204     void CSCursorUp()
1205     {
1206     if (Param[1]<1) Param[1] = 1;
1207    
1208     if (CursorY >= CursorTop)
1209     {
1210     if (CursorY-Param[1] > CursorTop)
1211     MoveCursor(CursorX,CursorY-Param[1]);
1212     else
1213     MoveCursor(CursorX,CursorTop);
1214     }
1215     else {
1216     if (CursorY > 0)
1217     MoveCursor(CursorX,CursorY-Param[1]);
1218     else
1219     MoveCursor(CursorX,0);
1220     }
1221     }
1222    
1223     void CSCursorUp1()
1224     {
1225     MoveCursor(0,CursorY);
1226     CSCursorUp();
1227     }
1228    
1229     void CSCursorDown()
1230     {
1231     if (Param[1]<1) Param[1] = 1;
1232    
1233     if (CursorY <= CursorBottom)
1234     {
1235     if (CursorY+Param[1] < CursorBottom)
1236     MoveCursor(CursorX,CursorY+Param[1]);
1237     else
1238     MoveCursor(CursorX,CursorBottom);
1239     }
1240     else {
1241     if (CursorY < NumOfLines-StatusLine-1)
1242     MoveCursor(CursorX,CursorY+Param[1]);
1243     else
1244     MoveCursor(CursorX,NumOfLines-StatusLine);
1245     }
1246     }
1247    
1248     void CSCursorDown1()
1249     {
1250     MoveCursor(0,CursorY);
1251     CSCursorDown();
1252     }
1253    
1254     void CSScreenErase()
1255     {
1256     if (Param[1] == -1) Param[1] = 0;
1257     BuffUpdateScroll();
1258     switch (Param[1]) {
1259     case 0:
1260     // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
1261     // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
1262     // �����������������B(2005.5.29 yutaka)
1263     // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
1264     if (ts.ScrollWindowClearScreen &&
1265     (CursorX == 0 && CursorY == 0)) {
1266     // Erase screen (scroll out)
1267     BuffClearScreen();
1268     UpdateWindow(HVTWin);
1269    
1270     } else {
1271     // Erase characters from cursor to the end of screen
1272     BuffEraseCurToEnd();
1273     }
1274     break;
1275    
1276     case 1:
1277     // Erase characters from home to cursor
1278     BuffEraseHomeToCur();
1279     break;
1280    
1281     case 2:
1282     // Erase screen (scroll out)
1283     BuffClearScreen();
1284     UpdateWindow(HVTWin);
1285     break;
1286     }
1287     }
1288    
1289     void CSInsertLine()
1290     {
1291     // Insert lines at current position
1292     int Count, YEnd;
1293    
1294     if (CursorY < CursorTop) return;
1295     if (CursorY > CursorBottom) return;
1296     if (Param[1]<1) Param[1] = 1;
1297     Count = Param[1];
1298    
1299     YEnd = CursorBottom;
1300     if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1301     if (Count > YEnd+1 - CursorY) Count = YEnd+1 - CursorY;
1302    
1303     BuffInsertLines(Count,YEnd);
1304     }
1305    
1306     void CSLineErase()
1307     {
1308     if (Param[1] == -1) Param[1] = 0;
1309     BuffUpdateScroll();
1310     switch (Param[1]) {
1311     /* erase char from cursor to end of line */
1312     case 0:
1313     BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1314     break;
1315     /* erase char from start of line to cursor */
1316     case 1:
1317     BuffEraseCharsInLine(0,CursorX+1);
1318     break;
1319     /* erase entire line */
1320     case 2:
1321     BuffEraseCharsInLine(0,NumOfColumns);
1322     break;
1323     }
1324     }
1325    
1326     void CSDeleteNLines()
1327     // Delete lines from current line
1328     {
1329     int Count, YEnd;
1330    
1331     if (CursorY < CursorTop) return;
1332     if (CursorY > CursorBottom) return;
1333     Count = Param[1];
1334     if (Count<1) Count = 1;
1335    
1336     YEnd = CursorBottom;
1337     if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1338     if (Count > YEnd+1-CursorY) Count = YEnd+1-CursorY;
1339     BuffDeleteLines(Count,YEnd);
1340     }
1341    
1342     void CSDeleteCharacter()
1343     {
1344     // Delete characters in current line from cursor
1345    
1346     if (Param[1]<1) Param[1] = 1;
1347     BuffUpdateScroll();
1348     BuffDeleteChars(Param[1]);
1349     }
1350    
1351     void CSEraseCharacter()
1352     {
1353     if (Param[1]<1) Param[1] = 1;
1354     BuffUpdateScroll();
1355     BuffEraseChars(Param[1]);
1356     }
1357    
1358     void CSScrollUP()
1359     {
1360     if (Param[1]<1) Param[1] = 1;
1361     BuffUpdateScroll();
1362     BuffRegionScrollUpNLines(Param[1]);
1363     }
1364    
1365     void CSScrollDown()
1366     {
1367     if (Param[1]<1) Param[1] = 1;
1368     BuffUpdateScroll();
1369     BuffRegionScrollDownNLines(Param[1]);
1370     }
1371    
1372     void CSForwardTab()
1373     {
1374     if (Param[1]<1) Param[1] = 1;
1375     CursorForwardTab(Param[1], AutoWrapMode);
1376     }
1377    
1378     void CSBackwardTab()
1379     {
1380     if (Param[1]<1) Param[1] = 1;
1381     CursorBackwardTab(Param[1]);
1382     }
1383    
1384     void CSMoveToColumnN()
1385     {
1386     if (Param[1]<1) Param[1] = 1;
1387     Param[1]--;
1388     if (Param[1] < 0) Param[1] = 0;
1389     if (Param[1] > NumOfColumns-1) Param[1] = NumOfColumns-1;
1390     MoveCursor(Param[1],CursorY);
1391     }
1392    
1393     void CSCursorRight()
1394     {
1395     if (Param[1]<1) Param[1] = 1;
1396     if (CursorX + Param[1] > NumOfColumns-1)
1397     MoveCursor(NumOfColumns-1,CursorY);
1398     else
1399     MoveCursor(CursorX+Param[1],CursorY);
1400     }
1401    
1402     void CSCursorLeft()
1403     {
1404     if (Param[1]<1) Param[1] = 1;
1405     if (CursorX-Param[1] < 0)
1406     MoveCursor(0,CursorY);
1407     else
1408     MoveCursor(CursorX-Param[1],CursorY);
1409     }
1410    
1411     void CSMoveToLineN()
1412     {
1413     if (Param[1]<1) Param[1] = 1;
1414     if (RelativeOrgMode)
1415     {
1416     if (CursorTop+Param[1]-1 > CursorBottom)
1417     MoveCursor(CursorX,CursorBottom);
1418     else
1419     MoveCursor(CursorX,CursorTop+Param[1]-1);
1420     }
1421     else {
1422     if (Param[1] > NumOfLines-StatusLine)
1423     MoveCursor(CursorX,NumOfLines-1-StatusLine);
1424     else
1425     MoveCursor(CursorX,Param[1]-1);
1426     }
1427     }
1428    
1429     void CSMoveToXY()
1430     {
1431     int NewX, NewY;
1432    
1433     if (Param[1]<1) Param[1] = 1;
1434     if ((NParam < 2) || (Param[2]<1)) Param[2] = 1;
1435     NewX = Param[2] - 1;
1436     if (NewX > NumOfColumns-1) NewX = NumOfColumns-1;
1437    
1438     if ((StatusLine>0) && (CursorY==NumOfLines-1))
1439     NewY = CursorY;
1440     else if (RelativeOrgMode)
1441     {
1442     NewY = CursorTop + Param[1] - 1;
1443     if (NewY > CursorBottom) NewY = CursorBottom;
1444     }
1445     else {
1446     NewY = Param[1] - 1;
1447     if (NewY > NumOfLines-1-StatusLine)
1448     NewY = NumOfLines-1-StatusLine;
1449     }
1450     MoveCursor(NewX,NewY);
1451     }
1452    
1453     void CSDeleteTabStop()
1454     {
1455     if (Param[1]==-1) Param[1] = 0;
1456     ClearTabStop(Param[1]);
1457     }
1458    
1459     void CS_h_Mode()
1460     {
1461     switch (Param[1]) {
1462 doda 3311 case 2: // KAM
1463     KeybEnabled = FALSE; break;
1464     case 4: // IRM
1465     InsertMode = TRUE; break;
1466     case 12: // SRM
1467 maya 3227 ts.LocalEcho = 0;
1468     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1469     TelChangeEcho();
1470     break;
1471 doda 3311 case 20: // LF/NL
1472 maya 3227 LFMode = TRUE;
1473     ts.CRSend = IdCRLF;
1474     cv.CRSend = IdCRLF;
1475     break;
1476 doda 3311 case 33: // WYSTCURM
1477 doda 3273 ts.NonblinkingCursor = TRUE;
1478     ChangeCaret();
1479     break;
1480 doda 3311 case 34: // WYULCURM
1481 doda 3273 ts.CursorShape = IdHCur;
1482     ChangeCaret();
1483     break;
1484 maya 3227 }
1485     }
1486    
1487     void CS_i_Mode()
1488     {
1489     if (Param[1]==-1) Param[1] = 0;
1490     switch (Param[1]) {
1491     /* print screen */
1492     // PrintEX -- TRUE: print screen
1493     // FALSE: scroll region
1494     case 0: BuffPrint(! PrintEX); break;
1495     /* printer controller mode off */
1496     case 4: break; /* See PrnParseCS() */
1497     /* printer controller mode on */
1498     case 5:
1499     if (! AutoPrintMode)
1500     OpenPrnFile();
1501     DirectPrn = (ts.PrnDev[0]!=0);
1502     PrinterMode = TRUE;
1503     break;
1504     }
1505     }
1506    
1507     void CS_l_Mode()
1508     {
1509     switch (Param[1]) {
1510 doda 3311 case 2: // KAM
1511     KeybEnabled = TRUE; break;
1512     case 4: // IRM
1513     InsertMode = FALSE; break;
1514     case 12: // SRM
1515 maya 3227 ts.LocalEcho = 1;
1516     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1517     TelChangeEcho();
1518     break;
1519 doda 3311 case 20: // LF/NL
1520 maya 3227 LFMode = FALSE;
1521     ts.CRSend = IdCR;
1522     cv.CRSend = IdCR;
1523     break;
1524 doda 3311 case 33: // WYSTCURM
1525 doda 3273 ts.NonblinkingCursor = FALSE;
1526     ChangeCaret();
1527     break;
1528 doda 3311 case 34: // WYULCURM
1529 doda 3273 ts.CursorShape = IdBlkCur;
1530     ChangeCaret();
1531     break;
1532 maya 3227 }
1533     }
1534    
1535     void CS_n_Mode()
1536     {
1537     char Report[16];
1538     int Y;
1539    
1540     switch (Param[1]) {
1541     case 5:
1542 doda 3311 /* Device Status Report -> Ready */
1543 maya 3227 if (Send8BitMode)
1544 doda 3311 CommBinaryOut(&cv,"\2330n",3);
1545 maya 3227 else
1546 doda 3311 CommBinaryOut(&cv,"\033[0n",4);
1547 maya 3227 break;
1548     case 6:
1549     /* Cursor Position Report */
1550     Y = CursorY+1;
1551     if ((StatusLine>0) &&
1552     (Y==NumOfLines))
1553     Y = 1;
1554     if (Send8BitMode)
1555     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\233%u;%uR", CLocale, Y, CursorX+1);
1556     else
1557     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\033[%u;%uR", CLocale, Y, CursorX+1);
1558     CommBinaryOut(&cv,Report,strlen(Report));
1559     break;
1560     }
1561     }
1562    
1563     void CSSetAttr()
1564     {
1565     int i, P;
1566    
1567     UpdateStr();
1568     for (i=1 ; i<=NParam ; i++)
1569     {
1570     P = Param[i];
1571     if (P<0) P = 0;
1572     switch (P) {
1573     case 0: /* Clear all */
1574     CharAttr = DefCharAttr;
1575     BuffSetCurCharAttr(CharAttr);
1576     break;
1577    
1578     case 1: /* Bold */
1579     CharAttr.Attr |= AttrBold;
1580     BuffSetCurCharAttr(CharAttr);
1581     break;
1582    
1583     case 4: /* Under line */
1584     CharAttr.Attr |= AttrUnder;
1585     BuffSetCurCharAttr(CharAttr);
1586     break;
1587    
1588     case 5: /* Blink */
1589     CharAttr.Attr |= AttrBlink;
1590     BuffSetCurCharAttr(CharAttr);
1591     break;
1592    
1593     case 7: /* Reverse */
1594     CharAttr.Attr |= AttrReverse;
1595     BuffSetCurCharAttr(CharAttr);
1596     break;
1597    
1598     case 22: /* Bold off */
1599     CharAttr.Attr &= ~ AttrBold;
1600     BuffSetCurCharAttr(CharAttr);
1601     break;
1602    
1603     case 24: /* Under line off */
1604     CharAttr.Attr &= ~ AttrUnder;
1605     BuffSetCurCharAttr(CharAttr);
1606     break;
1607    
1608     case 25: /* Blink off */
1609     CharAttr.Attr &= ~ AttrBlink;
1610     BuffSetCurCharAttr(CharAttr);
1611     break;
1612    
1613     case 27: /* Reverse off */
1614     CharAttr.Attr &= ~ AttrReverse;
1615     BuffSetCurCharAttr(CharAttr);
1616     break;
1617    
1618     case 30:
1619     case 31:
1620     case 32:
1621     case 33:
1622     case 34:
1623     case 35:
1624     case 36:
1625     case 37: /* text color */
1626     CharAttr.Attr2 |= Attr2Fore;
1627     CharAttr.Fore = P - 30;
1628     BuffSetCurCharAttr(CharAttr);
1629     break;
1630    
1631     case 38: /* text color (256color mode) */
1632     if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1633     i++;
1634     if (i < NParam) {
1635     P = Param[++i];
1636     if (P<0) {
1637     P = 0;
1638     }
1639     CharAttr.Attr2 |= Attr2Fore;
1640     CharAttr.Fore = P;
1641     BuffSetCurCharAttr(CharAttr);
1642     }
1643     }
1644     break;
1645    
1646     case 39: /* Reset text color */
1647     CharAttr.Attr2 &= ~ Attr2Fore;
1648     CharAttr.Fore = AttrDefaultFG;
1649     BuffSetCurCharAttr(CharAttr);
1650     break;
1651    
1652     case 40:
1653     case 41:
1654     case 42:
1655     case 43:
1656     case 44:
1657     case 45:
1658     case 46:
1659     case 47: /* Back color */
1660     CharAttr.Attr2 |= Attr2Back;
1661     CharAttr.Back = P - 40;
1662     BuffSetCurCharAttr(CharAttr);
1663     break;
1664    
1665     case 48: /* Back color (256color mode) */
1666     if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1667     i++;
1668     if (i < NParam) {
1669     P = Param[++i];
1670     if (P<0) {
1671     P = 0;
1672     }
1673     CharAttr.Attr2 |= Attr2Back;
1674     CharAttr.Back = P;
1675     BuffSetCurCharAttr(CharAttr);
1676     }
1677     }
1678     break;
1679    
1680     case 49: /* Reset back color */
1681     CharAttr.Attr2 &= ~ Attr2Back;
1682     CharAttr.Back = AttrDefaultBG;
1683     BuffSetCurCharAttr(CharAttr);
1684     break;
1685    
1686     case 90:
1687     case 91:
1688     case 92:
1689     case 93:
1690     case 94:
1691     case 95:
1692     case 96:
1693     case 97: /* aixterm style text color */
1694     if (ts.ColorFlag & CF_AIXTERM16) {
1695     CharAttr.Attr2 |= Attr2Fore;
1696     CharAttr.Fore = P - 90 + 8;
1697     BuffSetCurCharAttr(CharAttr);
1698     }
1699     break;
1700    
1701     case 100:
1702     if (! (ts.ColorFlag & CF_AIXTERM16)) {
1703     /* Reset text and back color */
1704     CharAttr.Attr2 &= ~ (Attr2Fore | Attr2Back);
1705     CharAttr.Fore = AttrDefaultFG;
1706     CharAttr.Back = AttrDefaultBG;
1707     BuffSetCurCharAttr(CharAttr);
1708     break;
1709     }
1710     /* fall through to aixterm style back color */
1711    
1712     case 101:
1713     case 102:
1714     case 103:
1715     case 104:
1716     case 105:
1717     case 106:
1718     case 107: /* aixterm style back color */
1719     if (ts.ColorFlag & CF_AIXTERM16) {
1720     CharAttr.Attr2 |= Attr2Back;
1721     CharAttr.Back = P - 100 + 8;
1722     BuffSetCurCharAttr(CharAttr);
1723     }
1724     break;
1725     }
1726     }
1727     }
1728    
1729     void CSSetScrollRegion()
1730     {
1731     if ((StatusLine>0) &&
1732     (CursorY==NumOfLines-1))
1733     {
1734     MoveCursor(0,CursorY);
1735     return;
1736     }
1737     if (Param[1]<1) Param[1] =1;
1738     if ((NParam < 2) | (Param[2]<1))
1739     Param[2] = NumOfLines-StatusLine;
1740     Param[1]--;
1741     Param[2]--;
1742     if (Param[1] > NumOfLines-1-StatusLine)
1743     Param[1] = NumOfLines-1-StatusLine;
1744     if (Param[2] > NumOfLines-1-StatusLine)
1745     Param[2] = NumOfLines-1-StatusLine;
1746     if (Param[1] >= Param[2]) return;
1747     CursorTop = Param[1];
1748     CursorBottom = Param[2];
1749     if (RelativeOrgMode) MoveCursor(0,CursorTop);
1750     else MoveCursor(0,0);
1751     }
1752    
1753     void CSSunSequence() /* Sun terminal private sequences */
1754     {
1755     char Report[16];
1756    
1757     switch (Param[1]) {
1758 doda 3302 case 1: // De-iconify window
1759 doda 3309 DispShowWindow(WINDOW_RESTORE);
1760 doda 3302 break;
1761     case 2: // Iconify window
1762 doda 3309 DispShowWindow(WINDOW_MINIMIZE);
1763 doda 3302 break;
1764     case 3: // set window position
1765 doda 3297 if (NParam < 2) Param[2] = 0;
1766     if (NParam < 3) Param[3] = 0;
1767     DispMoveWindow(Param[2], Param[3]);
1768     break;
1769 doda 3311 case 5: // Raise window
1770 doda 3309 DispShowWindow(WINDOW_RAISE);
1771     break;
1772 doda 3311 case 6: // Lower window
1773 doda 3309 DispShowWindow(WINDOW_LOWER);
1774     break;
1775 doda 3311 case 7: // Refresh window
1776 doda 3310 DispShowWindow(WINDOW_REFRESH);
1777     break;
1778 maya 3227 case 8: /* set terminal size */
1779     if ((Param[2]<=1) || (NParam<2)) Param[2] = 24;
1780     if ((Param[3]<=1) || (NParam<3)) Param[3] = 80;
1781     ChangeTerminalSize(Param[3],Param[2]);
1782     break;
1783 doda 3302 case 9: // Maximize/Restore window
1784     if (NParam < 2 || Param[2] == 0) {
1785 doda 3309 DispShowWindow(WINDOW_RESTORE);
1786 doda 3302 }
1787     else {
1788 doda 3309 DispShowWindow(WINDOW_MAXIMIZE);
1789 doda 3302 }
1790     break;
1791 maya 3227 case 14: /* get window size??? */
1792     /* this is not actual window size */
1793     if (Send8BitMode)
1794     CommBinaryOut(&cv,"\2334;640;480t",11);
1795     else
1796     CommBinaryOut(&cv,"\033[4;640;480t",12);
1797     break;
1798     case 18: /* get terminal size */
1799     if (Send8BitMode)
1800     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\2338;%u;%u;t", CLocale, NumOfLines-StatusLine, NumOfColumns);
1801     else
1802     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\033[8;%u;%u;t", CLocale, NumOfLines-StatusLine, NumOfColumns);
1803     CommBinaryOut(&cv,Report,strlen(Report));
1804     break;
1805     }
1806     }
1807    
1808     void CSGT(BYTE b)
1809     {
1810     switch (b) {
1811 doda 3311 case 'c': /* second terminal report (Secondary DA) */
1812 maya 3227 if (Send8BitMode)
1813     CommBinaryOut(&cv,"\233>32;10;2c",11); /* VT382 */
1814     else
1815     CommBinaryOut(&cv,"\033[>32;10;2c",11); /* VT382 */
1816     break;
1817     case 'J':
1818     if (Param[1]==3) // IO-8256 terminal
1819     {
1820     if (Param[2]<1) Param[2]=1;
1821     if (Param[3]<1) Param[3]=1;
1822     if (Param[4]<1) Param[4]=1;
1823     if (Param[5]<1) Param[5]=1;
1824     BuffEraseBox(Param[3]-1,Param[2]-1,
1825     Param[5]-1,Param[4]-1);
1826     }
1827     break;
1828     case 'K':
1829     if ((NParam>=2) && (Param[1]==5))
1830     { // IO-8256 terminal
1831     switch (Param[2]) {
1832     case 3:
1833     case 4:
1834     case 5:
1835     case 6:
1836     BuffDrawLine(CharAttr, Param[2], Param[3]);
1837     break;
1838     case 12:
1839     /* Text color */
1840     if ((Param[3]>=0) && (Param[3]<=7))
1841     {
1842     switch (Param[3]) {
1843     case 3: CharAttr.Fore = IdBlue; break;
1844     case 4: CharAttr.Fore = IdCyan; break;
1845     case 5: CharAttr.Fore = IdYellow; break;
1846     case 6: CharAttr.Fore = IdMagenta; break;
1847     default: CharAttr.Fore = Param[3]; break;
1848     }
1849     CharAttr.Attr2 |= Attr2Fore;
1850     BuffSetCurCharAttr(CharAttr);
1851     }
1852     break;
1853     }
1854     }
1855     else if (Param[1]==3)
1856     {// IO-8256 terminal
1857     if (Param[2]<1) Param[2] = 1;
1858     if (Param[3]<1) Param[2] = 1;
1859     BuffEraseCharsInLine(Param[2]-1,Param[3]-Param[2]+1);
1860     }
1861     break;
1862     }
1863     }
1864    
1865     void CSQExchangeColor()
1866     {
1867     COLORREF ColorRef;
1868    
1869     BuffUpdateScroll();
1870    
1871     if (ts.ColorFlag & CF_REVERSECOLOR) {
1872     ColorRef = ts.VTColor[0];
1873     ts.VTColor[0] = ts.VTReverseColor[0];
1874     ts.VTReverseColor[0] = ColorRef;
1875     ColorRef = ts.VTColor[1];
1876     ts.VTColor[1] = ts.VTReverseColor[1];
1877     ts.VTReverseColor[1] = ColorRef;
1878     }
1879     else {
1880     ColorRef = ts.VTColor[0];
1881     ts.VTColor[0] = ts.VTColor[1];
1882     ts.VTColor[1] = ColorRef;
1883     }
1884    
1885     ColorRef = ts.VTBoldColor[0];
1886     ts.VTBoldColor[0] = ts.VTBoldColor[1];
1887     ts.VTBoldColor[1] = ColorRef;
1888    
1889     ColorRef = ts.VTBlinkColor[0];
1890     ts.VTBlinkColor[0] = ts.VTBlinkColor[1];
1891     ts.VTBlinkColor[1] = ColorRef;
1892    
1893     ColorRef = ts.URLColor[0];
1894     ts.URLColor[0] = ts.URLColor[1];
1895     ts.URLColor[1] = ColorRef;
1896    
1897     ts.ColorFlag ^= CF_REVERSEVIDEO;
1898    
1899     #ifdef ALPHABLEND_TYPE2
1900     BGInitialize();
1901     #endif
1902     DispChangeBackground();
1903     UpdateWindow(HVTWin);
1904     }
1905    
1906     void CSQ_h_Mode()
1907     {
1908     int i;
1909    
1910     for (i = 1 ; i<=NParam ; i++)
1911     switch (Param[i]) {
1912     case 1: AppliCursorMode = TRUE; break;
1913     case 3:
1914     ChangeTerminalSize(132,NumOfLines-StatusLine);
1915     break;
1916     case 5: /* Reverse Video */
1917     if (!(ts.ColorFlag & CF_REVERSEVIDEO))
1918     CSQExchangeColor(); /* Exchange text/back color */
1919     break;
1920     case 6:
1921     if ((StatusLine>0) &&
1922     (CursorY==NumOfLines-1))
1923     MoveCursor(0,CursorY);
1924     else {
1925     RelativeOrgMode = TRUE;
1926     MoveCursor(0,CursorTop);
1927     }
1928     break;
1929     case 7: AutoWrapMode = TRUE; break;
1930     case 8: AutoRepeatMode = TRUE; break;
1931     case 9:
1932     if (ts.MouseEventTracking)
1933     MouseReportMode = IdMouseTrackX10;
1934     break;
1935 doda 3296 case 12: ts.NonblinkingCursor = FALSE; ChangeCaret(); break;
1936 maya 3227 case 19: PrintEX = TRUE; break;
1937     case 25: DispEnableCaret(TRUE); break; // cursor on
1938     case 38:
1939     if (ts.AutoWinSwitch>0)
1940     ChangeEmu = IdTEK; /* Enter TEK Mode */
1941     break;
1942     case 59:
1943     if (ts.Language==IdJapanese)
1944     { /* kanji terminal */
1945     Gn[0] = IdASCII;
1946     Gn[1] = IdKatakana;
1947     Gn[2] = IdKatakana;
1948     Gn[3] = IdKanji;
1949     Glr[0] = 0;
1950     if ((ts.KanjiCode==IdJIS) &&
1951     (ts.JIS7Katakana==0))
1952     Glr[1] = 2; // 8-bit katakana
1953     else
1954     Glr[1] = 3;
1955     }
1956     break;
1957     case 66: AppliKeyMode = TRUE; break;
1958     case 67: ts.BSKey = IdBS; break;
1959     case 1000:
1960     if (ts.MouseEventTracking)
1961     MouseReportMode = IdMouseTrackVT200;
1962     break;
1963     case 1001:
1964     if (ts.MouseEventTracking)
1965     MouseReportMode = IdMouseTrackVT200Hl;
1966     break;
1967     case 1002:
1968     if (ts.MouseEventTracking)
1969     MouseReportMode = IdMouseTrackBtnEvent;
1970     break;
1971     case 1003:
1972     if (ts.MouseEventTracking)
1973     MouseReportMode = IdMouseTrackAllEvent;
1974     break;
1975     case 1004:
1976     if (ts.MouseEventTracking)
1977     FocusReportMode = TRUE;
1978     break;
1979     }
1980     }
1981    
1982     void CSQ_i_Mode()
1983     {
1984     if (Param[1]==-1) Param[1] = 0;
1985     switch (Param[1]) {
1986     case 1:
1987     OpenPrnFile();
1988     BuffDumpCurrentLine(LF);
1989     if (! AutoPrintMode)
1990     ClosePrnFile();
1991     break;
1992     /* auto print mode off */
1993     case 4:
1994     if (AutoPrintMode)
1995     {
1996     ClosePrnFile();
1997     AutoPrintMode = FALSE;
1998     }
1999     break;
2000     /* auto print mode on */
2001     case 5:
2002     if (! AutoPrintMode)
2003     {
2004     OpenPrnFile();
2005     AutoPrintMode = TRUE;
2006     }
2007     break;
2008     }
2009     }
2010    
2011     void CSQ_l_Mode()
2012     {
2013     int i;
2014    
2015     for (i = 1 ; i <= NParam ; i++)
2016     switch (Param[i]) {
2017     case 1: AppliCursorMode = FALSE; break;
2018     case 3:
2019     ChangeTerminalSize(80,NumOfLines-StatusLine);
2020     break;
2021     case 5: /* Normal Video */
2022     if (ts.ColorFlag & CF_REVERSEVIDEO)
2023     CSQExchangeColor(); /* Exchange text/back color */
2024     break;
2025     case 6:
2026     if ((StatusLine>0) &&
2027     (CursorY==NumOfLines-1))
2028     MoveCursor(0,CursorY);
2029     else {
2030     RelativeOrgMode = FALSE;
2031     MoveCursor(0,0);
2032     }
2033     break;
2034     case 7: AutoWrapMode = FALSE; break;
2035     case 8: AutoRepeatMode = FALSE; break;
2036     case 9: MouseReportMode = IdMouseTrackNone; break;
2037 doda 3296 case 12: ts.NonblinkingCursor = TRUE; ChangeCaret(); break;
2038 maya 3227 case 19: PrintEX = FALSE; break;
2039     case 25: DispEnableCaret(FALSE); break; // cursor off
2040     case 59:
2041     if (ts.Language==IdJapanese)
2042     { /* katakana terminal */
2043     Gn[0] = IdASCII;
2044     Gn[1] = IdKatakana;
2045     Gn[2] = IdKatakana;
2046     Gn[3] = IdKanji;
2047     Glr[0] = 0;
2048     if ((ts.KanjiCode==IdJIS) &&
2049     (ts.JIS7Katakana==0))
2050     Glr[1] = 2; // 8-bit katakana
2051     else
2052     Glr[1] = 3;
2053     }
2054     break;
2055     case 66: AppliKeyMode = FALSE; break;
2056     case 67: ts.BSKey = IdDEL; break;
2057     case 1000:
2058     case 1001:
2059     case 1002:
2060     case 1003: MouseReportMode = IdMouseTrackNone; break;
2061     case 1004: FocusReportMode = FALSE; break;
2062     }
2063     }
2064    
2065     void CSQ_n_Mode()
2066     {
2067     }
2068    
2069     void CSQuest(BYTE b)
2070     {
2071     switch (b) {
2072     case 'K': CSLineErase(); break;
2073     case 'h': CSQ_h_Mode(); break;
2074     case 'i': CSQ_i_Mode(); break;
2075     case 'l': CSQ_l_Mode(); break;
2076     case 'n': CSQ_n_Mode(); break;
2077     }
2078     }
2079    
2080     void SoftReset()
2081     // called by software-reset escape sequence handler
2082     {
2083     UpdateStr();
2084     AutoRepeatMode = TRUE;
2085     DispEnableCaret(TRUE); // cursor on
2086     InsertMode = FALSE;
2087     RelativeOrgMode = FALSE;
2088     AppliKeyMode = FALSE;
2089     AppliCursorMode = FALSE;
2090     if ((StatusLine>0) &&
2091     (CursorY == NumOfLines-1))
2092     MoveToMainScreen();
2093     CursorTop = 0;
2094     CursorBottom = NumOfLines-1-StatusLine;
2095     ResetCharSet();
2096    
2097     Send8BitMode = ts.Send8BitCtrl;
2098    
2099     /* Attribute */
2100     CharAttr = DefCharAttr;
2101     Special = FALSE;
2102     BuffSetCurCharAttr(CharAttr);
2103    
2104     // status buffers
2105     ResetSBuffers();
2106     }
2107    
2108     void CSExc(BYTE b)
2109     {
2110     switch (b) {
2111     case 'p':
2112     /* Software reset */
2113     SoftReset();
2114     break;
2115     }
2116     }
2117    
2118     void CSDouble(BYTE b)
2119     {
2120     switch (b) {
2121     case 'p':
2122     /* Select terminal mode (software reset) */
2123     SoftReset();
2124     if (NParam > 0) {
2125     switch (Param[1]) {
2126     case 61: // VT100 Mode
2127     Send8BitMode = FALSE; break;
2128     case 62: // VT200 Mode
2129     case 63: // VT300 Mode
2130     case 64: // VT400 Mode
2131     if (NParam > 1 && Param[2] == 1)
2132     Send8BitMode = FALSE;
2133     else
2134     Send8BitMode = TRUE;
2135     break;
2136     }
2137     }
2138     break;
2139     }
2140     }
2141    
2142     void CSDol(BYTE b)
2143     {
2144     switch (b) {
2145     case '}':
2146     if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2147     if (StatusLine==0) return;
2148     if ((Param[1]<1) && (CursorY==NumOfLines-1))
2149     MoveToMainScreen();
2150     else if ((Param[1]==1) && (CursorY<NumOfLines-1))
2151     MoveToStatusLine();
2152     break;
2153     case '~':
2154     if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2155     if (Param[1]<=1)
2156     HideStatusLine();
2157     else if ((StatusLine==0) && (Param[1]==2))
2158     ShowStatusLine(1); // show
2159     break;
2160     }
2161     }
2162    
2163 doda 3263 void CSSpace(BYTE b) {
2164     switch (b) {
2165     case 'q':
2166     if (NParam > 0) {
2167     if (Param[1] < 0) Param[1] = 0;
2168     switch (Param[1]) {
2169     case 0:
2170     case 1:
2171     ts.CursorShape = IdBlkCur;
2172     ts.NonblinkingCursor = FALSE;
2173     break;
2174     case 2:
2175     ts.CursorShape = IdBlkCur;
2176     ts.NonblinkingCursor = TRUE;
2177     break;
2178     case 3:
2179     ts.CursorShape = IdHCur;
2180     ts.NonblinkingCursor = FALSE;
2181     break;
2182     case 4:
2183     ts.CursorShape = IdHCur;
2184     ts.NonblinkingCursor = TRUE;
2185     break;
2186 doda 3265 case 5:
2187     ts.CursorShape = IdVCur;
2188     ts.NonblinkingCursor = FALSE;
2189     break;
2190     case 6:
2191     ts.CursorShape = IdVCur;
2192     ts.NonblinkingCursor = TRUE;
2193     break;
2194 doda 3263 default:
2195     return;
2196     }
2197     ChangeCaret();
2198     }
2199     break;
2200     }
2201     }
2202    
2203 maya 3227 void PrnParseCS(BYTE b) // printer mode
2204     {
2205     ParseMode = ModeFirst;
2206     switch (ICount) {
2207     /* no intermediate char */
2208     case 0:
2209     switch (Prv) {
2210     /* no private parameter */
2211     case 0:
2212     switch (b) {
2213     case 'i':
2214     if (Param[1]==4)
2215     {
2216     PrinterMode = FALSE;
2217     // clear prn buff
2218     WriteToPrnFile(0,FALSE);
2219     if (! AutoPrintMode)
2220     ClosePrnFile();
2221     return;
2222     }
2223     break;
2224     } /* of case Prv=0 */
2225     break;
2226     }
2227     break;
2228     /* one intermediate char */
2229     case 1: break;
2230     } /* of case Icount */
2231    
2232     WriteToPrnFile(b,TRUE);
2233     }
2234    
2235     void ParseCS(BYTE b) /* b is the final char */
2236     {
2237     if (PrinterMode) { // printer mode
2238     PrnParseCS(b);
2239     return;
2240     }
2241    
2242     switch (ICount) {
2243     /* no intermediate char */
2244     case 0:
2245     switch (Prv) {
2246     /* no private parameter */
2247     case 0:
2248     switch (b) {
2249 doda 3311 // ISO/IEC 6429 / ECMA-48 Sequence
2250     case '@': CSInsertCharacter(); break; // ICH
2251     case 'A': CSCursorUp(); break; // CUU
2252     case 'B': CSCursorDown(); break; // CUD
2253     case 'C': CSCursorRight(); break; // CUF
2254     case 'D': CSCursorLeft(); break; // CUB
2255     case 'E': CSCursorDown1(); break; // CNL
2256     case 'F': CSCursorUp1(); break; // CPL
2257     case 'G': CSMoveToColumnN(); break; // CHA
2258     case 'H': CSMoveToXY(); break; // CUP
2259     case 'I': CSForwardTab(); break; // CHT
2260     case 'J': CSScreenErase(); break; // ED
2261     case 'K': CSLineErase(); break; // EL
2262     case 'L': CSInsertLine(); break; // IL
2263     case 'M': CSDeleteNLines(); break; // DL
2264     // case 'N': break; // EF -- Not support
2265     // case 'O': break; // EA -- Not support
2266     case 'P': CSDeleteCharacter(); break; // DCH
2267     // case 'Q': break; // SEE -- Not support
2268     // case 'R': break; // CPR -- Not support
2269     case 'S': CSScrollUP(); break; // SU
2270     case 'T': CSScrollDown(); break; // SD
2271     // case 'U': break; // NP -- Not support
2272     // case 'V': break; // PP -- Not support
2273     // case 'W': break; // CTC -- Not support
2274     case 'X': CSEraseCharacter(); break; // ECH
2275     // case 'Y': break; // CVT -- Not support
2276     case 'Z': CSBackwardTab(); break; // CBT
2277     // caes '[': break; // SRS -- Not support
2278     // caes '\\': break; // PTX -- Not support
2279     // caes ']': break; // SDS -- Not support
2280     // caes '^': break; // SIMD -- Not support
2281     case '`': CSMoveToColumnN(); break; // HPA
2282     case 'a': CSCursorRight(); break; // HPR
2283     // caes 'b': break; // REP -- Not support
2284     case 'c': AnswerTerminalType(); break; // DA
2285     case 'd': CSMoveToLineN(); break; // VPA
2286     case 'e': CSCursorUp(); break; // VPR
2287     case 'f': CSMoveToXY(); break; // HVP
2288     case 'g': CSDeleteTabStop(); break; // TBC
2289     case 'h': CS_h_Mode(); break; // SM
2290     case 'i': CS_i_Mode(); break; // MC
2291     // caes 'b': break; // HPB -- Not support
2292     // caes 'b': break; // VPB -- Not support
2293     case 'l': CS_l_Mode(); break; // RM
2294     case 'm': CSSetAttr(); break; // SGR
2295     case 'n': CS_n_Mode(); break; // DSR
2296     // caes 'o': break; // DAQ -- Not support
2297    
2298     // Private Sequence
2299     case 'r': CSSetScrollRegion(); break; // DECSTBM
2300     case 's': SaveCursor(); break; // SCP (Save cursor (ANSI.SYS/SCO?))
2301     case 't': CSSunSequence(); break; // DECSLPP / Window manipulation(dtterm?)
2302     case 'u': RestoreCursor(); break; // RCP (Restore cursor (ANSI.SYS/SCO))
2303 maya 3227 } /* of case Prv=0 */
2304     break;
2305     /* private parameter = '>' */
2306     case '>': CSGT(b); break;
2307     /* private parameter = '?' */
2308     case '?': CSQuest(b); break;
2309 doda 3311 } /* end of siwtch (Prv) */
2310 maya 3227 break;
2311     /* one intermediate char */
2312     case 1:
2313     switch (IntChar[1]) {
2314 doda 3263 /* intermediate char = ' ' */
2315     case ' ': CSSpace(b); break;
2316 maya 3227 /* intermediate char = '!' */
2317     case '!': CSExc(b); break;
2318     /* intermediate char = '"' */
2319     case '"': CSDouble(b); break;
2320     /* intermediate char = '$' */
2321     case '$': CSDol(b); break;
2322     }
2323     break;
2324     } /* of case Icount */
2325    
2326     ParseMode = ModeFirst;
2327     }
2328    
2329     void ControlSequence(BYTE b)
2330     {
2331     if ((b<=US) || (b>=0x80) && (b<=0x9F))
2332     ParseControl(b); /* ctrl char */
2333     else if ((b>=0x40) && (b<=0x7E))
2334     ParseCS(b); /* terminate char */
2335     else {
2336     if (PrinterMode)
2337     WriteToPrnFile(b,FALSE);
2338    
2339     if ((b>=0x20) && (b<=0x2F))
2340     { /* intermediate char */
2341     if (ICount<IntCharMax) ICount++;
2342     IntChar[ICount] = b;
2343     }
2344     else if ((b>=0x30) && (b<=0x39))
2345     {
2346     if (Param[NParam] < 0)
2347     Param[NParam] = 0;
2348     if (Param[NParam]<1000)
2349     Param[NParam] = Param[NParam]*10 + b - 0x30;
2350     }
2351     else if (b==0x3B)
2352     {
2353     if (NParam < NParamMax)
2354     {
2355     NParam++;
2356     Param[NParam] = -1;
2357     }
2358     }
2359     else if ((b>=0x3C) && (b<=0x3F))
2360     { /* private char */
2361     if (FirstPrm) Prv = b;
2362     }
2363     }
2364     FirstPrm = FALSE;
2365     }
2366    
2367     void DeviceControl(BYTE b)
2368     {
2369     if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2370     {
2371     ESCFlag = FALSE;
2372     ParseMode = SavedMode;
2373     return;
2374     }
2375    
2376     if (b==ESC)
2377     {
2378     ESCFlag = TRUE;
2379     return;
2380     }
2381     else ESCFlag = FALSE;
2382    
2383     if (b<=US)
2384     ParseControl(b);
2385     else if ((b>=0x30) && (b<=0x39))
2386     {
2387     if (Param[NParam] < 0) Param[NParam] = 0;
2388     if (Param[NParam]<1000)
2389     Param[NParam] = Param[NParam]*10 + b - 0x30;
2390     }
2391     else if (b==0x3B)
2392     {
2393     if (NParam < NParamMax)
2394     {
2395     NParam++;
2396     Param[NParam] = -1;
2397     }
2398     }
2399     else if ((b>=0x40) && (b<=0x7E))
2400     {
2401     if (b=='|')
2402     {
2403     ParseMode = ModeDCUserKey;
2404     if (Param[1] < 1) ClearUserKey();
2405     WaitKeyId = TRUE;
2406     NewKeyId = 0;
2407     }
2408     else ParseMode = ModeSOS;
2409     }
2410     }
2411    
2412     void DCUserKey(BYTE b)
2413     {
2414     if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2415     {
2416     if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2417     ESCFlag = FALSE;
2418     ParseMode = SavedMode;
2419     return;
2420     }
2421    
2422     if (b==ESC)
2423     {
2424     ESCFlag = TRUE;
2425     return;
2426     }
2427     else ESCFlag = FALSE;
2428    
2429     if (WaitKeyId)
2430     {
2431     if ((b>=0x30) && (b<=0x39))
2432     {
2433     if (NewKeyId<1000)
2434     NewKeyId = NewKeyId*10 + b - 0x30;
2435     }
2436     else if (b==0x2F)
2437     {
2438     WaitKeyId = FALSE;
2439     WaitHi = TRUE;
2440     NewKeyLen = 0;
2441     }
2442     }
2443     else {
2444     if (b==0x3B)
2445     {
2446     DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2447     WaitKeyId = TRUE;
2448     NewKeyId = 0;
2449     }
2450     else {
2451     if (NewKeyLen < FuncKeyStrMax)
2452     {
2453     if (WaitHi)
2454     {
2455     NewKeyStr[NewKeyLen] = ConvHexChar(b) << 4;
2456     WaitHi = FALSE;
2457     }
2458     else {
2459     NewKeyStr[NewKeyLen] = NewKeyStr[NewKeyLen] +
2460     ConvHexChar(b);
2461     WaitHi = TRUE;
2462     NewKeyLen++;
2463     }
2464     }
2465     }
2466     }
2467     }
2468    
2469     void IgnoreString(BYTE b)
2470     {
2471     if ((ESCFlag && (b=='\\')) ||
2472     (b<=US && b!=ESC && b!=HT) ||
2473     (b==ST && ts.KanjiCode!=IdSJIS))
2474     ParseMode = SavedMode;
2475    
2476     if (b==ESC) ESCFlag = TRUE;
2477     else ESCFlag = FALSE;
2478     }
2479    
2480     BOOL XsParseColor(char *colspec, COLORREF *color)
2481     {
2482     unsigned int r, g, b;
2483     // double dr, dg, db;
2484    
2485     r = g = b = 255;
2486    
2487     if (colspec == NULL || color == NULL) {
2488     return FALSE;
2489     }
2490    
2491     if (_strnicmp(colspec, "rgb:", 4) == 0) {
2492     switch (strlen(colspec)) {
2493     case 9: // rgb:R/G/B
2494     if (sscanf(colspec, "rgb:%1x/%1x/%1x", &r, &g, &b) != 3) {
2495     return FALSE;
2496     }
2497     r *= 17; g *= 17; b *= 17;
2498     break;
2499     case 12: // rgb:RR/GG/BB
2500     if (sscanf(colspec, "rgb:%2x/%2x/%2x", &r, &g, &b) != 3) {
2501     return FALSE;
2502     }
2503     break;
2504     case 15: // rgb:RRR/GGG/BBB
2505     if (sscanf(colspec, "rgb:%3x/%3x/%3x", &r, &g, &b) != 3) {
2506     return FALSE;
2507     }
2508     r >>= 4; g >>= 4; b >>= 4;
2509     break;
2510     case 18: // rgb:RRRR/GGGG/BBBB
2511     if (sscanf(colspec, "rgb:%4x/%4x/%4x", &r, &g, &b) != 3) {
2512     return FALSE;
2513     }
2514     r >>= 8; g >>= 8; b >>= 8;
2515     break;
2516     default:
2517     return FALSE;
2518     }
2519     }
2520     // else if (_strnicmp(colspec, "rgbi:", 5) == 0) {
2521     // ; /* nothing to do */
2522     // }
2523     else if (colspec[0] == '#') {
2524     switch (strlen(colspec)) {
2525     case 4: // #RGB
2526     if (sscanf(colspec, "#%1x%1x%1x", &r, &g, &b) != 3) {
2527     return FALSE;
2528     }
2529     r <<= 4; g <<= 4; b <<= 4;
2530     break;
2531     case 7: // #RRGGBB
2532     if (sscanf(colspec, "#%2x%2x%2x", &r, &g, &b) != 3) {
2533     return FALSE;
2534     }
2535     break;
2536     case 10: // #RRRGGGBBB
2537     if (sscanf(colspec, "#%3x%3x%3x", &r, &g, &b) != 3) {
2538     return FALSE;
2539     }
2540     r >>= 4; g >>= 4; b >>= 4;
2541     break;
2542     case 13: // #RRRRGGGGBBBB
2543     if (sscanf(colspec, "#%4x%4x%4x", &r, &g, &b) != 3) {
2544     return FALSE;
2545     }
2546     r >>= 8; g >>= 8; b >>= 8;
2547     break;
2548     default:
2549     return FALSE;
2550     }
2551     }
2552     else {
2553     return FALSE;
2554     }
2555    
2556     if (r > 255 || g > 255 || b > 255) {
2557     return FALSE;
2558     }
2559    
2560     *color = RGB(r, g, b);
2561     return TRUE;
2562     }
2563    
2564     #define ModeXsFirst 1
2565     #define ModeXsString 2
2566     #define ModeXsColorNum 3
2567     #define ModeXsColorSpec 4
2568     #define ModeXsEsc 5
2569     void XSequence(BYTE b)
2570     {
2571     static BYTE XsParseMode = ModeXsFirst, PrevMode;
2572     static char StrBuff[sizeof(ts.Title)];
2573     static unsigned int ColorNumber, StrLen;
2574     COLORREF color;
2575    
2576     switch (XsParseMode) {
2577     case ModeXsFirst:
2578     if (isdigit(b)) {
2579     if (Param[1] < 1000) {
2580     Param[1] = Param[1]*10 + b - '0';
2581     }
2582     }
2583     else if (b == ';') {
2584     StrBuff[0] = '\0';
2585     StrLen = 0;
2586     if (Param[1] == 4) {
2587     ColorNumber = 0;
2588     XsParseMode = ModeXsColorNum;
2589     }
2590     else {
2591     XsParseMode = ModeXsString;
2592     }
2593     }
2594     else {
2595     ParseMode = ModeFirst;
2596     }
2597     break;
2598     case ModeXsString:
2599     if ((b==ST && ts.KanjiCode!=IdSJIS) || b==BEL) { /* String Terminator */
2600     StrBuff[StrLen] = '\0';
2601     switch (Param[1]) {
2602     case 0: /* Change window title and icon name */
2603     case 1: /* Change icon name */
2604     case 2: /* Change window title */
2605     if (ts.AcceptTitleChangeRequest) {
2606     strncpy_s(cv.TitleRemote, sizeof(cv.TitleRemote), StrBuff, _TRUNCATE);
2607     // (2006.6.15 maya) �^�C�g�����n����������SJIS������
2608     ConvertToCP932(cv.TitleRemote, sizeof(cv.TitleRemote));
2609     ChangeTitle();
2610     }
2611     break;
2612     default:
2613     /* nothing to do */;
2614     }
2615     ParseMode = ModeFirst;
2616     XsParseMode = ModeXsFirst;
2617     }
2618     else if (b == ESC) { /* Escape */
2619     PrevMode = ModeXsString;
2620     XsParseMode = ModeXsEsc;
2621     }
2622     else if (b <= US) { /* Other control character -- invalid sequence */
2623     ParseMode = ModeFirst;
2624     XsParseMode = ModeXsFirst;
2625     }
2626     else if (StrLen < sizeof(StrBuff) - 1) {
2627     StrBuff[