teraterm/teraterm/buffer.c

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004-2020 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, scroll buffer routines */

#include "teraterm.h"
#include <string.h>
#include <stdio.h>
#include <windows.h>
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <mbstring.h>
#include <assert.h>
#include <errno.h>

#include "tttypes.h"
#include "ttwinman.h"
#include "teraprn.h"
#include "vtdisp.h"
#include "telnet.h"
#include "ttplug.h" /* TTPLUG */
#include "codeconv.h"
#include "unicode.h"
#include "buffer.h"
#include "unicode_test.h"
#include "asprintf.h"

typedef unsigned long char32_t;         // C++11

// �o�b�t�@�������p1������������
typedef struct {
        char32_t u32;
        char32_t u32_last;
        char WidthProperty;                             // 'W' or 'F' or 'H' or 'A' (����������)
        char HalfWidth;                                 // TRUE/FALSE = ���p/�S�p (�\������������������)
        char Padding;                                   // TRUE = �S�p�������l���� or �s�����l����
        char Emoji;                                             // TRUE = �G����
        unsigned char CombinationCharCount16;   // charactor count
        unsigned char CombinationCharSize16;            // buffer size
        unsigned char CombinationCharCount32;
        unsigned char CombinationCharSize32;
        wchar_t *pCombinationChars16;
        char32_t *pCombinationChars32;
        wchar_t wc2[2];
        unsigned char fg;
        unsigned char bg;
        unsigned char attr;
        unsigned char attr2;
        unsigned short ansi_char;
} buff_char_t;

#define BuffXMax TermWidthMax
//#define BuffYMax 100000
//#define BuffSizeMax 8000000
// �X�N���[���o�b�t�@�����������g�� (2004.11.28 yutaka)
#define BuffYMax 500000
#define BuffSizeMax (BuffYMax * 80)

// status line
int StatusLine; //0: none 1: shown
/* top, bottom, left & right margin */
int CursorTop, CursorBottom, CursorLeftM, CursorRightM;
BOOL Selected, Selecting;
BOOL Wrap;

static WORD TabStops[256];
static int NTabStops;

static WORD BuffLock = 0;

static buff_char_t *CodeBuffW;
static LONG LinePtr;
static LONG BufferSize;
static int NumOfLinesInBuff;
static int BuffStartAbs, BuffEndAbs;
static POINT SelectStart, SelectStartTmp, SelectEnd, SelectEndOld;
static DWORD SelectStartTime;
static BOOL BoxSelect;
static POINT DblClkStart, DblClkEnd;

// �`��
static int StrChangeStart;      // �`���J�n X (Y=CursorY)
static int StrChangeCount;      // �`���L�����N�^��(���p�P��),0�������`����������������
static BOOL UseUnicodeApi;

static BOOL SeveralPageSelect;  // add (2005.5.15 yutaka)

static TCharAttr CurCharAttr;

static char *SaveBuff = NULL;
static int SaveBuffX;
static int SaveBuffY;

static void BuffDrawLineI(int DrawX, int DrawY, int SY, int IStart, int IEnd);

static void BuffSetChar2(buff_char_t *buff, char32_t u32, char property, BOOL half_width, char emoji)
{
        size_t wstr_len;
        buff_char_t *p = buff;
        if (p->pCombinationChars16 != NULL) {
                free(p->pCombinationChars16);
                p->pCombinationChars16 = NULL;
        }
        p->CombinationCharCount16 = 0;
        p->CombinationCharSize16 = 0;
        if (p->pCombinationChars32 != NULL) {
                free(p->pCombinationChars32);
                p->pCombinationChars32 = NULL;
        }
        p->CombinationCharCount32 = 0;
        p->CombinationCharSize32 = 0;
        p->WidthProperty = property;
        p->HalfWidth = (char)half_width;
        p->u32 = u32;
        p->u32_last = u32;
        p->Padding = FALSE;
        p->Emoji = emoji;
        p->fg = AttrDefaultFG;
        p->bg = AttrDefaultBG;

        //
        wstr_len = UTF32ToUTF16(u32, &p->wc2[0], 2);
        switch (wstr_len) {
        case 0:
        default:
                p->wc2[0] = 0;
                p->wc2[1] = 0;
                break;
        case 1:
                p->wc2[1] = 0;
                break;
        case 2:
                break;
        }

        if (u32 < 0x80) {
                p->ansi_char = (unsigned short)u32;
        }
        else {
                char strA[4];
                size_t lenA = UTF32ToMBCP(u32, CP_ACP, strA, sizeof(strA));
                switch (lenA) {
                        case 0:
                        default:
                                p->ansi_char = 0;
                                break;
                        case 1:
                                p->ansi_char = (unsigned char)strA[0];
                                break;
                        case 2:
                                p->ansi_char = (unsigned char)strA[1] | ((unsigned char)strA[0] << 8);
                                break;
                }
        }
}

static void BuffSetChar3(buff_char_t *buff, char32_t u32, unsigned char fg, unsigned char bg, char property)
{
        buff_char_t *p = buff;
        BuffSetChar2(p, u32, property, TRUE, FALSE);
        p->fg = fg;
        p->bg = bg;
}

static void BuffSetChar4(buff_char_t *buff, char32_t u32, unsigned char fg, unsigned char bg, unsigned char attr, unsigned char attr2, char property)
{
        buff_char_t *p = buff;
        BuffSetChar2(p, u32, property, TRUE, FALSE);
        p->fg = fg;
        p->bg = bg;
        p->attr = attr;
        p->attr2 = attr2;
}

static void BuffSetChar(buff_char_t *buff, char32_t u32, char property)
{
        BuffSetChar2(buff, u32, property, TRUE, FALSE);
}

/**
 *      �����������A�R���r�l�[�V����
 */
static void BuffAddChar(buff_char_t *buff, char32_t u32)
{
        buff_char_t *p = buff;
        assert(p->u32 != 0);
        // �������������������g������
        if (p->CombinationCharSize16 < p->CombinationCharCount16 + 2) {
                size_t new_size = p->CombinationCharSize16;
                new_size = new_size == 0 ? 5 : new_size * 2;
                p->pCombinationChars16 = realloc(p->pCombinationChars16, sizeof(wchar_t) * new_size);
                p->CombinationCharSize16 = (char)new_size;
        }
        if (p->CombinationCharSize32 < p->CombinationCharCount32 + 2) {
                size_t new_size = p->CombinationCharSize32;
                new_size = new_size == 0 ? 5 : new_size * 2;
                p->pCombinationChars32 = realloc(p->pCombinationChars32, sizeof(char32_t) * new_size);
                p->CombinationCharSize32 = (char)new_size;
        }

        // UTF-32
        p->u32_last = u32;
        p->pCombinationChars32[(size_t)p->CombinationCharCount32] = u32;
        p->CombinationCharCount32++;

        // UTF-16
        {
                wchar_t *u16 = &p->pCombinationChars16[(size_t)p->CombinationCharCount16];
                size_t wlen = UTF32ToUTF16(u32, u16, 2);
                p->CombinationCharCount16 += (char)wlen;
        }
}

// TODO: ���[�N����
static void memcpyW(buff_char_t *dest, const buff_char_t *src, size_t count)
{
        size_t i;
        memcpy(dest, src, count * sizeof(buff_char_t));
        for (i=0; i<count; i++) {
                buff_char_t *p = &dest[i];
                size_t size = p->CombinationCharSize16;
                if (size > 0) {
                        wchar_t *new_buf = malloc(sizeof(wchar_t) * size);
                        memcpy(new_buf, p->pCombinationChars16, sizeof(wchar_t) * size);
                        p->pCombinationChars16 = new_buf;
                }
                size = p->CombinationCharSize32;
                if (size > 0) {
                        char32_t *new_buf = malloc(sizeof(char32_t) * size);
                        memcpy(new_buf, p->pCombinationChars32, sizeof(char32_t) * size);
                        p->pCombinationChars32 = new_buf;
                }
        }
}

static void memsetW(buff_char_t *dest, wchar_t ch, unsigned char fg, unsigned char bg, unsigned char attr, unsigned char attr2, size_t count)
{
        size_t i;
        for (i=0; i<count; i++) {
                BuffSetChar(dest, ch, 'H');
                dest->fg = fg;
                dest->bg = bg;
                dest->attr = attr;
                dest->attr2 = attr2;
                dest++;
        }
}

static void memmoveW(buff_char_t *dest, const buff_char_t *src, size_t count)
{
        memmove(dest, src, count * sizeof(buff_char_t));
}

static BOOL IsBuffPadding(const buff_char_t *b)
{
        if (b->Padding == TRUE)
                return TRUE;
        if (b->u32 == 0)
                return TRUE;
        return FALSE;
}

static BOOL IsBuffFullWidth(const buff_char_t *b)
{
        if (b->HalfWidth == FALSE)
                return TRUE;
        return FALSE;
}

static LONG GetLinePtr(int Line)
{
        LONG Ptr;

        Ptr = (LONG)(BuffStartAbs + Line) * (LONG)(NumOfColumns);
        while (Ptr>=BufferSize) {
                Ptr = Ptr - BufferSize;
        }
        return Ptr;
}

static LONG NextLinePtr(LONG Ptr)
{
        Ptr = Ptr + (LONG)NumOfColumns;
        if (Ptr >= BufferSize) {
                Ptr = Ptr - BufferSize;
        }
        return Ptr;
}

static LONG PrevLinePtr(LONG Ptr)
{
        Ptr = Ptr - (LONG)NumOfColumns;
        if (Ptr < 0) {
                Ptr = Ptr + BufferSize;
        }
        return Ptr;
}

/**
 * �|�C���^�����u���� x,y ��������
 */
static void GetPosFromPtr(const buff_char_t *b, int *bx, int *by)
{
        size_t index = b - CodeBuffW;
        int x = (int)(index % NumOfColumns);
        int y = (int)(index / NumOfColumns);
        if (y >= BuffStartAbs) {
                y -= BuffStartAbs;
        }
        else {
                y += (NumOfLines - BuffStartAbs);
        }
        *bx = x;
        *by = y;
}

static BOOL ChangeBuffer(int Nx, int Ny)
{
        LONG NewSize;
        int NxCopy, NyCopy, i;
        LONG SrcPtr, DestPtr;
        WORD LockOld;
        buff_char_t *CodeDestW;

        if (Nx > BuffXMax) {
                Nx = BuffXMax;
        }
        if (ts.ScrollBuffMax > BuffYMax) {
                ts.ScrollBuffMax = BuffYMax;
        }
        if (Ny > ts.ScrollBuffMax) {
                Ny = ts.ScrollBuffMax;
        }

        if ( (LONG)Nx * (LONG)Ny > BuffSizeMax ) {
                Ny = BuffSizeMax / Nx;
        }

        NewSize = (LONG)Nx * (LONG)Ny;

        CodeDestW = NULL;
        CodeDestW = malloc(NewSize * sizeof(buff_char_t));
        if (CodeDestW == NULL) {
                goto allocate_error;
        }

        memset(&CodeDestW[0], 0, NewSize * sizeof(buff_char_t));
        memsetW(&CodeDestW[0], 0x20, AttrDefaultFG, AttrDefaultBG, AttrDefault, AttrDefault, NewSize);
        if ( CodeBuffW != NULL ) {
                if ( NumOfColumns > Nx ) {
                        NxCopy = Nx;
                }
                else {
                        NxCopy = NumOfColumns;
                }

                if ( BuffEnd > Ny ) {
                        NyCopy = Ny;
                }
                else {
                        NyCopy = BuffEnd;
                }
                LockOld = BuffLock;
                LockBuffer();
                SrcPtr = GetLinePtr(BuffEnd-NyCopy);
                DestPtr = 0;
                for (i = 1 ; i <= NyCopy ; i++) {
                        memcpyW(&CodeDestW[DestPtr],&CodeBuffW[SrcPtr],NxCopy);
                        if (CodeDestW[DestPtr+NxCopy-1].attr & AttrKanji) {
                                BuffSetChar(&CodeDestW[DestPtr + NxCopy - 1], ' ', 'H');
                                CodeDestW[DestPtr+NxCopy-1].attr ^= AttrKanji;
                        }
                        SrcPtr = NextLinePtr(SrcPtr);
                        DestPtr = DestPtr + (LONG)Nx;
                }
                FreeBuffer();
        }
        else {
                LockOld = 0;
                NyCopy = NumOfLines;
                Selected = FALSE;
        }

        if (Selected) {
                SelectStart.y = SelectStart.y - BuffEnd + NyCopy;
                SelectEnd.y = SelectEnd.y - BuffEnd + NyCopy;
                if (SelectStart.y < 0) {
                        SelectStart.y = 0;
                        SelectStart.x = 0;
                }
                if (SelectEnd.y<0) {
                        SelectEnd.x = 0;
                        SelectEnd.y = 0;
                }

                Selected = (SelectEnd.y > SelectStart.y) ||
                           ((SelectEnd.y == SelectStart.y) &&
                            (SelectEnd.x > SelectStart.x));
        }

        CodeBuffW = CodeDestW;
        BufferSize = NewSize;
        NumOfLinesInBuff = Ny;
        BuffStartAbs = 0;
        BuffEnd = NyCopy;

        if (BuffEnd==NumOfLinesInBuff) {
                BuffEndAbs = 0;
        }
        else {
                BuffEndAbs = BuffEnd;
        }

        PageStart = BuffEnd - NumOfLines;

        LinePtr = 0;
        if (LockOld>0) {
        }
        else {
                ;
        }
        BuffLock = LockOld;

        return TRUE;

allocate_error:
        if (CodeDestW)  free(CodeDestW);
        return FALSE;
}

void InitBuffer(BOOL use_unicode_api)
{
        int Ny;

        UseUnicodeApi = use_unicode_api;

        /* setup terminal */
        NumOfColumns = ts.TerminalWidth;
        NumOfLines = ts.TerminalHeight;

        if (NumOfColumns <= 0)
                NumOfColumns = 80;
        else if (NumOfColumns > TermWidthMax)
                NumOfColumns = TermWidthMax;

        if (NumOfLines <= 0)
                NumOfLines = 24;
        else if (NumOfLines > TermHeightMax)
                NumOfLines = TermHeightMax;

        /* setup window */
        if (ts.EnableScrollBuff>0) {
                if (ts.ScrollBuffSize < NumOfLines) {
                        ts.ScrollBuffSize = NumOfLines;
                }
                Ny = ts.ScrollBuffSize;
        }
        else {
                Ny = NumOfLines;
        }

        if (! ChangeBuffer(NumOfColumns,Ny)) {
                PostQuitMessage(0);
        }

        if (ts.EnableScrollBuff>0) {
                ts.ScrollBuffSize = NumOfLinesInBuff;
        }

        StatusLine = 0;
}

static void NewLine(int Line)
{
        LinePtr = GetLinePtr(Line);
}

void LockBuffer()
{
        BuffLock++;
        if (BuffLock>1) {
                return;
        }
        NewLine(PageStart+CursorY);
}

void UnlockBuffer()
{
        if (BuffLock==0) {
                return;
        }
        BuffLock--;
        if (BuffLock>0) {
                return;
        }
}

void FreeBuffer()
{
        BuffLock = 1;
        UnlockBuffer();
        if (CodeBuffW != NULL) {
                free(CodeBuffW);
                CodeBuffW = NULL;
        }
}

void BuffAllSelect()
{
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd.x = 0;
        SelectEnd.y = BuffEnd;
//      SelectEnd.x = NumOfColumns;
//      SelectEnd.y = BuffEnd - 1;
        Selecting = TRUE;
}

void BuffScreenSelect()
{
        int X, Y;
        DispConvWinToScreen(0, 0, &X, &Y, NULL);
        SelectStart.x = X;
        SelectStart.y = Y + PageStart;
        SelectEnd.x = 0;
        SelectEnd.y = SelectStart.y + NumOfLines;
//      SelectEnd.x = X + NumOfColumns;
//      SelectEnd.y = Y + PageStart + NumOfLines - 1;
        Selecting = TRUE;
}

void BuffCancelSelection()
{
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd.x = 0;
        SelectEnd.y = 0;
        Selecting = FALSE;
}

void BuffReset()
// Reset buffer status. don't update real display
//   called by ResetTerminal()
{
        int i;

        /* Cursor */
        NewLine(PageStart);
        WinOrgX = 0;
        WinOrgY = 0;
        NewOrgX = 0;
        NewOrgY = 0;

        /* Top/bottom margin */
        CursorTop = 0;
        CursorBottom = NumOfLines-1;
        CursorLeftM = 0;
        CursorRightM = NumOfColumns-1;

        /* Tab stops */
        NTabStops = (NumOfColumns-1) >> 3;
        for (i=1 ; i<=NTabStops ; i++) {
                TabStops[i-1] = (WORD)(i*8);
        }

        /* Initialize text selection region */
        SelectStart.x = 0;
        SelectStart.y = 0;
        SelectEnd = SelectStart;
        SelectEndOld = SelectStart;
        Selected = FALSE;

        StrChangeCount = 0;
        Wrap = FALSE;
        StatusLine = 0;

        SeveralPageSelect = FALSE; // yutaka

        /* Alternate Screen Buffer */
        BuffDiscardSavedScreen();
}

void BuffScroll(int Count, int Bottom)
{
        int i, n;
        LONG SrcPtr, DestPtr;
        int BuffEndOld;

        if (Count>NumOfLinesInBuff) {
                Count = NumOfLinesInBuff;
        }

        DestPtr = GetLinePtr(PageStart+NumOfLines-1+Count);
        n = Count;
        if (Bottom<NumOfLines-1) {
                SrcPtr = GetLinePtr(PageStart+NumOfLines-1);
                for (i=NumOfLines-1; i>=Bottom+1; i--) {
                        memcpyW(&(CodeBuffW[DestPtr]),&(CodeBuffW[SrcPtr]),NumOfColumns);
                        memsetW(&(CodeBuffW[SrcPtr]),0x20,CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
                        SrcPtr = PrevLinePtr(SrcPtr);
                        DestPtr = PrevLinePtr(DestPtr);
                        n--;
                }
        }
        for (i = 1 ; i <= n ; i++) {
                buff_char_t *b = &CodeBuffW[DestPtr];
                memsetW(b ,0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns);
                DestPtr = PrevLinePtr(DestPtr);
        }

        BuffEndAbs = BuffEndAbs + Count;
        if (BuffEndAbs >= NumOfLinesInBuff) {
                BuffEndAbs = BuffEndAbs - NumOfLinesInBuff;
        }
        BuffEndOld = BuffEnd;
        BuffEnd = BuffEnd + Count;
        if (BuffEnd >= NumOfLinesInBuff) {
                BuffEnd = NumOfLinesInBuff;
                BuffStartAbs = BuffEndAbs;
        }
        PageStart = BuffEnd-NumOfLines;

        if (Selected) {
                SelectStart.y = SelectStart.y - Count + BuffEnd - BuffEndOld;
                SelectEnd.y = SelectEnd.y - Count + BuffEnd - BuffEndOld;
                if ( SelectStart.y<0 ) {
                        SelectStart.x = 0;
                        SelectStart.y = 0;
                }
                if ( SelectEnd.y<0 ) {
                        SelectEnd.x = 0;
                        SelectEnd.y = 0;
                }
                Selected = (SelectEnd.y > SelectStart.y) ||
                       ((SelectEnd.y==SelectStart.y) &&
                        (SelectEnd.x > SelectStart.x));
        }

        NewLine(PageStart+CursorY);
}

// If cursor is on left/right half of a Kanji, erase it.
//   LR: left(0)/right(1) flag
//      LR      0       �J�[�\��������������
//              1       �J�[�\�����������E��
static void EraseKanji(int LR)
{
        buff_char_t * CodeLineW = &CodeBuffW[LinePtr];

        buff_char_t *p;
        int bx;
        if (CursorX < LR) {
                // �S�p������������
                return;
        }
        bx = CursorX-LR;
        p = &CodeLineW[bx];
        if (IsBuffFullWidth(p)) {
                // �S�p��������
                BuffSetChar(p, ' ', 'H');
                p->attr = CurCharAttr.Attr;
                p->attr2 = CurCharAttr.Attr2;
                p->fg = CurCharAttr.Fore;
                p->bg = CurCharAttr.Back;
                if (bx+1 < NumOfColumns) {
                        BuffSetChar(p + 1, ' ', 'H');
                        (p+1)->attr = CurCharAttr.Attr;
                        (p+1)->attr2 = CurCharAttr.Attr2;
                        (p+1)->fg = CurCharAttr.Fore;
                        (p+1)->bg = CurCharAttr.Back;
                }
        }
}

void EraseKanjiOnLRMargin(LONG ptr, int count)
{
        int i;
        LONG pos;

        if (count < 1)
                return;

        for (i=0; i<count; i++) {
                pos = ptr + CursorLeftM-1;
                if (CursorLeftM>0 && (CodeBuffW[pos].attr & AttrKanji)) {
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
                        CodeBuffW[pos].attr &= ~AttrKanji;
                        pos++;
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
                        CodeBuffW[pos].attr &= ~AttrKanji;
                }
                pos = ptr + CursorRightM;
                if (CursorRightM < NumOfColumns-1 && (CodeBuffW[pos].attr & AttrKanji)) {
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
                        CodeBuffW[pos].attr &= ~AttrKanji;
                        pos++;
                        BuffSetChar(&CodeBuffW[pos], 0x20, 'H');
                        CodeBuffW[pos].attr &= ~AttrKanji;
                }
                ptr = NextLinePtr(ptr);
        }
}

// Insert space characters at the current position
//   Count: Number of characters to be inserted
void BuffInsertSpace(int Count)
{
        buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
        int MoveLen;
        int extr = 0;
        int sx;
        buff_char_t *b;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart + CursorY);

        sx = CursorX;
        b = &CodeLineW[CursorX];
        if (IsBuffPadding(b)) {
                /* if cursor is on right half of a kanji, erase the kanji */
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
                b->attr &= ~AttrKanji;
                sx--;
                extr++;
        }

        if (CursorRightM < NumOfColumns - 1 && (CodeLineW[CursorRightM].attr & AttrKanji)) {
                BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
                CodeLineW[CursorRightM + 1].attr &= ~AttrKanji;
                extr++;
        }

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmoveW(&(CodeLineW[CursorX + Count]), &(CodeLineW[CursorX]), MoveLen);
        }
        memsetW(&(CodeLineW[CursorX]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2, Count);
        /* last char in current line is kanji first? */
        if ((CodeLineW[CursorRightM].attr & AttrKanji) != 0) {
                /* then delete it */
                BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
                CodeLineW[CursorRightM].attr &= ~AttrKanji;
        }
        BuffUpdateRect(sx, CursorY, CursorRightM + extr, CursorY);
}

void BuffEraseCurToEnd()
// Erase characters from cursor to the end of screen
{
        LONG TmpPtr;
        int offset;
        int i, YEnd;

        NewLine(PageStart+CursorY);
        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
        }
        offset = CursorX;
        TmpPtr = GetLinePtr(PageStart+CursorY);
        YEnd = NumOfLines-1;
        if (StatusLine && !isCursorOnStatusLine) {
                YEnd--;
        }
        for (i = CursorY ; i <= YEnd ; i++) {
                memsetW(&(CodeBuffW[TmpPtr+offset]),0x20,CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, NumOfColumns-offset);
                offset = 0;
                TmpPtr = NextLinePtr(TmpPtr);
        }
        /* update window */
        DispEraseCurToEnd(YEnd);
}

void BuffEraseHomeToCur()
// Erase characters from home to cursor
{
        LONG TmpPtr;
        int offset;
        int i, YHome;

        NewLine(PageStart+CursorY);
        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(0); /* if cursor is on left half of a kanji, erase the kanji */
        }
        offset = NumOfColumns;
        if (isCursorOnStatusLine) {
                YHome = CursorY;
        }
        else {
                YHome = 0;
        }
        TmpPtr = GetLinePtr(PageStart+YHome);
        for (i = YHome ; i <= CursorY ; i++) {
                if (i==CursorY) {
                        offset = CursorX+1;
                }
                memsetW(&(CodeBuffW[TmpPtr]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, offset);
                TmpPtr = NextLinePtr(TmpPtr);
        }

        /* update window */
        DispEraseHomeToCur(YHome);
}

void BuffInsertLines(int Count, int YEnd)
// Insert lines at current position
//   Count: number of lines to be inserted
//   YEnd: bottom line number of scroll region (screen coordinate)
{
        int i, linelen;
        int extl=0, extr=0;
        LONG SrcPtr, DestPtr;

        BuffUpdateScroll();

        if (CursorLeftM > 0)
                extl = 1;
        if (CursorRightM < NumOfColumns-1)
                extr = 1;
        if (extl || extr)
                EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);

        SrcPtr = GetLinePtr(PageStart+YEnd-Count) + CursorLeftM;
        DestPtr = GetLinePtr(PageStart+YEnd) + CursorLeftM;
        linelen = CursorRightM - CursorLeftM + 1;
        for (i= YEnd-Count ; i>=CursorY ; i--) {
                memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
                SrcPtr = PrevLinePtr(SrcPtr);
                DestPtr = PrevLinePtr(DestPtr);
        }
        for (i = 1 ; i <= Count ; i++) {
                memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
                DestPtr = PrevLinePtr(DestPtr);
        }

        if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || !DispInsertLines(Count, YEnd)) {
                BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
        }
}

void BuffEraseCharsInLine(int XStart, int Count)
// erase characters in the current line
//  XStart: start position of erasing
//  Count: number of characters to be erased
{
        buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
        BOOL LineContinued=FALSE;

        if (ts.EnableContinuedLineCopy && XStart == 0 && (CodeLineW[0].attr & AttrLineContinued)) {
                LineContinued = TRUE;
        }

        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                EraseKanji(1); /* if cursor is on right half of a kanji, erase the kanji */
        }

        NewLine(PageStart+CursorY);
        memsetW(&(CodeLineW[XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, Count);

        if (ts.EnableContinuedLineCopy) {
                if (LineContinued) {
                        BuffLineContinued(TRUE);
                }

                if (XStart + Count >= NumOfColumns) {
                        CodeBuffW[NextLinePtr(LinePtr)].attr &= ~AttrLineContinued;
                }
        }

        DispEraseCharsInLine(XStart, Count);
}

void BuffDeleteLines(int Count, int YEnd)
// Delete lines from current line
//   Count: number of lines to be deleted
//   YEnd: bottom line number of scroll region (screen coordinate)
{
        int i, linelen;
        int extl=0, extr=0;
        LONG SrcPtr, DestPtr;

        BuffUpdateScroll();

        if (CursorLeftM > 0)
                extl = 1;
        if (CursorRightM < NumOfColumns-1)
                extr = 1;
        if (extl || extr)
                EraseKanjiOnLRMargin(GetLinePtr(PageStart+CursorY), YEnd-CursorY+1);

        SrcPtr = GetLinePtr(PageStart+CursorY+Count) + (LONG)CursorLeftM;
        DestPtr = GetLinePtr(PageStart+CursorY) + (LONG)CursorLeftM;
        linelen = CursorRightM - CursorLeftM + 1;
        for (i=CursorY ; i<= YEnd-Count ; i++) {
                memcpyW(&(CodeBuffW[DestPtr]), &(CodeBuffW[SrcPtr]), linelen);
                SrcPtr = NextLinePtr(SrcPtr);
                DestPtr = NextLinePtr(DestPtr);
        }
        for (i = YEnd+1-Count ; i<=YEnd ; i++) {
                memsetW(&(CodeBuffW[DestPtr]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, linelen);
                DestPtr = NextLinePtr(DestPtr);
        }

        if (CursorLeftM > 0 || CursorRightM < NumOfColumns-1 || ! DispDeleteLines(Count,YEnd)) {
                BuffUpdateRect(CursorLeftM-extl, CursorY, CursorRightM+extr, YEnd);
        }
}

// Delete characters in current line from cursor
//   Count: number of characters to be deleted
void BuffDeleteChars(int Count)
{
        buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
        int MoveLen;
        int extr = 0;
        buff_char_t *b;

        if (Count > CursorRightM + 1 - CursorX)
                Count = CursorRightM + 1 - CursorX;

        if (CursorX < CursorLeftM || CursorX > CursorRightM)
                return;

        NewLine(PageStart + CursorY);

        b = &CodeLineW[CursorX];

        if (IsBuffPadding(b)) {
                // �S�p���E���A�S�p���X�y�[�X���u��������
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
        }
        if (IsBuffFullWidth(b)) {
                // �S�p�������A�S�p���X�y�[�X���u��������
                BuffSetChar(b, ' ', 'H');
                BuffSetChar(b + 1, ' ', 'H');
        }
        if (Count > 1) {
                // �I�[���`�F�b�N
                if (IsBuffPadding(b + Count)) {
                        // �S�p���E���A�S�p���X�y�[�X���u��������
                        BuffSetChar(b + Count - 1, ' ', 'H');
                        BuffSetChar(b + Count, ' ', 'H');
                }
        }

        if (CursorRightM < NumOfColumns - 1 && (CodeLineW[CursorRightM].attr & AttrKanji)) {
                BuffSetChar(&CodeLineW[CursorRightM], 0x20, 'H');
                CodeLineW[CursorRightM].attr &= ~AttrKanji;
                BuffSetChar(&CodeLineW[CursorRightM + 1], 0x20, 'H');
                CodeLineW[CursorRightM + 1].attr &= ~AttrKanji;
                extr = 1;
        }

        MoveLen = CursorRightM + 1 - CursorX - Count;

        if (MoveLen > 0) {
                memmoveW(&(CodeLineW[CursorX]), &(CodeLineW[CursorX + Count]), MoveLen);
        }
        memsetW(&(CodeLineW[CursorX + MoveLen]), ' ', CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, Count);

        BuffUpdateRect(CursorX, CursorY, CursorRightM + extr, CursorY);
}

// Erase characters in current line from cursor
//   Count: number of characters to be deleted
void BuffEraseChars(int Count)
{
        buff_char_t * CodeLineW = &CodeBuffW[LinePtr];
        int extr = 0;
        int sx = CursorX;
        buff_char_t *b;
        NewLine(PageStart + CursorY);

        if (Count > NumOfColumns - CursorX) {
                Count = NumOfColumns - CursorX;
        }

        b = &CodeLineW[CursorX];
        if (IsBuffPadding(b)) {
                // �S�p���E���A�S�p���X�y�[�X���u��������
                BuffSetChar(b - 1, ' ', 'H');
                BuffSetChar(b, ' ', 'H');
                sx--;
                extr++;
        }
        if (IsBuffFullWidth(b)) {
                // �S�p�������A�S�p���X�y�[�X���u��������
                BuffSetChar(b, ' ', 'H');
                BuffSetChar(b + 1, ' ', 'H');
                if (Count == 1) {
                        extr++;
                }
        }
        if (Count > 1) {
                // �I�[���`�F�b�N
                if (IsBuffPadding(b + Count)) {
                        // �S�p���E���A�S�p���X�y�[�X���u��������
                        BuffSetChar(b + Count - 1, ' ', 'H');
                        BuffSetChar(b + Count, ' ', 'H');
                        extr++;
                }
        }

        memsetW(&(CodeLineW[CursorX]), 0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, Count);

        /* update window */
        DispEraseCharsInLine(sx, Count + extr);
}

void BuffFillWithE()
// Fill screen with 'E' characters
{
        LONG TmpPtr;
        int i;

        TmpPtr = GetLinePtr(PageStart);
        for (i = 0 ; i <= NumOfLines-1-StatusLine ; i++) {
                memsetW(&(CodeBuffW[TmpPtr]),'E', AttrDefaultFG, AttrDefaultBG, AttrDefault, AttrDefault, NumOfColumns);
                TmpPtr = NextLinePtr(TmpPtr);
        }
        BuffUpdateRect(WinOrgX,WinOrgY,WinOrgX+WinWidth-1,WinOrgY+WinHeight-1);
}

void BuffDrawLine(TCharAttr Attr, int Direction, int C)
{ // IO-8256 terminal
        LONG Ptr;
        int i, X, Y;

        if (C==0) {
                return;
        }
        Attr.Attr |= AttrSpecial;

        switch (Direction) {
                case 3:
                case 4:
                        if (Direction==3) {
                                if (CursorY==0) {
                                        return;
                                }
                                Y = CursorY-1;
                        }
                        else {
                                if (CursorY==NumOfLines-1-StatusLine) {
                                        return;
                                }
                                Y = CursorY+1;
                        }
                        if (CursorX+C > NumOfColumns) {
                                C = NumOfColumns-CursorX;
                        }
                        Ptr = GetLinePtr(PageStart+Y);
                        memsetW(&(CodeBuffW[Ptr+CursorX]),'q', Attr.Fore, Attr.Back, Attr.Attr, Attr.Attr2, C);
                        BuffUpdateRect(CursorX,Y,CursorX+C-1,Y);
                        break;
                case 5:
                case 6:
                        if (Direction==5) {
                                if (CursorX==0) {
                                        return;
                                }
                                X = CursorX - 1;
                        }
                        else {
                                if (CursorX==NumOfColumns-1) {
                                        X = CursorX-1;
                                }
                                else {
                                        X = CursorX+1;
                                }
                        }
                        Ptr = GetLinePtr(PageStart+CursorY);
                        if (CursorY+C > NumOfLines-StatusLine) {
                                C = NumOfLines-StatusLine-CursorY;
                        }
                        for (i=1; i<=C; i++) {
                                BuffSetChar4(&CodeBuffW[Ptr+X], 'x', Attr.Fore, Attr.Back, Attr.Attr, Attr.Attr2, 'H');
                                Ptr = NextLinePtr(Ptr);
                        }
                        BuffUpdateRect(X,CursorY,X,CursorY+C-1);
                        break;
        }
}

void BuffEraseBox(int XStart, int YStart, int XEnd, int YEnd)
{
        int C, i;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd) {
                return;
        }
        if (YStart>YEnd) {
                return;
        }
        C = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);
        for (i=YStart; i<=YEnd; i++) {
                if ((XStart>0) &&
                    ((CodeBuffW[Ptr+XStart-1].attr & AttrKanji) != 0)) {
                        BuffSetChar4(&CodeBuffW[Ptr+XStart-1], 0x20, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, 'H');
                }
                if ((XStart+C<NumOfColumns) &&
                    ((CodeBuffW[Ptr+XStart+C-1].attr & AttrKanji) != 0)) {
                        BuffSetChar4(&CodeBuffW[Ptr+XStart+C], 0x20, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, 'H');
                }
                memsetW(&(CodeBuffW[Ptr+XStart]),0x20, CurCharAttr.Fore, CurCharAttr.Back, AttrDefault, CurCharAttr.Attr2 & Attr2ColorMask, C);
                Ptr = NextLinePtr(Ptr);
        }
        BuffUpdateRect(XStart,YStart,XEnd,YEnd);
}

void BuffFillBox(char ch, int XStart, int YStart, int XEnd, int YEnd)
{
        int Cols, i;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd) {
                return;
        }
        if (YStart>YEnd) {
                return;
        }
        Cols = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);
        for (i=YStart; i<=YEnd; i++) {
                if ((XStart>0) &&
                    ((CodeBuffW[Ptr+XStart-1].attr & AttrKanji) != 0)) {
                        BuffSetChar(&CodeBuffW[Ptr + XStart - 1], 0x20, 'H');
                        CodeBuffW[Ptr+XStart-1].attr ^= AttrKanji;
                }
                if ((XStart+Cols<NumOfColumns) &&
                    ((CodeBuffW[Ptr+XStart+Cols-1].attr & AttrKanji) != 0)) {
                        BuffSetChar(&CodeBuffW[Ptr + XStart + Cols], 0x20, 'H');
                }
                memsetW(&(CodeBuffW[Ptr+XStart]), ch, CurCharAttr.Fore, CurCharAttr.Back, CurCharAttr.Attr, CurCharAttr.Attr2, Cols);
                Ptr = NextLinePtr(Ptr);
        }
        BuffUpdateRect(XStart, YStart, XEnd, YEnd);
}

//
// TODO: 1 origin �������������� 0 origin ������
//
void BuffCopyBox(
        int SrcXStart, int SrcYStart, int SrcXEnd, int SrcYEnd, int SrcPage,
        int DstX, int DstY, int DstPage)
{
        int i, C, L;
        LONG SPtr, DPtr;

        SrcXStart--;
        SrcYStart--;
        SrcXEnd--;
        SrcYEnd--;
        SrcPage--;
        DstX--;
        DstY--;
        DstPage--;

        if (SrcXEnd > NumOfColumns - 1) {
                SrcXEnd = NumOfColumns-1;
        }
        if (SrcYEnd > NumOfLines-1-StatusLine) {
                SrcYEnd = NumOfColumns-1;
        }
        if (SrcXStart > SrcXEnd ||
            SrcYStart > SrcYEnd ||
            DstX > NumOfColumns-1 ||
            DstY > NumOfLines-1-StatusLine) {
                return;
        }

        C = SrcXEnd - SrcXStart + 1;
        if (DstX + C > NumOfColumns) {
                C = NumOfColumns - DstX;
        }
        L = SrcYEnd - SrcYStart + 1;
        if (DstY + C > NumOfColumns) {
                C = NumOfColumns - DstX;
        }

        if (SrcXStart > DstX) {
                SPtr = GetLinePtr(PageStart+SrcYStart);
                DPtr = GetLinePtr(PageStart+DstY);
                for (i=0; i<L; i++) {
                        memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
                        SPtr = NextLinePtr(SPtr);
                        DPtr = NextLinePtr(DPtr);
                }
        }
        else if (SrcXStart < DstX) {
                SPtr = GetLinePtr(PageStart+SrcYEnd);
                DPtr = GetLinePtr(PageStart+DstY+L-1);
                for (i=L; i>0; i--) {
                        memcpyW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
                        SPtr = PrevLinePtr(SPtr);
                        DPtr = PrevLinePtr(DPtr);
                }
        }
        else if (SrcYStart != DstY) {
                SPtr = GetLinePtr(PageStart+SrcYStart);
                DPtr = GetLinePtr(PageStart+DstY);
                for (i=0; i<L; i++) {
                        memmoveW(&(CodeBuffW[DPtr+DstX]), &(CodeBuffW[SPtr+SrcXStart]), C);
                        SPtr = NextLinePtr(SPtr);
                        DPtr = NextLinePtr(DPtr);
                }
        }
        BuffUpdateRect(DstX,DstY,DstX+C-1,DstY+L-1);
}

void BuffChangeAttrBox(int XStart, int YStart, int XEnd, int YEnd, PCharAttr attr, PCharAttr mask)
{
        int C, i, j;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd || YStart>YEnd) {
                return;
        }
        C = XEnd-XStart+1;
        Ptr = GetLinePtr(PageStart+YStart);

        if (mask) { // DECCARA
                for (i=YStart; i<=YEnd; i++) {
                        j = Ptr+XStart-1;
                        if (XStart>0 && (CodeBuffW[j].attr & AttrKanji)) {
                                CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
                                CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[j].bg = attr->Back; }
                        }
                        while (++j < Ptr+XStart+C) {
                                CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
                                CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[j].bg = attr->Back; }
                        }
                        if (XStart+C<NumOfColumns && (CodeBuffW[j-1].attr & AttrKanji)) {
                                CodeBuffW[j].attr = (CodeBuffW[j].attr & ~mask->Attr) | attr->Attr;
                                CodeBuffW[j].attr2 = (CodeBuffW[j].attr2 & ~mask->Attr2) | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[j].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[j].bg = attr->Back; }
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        else { // DECRARA
                for (i=YStart; i<=YEnd; i++) {
                        j = Ptr+XStart-1;
                        if (XStart>0 && (CodeBuffW[j].attr & AttrKanji)) {
                                CodeBuffW[j].attr ^= attr->Attr;
                        }
                        while (++j < Ptr+XStart+C) {
                                CodeBuffW[j].attr ^= attr->Attr;
                        }
                        if (XStart+C<NumOfColumns && (CodeBuffW[j-1].attr & AttrKanji)) {
                                CodeBuffW[j].attr ^= attr->Attr;
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        BuffUpdateRect(XStart, YStart, XEnd, YEnd);
}

void BuffChangeAttrStream(int XStart, int YStart, int XEnd, int YEnd, PCharAttr attr, PCharAttr mask)
{
        int i, j, endp;
        LONG Ptr;

        if (XEnd>NumOfColumns-1) {
                XEnd = NumOfColumns-1;
        }
        if (YEnd>NumOfLines-1-StatusLine) {
                YEnd = NumOfLines-1-StatusLine;
        }
        if (XStart>XEnd || YStart>YEnd) {
                return;
        }

        Ptr = GetLinePtr(PageStart+YStart);

        if (mask) { // DECCARA
                if (YStart == YEnd) {
                        i = Ptr + XStart - 1;
                        endp = Ptr + XEnd + 1;

                        if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }
                        while (++i < endp) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }
                        if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }
                }
                else {
                        i = Ptr + XStart - 1;
                        endp = Ptr + NumOfColumns;

                        if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }
                        while (++i < endp) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }

                        for (j=0; j < YEnd-YStart-1; j++) {
                                Ptr = NextLinePtr(Ptr);
                                i = Ptr;
                                endp = Ptr + NumOfColumns;

                                while (i < endp) {
                                        CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                        CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                        if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                        if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                                        i++;
                                }
                        }

                        Ptr = NextLinePtr(Ptr);
                        i = Ptr;
                        endp = Ptr + XEnd + 1;

                        while (i < endp) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                                i++;
                        }
                        if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
                                CodeBuffW[i].attr = CodeBuffW[i].attr & ~mask->Attr | attr->Attr;
                                CodeBuffW[i].attr2 = CodeBuffW[i].attr2 & ~mask->Attr2 | attr->Attr2;
                                if (mask->Attr2 & Attr2Fore) { CodeBuffW[i].fg = attr->Fore; }
                                if (mask->Attr2 & Attr2Back) { CodeBuffW[i].bg = attr->Back; }
                        }
                }
        }
        else { // DECRARA
                if (YStart == YEnd) {
                        i = Ptr + XStart - 1;
                        endp = Ptr + XEnd + 1;

                        if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }
                        while (++i < endp) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }
                        if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }
                }
                else {
                        i = Ptr + XStart - 1;
                        endp = Ptr + NumOfColumns;

                        if (XStart > 0 && (CodeBuffW[i].attr & AttrKanji)) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }
                        while (++i < endp) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }

                        for (j=0; j < YEnd-YStart-1; j++) {
                                Ptr = NextLinePtr(Ptr);
                                i = Ptr;
                                endp = Ptr + NumOfColumns;

                                while (i < endp) {
                                        CodeBuffW[i].attr ^= attr->Attr;
                                        i++;
                                }
                        }

                        Ptr = NextLinePtr(Ptr);
                        i = Ptr;
                        endp = Ptr + XEnd + 1;

                        while (i < endp) {
                                CodeBuffW[i].attr ^= attr->Attr;
                                i++;
                        }
                        if (XEnd < NumOfColumns-1 && (CodeBuffW[i-1].attr & AttrKanji)) {
                                CodeBuffW[i].attr ^= attr->Attr;
                        }
                        Ptr = NextLinePtr(Ptr);
                }
        }
        BuffUpdateRect(0, YStart, NumOfColumns-1, YEnd);
}

static int LeftHalfOfDBCS(LONG Line, int CharPtr)
// If CharPtr is on the right half of a DBCS character,
// return pointer to the left half
//   Line: points to a line in CodeBuff
//   CharPtr: points to a char
//   return: points to the left half of the DBCS
{
        if ((CharPtr>0) &&
                ((CodeBuffW[Line+CharPtr-1].attr & AttrKanji) != 0)) {
                CharPtr--;
        }
        return CharPtr;
}

static int MoveCharPtr(LONG Line, int *x, int dx)
// move character pointer x by dx character unit
//   in the line specified by Line
//   Line: points to a line in CodeBuff
//   x: points to a character in the line
//   dx: moving distance in character unit (-: left, +: right)
//      One DBCS character is counted as one character.
//      The pointer stops at the beginning or the end of line.
// Output
//   x: new pointer. x points to a SBCS character or
//      the left half of a DBCS character.
//   return: actual moving distance in character unit
{
        int i;

        *x = LeftHalfOfDBCS(Line,*x);
        i = 0;
        while (dx!=0) {
                if (dx>0) { // move right
                        if ((CodeBuffW[Line+*x].attr & AttrKanji) != 0) {
                                if (*x<NumOfColumns-2) {
                                        i++;
                                        *x = *x + 2;
                                }
                        }
                        else if (*x<NumOfColumns-1) {
                                i++;
                                (*x)++;
                        }
                        dx--;
                }
                else { // move left
                        if (*x>0) {
                                i--;
                                (*x)--;
                        }
                        *x = LeftHalfOfDBCS(Line,*x);
                        dx++;
                }
        }
        return i;
}

/**
 *      (�N���b�v�{�[�h�p��)������������
 *      @param[in]      sx,sy,ex,ey     �I������
 *      @param[in]      box_select      TRUE=���^(���`)�I��
 *                                                      FALSE=�s�I��
 *      @param[out] _str_len    ��������(�����[L'\0'������)
 *                              NULL����������������
 *      @return         ������
 *                              �g�p���� free() ��������
 */
static wchar_t *BuffGetStringForCB(int sx, int sy, int ex, int ey, BOOL box_select, size_t *_str_len)
{
        wchar_t *str_w;
        size_t str_size;        // �m�������T�C�Y
        size_t k;
        LONG TmpPtr;
        int IStart, IEnd;
        int x, y;
        BOOL LineContinued;

        str_size = NumOfColumns * (ey - sy + 1);
        str_w = malloc(sizeof(wchar_t) * str_size);

        LockBuffer();

        str_w[0] = 0;
        TmpPtr = GetLinePtr(sy);
        k = 0;
        for (y = sy; y<=ey ; y++) {
                if (box_select) {
                        IStart = SelectStart.x;
                        IEnd = SelectEnd.x-1;
                }
                else {
                        IStart = 0;
                        IEnd = NumOfColumns-1;
                        if (y== sy) {
                                IStart = sx;
                        }
                        if (y== ey) {
                                IEnd = ex -1;
                        }
                }

                // �����s����������?
                LineContinued = FALSE;
                if (!box_select) {
                        // �s�I������������
                        if (ts.EnableContinuedLineCopy && y!= ey ) {
                                LONG NextTmpPtr = NextLinePtr(TmpPtr);
                                if ((CodeBuffW[NextTmpPtr].attr & AttrLineContinued) != 0) {
                                        LineContinued = TRUE;
                                }
                        }
                }

                if (!LineContinued) {
                        while ((IEnd>0)) {
                                // �R�s�[�s�v��������
                                const buff_char_t *b = &CodeBuffW[TmpPtr + IEnd];
                                if (b->u32 == 0x20) {
                                        MoveCharPtr(TmpPtr,&IEnd,-1);   // �����l����
                                }
                                else {
                                        break;
                                }
                        }
                }

                x = IStart;
                while (x <= IEnd) {
                        const buff_char_t *b = &CodeBuffW[TmpPtr + x];
                        if (b->u32 != 0) {
                                str_w[k++] = b->wc2[0];
                                if (b->wc2[1] != 0) {
                                        str_w[k++] = b->wc2[1];
                                }
                                if (k + 2 >= str_size) {
                                        str_size *= 2;
                                        str_w = realloc(str_w, sizeof(wchar_t) * str_size);
                                }
                                {
                                        int i;
                                        // �R���r�l�[�V����
                                        if (k + b->CombinationCharCount16 >= str_size) {
                                                str_size += + b->CombinationCharCount16;
                                                str_w = realloc(str_w, sizeof(wchar_t) * str_size);
                                        }
                                        for (i = 0 ; i < (int)b->CombinationCharCount16; i++) {
                                                str_w[k++] = b->pCombinationChars16[i];
                                        }
                                }
                        }
                        x++;
                }

                if (y < ey) {
                        // ���s��������(�������s���O������)
                        if (!LineContinued) {
                                str_w[k++] = 0x0d;
                                str_w[k++] = 0x0a;
                        }
                }

                TmpPtr = NextLinePtr(TmpPtr);
        }
        str_w[k++] = 0;

        UnlockBuffer();

        if (_str_len != NULL) {
                *_str_len = k;
        }
        return str_w;
}

/**
 *      1�Z������wchar_t���������W�J����
 *      @param[in]              b                       1�Z�������������������|�C���^
 *      @param[in,out]  buf                     �������W�J�� NULL���������W�J��������
 *      @param[in]              buf_size        buf��������(buff == NULL���������Q����������)
 *      @param[out]             too_small       NULL ��������������������
 *                                                              TRUE    �o�b�t�@�T�C�Y�s��
 *                                                                              �����l���K�v��������������
 *                                                              FALSE   �������W�J������
 *      @retrun                 ������          �o��������
 *                                                              0�������A�����o������
 *
 *      TODO
 *              GetWCS() ������?
 */
static size_t expand_wchar(const buff_char_t *b, wchar_t *buf, size_t buf_size, BOOL *too_samll)
{
        size_t len;

        if (IsBuffPadding(b)) {
                if (too_samll != NULL) {
                        *too_samll = FALSE;
                }
                return 0;
        }

        // ����������
        len = 0;
        if (b->wc2[1] == 0) {
                // �T���Q�[�g�y�A��������
                len++;
        } else {
                // �T���Q�[�g�y�A
                len += 2;
        }
        // �R���r�l�[�V����
        len += b->CombinationCharCount16;

        if (buf == NULL) {
                // ��������������
                return len;
        }

        // �o�b�t�@��������?
        if (len > buf_size) {
                // �o�b�t�@������������
                if (too_samll != NULL) {
                        *too_samll = TRUE;
                }
                return 0;
        }
        if (too_samll != NULL) {
                *too_samll = FALSE;
        }

        // �W�J��������
        *buf++ = b->wc2[0];
        if (b->wc2[1] != 0) {
                *buf++ = b->wc2[1];
        }
        if (b->CombinationCharCount16 != 0) {
                memcpy(buf, b->pCombinationChars16, b->CombinationCharCount16 * sizeof(wchar_t));
        }

        return len;
}

/**
 *      (x,y) ��1������ str��������������
 *              *�� 1������������wchar_t�����\������������
 *
 *      @param          b
 *      @param          str             ���r������(wchar_t)
 *      @param          len             ���r��������
 *      @retval         �}�b�`������������
 *                              0=�}�b�`����������
 */
static size_t MatchOneStringPtr(const buff_char_t *b, const wchar_t *str, size_t len)
{
        int match_pos = 0;
        if (len == 0) {
                return 0;
        }
        if (b->wc2[1] == 0) {
                // �T���Q�[�g�y�A��������
                if (str[match_pos] != b->wc2[0]) {
                        return 0;
                }
                match_pos++;
                len--;
        } else {
                // �T���Q�[�g�y�A
                if (len < 2) {
                        return 0;
                }
                if (str[match_pos+0] != b->wc2[0] ||
                        str[match_pos+1] != b->wc2[1]) {
                        return 0;
                }
                match_pos+=2;
                len-=2;
        }
        if (b->CombinationCharCount16 > 0) {
                // �R���r�l�[�V����
                int i;
                if (len < b->CombinationCharCount16) {
                        return 0;
                }
                for (i = 0 ; i < (int)b->CombinationCharCount16; i++) {
                        if (str[match_pos++] != b->pCombinationChars16[i]) {
                                return 0;
                        }
                }
                len -= b->CombinationCharCount16;
        }
        return match_pos;
}

/**
 *      (x,y) ��1������ str��������������
 *              *�� 1������������wchar_t�����\������������
 *
 *      @param          y               PageStart + CursorY
 *      @param          str             1����(wchar_t��)
 *      @param          len             ��������
 *      @retval         0=�}�b�`����������
 *                              �}�b�`������������
 */
static size_t MatchOneString(int x, int y, const wchar_t *str, size_t len)
{
        int TmpPtr = GetLinePtr(y);
        const buff_char_t *b = &CodeBuffW[TmpPtr + x];
        return MatchOneStringPtr(b, str, len);
}

/**
 *      b ���� str��������������
 *
 *      @param          b               �o�b�t�@�����|�C���^�A����������������
 *      @param          LineCntinued    TRUE=�s���p�����l������
 *      @retval         TRUE    �}�b�`����
 *      @retval         FALSE   �}�b�`����������
 */
static BOOL MatchStringPtr(const buff_char_t *b, const wchar_t *str, BOOL LineContinued)
{
        int x;
        int y;
        BOOL result;
        size_t len = wcslen(str);
        if (len == 0) {
                return FALSE;
        }
        GetPosFromPtr(b, &x, &y);
        for(;;) {
                size_t match_len;
                if (IsBuffPadding(b)) {
                        b++;
                        continue;
                }
                // 1����������������
                match_len = MatchOneString(x, y, str, len);
                if (match_len == 0) {
                        result = FALSE;
                        break;
                }
                len -= match_len;
                if (len == 0) {
                        // �S���������I������
                        result = TRUE;
                        break;
                }
                str += match_len;

                // ��������
                x++;
                if (x == NumOfColumns) {
                        if (LineContinued && ((b->attr & AttrLineContinued) != 0)) {
                                // �����s��
                                y++;
                                if (y == NumOfLines) {
                                        // �o�b�t�@���I�[
                                        return 0;
                                }
                                x = 0;
                                b = &CodeBuffW[GetLinePtr(y)];
                        } else {
                                // �s��
                                result = FALSE;
                                break;
                        }
                }
        }

        return result;
}

/**
 *      (x,y)���� str��������������
 *
 *      @param          x               �}�C�i�X�����A�����s������������
 *      @param          y               PageStart + CursorY
 *      @param          LineCntinued    TRUE=�s���p�����l������
 *      @retval         TRUE    �}�b�`����
 *      @retval         FALSE   �}�b�`����������
 */
static BOOL MatchString(int x, int y, const wchar_t *str, BOOL LineContinued)
{
        BOOL result;
        int TmpPtr = GetLinePtr(y);
        size_t len = wcslen(str);
        if (len == 0) {
                return FALSE;
        }
        while(x < 0) {
                if (LineContinued && (CodeBuffW[TmpPtr+0].attr & AttrLineContinued) == 0) {
                        // �s���p�������������l�� & �p������������
                        x = 0;  // �s������������
                        break;
                }
                TmpPtr = PrevLinePtr(TmpPtr);
                x += NumOfColumns;
                y--;
        }
        while(x > NumOfColumns) {
                if (LineContinued && (CodeBuffW[TmpPtr+NumOfColumns-1].attr & AttrLineContinued) == 0) {
                        // �s���p�������������l�� & �p������������
                        x = 0;  // �s������������
                        break;
                }
                TmpPtr = NextLinePtr(TmpPtr);
                x -= NumOfColumns;
        }

        for(;;) {
                // 1����������������
                size_t match_len = MatchOneString(x, y, str, len);
                if (match_len == 0) {
                        result = FALSE;
                        break;
                }
                len -= match_len;
                if (len == 0) {
                        // �S���������I������
                        result = TRUE;
                        break;
                }
                str += match_len;

                // ��������
                x++;
                if (x == NumOfColumns) {
                        if (LineContinued && (CodeBuffW[TmpPtr+NumOfColumns-1].attr & AttrLineContinued) != 0) {
                                // �����s��
                                x = 0;
                                TmpPtr = NextLinePtr(TmpPtr);
                                y++;
                        } else {
                                // �s��
                                result = FALSE;
                                break;
                        }
                }
        }

        return result;
}

/**
 *      (sx,sy)����(ex,ey)������ str ���}�b�`�����������T����
 *      ���u������
 *
 *      @param          sy,ex   PageStart + CursorY
 *      @param[out]     x               �}�b�`�������u
 *      @param[out]     y               �}�b�`�������u
 *      @retval         TRUE    �}�b�`����
 */
static BOOL BuffGetMatchPosFromString(
        int sx, int sy, int ex, int ey, const wchar_t *str,
        int *match_x, int *match_y)
{
        int IStart, IEnd;
        int x, y;

        for (y = sy; y<=ey ; y++) {
                IStart = 0;
                IEnd = NumOfColumns-1;
                if (y== sy) {
                        IStart = sx;
                }
                if (y== ey) {
                        IEnd = ex;
                }

                x = IStart;
                while (x <= IEnd) {
                        if (MatchString(x, y, str, TRUE)) {
                                // �}�b�`����
                                if (match_x != NULL) {
                                        *match_x = x;
                                }
                                if (match_y != NULL) {
                                        *match_y = y;
                                }
                                return TRUE;
                        }
                        x++;
                }
        }
        return FALSE;
}


/**
 *      �A�������X�y�[�X���^�u1�����u������
 *      @param[out] _str_len    ��������(L'\0'������)
 *      @return         ������
 *                              �g�p���� free() ��������
 */
static wchar_t *ConvertTable(const wchar_t *src, size_t src_len, size_t *str_len)
{
        wchar_t *dest_top = malloc(sizeof(wchar_t) * src_len);
        wchar_t *dest = dest_top;
        BOOL WhiteSpace = FALSE;
        while (*src != '\0') {
                wchar_t c = *src++;
                if (c == 0x0d || c == 0x0a) {
                        *dest++ = c;
                        WhiteSpace = FALSE;
                } else if (c <= L' ') {
                        if (!WhiteSpace) {
                                // insert tab
                                *dest++ = 0x09;
                                WhiteSpace = TRUE;
                        }
                } else {
                        *dest++ = c;
                        WhiteSpace = FALSE;
                }
        }
        *dest = L'\0';
        *str_len = dest - dest_top + 1;
        return dest_top;
}


/**
 *      �N���b�v�{�[�h�p����������
 *      @return         ������
 *                              �g�p���� free() ��������
 */
wchar_t *BuffCBCopyUnicode(BOOL Table)
{
        wchar_t *str_ptr;
        size_t str_len;
        str_ptr = BuffGetStringForCB(
                SelectStart.x, SelectStart.y,
                SelectEnd.x, SelectEnd.y, BoxSelect,
                &str_len);

        // �e�[�u���`��������
        if (Table) {
                size_t table_len;
                wchar_t *table_ptr = ConvertTable(str_ptr, str_len, &table_len);
                free(str_ptr);
                str_ptr = table_ptr;
                str_len = table_len;
        }
        return str_ptr;
}

void BuffPrint(BOOL ScrollRegion)
// Print screen or selected text
{
        int Id;
        POINT PrintStart, PrintEnd;
        TCharAttr CurAttr, TempAttr;
        int i, j, count;
        int IStart, IEnd;
        LONG TmpPtr;

        TempAttr = DefCharAttr;

        if (ScrollRegion) {
                Id = VTPrintInit(IdPrnScrollRegion);
        }
        else if (Selected) {
                Id = VTPrintInit(IdPrnScreen | IdPrnSelectedText);
        }
        else {
                Id = VTPrintInit(IdPrnScreen);
        }
        if (Id==IdPrnCancel) {
                return;
        }

        /* set print region */
        if (Id==IdPrnSelectedText) {
                /* print selected region */
                PrintStart = SelectStart;
                PrintEnd = SelectEnd;
        }
        else if (Id==IdPrnScrollRegion) {
                /* print scroll region */
                PrintStart.x = 0;
                PrintStart.y = PageStart + CursorTop;
                PrintEnd.x = NumOfColumns;
                PrintEnd.y = PageStart + CursorBottom;
        }
        else {
                /* print current screen */
                PrintStart.x = 0;
                PrintStart.y = PageStart;
                PrintEnd.x = NumOfColumns;
                PrintEnd.y = PageStart + NumOfLines - 1;
        }
        if (PrintEnd.y > BuffEnd-1) {
                PrintEnd.y = BuffEnd-1;
        }

        LockBuffer();

        TmpPtr = GetLinePtr(PrintStart.y);
        for (j = PrintStart.y ; j <= PrintEnd.y ; j++) {
                if (j==PrintStart.y) {
                        IStart = PrintStart.x;
                }
                else {
                        IStart = 0;
                }
                if (j == PrintEnd.y) {
                        IEnd = PrintEnd.x - 1;
                }
                else {
                        IEnd = NumOfColumns - 1;
                }

                while ((IEnd>=IStart) &&
                       (CodeBuffW[TmpPtr+IEnd].u32 == 0x20) &&
                       (CodeBuffW[TmpPtr+IEnd].attr==AttrDefault) &&
                       (CodeBuffW[TmpPtr+IEnd].attr2==AttrDefault)) {
                        IEnd--;
                }

                i = IStart;
                while (i <= IEnd) {
                        CurAttr.Attr = CodeBuffW[TmpPtr+i].attr & ~ AttrKanji;
                        CurAttr.Attr2 = CodeBuffW[TmpPtr+i].attr2;
                        CurAttr.Fore = CodeBuffW[TmpPtr+i].fg;
                        CurAttr.Back = CodeBuffW[TmpPtr+i].bg;

                        count = 1;
                        while ((i+count <= IEnd) &&
                               (CurAttr.Attr == (CodeBuffW[TmpPtr+i+count].attr & ~ AttrKanji)) &&
                               (CurAttr.Attr2 == CodeBuffW[TmpPtr+i+count].attr2) &&
                                   (CurAttr.Fore == CodeBuffW[TmpPtr+i].fg) &&
                                   (CurAttr.Back == CodeBuffW[TmpPtr+i].bg) ||
                               (i+count<NumOfColumns) &&
                               ((CodeBuffW[TmpPtr+i+count-1].attr & AttrKanji) != 0)) {
                                count++;
                        }

                        if (TCharAttrCmp(CurAttr, TempAttr) != 0) {
                                PrnSetAttr(CurAttr);
                                TempAttr = CurAttr;
                        }

                        // TODO ���������� ANSI ������
                        {
                                char bufA[TermWidthMax+1];
                                int k;
                                char *p = bufA;
                                const buff_char_t *b = &CodeBuffW[TmpPtr + i];

                                for (k = 0; k < count; b++,k++) {
                                        unsigned short c;
                                        if (IsBuffPadding(b)) {
                                                continue;
                                        }
                                        c = b->ansi_char;
                                        *p++ = (c & 0xff);
                                        if (c >= 0x100) {
                                                *p++ = ((c >> 8) & 0xff);
                                        }
                                }
                                PrnOutText(bufA, count);
                                i = i+count;
                        }
                }
                PrnNewLine();
                TmpPtr = NextLinePtr(TmpPtr);
        }

        UnlockBuffer();
        VTPrintEnd();
}

// TODO ���������� ANSI ������
// Dumps current line to the file (for path through printing)
//   HFile: file handle
//   TERM: terminator character
//      = LF or VT or FF
void BuffDumpCurrentLine(BYTE TERM)
{
        int i, j;
        buff_char_t *b = &CodeBuffW[LinePtr];
        char bufA[TermWidthMax+1];
        char *p = bufA;

        i = NumOfColumns;
        while ((i>0) && (b[i-1].ansi_char == 0x20)) {
                i--;
        }
        p = bufA;
        for (j=0; j<i; j++) {
                unsigned short c = b[j].ansi_char;
                *p++ = (c & 0xff);
                if (c > 0x100) {
                        *p++ = (c & 0xff);
                }
        }
        p = bufA;
        for (j=0; j<i; j++) {
                WriteToPrnFile(bufA[j],FALSE);
        }
        WriteToPrnFile(0,TRUE);
        if ((TERM>=LF) && (TERM<=FF)) {
                WriteToPrnFile(0x0d,FALSE);
                WriteToPrnFile(TERM,TRUE);
        }
}

static BOOL isURLchar(unsigned int u32)
{
        // RFC3986(Uniform Resource Identifier (URI): Generic Syntax)����������
        // by sakura editor 1.5.2.1: etc_uty.cpp
        static const char       url_char[] = {
          /* +0  +1  +2  +3  +4  +5  +6  +7  +8  +9  +A  +B  +C  +D  +E  +F */
              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    /* +00: */
              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    /* +10: */
              0, -1,  0, -1, -1, -1, -1,  0,  0,  0,  0, -1, -1, -1, -1, -1,    /* +20: " !"#$%&'()*+,-./" */
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0, -1,  0, -1,    /* +30: "0123456789:;<=>?" */
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,    /* +40: "@ABCDEFGHIJKLMNO" */
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0, -1,  0,  0, -1,    /* +50: "PQRSTUVWXYZ[\]^_" */
              0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,    /* +60: "`abcdefghijklmno" */
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0,  0,  0, -1,  0,    /* +70: "pqrstuvwxyz{|}~ " */
            /* 0    : not url char
             * -1   : url char
             * other: url head char --> url_table array number + 1
             */
        };

        if (u32 >= 0x80) {
                return FALSE;
        }
        return url_char[u32] == 0 ? FALSE : TRUE;
}

static BOOL BuffIsHalfWidthFromPropery(char width_property)
{
        switch (width_property) {
        case 'H':       // Halfwidth
        case 'n':       // Narrow
        case 'N':       // Neutral
        default:
                return TRUE;
        case 'A':       // Ambiguous �B��
                if (ts.Language == IdJapanese) {
                        // �S�p����������
                        return FALSE;
                }
                return TRUE;
        case 'W':
        case 'F':
                return FALSE;           // �S�p
        }
}

static BOOL BuffIsHalfWidthFromCode(TTTSet *ts_, unsigned int u32, char *width_property, char *emoji)
{
        *width_property = UnicodeGetWidthProperty(u32);
        *emoji = (char)UnicodeIsEmoji(u32);
        if (*emoji) {
                if (ts_->Language == IdJapanese) {
                        // �S�p
                        return FALSE;
                } else {
                        if (u32 >= 0x1f000) {
                                return FALSE;
                        }
                        return TRUE;
                }
        }
        return BuffIsHalfWidthFromPropery(*width_property);
}

/**
 *      �J�[�\�����u����URL�A�g���r���[�g�����������������v�Z����
 */
static int get_url_len(int cur_x, int cur_y)
{
        int sp = cur_x + cur_y * NumOfColumns;
        int cp;
        int dp;
        {
                int p = sp;
                p--;
                while (p > 0) {
                        int sy = p / NumOfColumns;