FreeWare Collection 2/FreeSoftwareCollection2pd199x-jp.img/dmycon/consim.asm

Assembly Source File | 1990-06-14 | 32KB | 2,229 lines

;/****************************************************
;
;    FM-TOWNS FM16/FMR50 Console Sim Program
;
;    89.9.16 make v1.00        by Ken
;    89.9.18 bug fix & speed up    by Ken
;    90.1.15 fully assembled    by YAMA
;    90.1.27 BIOS supported     by YAMA
;    90.1.31 optimized          by YAMA
;
;***************************************************/

.286c

    include    msdos.def

code    segment
    assume    cs:code,ds:code,es:code,ss:code

    org    5Ch
FCB1    label    byte
    org    6Ch
FCB2    label    byte
    org    80h
cmdl    label    byte

    org    100h
;
;
;
entry:        jmp    main
;
;
;

GVRAM    equ    0C000h
CVRAM    equ    0C800h
KVRAM    equ    0CA00h
ANKCG    equ    0CB00h

TRUE    equ    0FFh
FALSE    equ    0
;ERR     equ    (-1)

MAX_X    equ    80
MAX_Y    equ    24
MAX_Y2    equ    25

DMYKAN    equ    0FEh
CRCHR    equ    1Fh
TABCHR    equ    09h
TAB    equ    8
CONTRL    equ    FALSE
;
;

CUR_X    dw    0
CUR_Y    dw    0

CUR_C    db    TRUE    ;cursor :DSPLAY
CUR_T    db    10h    ;cursor type
CUR_OFF dw    14
CUR_SIZ dw    2
BAKXY    dw    0
B_COL    db    0

BAK_X    dw    0
BAK_Y    dw    0
COLOR    db    7
KANMOD    db    TRUE
BAKCH1    db    0
KANCOD    db    0
EXTFLG    db    FALSE
EXTPRO    dw    ?
ESCCNT    dw    0
ESCPRM    db    16 dup(0)
dmy_ram    dw    (MAX_X*MAX_Y2) dup(0700H)

;    UCHAR    ankfont[];

;*****************************
;*    割り込みワ－ク
;*****************************
vct_off    dw    ?
vct_seg    dw    ?
;*****************************
;*    タイマ割り込みテ－ブル
;*****************************
tim_no    db    ?
tim_md    db    00h
    db    00h
tim_off    dw    ?
tim_seg    dw    ?
    dw    0
    dw    7        ; 割り込み間隔 (1 = 10ms)
;*********************************************
;*    コンソ－ルBIOSベクタ(int 91h) &
;*    タイマ割り込みの設定
;*********************************************
setbios PROC NEAR
    push    ds
    push    es

    mov    ax,3591h        ; int 91h
    int    21h
    mov    ax,es
    mov    cs:[vct_seg],ax
    mov    cs:[vct_off],bx

    push    cs
    pop    ds
    mov    dx,offset bios_ent
    mov    ax,2591h        ; int 91h
    int    21h

    mov    ax,offset cflush
    mov    cs:[tim_off],ax
    mov    ax,cs
    mov    cs:[tim_seg],ax

    mov    di,offset tim_md
    push    cs
    pop    ds
    mov    ah,00h
    int    97h
    mov    cs:[tim_no],al

    pop    es
    pop    ds
    ret
setbios ENDP
;***************************************
;*    ベクタ及び割り込みの解除 & 終了
;***************************************
resetbios PROC NEAR
    push    ds
    push    es

    mov    ax,cs:[vct_seg]
    mov    ds,ax
    mov    dx,cs:[vct_off]
    mov    ax,2591h
    int    21h

    mov    al,cs:[tim_no]
    mov    ah,01h
    int    97h

    mov    ah,4ch
    mov    al,00h
    int    21h

    pop    es
    pop    ds
    ret
resetbios ENDP

;
; colset
;  ah:color(attr)
;  di:top address cx:char count
;

colset    proc    near

    mov    bx,CVRAM
    mov    es,bx
    sub    al,al
    rep    stosw

    ret
colset    endp

;
; vramcpy1 ( direction:increase )
;  [ds:si] source address  [es:di] dest address
;  cx:char count
;

vramcpy1 proc    near

v1_l1b: mov    ax,[si+2000h]
        mov    es:[di+2000h],ax
        movsw
    loop    short v1_l1b

    ret
vramcpy1 endp

;
; vramcpy2 ( direction:decrease )
;  si:source address  di:dest address
;  cx:char count
;

vramcpy2 proc    near

    std
    push    cx
    dec    cx
    shl    cx,1
    add    si,cx
    add    di,cx
    pop    cx

v1_l1c: mov    ax,[si+2000h]
        mov    es:[di+2000h],ax
        movsw
    loop    short v1_l1c

    cld
    ret
vramcpy2 endp

;
; Wrt_Ank
;   al:char ah:attr
;   cx:x    bx:y
;

Wrt_Ank proc    near
    push    ds
    push    si
    push    es
    push    di
    push    cx
    push    bx

    push    ax
    sub    ah,ah        ; char=>ANKCG address [si]
    shl    ax,4
    mov    si,ax
    mov    ax,80*16    ; x + y * 80*16(GVRAM address) [di]
    mul    bx
    add    ax,cx
    mov    di,ax
    pop    ax

    mov    bl,ah
    mov    cl,bl        ;cl
    and    bx,7

    test    cl,20h        ;cl
    je    $I147
    or    bl,8            ;at

$I147:
    test    cl,18h        ;cl
    je    $I148
    mov    bh,0FFh            ;bk
$I148:
    mov    ax,ANKCG
    mov    ds,ax
    mov    ax,GVRAM
    mov    es,ax
    mov    dx,0FF99h
    mov    al,01h
    out    dx,al

    mov    al,0Fh
    mov    dx,0FF81h
    out    dx,al

    mov    cx,16
    push    di
    sub    al,al
$F151:    mov    es:[di],al
    add    di,80
    loop    $F151
    pop    di

    mov    al,bl
    out    dx,al
    mov    cx,16
$F155:    lodsb
    xor    al,bh
    mov    es:[di],al
    add    di,80
    loop    $F155

    mov    dx,0FF99h
    xor    al,al
    out    dx,al

    pop    bx
    pop    cx
    pop    di
    pop    es
    pop    si
    pop    ds
    ret
Wrt_Ank    ENDP

;
; Wrt_Kan
;   dx:漢字コード ah:attr
;   cx:x          bx:y
;

Wrt_Kan PROC NEAR
    push    es
    push    di
    push    cx
    push    bx

    push    ax
    push    dx
    mov    ax,80*16    ; x + y * 80*16(GVRAM address) [di]
    mul    bx
    add    ax,cx
    mov    di,ax
    pop    dx
    pop    ax

    mov    cl,ah
    mov    ax,dx
    mov    dx,0FF94h
    out    dx,al
    inc    dx
    mov    al,ah
    out    dx,al

    mov    bl,cl    ;cl
    and    bx,7

    test    cl,20h    ;cl
    je    $I247
    or    bl,8            ;at
$I247:
    test    cl,18h    ;cl
    je    $I248
    mov    bh,0FFh            ;bk
$I248:
    mov    al,0Fh
    mov    dx,0FF81h
    out    dx,al

    mov    ax,GVRAM
    mov    es,ax
    mov    cx,16
    push    di
    sub    ax,ax
$F251:    mov    es:[di],ax
    add    di,80
    loop    $F251
    pop    di

    mov    al,bl
    out    dx,al
    mov    cx,16
$F277:    mov    dx,0FF96h
    in    al,dx
    xor    al,bh
    mov    es:[di],al
    inc    dx
    in    al,dx
    xor    al,bh
    mov    es:[di+1],al

    add    di,80
    loop    $F277

    pop    bx
    pop    cx
    pop    di
    pop    es
    ret
Wrt_Kan ENDP

;
; locate
;

locate    proc    near

    mov    cx,cs:[CUR_X]
    mov    bx,cs:[CUR_Y]
    mov    ax,MAX_X
    mul    bx
    add    ax,cx
    shl    ax,1
    add    ax,offset dmy_ram
    mov    di,ax
    xor    byte ptr cs:[di+1],0FFh

    shl    bx,4        ; y *= 16
    add    bx,cs:[CUR_OFF]
    mov    ax,80
    mul    bx        ; y *= 80
    add    ax,cx        ; y + x
    mov    di,ax

    mov    ax,GVRAM
    mov    es,ax
    mov    dx,0FF81h
    mov    al,00000001b
    call    loca_sub
    mov    al,01000010b
    call    loca_sub
    mov    al,10000100b
    call    loca_sub
    mov    al,11001000b
    call    loca_sub
    ret

loca_sub:
    out    dx,al
    push    di
    mov    cx,cs:[CUR_SIZ]
loca1:    not    byte ptr es:[di]
    add    di,80
    loop    loca1
    pop    di
    ret
locate    ENDP
;
; sjisto
;  ax:shift jis 漢字コード
;<return> ax:jis 漢字コード
;

sjisto    proc    near
    cmp    ah,9fh
    jbe    sjto1
    sub    ah,0B1h-071h
sjto1:  sub    ah,071h
    shl    ah,1
    inc    ah
    cmp    al,7fh
    jbe    sjto2
    dec    al
sjto2:    cmp    al,9eh
    jb    sjto3
    sub    al,7dh
    inc    ah
    jmp    sjto4
sjto3:    sub    al,1fh
sjto4:    cmp    ah,70h
    jb    short sjito5
    cmp    ah,74h
    ja    short sjito5
    cmp    al,60h
    jb    short sjito5
    cmp    al,7Eh
    add    ax,0C70h
sjito5:    ret

sjisto    ENDP

;
; iskanji
;  al:shift jis (上位)
;<return> C flug=1:漢字コード
;

iskanji        proc    near
        cmp    al,81h
        jb     short ik1_ed
        cmp    al,0A0h
        jae    short ik1_sk1
        ret
ik1_sk1:    cmp    al,0E0h
        jb    short ik1_ed
        cmp    al,0FDh
        jae    short ik1_ed
        ret
ik1_ed:        clc
        ret
iskanji     endp

;
; iskanji2
;  al:shift jis (下位)
;<return> C flug=1:漢字コード
;

iskanji2    proc    near
        cmp    al,40h
        jb     short ik2_ed
        cmp    al,7Fh
        jae    short ik2_sk1
        ret
ik2_sk1:    cmp    al,80h
        jb    short ik2_ed
        cmp    al,0FDh
        jae    short ik2_ed
        ret
ik2_ed:        clc
        ret
iskanji2    endp

;
; SetPal
;  al:Pallte no.  ah:Color no.
;

SetPal        proc    near
        push    ax
        push    dx
        mov    dx,0FD90h
        out    dx,al
        inc    dx
        inc    dx
        mov    al,7Fh
        shr    ah,1
        jc    short pal_skp1
        xor    al,al
pal_skp1:    out    dx,al
        inc    dx
        inc    dx
        mov    al,7Fh
        shr    ah,1
        jc    short pal_skp2
        xor    al,al
pal_skp2:    out    dx,al
        inc    dx
        inc    dx
        mov    al,7Fh
        shr    ah,1
        jc    short pal_skp3
        xor    al,al
pal_skp3:    out    dx,al
        pop    dx
        pop    ax
        ret
SetPal        endp
;
;
;

scrool        proc    near
        push    cx
        push    bx
        mov    di,0
        mov    si,(MAX_X*2)
        mov    cx,MAX_X*(MAX_Y-1)
        push    ds
        mov    ax,CVRAM
        mov    ds,ax
        mov    es,ax
v1_l1h:        mov    ax,[si+2000h]
            mov    es:[di+2000h],ax
            movsw
        loop    short v1_l1h
        pop    ds
        mov    di,(MAX_X*2)*(MAX_Y-1)
        mov    ah,byte ptr[offset COLOR]
        mov    cx,MAX_X
        sub    al,al
            rep    stosw
        pop    bx
        pop    cx
        ret
scrool        endp
;
;
;

PutBS        proc    near
        mov    cx,word ptr[offset CUR_X]
        mov    bx,word ptr[offset CUR_Y]
        dec    cl
        jns    short pbs_end
        mov    cl,MAX_X-1
        dec    bl
        jns    short pbs_end
        xor    bl,bl
pbs_end:    mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
PutBS        endp
;
;
;

PutTAB        proc    near
        mov    ax,word ptr[offset CUR_X]
        add    ax,TAB
        mov    dl,TAB
        div    dl
        xor    ah,ah
        mul    dl
        sub    ax,word ptr[offset CUR_X]
        mov    cx,ax
        mov    ah,byte ptr[offset COLOR]
        mov    al,' '
ptb_lp1:    push    ax
        push    cx
        call    PutChr
        pop    cx
        pop    ax
        loop    short ptb_lp1
        ret
PutTAB        endp
;
;
;

PutLF        proc    near
        mov    bx,word ptr[offset CUR_Y]
        inc    bl
        cmp    bl,MAX_Y
        jb    short plf_sk1
        mov    bl,MAX_Y-1
        call    scrool
plf_sk1:    mov    word ptr[offset CUR_Y],bx
        ret
PutLF        endp
;
;
;

PutHOME        proc near
        mov    word ptr[offset CUR_X],0
        mov    word ptr[offset CUR_Y],0
        ret
PutHOME        endp
;
;
;

PutCLS        proc    near
        push    ax
        push    cx
        push    di

        mov    ah,byte ptr[offset COLOR]
        mov    di,0
        mov    cx,MAX_X * MAX_Y
        call    colset

        mov    word ptr[offset CUR_X],0
        mov    word ptr[offset CUR_Y],0

        pop    di
        pop    cx
        pop    ax
        ret
PutCLS        endp
;
;
;

PutCR        proc    near
        mov    word ptr[offset CUR_X],0
        ret
PutCR        endp
;
;
;

PutRit        proc    near
        mov    cx,word ptr[offset CUR_X]
        mov    bx,word ptr[offset CUR_Y]
        inc    cl
        cmp    cl,MAX_X
        jb    short pr_sk1
        xor    cl,cl
        inc    bl
        cmp    bl,MAX_Y
        jb    short pr_sk1
        xor    bl,bl
pr_sk1:        mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
PutRit        endp
;
;
;

PutLft        proc    near
        mov    cx,word ptr[offset CUR_X]
        mov    bx,word ptr[offset CUR_Y]
        dec    cl
        jns    short pl_sk1
        mov    cl,MAX_X-1
        dec    bl
        jns    short pl_sk1
        mov    bl,MAX_Y-1
pl_sk1:        mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
PutLft        endp
;
;
;

PutUp        proc    near
        mov    bx,word ptr[offset CUR_Y]
        dec    bl
        jns    short pu_sk1
        mov    bl,MAX_Y-1
pu_sk1:        mov    word ptr[offset CUR_Y],bx
        ret
PutUp        endp
;
;
;

PutDwn        proc    near
        mov    bx,word ptr[offset CUR_Y]
        inc    bl
        cmp    bl,MAX_Y
        jb    short pd_sk1
        xor    bl,bl
pd_sk1:        mov    word ptr[offset CUR_Y],bx
        ret
PutDwn        endp
;
;
;

SVidAt        proc    near
        and    al,3Fh
        mov    byte ptr[offset COLOR],al
        ret
SVidAt        endp
;
;
;

SetDC2_s    proc    near
        xor    ch,ch
        xor    bh,bh
        mov    cl,byte ptr[offset BAKCH1]
        mov    bl,al
        or    cl,cl
        jns    short dc2_sk1
        xor    cl,cl
dc2_sk1:    cmp    cl,MAX_X
        jb    short dc2_sk2
        mov    cl,MAX_X-1
dc2_sk2:    or    bl,bl
        jns    short dc2_sk3
        xor    bl,bl
dc2_sk3:    cmp    bl,MAX_Y
        jb    short dc2_sk4
        mov    bl,MAX_Y-1
dc2_sk4:    mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
SetDC2_s    endp
;

SetDC2        proc    near
        mov    byte ptr[offset BAKCH1],al
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SetDC2_s
        ret
SetDC2        endp
;
;
;

SetDC3_s    proc    near
        xor    cx,cx
        mov    cl,byte ptr[offset BAKCH1]
        mov    ah,byte ptr[offset COLOR]
        or    ah,80h
dc3_lp1:    push    ax
        push    cx
        call    PutChr
        pop    cx
        pop    ax
        dec    cx
        jne    short dc3_lp1
        ret
SetDC3_s    endp
;

SetDC3        proc    near
        mov    byte ptr[offset BAKCH1],al
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SetDC3_s
        ret
SetDC3        endp
;
;
;

EraLin        proc    near
        mov    ax,MAX_X
        mul    word ptr [offset CUR_Y]
        add    ax,word ptr[offset CUR_X]
        shl    ax,1
        mov    di,ax

        mov    ax,MAX_X
        sub    ax,word ptr[offset CUR_X]
        mov    cx,ax

        mov    ah,byte ptr[offset COLOR]
        call    colset
        ret
EraLin        endp
;
;
;

EraScr        proc    near
        mov    ax,MAX_X
        mul    word ptr [offset CUR_Y]
        add    ax,word ptr[offset CUR_X]
        mov    dx,ax
        shl    ax,1
        mov    di,ax

        mov    ax,MAX_X*MAX_Y
        sub    ax,dx
        mov    cx,ax

        mov    ah,byte ptr[offset COLOR]
        call    colset
        ret
EraScr        endp
;
;
;

InsLin        proc    near
        mov    word ptr[offset CUR_X],0
        mov    ax,MAX_X
        mul    word ptr[offset CUR_Y]
        mov    si,ax
        shl    si,1
        push    si

        add    ax,MAX_X
        mov    di,ax
        shl    di,1

        mov    cx,MAX_X*MAX_Y
        sub    cx,ax

        push    ds
        mov    ax,CVRAM
        mov    ds,ax
        mov    es,ax
        call    vramcpy2
        pop    ds

        pop    di
        mov    ah,byte ptr[offset COLOR]
        mov    cx,MAX_X
        call    colset
        ret
InsLin        endp
;
;
;

DelLin        proc    near
        mov    ax,MAX_X
        mul    word ptr[offset CUR_Y]
        mov    di,ax
        shl    di,1

        add    ax,MAX_X
        mov    si,ax
        shl    si,1

        mov    cx,MAX_X*MAX_Y
        sub    cx,ax

        push    ds
        mov    ax,CVRAM
        mov    ds,ax
        mov    es,ax
        call    vramcpy1
        pop    ds

        mov    di,2*MAX_X*(MAX_Y-1)
        mov    ah,byte ptr[offset COLOR]
        mov    cx,MAX_X
        call    colset
        ret
DelLin        endp
;
;
;

SCurPs_s    proc    near
        xor    ch,ch
        xor    bh,bh
        mov    cl,al
        mov    bl,byte ptr[offset BAKCH1]
        sub    cl,' '
        jns    short scp_sk1
        xor    cl,cl
scp_sk1:    cmp    cl,MAX_X
        jb    short scp_sk2
        mov    cl,MAX_X-1
scp_sk2:    sub    bl,' '
        jns    short scp_sk3
        xor    bl,bl
scp_sk3:    cmp    bl,MAX_Y
        jb    short scp_sk4
        mov    bl,MAX_Y-1
scp_sk4:    mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
SCurPs_s    endp
;

SCurPs        proc    near
        mov    byte ptr[offset BAKCH1],al
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SCurPs_s
        ret
SCurPs        endp
;
;
;

CurAtt_s    proc    near
        ret
CurAtt_s    endp
;

CurAtt        proc    near
        mov    byte ptr[offset BAKCH1],al
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset CurAtt_s
        ret
CurAtt        endp
;
;
;

AnsiH        proc    near
        xor    bh,bh
        xor    ch,ch
        mov    bl,byte ptr ESCPRM[0]
        mov    cl,byte ptr ESCPRM[1]
        dec    cl
        jns    short ah_sk1
        xor    cl,cl
ah_sk1:        cmp    cl,MAX_X
        jb    short ah_sk2
        mov    cl,MAX_X-1
ah_sk2:        dec    bl
        jns    short ah_sk3
        xor    bl,bl
ah_sk3:        cmp    bl,MAX_Y
        jb    short ah_sk4
        mov    bl,MAX_Y-1
ah_sk4:        mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
AnsiH        endp
;
;
;

AnsiA        proc    near
        mov    bx,word ptr[offset CUR_Y]
        sub    bl,byte ptr ESCPRM[0]
        jns    short aa_sk1
        xor    bl,bl
aa_sk1:        mov    word ptr[offset CUR_Y],bx
        ret
AnsiA        endp
;
;
;

AnsiB        proc    near
        mov    bx,word ptr[offset CUR_Y]
        add    bl,byte ptr ESCPRM[0]
        cmp    bl,MAX_Y
        jb    short ab_sk1
        mov    bl,MAX_Y
ab_sk1:        mov    word ptr[offset CUR_Y],bx
        ret
AnsiB        endp
;
;
;

AnsiC        proc    near
        mov    cx,word ptr[offset CUR_X]
        add    cl,byte ptr ESCPRM[0]
        cmp    cl,MAX_X
        jb    short ac_sk1
        mov    cl,MAX_X
ac_sk1:        mov    word ptr[offset CUR_X],cx
        ret
AnsiC        endp
;
;
;

AnsiD        proc    near
        mov    cx,word ptr[offset CUR_X]
        sub    cl,byte ptr ESCPRM[0]
        jns    short ad_sk1
        xor    cl,cl
ad_sk1:        mov    word ptr[offset CUR_X],cx
        ret
AnsiD        endp
;
;
;

Ansis        proc    near
        mov    cx,word ptr[offset CUR_X]
        mov    bx,word ptr[offset CUR_Y]
        mov    word ptr[offset BAK_X],cx
        mov    word ptr[offset BAK_Y],bx
        ret
Ansis        endp
;
;
;

Ansiu        proc    near
        mov    cx,word ptr[offset BAK_X]
        mov    bx,word ptr[offset BAK_Y]
        mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx
        ret
Ansiu        endp
;
;
;

AnsiJ        proc    near
        mov    al,byte ptr ESCPRM[0]
        cmp    al,0
        jne    short aj_skp1
        call    EraScr
        ret
aj_skp1:    cmp    al,1
        jne    short aj_skp2
        mov    di,0
        mov    ax,MAX_X
        mul    word ptr[offset CUR_Y]
        add    ax,word ptr[offset CUR_X]
        inc    ax
        mov    cx,ax
        mov    ah,byte ptr[offset COLOR]
        call    colset
        ret
aj_skp2:    cmp    al,2
        jne    short aj_skp3
        call    PutCLS
aj_skp3:    ret
AnsiJ        endp
;
;
;

AnsiK        proc    near
        mov    al,byte ptr ESCPRM[0]
        cmp    al,0
        jne    short ak_skp1
        call    EraLin
        ret
ak_skp1:    cmp    al,1
        jne    short ak_skp2
        mov    ax,MAX_X*2
        mul    word ptr [offset CUR_Y]
        mov    di,ax
        mov    cx,word ptr[offset CUR_X]
        mov    ah,byte ptr[offset COLOR]
        call    colset
        ret

ak_skp2:    cmp    al,2
        jne    short ak_skp3
        mov    ax,MAX_X*2
        mul    word ptr [offset CUR_Y]
        mov    di,ax
        mov    cx,MAX_X
        mov    ah,byte ptr[offset COLOR]
        call    colset
ak_skp3:    ret
AnsiK        endp
;
;
;

AnsiM_l        proc    near
aml_lp1:    call    DelLin
        dec    byte ptr ESCPRM[0]
        jns    short aml_lp1
        mov    word ptr[offset CUR_X],0
        ret
AnsiM_l        endp
;
;
;

AnsiL        proc    near
al_lp1:        call    InsLin
        dec    byte ptr ESCPRM[0]
        jns    short al_lp1
        mov    word ptr[offset CUR_X],0
        ret
AnsiL        endp
;
;
;

Ansim_s        proc    near
        mov    cl,[COLOR]
        xor    si,si
        xor    bh,bh
ams_lp1:    mov    bl,byte ptr ESCPRM[si]
        cmp    bl,0
        jne    short ams_skp1
        mov    cl,7
        jmp    short ams_lend

ams_skp1:    cmp    bl,8
        ja    short ams_skp2
        or    cl,byte ptr ansiatt[bx]
        jmp    short ams_lend

ams_skp2:    cmp    bl,30
        jb    short ams_skp3
        cmp    bl,37
        ja    short ams_skp3
        and    cl,0F8h
        or    cl,byte ptr ansicol[bx-30]
        jmp    short ams_lend

ams_skp3:    cmp    bl,40
        jb    short ams_lend
        cmp    bl,47
        ja    short ams_lend
        mov    al,00h
        mov    ah,byte ptr ansicol[bx-40]
        mov    byte ptr [offset B_COL],ah
        call    SetPal

ams_lend:    inc    si
        cmp    si,word ptr[offset ESCCNT]
        jbe    short ams_lp1

        mov    [COLOR],cl
        ret
Ansim_s        endp

ansiatt        db    00h,20h,00h,00h,00h,10h,00h,08h,00h
ansicol        db    0,2,4,6,1,3,5,7
;
;
;

Ansiv        proc    near
        mov    al,ESCPRM[0]
CurDsp:        cmp    al,1
        je    short av_skp1
        mov    byte ptr cs:[CUR_C],TRUE
        ret
av_skp1:    mov    byte ptr cs:[CUR_C],FALSE
        ret
Ansiv        endp
;
;
;

AnsiCom        proc    near
        cmp    al,';'
        jne    short ansi_skp1
        mov    cx,[ESCCNT]
        cmp    cx,16
        jae    short ansi_skp1
        inc    cx
        mov    [ESCCNT],cx
        jmp    short ansi_end2

ansi_skp1:    cmp    al,'0'
        jb    short ansi_skp2
        cmp    al,'9'
        ja    short ansi_skp2
        sub    al,'0'
        mov    cl,al
        xor    ch,ch
        mov    bx,word ptr[offset ESCCNT]
        mov    al,10
        mul    byte ptr ESCPRM[bx]
        add    ax,cx
        mov    byte ptr ESCPRM[bx],al
        jmp    short ansi_end2

ansi_skp2:    cmp    al,' '
        je    short ansi_end2
        mov    di,offset ansi_tbl
        mov    cx,ansi_tbl_l
        repnz    scasb
        jne    short ansi_end
        sub    di,(offset ansi_tbl+1)
        shl    di,1
        mov    di,[offset ansi_j_tbl+di]
        call    near ptr di
ansi_end:    ret

ansi_end2:    mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset AnsiCom
        ret
AnsiCom        endp

ansi_tbl    db    'H','f','A','B','C','D','s','u','J','K','m','M','L','v'
ansi_tbl_l    equ    $-ansi_tbl
ansi_j_tbl    dw    offset AnsiH
        dw    offset AnsiH
        dw    offset AnsiA
        dw    offset AnsiB
        dw    offset AnsiC
        dw    offset AnsiD
        dw    offset Ansis
        dw    offset Ansiu
        dw    offset AnsiJ
        dw    offset AnsiK
        dw    offset Ansim_s
        dw    offset AnsiM_l
        dw    offset AnsiL
        dw    offset Ansiv
;
;
;

AnsiESC        proc    near
        mov    word ptr[offset ESCCNT],0
        mov    di,offset ESCPRM
        mov    cx,16
        xor    al,al
        rep    stosb
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset AnsiCom
        ret
AnsiESC        endp
;
;
;

EscCom        proc    near
        mov    di,offset esc_tbl
        mov    cx,esc_tbl_l
        repnz    scasb
        jne    short esc_end
        sub    di,(offset esc_tbl+1)
        shl    di,1
        mov    di,[offset esc_j_tbl+di]
        call    near ptr di
esc_end:    ret
EscCom        endp
;
Esc_K        proc    near
        mov    byte ptr[offset KANMOD],TRUE
        ret
Esc_K        endp
;
Esc_C        proc    near
        mov    byte ptr[offset KANMOD],FALSE
        ret
Esc_C        endp

N_SCurPs    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SCurPs
        ret
N_SCurPs    endp
;
N_SVidAt    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SVidAt
        ret
N_SVidAt    endp
;
N_CurAtt    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset CurAtt
        ret
N_CurAtt    endp

esc_tbl        db    '*','T','Y','E','R','=','G','K','C','.','['
esc_tbl_l    equ    $-esc_tbl
esc_j_tbl    dw    offset PutCLS
        dw    offset EraLin
        dw    offset EraScr
        dw    offset InsLin
        dw    offset DelLin
        dw    offset N_SCurPs
        dw    offset N_SVidAt
        dw    offset Esc_K
        dw    offset Esc_C
        dw    offset N_CurAtt
        dw    offset AnsiESC
;
;
;

PutCnt        proc    near
        mov    di,offset cnt_tbl
        mov    cx,cnt_tbl_l
        repnz    scasb
        jne    short pcn_end
        sub    di,(offset cnt_tbl+1)
        shl    di,1
        mov    di,[offset cnt_j_tbl+di]
        call    near ptr di
pcn_end:    ret
PutCnt        endp
;
N_SetDC2    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SetDC2
        ret
N_SetDC2    endp
;
N_SetDC3    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset SetDC3
        ret
N_SetDC3    endp

N_EscCom    proc    near
        mov    byte ptr[offset EXTFLG],TRUE
        mov    word ptr[offset EXTPRO],offset EscCom
        ret
N_EscCom    endp

cnt_tbl        db    08h,09h,0Ah,0Bh,0Ch,0Dh,12h,13h
        db    15h,16h,1Bh,1Ch,1Dh,1Eh,1Fh
cnt_tbl_l    equ    $-cnt_tbl
cnt_j_tbl    dw    offset PutBS
        dw    offset PutTAB
        dw    offset PutLF
        dw    offset PutHOME
        dw    offset PutCLS
        dw    offset PutCR
        dw    offset N_SetDC2
        dw    offset N_SetDC3
        dw    offset PutCLS
        dw    offset PutCLS
        dw    offset N_EscCom
        dw    offset PutRit
        dw    offset PutLft
        dw    offset PutUp
        dw    offset PutDwn
;
; PutChr
;  al:code  ah:attr
;  dx:漢字コード
;

PutChr        proc    near

        mov    bx,CVRAM
        mov    es,bx
        push    ax
        push    dx
        mov    ax,MAX_X
        mul    word ptr[offset CUR_Y]
        add    ax,word ptr[offset CUR_X]
        shl    ax,1
        mov    di,ax
        pop    dx
        pop    ax

        mov    es:[di],ax
        test    ah,40h
        jz    short pc_sk3
        xchg    dh,dl
        mov    es:[di+2000h],dx

pc_sk3:        mov    cx,word ptr[offset CUR_X]
        mov    bx,word ptr[offset CUR_Y]
        inc    cx
        cmp    cx,MAX_X
        jb    short pc_sk4
        xor    cx,cx
        inc    bx
        cmp    bx,MAX_Y
        jb    short pc_sk4
        mov    bx,MAX_Y-1
        call    scrool
pc_sk4:        mov    word ptr[offset CUR_X],cx
        mov    word ptr[offset CUR_Y],bx

        ret
PutChr        endp

;
; VDB_outchr ( int 91h  fun.1Dh )
;  al:char code ( shift jis )
;

VDB_outchr    proc    near
        mov    bx,cs
        mov    ds,bx
        mov    es,bx

        cmp    byte ptr[EXTFLG],FALSE
        jne    short Vo_extch

        cmp    byte ptr[KANMOD],FALSE
        je    short Vo_ank

        cmp    byte ptr[KANCOD],0
        je    short Vo_kan3
        call    iskanji2
        jnc    short Vo_kan2
        cmp    byte ptr[CUR_X],MAX_X-1
        jne    short Vo_kan1
        mov    ah,[COLOR]
        mov    al,DMYKAN
        call    PutChr
        call    PutChr
        mov    byte ptr[KANCOD],0
        ret
Vo_kan1:    mov    ah,[KANCOD]
        call    sjisto
        mov    dx,ax
        xor    al,al
        mov    ah,[COLOR]
        or    ah,40h
        call    PutChr
        mov    ah,[COLOR]
        or    ah,80h
        call    PutChr
        mov    byte ptr[KANCOD],0
        ret
Vo_kan2:    mov    ah,[COLOR]
        push    ax
        mov    al,[KANCOD]
        call    PutChr
        pop    ax
        call    PutChr
        ret
Vo_kan3:    call    iskanji
        jnc    short Vo_ank
        mov    [KANCOD],al
        ret

Vo_ank:        cmp    al,' '
        jb    short pc_sk1b
        cmp    al,7Fh
        je    short pc_sk1b
        mov    ah,[COLOR]
        call    PutChr
        ret
pc_sk1b:    call    PutCnt
        ret

Vo_extch:    mov    byte ptr[EXTFLG],FALSE
        mov    dx,[EXTPRO]
        call    near ptr dx
        ret
VDB_outchr    endp

;
; VDB_setpos ( int 91h  fun.0Dh )
;  cx:x (1-80)  bx:y (1-25)
;

VDB_setpos    proc    near
        dec    cx
        jns    short Vs_sk1
        mov    cx,0
Vs_sk1:        cmp    cx,MAX_X
        jb    short Vs_sk2
        mov    cx,MAX_X-1
Vs_sk2:        dec    bx
        jns    short Vs_sk3
        mov    bx,0
Vs_sk3:        cmp    bx,MAX_Y
        jb    short Vs_sk4
        mov    bx,MAX_Y-1
Vs_sk4:        mov    cs:[offset CUR_X],cx
        mov    cs:[offset CUR_Y],bx
        ret
VDB_setpos    endp

;
; VDB_string2
;  al : 0=文字のみ 1=文字とアトリビュート
;  [es:si] 文字コード  [ds:di] 文字属性
;

VDB_string2    proc    near
        cmp    al,1
        je    short Vs_l2

Vs_l1:        mov    bl,es:[si]        ;al=0
        mov    bh,[di]
        call    VDB_oc3
        inc    si
        inc    di
        inc    dl
        loop    short Vs_l1
        jmp    short Vs_ed

Vs_l2:        mov    ax,[di+1]        ;al=1
        and    al,38h
        and    ah,07h
        or    ah,al
        mov    al,1
        mov    bl,es:[si]
        mov    bh,[di]
        call    VDB_oc3
        inc    si
        add    di,4
        inc    dl
        loop    short Vs_l2

Vs_ed:        ret
VDB_string2    endp

;
; VDB_oc3
;  al 0:アトリビュート書換え 1:書き換えない
;  ah: アトリビュート
;  bl: 文字コード  bh:文字属性
;  dl: x(0-79)     dh: y(0-24)
;

VDB_oc3        proc    near

        push    es
        push    di
        push    ax
        push    bx
        push    cx
        push    dx

        push    ax
        mov    ax,CVRAM
        mov    es,ax
        mov    ax,MAX_X
        push    dx
        mov    dl,dh
        xor    dh,dh
        mul    dx
        pop    dx
        xor    dh,dh
        add    ax,dx
        shl    ax,1
        mov    di,ax
        pop    ax

        cmp    al,1
        jne    short Vo3_sk1b
        mov    es:[di+1],ah

Vo3_sk1b:    test    bh,01h
        jz    short Vo3_sk2
        test    bh,02h
        jnz    short Vo3_sk1

        mov    byte ptr es:[di],DMYKAN
        mov    es:[di+2000h],bl
        or    byte ptr es:[di+1],40h
        jmp    short Vo3_sk3

Vo3_sk1:    mov    byte ptr es:[di],DMYKAN
        mov    es:[di+2000h-1],bl
        and    byte ptr es:[di+1],3Fh
        jmp    short Vo3_sk3

Vo3_sk2:    mov    es:[di],bl
        and    byte ptr es:[di+1],3Fh


Vo3_sk3:    pop    dx
        pop    cx
        pop    bx
        pop    ax
        pop    di
        pop    es
        ret
VDB_oc3        endp

;
; VDB_scroll1
;

VDB_scroll1    proc    near
        cmp    al,1
        je    short b1A_r1

        mov    al,MAX_X
        mul    dh
        add    al,dl
        adc    ah,0
        shl    ax,1
        mov    di,ax

        mov    al,MAX_X*2
        mul    cl
        add    ax,di
        mov    si,ax

        sub    bh,dh
        sub    bh,cl
        inc    bh
        sub    bl,dl
        inc    bl
        mov    dx,cx

        mov    cl,bl
        mov    ax,CVRAM
        mov    ds,ax
        mov    es,ax

b1A_l1:        push    di
        push    si
v1_l1:         mov    ax,[si+2000h]
            mov    es:[di+2000h],ax
            movsw
        loop    short v1_l1
        pop    si
        pop    di

        add    si,MAX_X*2
        add    di,MAX_X*2
        mov    cl,bl
        dec    bh
        jne    short b1A_l1

        mov    ah,cs:[COLOR]
        xor    al,al
b1A_l2:        push    di
        rep    stosw
        pop    di
        add    di,MAX_X*2
        mov    cl,bl
        dec    dl
        jne    short b1A_l2
        ret

b1A_r1:        mov    al,MAX_X
        mul    bh
        add    al,dl
        adc    ah,0
        shl    ax,1
        mov    di,ax

        mov    al,MAX_X*2
        mul    cl
        mov    si,di
        sub    si,ax

        sub    bh,dh
        sub    bh,cl
        inc    bh
        sub    bl,dl
        inc    bl
        mov    dx,cx

        mov    cl,bl
        mov    ax,CVRAM
        mov    ds,ax
        mov    es,ax
b1A_l3:        push    di
        push    si
v1_l3:         mov    ax,[si+2000h]
            mov    es:[di+2000h],ax
            movsw
        loop    short v1_l3
        pop    si
        pop    di
        sub    si,MAX_X*2
        sub    di,MAX_X*2
        mov    cl,bl
        dec    bh
        jne    short b1A_l3

        mov    ah,cs:[COLOR]
        xor    al,al
b1A_l4:        push    di
        rep    stosw
        pop    di
        sub    di,MAX_X*2
        mov    cl,bl
        dec    dl
        jne    short b1A_l4
        ret
VDB_scroll1    endp

;******************************
;*    コンソ－ルBIOS(int 91h)
;******************************

bios_ent proc far
    push    bp
    push    es
    push    ds
    push    si
    push    di
    push    dx
    push    cx
    push    bx
    push    ax
    sti
    cld

    push    ax
    mov    al,ah
    xor    ah,ah
    shl    ax,1
    mov    si,ax
    mov    si,cs:[offset bios_tbl + si]
    pop    ax
    mov    bp,sp
    call    near ptr si
    mov    bp,sp
    mov    byte ptr[bp+1],0

    pop    ax
    pop    bx
    pop    cx
    pop    dx
    pop    di
    pop    si
    pop    ds
    pop    es
    pop    bp
    iret

bios_tbl    dw    offset b00
        dw    offset b01
        dw    offset b02
        dw    offset b03
        dw    offset b04
        dw    offset b05
        dw    offset b06
        dw    offset b07
        dw    offset b08
        dw    offset b09
        dw    offset b0A
        dw    offset b0B
        dw    offset b0C
        dw    offset b0D
        dw    offset b0E
        dw    offset b0F
        dw    offset b10
        dw    offset b11
        dw    offset b12
        dw    offset b13
        dw    offset b14
        dw    offset b15
        dw    offset b16
        dw    offset b17
        dw    offset b18
        dw    offset b19
        dw    offset b1A
        dw    offset b1B
        dw    offset b1C
        dw    offset b1D
        dw    offset b1E
        dw    offset b1F
        dw    offset b20
bios_ent endp

b00    proc    near
    ret
b00    endp

b01    proc    near
    ret
b01    endp

b02    proc    near
    ret
b02    endp

b03    proc    near
    ret
b03    endp

b04    proc    near
    mov    dx,1950h
    mov    [bp+6],dx
    ret
b04    endp

b05    proc    near
    ret
b05    endp

b06    proc    near
    ret
b06    endp

b07    proc    near
    ret
b07    endp

b08    proc    near
    ret
b08    endp

b09    proc    near
    mov    cs:[CUR_T],al
    mov    ah,al
    and    al,0Fh
    cmp    al,0
    jne    short b09_s1
    mov    byte ptr cs:[CUR_OFF],14
    mov    byte ptr cs:[CUR_SIZ],2
    jmp    short b09_s3
b09_s1:    cmp    al,1
    jne    short b09_s2
    mov    byte ptr cs:[CUR_OFF],0
    mov    byte ptr cs:[CUR_SIZ],16
    jmp    short b09_s3
b09_s2:    cmp    al,15
    jne    short b09_s3
    cmp    dh,0
    js    short b09_c1
    cmp    dh,15
    jbe    short b09_n1
b09_c1:    mov    dh,15
b09_n1:    cmp    dl,dh
    jbe    short b09_c2
    cmp    dl,15
    jbe    short b09_n2
b09_c2:    mov    dl,15
b09_n2:    sub    dl,dh
    inc    dl
    mov    byte ptr cs:[CUR_OFF],dh
    mov    byte ptr cs:[CUR_SIZ],dl
b09_s3: and    ah,60h
    cmp    ah,20h
    jne    short b09_s4
    mov    byte ptr cs:[CUR_C],FALSE
    ret
b09_s4:    mov    byte ptr cs:[CUR_C],TRUE
    ret
b09    endp

b0A    proc    near
    mov    al,[CUR_T]
    mov    dh,byte ptr[CUR_OFF]
    mov    dl,byte ptr[CUR_SIZ]
    add    dl,dh
    dec    dl
    mov    [bp],al
    mov    [bp+6],dx
    ret
b0A    endp

b0B    proc    near
    call    CurDsp
    ret
b0B    endp

b0C    proc    near
    ret
b0C    endp

b0D    proc    near
    sub    ah,ah
    mov    al,dh    ;y
    mov    bx,ax
    mov    al,dl    ;x
    mov    cx,ax
    call    VDB_setpos
    ret
b0D    endp

b0E    proc    near
    mov    dl,byte ptr cs:[CUR_X]
    inc    dl
    mov    dh,byte ptr cs:[CUR_Y]
    inc    dh
    mov    [bp+6],dx
    ret
b0E    endp

b0F    proc    near
    ret
b0F    endp

b10    proc    near
    ret
b10    endp

b11    proc    near
    mov    ax,[di+1]
    and    al,38h
    and    ah,07h
    or    al,ah
    mov    cs:[COLOR],al
    ret
b11    endp

b12    proc    near
    mov    al,cs:[COLOR]
    mov    ah,al
    and    al,38h
    and    ah,07h
    mov    [di+1],ax
    mov    byte ptr[di+3],0
    ret
b12    endp

b13    proc    near
    dec    dh
    dec    dl
    mov    ah,cs:[COLOR]
    call    VDB_oc3
    ret
b13    endp

b14    proc    near
    ret
b14    endp

b15    proc near

    dec    dl
    dec    dh
    dec    bl
    dec    bh
    push    dx
    push    bx
    mov    bp,sp

    mov    [bp+3],bl
    sub    [bp+3],dl
    inc    byte ptr[bp+3]
    xor    ch,ch
    mov    cl,[bp+3]

    push    bx
    push    dx
    mov    si,[di]
    mov    es,[di+2]
    mov    dx,[di+4]
    mov    bx,[di+6]
    mov    di,dx
    mov    ds,bx
    pop    dx
    pop    bx

b15_l1:    call    VDB_string2
    mov    cl,[bp+3]
    mov    dl,[bp+2]
    inc    dh
    cmp    dh,[bp+1]
    jbe    short b15_l1

    add    sp,4
    ret
b15    endp

b16    proc    near
    ret
b16    endp

b17    proc    near
    ret
b17    endp

b18    proc    near
    dec    dl
    dec    dh
    dec    bl
    dec    bh
b18_e1:    push    dx
    push    bx
    mov    bp,sp

    mov    al,1
    mov    ah,cs:[COLOR]
    xor    bx,bx


b18_l1:    call    VDB_oc3
    inc    dl
    cmp    dl,[bp]
    jbe    short b18_l1
    mov    dl,[bp+2]
    inc    dh
    cmp    dh,[bp+1]
    jbe    short b18_l1

    add    sp,4
    ret
b18    endp

b19    proc    near
    ret
b19    endp

b1A    proc    near
    dec    dl
    dec    dh
    dec    bl
    dec    bh
    cmp    al,2
    jae    short b1A_s1

;    push    bx
;    sub    bh,dh
;    mov    bl,bh
;    xor    bh,bh
;    cmp    cx,bx
;    pop    bx
;    jae    short b18_e1

    call    VDB_scroll1
b1A_s1:    ret
b1A    endp

b1B    proc    near
    ret
b1B    endp

b1C    proc    near
    ret
b1C    endp

b1D    proc    near
    call    VDB_outchr
    ret
b1D    endp

b1E    proc    near
b1E_1:    mov    al,[di]
    push    ds
    push    di
    push    cx
    call    VDB_outchr
    pop    cx
    pop    di
    pop    ds
    inc    di
    loop    b1E_1
    ret
b1E    endp

b1F    proc    near
    cmp    dl,76
    jb    short b1F_s1
    mov    dl,76

b1F_s1:    dec    dl
    mov    dh,24
    push    bx
    push    dx
    mov    si,[di]
    mov    es,[di+2]
    mov    dx,[di+4]
    mov    bx,[di+6]
    mov    di,dx
    mov    ds,bx
    pop    dx
    pop    bx
    call    VDB_string2
    ret
b1F    endp

b20    proc    near
    xor    dh,dh
    mov    dl,cs:[B_COL]
    mov    [bp+6],dx
    ret
b20    endp

;
;
;

cflush        proc far
        mov    dx,05C8h
        in    al,dx
        sti
        test    al,80h
        jnz    short cf_main
        mov    al,byte ptr cs:[CUR_X]
        mov    ah,byte ptr cs:[CUR_Y]
        cmp    ax,word ptr cs:[BAKXY]
        jne    short cf_chk1
cf_cend:    ret

cf_chk1:    mov    word ptr cs:[BAKXY],ax
        cmp    byte ptr cs:[CUR_C],FALSE
        je    short cf_cend

cf_main:    cld
        mov    ax,CVRAM    ; cp
        mov    ds,ax
        xor    si,si

        mov    ax,cs        ; dp
        mov    es,ax
        mov    di,offset dmy_ram

        xor    cx,cx        ; x:cx
        xor    bx,bx        ; y:bx

cf_lp1:        mov    ax,[si]
        test    ah,40h
        je    short cf_ank

        mov    dx,[si+2000h]
        cmp    dx,es:[di+2]
        jne    short cf_knj
        cmp    ah,es:[di+1]
        je    short cf_ked
cf_knj:        mov    es:[di],ax
        mov    es:[di+2],dx
        call    Wrt_kan
cf_ked:        add    si,4
        add    di,4
        add    cx,2
        jmp    short cf_end

cf_ank:        cmp    ax,es:[di]
        mov    es:[di],ax
        je    short cf_aed
        call    Wrt_ank
cf_aed:        add    si,2
        add    di,2
        inc    cx
cf_end:        cmp    cx,MAX_X
        jb    short cf_lp1
        sub    cx,MAX_X
        inc    bx
        cmp    bx,MAX_Y2
        jb    short cf_lp1

        cmp    byte ptr cs:[CUR_C],FALSE
        je    short cf_end2
        call    locate
cf_end2:    ret
cflush        endp
;
;
;

main:        mov    ah,byte ptr[offset COLOR]
        xor    al,al
        mov    di,0
        mov    cx,MAX_X * MAX_Y2
        call    colset
        mov    word ptr[offset CUR_X],0
        mov    word ptr[offset CUR_Y],0

        call    setbios

        mov    ax,cs
        mov    ds,ax
        mov    es,ax

        mov    bx,offset para
        mov    [bx+4],ax
        mov    [bx+8],ax
        mov    [bx+12],ax
        mov    bx,offset mem_end+0Fh
        shr    bx,4
        mov    ah,4Ah
        int    21h

        cld
        mov    si,offset cmdl+1
        mov    di,offset path
skip_lp1:    lodsb
        cmp    al,0Dh
        je    short exit
        cmp    al,20h
        jbe    short skip_lp1
        stosb
main_lp1:    lodsb
        cmp    al,0Dh
        jne    short main_sk1
        mov    word ptr[offset cmdl],0D00h
        mov    byte ptr[di],0
        jmp    short cmd_end
main_sk1:    cmp    al,20h
        je    short new_cmdl
        stosb
        jmp    short main_lp1
new_cmdl:    mov    byte ptr[di],0
        mov    cl,1
        mov    bx,offset cmdl
        lea    di,[bx+1]
        stosb
main_lp2:    lodsb
        cmp    al,0Dh
        je    short end_ncmdl
        stosb
        inc    cl
        jmp    short main_lp2
end_ncmdl:    mov    byte ptr[di],0Dh
        mov    [bx],cl
cmd_end:    mov    si,offset cmdl+1
        mov    di,offset FCB1
        mov    ax,2901h
        int    21h
        mov    di,offset FCB2
        mov    ax,2901h
        int    21h
        mov    dx,offset path
        mov    bx,offset para
        mov    al,0
        mov    ah,4Bh
        int    21h

        call    resetbios

exit:        xor    al,al
        msdos    F$Exit;

;
;
;
path        db    64 dup(?)
para        dw    0
        dw    offset cmdl
        dw    ?
        dw    offset FCB1
        dw    ?
        dw    offset FCB2
        dw    ?
;
;
;
mem_end        equ    $

code        ends
        end    entry