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