teraterm/teraterm/vtterm.c

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004- TeraTerm Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* TERATERM.EXE, VT terminal emulation */
#include "teraterm.h"
#include "tttypes.h"
#include <stdio.h>
#include <string.h>
#include <mbstring.h>
#include <locale.h>
#include <ctype.h>
#if !defined(_CRTDBG_MAP_ALLOC)
#define _CRTDBG_MAP_ALLOC
#endif
#include <stdlib.h>
#include <crtdbg.h>
#include <assert.h>

#include "buffer.h"
#include "ttwinman.h"
#include "ttcommon.h"
#include "commlib.h"
#include "vtdisp.h"
#include "keyboard.h"
#include "ttlib.h"
#include "filesys.h"
#include "teraprn.h"
#include "telnet.h"
#include "ttime.h"
#include "clipboar.h"
#include "codeconv.h"
#include "unicode.h"
#include "ttdde.h"
#include "checkeol.h"

#include "vtterm.h"

#include "unicode_test.h"

static void ParseFirst(BYTE b);

#define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))

  /* Parsing modes */
#define ModeFirst 0
#define ModeESC   1
#define ModeDCS   2
#define ModeDCUserKey 3
#define ModeSOS   4
#define ModeCSI   5
#define ModeXS    6
#define ModeDLE   7
#define ModeCAN   8
#define ModeIgnore 9

#define NParamMax  16
#define NSParamMax 16
#define IntCharMax  5

/* DEC Locator Flag */
#define DecLocatorOneShot    1
#define DecLocatorPixel      2
#define DecLocatorButtonDown 4
#define DecLocatorButtonUp   8
#define DecLocatorFiltered   16

void RingBell(int type);
void VisualBell();
BOOL DecLocatorReport(int Event, int Button);

/* character attribute */
static TCharAttr CharAttr;

/* various modes of VT emulation */
static BOOL RelativeOrgMode;
static BOOL InsertMode;
static BOOL LFMode;
static BOOL ClearThenHome;
static BOOL AutoWrapMode;
static BOOL FocusReportMode;
static BOOL AltScr;
static BOOL LRMarginMode;
static BOOL RectangleMode;
static BOOL BracketedPaste;

static char BracketStart[] = "\033[200~";
static char BracketEnd[] = "\033[201~";
static int BracketStartLen = (sizeof(BracketStart)-1);
static int BracketEndLen = (sizeof(BracketEnd)-1);

static int VTlevel;

static BOOL AcceptWheelToCursor;

// save/restore cursor
typedef struct {
        int CursorX, CursorY;
        TCharAttr Attr;
        int Glr[2], Gn[4]; // G0-G3, GL & GR
        BOOL AutoWrapMode;
        BOOL RelativeOrgMode;
} TStatusBuff;
typedef TStatusBuff *PStatusBuff;

// currently only used for AUTO CR/LF receive mode
static BYTE PrevCharacter;
static BOOL PrevCRorLFGeneratedCRLF;      // indicates that previous CR or LF really generated a CR+LF

static BYTE LastPutCharacter;

// status buffer for main screen & status line
static TStatusBuff SBuff1, SBuff2, SBuff3;

static BOOL ESCFlag, JustAfterESC;
static BOOL KanjiIn;                            // TRUE = MBCS��1byte�������M��������
static BOOL EUCkanaIn, EUCsupIn;
static int  EUCcount;
static BOOL Special;

static int Param[NParamMax+1];
static int SubParam[NParamMax+1][NSParamMax+1];
static int NParam, NSParam[NParamMax+1];
static BOOL FirstPrm;
static BYTE IntChar[IntCharMax+1];
static int ICount;
static BYTE Prv;
static int ParseMode;
static int ChangeEmu;

typedef struct tstack {
        char *title;
        struct tstack *next;
} TStack;
typedef TStack *PTStack;
static PTStack TitleStack = NULL;

/* user defined keys */
static BOOL WaitKeyId, WaitHi;

/* GL, GR code group */
static int Glr[2];
/* G0, G1, G2, G3 code group */
static int Gn[4];
/* GL for single shift 2/3 */
static int GLtmp;
/* single shift 2/3 flag */
static BOOL SSflag;
/* JIS -> SJIS conversion flag */
static BOOL ConvJIS;
static WORD Kanji;
static BOOL Fallbacked;

// variables for status line mode
static int StatusX=0;
static BOOL StatusWrap=FALSE;
static BOOL StatusCursor=TRUE;
static int MainX, MainY; //cursor registers
static int MainTop, MainBottom; // scroll region registers
static BOOL MainWrap;
static BOOL MainCursor=TRUE;

/* status for printer escape sequences */
static BOOL PrintEX = TRUE; // printing extent
                            // (TRUE: screen, FALSE: scroll region)
static BOOL AutoPrintMode = FALSE;
static BOOL PrinterMode = FALSE;
static BOOL DirectPrn = FALSE;
PrintFile *PrintFile_;

/* User key */
static BYTE NewKeyStr[FuncKeyStrMax];
static int NewKeyId, NewKeyLen;

/* Mouse Report */
static int MouseReportMode;
static int MouseReportExtMode;
static unsigned int DecLocatorFlag;
static int LastX, LastY;
static int ButtonStat;
static int FilterTop, FilterBottom, FilterLeft, FilterRight;

/* Saved IME status */
static BOOL SavedIMEstatus;

/* Beep over-used */
static DWORD BeepStartTime = 0;
static DWORD BeepSuppressTime = 0;
static DWORD BeepOverUsedCount = 0;

static _locale_t CLocale = NULL;

typedef struct {
        CheckEOLData_t *check_eol;
        int log_cr_type;
} vtterm_work_t;

static vtterm_work_t vtterm_work;

void ClearParams()
{
        ICount = 0;
        NParam = 1;
        NSParam[1] = 0;
        Param[1] = 0;
        Prv = 0;
}

void ResetSBuffer(PStatusBuff sbuff)
{
        sbuff->CursorX = 0;
        sbuff->CursorY = 0;
        sbuff->Attr = DefCharAttr;
        if (ts.Language==IdJapanese) {
                sbuff->Gn[0] = IdASCII;
                sbuff->Gn[1] = IdKatakana;
                sbuff->Gn[2] = IdKatakana;
                sbuff->Gn[3] = IdKanji;
                sbuff->Glr[0] = 0;
                if ((ts.KanjiCode==IdJIS) && (ts.JIS7Katakana==0))
                        sbuff->Glr[1] = 2;      // 8-bit katakana
                else
                        sbuff->Glr[1] = 3;
        }
        else {
                sbuff->Gn[0] = IdASCII;
                sbuff->Gn[1] = IdSpecial;
                sbuff->Gn[2] = IdASCII;
                sbuff->Gn[3] = IdASCII;
                sbuff->Glr[0] = 0;
                sbuff->Glr[1] = 0;
        }
        sbuff->AutoWrapMode = TRUE;
        sbuff->RelativeOrgMode = FALSE;
}

void ResetAllSBuffers()
{
        ResetSBuffer(&SBuff1);
        // copy SBuff1 to SBuff2
        SBuff2 = SBuff1;
        SBuff3 = SBuff1;
}

void ResetCurSBuffer()
{
        PStatusBuff Buff;

        if (AltScr) {
                Buff = &SBuff3; // Alternate screen buffer
        }
        else {
                Buff = &SBuff1; // Normal screen buffer
        }
        ResetSBuffer(Buff);
        SBuff2 = *Buff;
}

void ResetTerminal() /*reset variables but don't update screen */
{
        DispReset();
        BuffReset();

        /* Attribute */
        CharAttr = DefCharAttr;
        Special = FALSE;
        BuffSetCurCharAttr(CharAttr);

        /* Various modes */
        InsertMode = FALSE;
        LFMode = (ts.CRSend == IdCRLF);
        AutoWrapMode = TRUE;
        AppliKeyMode = FALSE;
        AppliCursorMode = FALSE;
        AppliEscapeMode = FALSE;
        AcceptWheelToCursor = ts.TranslateWheelToCursor;
        RelativeOrgMode = FALSE;
        ts.ColorFlag &= ~CF_REVERSEVIDEO;
        AutoRepeatMode = TRUE;
        FocusReportMode = FALSE;
        MouseReportMode = IdMouseTrackNone;
        MouseReportExtMode = IdMouseTrackExtNone;
        DecLocatorFlag = 0;
        ClearThenHome = FALSE;
        RectangleMode = FALSE;

        ChangeTerminalID();

        LastX = 0;
        LastY = 0;
        ButtonStat = 0;

        if (CLocale == NULL) {
                CLocale = _create_locale(LC_ALL, "C");
        }

        /* Character sets */
        ResetCharSet();

        /* ESC flag for device control sequence */
        ESCFlag = FALSE;
        /* for TEK sequence */
        JustAfterESC = FALSE;

        /* Parse mode */
        ParseMode = ModeFirst;

        /* Clear printer mode */
        PrinterMode = FALSE;

        // status buffers
        ResetAllSBuffers();

        // Alternate Screen Buffer
        AltScr = FALSE;

        // Left/Right Margin Mode
        LRMarginMode = FALSE;

        // Bracketed Paste Mode
        BracketedPaste = FALSE;

        // Saved IME Status
        SavedIMEstatus = FALSE;

        // previous received character
        PrevCharacter = -1;     // none
        PrevCRorLFGeneratedCRLF = FALSE;

        LastPutCharacter = 0;

        // Beep over-used
        BeepStartTime = GetTickCount();
        BeepSuppressTime = BeepStartTime - ts.BeepSuppressTime * 1000;
        BeepStartTime -= (ts.BeepOverUsedTime * 1000);
        BeepOverUsedCount = ts.BeepOverUsedCount;

        {
                vtterm_work_t *vtterm = &vtterm_work;
                vtterm->check_eol = CheckEOLCreate();
                vtterm->log_cr_type = 0;
        }
}

void ResetCharSet()
{
        char *result;
        if (ts.Language==IdJapanese) {
                Gn[0] = IdASCII;
                Gn[1] = IdKatakana;
                Gn[2] = IdKatakana;
                Gn[3] = IdKanji;
                Glr[0] = 0;
                if ((ts.KanjiCode==IdJIS) && (ts.JIS7Katakana==0))
                        Glr[1] = 2;     // 8-bit katakana
                else
                        Glr[1] = 3;
        }
        else {
                Gn[0] = IdASCII;
                Gn[1] = IdSpecial;
                Gn[2] = IdASCII;
                Gn[3] = IdASCII;
                Glr[0] = 0;
                Glr[1] = 0;
                cv.SendCode = IdASCII;
                cv.SendKanjiFlag = FALSE;
                cv.EchoCode = IdASCII;
                cv.EchoKanjiFlag = FALSE;
        }
        /* Kanji flag */
        KanjiIn = FALSE;
        EUCkanaIn = FALSE;
        EUCsupIn = FALSE;
        SSflag = FALSE;
        ConvJIS = FALSE;
        Fallbacked = FALSE;

        cv.Language = ts.Language;
        cv.CRSend = ts.CRSend;
        cv.KanjiCodeEcho = ts.KanjiCode;
        cv.JIS7KatakanaEcho = ts.JIS7Katakana;
        cv.KanjiCodeSend = ts.KanjiCodeSend;
        cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
        cv.KanjiIn = ts.KanjiIn;
        cv.KanjiOut = ts.KanjiOut;

        // ���P�[��������
        // wctomb ������
        result = setlocale(LC_ALL, ts.Locale);
    if (result == NULL) {
                // ��������Locale���������Z�b�g����������?
                // default���Z�b�g��������
                strcpy(ts.Locale, DEFAULT_LOCALE);
                result = setlocale(LC_ALL, ts.Locale);
        }
        // �p����Windows�����Ats.Locale���f�t�H���g��"japanese"�����������A
        // setlocale�� NULL �����������ATera Term���N�������������Bstrrchr��
        // ��1��������NULL���w���������������B
        // setlocale ���������������R�[�h�y�[�W���������A���s��������
        // ANSI�R�[�h�y�[�W�����������B
        if (result)
                ts.CodePage = atoi(strrchr(result, '.')+1);
        else
                ts.CodePage = GetACP();
}

void ResetKeypadMode(BOOL DisabledModeOnly)
{
        if (!DisabledModeOnly || ts.DisableAppKeypad)
                AppliKeyMode = FALSE;
        if (!DisabledModeOnly || ts.DisableAppCursor)
                AppliCursorMode = FALSE;
}

void MoveToMainScreen()
{
        StatusX = CursorX;
        StatusWrap = Wrap;
        StatusCursor = IsCaretEnabled();

        CursorTop = MainTop;
        CursorBottom = MainBottom;
        Wrap = MainWrap;
        DispEnableCaret(MainCursor);
        MoveCursor(MainX, MainY); // move to main screen
}

/**
 *      1�L�����N�^(unsigned int, char32_t)��macro���o��
 */
static void DDEPut1U32(unsigned int u32)
{
        if (DDELog) {
                // UTF-8 ���o������
                char u8_buf[4];
                size_t u8_len = UTF32ToUTF8(u32, u8_buf, _countof(u8_buf));
                size_t i;
                for (i = 0; i < u8_len; i++) {
                        BYTE b = u8_buf[i];
                        DDEPut1(b);
                }
        }
}

/**
 *      ���O���������������s�R�[�h���o��
 */
static void OutputLogNewLine(vtterm_work_t *vtterm)
{
        switch(vtterm->log_cr_type) {
        case 0:
                // CR + LF
                FLogPutUTF32(CR);
                FLogPutUTF32(LF);
                break;
        case 1:
                // CR
                FLogPutUTF32(CR);
                break;
        case 2:
                // LF
                FLogPutUTF32(LF);
                break;
        }
}

/**
 *      1�L�����N�^(unsigned int, char32_t)�����O(or/and macro���M�o�b�t�@)���o��
 *              �o����
 *                      ���O�t�@�C��
 *                      macro���M�o�b�t�@(DDEPut1())
 *                      �v�����g�p
 */
static void OutputLogUTF32(unsigned int u32)
{
        vtterm_work_t *vtterm;
        CheckEOLRet r;

        if (!FLogIsOpendText() && !DDELog && !PrinterMode) {
                return;
        }
        vtterm = &vtterm_work;
        r = CheckEOLCheck(vtterm->check_eol, u32);

        // ���O
        if (FLogIsOpendText()) {
                if ((r & CheckEOLOutputEOL) != 0) {
                        // ���s���o��
                        OutputLogNewLine(vtterm);
                }

                if ((r & CheckEOLOutputChar) != 0) {
                        // u32���o��
                        FLogPutUTF32(u32);
                }
        }

        // �}�N���o��
        if (DDELog) {
                if ((r & CheckEOLOutputEOL) != 0) {
                        // ���s���o��
                        DDEPut1(CR);
                        DDEPut1(LF);
                }

                // u32���o��
                if ((r & CheckEOLOutputChar) != 0) {
                        DDEPut1U32(u32);
                }
        }

        // �v�����g
        if (PrinterMode) {
                if ((r & CheckEOLOutputEOL) != 0) {
                        // ���s���o��
                        WriteToPrnFile(PrintFile_, CR,TRUE);
                        WriteToPrnFile(PrintFile_, LF,TRUE);
                }

                // u32���o��
                if ((r & CheckEOLOutputChar) != 0) {
                        WriteToPrnFileUTF32(PrintFile_, u32, TRUE);
                }
        }
}

/**
 *      1�L�����N�^(BYTE)�����O(or/and macro���M�o�b�t�@)���o��
 */
static void OutputLogByte(BYTE b)
{
        OutputLogUTF32(b);
}

/**
 *      ���O(or/and Macro���M�o�b�t�@)�o�����K�v��������?
 */
static BOOL NeedsOutputBufs(void)
{
        return FLogIsOpendText() || DDELog;
}

void MoveToStatusLine()
{
        MainX = CursorX;
        MainY = CursorY;
        MainTop = CursorTop;
        MainBottom = CursorBottom;
        MainWrap = Wrap;
        MainCursor = IsCaretEnabled();

        DispEnableCaret(StatusCursor);
        MoveCursor(StatusX, NumOfLines-1); // move to status line
        CursorTop = NumOfLines-1;
        CursorBottom = CursorTop;
        Wrap = StatusWrap;
}

void HideStatusLine()
{
        if (isCursorOnStatusLine)
                MoveToMainScreen();
        StatusX = 0;
        StatusWrap = FALSE;
        StatusCursor = TRUE;
        ShowStatusLine(0); //hide
}

void ChangeTerminalSize(int Nx, int Ny)
{
        BuffChangeTerminalSize(Nx, Ny);
        StatusX = 0;
        MainX = 0;
        MainY = 0;
        MainTop = 0;
        MainBottom = NumOfLines-StatusLine-1;
}

void SendCSIstr(char *str, int len) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (Send8BitMode)
                CommBinaryOut(&cv,"\233", 1);
        else
                CommBinaryOut(&cv,"\033[", 2);

        CommBinaryOut(&cv, str, l);
}

void SendOSCstr(char *str, int len, char TermChar) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (TermChar == BEL) {
                CommBinaryOut(&cv,"\033]", 2);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\007", 1);
        }
        else if (Send8BitMode) {
                CommBinaryOut(&cv,"\235", 1);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\234", 1);
        }
        else {
                CommBinaryOut(&cv,"\033]", 2);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\033\\", 2);
        }

}

void SendDCSstr(char *str, int len) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (Send8BitMode) {
                CommBinaryOut(&cv,"\220", 1);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\234", 1);
        }
        else {
                CommBinaryOut(&cv,"\033P", 2);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\033\\", 2);
        }

}

void BackSpace()
{
        if (CursorX == CursorLeftM || CursorX == 0) {
                if (CursorY > 0 && (ts.TermFlag & TF_BACKWRAP)) {
                        MoveCursor(CursorRightM, CursorY-1);
                        if (NeedsOutputBufs() && !ts.LogTypePlainText) OutputLogByte(BS);
                }
        }
        else if (CursorX > 0) {
                MoveCursor(CursorX-1, CursorY);
                if (NeedsOutputBufs() && !ts.LogTypePlainText) OutputLogByte(BS);
        }
}

static void CarriageReturn(BOOL logFlag)
{
        if (!ts.EnableContinuedLineCopy || logFlag)
                if (NeedsOutputBufs()) OutputLogByte(CR);

        if (RelativeOrgMode || CursorX > CursorLeftM)
                MoveCursor(CursorLeftM, CursorY);
        else if (CursorX < CursorLeftM)
                MoveCursor(0, CursorY);

        Fallbacked = FALSE;
}

static void LineFeed(BYTE b, BOOL logFlag)
{
        /* for auto print mode */
        if ((AutoPrintMode) &&
                (b>=LF) && (b<=FF))
                BuffDumpCurrentLine(PrintFile_, b);

        if (!ts.EnableContinuedLineCopy || logFlag)
                if (NeedsOutputBufs()) OutputLogByte(LF);

        if (CursorY < CursorBottom)
                MoveCursor(CursorX,CursorY+1);
        else if (CursorY == CursorBottom) BuffScrollNLines(1);
        else if (CursorY < NumOfLines-StatusLine-1)
                MoveCursor(CursorX,CursorY+1);

        ClearLineContinued();

        if (LFMode) CarriageReturn(logFlag);

        Fallbacked = FALSE;
}

void Tab()
{
        if (Wrap && !ts.VTCompatTab) {
                CarriageReturn(FALSE);
                LineFeed(LF,FALSE);
                if (ts.EnableContinuedLineCopy) {
                        SetLineContinued();
                }
                Wrap = FALSE;
        }
        CursorForwardTab(1, AutoWrapMode);
        if (NeedsOutputBufs()) OutputLogByte(HT);
}

void RepeatChar(BYTE b, int count)
{
        int i;
        BOOL SpecialNew;
        TCharAttr CharAttrTmp, CharAttrWrap;

        if (b <= US || b == DEL)
                return;

        CharAttrTmp = CharAttr;
        LastPutCharacter = 0;

        SpecialNew = FALSE;
        if ((b>0x5F) && (b<0x80)) {
                if (SSflag)
                        SpecialNew = (Gn[GLtmp]==IdSpecial);
                else
                        SpecialNew = (Gn[Glr[0]]==IdSpecial);
        }
        else if (b>0xDF) {
                if (SSflag)
                        SpecialNew = (Gn[GLtmp]==IdSpecial);
                else
                        SpecialNew = (Gn[Glr[1]]==IdSpecial);
        }

        if (SpecialNew != Special) {
                UpdateStr();
                Special = SpecialNew;
        }

        if (Special) {
                b = b & 0x7F;
                CharAttrTmp.Attr |= AttrSpecial;
        }
        else
                CharAttrTmp.Attr |= CharAttr.Attr;
        CharAttrTmp.AttrEx = CharAttrTmp.Attr;

        CharAttrWrap = CharAttrTmp;
        CharAttrWrap.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;

        for (i=0; i<count; i++) {
                if (Wrap) {
                        CarriageReturn(FALSE);
                        LineFeed(LF,FALSE);
                }

                BuffPutChar(b, Wrap ? CharAttrWrap : CharAttrTmp, InsertMode);

                if (CursorX == CursorRightM || CursorX >= NumOfColumns-1) {
                        UpdateStr();
                        Wrap = AutoWrapMode;
                }
                else {
                        Wrap = FALSE;
                        MoveRight();
                }
        }
}

static void PutChar(BYTE b)
{
        BOOL SpecialNew;
        TCharAttr CharAttrTmp;

        CharAttrTmp = CharAttr;

        LastPutCharacter = b;

        if (PrinterMode) { // printer mode
                WriteToPrnFile(PrintFile_, b,TRUE);
                return;
        }

        if (Wrap) {
#if UNICODE_INTERNAL_BUFF
                TCharAttr t = BuffGetCursorCharAttr(CursorX, CursorY);
                t.Attr |= AttrLineContinued;
                t.AttrEx = t.Attr;
                BuffSetCursorCharAttr(CursorX, CursorY, t);
#endif
                CarriageReturn(FALSE);
                LineFeed(LF,FALSE);
#if !UNICODE_INTERNAL_BUFF
                CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
#else
                CharAttrTmp.Attr |= AttrLineContinued;
                t.AttrEx = t.Attr;
#endif
        }

        if (NeedsOutputBufs()) {
                // (2005.2.20 yutaka)
                if (ts.LogTypePlainText) {
                        if (__isascii(b) && !isprint(b)) {
                                // ASCII�������A���\�������������O�����������B
                        } else {
                                OutputLogByte(b);
                        }
                } else {
                        OutputLogByte(b);
                }
        }

        Wrap = FALSE;

        SpecialNew = FALSE;
        if ((b>0x5F) && (b<0x80)) {
                if (SSflag)
                        SpecialNew = (Gn[GLtmp]==IdSpecial);
                else
                        SpecialNew = (Gn[Glr[0]]==IdSpecial);
        }
        else if (b>0xDF) {
                if (SSflag)
                        SpecialNew = (Gn[GLtmp]==IdSpecial);
                else
                        SpecialNew = (Gn[Glr[1]]==IdSpecial);
        }

        if (SpecialNew != Special) {
                UpdateStr();
                Special = SpecialNew;
        }

        if (Special) {
                b = b & 0x7F;
                CharAttrTmp.Attr |= AttrSpecial;
        }
        else
                CharAttrTmp.Attr |= CharAttr.Attr;

#if 0
        if (CursorX == CursorRightM || CursorX >= NumOfColumns - 1) {
                CharAttrTmp.Attr |= AttrLineContinued;
        }
#endif

#if UNICODE_INTERNAL_BUFF
        CharAttrTmp.AttrEx = CharAttrTmp.Attr;
        if (ts.Language == IdJapanese) {
                unsigned long u32;
                switch (ts.KanjiCode) {
//              case IdJIS:
//                      b = JIS2SJIS(b);
                case IdSJIS:
                        u32 = MBCP_UTF32(b, 932);
                        BuffPutUnicode(u32, CharAttrTmp, InsertMode);
                        break;
                case IdUTF8:
                        BuffPutUnicode(b, CharAttrTmp, InsertMode);
                        break;
                default:
                        BuffPutUnicode(b, CharAttrTmp, InsertMode);
                        break;
                }
        } else if (ts.Language == IdRussian) {
                BYTE c = RussConv(ts.RussHost, IdWindows, b);
                unsigned long u32 = MBCP_UTF32(c, 1251);
                BuffPutUnicode(u32, CharAttrTmp, InsertMode);
        } else {
                BuffPutUnicode(b, CharAttrTmp, InsertMode);
        }
#else
        BuffPutChar(b, CharAttrTmp, InsertMode);
#endif

        if (CursorX == CursorRightM || CursorX >= NumOfColumns-1) {
                UpdateStr();
                Wrap = AutoWrapMode;
        }
        else {
                MoveRight();
        }
}

static void PutDecSp(BYTE b)
{
        TCharAttr CharAttrTmp;

        CharAttrTmp = CharAttr;

        if (PrinterMode) { // printer mode
                WriteToPrnFile(PrintFile_, b, TRUE);
                return;
        }

        if (Wrap) {
                CarriageReturn(FALSE);
                LineFeed(LF, FALSE);
                CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
        }

        if (NeedsOutputBufs()) OutputLogByte(b);
/*
        if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
                // ASCII�������A���\�������������O�����������B
        } else {
                if (NeedsOutputBufs()) OutputLogByte(b);
        }
 */

        Wrap = FALSE;

        if (!Special) {
                UpdateStr();
                Special = TRUE;
        }

        CharAttrTmp.Attr |= AttrSpecial;
#if UNICODE_INTERNAL_BUFF
        CharAttrTmp.AttrEx = CharAttrTmp.Attr;
#endif
        BuffPutChar(b, CharAttrTmp, InsertMode);

        if (CursorX == CursorRightM || CursorX >= NumOfColumns-1) {
                UpdateStr();
                Wrap = AutoWrapMode;
        }
        else {
                MoveRight();
        }
}

/**
 *      mbcs���o��
 */
static void PutKanji(BYTE b)
{
        int LineEnd;
        TCharAttr CharAttrTmp;
        CharAttrTmp = CharAttr;

        Kanji = Kanji + b;

        if (PrinterMode && DirectPrn) {
                WriteToPrnFile(PrintFile_, HIBYTE(Kanji),FALSE);
                WriteToPrnFile(PrintFile_, LOBYTE(Kanji),TRUE);
                return;
        }

        if (ConvJIS)
                Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));

        if (PrinterMode) { // printer mode
                WriteToPrnFile(PrintFile_, HIBYTE(Kanji),FALSE);
                WriteToPrnFile(PrintFile_, LOBYTE(Kanji),TRUE);
                return;
        }

        if (CursorX > CursorRightM)
                LineEnd = NumOfColumns - 1;
        else
                LineEnd = CursorRightM;

        if (Wrap) {
                CarriageReturn(FALSE);
                LineFeed(LF,FALSE);
#if !UNICODE_INTERNAL_BUFF
                if (ts.EnableContinuedLineCopy)
                        CharAttrTmp.Attr |= AttrLineContinued;
#else
                if (ts.EnableContinuedLineCopy) {
                        CharAttrTmp.Attr |= AttrLineContinued;
                        CharAttrTmp.AttrEx = CharAttrTmp.Attr;
                }
#endif
        }
        else if (CursorX > LineEnd - 1) {
                if (AutoWrapMode) {
                        if (ts.EnableContinuedLineCopy) {
                                CharAttrTmp.Attr |= AttrLineContinued;
#if UNICODE_INTERNAL_BUFF
                                CharAttrTmp.AttrEx = CharAttrTmp.Attr;
#endif
                                if (CursorX == LineEnd)
                                        BuffPutChar(0x20, CharAttr, FALSE);
                        }
                        CarriageReturn(FALSE);
                        LineFeed(LF,FALSE);
                }
                else {
                        return;
                }
        }

        Wrap = FALSE;

        if (NeedsOutputBufs()) {
                OutputLogByte(HIBYTE(Kanji));
                OutputLogByte(LOBYTE(Kanji));
        }

        if (Special) {
                UpdateStr();
                Special = FALSE;
        }

#if UNICODE_INTERNAL_BUFF
        {
                // codepage����
                // https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ucoderef/28fefe92-d66c-4b03-90a9-97b473223d43
                unsigned long u32 = 0;
                switch (ts.Language) {
                case IdJapanese:
                        // �������������_��CP932������������
                        u32 = CP932ToUTF32(Kanji);
                        break;
                case IdKorean:
                        if (ts.KanjiCode == IdKoreanCP51949) {
                                // CP51949
                                u32 = MBCP_UTF32(Kanji, 51949);
                        }
                        else {
                                assert(FALSE);
                                goto default_;
                        }
                        break;
                case IdChinese:
                        if (ts.KanjiCode == IdCnGB2312) {
                                // CP936 GB2312
                                u32 = MBCP_UTF32(Kanji, 936);
                        }
                        else if (ts.KanjiCode == IdCnBig5) {
                                // CP950 Big5
                                u32 = MBCP_UTF32(Kanji, 950);
                        }
                        else {
                                assert(FALSE);
                                goto default_;
                        }
                        break;
                default:
                default_:
                        assert(FALSE);
                        u32 = MBCP_UTF32(Kanji, ts.CodePage);
                        break;
                }
                CharAttrTmp.AttrEx = CharAttrTmp.Attr;
                BuffPutUnicode(u32, CharAttrTmp, InsertMode);
        }
#else
        BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
#endif

        if (CursorX < LineEnd - 1) {
                MoveRight();
                MoveRight();
        }
        else {
                if (CursorX == LineEnd - 1) {
                        MoveRight();
                }
                UpdateStr();
                Wrap = AutoWrapMode;
        }
}

void PutDebugChar(BYTE b)
{
        static BYTE buff[3];
        int i;
        BOOL svInsertMode, svAutoWrapMode;
        BYTE svCharAttr;

        if (DebugFlag!=DEBUG_FLAG_NOUT) {
                svInsertMode = InsertMode;
                svAutoWrapMode = AutoWrapMode;
                InsertMode = FALSE;
                AutoWrapMode = TRUE;

                svCharAttr = CharAttr.Attr;
                if (CharAttr.Attr != AttrDefault) {
                        UpdateStr();
                        CharAttr.Attr = AttrDefault;
                }

                if (DebugFlag==DEBUG_FLAG_HEXD) {
                        _snprintf(buff, 3, "%02X", (unsigned int) b);

                        for (i=0; i<2; i++)
                                PutChar(buff[i]);
                        PutChar(' ');
                }
                else if (DebugFlag==DEBUG_FLAG_NORM) {

                        if ((b & 0x80) == 0x80) {
                                UpdateStr();
                                CharAttr.Attr = AttrReverse;
                                b = b & 0x7f;
                        }

                        if (b<=US) {
                                PutChar('^');
                                PutChar((char)(b+0x40));
                        }
                        else if (b==DEL) {
                                PutChar('<');
                                PutChar('D');
                                PutChar('E');
                                PutChar('L');
                                PutChar('>');
                        }
                        else
                                PutChar(b);
                }

                if (CharAttr.Attr != svCharAttr) {
                        UpdateStr();
                        CharAttr.Attr = svCharAttr;
                }
                InsertMode = svInsertMode;
                AutoWrapMode = svAutoWrapMode;
        }
}

static void PrnParseControl(BYTE b) // printer mode
{
        switch (b) {
        case NUL:
                return;
        case SO:
                if ((ts.ISO2022Flag & ISO2022_SO) && ! DirectPrn) {
                        if ((ts.Language==IdJapanese) &&
                            (ts.KanjiCode==IdJIS) &&
                            (ts.JIS7Katakana==1) &&
                            ((ts.TermFlag & TF_FIXEDJIS)!=0))
                        {
                                Gn[1] = IdKatakana;
                        }
                        Glr[0] = 1; /* LS1 */
                        return;
                }
                break;
        case SI:
                if ((ts.ISO2022Flag & ISO2022_SI) && ! DirectPrn) {
                        Glr[0] = 0; /* LS0 */
                        return;
                }
                break;
        case DC1:
        case DC3:
                return;
        case ESC:
                ICount = 0;
                JustAfterESC = TRUE;
                ParseMode = ModeESC;
                WriteToPrnFile(PrintFile_, 0, TRUE); // flush prn buff
                return;
        case CSI:
                if (! Accept8BitCtrl) {
                        PutChar(b); /* Disp C1 char in VT100 mode */
                        return;
                }
                ClearParams();
                FirstPrm = TRUE;
                ParseMode = ModeCSI;
                WriteToPrnFile(PrintFile_, 0, TRUE); // flush prn buff
                WriteToPrnFile(PrintFile_, b, FALSE);
                return;
        }
        /* send the uninterpreted character to printer */
        WriteToPrnFile(PrintFile_, b, TRUE);
}

static void ParseControl(BYTE b)
{
        if (PrinterMode) { // printer mode
                PrnParseControl(b);
                return;
        }

        if (b>=0x80) { /* C1 char */
                if (ts.Language==IdEnglish) { /* English mode */
                        if (!Accept8BitCtrl) {
                                PutChar(b); /* Disp C1 char in VT100 mode */
                                return;
                        }
                }
                else { /* Japanese mode */
                        if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0) {
                                return; /* ignore C1 char */
                        }
                        /* C1 chars are interpreted as C0 chars in VT100 mode */
                        if (VTlevel < 2) {
                                b = b & 0x7F;
                        }
                }
        }
        switch (b) {
        /* C0 group */
        case ENQ:
                CommBinaryOut(&cv, &(ts.Answerback[0]), ts.AnswerbackLen);
                break;
        case BEL:
                if (ts.Beep != IdBeepOff)
                        RingBell(ts.Beep);
                break;
        case BS:
                BackSpace();
                break;
        case HT:
                Tab();
                break;
        case LF:
                if (ts.CRReceive == IdLF) {
                        // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
                        // CR+LF���������������������B
                        // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
                        // (2007.1.21 yutaka)
                        CarriageReturn(TRUE);
                        LineFeed(b, TRUE);
                        break;
                }
                else if (ts.CRReceive == IdAUTO) {
                        // 9th Apr 2012: AUTO CR/LF mode (tentner)
                        // a CR or LF will generated a CR+LF, if the next character is the opposite, it will be ignored
                        if(PrevCharacter != CR || !PrevCRorLFGeneratedCRLF) {
                                CarriageReturn(TRUE);
                                LineFeed(b, TRUE);
                                PrevCRorLFGeneratedCRLF = TRUE;
                        }
                        else {
                                PrevCRorLFGeneratedCRLF = FALSE;
                        }
                        break;
                }

        case VT:
                LineFeed(b, TRUE);
                break;

        case FF:
                if ((ts.AutoWinSwitch>0) && JustAfterESC) {
                        CommInsert1Byte(&cv, b);
                        CommInsert1Byte(&cv, ESC);
                        ChangeEmu = IdTEK;      /* Enter TEK Mode */
                }
                else
                        LineFeed(b, TRUE);
                break;
        case CR:
                if (ts.CRReceive == IdAUTO) {
                        // 9th Apr 2012: AUTO CR/LF mode (tentner)
                        // a CR or LF will generated a CR+LF, if the next character is the opposite, it will be ignored
                        if(PrevCharacter != LF || !PrevCRorLFGeneratedCRLF) {
                                CarriageReturn(TRUE);
                                LineFeed(b, TRUE);
                                PrevCRorLFGeneratedCRLF = TRUE;
                        }
                        else {
                                PrevCRorLFGeneratedCRLF = FALSE;
                        }
                }
                else {
                        CarriageReturn(TRUE);
                        if (ts.CRReceive==IdCRLF) {
                                CommInsert1Byte(&cv, LF);
                        }
                }
                break;
        case SO: /* LS1 */
                if (ts.ISO2022Flag & ISO2022_SO) {
                        if ((ts.Language==IdJapanese) &&
                            (ts.KanjiCode==IdJIS) &&
                            (ts.JIS7Katakana==1) &&
                            ((ts.TermFlag & TF_FIXEDJIS)!=0))
                        {
                                Gn[1] = IdKatakana;
                        }

                        Glr[0] = 1;
                }
                break;
        case SI: /* LS0 */
                if (ts.ISO2022Flag & ISO2022_SI) {
                        Glr[0] = 0;
                }
                break;
        case DLE:
                if ((ts.FTFlag & FT_BPAUTO)!=0)
                        ParseMode = ModeDLE; /* Auto B-Plus activation */
                break;
        case CAN:
                if ((ts.FTFlag & FT_ZAUTO)!=0)
                        ParseMode = ModeCAN; /* Auto ZMODEM activation */
//              else if (ts.AutoWinSwitch>0)
//                      ChangeEmu = IdTEK;      /* Enter TEK Mode */
                else
                        ParseMode = ModeFirst;
                break;
        case SUB:
                ParseMode = ModeFirst;
                break;
        case ESC:
                ICount = 0;
                JustAfterESC = TRUE;
                ParseMode = ModeESC;
                break;
        case FS:
        case GS:
        case RS:
        case US:
                if (ts.AutoWinSwitch>0) {
                        CommInsert1Byte(&cv, b);
                        ChangeEmu = IdTEK;      /* Enter TEK Mode */
                }
                break;

        /* C1 char */
        case IND:
                LineFeed(0, TRUE);
                break;
        case NEL:
                LineFeed(0, TRUE);
                CarriageReturn(TRUE);
                break;
        case HTS:
                if (ts.TabStopFlag & TABF_HTS8)
                        SetTabStop();
                break;
        case RI:
                CursorUpWithScroll();
                break;
        case SS2:
                if (ts.ISO2022Flag & ISO2022_SS2) {
                        GLtmp = 2;
                        SSflag = TRUE;
                }
                break;
        case SS3:
                if (ts.ISO2022Flag & ISO2022_SS3) {
                        GLtmp = 3;
                        SSflag = TRUE;
                }
                break;
        case DCS:
                ClearParams();
                ESCFlag = FALSE;
                ParseMode = ModeDCS;
                break;
        case SOS:
                ESCFlag = FALSE;
                ParseMode = ModeIgnore;
                break;
        case CSI:
                ClearParams();
                FirstPrm = TRUE;
                ParseMode = ModeCSI;
                break;
        case OSC:
                ClearParams();
                ParseMode = ModeXS;
                break;
        case PM:
        case APC:
                ESCFlag = FALSE;
                ParseMode = ModeIgnore;
                break;
        }
}

void SaveCursor()
{
        int i;
        PStatusBuff Buff;

        if (isCursorOnStatusLine)
                Buff = &SBuff2; // for status line
        else if (AltScr)
                Buff = &SBuff3; // for alternate screen
        else
                Buff = &SBuff1; // for main screen

        Buff->CursorX = CursorX;
        Buff->CursorY = CursorY;
        Buff->Attr = CharAttr;

        Buff->Glr[0] = Glr[0];
        Buff->Glr[1] = Glr[1];
        for (i=0 ; i<=3; i++)
                Buff->Gn[i] = Gn[i];

        Buff->AutoWrapMode = AutoWrapMode;
        Buff->RelativeOrgMode = RelativeOrgMode;
}

void RestoreCursor()
{
        int i;
        PStatusBuff Buff;

        UpdateStr();

        if (isCursorOnStatusLine)
                Buff = &SBuff2; // for status line
        else if (AltScr)
                Buff = &SBuff3; // for alternate screen
        else
                Buff = &SBuff1; // for main screen

        if (Buff->CursorX > NumOfColumns-1)
                Buff->CursorX = NumOfColumns-1;
        if (Buff->CursorY > NumOfLines-1-StatusLine)
                Buff->CursorY = NumOfLines-1-StatusLine;
        MoveCursor(Buff->CursorX, Buff->CursorY);

        CharAttr = Buff->Attr;
        BuffSetCurCharAttr(CharAttr);

        Glr[0] = Buff->Glr[0];
        Glr[1] = Buff->Glr[1];
        for (i=0 ; i<=3; i++)
                Gn[i] = Buff->Gn[i];

        AutoWrapMode = Buff->AutoWrapMode;
        RelativeOrgMode = Buff->RelativeOrgMode;
}

void AnswerTerminalType()
{
        char Tmp[50];

        if (ts.TerminalID<IdVT320 || !Send8BitMode)
                strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
        else
                strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);

        switch (ts.TerminalID) {
        case IdVT100:
                strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
                break;
        case IdVT100J:
                strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
                break;
        case IdVT101:
                strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
                break;
        case IdVT102:
                strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
                break;
        case IdVT102J:
                strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
                break;
        case IdVT220J:
                strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
                break;
        case IdVT282:
                strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
                break;
        case IdVT320:
                strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
                break;
        case IdVT382:
                strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
                break;
        case IdVT420:
                strncat_s(Tmp,sizeof(Tmp),"64;1;2;7;8;9;15;18;21",_TRUNCATE);
                break;
        case IdVT520:
                strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;8;9;12;18;19;21;23;24;42;44;45;46",_TRUNCATE);
                break;
        case IdVT525:
                strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;9;12;18;19;21;22;23;24;42;44;45;46",_TRUNCATE);
                break;
        }
        strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);

        CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
}

void ESCSpace(BYTE b)
{
        switch (b) {
        case 'F':  // S7C1T
                Send8BitMode = FALSE;
                break;
        case 'G':  // S8C1T
                if (VTlevel >= 2) {
                        Send8BitMode = TRUE;
                }
                break;
        }
}

void ESCSharp(BYTE b)
{
        switch (b) {
        case '8':  /* Fill screen with "E" (DECALN) */
                BuffUpdateScroll();
                BuffFillWithE();
                CursorTop = 0;
                CursorBottom = NumOfLines-1-StatusLine;
                CursorLeftM = 0;
                CursorRightM = NumOfColumns - 1;
                MoveCursor(0, 0);
                ParseMode = ModeFirst;
                break;
        }
}

/* select double byte code set */
void ESCDBCSSelect(BYTE b)
{
        int Dist;

        if (ts.Language!=IdJapanese) return;

        switch (ICount) {
                case 1:
                        if ((b=='@') || (b=='B'))
                        {
                                Gn[0] = IdKanji; /* Kanji -> G0 */
                                if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
                                        Glr[0] = 0; /* G0->GL */
                        }
                        break;
                case 2:
                        /* Second intermediate char must be
                                 '(' or ')' or '*' or '+'. */
                        Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
                        if ((b=='1') || (b=='3') ||
                                        (b=='@') || (b=='B'))
                        {
                                Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
                                if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
                                                (Dist==0))
                                        Glr[0] = 0; /* G0->GL */
                        }
                        break;
        }
}

void ESCSelectCode(BYTE b)
{
        switch (b) {
                case '0':
                        if (ts.AutoWinSwitch>0)
                                ChangeEmu = IdTEK; /* enter TEK mode */
                        break;
        }
}

        /* select single byte code set */
void ESCSBCSSelect(BYTE b)
{
        int Dist;

        /* Intermediate char must be '(' or ')' or '*' or '+'. */
        Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */

        switch (b) {
        case '0': Gn[Dist] = IdSpecial; break;
        case '<': Gn[Dist] = IdASCII; break;
        case '>': Gn[Dist] = IdASCII; break;
        case 'A': Gn[Dist] = IdASCII; break;
        case 'B': Gn[Dist] = IdASCII; break;
        case 'H': Gn[Dist] = IdASCII; break;
        case 'I':
                if (ts.Language==IdJapanese)
                        Gn[Dist] = IdKatakana;
                break;
        case 'J': Gn[Dist] = IdASCII; break;
        }

        if (((ts.TermFlag & TF_AUTOINVOKE)!=0) && (Dist==0))
                Glr[0] = 0;  /* G0->GL */
}

void PrnParseEscape(BYTE b) // printer mode
{
        int i;

        ParseMode = ModeFirst;
        switch (ICount) {
        /* no intermediate char */
        case 0:
                switch (b) {
                case '[': /* CSI */
                        ClearParams();
                        FirstPrm = TRUE;
                        WriteToPrnFile(PrintFile_, ESC,FALSE);
                        WriteToPrnFile(PrintFile_, '[',FALSE);
                        ParseMode = ModeCSI;
                        return;
                } /* end of case Icount=0 */
                break;
        /* one intermediate char */
        case 1:
                switch (IntChar[1]) {
                case '$':
                        if (! DirectPrn) {
                                ESCDBCSSelect(b);
                                return;
                        }
                        break;
                case '(':
                case ')':
                case '*':
                case '+':
                        if (! DirectPrn) {
                                ESCSBCSSelect(b);
                                return;
                        }
                        break;
                }
                break;
        /* two intermediate char */
        case 2:
                if ((! DirectPrn) &&
                    (IntChar[1]=='$') &&
                    ('('<=IntChar[2]) &&
                    (IntChar[2]<='+'))
                {
                        ESCDBCSSelect(b);
                        return;
                }
                break;
        }
        // send the uninterpreted sequence to printer
        WriteToPrnFile(PrintFile_, ESC,FALSE);
        for (i=1; i<=ICount; i++)
                WriteToPrnFile(PrintFile_, IntChar[i],FALSE);
        WriteToPrnFile(PrintFile_, b,TRUE);
}

void ParseEscape(BYTE b) /* b is the final char */
{
        if (PrinterMode) { // printer mode
                PrnParseEscape(b);
                return;
        }

        switch (ICount) {
        case 0: /* no intermediate char */
                switch (b) {
                case '6': // DECBI
                        if (CursorY >= CursorTop && CursorY <= CursorBottom &&
                            CursorX >= CursorLeftM && CursorX <= CursorRightM) {
                                if (CursorX == CursorLeftM)
                                        BuffScrollRight(1);
                                else
                                        MoveCursor(CursorX-1, CursorY);
                        }
                break;
                case '7': SaveCursor(); break;
                case '8': RestoreCursor(); break;
                case '9': // DECFI
                        if (CursorY >= CursorTop && CursorY <= CursorBottom &&
                            CursorX >= CursorLeftM && CursorX <= CursorRightM) {
                                if (CursorX == CursorRightM)
                                        BuffScrollLeft(1);
                                else
                                        MoveCursor(CursorX+1, CursorY);
                        }
                        break;
                case '=': AppliKeyMode = TRUE; break;
                case '>': AppliKeyMode = FALSE; break;
                case 'D': /* IND */
                        LineFeed(0,TRUE);
                        break;
                case 'E': /* NEL */
                        MoveCursor(0,CursorY);
                        LineFeed(0,TRUE);
                        break;
                case 'H': /* HTS */
                        if (ts.TabStopFlag & TABF_HTS7)
                                SetTabStop();
                        break;
                case 'M': /* RI */
                        CursorUpWithScroll();
                        break;
                case 'N': /* SS2 */
                        if (ts.ISO2022Flag & ISO2022_SS2) {
                                GLtmp = 2;
                                SSflag = TRUE;
                        }
                        break;
                case 'O': /* SS3 */
                        if (ts.ISO2022Flag & ISO2022_SS3) {
                                GLtmp = 3;
                                SSflag = TRUE;
                        }
                        break;
                case 'P': /* DCS */
                        ClearParams();
                        ESCFlag = FALSE;
                        ParseMode = ModeDCS;
                        return;
                case 'X': /* SOS */
                case '^': /* APC */
                case '_': /* PM  */
                        ESCFlag = FALSE;
                        ParseMode = ModeIgnore;
                        return;
                case 'Z': /* DECID */
                        AnswerTerminalType();
                        break;
                case '[': /* CSI */
                        ClearParams();
                        FirstPrm = TRUE;
                        ParseMode = ModeCSI;
                        return;
                case '\\': break; /* ST */
                case ']': /* XTERM sequence (OSC) */
                        ClearParams();
                        ParseMode = ModeXS;
                        return;
                case 'c': /* Hardware reset */
                        HideStatusLine();
                        ResetTerminal();
                        ClearUserKey();
                        ClearBuffer();
                        if (ts.PortType==IdSerial) // reset serial port
                                CommResetSerial(&ts, &cv, TRUE);
                        break;
                case 'g': /* Visual Bell (screen original?) */
                        RingBell(IdBeepVisual);
                        break;
                case 'n': /* LS2 */
                        if (ts.ISO2022Flag & ISO2022_LS2) {
                                Glr[0] = 2;
                        }
                        break;
                case 'o': /* LS3 */
                        if (ts.ISO2022Flag & ISO2022_LS3) {
                                Glr[0] = 3;
                        }
                        break;
                case '|': /* LS3R */
                        if (ts.ISO2022Flag & ISO2022_LS3R) {
                                Glr[1] = 3;
                        }
                        break;
                case '}': /* LS2R */
                        if (ts.ISO2022Flag & ISO2022_LS2R) {
                                Glr[1] = 2;
                        }
                        break;
                case '~': /* LS1R */
                        if (ts.ISO2022Flag & ISO2022_LS1R) {
                                Glr[1] = 1;
                        }
                        break;
                }
                break;
                /* end of case Icount=0 */

        case 1: /* one intermediate char */
                switch (IntChar[1]) {
                case ' ': ESCSpace(b); break;
                case '#': ESCSharp(b); break;
                case '$': ESCDBCSSelect(b); break;
                case '%': break;
                case '(':
                case ')':
                case '*':
                case '+':
                        ESCSBCSSelect(b);
                        break;
                }
                break;

        case 2: /* two intermediate char */
                if ((IntChar[1]=='$') && ('('<=IntChar[2]) && (IntChar[2]<='+'))
                        ESCDBCSSelect(b);
                else if ((IntChar[1]=='%') && (IntChar[2]=='!'))
                        ESCSelectCode(b);
                break;
        }
        ParseMode = ModeFirst;
}

void EscapeSequence(BYTE b)
{
        if (b<=US)
                ParseControl(b);
        else if ((b>=0x20) && (b<=0x2F)) {
                // TODO: ICount �� IntCharMax ���B�������A������ IntChar ���u����������������?
                if (ICount<IntCharMax)
                        ICount++;
                IntChar[ICount] = b;
        }
        else if ((b>=0x30) && (b<=0x7E))
                ParseEscape(b);
        else if ((b>=0x80) && (b<=0x9F))
                ParseControl(b);
        else if (b>=0xA0) {
                ParseMode=ModeFirst;
                ParseFirst(b);
        }

        JustAfterESC = FALSE;
}

#define CheckParamVal(p,m) \
        if ((p) == 0) { \
                (p) = 1; \
        } \
        else if ((p) > (m) || p < 0) { \
                (p) = (m); \
        }

#define CheckParamValMax(p,m) \
        if ((p) > (m) || p <= 0) { \
                (p) = (m); \
        }

#define RequiredParams(n) \
        if ((n) > 1) { \
                while (NParam < n) { \
                        NParam++; \
                        Param[NParam] = 0; \
                        NSParam[NParam] = 0; \
                } \
        }

// ICH
static void CSInsertCharacter(void)
{
        // Insert space characters at cursor
        CheckParamVal(Param[1], NumOfColumns);

        BuffUpdateScroll();
        BuffInsertSpace(Param[1]);
}

void CSCursorUp(BOOL AffectMargin)      // CUU / VPB
{
        int topMargin, NewY;

        CheckParamVal(Param[1], CursorY);

        if (AffectMargin && CursorY >= CursorTop)
                topMargin = CursorTop;
        else
                topMargin = 0;

        NewY = CursorY - Param[1];
        if (NewY < topMargin)
                NewY = topMargin;

        MoveCursor(CursorX, NewY);
}

void CSCursorUp1()                      // CPL
{
        MoveCursor(CursorLeftM, CursorY);
        CSCursorUp(TRUE);
}

void CSCursorDown(BOOL AffectMargin)    // CUD / VPR
{
        int bottomMargin, NewY;

        if (AffectMargin && CursorY <= CursorBottom)
                bottomMargin = CursorBottom;
        else
                bottomMargin = NumOfLines-StatusLine-1;

        CheckParamVal(Param[1], bottomMargin);

        NewY = CursorY + Param[1];
        if (NewY > bottomMargin)
                NewY = bottomMargin;

        MoveCursor(CursorX, NewY);
}

void CSCursorDown1()                    // CNL
{
        MoveCursor(CursorLeftM, CursorY);
        CSCursorDown(TRUE);
}

void CSScreenErase()
{
        BuffUpdateScroll();
        switch (Param[1]) {
          case 0:
                // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
                // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
                // �����������������B(2005.5.29 yutaka)
                // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
                if (ts.ScrollWindowClearScreen &&
                        (CursorX == 0 && CursorY == 0)) {
                        // Erase screen (scroll out)
                        BuffClearScreen();
                        UpdateWindow(HVTWin);

                } else {
                        // Erase characters from cursor to the end of screen
                        BuffEraseCurToEnd();
                }
                break;

          case 1:
                // Erase characters from home to cursor
                BuffEraseHomeToCur();
                break;

          case 2:
                // Erase screen (scroll out)
                BuffClearScreen();
                UpdateWindow(HVTWin);
                if (ClearThenHome && !isCursorOnStatusLine) {
                        if (RelativeOrgMode) {
                                MoveCursor(0, 0);
                        }
                        else {
                                MoveCursor(CursorLeftM, CursorTop);
                        }
                }
                break;

          case 3:
                if (ts.TermFlag & TF_REMOTECLEARSBUFF) {
                        ClearBuffer();
                }
                break;
        }
}

void CSQSelScreenErase()
{
        BuffUpdateScroll();
        switch (Param[1]) {
          case 0:
                // Erase characters from cursor to end
                BuffSelectedEraseCurToEnd();
                break;

          case 1:
                // Erase characters from home to cursor
                BuffSelectedEraseHomeToCur();
                break;

          case 2:
                // Erase entire screen
                BuffSelectedEraseScreen();
                break;

          case 3:
                if (ts.TermFlag & TF_REMOTECLEARSBUFF) {
                        ClearBuffer();
                }
                break;
        }
}

void CSInsertLine()
{
        // Insert lines at current position
        int Count, YEnd;

        if (CursorY < CursorTop || CursorY > CursorBottom) {
                return;
        }

        CheckParamVal(Param[1], NumOfLines);

        Count = Param[1];

        YEnd = CursorBottom;
        if (CursorY > YEnd)
                YEnd = NumOfLines-1-StatusLine;

        if (Count > YEnd+1 - CursorY)
                Count = YEnd+1 - CursorY;

        BuffInsertLines(Count,YEnd);
}

void CSLineErase()
{
        BuffUpdateScroll();
        switch (Param[1]) {
          case 0: /* erase char from cursor to end of line */
                BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
                break;

          case 1: /* erase char from start of line to cursor */
                BuffEraseCharsInLine(0,CursorX+1);
                break;

          case 2: /* erase entire line */
                BuffEraseCharsInLine(0,NumOfColumns);
                break;
        }
}

static void CSQSelLineErase(void)
{
        BuffUpdateScroll();
        switch (Param[1]) {
          case 0: /* erase char from cursor to end of line */
                BuffSelectedEraseCharsInLine(CursorX,NumOfColumns-CursorX);
                break;

          case 1: /* erase char from start of line to cursor */
                BuffSelectedEraseCharsInLine(0,CursorX+1);
                break;

          case 2: /* erase entire line */
                BuffSelectedEraseCharsInLine(0,NumOfColumns);
                break;
        }
}

void CSDeleteNLines()
// Delete lines from current line
{
        int Count, YEnd;

        if (CursorY < CursorTop || CursorY > CursorBottom) {
                return;
        }

        CheckParamVal(Param[1], NumOfLines);
        Count = Param[1];

        YEnd = CursorBottom;
        if (CursorY > YEnd)
                YEnd = NumOfLines-1-StatusLine;

        if (Count > YEnd+1-CursorY)
                Count = YEnd+1-CursorY;

        BuffDeleteLines(Count,YEnd);
}

// DCH
static void CSDeleteCharacter(void)
{
// Delete characters in current line from cursor
        CheckParamVal(Param[1], NumOfColumns);

        BuffUpdateScroll();
        BuffDeleteChars(Param[1]);
}

// ECH
static void CSEraseCharacter(void)
{
        CheckParamVal(Param[1], NumOfColumns);

        BuffUpdateScroll();
        BuffEraseChars(Param[1]);
}

void CSRepeatCharacter()
{
        CheckParamVal(Param[1], NumOfColumns * NumOfLines);

        BuffUpdateScroll();
        RepeatChar(LastPutCharacter, Param[1]);
}

void CSScrollUp()
{
        // TODO: �X�N���[���������l���[���s�����������������v����
        CheckParamVal(Param[1], INT_MAX);

        BuffUpdateScroll();
        BuffRegionScrollUpNLines(Param[1]);
}

void CSScrollDown()
{
        CheckParamVal(Param[1], NumOfLines);

        BuffUpdateScroll();
        BuffRegionScrollDownNLines(Param[1]);
}

void CSForwardTab()
{
        CheckParamVal(Param[1], NumOfColumns);
        CursorForwardTab(Param[1], AutoWrapMode);
}

void CSBackwardTab()
{
        CheckParamVal(Param[1], NumOfColumns);
        CursorBackwardTab(Param[1]);
}

void CSMoveToColumnN()          // CHA / HPA
{
        CheckParamVal(Param[1], NumOfColumns);

        Param[1]--;

        if (RelativeOrgMode) {
                if (CursorLeftM + Param[1] > CursorRightM )
                        MoveCursor(CursorRightM, CursorY);
                else
                        MoveCursor(CursorLeftM + Param[1], CursorY);
        }
        else {
                MoveCursor(Param[1], CursorY);
        }
}

void CSCursorRight(BOOL AffectMargin)   // CUF / HPR
{
        int NewX, rightMargin;

        CheckParamVal(Param[1], NumOfColumns);

        if (AffectMargin && CursorX <= CursorRightM) {
                rightMargin = CursorRightM;
        }
        else {
                rightMargin = NumOfColumns-1;
        }

        NewX = CursorX + Param[1];
        if (NewX > rightMargin)
                NewX = rightMargin;

        MoveCursor(NewX, CursorY);
}

void CSCursorLeft(BOOL AffectMargin)    // CUB / HPB
{
        int NewX, leftMargin;

        CheckParamVal(Param[1], NumOfColumns);

        if (AffectMargin && CursorX >= CursorLeftM) {
                leftMargin = CursorLeftM;
        }
        else {
                leftMargin = 0;
        }

        NewX = CursorX  - Param[1];
        if (NewX < leftMargin) {
                NewX = leftMargin;
        }

        MoveCursor(NewX, CursorY);
}

void CSMoveToLineN()            // VPA
{
        CheckParamVal(Param[1], NumOfLines-StatusLine);

        if (RelativeOrgMode) {
                if (CursorTop+Param[1]-1 > CursorBottom)
                        MoveCursor(CursorX,CursorBottom);
                else
                        MoveCursor(CursorX,CursorTop+Param[1]-1);
        }
        else {
                if (Param[1] > NumOfLines-StatusLine)
                        MoveCursor(CursorX,NumOfLines-1-StatusLine);
                else
                        MoveCursor(CursorX,Param[1]-1);
        }
        Fallbacked = FALSE;
}

void CSMoveToXY()               // CUP / HVP
{
        int NewX, NewY;

        RequiredParams(2);
        CheckParamVal(Param[1], NumOfLines-StatusLine);
        CheckParamVal(Param[2], NumOfColumns);

        NewY = Param[1] - 1;
        NewX = Param[2] - 1;

        if (isCursorOnStatusLine)
                NewY = CursorY;
        else if (RelativeOrgMode) {
                NewX += CursorLeftM;
                if (NewX > CursorRightM)
                        NewX = CursorRightM;

                NewY += CursorTop;
                if (NewY > CursorBottom)
                        NewY = CursorBottom;
        }
        else {
                if (NewY > NumOfLines-1-StatusLine)
                        NewY = NumOfLines-1-StatusLine;
        }

        MoveCursor(NewX, NewY);
        Fallbacked = FALSE;
}

void CSDeleteTabStop()
{
        ClearTabStop(Param[1]);
}

void CS_h_Mode()                // SM
{
        switch (Param[1]) {
          case 2:       // KAM
                KeybEnabled = FALSE; break;
          case 4:       // IRM
                InsertMode = TRUE; break;
          case 12:      // SRM
                ts.LocalEcho = 0;
                if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
                        TelChangeEcho();
                break;
          case 20:      // LF/NL
                LFMode = TRUE;
                ts.CRSend = IdCRLF;
                cv.CRSend = IdCRLF;
                break;
          case 33:      // WYSTCURM
                if (ts.WindowFlag & WF_CURSORCHANGE) {
                        ts.NonblinkingCursor = TRUE;
                        ChangeCaret();
                }
                break;
          case 34:      // WYULCURM
                if (ts.WindowFlag & WF_CURSORCHANGE) {
                        ts.CursorShape = IdHCur;
                        ChangeCaret();
                }
                break;
        }
}

void CS_i_Mode()                // MC
{
        switch (Param[1]) {
          /* print screen */
          //  PrintEX -- TRUE: print screen
          //             FALSE: scroll region
          case 0:
                if (ts.TermFlag&TF_PRINTERCTRL) {
                        BuffPrint(! PrintEX);
                }
                break;
          /* printer controller mode off */
          case 4: break; /* See PrnParseCS() */
          /* printer controller mode on */
          case 5:
                if (ts.TermFlag&TF_PRINTERCTRL) {
                        if (! AutoPrintMode)
                                PrintFile_ = OpenPrnFile();
                        DirectPrn = (ts.PrnDev[0]!=0);
                        PrinterMode = TRUE;
                }
                break;
        }
}

void CS_l_Mode()                // RM
{
        switch (Param[1]) {
          case 2:       // KAM
                KeybEnabled = TRUE; break;
          case 4:       // IRM
                InsertMode = FALSE; break;
          case 12:      // SRM
                ts.LocalEcho = 1;
                if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
                        TelChangeEcho();
                break;
          case 20:      // LF/NL
                LFMode = FALSE;
                ts.CRSend = IdCR;
                cv.CRSend = IdCR;
                break;
          case 33:      // WYSTCURM
                if (ts.WindowFlag & WF_CURSORCHANGE) {
                        ts.NonblinkingCursor = FALSE;
                        ChangeCaret();
                }
                break;
          case 34:      // WYULCURM
                if (ts.WindowFlag & WF_CURSORCHANGE) {
                        ts.CursorShape = IdBlkCur;
                        ChangeCaret();
                }
                break;
        }
}

void CS_n_Mode()                // DSR
{
        char Report[16];
        int X, Y, len;

        switch (Param[1]) {
          case 5:
                /* Device Status Report -> Ready */
                SendCSIstr("0n", 0);
                break;
          case 6:
                /* Cursor Position Report */
                if (isCursorOnStatusLine) {
                        X = CursorX + 1;
                        Y = 1;
                }
                else if (RelativeOrgMode) {
                        X = CursorX - CursorLeftM + 1;
                        Y = CursorY - CursorTop + 1;
                }
                else {
                        X = CursorX + 1;
                        Y = CursorY+1;
                }
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%u;%uR", CLocale, Y, X);
                SendCSIstr(Report, len);
                break;
        }
}

void ParseSGRParams(PCharAttr attr, PCharAttr mask, int start)
{
        int i, j, P, r, g, b, color;
        TCharAttr dummy;

        if (mask == NULL) {
                mask = &dummy;
        }

        for (i=start ; i<=NParam ; i++) {
                P = Param[i];
                switch (P) {
                  case   0:     /* Clear all */
                        attr->Attr = DefCharAttr.Attr;
                        attr->Attr2 = DefCharAttr.Attr2 | (attr->Attr2&Attr2Protect);
#if UNICODE_INTERNAL_BUFF
                        attr->AttrEx = attr->Attr;
#endif
                        attr->Fore = DefCharAttr.Fore;
                        attr->Back = DefCharAttr.Back;
                        mask->Attr = AttrSgrMask;
                        mask->Attr2 = Attr2ColorMask;
                        break;

                  case   1:     /* Bold */
                        attr->Attr |= AttrBold;
                        mask->Attr |= AttrBold;
                        break;

                  case   4:     /* Under line */
                        attr->Attr |= AttrUnder;
                        mask->Attr |= AttrUnder;
                        break;

                  case   5:     /* Blink */
                        attr->Attr |= AttrBlink;
                        mask->Attr |= AttrBlink;
                        break;

                  case   7:     /* Reverse */
                        attr->Attr |= AttrReverse;
                        mask->Attr |= AttrReverse;
                        break;

                  case  22:     /* Bold off */
                        attr->Attr &= ~ AttrBold;
                        mask->Attr |= AttrBold;
                        break;

                  case  24:     /* Under line off */
                        attr->Attr &= ~ AttrUnder;
                        mask->Attr |= AttrUnder;
                        break;

                  case  25:     /* Blink off */
                        attr->Attr &= ~ AttrBlink;
                        mask->Attr |= AttrBlink;
                        break;

                  case  27:     /* Reverse off */
                        attr->Attr &= ~ AttrReverse;
                        mask->Attr |= AttrReverse;
                        break;

                  case  30:
                  case  31:
                  case  32:
                  case  33:
                  case  34:
                  case  35:
                  case  36:
                  case  37:     /* text color */
                        attr->Attr2 |= Attr2Fore;
                        mask->Attr2 |= Attr2Fore;
                        attr->Fore = P - 30;
                        break;

                  case  38:     /* text color (256color mode) */
                        if (ts.ColorFlag & CF_XTERM256) {
                                /*
                                 * Change foreground color. accept following formats.
                                 *
                                 * 38 ; 2 ; r ; g ; b
                                 * 38 ; 2 : r : g : b
                                 * 38 : 2 : r : g : b
                                 * 38 ; 5 ; idx
                                 * 38 ; 5 : idx
                                 * 38 : 5 : idx
                                 *
                                 */
                                color = -1;
                                j = 0;
                                if (NSParam[i] > 0) {
                                        P = SubParam[i][1];
                                        j++;
                                }
                                else if (i < NParam) {
                                        P = Param[i+1];
                                        if (P == 2 || P == 5) {
                                                i++;
                                        }
                                }
                                switch (P) {
                                  case 2:
                                        r = g = b = 0;
                                        if (NSParam[i] > 0) {
                                                if (j < NSParam[i]) {
                                                        r = SubParam[i][++j];
                                                        if (j < NSParam[i]) {
                                                                g = SubParam[i][++j];
                                                        }
                                                        if (j < NSParam[i]) {
                                                                b = SubParam