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