teraterm/teraterm/vtterm.c

/* Tera Term
 Copyright(C) 1994-1998 T. Teranishi
 All rights reserved. */

/* TERATERM.EXE, VT terminal emulation */
#include "teraterm.h"
#include "tttypes.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <mbstring.h>
#include <locale.h>
#include <ctype.h>

#include "buffer.h"
#include "ttwinman.h"
#include "ttcommon.h"
#include "commlib.h"
#include "vtdisp.h"
#include "keyboard.h"
#include "ttlib.h"
#include "ttftypes.h"
#include "filesys.h"
#include "teraprn.h"
#include "telnet.h"
#include "ttime.h"
#include "clipboar.h"

#include "vtterm.h"

void ParseFirst(BYTE b);

#define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
#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;
BOOL BracketedPaste;

static int VTlevel;

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
BYTE PrevCharacter;
BOOL PrevCRorLFGeneratedCRLF;     // indicates that previous CR or LF really generated a CR+LF

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

static BOOL ESCFlag, JustAfterESC;
static BOOL KanjiIn;
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;
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;

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

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

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

/* IME Status */
BOOL IMEstat;

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

static _locale_t CLocale = NULL;

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;

  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
  IMEstat = FALSE;

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

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

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

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

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
}

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 = NumOfColumns-1;
  LRMarginMode = FALSE;
}

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 (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
                }
        }
        else if (CursorX > 0) {
                MoveCursor(CursorX-1, CursorY);
                if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
        }
}

void CarriageReturn(BOOL logFlag)
{
#ifndef NO_COPYLINE_FIX
        if (!ts.EnableContinuedLineCopy || logFlag)
#endif /* NO_COPYLINE_FIX */
        if (cv.HLogBuf!=0) Log1Byte(CR);

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

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

#ifndef NO_COPYLINE_FIX
        if (!ts.EnableContinuedLineCopy || logFlag)
#endif /* NO_COPYLINE_FIX */
        if (cv.HLogBuf!=0) Log1Byte(LF);

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

#ifndef NO_COPYLINE_FIX
        ClearLineContinued();
#endif /* NO_COPYLINE_FIX */

        if (LFMode) CarriageReturn(logFlag);
}

void Tab()
{
  if (Wrap && !ts.VTCompatTab) {
      CarriageReturn(FALSE);
      LineFeed(LF,FALSE);
#ifndef NO_COPYLINE_FIX
      if (ts.EnableContinuedLineCopy) {
        SetLineContinued();
      }
#endif /* NO_COPYLINE_FIX */
      Wrap = FALSE;
  }
  CursorForwardTab(1, AutoWrapMode);
  if (cv.HLogBuf!=0) Log1Byte(HT);
}

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

  CharAttrTmp = CharAttr;

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

  if (Wrap)
  {
    CarriageReturn(FALSE);
    LineFeed(LF,FALSE);
#ifndef NO_COPYLINE_FIX
    CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
#endif /* NO_COPYLINE_FIX */
  }

//  if (cv.HLogBuf!=0) Log1Byte(b);
// (2005.2.20 yutaka)
  if (ts.LogTypePlainText) {
          if (__isascii(b) && !isprint(b)) {
                  // ASCII�������A���\�������������O�����������B
          } else {
                if (cv.HLogBuf!=0) Log1Byte(b);
          }
  } else {
          if (cv.HLogBuf!=0) Log1Byte(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;

  BuffPutChar(b, CharAttrTmp, InsertMode);

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

void PutDecSp(BYTE b)
{
  TCharAttr CharAttrTmp;

  CharAttrTmp = CharAttr;

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

  if (Wrap) {
    CarriageReturn(FALSE);
    LineFeed(LF, FALSE);
#ifndef NO_COPYLINE_FIX
    CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
#endif /* NO_COPYLINE_FIX */
  }

  if (cv.HLogBuf!=0) Log1Byte(b);
/*
  if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
    // ASCII�������A���\�������������O�����������B
  } else {
    if (cv.HLogBuf!=0) Log1Byte(b);
  }
 */

  Wrap = FALSE;

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

  CharAttrTmp.Attr |= AttrSpecial;
  BuffPutChar(b, CharAttrTmp, InsertMode);

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

void PutKanji(BYTE b)
{
  int LineEnd;
#ifndef NO_COPYLINE_FIX
  TCharAttr CharAttrTmp;

  CharAttrTmp = CharAttr;
#endif /* NO_COPYLINE_FIX */
  Kanji = Kanji + b;

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

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

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

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

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

  Wrap = FALSE;

  if (cv.HLogBuf!=0)
  {
    Log1Byte(HIBYTE(Kanji));
    Log1Byte(LOBYTE(Kanji));
  }

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

#ifndef NO_COPYLINE_FIX
  BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
#else
  BuffPutKanji(Kanji, CharAttr, InsertMode);
#endif /* NO_COPYLINE_FIX */

  if (CursorX < LineEnd - 1) {
    MoveRight();
    MoveRight();
  }
  else {
    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;
        }
}

void PrnParseControl(BYTE b) // printer mode
{
  switch (b) {
    case NUL: return;
    case SO:
      if (! 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 (! DirectPrn)
      {
        Glr[0] = 0; /* LS0 */
        return;
      }
      break;
    case DC1:
    case DC3: return;
    case ESC:
      ICount = 0;
      JustAfterESC = TRUE;
      ParseMode = ModeESC;
      WriteToPrnFile(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(0,TRUE); // flush prn buff
      WriteToPrnFile(b,FALSE);
      return;
  }
  /* send the uninterpreted character to printer */
  WriteToPrnFile(b,TRUE);
}

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

  if (b>=0x80) /* C1 char */
  {
    /* English mode */
    if (ts.Language==IdEnglish)
    {
      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:
      if ((ts.Language==IdJapanese) &&
          (ts.KanjiCode==IdJIS) &&
          (ts.JIS7Katakana==1) &&
          ((ts.TermFlag & TF_FIXEDJIS)!=0))
        Gn[1] = IdKatakana;

      Glr[0] = 1; /* LS1 */
      break;
    case SI: Glr[0] = 0; break; /* LS0 */
    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:
      GLtmp = 2;
      SSflag = TRUE;
      break;
    case 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(ESC,FALSE);
          WriteToPrnFile('[',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(ESC,FALSE);
  for (i=1; i<=ICount; i++)
    WriteToPrnFile(IntChar[i],FALSE);
  WriteToPrnFile(b,TRUE);
}

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

  switch (ICount) {
    /* no intermediate char */
    case 0:
      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 */
          GLtmp = 2;
          SSflag = TRUE;
          break;
        case 'O': /* 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': Glr[0] = 2; break; /* LS2 */
        case 'o': Glr[0] = 3; break; /* LS3 */
        case '|': Glr[1] = 3; break; /* LS3R */
        case '}': Glr[1] = 2; break; /* LS2R */
        case '~': Glr[1] = 1; break; /* LS1R */
      } /* end of case Icount=0 */
      break;
    /* one intermediate char */
    case 1:
      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;
    /* two intermediate char */
    case 2:
      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; \
                } \
        }

void CSInsertCharacter()                // ICH
{
        // 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;
        }
}

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

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

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

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

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

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

        BuffUpdateScroll();
        BuffEraseChars(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);
        }
}

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

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

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

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

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

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

        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)
                        DispShowWindow(WINDOW_MINIMIZE);
                break;

          case 3: // set window position
                if (ts.WindowFlag & WF_WINDOWCHANGE) {
                        RequiredParams(3);
                        DispMoveWindow(Param[2], Param[3]);
                }
                break;

          case 4: // set window size
                if (ts.WindowFlag & WF_WINDOWCHANGE) {
                        RequiredParams(3);
                        DispResizeWin(Param[3], Param[2]);
                }
                break;

          case 5: // Raise window
                if (ts.WindowFlag & WF_WINDOWCHANGE)
                        DispShowWindow(WINDOW_RAISE);
                break;

          case 6: // Lower window
                if (ts.WindowFlag & WF_WINDOWCHANGE)
                        DispShowWindow(WINDOW_LOWER);
                break;

          case 7: // Refresh window
                if (ts.WindowFlag & WF_WINDOWCHANGE)
                        DispShowWindow(WINDOW_REFRESH);
                break;

          case 8: /* set terminal size */
                if (ts.WindowFlag & WF_WINDOWCHANGE) {
                        RequiredParams(3);
                        if (Param[2] <= 1) Param[2] = 24;
                        if (Param[3] <= 1) Param[3] = 80;
                        ChangeTerminalSize(Param[3], Param[2]);
                }
                break;

          case 9: // Maximize/Restore window
                if (ts.WindowFlag & WF_WINDOWCHANGE) {
                        RequiredParams(2);
                        if (Param[2] == 0) {
                                DispShowWindow(WINDOW_RESTORE);
                        }
                        else if (Param[2] == 1) {
                                DispShowWindow(WINDOW_MAXIMIZE);
                        }
                }
                break;

          case 11: // Report window state
                if (ts.WindowFlag & WF_WINDOWREPORT) {
                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%dt", CLocale, DispWindowIconified()?2:1);
                        SendCSIstr(Report, len);
                }
                break;

          case 13: // Report window position
                if (ts.WindowFlag & WF_WINDOWREPORT) {
                        DispGetWindowPos(&x, &y);
                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "3;%u;%ut", CLocale, (unsigned int)x, (unsigned int)y);
                        SendCSIstr(Report, len);
                }
                break;

          case 14: /* get window size */
                if (ts.WindowFlag & WF_WINDOWREPORT) {
                        DispGetWindowSize(&x, &y);
                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "4;%d;%dt", CLocale, y, x);
                        SendCSIstr(Report, len);
                }
                break;

          case 18: /* get terminal size */
                if (ts.WindowFlag & WF_WINDOWREPORT) {
                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "8;%u;%ut", CLocale,
                                            NumOfLines-StatusLine, NumOfColumns);
                        SendCSIstr(Report, len);
                }
                break;

          case 19: // Report display size (character)
                if (ts.WindowFlag & WF_WINDOWREPORT) {
                        DispGetRootWinSize(&x, &y);
                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "9;%d;%dt", CLocale, y, x);
                        SendCSIstr(Report, len);
                }
                break;

          case 20: // Report icon label
                switch (ts.WindowFlag & WF_TITLEREPORT) {
                  case IdTitleReportIgnore:
                        // nothing to do
                        break;

                  case IdTitleReportAccept:
                        switch (ts.AcceptTitleChangeRequest) {
                          case IdTitleChangeRequestOff:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
                                break;

                          case IdTitleChangeRequestAhead:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, cv.TitleRemote, ts.Title);
                                break;

                          case IdTitleChangeRequestLast:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, ts.Title, cv.TitleRemote);
                                break;

                          default:
                                if (cv.TitleRemote[0] == 0) {
                                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
                                }
                                else {
                                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, cv.TitleRemote);
                                }
                        }
                        SendOSCstr(Report, len, ST);
                        break;

                  default: // IdTitleReportEmpty:
                        SendOSCstr("L", 0, ST);
                        break;
                }
                break;

          case 21: // Report window title
                switch (ts.WindowFlag & WF_TITLEREPORT) {
                  case IdTitleReportIgnore:
                        // nothing to do
                        break;

                  case IdTitleReportAccept:
                        switch (ts.AcceptTitleChangeRequest) {
                          case IdTitleChangeRequestOff:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
                                break;

                          case IdTitleChangeRequestAhead:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, cv.TitleRemote, ts.Title);
                                break;

                          case IdTitleChangeRequestLast:
                                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, ts.Title, cv.TitleRemote);
                                break;

                          default:
                                if (cv.TitleRemote[0] == 0) {
                                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
                                }
                                else {
                                        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, cv.TitleRemote);
                                }
                        }
                        SendOSCstr(Report, len, ST);
                        break;

                  default: // IdTitleReportEmpty:
                        SendOSCstr("l", 0, ST);
                        break;
                }
                break;

          case 22: // Push Title
                RequiredParams(2);
                switch (Param[2]) {
                  case 0:
                  case 1:
                  case 2:
                        if (ts.AcceptTitleChangeRequest && (t=malloc(sizeof(TStack))) != NULL) {
                                if ((t->title = _strdup(cv.TitleRemote)) != NULL) {
                                        t->next = TitleStack;
                                        TitleStack = t;
                                }
                                else {
                                        free(t);
                                }
                        }
                        break;
                }
                break;

          case 23: // Pop Title
                RequiredParams(2);
                switch (Param[2]) {
                  case 0:
                  case 1:
                  case 2:
                        if (ts.AcceptTitleChangeRequest && TitleStack != NULL) {
                                t = TitleStack;
                                TitleStack = t->next;
                                strncpy_s(cv.TitleRemote, sizeof(cv.TitleRemote), t->title, _TRUNCATE);
                                ChangeTitle();
                                free(t->title);
                                free(t);
                        }
                        break;
                }