init.mini

flush Some useful procedures

flush --
newhdr extends-assembler
proc asm
begin
    dict load
    8 add
    copy bload
    128 or
    swap bstore
    return
end

flush --
flush Assembles the following word regardless of immediacy
newhdr '
proc asm
begin
    prs_nxt drop
    prs_wrd find de_name add calign asm
    return
end extends-assembler


flush --
flush Nicer comment syntax
newhdr #
proc asm
begin
    ' flush
    return
end extends-assembler

# Now we have comments syntax, so lets define function syntax

# --
newhdr fn:
proc asm
begin
    newhdr
    proc asm
    begin
    return
end

# --
fn: end-fn
    lit return asm
    ' end
    return
end extends-assembler

# Now loops

# -- target
fn: do
    here load
end-fn extends-assembler

# target --
fn: loop
    lit branch asm
    here load 8 add sub asm
end-fn extends-assembler

# Some output helpers

# --
fn: defstr:
    newhdr
    str asm
end-fn

defstr: nl
1 basm
10 basm
0 basm

defstr: tab
4 basm
32 copy copy copy basm basm basm basm
0 basm

# str len --
fn: println
    print nl print
end-fn

# And a dictionary walk

# ptr --
fn: walk
    do
        tab print
        copy de_name println
        load copy
    loop

    drop
end-fn

fn: const:
    newhdr
    const asm
    asm
end-fn

92 const: backslash

# --
fn: \
    do
        in_ptr load backslash prs_ch in_adv
        swap not or not
    loop

    in_ptr load 1 add in_adv drop drop
end-fn extends-assembler

\
    The above magic little definition lets us do block comments
    like these.
\

34 const: quotes

# start end -- start len
fn: string-from-range
    over sub
end-fn

fn: var-add         \ n var -- \            swap over load add swap store           end-fn
fn: copy-pair       \ a b -- a b a b \      over over                               end-fn
fn: assemble-string \ string length -- \    swap over here load scopy here var-add  end-fn
fn: realign-arena   \ -- \                  here load calign here store             end-fn

fn: patch-target
    \ patch-address -- \
    here load over 8 add sub
    swap store
end-fn

fn: if
    \ -- patch-address \
    lit zeroes asm
    lit eq asm
    lit branch asm
    here load
    0 asm
end-fn extends-assembler

fn: end-if
    \ patch-address -- \
    patch-target
end-fn extends-assembler

fn: assemble-literal
    \ value -- \
    lit lit asm
    asm
end-fn

# Multiline strings should be easy to implement; each go of the loop we `scopy` the stuff we've found
# so far into the arena, and finally return pointers.
# -- string length
fn: s"
    \
        Block comments even work inside assembly mode
    \

    mode load if
        # This will be patched later so that an inline string can be skipped
        lit jump asm
        here load push
        0 asm
    end-if

    here load
    do
        in_ptr load
        copy quotes prs_ch
        string-from-range
        copy-pair assemble-string    add in_adv swap not or not
    loop

    1 add # Trim leading space

    in_ptr load 1 add in_adv drop drop      # Consume closing quote
    0 basm                                  # Null-terminate
    here load
    realign-arena
    string-from-range 1 sub

    mode load if
        pop patch-target
        swap
        assemble-literal
        assemble-literal
    end-if
end-fn extends-assembler

fn: next-line \ -- \ nl print end-fn

s" Mini (C) 2023 David Detweiler" println
next-line

s" The kernel defines only the following instructions:" println
kernel walk

\
    Assembles the machine code for:
    mov wp, [tp]
    add tp, 8
    jmp [wp]
\

fn: asm-next
    \ -- \
    77  basm
    139 basm
    55  basm
    73  basm
    131 basm
    199 basm
    8   basm
    65  basm
    255 basm
    38  basm
end-fn

fn: const:
    \ value -- \
    newhdr
    const asm
    asm
end-fn

\
    The following is the machine code for:
    lea rax, [wp + 8]
    sub dp, 8
    mov [dp], rax
    next
\

here load
73  basm
141 basm
70  basm
8   basm
73  basm
131 basm
236 basm
8   basm
73  basm
137 basm
4   basm
36  basm
asm-next
realign-arena
const: var

fn: var:
    \ cells -- \
    newhdr
    drop var asm
    0 asm
end-fn

1 var: foo

12 foo store
foo load copy sub foo store
foo load exit