docs(buzbee): update docs to represent feature completion state

.editorconfig

@@ -12,7 +12,7 @@ insert_final_newline = true
 indent_style = space
 indent_size = 2
 
-[*.md]
+[*.{md,typ}]
 indent_style = space
 indent_size = 2
 max_line_length = 80

docs/buzbee.typ

@@ -18,6 +18,10 @@ the CHIBI PC-09 hobby computer platform. It is the stock bootloader and
 interface for the PC-09. This manual goes over the usage of BUZBEE, and some of
 the technical internals of how it works and how to hack on it.
 
+BUZBEE was created primarily to debug prototype versions of the CHIBI PC-09.
+BUZBEE will grow alongside the CHIBI PC-09 project. It also functions as a
+reference implementation of an OS using the CHIBI PC-09 BIOS.
+
 The CHIBI PC-09 name and platform is copyright 2024-2025 Amber Zeller. The CHIBI
 PC-09 BIOS is copyright 2024-2025 Gale Faraday and Amber Zeller. BUZBEE is
 copyright 2025 Gale Faraday. All CHIBI PC-09 components are licensed under the
@@ -29,10 +33,11 @@ MIT license.
 
 BUZBEE is at its core a chain loader or bootloader. This means that most of the
 functionality of the CHIBI starts with using BUZBEE. BUZBEE functions are broken
-into two categories: _Internal Functions_ or "IFs," and _External Functions_ or
+into two categories: _Internal Functions_ or "IFs" defined in @if-top, and
-"EFs." IFs are native routines mapped to textual commands entered at the BUZBEE
+_External Functions_ or "EFs" in @ef-top. IFs are native routines mapped to
-prompt. EFs are native routines called through IFs. EFs can either be any user
+textual commands entered at the BUZBEE prompt. EFs are native routines called
-supplied code, or one of a set of routines in the BIOS/BUZBEE ROM or "firmware".
+through IFs. EFs can either be any user supplied code, or one of a set of
+routines in the BIOS/BUZBEE ROM or "firmware".
 
 #pagebreak()
 
@@ -44,21 +49,29 @@ listed in alphabetical order. Below in @if-table is a list of available IFs.
 
 #figure(
   table(
-    columns: (1fr, auto),
+    columns: (auto, auto, 1fr),
     inset: 10pt,
     align: center,
+    fill: (_, y) =>
+      if calc.odd(y) { luma(250) }
+      else { white },
     table.header(
-      [*Name* (pg. no.)], [*Description*]
+      [*Name* (pg. no.)], [*Command Token*], [*Description*]
     ),
-    [`CALL` #ref(<if-call>, form: "page")],
+    [`CALL` (#ref(<if-call>, form: "page"))],
+    [`$00`],
     [Call a resident routine in the MPU's address space.],
-    [`HELP` #ref(<if-help>, form: "page")],
+    [`HELP` (#ref(<if-help>, form: "page"))],
+    [`$01`],
     [Display a summary of known commands.],
-    [`PEEK` #ref(<if-peek>, form: "page")],
+    [`PEEK` (#ref(<if-peek>, form: "page"))],
+    [`$02`],
     [Dumps memory from the MPU's address space to the terminal.],
-    [`POKE` #ref(<if-poke>, form: "page")],
+    [`POKE` (#ref(<if-poke>, form: "page"))],
+    [`$03`],
     [Overwrites memory in the MPU's address space.],
-    [`SREC` #ref(<if-srec>, form: "page")],
+    [`SREC` (#ref(<if-srec>, form: "page"))],
+    [`$04`],
     [Switches into Motorola S-Record receive mode.],
   ),
   caption: [Table of IFs],
@@ -66,10 +79,18 @@ listed in alphabetical order. Below in @if-table is a list of available IFs.
 
 In the following pages these IFs are described in specific.
 
-// TODO: Talk about how IFs are tokenized.
+IFs are tokenized from their textual form into a binary "bytecode" form. This
+bytecode is described in @internals.
+
+First the text command name (eg. `CALL`) is hashed in some way into a token.
+Then conditional processing on the remainder of the line occurs. Values given in
+hex are encoded as their corresponding bytes directly. The token buffer
+mechanics are described more in @internals. Subcommands are also hashed into
+tokens.
 
 #pagebreak()
 
+// Function for creating IF page headers
 #let _ifpagehead(
   desc: none,
   syntax: none,
@@ -99,7 +120,8 @@ In the following pages these IFs are described in specific.
   ),
 )
 
-#lorem(120)
+Call takes an absolute pointer into the MPU's address space to call as if it
+were a subroutine using `JSR`.
 
 // TODO: For when CHIBI PC-09 Prototype #2 comes out or whenever we get banking
 // add it here "Special care must be taken to properly bank in the correct
@@ -129,17 +151,18 @@ BIOS routine.
   syntax: [`PEEK <BASE> [<HIGH>]`],
   params: (
     base: [
-      The address of the byte to dump or the base (lower bound) address of the
+      The address (two bytes) of the byte to dump or the base (lower bound)
-      byte to start dumping from if `<HIGH>` is specified.
+      address of the byte to start dumping from if `<HIGH>` is specified.
     ],
     high: [
       An optional operand given as the upper bound of the range to dump. Forms
-      a range together with `<BASE>`.
+      a range together with `<BASE>`. (two bytes)
     ],
   )
 )
 
-#lorem(120)
+Peeking memory causes the MPU to read the requested bytes and dump them to the
+screen.
 
 #pagebreak()
 
@@ -149,12 +172,13 @@ BIOS routine.
   desc: "Writes values to the MPU's address space.",
   syntax: [`POKE <ADDR> <BYTES>`],
   params: (
-    addr: "The base (low) address to start writing bytes from.",
+    addr: "The base (low) address (two bytes) to start writing bytes from.",
     bytes: "The bytes to write into memory separated by whitespace.",
   )
 )
 
-#lorem(120)
+Poking memory causes the MPU to overwrite the bytes at `<ADDR>` with the bytes
+given in `<BYTES>`.
 
 #pagebreak()
 
@@ -166,32 +190,104 @@ BIOS routine.
   params: (),
 )
 
-#lorem(120)
+Motorola S-Record mode is currently a stub.
 
 #pagebreak()
 
 == External Functions (EFs) <ef-top>
 
-#lorem(120)
+External functions are any native user code that can be called with `CALL` (see
+@if-call). This mechanism is usable to run any code or routine in memory as
+though interactively using the MPU's `JSR` instruction.
 
 === EFs in ROM <ef-rom>
 
-#lorem(120)
+Some common EFs to call include the using call to reset the CHIBI PC-09 with
+`CALL 8000`.
+
+// TODO: Talk about memory test and BIOS interface
 
 #pagebreak()
 
 = BUZBEE Reserved Memory Regions <res-mem>
 
-#lorem(120)
+BUZBEE uses memory in the 0200-02FF page. A table of the layout of this memory
+is provided. The memory is laid out in a packed structure starting at 0200.
+
+#table(
+  columns: (auto, 1fr, auto),
+  inset: 10pt,
+  align: center,
+  fill: (_, y) =>
+    if calc.odd(y) { luma(250) }
+    else { white },
+  table.header(
+    [*Internal Name*], [*Size (Bytes)*], [*Description*]
+  ),
+  [`input`],
+  [128],
+  [Text input buffer],
+  [`cchinput`],
+  [2],
+  [Text input buffer character count],
+  [`tokens`],
+  [64],
+  [BUZBEE token buffer],
+  [`cbtokens`],
+  [2],
+  [Count of bytes in `tokens`],
+  [`scratch`],
+  [2],
+  [Internal scratch word used for some operations],
+)
 
 #pagebreak()
 
 = Building CHIBI PC-09 Firmware from Source <building>
 
-#lorem(120)
+Building the CHIBI PC-09 firmware from source requires LWTOOLS
+#link("http://lwtools.ca"), a functioning C compiler (`cc`), and a POSIX Shell
+implementation (`sh`). The firmware was developed using LWTOOLS version 4.24 on
+Linux, though later versions may work as well. A GNU Make "makefile" is provided for
+building on Linux. GNU binutils' `objcopy` is also used to build the compiled
+Motorola S-Record into a raw binary. Development is tracked using Git.
+
+Using the makefile is simple. It provides facilities for easy building, and
+development.
+
+To build an S-Record of the ROM run:
+```sh
+make generate && make boot.s19
+```
+
+To build a ROM image with `objcopy` run:
+```sh
+make generate && make
+```
+
+In order to rebuild, first the generated files and existing objects must be
+cleaned. To do this a `make clean` pseudo-target is defined.
+
+Building the documentation can also be accomplished using `make docs`, provided
+`typst` is installed.
 
 #pagebreak()
 
 = BUZBEE Internals and Modding <internals>
 
-#lorem(120)
+BUZBEE's interpreter works by "compiling" textual user commands into bytecode
+for more simply passing parameters to IFs (see @if-top). The way that works is
+the implementation dependent, but each hash is one byte (1B) in size, and
+corresponds to an IF token, which is the index of the hash.
+
+BUZBEE's source, and the surrounding BIOS source is well commented, but a
+general summary of the control flow is provided here.
+
++ BUZBEE sets up the prompt and input buffer with `NEWLINE`
++ BUZBEE enters an input processing loop that works with the CHIBI PC-09's
+  serial driver.
++ If no input is provided, restart.
++ BUZBEE makes a tokenizing pass over the input buffer.
++ BUZBEE attempts to execute the tokens, which may involve leaving the BUZBEE
+  loop, or in the event the IF returns, loops around and re-enters the BUZBEE
+  loop.

src/buzbee.inc

@@ -5,16 +5,3 @@
 ; vim: ft=asm
 
 BUZBEE IMPORT
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; BUZBEE Variables
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-BBIN_BASE      EQU $0200
-BBIN_DEPTH     EQU $7F
-BBTOKENS_BASE  EQU $0280
-BBTOKENS_DEPTH EQU $3F
-BBTOKENS_CCH   EQU $02C0
-

src/buzbee.s

@@ -9,7 +9,29 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;; BUZBEE Machine Language Monitor for CHIBI PC-09
+;; BUZBEE Variables
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+BBIN_DEPTH     EQU $80 ; Input buffer depth
+BBTOKENS_DEPTH EQU $40 ; Token buffer depth
+
+  SECTION BBVARS,bss
+
+tagbbvar STRUCT
+input    rmb BBIN_DEPTH     ; Input buffer
+cchinput rmd 1              ; Input buffer char count
+tokens   rmb BBTOKENS_DEPTH ; Token buffer
+cbtokens rmd 1              ; Token buffer byte count
+scratch  rmd 1              ; Scratch word
+  ENDSTRUCT
+
+  ORG $0200
+BBVAR tagbbvar
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; BUZBEE Main Loop
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -18,13 +40,13 @@
   EXPORT BUZBEE
 
 BUZBEE
-  bsr NEWLINE ; Setup the new input line and handle display.
+  lbsr NEWLINE  ; Setup the new input line and handle display.
-  bsr INPLOOP ; Fill input buffer.
+  bsr INPLOOP   ; Fill input buffer.
-  cmpy #$0000 ; No data?
+  cmpy #0       ; No data?
-  beq BUZBEE  ;  Try again...
+  beq BUZBEE    ;  Try again...
-  ; TODO: Parse the input buffer into tokens
+  lbsr TOKENIZE ; Try to tokenize the input buffer
-  ; TODO: Execute the token buffer
+  lbsr RUNIF    ; Execute token buffer, handling any errors
-  bra BUZBEE
+  bra BUZBEE    ; Repeat
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
@@ -32,25 +54,11 @@ BUZBEE
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-; Handle new lines; prints a new prompt and then clears the input buffer
-NEWLINE
-  PZSTR PROMPTLINE  ; Print prompt line
-CLRIN               ; Label to just clear input buffer without newline
-  clra              ; Init A and X
-  ldx #$0000
-NEXT@
-  sta BBIN_BASE,x   ; Clear input buffer
-  leax 1,x
-  cmpx #BBIN_DEPTH
-  blo NEXT@
-  ldy #$0000        ; Reset buffer fill pointer
-  rts
-
 ; Fills input buffer with characters from the serial console. Sets Y to the
 ; offset in the input buffer of the last char read.
 INPLOOP
   jsr PINCHAR          ; Try to read a char
-  cmpd #$0000          ; If no char keep waitin'
+  cmpd #0              ; If no char keep waitin'
   beq INPLOOP
   bitb #UARTF_LSR_DR   ; Is there a char in A?
   beq NOCHAR@
@@ -59,13 +67,14 @@ INPLOOP
   cmpa #$08            ; BS?
   beq HBACKSPC@        ;  Backup a char
   cmpa #$0D            ; CR?
-  beq EXIT@            ;  Then parse input buffer
+  beq HCR@             ;  Then terminate and parse input buffer
   cmpy #BBIN_DEPTH     ; Are we at the end of the input buffer?
   beq FULLBUF@         ; Handle the buffer being full
 ECHO@
   jsr POUTCHAR         ; Echo char back, this includes BS chars
-  sta BBIN_BASE,y      ; Add it to the input buffer
+  sta BBVAR.input,y    ; Add it to the input buffer
   leay 1,y
+  ; Fall through
 NOCHAR@
   ; Check for error condition, work based on The Serial Port release 19
   bitb #(UARTF_LSR_FIFO|UARTF_LSR_BI|UARTF_LSR_FE|UARTF_LSR_PE|UARTF_LSR_OE)
@@ -83,66 +92,229 @@ NOPARITY@
   PZSTR EM_FRAMING
 NOFRAM@
   bitb #UARTF_LSR_FIFO ; Check for FIFO error
-  beq INPLOOP
+  beq INPLOOP          ; Loop over
   PZSTR EM_FIFO
-  bra INPLOOP
+  bra INPLOOP          ; Loop over
-EXIT@
+HCR@
+  sty BBVAR.cchinput   ; Store buffer length
   rts
 HESC@
   lda #'^              ; Print a char that signifies that ESC was pressed
   jsr POUTCHAR
-  ldy #$0000           ; On return we cmpy #$0000 and if eq then newline.
+  ldy #0               ; On return we cmpy #0 and if eq then newline
   rts
 HBACKSPC@
   clrb                 ; Clear last char
   leay -1,y
-  stb BBIN_BASE
+  stb BBVAR.input
   bra ECHO@            ; Echo the char in A
 FULLBUF@
   lda #$07             ; ASCII BEL
   jsr POUTCHAR
-  bra INPLOOP
+  lbra INPLOOP
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Handle new lines; prints a new prompt and then clears the input buffer
-;;
+NEWLINE
-;; BUZBEE Command Hashing Routines
+  PZSTR PROMPTLINE  ; Print prompt line
-;;
+CLRIN               ; Label to just clear input buffer without newline
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  clra              ; Init A and X
-
+  ldx #0
-; Makes a hash of four chars in BBIN starting at offset X.
+NEXT@
-; @param X: offset in BBIN to read the four chars from
+  sta BBVAR.input,x ; Clear input buffer
-; @return A: resulting hash
+  leax 1,x
-MKCMDSUM
+  cmpx #BBIN_DEPTH
-  pshs b
+  blo NEXT@
-  ldb #4           ; Loop over four chars
+  ldy #0            ; Reset buffer fill pointer
-  clra             ; Initialize accumulator
-NEXTC@
-  suba BBIN_BASE,x ; Subtract current char from accumulator
-  leax 1,x         ; Next char
-  decb             ; Reduce count
-  cmpb #0          ; Are we at the end?
-  bne NEXTC@       ;  No? loop
   rts
 
-; Maps a command hash to a command index, and executes it
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; @corrupts B
+;;
-; @param A: input hash
+;; Hex Conversion and Printing Routines
-; @return X: command data table index
+;;
-CALLFROMHASH
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ldx #0          ; Counting up from zero
+
+; Prints a byte in A
+; @param A: byte to print
+PBYTE
+  pshs b
+  tfr a,b      ; Transfer lower nybble into B
+  andd #$F00F  ; Mask and adjsut
+  asra
+  asra
+  asra
+  asra
+  anda #$0F
+  ora #'0      ; Add '0' to offset to digits
+  cmpa #$3A    ; Hex? ':' '9'+1
+  blo SKIPA@
+  adca #6      ; Hex offset
+SKIPA@
+  jsr POUTCHAR ; Print char in A
+  andb #$0F
+  orb #'0      ; Add '0' to offset to digits
+  cmpb #$3A    ; Hex? ':' '9'+1
+  blo SKIPB@
+  adcb #6      ; Hex offset
+SKIPB@
+  tfr b,a      ; Print char in B
+  jsr POUTCHAR
+  puls b       ; Restore B
+  rts
+
+; Converts a hexadecimal sequence into a byte value
+; @param D: hex representation of a byte with A: MSD B: LSD
+; @return A: returned byte value
+; NOTE: Conversion logic credit to Wozniak. This code unrolled for speed.
+HEX2BYT
+  eora #$B0         ; Map digits to 0-9
+  cmpa #9+1         ; Is it a decimal?
+  blo AISDEC@       ;  Yes? skip hex adjust
+  adca #$88         ; Map 'A'-'F' to $FA-$FF
+  cmpa #$FA         ; Hex char?
+  blo BADHEX@       ;  No? Print error
+AISDEC@
+  asla              ; Shift MSD into upper nybble of A
+  asla
+  asla
+  asla
+; Do B part
+  eorb #$B0         ; Map digits to 0-9
+  cmpa #9+1         ; Is it a decimal?
+  blo BISDEC@       ; Yes? skip hex adjust
+  adcb #$88         ; Map 'A'-'F' to $FA-$FF
+  andb #$0F         ; Mask high nybble
+  cmpb #$0A         ; Hex char?
+  blo BADHEX@       ;  No? Print error
+BISDEC@
+  stb BBVAR.scratch ; Store low nybble in scratch buffer
+  ora BBVAR.scratch ; Combine the nybbles
+  rts
+BADHEX@
+  PZSTR EM_BADHEX   ; Print an error message
+  clrd              ; Prevent RUNIF from executing
+  std BBVAR.cbtokens
+  rts
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; BUZBEE Tokenizing Routines
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Attempts to parse the input buffer into tokens depending on the command
+TOKENIZE
+  ldd BBVAR.cchinput   ; Do we have input to work with?
+  cmpd #4              ; Do we have even enough space for a string command
+  blo TOKFAIL@         ;  No? GTFO
+  ldy #0               ; Initialize Y; used to track current position in BBVAR.input
+  ldx #0               ; Initialize X; used to track position in BBVAR.tokens
+  bsr SKIPTONEXTC      ; Get the next non-whitespace char
+  bsr MKCMDSUM         ; Hash the first four non-whitespace chars
+  bsr HASH2TOKEN       ; Try to turn that hash into a proper token
+  bcs TOKFAIL@
+  bra STTOK@           ; Store token
+NEXTHEX@               ; Next hex token
+  bsr SKIPTONEXTC      ; Skip to next whitespace
+  ldd BBVAR.input,y    ; Get hex value (two digits)
+  bsr HEX2BYT          ; Convert hex value to byte value
+STTOK@
+  sta BBVAR.tokens,x   ; Store curent token
+  leax 1,x             ; Advance to next token
+  cmpx #BBTOKENS_DEPTH ; Is this next token in bounds?
+  beq FULLBUF@         ;  No? handle a full buffer
+  bra NEXTHEX@         ; Try to turn the next character into a hex value
+FULLBUF@
+  PZSTR EM_FULLTOKBUF  ; Print an error message
+  clrd                 ; Say we wrote no tokens
+  std BBVAR.cbtokens
+  rts
+TOKFAIL@
+  PZSTR EM_TOKFAIL     ; Print tokenization fail
+  clrd                 ; Say we wrote no tokens
+  std BBVAR.cbtokens
+  rts
+
+; Converts a runtime command hash into a portable token. Command tokens are
+; indexes into BBCHT, which is generated at compile-time
+; @param A: runtime hash
+; @return A: output token
+; @return CC.C: set if error state, cleared otherwise
+HASH2TOKEN
+  pshs x           ; Preserve & init X; other routines in this group use it
+  ldx #0
 NEXTHASH@
-  cmpa BBCHT,x    ; Is this hash our hash?
+  cmpa BBCHT,x     ; Is this hash our hash?
-  beq CALCPTR@    ;  Yes? skip to next step to put ptr in x
+  beq THISHASH@    ;  Yes? turn it into a token
-  leax 1,x        ; Begin considering next hash
+  leax 1,x         ; Begin considering next hash
-  cmpx BBCHTC     ; Is this the last byte?
+  cmpx BBCHTC      ; Is the next hash even in the table?
-  blo NEXTHASH@   ;  No? try next hash, Yes? fall through
+  blo NEXTHASH@    ;  Yes? try this next hash, No? fall through
-  PZSTR EM_BADCMD ; Print an error message
+  PZSTR EM_BADHASH CALL; Print an error message to the user
-  lbra IFHELP     ; Proceed to call "HELP"
+  puls x
-CALCPTR@
+  orcc #1          ; Set CC.C to indicate error
-  tfr x,d         ; Swap into d to do a cheap multiply
+  rts
-  asld            ; Cheaply << to get *2, pointer size
+THISHASH@
-  tfr d,x         ; Restore x from d and jump to function at index
+  puls x
-  jmp [BBCMDPTRTBL,x]
+  andcc #$FE       ; Clear CC.C to indicate success
+  rts
+
+; Makes a hash of four chars in BBIN starting at offset X
+; @param Y: offset in BBIN to read the four chars from
+; @return A: resulting hash
+; @return Y: offset after hash processing
+MKCMDSUM
+  pshs b
+  ldb #4             ; Loop over four chars
+  clra               ; Initialize accumulator
+NEXTC@
+  suba BBVAR.input,y ; Subtract current char from accumulator
+  leax 1,y           ; Next char
+  decb               ; Reduce count
+  cmpb #0            ; Are we at the end?
+  bne NEXTC@         ;  No? loop
+  puls b
+  rts
+
+; Skips "whitespace" to the next semantic char
+; @param Y: current index in text buffer
+; @return Y: resulting index in text buffer
+SKIPTONEXTC
+  lda BBVAR.input,y ; Get our char?
+  cmpa #$20         ; SPACE or control char?
+  bhi EXIT@         ;  Yes? End
+  leay 1,y          ; Iterate next char
+  bra SKIPTONEXTC
+EXIT@
+  rts
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; BUZBEE IF Handling Functions
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Executes a command based on the initial token
+; @corrupts B
+; @return X: command data table index
+RUNIF
+  clrd             ; Do we have any tokens?
+  cmpd BBVAR.cbtokens
+  beq NOTOK@
+  ldx #0           ; Counting up from zero
+  lda BBVAR.tokens ; Load token
+  tfr a,b          ; Get the index in D
+  asld             ; Cheaply << to get *2, pointer size
+  tfr d,x          ; Move to X so we can use indexed mode with the offset
+  jmp [IFPTRTBL,x] ; Select IF
+NOTOK@
+  rts
+
+; IF pointer table
+IFPTRTBL
+  fdb IFCALL
+  fdb IFHELP
+  fdb IFPEEK
+  fdb IFPOKE
+  fdb IFSREC
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
@@ -150,21 +322,74 @@ CALCPTR@
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+; Call a pointer
+IFCALL
+  ldd BBVAR.cbtokens   ; Only jump if three tokens given
+  cmpd #3
+  lbne INVALIDARG
+  jsr [BBVAR.tokens+1] ; Make our jump (doesn't implicitly return)
+  rts
+
 ; Print out a help message
 IFHELP
   PZSTR HELP_MSG
   rts
 
-; Placeholder function labels to make assembler happy before git commit
+; Peek memory
-IFCALL
 IFPEEK
+  ldd BBVAR.cbtokens   ; One 16-bit token given, single peek
+  cmpd #3
+  lblo INVALIDARG      ; Not enough args given
+  bhi SELTYPE@         ; Select forward or backward peek
+SINGLE@
+  lda [BBVAR.tokens+1] ; Get byte
+  lbsr PBYTE           ; Print peek byte
+  rts
+SELTYPE@
+  ldd BBVAR.cbtokens   ; Have enough tokens?
+  cmpd #5
+  lbne INVALIDARG      ;  No? bounce out
+  ldd BBVAR.tokens+1   ; Are we forwards (BASE < HIGH)?
+  cmpd BBVAR.tokens+3
+  beq SINGLE@          ; Gracefully handle BASE == HIGH
+  bhi INVALIDARG       ; Malformed if BASE > HIGH
+  ldx BBVAR.tokens+1   ; Get BASE
+NEXT@
+  lda ,x+              ; Get the next byte
+  lbsr PBYTE           ; Print our byte
+  cmpx BBVAR.tokens+3  ; Are we at <HIGH> yet?
+  bne NEXT@            ;  No? loop
+  rts
+
+; Poke bytes into memory
+; NOTE: Blocks could also use 6309 TFM instruction
 IFPOKE
+  ldx BBVAR.cbtokens      ; Make sure we have enough tokens
+  cmpx #4
+  lblo INVALIDARG
+  leax -3,x               ; Get count of bytes to write into X
+  ldy #0                  ; Setup Y for indexing
+NEXTB@
+  lda BBVAR.tokens+3,y    ; Get source byte to copy
+  sta [BBVAR.tokens+1,y]  ; Copy byte
+  leay +1,y               ; Increment memory indexer
+  leax -1,x               ; Decement byte count
+  cmpx #0                 ; Are we at our last byte?
+  bhi NEXTB@              ;  No? loop
+  rts
+
+; Placeholder function labels to make assembler happy before git commit
 IFSREC
   rts
 
+; Invalid argument IF tail
+INVALIDARG
+  PZSTR EM_BADARG
+  rts
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;; BUZBEE Strings and Tables
+;; BUZBEE Strings and Fixed Data
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -175,8 +400,6 @@ HELP_MSG
   fcb $0D,$0A
   fcc "CALL <PTR> - Call the pointer given in <PTR> as a subroutine."
   fcb $0D,$0A
-  fcc "EXEC <PTR> - Start program at <PTR>."
-  fcb $0D,$0A
   fcc "HELP [CMD] - Display help, command optional."
   fcb $0D,$0A
   fcc "PEEK <BASE> [<HIGH>] - Read memory at <BASE> to <HIGH>."
@@ -184,30 +407,36 @@ HELP_MSG
   fcc "POKE <ADDR> <BYTES> - Overwrite memory with <BYTES> starting at <BASE>."
   fcb $0D,$0A
   fcc "SREC - Enter Motorola S-Record entry mode."
+  fcb $0D,$0A
   fcb $00
 
-BBCMDPTRTBL
-  fdb IFCALL
-  fdb IFHELP
-  fdb IFPEEK
-  fdb IFPOKE
-  fdb IFSREC
-
 PROMPTLINE
   fcb $0D,$0A,$25,$00 ; CR LF '%' NUL
 
 EM_OVERRUN
-  fcc "!!! Overrun Error !!!"
+  fcc "!!! UART Overrun Error !!!"
   fcb $0D,$0A,$00
 EM_PARITY
-  fcc "!!! Parity Error !!!"
+  fcc "!!! UART Parity Error !!!"
   fcb $0D,$0A,$00
 EM_FRAMING
-  fcc "!!! Framing Error !!!"
+  fcc "!!! UART Framing Error !!!"
   fcb $0D,$0A,$00
 EM_FIFO
-  fcc "!!! FIFO Error !!!"
+  fcc "!!! UART FIFO Error !!!"
   fcb $0D,$0A,$00
-EM_BADCMD
+EM_BADHASH
   fcc "!!! Bad Command Hash !!!"
   fcb $0D,$0A,$00
+EM_BADARG
+  fcc "!!! Malformed Arguments !!!"
+  fcb $0D,$0A,$00
+EM_TOKFAIL
+  fcc "!!! Tokenization Failure !!!"
+  fcb $0D,$0A,$00
+EM_BADHEX
+  fcc "!!! Malformed Hex Value !!!"
+  fcb $0D,$0A,$00
+EM_FULLTOKBUF
+  fcc "!!! Token Buffer Overrun !!!"
+  fcb $0D,$0A,$00

src/reset.s

@@ -24,7 +24,7 @@ RESET
 CLRSTACK
   ; Initialize the system stack
   clra               ; Init A & X to zero out the stack
-  ldx #$0000
+  ldx #0
 NEXT@
   sta STACK_BOTTOM,x ; Write a zero and progress to the next byte
   leax 1,x
@@ -36,18 +36,12 @@ BOOTSCR
   lda #13      ; 9600 baud
   ldb #%11     ; 8N1
   jsr INITUART ; Initialize serial console
-  ldx #VERMSG  ; Print version information
+  PZSTR VERMSG ; Print version information
-  jsr POUTZSTR
-
-; Progress to POST
-POST
-  jsr RAMTEST
 
 ; Hand off control to the BUZBEE monitor and print notification of leaving the
 ; firmware
 ENTERMON
-  ldx #TXTRUN
+  PZSTR TXTRUN
-  jsr POUTZSTR
   jmp BUZBEE
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;