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