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