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