x86リアルモードでモニターを作ろうシリーズです。
Windows11＋wsl2で構築しています。

発端

なんかけっこう長くやってる気がするんですが、動くコマンドはechoの一つだけという現状。とってもさみしいです。ここはコマンドを増やしたいところ。
ファイルシステムまわりのプログラムの勉強と修行を兼ねてlsなんかはどうだろうか、とか思うわけです。

ルートディレクトリのLBAは保存してあるし、ディレクトリエントリをファイル名でサーチする処理はファイルロードで作ったし、ちょっと流用すればできそうな気がするんです。

ええと、ルートディレクトリをバッファに読み込んで……
バッファのサイズはどうしよう……
位置はどこにあればいいんだろう……
ほかの処理とかち合わないようにしないと……
ええと、ええと、ええと……

えぇい！面倒くさい！使い捨てのバッファなんか、いちいち細かいところなんか考えてられるかっ！！

というわけでメモリ・アロケータを作成することになるのでした。

仕様っぽなにか

もうね、使えるメモリは全部対象にしてしまおうと思うんです。面倒くさいので。
0x10000～0xA0000までをアプリケーションエリアとしているので、ここが対象です。

管理はビットマップで行きましょう。対象が（今どきのメモリサイズと比べて）大きくないので、それほどエリアコストになりません。

ページサイズは4KByteで。4KByteは大きすぎる気もしますが（今どきのメモリと比べれば）大した問題にならないでしょう

ビットマップそのものは最初のユーザーとしましょう。対象の1ページ目はビットマップスペースです。

システムコールで取得、解放できるように。

ビットマップのビットが使えるかどうかのテスト、そしてセットとクリアはマクロにします。処理が小さいこと、呼び出しコストがもったいないことを考慮しました。

厳密な排他処理は考慮しません。所詮はシングルタスク、シングルユーザのシステムですし。

こんなもんでしょうか。

マクロ

マップのビットが立っているかどうかを確認するマクロはこんな感じです。
bxで指定したbitの内容を8bitレジスタに返します。

%macro BIT_TEST 1
    push cx
    mov di, bx
    shr di, 3
    mov al, [es:di]
    mov cl, bl
    and cl, 7
    shr al, cl
    and al, 1
    mov %1, al
    pop cx
%endmacro

bitをセットするマクロです。bxで指定されたbitをセットします。

%macro BIT_SET 0
    push cx
    mov di, bx
    shr di, 3
    mov al, [es:di]
    mov cl, bl
    and cl, 7
    mov ah, 1
    shl ah, cl
    or  al, ah
    mov [es:di], al
    pop cx
%endmacro

bitをクリアするマクロはこう。bxで指定されたbitをクリアします。

%macro BIT_CLR 0
    push cx
    mov di, bx
    shr di, 3
    mov al, [es:di]
    mov cl, bl
    and cl, 7
    mov ah, 1
    shl ah, cl
    not ah
    and al, ah
    mov [es:di], al
    pop cx
%endmacro

初期化・アロケート・フリー

初期化はこうなります。何はともあれまず最初にこれを実行します。
自分自身の登録もしています。

; ---------------------------------
; page_init
; DX:AX = managed_end physical address
; ---------------------------------
page_init:
    push ax
    push dx
    push bx
    push cx
    push di
    push es

    mov bx, MANAGED_SEG
    mov [cs:bitmap_seg], bx
    mov es, bx

    and ax, 0xF000

    mov [cs:g_managed_end], ax
    mov [cs:g_managed_end+2], dx

    mov bx, dx
    shl bx, 4
    mov cx, ax
    shr cx, 12
    or  bx, cx

    sub bx, MANAGED_BASE_PAGE
    mov [cs:g_num_pages], bx

    mov cx, bx
    add cx, 7
    shr cx, 3

    xor di, di
.clear:
    mov byte [es:di], 0
    inc di
    loop .clear

    mov si, [MHS_OFF]
    mov ax, [si + MHS.cnt]
    cmp ax, 0
    je .free_skip
    mov cx, ax
.free_loop:
    mov bx, cx
    shl bx, 1
    mov ax, [si + MHS.AXs + bx] 
    mov dx, [si + MHS.DXs + bx]
    mov bx, ax
    shl dx, 12
    mov ah, svc_page_free
    int 0x80
    loop .free_loop
.free_skip:

    xor bx, bx
    BIT_SET

    xor ax, ax
    mov [cs:g_scan_hint], ax

    pop es
    pop di
    pop cx
    pop bx
    pop dx
    pop ax
    ret

アロケート処理です。失敗するとdx:axが０、Cフラグが立ちます。

; ---------------------------------
; page_alloc
; ---------------------------------
page_alloc:
    push bx
    push cx
    push di
    push es

    mov ax, [cs:bitmap_seg]
    mov es, ax

    mov bx, [cs:g_scan_hint]
    mov cx, [cs:g_num_pages]

.scan1:
    cmp bx, cx
    jae .scan2

    BIT_TEST al
    cmp al, 0
    jne .next1

    BIT_SET

    mov ax, bx
    inc ax
    mov [cs:g_scan_hint], ax

    mov ax, bx
    add ax, MANAGED_BASE_PAGE

    mov dx, ax
    shl ax, 12
    shr dx, 4
    jmp .ok

.next1:
    inc bx
    jmp .scan1

.scan2:
    xor bx, bx

.scan2_loop:
    cmp bx, [cs:g_scan_hint]
    jae .fail

    BIT_TEST al
    cmp al, 0
    jne .next2

    BIT_SET

    mov ax, bx
    inc ax
    mov [cs:g_scan_hint], ax

    mov ax, bx
    add ax, MANAGED_BASE_PAGE

    mov dx, ax
    shl ax, 12
    shr dx, 4
    clc
    jmp .ok

.next2:
    inc bx
    jmp .scan2_loop

.fail:
    xor ax, ax
    xor dx, dx
    stc

.ok:
    pop es
    pop di
    pop cx
    pop bx
    ret

フリー処理です。失敗するとaxに１、Cフラグが立ちます。

; ---------------------------------
; page_free
; 入力：DX:BX = ページ先頭物理アドレス 
; 出力：AX=0 成功 / AX!=0 エラー
; ---------------------------------
page_free:
    push bx
    push cx
    push di
    push es

    mov si, bx              ; BXを保存（AXの代わり）

    mov ax, [cs:bitmap_seg]
    mov es, ax

    ; range check: addr >= 0x0001:0000 (0x10000)
    cmp dx, 0x0001
    jb  .err
    jne .chk_align
    cmp si, 0x0000
    jb  .err

.chk_align:
    ; 4KB align check: low 12 bits must be 0
    test si, 0x0FFF
    jnz .err

    ; page_num = addr >> 12 = (DX<<4) | (BX>>12)
    mov bx, dx
    shl bx, 4
    mov cx, si
    shr cx, 12
    or  bx, cx              ; BX = page_num (absolute)

    ; index = page_num - MANAGED_BASE_PAGE
    sub bx, MANAGED_BASE_PAGE

    ; index 0 is reserved
    cmp bx, 0
    je  .err

    ; index < num_pages ?
    cmp bx, [cs:g_num_pages]
    jae .err

    ; double-free check: must be allocated
    BIT_TEST al
    cmp al, 1
    jne .err

    BIT_CLR
    xor ax, ax
    clc
    jmp .ok

.err:
    mov ax, 1
    stc

.ok:
    pop es
    pop di
    pop cx
    pop bx
    ret

定数、変数はこうです。

PAGE_SHIFT        equ 12
PAGE_SIZE         equ (1 << PAGE_SHIFT)

MANAGED_BASE      equ 0x10000
MANAGED_BASE_PAGE equ (MANAGED_BASE >> PAGE_SHIFT)   ; = 0x10
MANAGED_SEG       equ (MANAGED_BASE >> 4)            ; = 0x1000

; ---- globals (Monitor常駐) ----
g_managed_end  dd 0
g_num_pages    dw 0
g_scan_hint    dw 0
bitmap_seg     dw 0

おわりに

既存のloadappにも組み込みました。monitorが動かないとシステムコールが使えないので、boot1から呼ばれたのかTTSから呼ばれたのかフラグで判定しました。
これでこれからは配置とか気にせずにメモリを使うことができます。

このソースはgithubで公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-08-alloc

今更ですがalloct.asmはテスト用のドライバアプリです。TTSがコマンド待ちになったら『alloct』と打ち込めば実行されます。

《2026/01/21 22:03:47》

x86リアルモードでモニターを作ろうシリーズです。
Windows11＋wsl2で構築しています。

前回は 1桁除算（A ÷ digit） まで実装しました。
今回はその続きで、多桁 ÷ 多桁 に進みます。

ただし、最初に言っておきます。

今回の除算は「商を推定しません」。

なぜ推定しないのか

多桁除算というと、

• 上位桁から商を推定
• 掛けて引いて
• 外れたら修正

という方法がよく紹介されます。

でも、今回扱っているのは 10進・1桁=0..9 の BCD です。
つまり、1桁の商は 最大でも 9。

ならば、

引けるだけ引いて、その回数を数えればいい

という、極めて単純な方法が使えます。

• 推定が不要
• 外れも存在しない
• 最大でも 9 回で確定

リアルモードで事故らせないなら、こちらの方が安全です。

基本方針（再確認）

今回の多桁除算は、以下の前提で実装しています。

• 計算はすべて 絶対値
• 符号は外側で処理
• DHS（unpacked BCD）で演算
• 商は 上位桁から1桁ずつ確定

やっていることは、完全に小学校の筆算です。

除算の流れ（全体像）

1. 余り R を 0 で初期化
2. 被除数の最上位桁から順に
   • R = R × 10
   • R = R + a[i]
3. R >= 除数 B の間
   • R -= B
   • 商の桁を +1
4. 商の1桁が確定
5. 次の桁へ

この 2～4 を桁数分繰り返します。

実装の核心部分

    ; R = R * 10
    mov si, bx
    call dhs_mul10

    ; R += a[i]
    mov al, [si + DHS_VAL + cx]
    call dhs_add_digit

    ; q_digit = 0
    mov byte [tmp_div_qdigit], 0
    mov byte [tmp_div_guard], 10   ; 0..9 を超えない安全装置

.try_sub:
    dec byte [tmp_div_guard]
    jz .store_qdigit

    ; if R < B then break
    mov bp, [dhs_div_b_local]
    mov si, bx
    call dhs_cmp_abs
    jc .store_qdigit

    ; R -= B
    mov bp, [dhs_div_b_local]
    mov si, bx
    mov di, dhs_div_tmp
    call dhs_sub_abs

    mov si, dhs_div_tmp
    mov di, bx
    call dhs_copy

    inc byte [tmp_div_qdigit]
    jmp .try_sub

このループは、

• 比較
• 引き算
• 回数を数える

だけ。

tmp_div_guard について

mov byte [tmp_div_guard], 10

これは「保険」です。

• 10進1桁なので、最大でも 9 回
• バグって無限ループになるのを防ぐ

実装中に自分を救ってくれるタイプのコードです。

この方法の良いところ

• 実装が単純
• フラグとレジスタの破壊が追いやすい
• normalize のタイミングが明確
• デバッグしやすい

速度は速くありませんが、
リアルモードでは 正しく終わることの方が重要 です。

実際に動かしてみると

• 小さい数でも
• 桁数が多くても
• 同じ流れで処理できる

という、非常に素直な挙動になります。

「計算している感」がちゃんとあります。

ここまで来て思うこと

add / sub / mul / div が揃ったことで、
ようやく 10進整数を「普通に扱える」状態 になりました。

64bit に収まらない数を
無理に 2 進で扱わなくていい、というのは気が楽です。

おわりに

これで10進20桁の演算ができるようになりました。40桁にしようと思えば簡単にできます。それにしても……

いったいわたしは何を目指しているのでしょう？？？

自分でもわからなくなってきました。

今回はここまでです。
読んでいただきありがとうございました。

このソースはgithubで公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-07-digit

《2026/1/13 16:01:21》

x86リアルモードでモニターを作ろうシリーズです。Windows11＋wsl2で構築しています。

前回は BCD ライブラリを「導入しただけ」で終わりました。
おなか一杯とか言って終わりにしました。

……が、さすがに導入だけで終わると「で、何ができるの？」というお話になるので、今回は 計算のコア をやります。

やることは単純で、

• PHS（packed） ⇄ DHS（unpacked）
• 計算は DHS で筆算
• 最後に PHS に戻す

という流れ。前回の変換関数（pack/unpack）はそのまま使います。

方針：符号つき四則演算は “絶対値” に落として処理する

BCD筆算は「桁列」を扱うので、符号まで混ぜると面倒になります。
なので基本方針はこれ。

1. 符号だけ先に剥がす（signを別に持つ）
2. 絶対値で add/sub/mul/div
3. 最後に 符号を付け直す

これをやるだけで、気持ちがだいぶ楽になります。

まずは比較：cmp_abs（絶対値比較）

加減算は「どっちが大きい？」がないと破綻します。
DHS は 下位桁が index 0 の “リトルエンディアン桁列” として扱うことにします（0桁目が1の位）。

; ----------------------------------------
; dhs_cmp_abs
;   絶対値比較
; 入力:
;   DS:SI = DHS A
;   ES:DI = DHS B
; 出力:
;   AX = 1 (A>B), 0 (A==B), -1 (A<B)
; 破壊: BX,CX,DX
; ----------------------------------------
dhs_cmp_abs:
    ; 桁数で先に判定
    mov cx, [si + DHS_LEN]
    mov dx, [es:di + DHS_LEN]
    cmp cx, dx
    ja  .a_gt
    jb  .a_lt

    ; 同じ桁数なら最上位桁から比較
    test cx, cx
    jz .eq

    dec cx                 ; cx = last index
.loop:
    mov al, [si + DHS_VAL + cx]
    mov bl, [es:di + DHS_VAL + cx]
    cmp al, bl
    ja  .a_gt
    jb  .a_lt
    test cx, cx
    jz  .eq
    dec cx
    jmp .loop

.a_gt:
    mov ax, 1
    ret
.a_lt:
    mov ax, -1
    ret
.eq:
    xor ax, ax
    ret

絶対値加算：add_abs（桁上がりだけ）

これは筆算なので素直です。
A+B を計算して、carry を次桁へ。

; ----------------------------------------
; dhs_add_abs
;   C = |A| + |B|
; 入力:
;   DS:SI = DHS A
;   ES:DI = DHS B
;   SS:BP = DHS C (出力)
; 破壊: AX,BX,CX,DX
; ----------------------------------------
dhs_add_abs:
    ; c を 0 クリア（val 40 / len / sign）
    ; （クリア関数は省略。前回同様にベタループでOK）

    ; maxlen = max(a.len, b.len)
    mov cx, [si + DHS_LEN]
    mov dx, [es:di + DHS_LEN]
    cmp cx, dx
    jae .len_ok
    mov cx, dx
.len_ok:

    xor bx, bx            ; i=0
    xor dl, dl            ; carry=0
.loop:
    cmp bx, cx
    jae .done_digits

    mov al, [si + DHS_VAL + bx]
    add al, [es:di + DHS_VAL + bx]
    add al, dl            ; +carry

    ; al は 0..19 くらいになる
    cmp al, 10
    jb  .no_carry
    sub al, 10
    mov dl, 1
    jmp .store
.no_carry:
    xor dl, dl

.store:
    mov [ss:bp + DHS_VAL + bx], al
    inc bx
    jmp .loop

.done_digits:
    ; 最後に carry が残ったら 1 桁追加
    test dl, dl
    jz .set_len
    mov [ss:bp + DHS_VAL + bx], dl
    inc bx

.set_len:
    mov [ss:bp + DHS_LEN], bx
    ret

絶対値減算：sub_abs（借りだけ）

A-B（ただし |A|>=|B| を前提）です。

; ----------------------------------------
; dhs_sub_abs
;   C = |A| - |B|  (|A|>=|B|)
; 入力:
;   DS:SI = DHS A
;   ES:DI = DHS B
;   SS:BP = DHS C
; ----------------------------------------
dhs_sub_abs:
    mov cx, [si + DHS_LEN]    ; a.len
    xor bx, bx                ; i
    xor dl, dl                ; borrow=0

.loop:
    cmp bx, cx
    jae .finish

    mov al, [si + DHS_VAL + bx]
    sub al, dl                ; -borrow
    mov dl, 0

    mov ah, [es:di + DHS_VAL + bx]
    cmp al, ah
    jae .ok
    add al, 10
    mov dl, 1                 ; borrow
.ok:
    sub al, ah
    mov [ss:bp + DHS_VAL + bx], al
    inc bx
    jmp .loop

.finish:
    mov [ss:bp + DHS_LEN], cx

    ; 正規化（上位 0 を削る）
    ; → 前回の phs_normalize 相当を DHS でもやる
    ; （ここでは dhs_normalize を呼ぶことにする）
    mov si, bp
    call dhs_normalize
    ret

ここで “符号つき add/sub” を組む

符号の組み合わせは結局こうです。

• same sign：絶対値加算、符号はそのまま
• different sign：大きい方から小さい方を引いて、符号は“大きい方”

これで 符号付き加算 ができます。

; ----------------------------------------
; phs_add
;   PHS A + PHS B -> PHS C
; 入力: DS:SI=A, ES:DI=B, SS:BP=C
; ----------------------------------------
phs_add:
    ; A,B を unpack して DHS に
    ; work_dhs_a / work_dhs_b / work_dhs_c を使う（固定領域）

    ; sign が同じ？
    mov al, [si + PHS_SIGN]
    mov bl, [es:di + PHS_SIGN]
    cmp al, bl
    jne .diff

.same:
    ; c = |a| + |b|, sign = a.sign
    ; dhs_add_abs(...)
    ; c.sign = al
    jmp .pack

.diff:
    ; |a| と |b| を比較
    ; 大きい方 - 小さい方
    ; c.sign = big.sign
    ; （cmp_abs → sub_abs の順）

.pack:
    ; DHS -> PHS pack
    ret

（この辺は “書くのは面倒だけど考え方は小学生とか中学生なので、コードの全体は github に置くことにします）

乗算：まずは「1桁 × 多桁」（mul_digit）

いきなり多桁×多桁をやると泣くので、最初はこれ。

• C = A * digit（0..9）

; ----------------------------------------
; dhs_mul_digit
;   C = |A| * digit(0..9)
; 入力: DS:SI=A, AL=digit, SS:BP=C
; ----------------------------------------
dhs_mul_digit:
    mov cx, [si + DHS_LEN]
    xor bx, bx
    xor dl, dl            ; carry=0
.loop:
    cmp bx, cx
    jae .finish

    mov ah, [si + DHS_VAL + bx]
    ; ax = ah * digit + carry
    ; ここで8bit mulを使う（AL=digit, AH=digit?）ので、適当に退避する
    ; 実装は各自の流儀で（私は泥臭くやります）

    ; 結果を 10 で割って carry と digit を作る
    ; （div は 16bit で余裕）
    inc bx
    jmp .loop

.finish:
    ; carry が残ったら append
    ret

この mul_digit ができると、次は「筆算の掛け算」がそのまま書けます。
（つまり “各桁の mul_digit をずらしながら足す”）

除算：今回は 割り算の入口だけ（div_digit）

本当は除算まで行きたいところですが、除算は一気に面倒になります。
なので今回は入口として、

• A ÷ digit（0..9）で 商と余り

を作って終わります。
これがあると「10進→2進」「2進→10進」の補助にも使えて便利です。
上位桁から順に余りを *10 倍して足し、割り算を行う筆算そのままの流れで商を構築します。

; ----------------------------------------
; dhs_div_digit
;   C = |A| / digit
;   R = remainder
;
; 入力:
;   DS:SI = DHS A
;   AL    = digit (1..9)   ※0は呼ぶ側で弾く
;   SS:BP = DHS C (商)
;
; 出力:
;   AH = remainder (0..digit-1)
;
; 破壊:
;   BX,CX,DX
; ----------------------------------------
dhs_div_digit:
    mov cx, [si + DHS_LEN]    ; 桁数
    xor dx, dx                ; remainder = 0
    xor bx, bx                ; i = 0

    ; 商の長さは一旦 A.len にしておく
    mov [ss:bp + DHS_LEN], cx

    test cx, cx
    jz .zero                  ; A==0

    dec cx                    ; 最上位桁 index

.loop:
    ; dx = remainder * 10 + current_digit
    mov dl, 10
    mul dl                    ; AX = remainder * 10
    mov dl, [si + DHS_VAL + cx]
    add al, dl                ; AX = remainder*10 + digit

    ; AX / digit
    div byte [digit_tmp]      ; AL=quotient, AH=remainder

    ; 商の桁を書き込む（同じ位置）
    mov [ss:bp + DHS_VAL + cx], al

    ; remainder は AH に残る
    mov dl, ah

    test cx, cx
    jz .done
    dec cx
    jmp .loop

.done:
    mov ah, dl                ; remainder を返す
    ; 上位0桁を削る
    mov si, bp
    call dhs_normalize
    ret

.zero:
    xor ah, ah
    ret

実行できること

この段階でできることは、

• 符号つき加算／減算（PHS）
• 1桁乗算（DHS）
• 1桁除算（DHS）

です。

「64bitが欲しい」から始まったのに、気づいたら 10進20桁 を手に入れつつあります。
現代の感覚だと遠回りすぎますが、リアルモードだとこれが近道です。たぶん。

そんなこんなで

まだ “おなか一杯” にはなってません。
むしろ、ここからが地獄です。

次回は多分、

• 多桁×多桁（筆算の掛け算）
• 正規化の地獄（len と leading zero）
• そして、みんな大好き「ゼロの符号問題」

あたりをやります。やる……はず。

今回はここまでです。お付き合いいただきありがとうございました。

《2026/1/13 12:32:06》

x86リアルモードでモニターを作ろうシリーズです。Windows11＋wsl2で構築しています。

皆さんは開発していて整数が足りないと思ったことはないでしょうか？
ない？
そうですか。16Bitリアルモードで開発している変態誰かさんとは違いますか……

気を取り直して。
そう、16ビットのレジスタひとつで扱えるのは、たかだか 65,535 まで。32ビットに拡張したところで、42億。十分大きく見えるけれど、 現代の感覚からすればちょっとした統計計算や、少し精度の高い固定小数点演算で、あっという間にその壁にぶつかってしまいます。

これを何とかしたかった。選択肢として32bitライブラリを自作するってのがあるんですがテクニカルでめんどいうえ桁数も先に述べた通り十分じゃない。んじゃ、64Bitライブラリはといえば輪をかけてめんどいという。
小学生でもわかる簡単な方法で何とかならないものか？

あるんですね、これが。その方法とは『筆算』と呼ばれます。で、64Bitで表現できる10進20桁の筆算ライブラリを作ってみようと思うわけです。

今回、Hyfaxに導入することにしたのが BCD（二進化十進表現） ライブラリです。桁数さえ確保すれば「無限」に近い精度を扱えるBCDです。64Bitどころか128Bitだって怖くはないのです。処理時間さえ気にしなければ。

実装の裏側：PHSとDHS、I64HS

今回のライブラリでは、2つのデータ構造を使い分けています。

1. PHS (Packed Handle Structure): メモリ効率を重視した形式。1バイトに2桁を詰め込みます。20桁の数値を10バイト程度で保持できる、いわば「保存用」の姿です。
2. DHS (Digit Handle Structure): 計算効率を重視した形式。1バイトに1桁を贅沢に使い、内部的な演算（加減乗除）はこの形で行います。
3. I64HS (Integer 64 Handle Structure): いわゆる64Bitバイナリです。外部とのやり取りはこの形式になります。

構造としてはこうですね。

;===============================
; Paced Handle Structure
;===============================
struc PHS
    .val    resb 20    ; packed BCD value (最大20桁)
    .len    resw 1     ; 有効桁数
    .sign   resb 1     ; 0=正, 1=負
endstruc

;===============================
; Digit Handle Structure
;===============================
struc DHS
    .val    resb 40    ; unpacked BCD value (最大40桁)
    .len    resw 1     ; 有効桁数
    .sign   resb 1     ; 0=正, 1=負
endstruc

;===============================
; Int 64 Handle Structure
;===============================
struc I64HS
    .LowLow     resw 1      ; bits 0-15
    .LowHigh    resw 1      ; bits 16-31
    .HighLow    resw 1      ; bits 32-47
    .HighHigh   resw 1      ; bits 48-63
endstruc

相互変換

まず最初に、I64HSを扱うユーティリティ、I64HSをPHSに変換する処理、PHSをDHSと相互変換する処理を作ります。

I64HS関連処理

I64HS構造体を0クリアする処理です。

; ----------------------------------------
; clear_i64hs
;   64ビット値を0クリアする
; 入力:
;   DS:SI = I64HS構造体
; 出力:
;   DS:SI = クリアした値
; 破壊:
;   AX
; ----------------------------------------
clear_i64hs:
    push ax
    push di

    xor ax, ax
    mov [di + I64HS.LowHigh], ax
    mov [di + I64HS.HighLow], ax
    mov [di + I64HS.HighHigh], ax

    pop di
    pop ax
    ret

I64HS構造体を2の補数表現にする処理です。

; ----------------------------------------
; i64_negate
;   64ビット値の2の補数を取る (符号反転)
; 入力:
;   DS:DI = I64HS構造体
; 出力:
;   DS:DI = 反転後の値
; 破壊:
;   AX
; ----------------------------------------
i64_negate:
    push bx
    push cx
    
    ; ビット反転 (NOT)
    mov bx, si
    mov cx, 4
.not_loop:
    mov ax, [bx]
    not ax
    mov [bx], ax
    add bx, 2
    loop .not_loop
    
    ; +1 (加算)
    mov bx, si
    mov ax, [bx + I64HS.LowLow]
    add ax, 1
    mov [bx + I64HS.LowLow], ax
    
    mov ax, [bx + I64HS.LowHigh]
    adc ax, 0
    mov [bx + I64HS.LowHigh], ax
    
    mov ax, [bx + I64HS.HighLow]
    adc ax, 0
    mov [bx + I64HS.HighLow], ax
    
    mov ax, [bx + I64HS.HighHigh]
    adc ax, 0
    mov [bx + I64HS.HighHigh], ax
    
    pop cx
    pop bx
    ret

I64HSからPHSに変換する処理です。

; -------------------------------------------------
; phs_from_i64
;   符号付き I64HS → PHS (pac BCD)
; 入力:
;   DS:SI = I64HS
;   ES:DI = PHS
; -------------------------------------------------
; PHS_VAL  = packed BCD(絶対値)
; PHS_LEN  = 桁数(10進)
; PHS_SIGN = 符号
phs_from_i64:
    push ax
    push bx
    push cx
    push dx
    push si
    push di

    mov bp, di              ; BP = PHS ptr を保持(DIが途中で壊れるので)

    ; -----------------------------
    ; 符号判定(入力は破壊しない:work_areaへコピーしてから)
    ; -----------------------------
    ; work_area = 入力コピー
    push si
    push di
    mov di, work_area
    mov cx, 4
.copy_in:
    mov ax, [si]
    mov [di], ax
    add si, 2
    add di, 2
    loop .copy_in
    pop di
    pop si

    ; work_area の符号で判定
    mov si, work_area
    mov ax, [si + I64HS.HighHigh]
    test ax, 0x8000
    jz .positive

    mov byte [es:bp + PHS_SIGN], 1
    call i64_negate          ; work_area を絶対値化
    jmp .sign_done
.positive:
    mov byte [es:bp + PHS_SIGN], 0
.sign_done:
    ; ---- zero normalization ----
    mov ax, [si + I64HS.LowLow]
    or  ax, [si + I64HS.LowHigh]
    or  ax, [si + I64HS.HighLow]
    or  ax, [si + I64HS.HighHigh]
    jnz .nz

    ; value == 0 → force +0
    mov byte [es:bp + PHS_SIGN], 0

.nz:

    ; -----------------------------
    ; PHS_VAL クリア
    ; -----------------------------
    lea bx, [ds:bp + PHS_VAL]
    xor ax, ax
    mov cx, 20
.clear_val:
    mov [es:bx], al
    inc bx
    loop .clear_val

    ; -----------------------------
    ; double dabble(64回)
    ;   DS:SI = work_area 固定
    ;   ES:DI = BCD base
    ; -----------------------------
    mov si, work_area
    lea di, [ds:bp + PHS_VAL]   ; 先頭10バイトだけ使う(20桁=10バイト)
    mov cx, 64
.dd_loop:
    push cx
    mov cx, 10
    call bcd_add3
    pop cx

    call i64_shl1

    push cx
    mov cx, 10
    call bcd_shl1
    pop cx

    loop .dd_loop

    ; -----------------------------
    ; len 算出(MSB → LSB)
    ; -----------------------------
    mov di, bp              ; di = PHS base

    mov dx, 19              ; 最大桁 index(0..19)
.len_scan:
    mov bx, dx
    shr bx, 1           ; byte index

    mov al, [es:di + PHS_VAL + bx]
    test dl, 1
    jz  .low
    shr al, 4            ; 奇数桁 → high nibble
    jmp .chk
.low:
    and al, 0x0F         ; 偶数桁 → low nibble
.chk:
    cmp al, 0
    jne .found

    dec dx
    jns .len_scan

    ; 全部 0 の場合 → PHS規約: len=0, sign=0
    mov word [es:bp + PHS_LEN], 0
    mov byte [es:bp + PHS_SIGN], 0
    jmp .done

.found:
    inc dx               ; index → 桁数
    mov [es:di + PHS_LEN], dx


    ; ---- PHS zero normalization (MUST be last) ----
    mov ax, [es:di + PHS_LEN]
    test ax, ax
    jnz .nz_i64

    ; len == 0 → force +0
    mov byte [es:di + PHS_SIGN], 0

.nz_i64:

.done:
    push ds
    mov ax, ds
    mov ds, ax
    mov si, bp
    call phs_normalize
    pop ds

    ; ---- PHS invariant: len==0 => sign=0 ----
    mov ax, [es:di + PHS_LEN]
    test ax, ax
    jnz .ret_ok
    mov byte [es:di + PHS_SIGN], 0
.ret_ok:

    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    ret

PHS関連処理

PHSを正規化する処理です。

; ===============================
; phs_normalize
;   DS:SI = PHS
;   PHS_LEN を有効桁数に正規化
;   ゼロなら sign=0, len=0 にする
; ===============================

phs_normalize:
    push ax
    push bx
    push cx
    push dx
    push di

    ; cx = len
    mov cx, [si + PHS_LEN]
    test cx, cx
    jnz .check_top

    ; len == 0 → 0(PHS規約)
    mov byte [si + PHS_SIGN], 0
    jmp .done

.check_top:
    ; di = val base
    lea di, [si + PHS_VAL]

.normalize_loop:
    cmp cx, 1
    jbe .check_zero      ; len==1 まで来たら終了候補

    ; top digit index = cx-1
    mov dx, cx
    dec dx

    ; byte index = dx / 2
    mov bx, dx
    shr bx, 1

    mov al, [di + bx]

    ; nibble 選択
    test dl, 1
    jz .low_nib
    shr al, 4
    jmp .chk
.low_nib:
    and al, 0x0F
.chk:
    test al, al
    jne .done_len        ; 非0ならここで終了

    ; 上位 0 桁を捨てる
    dec cx
    jmp .normalize_loop

.done_len:
    mov [si + PHS_LEN], cx
    jmp .done

.check_zero:
    ; len==1 だが digit==0 なら len=0 に
    mov al, [di]
    and al, 0x0F
    test al, al
    jnz .done_len

    mov word [si + PHS_LEN], 0
    mov byte [si + PHS_SIGN], 0

.done:
    pop di
    pop dx
    pop cx
    pop bx
    pop ax
    ret

PHSをDHSに変換する処理です。

;--------------------------------------------------
; phs_unpack
;   SI = PHS*
;   DI = DHS*
; destroys: AX,BX,CX,DX
;--------------------------------------------------
phs_unpack:
    ; ---- copy len / sign ----
    mov ax, [si + PHS_LEN]
    mov [di + DHS_LEN], ax

    mov al, [si + PHS_SIGN]
    mov [di + DHS_SIGN], al

    ; ---- clear DHS_VAL (40 bytes) ----
    push si
    push di
    lea bx, [di + DHS_VAL]
    mov cx, 40
    xor ax, ax
.clr:
    mov [bx], al
    inc bx
    loop .clr
    pop di
    pop si

    ; ---- unpack digits ----
    ; BX = digit index (0..len-1)
    xor bx, bx
    mov cx, [si + PHS_LEN]

.loop:
    cmp bx, cx
    jae .done

    ; byte index = bx >> 1
    mov dx, bx
    shr dx, 1

    ; read packed byte
    push bx
    mov bx, dx
    mov al, [si + PHS_VAL + bx]
    pop bx

    ; even digit -> low nibble, odd -> high nibble
    test bl, 1
    jz .low

    ; odd: high nibble
    shr al, 4
    jmp .store

.low:
    ; even: low nibble
    and al, 0x0F

.store:
    mov [di + DHS_VAL + bx], al

    inc bx
    jmp .loop

.done:
    ret

DHSをPHSに変換する処理です。

;--------------------------------------------------
; phs_pack
;   SI = DHS*
;   DI = PHS*
; destroys: AX,BX,CX,DX
;--------------------------------------------------
phs_pack:
    ; ---- copy len / sign ----
    mov ax, [si + DHS_LEN]
    mov [di + PHS_LEN], ax

    mov al, [si + DHS_SIGN]
    mov [di + PHS_SIGN], al

    ; ---- clear PHS_VAL (20 bytes) ----
    push si
    push di
    lea bx, [di + PHS_VAL]
    mov cx, 20
    xor ax, ax
.clr:
    mov [bx], al
    inc bx
    loop .clr
    pop di
    pop si

    ; ---- pack digits ----
    ; BX = digit index (0..len-1)
    xor bx, bx
    mov cx, [si + DHS_LEN]

.loop:
    cmp bx, cx
    jae .done

    ; get digit (0..9)
    mov al, [si + DHS_VAL + bx]
    and al, 0x0F

    ; byte index = bx >> 1
    mov dx, bx
    shr dx, 1

    ; read current packed byte
    push bx
    mov bx, dx
    mov ah, [di + PHS_VAL + bx]
    pop bx

    ; even digit -> low nibble, odd -> high nibble
    test bl, 1
    jz .low

    ; odd: high nibble
    shl al, 4
    and ah, 0x0F          ; keep low nibble
    or  ah, al
    push bx
    mov bx, dx
    mov [di + PHS_VAL + bx], ah
    pop bx
    jmp .next

.low:
    ; even: low nibble
    and ah, 0xF0          ; keep high nibble
    or  ah, al
    push bx
    mov bx, dx
    mov [di + PHS_VAL + bx], ah
    pop bx

.next:
    inc bx
    jmp .loop

.done:
    ; normalize to ensure zero has sign=0
    push si
    mov si, di
    call phs_normalize
    pop si
    ret

はい。おなか一杯になりました。

導入だけになってしまいましたが、今回はここまでにします。
次回以降、どうなるんでしょう。不安です。

《2026/1/12 01:41:24》

x86リアルモードでモニターを作ろうシリーズです。Windows11＋wsl2で構築しています。

キーボードをタイプしてプログラムを起動できるようになりました。そこでコマンドを作ってみようと思います。定番ではあるものの作るコマンドはechoです。与えられた引数を表示するだけのプログラムですね。実用性はともかく、引数を受け取ってそれを操作する基本を押さえるのに重宝するプログラムです。

処理の概要

今回作るまで知らなかったのですが例えば『echo aaa bbb』とか打ち込むと途中の複数の空白を一つにまとめて『aaa bbb』と表示されるのですね。何のことはない、コマンド自体をsplitでパースして、コマンド自体を除いた引数部分を順に表示するという仕様なわけです。

ということであれば、もうsplitはできているわけで、コマンド部分を読み取り、それを実行し、コマンド内では引数部分を列挙表示すればよいということです。これならすぐできそうです。

実際の実行イメージはこんな感じでしょうか

    mov bx, [app_arg_data]
    
    ; APPを実行
    jmp APP_SEG:APP_OFF

レジスタはどれでもよかったのですが、axは成功失敗を受け取るために使用していたので、引数はbxで渡しています。bxにsplitした引数を設定して、アプリを実行です。

実際の実行部にあわせて、必要な部分で引数を設定していきます。まず最初はtss.asmですね。抜粋するとこんな感じ。

    ; 入力文字列をパース
    ; DS:SI = 入力文字列
    ; ES:DI = THS 構造体先頭
    ; al    = 区切り文字
    mov si, line_buf
    mov di, line_buf_ths
    mov al, ' '
    call split

    mov bx, di          ; di = line_buf_ths
    mov si, [line_buf_ths]
    mov ah, svc_exec
    int 0x80

コマンドの実行はシステムコールにしています。

で、monitor.asmのsvc_execがこんな感じ。

    ; ★★★ BXを一旦AXに退避 ★★★
    mov ax, bx

    ; ★★★ ここで引数を monitor のグローバル変数に保存 ★★★
    pop ax                      ; 退避していたAXの値
    mov [app_arg_data], ax

    ; --- 83形式に変換 (DSはMON_SEGのままでOK) ---
    call to_83

    ; --- 実行 ---
    mov ax, file_name
    call runapp
    mov [.exit_code], ax

都合、loadapp.asm、monitor.asm、tts.asmの3つを変更しています。

echo本体

echo本体は引数を受け取って順次表示するだけです。こんな感じ。

; echo.asm - simple and working version
BITS 16

%include 'hyfax.asm'

%macro PUTC 1
    push ax
    mov al, %1
    out 0xE9, al
    pop ax
%endmacro

start:
    PUTC 'E'
    PUTC ':'

    ; ★★★ BXを先にDIに退避 ★★★
    mov di, bx

    ; --- 通常の初期化 ---
    push cs
    pop  ds
    push cs
    pop  es
    push cs
    pop  ss
    mov  sp, 0xfffe
    
    ; ★★★ ths_offsetに保存 ★★★
    mov [ths_offset], di

    ; ; メッセージ表示
    ; mov si, msg_hello
    ; mov ah, svc_write
    ; int 0x80
    ; mov ah, svc_newline
    ; int 0x80

    ; TTS_SEGから引数の数を取得
    mov ax, TTS_SEG
    mov es, ax
    mov di, [ths_offset]
    mov cx, es:[di + THS.cnt]
    
    ; デバッグ: 引数の数を表示
    ; mov si, msg_cnt
    ; mov ah, svc_write
    ; int 0x80
    ; mov bx, cx
    ; mov ah, svc_puthex
    ; int 0x80
    ; mov ah, svc_newline
    ; int 0x80
    
    ; 引数が2つ以下（コマンド名のみ）なら何も表示しない
    cmp cx, 2
    jl .no_args
    
    ; 全ての引数を表示（1番目から）
    mov word [current_index], 1

.loop:
    ; 現在のインデックスを取得
    mov si, [current_index]
    
    ; 終了判定
    mov ax, TTS_SEG
    mov es, ax
    mov di, [ths_offset]
    cmp si, es:[di + THS.cnt]
    jge .done
    
    ; デバッグ: インデックスを表示
    ; mov si, msg_idx
    ; mov ah, svc_write
    ; int 0x80
    ; mov bx, [current_index]
    ; mov ah, svc_puthex
    ; int 0x80
    ; mov al, ':'
    ; mov ah, svc_putchar
    ; int 0x80
    
    ; 引数のオフセットを取得
    mov si, [current_index]
    mov bx, si
    shl bx, 1
    add bx, THS.off
    mov bx, es:[di + bx]        ; BX = 文字列のオフセット（TTS_SEG内）
    
    ; デバッグ: オフセットを表示
    ; push ds
    ; push cs
    ; pop ds
    ; mov si, msg_off
    ; mov ah, svc_write
    ; int 0x80
    ; pop ds
    
    ; push bx
    ; mov ah, svc_puthex
    ; int 0x80
    ; mov al, '='
    ; mov ah, svc_putchar
    ; int 0x80
    ; pop bx
    
    ; 文字列を表示（TTS_SEGから）
    mov ax, TTS_SEG
    mov ds, ax
    mov si, bx
    mov ah, svc_write
    int 0x80
    mov ah, svc_putchar
    mov al, ' '
    int 0x80
    
    ; DSを戻す
    push cs
    pop ds
    
    ; 改行を表示
    ; mov ah, svc_newline
    ; int 0x80
    
    ; 次の引数へ
    inc word [current_index]
    jmp .loop

.no_args:
    mov si, msg_no_args
    mov ah, svc_write
    int 0x80

.done:
    mov ah, svc_newline
    int 0x80
    mov ah, svc_newline
    int 0x80
    ; mov si, msg_wait
    ; mov ah, svc_write
    ; int 0x80
    
    ; mov ah, svc_getkey
    ; int 0x80

exit:
    push word TTS_SEG
    push word 0x0000
    retf


%include 'common.asm'

; ---- data ----
msg_hello:        db 'Hello from ECHO', 13, 10, 0
msg_cnt:          db 'Arg count: ', 0
msg_idx:          db 'Index ', 0
msg_off:          db ' offset=', 0
msg_no_args:      db '(no arguments)', 0
msg_wait:         db 13, 10, 'Press any key to return shell...', 13, 10, 0

ths_offset:       dw 0
current_index:    dw 0

times 3072-($-$$) db 0

デバッグ用の表示がそのまま残っていますが、許してください。いつ必要になるかわからない開発中の状況ですんでそのままにしてあります。

実際の実行結果はこうなります。

終わりに

今回はここまでになります。

それにしても、コマンドとか作ってできることが多くなってくるとわくわくしますよね♪

このソースはgithubで公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-05-echo

《2026/01/11 15:38:35》

x86リアルモードでモニターを作ろうシリーズです。
まずshell機能を独立させるかMonitorに取り込むかという問題ですが、shellとして独立させることにしました。そのうえ常駐します。このため、Monitorとほぼ同様のメモリに展開されます。アプリケーションとは完全独立です。
shellはTiny Thin Shell、小さい最低限のシェルということでTSSという名称にしました。

TTS本体

TTSはline_input（1行入力）を行います。
次にパースしたトップの文字列をファイル名とみなしてMonitorに実行依頼をします。
大枠で言うとこれだけです。

start:
    PUTC 'T'
    PUTC ':'

    ; --- COMライク初期化（CS=DS=ES=SS=自分、SP設定） ---
    ; mov ax, 0x1000
    ; mov ds, ax
    push cs
    pop  ds
    push cs
    pop  es
    push cs
    pop  ss
    mov  sp, 0xfffe

    mov bx, ax

    ; --- メッセージ表示 ---
    mov si, msg_hello
    mov ah, svc_write              ; write(DS:SI, CX)
    int 0x80
    mov ah, svc_newline
    int 0x80

    ; 入力バッファの初期化
    mov ax, line_buf
    mov bl, 0
    mov cx, line_buf_size
    call memset


.loop1:
    mov di, line_buf        ; バッファの準備
    call line_input         ; 行入力

    xor cx, cx              ; 0文字なら何もしない
    mov ax, line_buf
    call strlen
    cmp cx, 0
    je .skip

    ; 入力文字列をパース
    ; DS:SI = 入力文字列
    ; ES:DI = THS 構造体先頭
    ; al    = 区切り文字
    mov si, line_buf
    mov di, line_buf_ths
    mov al, ' '
    call split

    ; ファイル名候補を抽出
    mov ax, file_name
    mov bx, [line_buf_ths + THS.off + 0]
    call strcpy   
    
    ; 内部コマンドかどうかを判定
    ; 内部コマンドならそれを実行
    ; 現在は内部コマンドがないので未処理
    
    ; パースした最初がファイル名なのでこれを送る
    mov si, [line_buf_ths]
    mov ah, svc_exec
    int 0x80

    ; エラー判定
    cmp ax, 0
    je .nf_skip2
    push ds
    mov ax, TTS_SEG
    mov ds, ax

    ; エラーならエラーメッセージを表示
    mov si, ._s_msg_nf
    mov ah, svc_write
    int 0x80
    pop ds
.nf_skip2:

    ; バッファのクリア
    mov ax, line_buf        
    mov bl, 0
    mov cx, cx
    call memset

.skip:
    jmp .loop1

split処理

パース処理についてもちょっと触れておきますね。パースとか言ってますけど、内容はsplitです。入力された文字列を空白を区切り文字として複数の文字列に分解するアレです。データ構造はこんな感じ。

;===============================
; Token Handle Structure
;===============================
struc THS
    .off    resw 126   ; 02h オフセット
    .cnt    resw 1     ; 04h Item Num
endstruc

先頭にアドレス配列があり、アイテム数を持っていてこれで管理します。
splitのコードはこちら。

;************************************
; split処理
;************************************
; DS:SI = 入力文字列
; ES:DI = THS 構造体先頭
; al    = 区切り文字
split:
    xor cx, cx                  ; cnt = 0
    lea bx, [di + THS.off]      ; off 配列先頭

.skip:
    cmp byte [si], al
    jne .check
    inc si
    jmp .skip

.check:
    cmp byte [si], 0
    je .done

    mov [bx], si                ; offset 登録
    add bx, 2
    inc cx

.scan:
    cmp byte [si], 0
    je .next
    cmp byte [si], al
    je .cut
    inc si
    jmp .scan

.cut:
    mov byte [si], 0
    inc si

.next:
    jmp .skip

.done:
    mov [di + THS.cnt], cx
    ret

.dlm db 0

83形式編集処理

最後は83形式に変換する関数です。
『APP.BIN』の形式を『APP BIN』の11文字にします。

;************************************
; ドット表記のファイル名を83形式にする
; IN : なし (file_name グローバル変数を直接使用)
; OUT: file_name が 83形式に変換される
;************************************
to_83:
    push bp
    mov bp, sp
    push ax
    push ds
    push es
    push si
    push di
    push bx
    push cx

    ; === 入力文字列(file_name)をCSセグメント内にコピー ===
    mov si, file_name         ; DS:SI = file_name
    push cs
    pop es
    mov di, .input_copy
.copy_in:
    lodsb
    stosb
    test al, al
    jnz .copy_in

    ; === DS/ESをCSに設定してパース実行 ===
    mov ax, cs
    mov ds, ax
    mov es, ax

    mov si, .input_copy
    mov di, file_name_ths
    mov al, '.'
    call split

    ; base/ext 取得
    mov si, [di + THS.off]
    mov [.base], si
    mov si, [di + THS.off + 2]
    mov [.ext], si

    ; === temp_bufを空白で初期化 ===
    mov di, .temp_buf
    mov al, ' '
    mov cx, 11
    rep stosb
    mov byte [di], 0          ; NUL終端

    ; === NAME部分コピー (最大8文字) ===
    mov si, [.base]
    mov di, .temp_buf
    mov cx, 8
.name_loop:
    cmp byte [si], 0
    je .name_done
    movsb
    loop .name_loop
.name_done:

    ; === EXT部分コピー (最大3文字) ===
    mov si, [.ext]
    test si, si               ; NULLチェック
    jz .no_ext
    cmp byte [si], 0          ; 空文字列チェック
    je .no_ext

    mov di, .temp_buf
    add di, 8
    mov cx, 3
.ext_loop:
    cmp byte [si], 0
    je .ext_done
    movsb
    loop .ext_loop
.ext_done:
.no_ext:

     ; === 結果をfile_name(呼び出し元セグメント)にコピー ===
    pop cx                    ; スタックからレジスタ復元開始
    pop bx
    pop di
    pop si
    pop es
    pop ds                    ; DS = 元のセグメント
    pop ax
    
    ; ここでDS = 呼び出し元, ES = CSにする
    mov di, file_name         ; DS:DI = file_name
    
    push cs
    pop es                    ; ES = CSセグメント
    mov si, .temp_buf         ; ES:SI = temp_buf
    
    mov cx, 12                ; 11文字 + NUL
.copy_out:
    mov al, es:[si]           ; CSセグメントから読む
    mov [di], al              ; 呼び出し元セグメントに書く
    inc si
    inc di
    loop .copy_out

    pop bp
    ret

主要な関数は以上になります。
これらをうまく組み込んでTTSは成り立っています。

実行結果図

実行結果はこんな感じになります。

所感

セグメントが辛かったです。かつてセグメントが面倒臭いとか、厄介だとかいろいろ話は聞いていたのですが、思っていたより10倍も面倒くさかったなぁ。
特に文字列が複数セグメントに設置されているような場合、セグメント合わせに多大な時間がかかることがわかりました。

元日そうそう丸一日セグメントと格闘してしまいました。

はい、今日はここまでです。お読みくださりありがとうございました。

このソースはgithubで公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-03-hello-tts

《2026/01/02 06:12:12》

x86リアルモードでMonitorプログラムを作ってみようの、第何回目だっけ？
よくわからなくなってますが、始めます。

一応ね、shellからコマンドを実行するところまで作ってみたんですよ。KBからファイル名を入力すると、そのファイルを実行するっていう感じで。shellの対話環境の基礎的な部分です。でもね、なんか気に入らないという。
実行結果はこんな感じです。

コマンドを打ち込むと内部コマンドならそれを実行（ただし現状では内部コマンドないので処理なし）、違うならファイルを検索して見つけたらロードして遷移です。

ただ記事を書く気にどうしてもなれなかったんですね。もやもやしてて。
構造はこんな感じでした。

①のファイルの実行は仕方ないです。Boot1からMonitorを呼ぶ経路は一つしかないし、クリティカルパスなので外せない。でもね②と③が気に入りません。
まったく同じ機能、ファイルを探して、見つけたら読み込んで、そこに遷移するってのが2か所にある。もやもやもや。

で、結局役割分担を間違えているんじゃないかと思ったわけです。こうなる方がいいんじゃないかと。

shellはコマンドを受け取って最低限の動作をする。ファイルの検索、ロード、遷移はMonitorに任せる。内部コマンドの時だけ自分で実行する。
きれいじゃないですか？

というわけで作り直しです。一応作ってしまったものはもったいないので、懺悔と供養のために公開しちゃいます。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-02-hello-tts-X

作る前にきっちり設計しようね！

というお話でした。

《2026/01/01 3:23:12》

MONITORが動くようになりAPP実行から終了までできるようになりました。でもそれだけです。まだ入力とかもほとんどできません。プログラム名の入力→実行とか出来るようにしたいな～……。

というわけで、まずはshellを目指すのでした。これがないとHyfax君と会話できないし♪
shellといっても超簡易版です。最初ですんで何かキーを押したら反応が返ってくる、それくらいのやつ。

なにはともあれechoの実装

echoから作ります。shellに組み込む前に動作確認ですね。せっかくAPPが動くようになったんで、APP内で作って動作チェックして、それからshellとして取り込みましょう。
ドライバのソースはこれ。

;********************************
; echo確認用ドライバ
;********************************
exp_echo:
.loop:
    mov di, line_buf    ; バッファの準備
    call echo           ; echoの実行

    mov si, line_buf    ; 戻ってきた値を出力
    mov ah, svc_write
    int 0x80

    mov ah, svc_newline ; 後片付け
    int 0x80
    
    mov ax, line_buf    ; バッファのクリア
    mov bl, 0
    mov cx, line_buf_size
    call memset

    jmp .loop

    ret

本体がこちら。

;********************************
; echo
;********************************
; IN : DI = buffer
; OUT: buffer filled, CX = length
; END: buffer is NUL-terminated
; CLOBBER: AX, CX, DI
echo:

.main_loop:

    ; --- ブロッキングで1キー待ち (AH=0x22) ---
    mov ah, svc_getkey  ; getkey_wait() -> AX=ASCII(0含む)
    int 0x80

    cmp al, 0x0d
    je ._0d

    test al, al
    jz .skip_echo
    
    mov al, al
    mov ah, svc_putchar
    int 0x80
    mov [di], al

    inc di
    inc byte [.cnt]

    jmp .main_loop

._0d:

    mov byte [di], 0x00
    xor cx, cx
    mov byte cl, [.cnt]

    cmp cl, 0
    je .skip_echo
    
    mov ah, svc_newline
    int 0x80

.skip_echo:

    ret

.cnt db 0

line_buf: times line_buf_size db 0

実行結果

ちゃんと返ってきてます。これで勝ち確ですよね。アプリ名を入力して、前回作ったapploadに渡せば実行できる流れです。とはいえ今はappに居る関係上、このまま実行するとアドレスが被るんで動かないんでしょうけれども。動かすにはもう少し調整が必要です。（今回はやりません。）

履歴機能とか

コマンド（らしきもの）が入力できるようになると、欲しくなってくるのが履歴機能です。command historyですね。以前打ち込んだ内容を↑キーとか↓キーで表示してくれるやつです。プログラミングの練習がてら上下カーソルキーで文字列を変更するプログラムも書いてみましょう。

実行確認用ドライバのソースはこれ。

;********************************
; 履歴(history)確認用ドライバ
;********************************
exp_history:
.loop3:
    mov di, line_buf
    call history        ; history機能

    jmp .loop3

    ret

本体のソースはこれです。

;********************************
; history
;********************************
history:
.loop4:
    mov ah, svc_getkey  ; getkey_wait() -> AX=ASCII(0含む)
    int 0x80

    test al, al
    jz .ext_key

    cmp al, 0x0d    ; return
    je ._0d
.ext_key:
.up:
    dec byte [hisp]
    js .up_worp
    jmp .exit

.up_worp:
    mov byte [hisp], 3
    jmp .exit

.down:
    inc byte [hisp]
    cmp byte [hisp], 4
    jl  .exit
    mov byte [hisp], 0
    jmp .exit

.exit:    
    cmp byte [.cnt], 0
    je .loop4
    
    xor cx, cx
    mov cl, 79
    call clear_line

    xor ax, ax
    mov al, [hisp]
    mov bx, line_buf_size
    mul bx
    mov si, hibuf
    add si, ax
    mov ah, svc_write
    int 0x80

    mov ah, svc_putchar
    mov al, 0x0d
    int 0x80

    jmp .loop4

._0d:

    ret

実行結果はこちら。

上下キーでone、two、three、fourが切り替わります。

そして1行入力へ

echoとhistoryが形になりました。次にこれを悪魔合体させて1行入力を作りましょう。
例によって確認用ドライバのソースはこれ。

;********************************
; line_input確認用ドライバ
;********************************
exp_line_input:
.loop1:
    mov di, line_buf        ; バッファの準備
    call line_input         ; historyの実行

    xor cx, cx              ; 0文字なら何もしない
    mov ax, line_buf
    call strlen
    cmp cx, 0
    je .skip

    mov si, line_buf        ; バッファの表示
    mov ah, svc_write
    int 0x80

    mov ah, svc_newline     ; 改行
    int 0x80
    
    mov ax, line_buf        ; バッファのクリア
    mov bl, 0
    mov cx, cx
    call memset

.skip:
    jmp .loop1

    ret             ; 無限ループなのでここには来ない

本体のソースはこちら。

;********************************
; line_input
;********************************
line_input:
    mov ax, line_buf
    call strlen
    mov [.cnt], cl

.loop2:
    ; --- ブロッキングで1キー待ち (AH=0x22) ---
    mov ah, svc_getkey  ; getkey_wait() -> AX=ASCII(0含む)
    int 0x80

    ; for debug
    push ax
    mov bx, ax
    mov ah, svc_puthex 
    int 0x80
    pop ax
    
    test al, al
    jz .ext_key

    cmp al, 0x0d    ; return
    je ._0d

    cmp al, 0x08    ; BS
    je ._bs

    cmp al, 0x09    ; tab
    je ._tab

    jmp .ascii

.ext_key:
    cmp ah, 0x48    ; ↑ : History up
    je .up
    cmp ah, 0x50    ; ↓ : History down
    je .down
    jmp .loop2

.ascii:
    ; mov al, al
    mov ah, svc_putchar
    int 0x80
    mov [di], al

    inc di
    inc byte [.cnt]

    jmp .loop2

.up:
    dec byte [hisp]
    js .up_worp
    jmp .exit

.up_worp:
    mov byte [hisp], 3
    jmp .exit

.down:
    inc byte [hisp]
    cmp byte [hisp], 4
    jl  .exit
    mov byte [hisp], 0
    jmp .exit
    
    
.exit:    
    cmp byte [.cnt], 250    ; バッファサイズ上限チェック (250文字まで)
    jae .loop2              ; 上限なら入力を無視してループへ
    
    xor cx, cx
    mov cl, [.cnt]
    call clear_line

    xor ax, ax
    mov al, [hisp]
    mov bx, line_buf_size
    mul bx
    mov si, hibuf
    add si, ax
    mov ah, svc_write
    int 0x80

    mov ax, line_buf
    mov bl, 0
    mov cx, line_buf_size
    call memset
    
    mov ax, line_buf
    mov bx, si
    call strcpy
    mov [.cnt], cl
    mov di, line_buf
    add di, cx        ; CX = strlen

    jmp .loop2

._bs:
    cmp byte [.cnt], 0
    je .loop2
    
    dec byte [.cnt]
    dec di

; 画面上の削除処理 (BS -> 空白 -> BS)
    mov al, 0x08
    mov ah, svc_putchar
    int 0x80                ; カーソル戻す
    
    mov al, ' '
    mov ah, svc_putchar
    int 0x80                ; 空白で文字を消す
    
    mov al, 0x08
    mov ah, svc_putchar
    int 0x80                ; カーソルを再度戻す

    jmp .loop2

._tab:
    ; tabで現在の履歴バッファの内容を反映
    ; 直前のコマンドをリピートしたいときに便利
    jmp .exit

._0d:
    xor ax, ax
    mov al, [hisp]
    mov bx, line_buf_size
    mul bx
    mov si, hibuf
    add si, ax
    mov ax, si
    mov bl, 0
    mov cx, line_buf_size
    call memset

    mov ax, si
    mov bx, line_buf
    call strcpy

    mov ah, svc_newline
    int 0x80
    mov byte [.cnt], 0
    mov di, line_buf
    
    ret


.cnt db 0

hibuf:          ; history buffer
    db 'one',  0, 0, 0
    times 250 db 0
    db 'two',  0, 0, 0
    times 250 db 0
    db 'three',0
    times 250 db 0
    db 'four', 0, 0
    times 250 db 0

hisp: db 0

上下キーで履歴の内容を表示、文字入力可能でエンターキーで確定して戻ります。
戻ったらバッファの内容を表示して文字数、バッファをクリアしています。
実行結果はこちら。

履歴を切り替えてバッファに反映、文字入力をバッファに反映、履歴と文字入力を共にバッファに反映、それぞれできています。
追加機能として,tabキーで現在の履歴を即時反映させます。直前のコマンド表示させるのに上下キーで上って降りてなんてしたくないですから。

（tabが素通しで文字化けしたんで機能を得割り振ったなんてことはないですよ？
本当のところは、どう、なのかですか？
禁則事項です♪）

shellへの遠い道

これで文字列を入力することができるようになります。受け取った文字列をコマンドとして実行したり処理を振り分けたりできるようになるということですね。

現状ではまだ本体に組み込みません。MONIOTRにshell機能を持たせるか、shellとして独立したapp扱いするか決めかねているからです。それによってメモリ配置も考え直す必要があります。今後の宿題ですね。

今回はここまでです。お付き合いありがとうございましたm(_ _)m

この連載の成果物はgithubに公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax-01-long-road-to-shell

《2025/12/28 15:34:41》

x86リアルモードで動くモニタプログラムのHyfaxを作るお話の8回目です。boot0→boot1→monitorとやってきて、monitorに機能を実装しました。今回はmonitorからappをロードし実行する部分です。

アプリのロードと起動

実はアプリのロードと起動って、実を言うともう完成してるって言ってもいいんですよね。そもそも既にあるboot1の機能は

①『MONITOR BIN』をルートディレクトリから探す
②見つかった『MONITOR BIN』をメモリに読み込む
③読み込んだメモリに制御を移す

という処理をやっているわけです。んじゃmonitorは何をするのかというと

①『APP BIN』をルートディレクトリから探す
②見つかった『APP BIN』をメモリに読み込む
③読み込んだメモリに制御を移す

何のことはない、ファイル名が違うだけなんです。（厳密に言うと、読み込むメモリの位置も違うんですが。）そこだけこちょこちょっと変えれば完成してしまうのですね。
ただ、boot1をまるっとコピーして必要な部分だけ修正するのは楽なんですが、例によって「ほとんど同じコードがあちこちに存在する」というのがね。背筋がぞわぞわしてくるので関数化してしまいます。
該当部分をloadapp.asmにくくりだして修正を加えます。
axにファイル名、es:bxに読み込むエリアのセグメントとオフセットを指定します。

[BITS 16]

loadapp:

    mov [TARGET_APP_NAME], ax
    mov ax, es
    mov [TARGET_APP_SEG], ax
    mov [TARGET_APP_OFF], bx

    xor ax, ax
    mov es, ax
    ; -----------------------------------
    ; Bootドライブ
    ; -----------------------------------
    mov al, es:[BOOT_DRV_OFF]
    mov [BOOT_DRIVE], al
    ; -----------------------------------
    ; VBR_LBA = start_lba
    ; -----------------------------------
    mov ax, es:[VBR_START_LBA]
    mov word [VBR_LBA], ax
    ; -----------------------------------
    ; SEC_PER_CLUS
    ; -----------------------------------
    mov al, es:[SEC_PER_CLUS_OFF]
    mov byte [SEC_PER_CLUS], al
    ; -----------------------------------
    ; ROOT_ENT_CNT
    ; -----------------------------------
    mov ax, es:[ROOT_ENT_CNT_OFF]
    mov [ROOT_ENT_CNT], ax
    ; -----------------------------------
    ; FAT_LBA
    ; -----------------------------------
    mov ax, es:[FAT_START_LBA]
    mov [FAT_LBA], ax
    ; -----------------------------------
    ; DATA_LBA
    ; -----------------------------------
    mov ax, es:[DATA_START_LBA]
    mov word [DATA_LBA], ax
    ; -----------------------------------
    ; DIR_LBA
    ; -----------------------------------
    mov ax, es:[DIR_START_LBA]
    mov [DIR_LBA], ax
    ; -----------------------------------
    ; CLUS_SIZ
    ; -----------------------------------
    mov ax, es:[CLUS_SIZ_OFF]
    mov [CLUS_SIZ], ax
    ; -----------------------------------
    ; BYTE_PER_SEC
    ; -----------------------------------
    mov ax, es:[BYTE_PER_SEC_OFF]
    mov [BYTE_PER_SEC], ax
    mov [BYTE_PER_SEC_SAVE], ax

    ; --- 転送先を設定 ---
    mov bx, BUF_SEG
    mov es, bx
    mov bx, BUF_OFF
    
    ; -----------------------------------
    ; Dir EntからTarget Fileのエントリを探す
    ; -----------------------------------
    mov ax, [ROOT_ENT_CNT]
    mov bx, 32
    mul bx
    mov bx, [BYTE_PER_SEC]
    div bx
    mov word [DIR_ENT_SEC_CNT], ax

    mov ax, [DIR_LBA]
    mov si, [TARGET_APP_NAME]

dir_ent_sec_loop:

    ; -----------------------------------
    ; Dir Entを読み込む
    ; -----------------------------------
    ; Dir Entを読み込むための設定
    mov si, dap
    mov word [si + DAP.NumBlocks], ENT_SECTORS ; sectors
    mov word [si + DAP.BufferOff], BUF_OFF     ; buffer offset
    mov word [si + DAP.BufferSeg], BUF_SEG     ; buffer segment
    mov ax, [DIR_LBA]
    mov word [si + DAP.LBA_Low],   ax ; LBA low Low
    mov dword [si + DAP.LBA_High],  0 ; LBA high
    mov dl, [BOOT_DRIVE]
    mov ah, 0x42
    int 0x13

    jc disk_error

    mov di, BUF_OFF
    mov cx, 16

find_entry:

    mov al, es:[di]
    cmp al, 0x00
    je not_found
    cmp al, 0xE5
    je next_entry
    mov al, es:[di+11]
    test al, 0x18          ; Volume or Dir
    jnz next_entry

    ; --- compare 11 bytes "MONITOR BIN" ---
    push di
    mov si, [TARGET_APP_NAME]
    
    mov bx, 11
cmp_loop:
    mov al, es:[di]
    mov ah, [si]
    ; PUTC '['
    ; PUTC ah
    ; PUTC ':'
    ; PUTC al
    ; PUTC ']'
    cmp al, ah
    jne cmp_ng
    inc di
    inc si
    dec bx
    jnz cmp_loop
    jmp find_dir_ent

cmp_ng:
    pop di
next_entry:
    add di, 32
    loop find_entry
next_sec:
    mov ax, [DIR_LBA]
    inc ax
    mov [DIR_LBA], ax
    mov ax, [DIR_ENT_SEC_CNT]
    dec ax
    mov [DIR_ENT_SEC_CNT], ax
    cmp ax, 0
    jnz dir_ent_sec_loop

not_found:
    mov al, 'N'
    out 0xE9, al
    jmp done

disk_error:
    mov al, 'X'
    out 0xE9, al
    mov al, ah
    call phd2
    jmp hlt

find_dir_ent:
    ; --- 一致 ---
    ; クラスタ・LBA変換
    pop di
    mov bx, es:[di+26]        ; FirstCluster low
    mov ax, es:[di+20]        ; FirstCluster high
    mov [TARGET_CLUS], bx       ; ファイルのあるクラスタ
    sub bx, 2
    mov al, [SEC_PER_CLUS]
    mov ah, 0
    mul bx
    mov bx, ax
    mov ax, [DATA_LBA]          ; データ開始LBA
    add ax, bx
    mov [FILE_LBA], ax          ; ファイルのLBA

    ; ファイルサイズ・セクタ変換
    mov ax, es:[di+28]          ; File size low word
    add ax, 511
    shr ax, 9
    mov [FILE_SECTOR], ax       ; ファイルのセクタ数

    mov cx, 0
file_read_loop:
    PUTC '.'
    mov si, dap
    mov ax, [SEC_PER_CLUS]
    mov word [si + DAP.NumBlocks], ax ; sectors
    mov ax, [SEC_PER_CLUS]
    mov bx, [BYTE_PER_SEC_SAVE]
    mov [BYTE_PER_SEC], bx

    mul bx
    mul cx
    add ax, [TARGET_APP_OFF]
    mov word [si + DAP.BufferOff], ax     ; buffer offset
    add ax, [TARGET_APP_SEG]
    mov word [si + DAP.BufferSeg], ax     ; buffer segment
    mov ax, [FILE_LBA]
    mov word [si + DAP.LBA_Low],   ax ; LBA low Low
    mov dword [si + DAP.LBA_High],  0 ; LBA high
    mov dl, [BOOT_DRIVE]
    mov ah, 0x42
    int 0x13

    jc disk_error

    mov ax, [FILE_SECTOR]
    sub ax, [SEC_PER_CLUS]
    mov [FILE_SECTOR], ax
    cmp ax, 0
    jle exit_loop

    inc cx

    ; ------------------------------------------------
    ; FAT16チェーンを辿って次のクラスタを取得する
    ;  current cluster = [TARGET_CLUS]
    ; ------------------------------------------------
    ; ★ FAT16: エントリサイズ 2byte
    ;   offset_bytes = cluster * 2
    ;   FAT_sector   = FAT_LBA + offset_bytes / BytesPerSec
    ;   byte_offset  = offset_bytes % BytesPerSec
    ; ------------------------------------------------

    mov ax, [TARGET_CLUS]    ; 現在のクラスタ番号
    mov bx, 2
    mul bx                   ; DX:AX = cluster * 2 (FAT内オフセット[byte])
    mov bx, [BYTE_PER_SEC]   ; 通常 512
    div bx                   ; AX = FAT内セクタオフセット, DX = セクタ内byteオフセット

    mov [FAT_TARGET_CLUS], ax    ; FAT内セクタオフセットとして再利用
    mov [FAT_TARGET_ENT], dx     ; セクタ内byteオフセット

    ; FATセクタのLBA = FAT_LBA + FAT内セクタオフセット
    mov ax, [FAT_LBA]
    add ax, [FAT_TARGET_CLUS]
    mov [TARGET_FAT_LBA], ax

    ; ------------------------------------------------
    ; FATセクタを1セクタだけBUFへ読み込み
    ; ------------------------------------------------
    mov si, dap
    mov word [si + DAP.NumBlocks], 1      ; FATは1セクタで十分
    mov word [si + DAP.BufferOff], BUF_OFF
    mov word [si + DAP.BufferSeg], BUF_SEG
    mov ax, [TARGET_FAT_LBA]
    mov word [si + DAP.LBA_Low], ax
    mov dword [si + DAP.LBA_High], 0
    mov dl, [BOOT_DRIVE]
    mov ah, 0x42
    int 0x13
    jc disk_error

    ; ------------------------------------------------
    ; 読み込んだFATセクタから次クラスタ取得
    ; ------------------------------------------------
    mov ax, BUF_SEG
    mov es, ax
    mov si, BUF_OFF
    mov bx, [FAT_TARGET_ENT]      ; セクタ内byteオフセット
    add si, bx
    mov ax, [es:si]               ; FAT16なので2バイト読み

    ; ------------------------------------------------
    ; FAT16: 終端判定 (0xFFF8以上をEOFとみなす)
    ; ------------------------------------------------
    cmp ax, 0xFFF8
    jae exit_loop                 ; EOFなので読み込み終了
    cmp ax, 0x0002
    jb  exit_loop                 ; 無効クラスタはとりあえず終了扱い

    ; ------------------------------------------------
    ; 次クラスタ → FILE_LBAへ変換
    ;   clusterN → LBA = DATA_LBA + (clusterN - 2) * SEC_PER_CLUS
    ; ------------------------------------------------
    mov [TARGET_CLUS], ax         ; 現在クラスタを更新

    mov bx, ax                    ; bx = clusterN
    sub bx, 2
    mov al, [SEC_PER_CLUS]
    mov ah, 0
    mul bx                        ; AX = (clusterN - 2) * SEC_PER_CLUS
    mov bx, ax
    mov ax, [DATA_LBA]
    add ax, bx
    mov [FILE_LBA], ax            ; 次クラスタの先頭LBA

    jmp file_read_loop

exit_loop:


done:

    ; 読み込んだ内容の冒頭をダンプ（目視確認用）
    ; mov ax, [TARGET_APP_SEG]
    ; mov es, ax
    ; mov si, [TARGET_APP_OFF]
    ; mov cx, 0x20
    ; call dump_mem

    ; mov ax, BOOT1_SEG
    ; mov ds, ax
    ; mov ax, _s_msg_jmp_monitor
    ; call ps


    ret


; _s_filename db 'APPF    BIN', 0x00

_s_msg_start db 'B1:Start', 0x0d, 0x0a, 0x00
_s_msg_jmp_monitor db 'B1:jmp', 0x0d, 0x0a, 0x00
_s_msg_read_monitor db 'B1:read', 0x0a, 0x0d, 0x00

BOOT_DRIVE db 0
SEC_PER_CLUS db 0
ROOT_ENT_CNT dw 0
VBR_LBA dw 0
DATA_LBA dw 0
DIR_LBA dw 0
FILE_SECTOR dw 0
FILE_LBA dw 0
DIR_ENT_LBA dw 0
DIR_ENT_SEC_CNT dw 0
FIRST_CLUS dw 0
TARGET_FAT_LBA dw 0
FAT_TARGET_ENT dw 0
FAT_TARGET_CLUS dw 0
FAT_LBA dw 0
FAT_ENT_CNT dw 0
FILE_TARGET_CLUS dw 0
BYTE_PER_CLUS dw 0
TARGET_CLUS dw 0
CLUS_SIZ dw 0
BYTE_PER_SEC dw 0
BYTE_PER_SEC_SAVE dw 0
TARGET_APP_SEG dw 0
TARGET_APP_OFF dw 0
TARGET_APP_NAME dw 0


align 16
dap:                ; 
    db 0x10, 0x00   ; size / reserved
    dw 0            ; sectors
    dw 0x0000       ; buffer offset
    dw 0x0          ; buffer segment
    dq 0x0          ; LBA (low=2048, high=0)

こうするとboot1.asmがどうなるかというと、こうなります。すっかすかです。

[BITS 16]
org 0x8000

%macro PUTC 1
    push ax
    mov  al, %1
    out  0xE9, al
    pop  ax
%endmacro

%include 'hifax.asm'

jmp start
nop

OEMLabel        db 'MSDOS5.0'       ; 8 bytes
BytesPerSec     dw 0x0200
SecPerClus      db 4                ; 10MB パーティションでは4が妥当
RsvdSecCnt      dw 0x0004           ; mformatのデフォルト
NumFATs         db 2
RootEntCnt      dw 0x0200           ; HDDでは512が一般的
TotSec16        dw 0xf800          ; パーティションサイズ (9MB)
Media           db 0xf8             ; HDD
FATSz16         dw 0x0040           ; FAT16サイズ（要計算）114?
SecPerTrk       dw 0x0020
NumHeads        dw 4
HiddSec         dd 0                ; パーティション開始LBA
TotSec32        dd 0
; ======================================================

start:
    PUTC 'B'
    PUTC '1'
    PUTC ':'

    cli
    mov ax, 0x7000
    mov ss, ax
    mov sp, 0xfff0
    sti

    mov ax, _s_msg_start
    call ps

    mov ax, MON_SEG
    mov es, ax
    mov bx, MON_OFF
    mov ax, _s_target_name
    
    call loadapp

    jmp MON_SEG:MON_OFF

hlt:
    hlt
    jmp hlt

_s_target_name db 'MONITOR BIN', 0x00

%include 'loadapp.asm'
%include 'common.asm'

monitor.asmにもloadappを呼び出す部分を追加します。

; ============================================================================
; monitor.asm
; バッファ = 09e0:0000, DLはブートからの値をそのまま使用
; 制約: FAT16フォーマットのみ対応（FATsz16 != 0 必須）
; ============================================================================
[BITS 16]
[SECTION .text]

jmp start

%include 'hifax.asm'

; ---------------- デバッグ出力 ----------------
%macro PUTC 1
  push ax
  mov  al,%1
  out  0xE9,al
  pop  ax
%endmacro

global start 

; ---------------- 本体 ----------------
start:
    PUTC 'M'
    PUTC ':'
    cli
    mov ax, STACK_SEG
    mov ss, ax
    mov sp, 0xE000
    sti

    mov ax, MON_SEG
    mov ds, ax
    mov es, ax

    call install_int80

    mov si, _s_msg_monitor
    mov ah, 0x20              ; write(DS:SI, CX)
    int 0x80

    mov ax, APP_SEG
    mov es, ax
    mov bx, APP_OFF
    mov ax, _s_target_name
    
    call loadapp

    jmp APP_SEG:APP_OFF

    jmp hlt

hlt:
    hlt
    jmp hlt

; =====================================================================
;  syscall.asm  (INT 80h 拡張版)
; =====================================================================

[BITS 16]
[SECTION .text]

; ------------------------------------------------------------
; install_int80: INT80h のハンドラを IVT に登録
; ------------------------------------------------------------
install_int80:
    cli
    push ax
    push bx
    push es

    xor ax, ax
    mov es, ax                ; IVTセグメント
    mov bx, 0x80*4            ; INT80hエントリ番地
    mov word [es:bx], int80_handler
    mov word [es:bx+2], MON_SEG  ; モニタのCS値

    pop es
    pop bx
    pop ax
    sti
    ret

; ------------------------------------------------------------
; INT80h ハンドラ本体
; ------------------------------------------------------------
int80_handler:
    ; push ax
    push bx
    push cx
    push dx
    push si
    push di
    push bp
    push ds
    push es

    cmp ah, 0x20
    je  .svc_write
    cmp ah, 0x21
    je  .svc_puthex
    cmp ah, 0x22
    je  .svc_getkey
    cmp ah, 0x23
    je  .svc_putchar
    cmp ah, 0x24
    je  .svc_newline
    cmp ah, 0x25
    je  .svc_cls
    cmp ah, 0x26
    je  .svc_reboot
    jmp .svc_exit

; ------------------------------------------------------------
.svc_write:                      ; AH=20h : write string DS:SI (0終端)
    mov bx, 0x0007
    mov ah, 0x0E
.w_loop:
    lodsb
    test al, al
    jz .svc_exit
    int 0x10
    jmp .w_loop

; ------------------------------------------------------------
.svc_puthex:                     ; AH=21h : AXを16進で出力
    push ax
    mov al, ah
    call phd2
    pop ax
    call phd2
    jmp .svc_exit

; ------------------------------------------------------------
.svc_getkey:                     ; AH=22h : キー入力待ち (ALに返す)
    xor ax, ax
    int 0x16
    jmp .svc_iret

; ------------------------------------------------------------
.svc_putchar:                    ; AH=23h : ALを1文字出力
    mov ah, 0x0E
    mov bx, 0x0007
    int 0x10
    jmp .svc_exit

; ------------------------------------------------------------
.svc_newline:                    ; AH=24h : 改行(CR+LF)
    mov ah, 0x0E
    mov al, 0x0D
    int 0x10
    mov al, 0x0A
    int 0x10
    jmp .svc_exit

; ------------------------------------------------------------
.svc_cls:                        ; AH=25h : 画面クリア
    mov ax, 0x0003
    int 0x10
    jmp .svc_exit

; ------------------------------------------------------------
.svc_reboot:                     ; AH=26h : 再起動
    ; jmp 0FFFFh:0000h
    cli

.wait_kbc:
    in   al, 0x64
    test al, 0x02
    jnz  .wait_kbc

    mov  al, 0xFE
    out  0x64, al

    hlt
; ------------------------------------------------------------
.svc_exit:
.svc_iret:
    pop es
    pop ds
    pop bp
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    ; pop ax
    iret


%include 'loadapp.asm'
%include 'common.asm'

_s_msg_monitor db 'Hello from Monitor', 0x0d, 0x0a, 0x00
_s_msg_wait:   db 'Press any key to continue...', 0x0d, 0x0d, 0

_s_target_name db 'APPF    BIN', 0x00

times 1280-($-$$) db 0

実行結果はこちら。

monitorからのHello、appからのHello、Monitor内・App内で実行したSyscallの結果が確認できます。

終わりに

8回にわたり続けてきました『Hyfaxのこと』もこれで一区切りです。この後は文字入力を可能にして、簡易シェルを作成し、複数アプリを実行してもよし、マルチタスクに挑戦してもよし。ロングモードに移行してもよしです。望むままの世界が開けています。

さて、名残は尽きないものの、皆様の開発ライフに幸が多からんことを祈りつつ、この辺で終わりにしたいと思います。
お付き合いありがとうございました。

この連載の成果物はgithubに公開しています。よろしければどうぞ。
https://github.com/CbWB-Inc/software/tree/main/laboratory/lab02/hyfax_base

《2025/12/21 1:08:21》