;＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
;＊　　　　　　　　　　　　　　　　　　　　　　　　＊
;＊　Ｈｉｇｈ－Ｃ用　ＯＡＫ２ライブラリー　        ＊
;＊　　　　　　　　　Programmed by 山崎憲明　　　　＊
;＊　　　　　　　　   　  NIFTY ID=QGB01416　　　　＊
;＊　　　　　　　     nanno-NET ID= YAMA 　　　　　＊
;＊　　　　　　　　　　　　　　　　　　　　　　　　＊
;＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
;
;このプログラムにおいては、Ｈｉｇｈ－Ｃ＜＝＞プロテクトモードアセンブラ＜＝＞
;リアルモードアセンブラ＜＝＞Ｈｉｇｈ－Ｃという相互呼出しを行っています。
;
;この動作について、詳しく知りたい方は、以下の文献を参照してください。
;（プロテクト＜＝＞リアルモード）　Dos-Extender p.30 p35 p.99-102
;（Ｈｉｇｈ－Ｃ＜＝＞プロテクト）　High-C 第一部 9章､14章
;（参考プログラム）　High-C付属サンプル 'tail.c'
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;       v0.01   Makeing by YAMA cyan
;       v0.02   ユ－ザ－関数仕様変更 YAMA (Reqest by Ken)
;       v0.02a  KYB_open()でのmode_chgを復活 by Ken
;       v0.03   デバッグ用のゴミを除去 by YAMA
;       v0.04   ﾈｲﾃｨﾌﾞﾀﾞｰﾀが64kを越える場合に起こるlink障害除去 by YAMA
;       v0.04a  KYB_readのenc_cntのバグ修正及びkancnvflgの追加 by Ken
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;セグメント宣言
;
rmcode  segment word public use16
rmcode  ends
rmdata  segment dword public 'DATA' use16
rmdata  ends
pmdata  segment dword public 'DATA' use32
pmdata  ends
pmcode  segment dword public 'CODE' use32
pmcode  ends
DGROUP  group   rmdata,pmdata

;
;定数
;
STACK_R equ     4*1024  ;リアル=>プロテクト(High-C)用に確保すべきスタック量
;                       ;(デフォルト:4 Kbytes : putstr, putsysがこの量以上に
;                       ;スタックを使用すると、スタックが破壊されるので
;                       ;要注意！！

TRUE    equ     1
FALSE   equ     0
;
;キーアドレス
;
sCAP    equ     55h
sHIRA   equ     56h
sKATA   equ     5Ah

sEIJI   equ     6Ah
sEIKO   equ     6Fh
sMUHEN  equ     57h
sHENKAN equ     58h

sKANJI  equ     59h
sZENHAN equ     71h

;
;モ－ドフラグ
;
mKANJI  equ     0002h
mROMA   equ     0008h
mZEN    equ     0020h
mKATA   equ     0080h
mHIRA   equ     0100h

;
;  かな漢字変換用構造体定義
;
Funcparm        struc
        wFunc           dw      ?
        wMode           dw      ?
        lpKkname        dd      far
        lpDataparm      dd      far
        wHandle         dw      ?
        Reserved_f      db      2 dup(0)
Funcparm        ends

Kkname          struc
        wLevel          dw      ?
        rgchName        db      8 dup(?)
        rgchVersion     db      4 dup(?)
        rgchRevision    db      4 dup(?)
        Reserved_k      db      14 dup(0)
Kkname          ends

Dataparm        struc
        wType           dw      0
        wScan           dw      0
        wAscii          dw      0
        wStatus         dw      0

        cchResult       dw      0
        lpchResult      dd      far

        cchMode         dw      0
        lpchMode        dd      far
        lpattrMode      dd      far

        cchSystem       dw      0
        lpchSystem      dd      far
        lpattrSystem    dd      far

        cchBuf          dw      0
        lpchBuf         dd      far
        lpattrBuf       dd      far
        cchBufCursor    dw      0
        cchBufAct       dw      0

        cchHomonym      dw      0
        lpchHomonym     dd      far
        cchHomonymAct   dw      0
        cchHomonymTotal dw      0
        cchHomonymNum   dw      0

        fKanji          dw      ?
        fNtype          dw      ?

        Reserved_d      db      16 dup(0)
Dataparm        ends

;
;
;
MAX_X   equ     80
MAX_Y   equ     24

;
;リアルモードデータセグメント
;

rmdata segment 
;
;
;
call_port       dd      far     ;リアル=>プロテクト呼出しポート
rm_seg          dw      ?       ;リアルモードセグメント値

save_rt_ofs     dw      ?
;
;  データ領域
;
                public  modeW

fnc     Funcparm        <>
knm     Kkname          <>
dat     Dataparm        <>
buf_size        equ     100
buf             db      8 dup(buf_size dup(0))
Slock           db      FALSE
modeW           dw      0056h or 8000h
modeS           db      '漢　 英小',0
sw              dw      0
enc             dw      0
key_c           dw      0
kancnvflg       db      0               ; Apend OAKLIB by Ken
old_cchS        dw      0
old_cchB        dw      0

cchR_p          dw      0
k_kind          db      ?
key_tbl         db      16 dup(?)

enc_cnt         dw      0               ;bug fixed at v1.00
enc_str         db      7 dup (0)

        public  end_real        ;リアルモードエンドアドレス
end_real label  byte

rmdata  ends

;
;プロテクトモードデータセグメント
;

pmdata  segment

save_esp_p      dd      ?
save_ss_p       dw      ?       ; Selecter era ! LSS esp,save_esp_p
save_esp_r      dd      ?
save_ss_r       dw      ?       ; Selecter era ! lss esp,save_esp_r
;
;表示関数(ユーザー定義)
;
putstr_p        dd      near
putsys_p        dd      near
putmode_p       dd      near

putstr_fp       dd      offset pmcode:putstr_f          ;Bug Fixed at v0.04
putsys_fp       dd      offset pmcode:putsys_f          ;
putmode_fp      dd      offset pmcode:putmode_f         ;

pmdata  ends

;
;
;
        assume  cs:pmcode,ds:DGROUP

;
;プロテクトモードｰコード
;

pmcode  segment

;
;プロテクトルーチン     
;

;
;call_real:プロテクト=>リアルプロシジャ呼出しルーチン
;  AX=呼び出す関数のリアルオフセット

call_real       proc    near
                mov     save_ss_p,ss    ; SS Selcter save
                mov     save_esp_p,esp  ;リアル=>プロテクト呼出し用スタック確保
                sub     esp,STACK_R
                mov     bx,rm_seg       ;リアルモードセグメント設定
                shl     ebx,16          ;
                mov     bx,ax           ;リアルモードオフセット
                xor     ecx,ecx         ;0 word パラメーター
                mov     ax,250Eh        ;リアルプロシジャ呼出し
                int     21h
                add     esp,STACK_R     ;リアル=>プロテクト呼出し用スタック解放
                ret
call_real       endp

;かな漢システムオープン
;int     KAN_open(void (*putstr)(), void (*putsys)(),void (*putmode)() );
;
        public  KAN_open
KAN_open        proc    near

                push    ebp             ;High-C用ヘッダー
                mov     ebp,esp
                push    esi
                push    edi
                push    ebx
                push    es

;リアルモード呼出し用初期化ルーチン
                mov     ax,250Dh        ;リアル=>プロテクト呼出し用
                int     21h             ;プロシジャアドレス取得
                mov     dword ptr call_port,eax

                mov     ax,ds           ;リアルモード用セグメント算定
                mov     es,ax           ;先頭アドレス
                xor     ebx,ebx         ;
                lea     ecx,end_real    ;リアルモードコードセグメントサイズ
                mov     ax,250Fh        ;プロテクト=>リアルアドレス変換
                int     21h
                ;jc     err             ;エラー処理
                ;test   ecx,0FFFFh      ;
                ;jnz    err             ;
                shr     ecx,16
                mov     rm_seg,cx       ;リアルモードセグメント値保存
;
;かな漢変換システム初期化
                mov     esi,[ebp][16]   ;引数 3( void (*putmode)() )
                mov     putmode_p,esi
                mov     esi,[ebp][12]   ;引数 2( void (*putsys)() )
                mov     putsys_p,esi
                mov     esi,[ebp][8]    ;引数 1( void (*putstr)() )
                mov     putstr_p,esi

                lea     ax,KAN_open_s   ;プロシジャ KAN_open_s
                call    call_real

                pop     es
                pop     ebx             ;High-C用後処理
                pop     edi
                pop     esi
                mov     esp,ebp
                pop     ebp
                ret
KAN_open        endp

;かな漢システムクローズ
;int     KAN_close();
;
        public  KAN_close
KAN_close       proc    near

                push    ebp             ;High-C用ヘッダー
                mov     ebp,esp
                push    esi
                push    edi
                push    ebx
                push    es

                lea     ax,KAN_close_s  ;プロシジャ KAN_close_s
                call    call_real

                pop     es
                pop     ebx             ;High-C用後処理
                pop     edi
                pop     esi
                mov     esp,ebp
                pop     ebp
                ret
KAN_close       endp

;キー読み取り(かな漢変換付き)
;int     KAN_read(int sw, unsigned *enc );
;
        public  KAN_read
KAN_read        proc    near

                push    ebp             ;High-C用ヘッダー
                mov     ebp,esp
                push    esi
                push    edi
                push    ebx
                push    es
                push    ebp

                mov     eax,[ebp][8]    ;引数 1( int sw )
                mov     sw,ax

                lea     ax,KAN_read_s   ;プロシジャ KAN_read_s
                call    call_real

                pop     ebp
                xor     eax,eax
                mov     ax,enc
                mov     edi,[ebp][12]   ;引数 2( unsigned *enc )
                mov     [edi],eax       ;
                mov     ax,key_c        ;リターン:キーコード

                pop     es
                pop     ebx             ;High-C用後処理
                pop     edi
                pop     esi
                mov     esp,ebp
                pop     ebp
                ret
KAN_read        endp

;単語登録
;int     KAN_touroku(int len, char *tango );
;
        public  KAN_touroku
KAN_touroku     proc    near

                push    ebp             ;High-C用ヘッダー
                mov     ebp,esp
                push    esi
                push    edi
                push    ebx
                push    es
                push    ebp

                mov     esi,[ebp][12]   ;引数 2( char *tango )
                mov     ecx,[ebp][8]    ;引数 1( int len )
                mov     dat.cchResult,cx
                xor     edi,edi
                mov     di,word ptr dat.lpchResult
                rep     movsb

                lea     ax,KAN_touroku_s        ;プロシジャ KAN_read_s
                call    call_real

                pop     ebp

                pop     es
                pop     ebx             ;High-C用後処理
                pop     edi
                pop     esi
                mov     esp,ebp
                pop     ebp
                ret
KAN_touroku     endp


;
;リアル=>High-C呼出し用プロシジャ:
;<解説> Dos-Extenderによるリアル=>プロテクト呼出しは、プロテクトFARコール
;によって行われるため、プロテクトNEARプロシジャであるHigh-C関数を呼び出すには、
;この様に中継用のプロシジャが必要となる。また、リアル=>プロテクト呼出しの為、
;スタックフレームがHigh-Cと共用出来ないのを防ぐため、予め用意したプロテクト側の
;スタックに切り換える。
;

;       void    putstr(int pos,int len,char *str,char *att);
                public  putstr_f
putstr_f        proc    far
                mov     save_ss_r,ss    ; Selecter Save
                mov     save_esp_r,esp  ;スタックフレーム再構築
                lss     esp,pword ptr save_esp_p ; Load Loacl Stack Address

                xor     eax,eax
                mov     ax,word ptr dat.lpattrBuf       ;引数 4( char *att )
                push    eax
                mov     ax,word ptr dat.lpchBuf         ;引数 3( char *str )
                push    eax
                mov     ax,dat.cchBuf                   ;引数 2( int len )
                push    eax
                mov     ax,dat.cchBufCursor             ;引数 1( int pos )
                push    eax
                call    putstr_p
                add     esp,4*4         ;引数pop

                lss     esp,pword ptr save_esp_r
                ret
putstr_f        endp

;       void    putsys(int len, char *str, char *att);
                public  putsys_f
putsys_f        proc    far
                mov     save_ss_r,ss    ; Selecter Save
                mov     save_esp_r,esp  ;スタックフレーム再構築
                lss     esp,pword ptr save_esp_p ; Load Loacl Stack Address

                xor     eax,eax
                mov     ax,word ptr dat.lpattrSystem    ;引数 3( char *att )
                push    eax
                mov     ax,word ptr dat.lpchSystem      ;引数 2( char *str )
                push    eax
                mov     ax,dat.cchSystem                ;引数 1( int len )
                push    eax
                call    putsys_p
                add     esp,3*4         ;引数pop

                lss     esp,pword ptr save_esp_r
                ret
putsys_f        endp

;       void    putmode(int mode, int shift, char *str);
                public  putmode_f
putmode_f       proc    far
                mov     save_ss_r,ss    ; Selecter Save
                mov     save_esp_r,esp  ;スタックフレーム再構築
                lss     esp,pword ptr save_esp_p ; Load Loacl Stack Address

                xor     eax,eax
                mov     ax,offset modeS ;引数 3( char *str )
                push    eax
                mov     ax,enc          ;引数 2( int shift )
                and     ax,00FFh
                push    eax
                mov     ax,modeW        ;引数 1( int mode )
                push    eax
                call    putmode_p
                add     esp,3*4         ;引数pop

                lss     esp,pword ptr save_esp_r
                ret
putmode_f       endp

pmcode  ends

;
;リアルモードコード
;

rmcode  segment word public use16

        assume  cs:rmcode,ds:DGROUP

;
;call_prot:リアル=>プロテクト呼出しルーチン
;  EAX=呼び出す関数のネイティブオフセット

call_prot       proc    near
                pop     [save_rt_ofs]
                push    dword ptr 0     ;データセグメントは初期設定値
                push    word ptr 0Ch    ;プロテクトモードセレクタ
                push    eax             ;呼び出す関数のネイティブオフセット
                call    call_port       ;プロテクトプロシジャ呼出し
                add     sp,10
                push    [save_rt_ofs]
                ret
call_prot       endp

;
;  かな漢字変換関数
;
KKfunc  proc    near
        push    es
        push    ds
        push    bx
        push    cx
        push    dx
        push    si
        push    di
        mov     ax,cs
        mov     ds,ax
        mov     es,ax

        mov     ax,fnc.wFunc
        mov     bx,offset fnc
        mov     cx,offset fnc
        mov     dx,offset fnc
        mov     di,offset fnc
        mov     si,offset fnc

        int     0EEh
        pop     di
        pop     si
        pop     dx
        pop     cx
        pop     bx
        pop     ds
        pop     es
        ret
KKfunc  endp

KKOpen  proc    near
        mov     fnc.wFunc,2
        mov     fnc.wHandle,1
        mov     ax,ds
        mov     word ptr fnc.lpKkname,offset knm
        mov     word ptr fnc.lpKkname+2,ax
        mov     word ptr fnc.lpDataparm,offset dat
        mov     word ptr fnc.lpDataparm+2,ax
        mov     dat.wType,1
        call    KKfunc
        ret
KKOpen  endp

KKClose proc    near
        mov     fnc.wFunc,3
        mov     fnc.wMode,0
        mov     word ptr fnc.lpKkname,0
        mov     word ptr fnc.lpKkname+2,0
        mov     word ptr fnc.lpDataparm,0
        mov     word ptr fnc.lpDataparm+2,0
        call    KKfunc
        ret
KKClose endp

KKInOut proc    near
        mov     fnc.wFunc,4
        mov     fnc.wMode,0
        mov     word ptr fnc.lpKkname,0
        mov     word ptr fnc.lpKkname+2,0
        mov     ax,ds
        mov     word ptr fnc.lpDataparm,offset dat
        mov     word ptr fnc.lpDataparm+2,ax

        mov     word ptr dat.lpchResult,offset buf[0]
        mov     word ptr dat.lpchResult+2,ax
        mov     word ptr dat.lpchMode,offset buf[1*buf_size]
        mov     word ptr dat.lpchMode+2,ax
        mov     word ptr dat.lpattrMode,offset buf[2*buf_size]
        mov     word ptr dat.lpattrMode+2,ax
        mov     word ptr dat.lpchSystem,offset buf[3*buf_size]
        mov     word ptr dat.lpchSystem+2,ax
        mov     word ptr dat.lpattrSystem,offset buf[4*buf_size]
        mov     word ptr dat.lpattrSystem+2,ax
        mov     word ptr dat.lpchBuf,offset buf[5*buf_size]
        mov     word ptr dat.lpchBuf+2,ax
        mov     word ptr dat.lpattrBuf,offset buf[6*buf_size]
        mov     word ptr dat.lpattrBuf+2,ax
        mov     word ptr dat.lpchHomonym,offset buf[7*buf_size]
        mov     word ptr dat.lpchHomonym+2,ax
        call    KKfunc
        ret
KKInOut endp

KKMode  proc    near
        mov     fnc.wFunc,5
        mov     word ptr fnc.lpKkname,0
        mov     word ptr fnc.lpKkname+2,0
        mov     ax,ds
        mov     word ptr fnc.lpDataparm,offset dat
        mov     word ptr fnc.lpDataparm+2,ax
        call    KKfunc
        ret
KKMode  endp

KKTrans proc    near
        mov     fnc.wFunc,6
        mov     fnc.wMode,0
        mov     word ptr fnc.lpKkname,0
        mov     word ptr fnc.lpKkname+2,0
        mov     ax,ds
        mov     word ptr fnc.lpDataparm,offset dat
        mov     word ptr fnc.lpDataparm+2,ax
        mov     fnc.wHandle,1

        mov     byte ptr dat.wScan,0
        mov     byte ptr dat.wAscii,0
        mov     byte ptr dat.wStatus,0
        mov     word ptr dat.lpchMode,0
        mov     word ptr dat.lpchMode+2,0
        mov     word ptr dat.lpattrMode,0
        mov     word ptr dat.lpattrMode+2,0
        mov     word ptr dat.lpchSystem,offset buf[3*buf_size]
        mov     word ptr dat.lpchSystem+2,ax
        mov     word ptr dat.lpattrSystem,offset buf[4*buf_size]
        mov     word ptr dat.lpattrSystem+2,ax
;       mov     word ptr dat.lpchBuf,0
;       mov     word ptr dat.lpchBuf+2,0
;       mov     word ptr dat.lpattrBuf,0
;       mov     word ptr dat.lpattrBuf+2,0
        mov     word ptr dat.lpchHomonym,0
        mov     word ptr dat.lpchHomonym+2,0
        call    KKfunc
        ret
KKTrans endp

;
;
;

KYB_check       macro
                mov     ah,07h
                int     90h
                endm

KYB_read        macro   sw
                mov     ah,09h
                mov     al,sw
                int     90h
                endm

KYB_matrix      macro
                mov     di,offset key_tbl
                mov     ah,0Ah
                int     90h
                endm

KYB_KindKb      macro
                mov     ah,0FAh
                int     90h
                endm

KYB_setShift    macro
                mov     ah,0FCh
                int     90h
                endm

movKs           macro   index,code
        mov     word ptr modeS[index],((code shl 8)or(code shr 8))and 0FFFFh
                endm

KYB_read2_s     proc    near
kr2s_lp1:       call    KYBN_check
                cmp     dh,0FFh
                je      kr2s_lp1
                mov     ax,0900h
                int     90h
                push    ax
                push    bx
                push    cx
                push    dx
                mov     cl,bh
kr2s_apn31:     mov     ah,07h
                int     90h
                cmp     dh,0ffh
                je      kr2s_apn4

                cmp     bh,cl
                jne     kr2s_apn4

                cmp     bh,4dh
                je      kr2s_apn32
                cmp     bh,4fh
                je      kr2s_apn32
                cmp     bh,50h
                je      kr2s_apn32
                cmp     bh,51h
                je      kr2s_apn32
                cmp     bh,4Bh
                je      kr2s_apn32
                cmp     bh,4Eh
                je      kr2s_apn32
                cmp     bh,48h
                je      kr2s_apn32
                cmp     bh,72h
                je      kr2s_apn32
                cmp     bh,73h
                jne     kr2s_apn4

kr2s_apn32:     mov     ax,0900h
                int     90h
                jmp     kr2s_apn31
kr2s_apn4:      
                pop     dx
                pop     cx
                pop     bx
                pop     ax
                ret
KYB_read2_s     endp

KYB_read2       macro
                call KYB_read2_s
                endm

key_test        macro   scan
                test    key_tbl[scan/8],(1 shl (scan mod 8))
                endm

key_break       macro   scan
                local   lp
lp:                 KYB_matrix
                    key_test    scan
                    jnz short lp
                endm

putstr_r        proc    near
                mov     eax,[putstr_fp]         ;Bug Fixed at v0.04
                call    call_prot
                mov     ax,dat.cchBuf
                mov     old_cchB,ax
                ret
putstr_r        endp

putsys_r        proc    near
                mov     eax,[putsys_fp]         ;Bug Fixed at v0.04
                call    call_prot
                mov     ax,dat.cchSystem
                mov     old_cchS,ax
                ret
putsys_r        endp

;
;空文字列出力:KAN_readの処理が終わる時、このルーチンによって長さ０の
;文字列がputstr,putsysに出力される。(画面復元用)
;
clrstr          proc    near
                push    dat.cchBuf
                push    dat.cchSystem
                mov     dat.cchBuf,0
                mov     dat.cchSystem,0
                mov     eax,[putstr_fp]         ;Bug Fixed at v0.04
                call    call_prot
                mov     eax,[putsys_fp]         ;Bug Fixed at v0.04
                call    call_prot
                mov     old_cchB,0
                mov     old_cchS,0
                pop     dat.cchSystem
                pop     dat.cchBuf
                ret
clrstr          endp

;
;
;

mode_chg        proc    near

                push    di
                push    ax
                push    cx
                push    dx

                test    modeW,01h
                  jz    short krn_edsk0
                    mov         modeW,8055h
                    test        bl,02h
                    jz          short krn_edsk0
                      xor       modeW,0C0h

krn_edsk0:      test    modeW,0008h
                jne     short krn_edsk1
                  test  modeW,180h
                  jz    short krn_edsk1
                  or    bl,02h
                  mov   al,bl
                 jmp    short krn_edsk2

krn_edsk1:        and   bl,0FDh
                  mov   al,bl
krn_edsk2:        KYB_setShift
                test    modeW,0002h
                je      short krnc_sk11
                  movKs 0,'漢'
                 jmp    short krnc_sk2
krnc_sk11:        movKs 0,'  '
krnc_sk2:       test    modeW,0008h
                je      short krnc_sk21
                  mov   modeS[4],'R'
                 jmp    short krnc_sk3
krnc_sk21:        mov   modeS[4],' '
krnc_sk3:       test    modeW,0020h
                je      short krnc_sk31
                  movKs 2,'全'
                 jmp    short krnc_sk4
krnc_sk31:        movKs 2,'  '
krnc_sk4:       test    modeW,0040h
                je      short krnc_sk42
                  movKs 5,'英'
                  test  bl,01h
                  je    short krnc_sk411
                    movKs       7,'大'
                   jmp  short krnc_sk5
krnc_sk411:         movKs       7,'小'
                   jmp  short krnc_sk5
krnc_sk42:      test    modeW,0080h
                je      short krnc_sk43
                  movKs 5,'カ'
                  movKs 7,'ナ'
                 jmp    short krnc_sk5
krnc_sk43:        movKs 5,'か'
                  movKs 7,'な'

krnc_sk5:
                mov     enc,bx
                mov     ax,modeW
                mov     fnc.wMode,ax
                call    KKMode
                mov     eax,[putmode_fp]        ;Bug Fixed at v0.04
                call    call_prot

                pop     dx
                pop     cx
                pop     ax
                pop     di
                mov     bx,enc
                ret
mode_chg        endp

KYBN_check      proc    near
                KYB_matrix
                KYB_check
                cmp     dh,0FFh
                je      krn_sk1

                cmp     dh,80h          ;PF key?
                jne     kcn_sk1
;
; For oyayubi shift
;
                cmp     bh,57h          ;
                je      kcn_sk0
                cmp     bh,58h          ;
                jne     kcn_sk01
kcn_sk0:        cmp     k_kind,1        ;JIS?
                je      kcn_sk01
                and     modeW,803Fh
                or      modeW,100h
                push    dx
                push    bx
                call    mode_chg
                pop     bx
                pop     dx
                jmp     kcn_sk2
kcn_sk01:       jmp     kcn_sk3

kcn_sk1:        test    modeW,0020h     ;全角?
                jne     kcn_sk2
                test    modeW,0040h     ;英数入力モード?
                jne     kcn_sk3
                test    modeW,0108h     ;ローマ字入力モード or ひらがな?
                jne     kcn_sk2
                jmp     kcn_sk3         ;かな入力モード and かたかな.

kcn_sk2:        mov     ah,0FFh         ;変換の必要有り
                ret
kcn_sk3:        mov     ah,0            ;変換の必要なし
                ret
;
; For JIS keybord
;
krn_sk1:          key_test      sCAP
                  jz    short krn_sk2
                    key_break   sCAP
                   jmp  krn_end1

krn_sk2:          key_test      sHIRA
                  jz    short krn_sk3
                    test        bl,10h          ;CTRL
                    jz  short krn_sk22
                      test      Slock,TRUE
                      jnz       krn_sk21
                      xor       modeW,0Ch
krn_sk21:             key_break sHIRA
                     jmp        krn_end1
krn_sk22:             test      Slock,TRUE
                      jnz       krn_sk23
                     xor        modeW,140h
krn_sk23:             test      modeW,100h
                      je        short krn_sk21
                       and      modeW,813Fh
                     jmp        short krn_sk21
krn_sk3:          key_test      sKATA
                  jz    short krn_sk4
                      test      Slock,TRUE
                      jnz       krn_sk32
                    xor         modeW,80h
                    test        modeW,80h
                    je          short krn_sk31
                      and       modeW,80BFh
                     jmp        short krn_sk32
krn_sk31:             and       modeW,803Fh
                      or        modeW,40h
krn_sk32:             key_break sKATA
                      jmp       krn_end1
;
; For oyayubi shift keybord
;
krn_sk4:
                  key_test      sEIJI
                  jz    short krn_sk5
                    test        bl,10h          ;CTRL
                    jz  short krn_sk42
                      test      Slock,TRUE
                      jnz       krn_sk41
                      xor       modeW,0Ch
krn_sk41:             key_break sEIJI
                     jmp        krn_end1
krn_sk42:             test      Slock,TRUE
                      jnz       krn_sk41
                     and        modeW,803Fh
                     or         modeW,040h
                     jmp        short krn_sk41

krn_sk5:          key_test      sEIKO
                  jz    short krn_sk6
                    test        Slock,TRUE
                    jnz         krn_sk52
                    test        modeW,040h
                    jne         krn_sk52
                    and         modeW,803Fh
                    or          modeW,080h
krn_sk52:           key_break   sKATA
                    jmp short krn_end1
;
;
;
krn_sk6:          key_test      sZENHAN
                  jz    krn_sk7
                      test      Slock,TRUE
                      jnz       krn_sk61
                    xor modeW,30h
krn_sk61:             key_break sZENHAN
                    jmp krn_end1
krn_sk7:          key_test      sKANJI
                  jz    short krn_end2
                      test      Slock,TRUE
                      jnz       krn_sk71
                    xor         modeW,03h
krn_sk71:           key_break   sKANJI

krn_end1:       call    mode_chg
                mov     dx,0FFFFh
                mov     bh,0FFh
krn_end2:       ret
KYBN_check      endp


;
;
;
        public  KAN_touroku_s
KAN_touroku_s   proc    far
                push    bp
                mov     bp,sp
                mov     ax,cs
                mov     ds,ax
                mov     es,ax

;               mov     Slock,TRUE

                cmp     dat.cchResult,0
                je      ew_end
                call    KKTrans

ew_lp4:         call    putsys_r

                KYB_read2
                mov     byte ptr dat.wType,0
                mov     byte ptr dat.wScan,bh
                mov     byte ptr dat.wAscii,dl
                mov     byte ptr dat.wStatus,bl
                call    KKInOut
                cmp     dat.cchSystem,0
                jne     ew_lp4

ew_end:         call    clrstr

;               mov     Slock,FALSE
                mov     dat.cchResult,0
                mov     dat.cchBuf,0
                mov     dat.cchSystem,0

                xor     eax,eax
err4:           pop     bp
                ret
KAN_touroku_s   endp

        public  KAN_read_s
KAN_read_s      proc    far
                push    bp
                mov     bp,sp
                mov     ax,cs
                mov     ds,ax
                mov     es,ax

                mov     cx,cchR_p
                cmp     cx,dat.cchResult
                jae     short kr_sk1
                mov     si,word ptr dat.lpchResult
                add     si,cx
                xor     dh,dh
                mov     dl,[si]
                mov     bh,byte ptr dat.wScan
                cmp     enc_cnt,0
                je      v101_fx2
                xor     bh,bh
                dec     enc_cnt
v101_fx2:       mov     bl,byte ptr dat.wStatus
                mov     enc,bx
                mov     key_c,dx
                inc     cchR_p
                jmp     kr_end23

kr_sk1:         cmp     kancnvflg,0             ; Apend OAKLIB by Ken
                je      ken_fix1
                mov     kancnvflg,0

                cmp     sw,1                    ; No wait key in?
                jne     ken_fix1

                mov     bh,0FFH
                mov     bl,byte ptr dat.wStatus
                mov     dx,0FFFFh
                jmp     ken_fix2                ; Return to Null Char

ken_fix1:       mov     cchR_p,0
                mov     dat.cchResult,0

                cmp     word ptr dat.cchSystem,0
                je      kr_sk101
                call    putsys_r

kr_sk101:       cmp     word ptr dat.cchBuf,0
                je      short kr_lp1
                call    putstr_r

kr_lp1:         call    KYBN_check
                cmp     dh,0FFh                 ;No key in?
                jne     short kr_sk2            ;No.
                cmp     sw,1                    ;No wait key in?
                jne     short kr_lp1            ;No.
kr_lp11:        cmp     word ptr dat.cchBuf,0
                jne     short kr_lp1

kr_lp12:        cmp     bh,57h                  ;変換,無変換を返さない
                je      kr_lp1                  ;ようにした  by Ken
                cmp     bh,58h
                je      kr_lp1
ken_fix2:       mov     enc,bx
                mov     key_c,dx
                jmp     kr_end23

kr_sk2:         push    ax
                mov     ax,0900h                ;dummy read
                int     90h
                pop     ax
                cmp     word ptr dat.cchBuf,0   ;未確定文字列があるか？
                jne     kr_sk22

kr_sk21:        cmp     ah,0FFh         ;変換の必要ありか？
                jne     kr_lp12         ;無。

kr_sk22:        mov     byte ptr dat.wType,0
                mov     byte ptr dat.wScan,bh
                mov     byte ptr dat.wAscii,dl
                mov     byte ptr dat.wStatus,bl

                mov     si,offset enc_str
                mov     enc_cnt,1
                mov     [si],dl
                inc     si

;Bug Fixed by K.MIYAZAKI
;   Thanks a lot!!
;
                mov     ah,1eh
                cmp     bh,4dh
                je      ken_apn2
                mov     ah,1dh
                cmp     bh,4fh
                je      ken_apn2
                mov     ah,1fh
                cmp     bh,50h
                je      ken_apn2
                mov     ah,1ch
                cmp     bh,51h
                je      ken_apn2

                mov     ah,7Fh
                cmp     bh,4Bh
                je      ken_apn2
                mov     ah,0Bh
                cmp     bh,4Eh
                je      ken_apn2

                mov     ah,1bh
                cmp     bh,48h
                je      ken_apn2
                cmp     bh,6Dh
                je      ken_apn2
                cmp     bh,72h
                je      ken_apn2
                cmp     bh,73h
                jne     ken_apn5

ken_apn2:
                cmp     old_cchS,0
                jne     ken_apn3
                cmp     old_cchB,0
                jne     ken_apn3
                jmp     kr_lp12
ken_apn3:       
                mov     byte ptr dat.wAscii,ah

                push    ax
                push    bx
                push    dx
ken_apn31:      mov     ah,07h
                int     90h
                cmp     dh,0ffh
                je      ken_apn4
                cmp     bh,byte ptr dat.wScan
                jne     ken_apn4
                mov     ax,0900h
                int     90h
                mov     [si],dl
                inc     si
                inc     enc_cnt
                jmp     ken_apn31

ken_apn4:       
                pop     dx
                pop     bx
                pop     ax
ken_apn5:       
;
;
;

                call    KKInOut

                cmp     [dat.cchResult],0       ;No result string?
                jne     kr_sk3                  ;No.

                call    putstr_r

                call    putsys_r

                mov     kancnvflg,1             ; Apend OAKLIB by Ken

                jmp     kr_lp1

kr_sk3:
;               cmp     dat.cchBuf,0            ; Wait is Code ? by Ken
;               jne     kr_sk301

                mov     di,word ptr[dat.lpchResult]
                add     di,dat.cchResult
                dec     di
                mov     si,offset enc_str
                mov     cx,enc_cnt

                mov     al,byte ptr dat.wAscii  ;キーコードの復元が必要か？
                cmp     al,[di]
                je      kr_sk309        ; Do Cnvert
                dec     enc_cnt         ; エンコ－ドの禁止 by Ken
                jmp     kr_sk301

kr_sk309:       repnz   movsb
                mov     cx,dat.cchResult
                add     cx,enc_cnt
                dec     cx
                mov     dat.cchResult,cx

kr_sk301:       mov     si,word ptr[dat.lpchResult]
                cmp     dl,[si]
                je      short kr_sk31

kr_sk4:         mov     dl,[si]
                xor     dh,dh
                xor     bh,bh

kr_sk31:        mov     enc,bx
                mov     key_c,dx

                call    clrstr

                mov     cchR_p,1
                mov     ax,dat.cchResult
                sub     ax,enc_cnt
                dec     ax
                jns     kr_end20
                xor     ax,ax
kr_end20:       mov     enc_cnt,ax
kr_end23:
                xor     eax,eax
err3:           pop     bp
                ret
KAN_read_s      endp

        public  KAN_open_s
KAN_open_s      proc    far
                push    bp
                mov     bp,sp
                mov     ax,cs
                mov     ds,ax
                mov     es,ax

                KYB_KindKb                      ;キーボード種類
                mov     k_kind,al

                call    KKOpen                  ;oak/2 open
                or      ax,ax
                jne     err
                mov     ax,modeW
                mov     fnc.wMode,ax
                call    KKMode
                or      ax,ax
                jne     err
                mov     byte ptr dat.wType,0            ;リフレッシュ
                mov     byte ptr dat.wScan,0
                mov     byte ptr dat.wAscii,0
                mov     byte ptr dat.wStatus,0
                call    KKInOut
                or      ax,ax
                jne     err
                mov     dat.cchResult,0
                mov     dat.cchSystem,0
                mov     dat.cchBuf,0
                mov     old_cchS,0
                mov     old_cchB,0
                mov     cchR_p,0

                mov     ah,07h                  ;set shift mode
                int     90h
                call    mode_chg

                xor     eax,eax
err:            pop     bp
                ret
KAN_open_s      endp

        public  KAN_close_s
KAN_close_s     proc    far
                push    bp
                mov     bp,sp
                mov     ax,cs
                mov     ds,ax
                mov     es,ax
                push    bx
                mov     bx,modeW
                push    bx

                mov     ah,07h
                int     90h
                or      modeW,1                 ;漢字off
                call    mode_chg
                call    KKClose
                or      ax,ax
                jne     err2

                xor     eax,eax
err2:           pop     bx
                mov     modeW,bx
                pop     bx
                pop     bp
                ret
KAN_close_s     endp

rmcode  ends

        end
