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 <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 "ttdde.h"
#include "checkeol.h"
#include "asprintf.h"
#include "charset.h"
#include "ttcstd.h"

#include "vtterm.h"

// #define DEBUG_DUMP_INPUTCODE 1

#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

static void RingBell(int type);
static void VisualBell(void);
static BOOL DecLocatorReport(int Event, int Button);
static CharSetData *CharSetInitTerm(void);

/* 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;
        CharSetState CharSetState;
        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 char32_t LastPutCharacter;

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

static BOOL ESCFlag, JustAfterESC;

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 {
        wchar_t *title;
        struct tstack *next;
} TStack;
typedef TStack *PTStack;
static PTStack TitleStack = NULL;

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

// 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 CharSetData *charset_data;
static vtterm_work_t vtterm_work;

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

static void SaveCursorBuf(PStatusBuff Buff)
{
        Buff->CursorX = CursorX;
        Buff->CursorY = CursorY;
        Buff->Attr = CharAttr;

        CharSetSaveState(charset_data, &Buff->CharSetState);
        Buff->AutoWrapMode = AutoWrapMode;
        Buff->RelativeOrgMode = RelativeOrgMode;
}

static void SaveCursor()
{
        PStatusBuff Buff;

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

        SaveCursorBuf(Buff);
}

static void RestoreCursor()
{
        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);
        CharSetLoadState(charset_data, &Buff->CharSetState);

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

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

        /* Attribute */
        CharAttr = DefCharAttr;
        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();
        // status buffers
        SaveCursorBuf(&SBuff1);
        SaveCursorBuf(&SBuff2);
        SaveCursorBuf(&SBuff3);

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

        /* Parse mode */
        ParseMode = ModeFirst;

        /* Clear printer mode */
        PrinterMode = FALSE;

        // 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;
                if (vtterm->check_eol == NULL) {
                        vtterm->check_eol = CheckEOLCreate();
                }
                else {
                        CheckEOLClear(vtterm->check_eol);
                }
                vtterm->log_cr_type = 0;
        }
}

void ResetCharSet()
{
        if (ts.Language != IdJapanese) {
                cv.SendCode = IdASCII;
                cv.EchoCode = IdASCII;
        }

        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;

        if (charset_data != NULL) {
                CharSetFinish(charset_data);
        }
        charset_data = CharSetInitTerm();
}

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

static void MoveToMainScreen(void)
{
        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;
}

static void SendCSIstr(char *str, int len)
{
        size_t 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);
}

static void SendOSCstrW(const wchar_t *str, char TermChar)
{
        size_t len;

        if (str == NULL) {
                return;
        }

        len = wcslen(str);

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

}

static void SendOSCstr(char *str, int len, char TermChar)
{
        size_t 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);
        }

}

static void SendDCSstr(char *str, int len)
{
        size_t 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);
        }
}

static void BackSpace(void)
{
        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);

        CharSetFallbackFinish(charset_data);
}

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);

        CharSetFallbackFinish(charset_data);
}

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

static void BuffPutChar(BYTE b, TCharAttr Attr, BOOL Insert)
{
        BuffPutUnicode(b, Attr, Insert);
}

/**
 *      unicode(char32_t)���o�b�t�@����������
 *              ���O������������������ PutU32() ���g��
 */
static void PutU32NoLog(unsigned int code)
{
        int LineEnd;
        TCharAttr CharAttrTmp;
        BOOL dec_special;
        int r;

        LastPutCharacter = code;

        dec_special = FALSE;
        if (code <= 0xff) {
                dec_special = CharSetIsSpecial(charset_data, code);
        }

        if (ts.Dec2Unicode) {
                if (dec_special) {
                        // DEC������������Unicode�����}�b�s���O
                        if (ts.Dec2Unicode) {
                                // 0x5f����0x7e �� Unicode �������U��
                                //  Unicode�����}�b�s���O��
                                //  DEC Special Graphics(Wikipedia en)��Unicode���Q�l������
                                //       https://en.wikipedia.org/wiki/DEC_Special_Graphics
                                static const char16_t dec2unicode[] = {
                                                                                        0x00a0,         // 0x5f

                                        0x25c6, 0x2592, 0x2409, 0x240c,         // 0x60 -
                                        0x240d, 0x240a, 0x00b0, 0x00b1,
                                        0x2424, 0x240b, 0x2518, 0x2510,
                                        0x250c, 0x2514, 0x253c, 0x23ba,         // 0x6c - 0x6f

                                        0x23bb, 0x2500, 0x23bc, 0x23bd,         // 0x70 -
                                        0x251c, 0x2524, 0x2534, 0x252c,
                                        0x2502, 0x2264, 0x2265, 0x03c0,
                                        0x2260, 0x00a3, 0x00b7,                         // 0x7c - 0x7e
                                };
                                code = code & 0x7F;
                                if (0x5f <= code && code <= 0x7e) {
                                        code = dec2unicode[code - 0x5f];
                                        dec_special = FALSE;
                                }
                        }
                }
        }
        else {
                // Unicode����DEC�������������}�b�s���O
                if (dec_special == FALSE && ts.UnicodeDecSpMapping) {
                        unsigned short cset;
                        cset = UTF32ToDecSp(code);
                        if (((cset >> 8) & ts.UnicodeDecSpMapping) != 0) {
                                dec_special = TRUE;
                                code = cset & 0xff;
                        }
                }
        }

        CharAttrTmp = CharAttr;
        if (dec_special) {
                CharAttrTmp.Attr |= AttrSpecial;
        }
        else {
                CharAttrTmp.Attr |= CharAttr.Attr;
        }

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

        // Wrap�����A�J�[�\������
        if (Wrap) {
                // ���� Wrap ����
                if (!BuffIsCombiningCharacter(CursorX, CursorY, code)) {
                        // �����R�[�h������������������ = �J�[�\������������

                        // �J�[�\�����u���s�p���A�g���r���[�g������
                        TCharAttr t = BuffGetCursorCharAttr(CursorX, CursorY);
                        t.Attr |= AttrLineContinued;
                        t.AttrEx = t.Attr;
                        BuffSetCursorCharAttr(CursorX, CursorY, t);

                        // �s�p���A�g���r���[�g��������
                        CharAttrTmp.Attr |= AttrLineContinued;
                        CharAttrTmp.AttrEx = CharAttrTmp.Attr;

                        // �����s���s����
                        CarriageReturn(FALSE);
                        LineFeed(LF,FALSE);
                }
        }

        // �o�b�t�@��������������
        //      BuffPutUnicode()���������l���������Z�������m��������������
        //              �G���[�����J�[�\�����u����������
        CharAttrTmp.AttrEx = CharAttrTmp.Attr;
retry:
        r = BuffPutUnicode(code, CharAttrTmp, InsertMode);
        if (r == -1) {
                // �����S�p���s���A������������

                if (AutoWrapMode) {
                        // �������s
                        // �Awrap����
                        CharAttrTmp = CharAttr;
                        CharAttrTmp.Attr |= AttrLineContinued;
                        CharAttrTmp.AttrEx = CharAttrTmp.Attr | AttrPadding;
                        // AutoWrapMode
                        // ts.EnableContinuedLineCopy
                        //if (CursorX != LineEnd){
                        //&& BuffIsHalfWidthFromCode(&ts, code)) {

                        // full width�o���������o������������������0x20���o��
                        BuffPutUnicode(0x20, CharAttrTmp, FALSE);
                        CharAttrTmp.AttrEx = CharAttrTmp.AttrEx & ~AttrPadding;

                        // �����s���s����
                        CarriageReturn(FALSE);
                        LineFeed(LF,FALSE);
                }
                else {
                        // �s��������
                        CursorX = 0;
                }

                //CharAttrTmp.Attr &= ~AttrLineContinued;
                goto retry;
        }
        else if (r == 0) {
                // �J�[�\������������,��������,��������
                // Wrap ������������
                UpdateStr();    // �u���v->�u���v�����A�����������������������`������
        } else if (r == 1) {
                // ���p(1�Z��)
                if (CursorX + 0 == CursorRightM || CursorX >= NumOfColumns - 1) {
                        UpdateStr();
                        Wrap = AutoWrapMode;
                } else {
                        MoveRight();
                        Wrap = FALSE;
                }
        } else if (r == 2) {
                // �S�p(2�Z��)
                if (CursorX + 1 == CursorRightM || CursorX + 1 >= NumOfColumns - 1) {
                        MoveRight();    // �S�p���E�����J�[�\������
                        UpdateStr();
                        Wrap = AutoWrapMode;
                } else {
                        MoveRight();
                        MoveRight();
                        Wrap = FALSE;
                }
        }
        else {
                assert(FALSE);
        }
}

/**
 *      unicode(char32_t)���o�b�t�@����������
 *      ���O������������
 *
 *      PutChar() �� UTF-32��
 */
static void PutU32(unsigned int code)
{
        PutU32NoLog(code);

        // ���O���o��
        OutputLogUTF32(code);
}

static void RepeatChar(char32_t b, int count)
{
        int i;

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

        for (i = 0; i < count; i++) {
                PutU32NoLog(b);
        }
}

static void PutChar(BYTE b)
{
        PutU32(b);
}

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))
                        {
                                CharSet2022Designate(charset_data, 1, IdKatakana);
                        }
                        /* LS1 */
                        CharSet2022Invoke(charset_data, CHARSET_LS1);
                        return;
                }
                break;
        case SI:
                if ((ts.ISO2022Flag & ISO2022_SI) && ! DirectPrn) {
                        /* LS0 */
                        CharSet2022Invoke(charset_data, CHARSET_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))
                        {
                                CharSet2022Designate(charset_data, 1, IdKatakana);
                        }

                        CharSet2022Invoke(charset_data, CHARSET_LS1);
                }
                break;
        case SI: /* LS0 */
                if (ts.ISO2022Flag & ISO2022_SI) {
                        CharSet2022Invoke(charset_data, CHARSET_LS0);
                }
                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) {
                        CharSet2022Invoke(charset_data, CHARSET_SS2);
                }
                break;
        case SS3:
                if (ts.ISO2022Flag & ISO2022_SS3) {
                        CharSet2022Invoke(charset_data, CHARSET_SS3);
                }
                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;
        }
}

static void csPutU32(char32_t code, void *client_data)
{
        (void)client_data;
        PutU32(code);
}

static void csParseControl(BYTE b, void *client_data)
{
        (void)client_data;
        ParseControl(b);
}

static CharSetData *CharSetInitTerm(void)
{
        CharSetOp op;
        op.PutU32 = csPutU32;
        op.ParseControl = csParseControl;
        return CharSetInit(&op, NULL);
}

static void AnswerTerminalType(void)
{
        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 */
}

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

static 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 */
static void ESCDBCSSelect(BYTE b)
{
        int Dist;

        if (ts.Language!=IdJapanese) return;

        switch (ICount) {
                case 1:
                        // - ESC $ @ (01/11 02/04 04/00) (0x1b 0x24 0x40)
                        //              - G0 <- ��JIS����
                        //              - ��JIS���� = JIS X 0208-1978 (JIS C 6226-1978)
                        // - ESC $ B (01/11 02/04 04/02) (0x1b 0x24 0x42)
                        //              - G0 <- �VJIS����
                        //              - �VJIS���� = JIS X 0208-1990
                        if ((b=='@') || (b=='B'))
                        {
                                /* Kanji -> G0 */
                                CharSet2022Designate(charset_data, 0, IdKanji);
                                if ((ts.TermFlag & TF_AUTOINVOKE)!=0) {
                                        /* G0->GL */
                                        CharSet2022Invoke(charset_data, CHARSET_LS0);
                                }
                        }
                        break;
                case 2:
                        // - ESC $ ( @ (01/11 02/04 02/08 04/00) (0x1b 0x24 0x28 0x40)
                        // - ESC $ ) @ (01/11 02/04 02/09 04/00) (0x1b 0x24 0x29 0x40)
                        // - ESC $ * @ (01/11 02/04 02/10 04/00) (0x1b 0x24 0x2a 0x40)
                        // - ESC $ + @ (01/11 02/04 02/11 04/00) (0x1b 0x24 0x2b 0x40)
                        //              - G0..G3 <- ��JIS����
                        // - ESC $ ( B (01/11 02/04 02/08 04/02) (0x1b 0x24 0x28 0x42)
                        // - ESC $ ) B (01/11 02/04 02/09 04/02) (0x1b 0x24 0x29 0x42)
                        // - ESC $ * B (01/11 02/04 02/10 04/02) (0x1b 0x24 0x2a 0x42)
                        // - ESC $ + B (01/11 02/04 02/11 04/02) (0x1b 0x24 0x2b 0x42)
                        //              - G0..G3 <- �VJIS����
                        //
                        /* Second intermediate char must be
                                 '(' or ')' or '*' or '+'. */
                        Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
                        if ((b=='1') || (b=='3') ||
                                        (b=='@') || (b=='B'))
                        {
                                /* Kanji -> G0-3 */
                                CharSet2022Designate(charset_data, Dist, IdKanji);
                                if (((ts.TermFlag & TF_AUTOINVOKE)!=0) && (Dist==0)) {
                                        /* G0->GL */
                                        CharSet2022Invoke(charset_data, CHARSET_LS0);
                                }
                        }
                        break;
        }
}

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

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

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

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

        if (((ts.TermFlag & TF_AUTOINVOKE)!=0) && (Dist==0)) {
                /* G0->GL */
                CharSet2022Invoke(charset_data, CHARSET_LS0);
        }
}

static 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);
}

static 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) {
                                CharSet2022Invoke(charset_data, CHARSET_SS2);
                        }
                        break;
                case 'O': /* SS3 */
                        if (ts.ISO2022Flag & ISO2022_SS3) {
                                CharSet2022Invoke(charset_data, CHARSET_SS3);
                        }
                        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) {
                                CharSet2022Invoke(charset_data, CHARSET_LS2);
                        }
                        break;
                case 'o': /* LS3 */
                        if (ts.ISO2022Flag & ISO2022_LS3) {
                                CharSet2022Invoke(charset_data, CHARSET_LS3);
                        }
                        break;
                case '|': /* LS3R */
                        if (ts.ISO2022Flag & ISO2022_LS3R) {
                                CharSet2022Invoke(charset_data, CHARSET_LS3R);
                        }
                        break;
                case '}': /* LS2R */
                        if (ts.ISO2022Flag & ISO2022_LS2R) {
                                CharSet2022Invoke(charset_data, CHARSET_LS2R);
                        }
                        break;
                case '~': /* LS1R */
                        if (ts.ISO2022Flag & ISO2022_LS1R) {
                                CharSet2022Invoke(charset_data, CHARSET_LS1R);
                        }
                        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;
}

static 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(charset_data, 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]);
}

static 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);
}

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

static 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);
}

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

static 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;
        }
}

static 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;
        }
}

static 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);
}

static 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;
        }
}

static 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]);
}

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

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

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

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

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

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

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

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

static 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);
        }
}

static 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);
}

static 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);
}

static 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);
        }
        CharSetFallbackFinish(charset_data);
}

static 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);
        CharSetFallbackFinish(charset_data);
}

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

static 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;
        }
}

static 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;
        }
}

static 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;
        }
}

static 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;
        }
}

static 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);
                        attr->AttrEx = attr->Attr;
                        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[i][++j];
                                                        }
                                                        color = DispFindClosestColor(r, g, b);
                                                }
                                        }
                                        else if (i < NParam && NSParam[i+1] > 0) {
                                                r = Param[++i];
                                                g = SubParam[i][1];
                                                if (NSParam[i] > 1) {
                                                        b = SubParam[i][2];
                                                }
                                                color = DispFindClosestColor(r, g, b);
                                        }
                                        else if (i+2 < NParam) {
                                                r = Param[++i];
                                                g = Param[++i];
                                                b = Param[++i];
                                                color = DispFindClosestColor(r, g, b);
                                        }
                                        break;
                                  case 5:
                                        if (NSParam[i] > 0) {
                                                if (j < NSParam[i]) {
                                                        color = SubParam[i][++j];
                                                }
                                        }
                                        else if (i < NParam) {
                                                color = Param[++i];
                                        }
                                        break;
                                }
                                if (color >= 0 && color < 256) {
                                        attr->Attr2 |= Attr2Fore;
                                        mask->Attr2 |= Attr2Fore;
                                        attr->Fore = color;
                                }
                        }
                        break;

                  case  39:     /* Reset text color */
                        attr->Attr2 &= ~ Attr2Fore;
                        mask->Attr2 |= Attr2Fore;
                        attr->Fore = AttrDefaultFG;
                        break;

                  case  40:
                  case  41:
                  case  42:
                  case  43:
                  case  44:
                  case  45:
                  case  46:
                  case  47:     /* Back color */
                        attr->Attr2 |= Attr2Back;
                        mask->Attr2 |= Attr2Back;
                        attr->Back = P - 40;
                        break;

                  case  48:     /* Back color (256color mode) */
                        if (ts.ColorFlag & CF_XTERM256) {
                                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[i][++j];
                                                        }
                                                        color = DispFindClosestColor(r, g, b);
                                                }
                                        }
                                        else if (i < NParam && NSParam[i+1] > 0) {
                                                r = Param[++i];
                                                g = SubParam[i][1];
                                                if (NSParam[i] > 1) {
                                                        b = SubParam[i][2];
                                                }
                                                color = DispFindClosestColor(r, g, b);
                                        }
                                        else if (i+2 < NParam) {
                                                r = Param[++i];
                                                g = Param[++i];
                                                b = Param[++i];
                                                color = DispFindClosestColor(r, g, b);
                                        }
                                        break;
                                  case 5:
                                        if (NSParam[i] > 0) {
                                                if (j < NSParam[i]) {
                                                        color = SubParam[i][++j];
                                                }
                                        }
                                        else if (i < NParam) {
                                                color = Param[++i];
                                        }
                                        break;
                                }
                                if (color >= 0 && color < 256) {
                                        attr->Attr2 |= Attr2Back;
                                        mask->Attr2 |= Attr2Back;
                                        attr->Back = color;
                                }
                        }
                        break;

                  case  49:     /* Reset back color */
                        attr->Attr2 &= ~ Attr2Back;
                        mask->Attr2 |= Attr2Back;
                        attr->Back = AttrDefaultBG;
                        break;

                  case 90:
                  case 91:
                  case 92:
                  case 93:
                  case 94:
                  case 95:
                  case 96:
                  case 97:      /* aixterm style text color */
                        if (ts.ColorFlag & CF_AIXTERM16) {
                                attr->Attr2 |= Attr2Fore;
                                mask->Attr2 |= Attr2Fore;
                                attr->Fore = P - 90 + 8;
                        }
                        break;

                  case 100:
                        if (! (ts.ColorFlag & CF_AIXTERM16)) {
                                /* Reset text and back color */
                                attr->Attr2 &= ~ (Attr2Fore | Attr2Back);
                                mask->Attr2 |= Attr2ColorMask;
                                attr->Fore = AttrDefaultFG;
                                attr->Back = AttrDefaultBG;
                                break;
                        }
                        // fall through
                        //  to aixterm style back color

                  case 101:
                  case 102:
                  case 103:
                  case 104:
                  case 105:
                  case 106:
                  case 107:     /* aixterm style back color */
                        if (ts.ColorFlag & CF_AIXTERM16) {
                                attr->Attr2 |= Attr2Back;
                                mask->Attr2 |= Attr2Back;
                                attr->Back = P - 100 + 8;
                        }
                        break;
                }
        }
}

static void CSSetAttr(void)             // SGR
{
        UpdateStr();
        ParseSGRParams(&CharAttr, NULL, 1);
        BuffSetCurCharAttr(CharAttr);
}

static void CSSetScrollRegion() // DECSTBM
{
        if (isCursorOnStatusLine) {
                MoveCursor(0,CursorY);
                return;
        }

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

        if (Param[1] >= Param[2])
                return;

        CursorTop = Param[1] - 1;
        CursorBottom = Param[2] - 1;

        if (RelativeOrgMode)
                // TODO: ���}�[�W���������������B�v���@�m�F�B
                MoveCursor(0, CursorTop);
        else
                MoveCursor(0, 0);
}

static void CSSetLRScrollRegion()       // DECSLRM
{
//      TODO: �X�e�[�^�X���C�������������m�F�B
//      if (isCursorOnStatusLine) {
//              MoveCursor(0,CursorY);
//              return;
//      }

        RequiredParams(2);
        CheckParamVal(Param[1], NumOfColumns);
        CheckParamValMax(Param[2], NumOfColumns);

        if (Param[1] >= Param[2])
                return;

        CursorLeftM = Param[1] - 1;
        CursorRightM = Param[2] - 1;

        if (RelativeOrgMode)
                MoveCursor(CursorLeftM, CursorTop);
        else
                MoveCursor(0, 0);
}

// CSI sequence
static void CSSunSequence() /* Sun terminal private sequences */
{
        int x, y, len;
        char Report[TitleBuffSize*2+10];

        switch (Param[1]) {
          case 1: // De-iconify window
                if (ts.WindowFlag & WF_WINDOWCHANGE)
                        DispShowWindow(WINDOW_RESTORE);
                break;

          case 2: // Iconify window
                if (ts.WindowFlag & WF_WINDOWCHANGE)