Tiny BASIC in 2K

vidak

General concept

The idea is to write a Tiny BASIC that can be vaguely useful for the ATmega328, i.e, the Arduino Uno or Nano.

The chip has 2K RAM, and is the entry-level Arduino platform micro-controller. Given these constraints, and my lack of training in any C, I am opting to code the project in AVR assembly.

Looking across the different electronic shopping sites, there are certainly cheaper and more powerful boards than the Uno or Nano. But I am still going to do this project anyway.

The language

The Tiny BASIC language set will be small:

PRINT
IF
THEN
GOTO
INPUT
LET
GOSUB
RETURN
CLEAR
LIST
RUN
END

It is derived from the People’s Computer Company 1975 September gazette. I should really put the link to that here. I think such a small BASIC makes this a project able to be done in a few evening/afternoons of serious effort.

Resources

You may be interested to see what I have already dug up:

http://www.ittybittycomputers.com/IttyBitty/TinyBasic/TinyBasic.asm

http://www.ittybittycomputers.com/IttyBitty/TinyBasic/TB_6800.asm

https://github.com/trevorjay/atinybasic (Written in C, full implementation of the People’s Computer Company spec)

https://github.com/CorshamTech/6502-Tiny-BASIC/

vidak

https://github.com/pearsonalan/arduino-serial-asm/blob/master/serial-message.asm

currently stepping through this.

vidak

this also seems like a really good resource–

https://www.instructables.com/Command-Line-AVR-Tutorials/

vidak

https://social.solarpunk.au/notice/AzVIvOoCcyhVZwHEv2

vidak

Finally managed to get the onboard orange LED to blink–

; --------------------------------------------------------------
; blink.S — AVR Assembly LED blink for Arduino Mega 2560
; Target MCU: ATmega2560
; Toolchain:  avr-gcc, avr-objcopy, avrdude
; --------------------------------------------------------------

#define __SFR_OFFSET 0
#include <avr/io.h>	

#define delayVal 10000
	

.org 0x0000
	rcall start
led:	rcall ledOFF
	rcall delay
	rcall ledON
	rcall delay
	rjmp led

start:
	sbi DDRB, 7
	ret

ledOFF:
	cbi PORTB, 7
	rcall delay
	ret

delay:
	ldi r20, 100
outerLoop:
	ldi r30, lo8(delayVal)
	ldi r31, hi8(delayVal)
innerLoop:
	sbiw r30, 1
	brne innerLoop
	;; ------
	subi r20, 1
	brne outerLoop
	ret
	
ledON:
	sbi PORTB, 7
	rcall delay
        ret

vidak

Made some more progress.

From this: https://github.com/pearsonalan/arduino-serial-asm/blob/master/serial-alpha.asm

I was able to rather quickly adapt the code below.

;************************************
; serial-alpha.S
;************************************

#define __SFR_OFFSET 0
#include <avr/io.h>
#include <avr/interrupt.h>


;
; Set up the Interrupt Vector at 0x0000
;
; We only use 1 interrupt in this program, the RESET
; interrupt.
;

.org 0x0000
	jmp reset		; PC = 0x0000	RESET


;======================
; initialization

reset: 
	clr	r1			; set the SREG to 0
	out	SREG, r1

	ldi	r28, lo8(RAMEND)	; init the stack pointer to point to RAMEND
	ldi	r29, hi8(RAMEND)
	out	SPL, r28
	out	SPH, r29

	rcall	USART_Init		; initialize the serial communications
	sei				; enable global interrupts
	rjmp	main

;=======================
; Initialize the USART
;
USART_Init:
	; these values are for 9600 Baud with a 16MHz clock
	ldi	r16, 103
	clr	r17

	; Set baud rate
	sts	UBRR0H, r17
	sts	UBRR0L, r16

	; Enable receiver and transmitter
	ldi	r16, (1<<RXEN0)|(1<<TXEN0)
	sts	UCSR0B, r16

	; Set frame format: Async, no parity, 8 data bits, 1 stop bit
	ldi	r16, 0b00001110
	sts	UCSR0C, r16
	ret

;=======================
; send a byte over the serial wire
; byte to send is in r19

USART_Transmit:
	; wait for empty transmit buffer
	lds	r16, UCSR0A
	sbrs	r16, UDRE0
	rjmp	USART_Transmit

	; Put data (r19) into buffer, sends the data
	sts	UDR0, r19
	ret


;======================
; Main body of program:

main:
	ldi	r19, 'A'		; load 'A' into r19
loop:
	rcall	USART_Transmit		; send the character in r19 to the USART
	inc	r19			; increment to the next character
	cpi	r19, 'Z'+1		; see if we are now at ascii 91 ('[' or the first letter past 'Z')
	brne	loop			; if not go back and print again

	; send cr to the USART
	ldi	r19, 13
	rcall	USART_Transmit

	; send newline to the USART
	ldi	r19, 10
	rcall	USART_Transmit
	
	rjmp	main			; else go back and to reset the value in r19

Should you want to build the code yourself on your own Arduino Mega, use:

$ avr-gcc -mmcu=atmega2560 -nostartfiles -o serial-alpha.elf serial-alpha.S

$ avr-objcopy -O ihex serial-alpha.elf serial-alpha.hex

$ avrdude -D -v -p atmega2560 -c wiring -P /dev/ttyACM0 -U flash:w:serial-alpha.hex

vidak

https://github.com/WillStevens/basic1K

vidak

https://retro.social/@permacomputer/116916814668191406

the latest attempt at writing Dandelion BASIC is at hand.

https://codeberg.org/vidak/dandelion/src/branch/main/dandelion.S

for the arduino mega 2560
written in pure assembly language
GCC assembler syntax (avr-gcc)
sits within first 64KB of flash
follows dick whipple and li-chen wang’s interpretive language method
all Tiny BASIC Extended commands supported (2D integer arrays, FOR NEXT)

please see: https://whippleway.com/Source_Code/TBX.asm


	;; FILE HEADER AND METADATA

	/**
	*    ┌┬┐┌─┐┌┐┌┌┬┐┌─┐┬  ┬┌─┐┌┐┌
	*     ││├─┤│││ ││├┤ │  ││ ││││
	*    ─┴┘┴ ┴┘└┘─┴┘└─┘┴─┘┴└─┘┘└┘
	*        ┌┐ ┌─┐┌─┐┬┌─┐  O┬    
	*        ├┴┐├─┤└─┐││    ┌┘    
	*        └─┘┴ ┴└─┘┴└─┘  ┴O    
	*/

	;; Dandelion BASIC
	;;
	;; Sponsored by the People's Permacomputer Project.
	;;
	;; Public Domain Licence.

	/**
	*    ┬─┐┌─┐┌┬┐
	*    ├┬┘│ ││││
	*    ┴└─└─┘┴ ┴
	*/

	;; ADDRESS	SIZE		SECTION
	;; .		.		.
	;; $0000	256B		INTERRUPTS
	;; $0100	3.75KB		INIT
	;; $1000	8KB		INTERPRETER CORE
	;; $3000	20KB		INTERPRETER ML ROUTINES
	;; $8000	4KB		ERROR HANDLING
	;; $9000	12KB		ILPGM ITSELF
	;; $C000	8KB		ALL JUMP TABLES
	;; $E000	4KB		MESSAGE CONSTANTS
	;; $F000	4KB		FREE MEMORY

	/**
	*        ┌─┐┌─┐ ┬ ┬┌─┐┌┬┐┌─┐┌─┐      
	*        ├┤ │─┼┐│ │├─┤ │ ├┤ └─┐      
	*        └─┘└─┘└└─┘┴ ┴ ┴ └─┘└─┘      
	*     ┬   ┌─┐┌─┐┌┐┌┌─┐┌┬┐┌─┐┌┐┌┌┬┐┌─┐
	*    ┌┼─  │  │ ││││└─┐ │ ├─┤│││ │ └─┐
	*    └┘   └─┘└─┘┘└┘└─┘ ┴ ┴ ┴┘└┘ ┴ └─┘
	*/
	
	;; EQUATES AND CONSTANTS

	.equ	CR,		0x0D
	.equ	LF,		0x0A
	.equ	EOF,		0xFF
	.equ	
	.equ	RAMEND,		0x21FF
	.equ	ILSTRT,		0x9000
	.equ	PRG_START,	0x0000
	.equ	AESTK_BASE,	0x0000
	.equ	SBRSTK_BASE,	0x0000
	.equ	MEMEND,		0x21FF
	.equ	ZWIDTH,		15 ; Width of zone for comma in PRINT
				   ; statement.

	;; Error codes

	;; IL Opcodes

	/**
	*    ┬─┐┌─┐┌─┐┬┌─┐┌┬┐┌─┐┬─┐┌─┐
	*    ├┬┘├┤ │ ┬│└─┐ │ ├┤ ├┬┘└─┐
	*    ┴└─└─┘└─┘┴└─┘ ┴ └─┘┴└─└─┘
	*/
		
	;; REGISTER VARIABLE DEFINITIONS

	#define temp r16

	/**
	*    ┌┬┐┌─┐┌┬┐┌─┐  ┌─┐┌─┐┌─┐┌┬┐┌─┐┌┐┌┌┬┐
	*     ││├─┤ │ ├─┤  └─┐├┤ │ ┬│││├┤ │││ │ 
	*    ─┴┘┴ ┴ ┴ ┴ ┴  └─┘└─┘└─┘┴ ┴└─┘┘└┘ ┴ 
	*/
	
	;; DATA SEGMENT

	.section .data

	.org 0x0200		; Zero page start

	;; 

CURLBL:		.word	0x0000	; Current line number.
PRGMEM:		.word	0x0000	; Start of user program.
PRGSTRT:	.word	PRGMEM	; First byte of user program.
PROGEND:	.word	PRGMEM	; Last byte of user program.
COUNT:		.byte	1	; Length of text in buffer.
ZONE:		.byte	15	; Print zone/column counter.

	;; Stack pointers.

AELVL:		.word	AESTK_BASE ; AESTK pointer
SBRLVL:		.word	SBRSTK_BASE ;SBRSTK pointer

	;; Arrays

INDX:		.byte	1
ASTRT:		.word 	PRGMEM

MEND:		.word	MEMEND

	.section .bss

BUFSTRT:	.space	72 	; change this later.
VARSTRT:	.space	52
ARRAYDATA:	.space 	1024 	; this could be an error
AESTK:		.space	256
SBRSTK:		.space	256

	
	/**
	*    ┬─┐┌─┐┌┬┐  ┌─┐┌─┐┌─┐┌┬┐┌─┐┌┐┌┌┬┐
	*    ├┬┘│ ││││  └─┐├┤ │ ┬│││├┤ │││ │ 
	*    ┴└─└─┘┴ ┴  └─┘└─┘└─┘┴ ┴└─┘┘└┘ ┴ 
	*/

	.section .text

	/**
	*    ┬┌┐┌┌┬┐┌─┐┬─┐┬─┐┬ ┬┌─┐┌┬┐┌─┐
	*    ││││ │ ├┤ ├┬┘├┬┘│ │├─┘ │ └─┐
	*    ┴┘└┘ ┴ └─┘┴└─┴└─└─┘┴   ┴ └─┘
	*/

	;; INTERRUPT VECTORS AND RESET.

	;; $0000 - $00FF.
	;; 256 bytes.

	.org	0x0000

	jmp	COLDSTART
	jmp	WARMSTART	; Preserves user program.
	;; --- other vectors ---

null_int:
	reti

	/**
	*    ┬┌┐┌┬┌┬┐┬┌─┐┬  ┬┌─┐┌─┐┌┬┐┬┌─┐┌┐┌  
	*    │││││ │ │├─┤│  │└─┐├─┤ │ ││ ││││  
	*    ┴┘└┘┴ ┴ ┴┴ ┴┴─┘┴└─┘┴ ┴ ┴ ┴└─┘┘└┘  
	*/

	;; INITIALISATION.
	
	;; $0100 - $0FFF
	;; 3.75 kilobytes.
	
COLDSTART:
	;; Initialise hardware stack pointer to origin address.
	;; Clear screen and send sign on message.
	;; CRLF.
	jmp ILXQT

	;; Message ASCII data.
	;; Message out routine.

WARMSTART:
	;; Initialise hardware stack pointer to origin address.
	;; Reset AESTK.
	;; Reset SBRSTK.
	;; Start at new BASIC line.
	jmp	NXTIL

	/**
	*    ┬┌┐┌┬┌┬┐
	*    │││││ │ 
	*    ┴┘└┘┴ ┴ 
	*/

	;; INIT: Initialise system values, and clear command.

INIT:	
	;; See DATA SEGMENT for initialised RAM.

XINIT:

	/**
	*    ┬┬    ┌─┐─┐ ┬┌─┐┌─┐┬ ┬┌┬┐┬┌─┐┌┐┌
	*    ││    ├┤ ┌┴┬┘├┤ │  │ │ │ ││ ││││
	*    ┴┴─┘  └─┘┴ └─└─┘└─┘└─┘ ┴ ┴└─┘┘└┘
	*          ┬─┐┌─┐┬ ┬┌┬┐┬┌┐┌┌─┐       
	*          ├┬┘│ ││ │ │ ││││├┤        
	*          ┴└─└─┘└─┘ ┴ ┴┘└┘└─┘       
	*/

	;; INTERPRETER CORE.

	;; $1000 - $2FFF.
	;; 8 kilobytes.

	.org	0x1000

ILXQT:
	;; load address for beginning of IL program
NXTIL:	
	;; 
	;; 

	/**
	*            ┌─┐┌─┐┬─┐┌─┐           
	*            │  │ │├┬┘├┤            
	*            └─┘└─┘┴└─└─┘           
	*    ┌─┐┬ ┬┌┐ ┬─┐┌─┐┬ ┬┌┬┐┬┌┐┌┌─┐┌─┐
	*    └─┐│ │├┴┐├┬┘│ ││ │ │ ││││├┤ └─┐
	*    └─┘└─┘└─┘┴└─└─┘└─┘ ┴ ┴┘└┘└─┘└─┘
	*/
	
	;; CORE SUBROUTINES
	
	;; $3000 - $7FFF
	;; 20 kilobytes.

	.org 0x3000

NEWLINE:
	
GETLINE:

BUFIN:

INSRT:

MEMTEST:

LST:

TSTL:

CHRIN:

CHROUT:	

NLINE:

CRLF:	

PRS:

SPCZ:

SPCONE:

NXT:

NXTX:

RTN:	

PRN:	

TSTV:	

TSTN:	

PSHAE:	

POPAE:	

TWOCMP:	

IND:	

ARRAY:	

STORE:

ADD:

SUB:

MUL:

DIV:

NEG:

CMPR:

FNDLBL:

XFER:

DONEX:

SAVE:

RSTR:

PSHSBR:

POPSBR:

INNUM:

RNDM:

DIM:

	/**
	*    ┌─┐┬─┐┬─┐┌─┐┬─┐┌─┐
	*    ├┤ ├┬┘├┬┘│ │├┬┘└─┐
	*    └─┘┴└─┴└─└─┘┴└─└─┘
	*/
	
	;; ERROR PROCESSING

	;; $8000 - $8FFF
	;; Four kilobytes.

	.org 0x8000

	/**
	*    ┬  ┬    ┌─┐┬─┐┌─┐┌─┐┬─┐┌─┐┌┬┐
	*    │  │    ├─┘├┬┘│ ││ ┬├┬┘├─┤│││
	*    ┴  ┴─┘  ┴  ┴└─└─┘└─┘┴└─┴ ┴┴ ┴
	*/

	;; IL PROGRAM

	;; $9000 - $BFFF
	;; Twelve kilobytes.

	.org 0x9000

ILSTRT:	

NEWPRG:

	/**
	*    ┌┬┐┌─┐┌┐ ┬  ┌─┐┌─┐
	*     │ ├─┤├┴┐│  ├┤ └─┐
	*     ┴ ┴ ┴└─┘┴─┘└─┘└─┘
	*/

	;; TABLES.

	;; $C000 - $DFFF.
	;; 8 kilobytes.

	.org 0xC000

	/**
	*    ┌┬┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐┌─┐
	*    │││├┤ └─┐└─┐├─┤│ ┬├┤ └─┐
	*    ┴ ┴└─┘└─┘└─┘┴ ┴└─┘└─┘└─┘
	*/

	;; MESSAGE CONSTANTS.

	;; $E000 - $EFFF.
	;; Four kilobytes.

	.org 0xE000

	;; FREE FLASH MEMORY.

	;; $F000 - $FFFF
	;;  Four kilobytes.
	
	.org 0xF000

vidak

How To Setup The GNU Assembler

Installation

$ sudo apt install gcc-avr arduino

Usual Invocation

The assembler:

$ avr-gcc -mmcu=atmega2560 -x assembler-with-cpp -c dandelion.S -o dandelion.o

The linker:

$ avr-gcc -mmcu=atmega2560 -nostdlib dandelion.o -o dandelion.elf

Generating the hex file:

$ avr-objcopy -O ihex dandelion.elf dandelion.hex

My upload process uses /dev/ttyACM1 because I have another arduino plugged into the workstation already:

$ avrdude -D -v -p atmega2560 -c wiring -P /dev/ttyACM1 -b 115200 -U flash:w:dandelion.hex

vidak

Dandelion BASIC devlog

We’re up off the ground and flying… sort of.

Let me explain a bit of my thinking process.

Much of the difficulty over the past few days has been taking the original TBX interpretive language program and trying to encode it in such a way that makes sense on the Arduino.

You may recall the original TBX IL program:

STRT:	INIT
ERRENT:	NLINE
CO:	GETLN
;	NLINE
	TSTL	DIR
	INSRT
	IJMP	CO
XEC:	XINIT
DIR:	TST	S1,'LET'
	ICALL	AVTEST
	ICALL	EXPR1
	STORE
	DONE
	NXT
S1:	TST	S3,'GO'
	TST	S2,'TO'
	ICALL	EXPR
	DONE
	XFER
S2:	TST	S14,'SUB'
	ICALL	EXPR
	DONEX
	SAV
	XFER
S3:	TST	S3A,'IF'
	ICALL	EXPR
	ICALL	RELOP
	ICALL	EXPR
	CMPR
	IJMP	DIR
S3A:	TST	S4A,'FOR'
	TSTV	S3ERR
	ICALL	EXPR1
	STORE
	TST	S3ERR,'TO'	; DDJ V1N2, p.36 #1
	FOR
	ICALL	EXPR
	DONE
	NXT
S3ERR:	ERR	16
S4:	TST	S9,'PR'
S5:	TST	S8C,'"'
	PRS
S6:	TST	S7A,','
	SPC
S7B:	TST	S5A,13
	NXT
S7A:	TST	S7,59		; semicolon
	SPCONE
	IJMP	S7B
S7:	NLINE
	DONE
	NXT
S8:	ICALL	EXPR
	PRN
	IJMP	S6
S8A:	DONE
	NXT
S9:	TST	S12,'IN'
S10:	ICALL	AVTEST
	INNUM
	STORE
	TST	S11,','
	IJMP	S10
S11:	TST	S7,59		; DDJ V1N2, p.36 #2
	DONE
	NXT
S12:	TST	S13,'RET'
	DONE
	RSTR
	NXT
S13:	TST	S14,'END'
	NLINE
	FIN
S18:	TST	S15,'LST'
	IJMP	S18A
S15:	TST	S16,'RUN'
	DONE
	IJMP	XEC
S16:	TST	S17A,'NEW'
	DONE
	IJMP	STRT
S17:	ERR	12
S5A:	TST	S5,'$'
	NXTX
EXPR1:	TST	EXPR,'='
EXPR:	TST	E0,'-'
	ICALL	TERM
	NEG
	IJMP	E1
E0:	TST	E3,'+'
E3:	ICALL	TERM
E1:	TST	E2,'+'
	ICALL	TERM
	ADD
	IJMP	E1
E2:	TST	E4,'-'
	ICALL	TERM
	SUB
	IJMP	E1
TERM:	ICALL	FACT
T0:	TST	T1,'*'
	ICALL	FACT
	MPY
	IJMP	T0
T1:	TST	T2,'/'
	ICALL	FACT
	DIV
	IJMP	T0
FACT:	TSTF	F4
	IJMP	FN
F4:	TSTA	F0
	ICALL	ARRAY
	IND
	RTN
F0:	TSTV	F1
	IND
T2:	RTN
E4:	RTN
F1:	TSTN	F2
	RTN
F2:	TST	F3,'('
	ICALL	EXPR
	TST	F3,')'
	RTN
F3:	ERR	13
S17A:	TST	S17,'SZE'
	SIZE
	IJMP	S8A
RELOP:	TST	R0,'='
	LIT	0
	RTN
R0:	TST	R4,'<'
	TST	R1,'='
	LIT	2
	RTN
R1:	TST	R3,'>'
	LIT	3
	RTN
R3:	LIT	1
	RTN
R4:	TST	S17,'>'
	TST	R5,'='
	LIT	5
	RTN
R5:	TST	R6,'<'
	LIT	3
	RTN
R6:	LIT	4
	RTN
S14:	TST	S18,'DIM'
Z0:	TSTV	ZERR
	TST	F3,'('
	ICALL	EXPR
	TST	Z1,','
	ICALL	EXPR
	TST	F3,')'
	DIM2
Z3:	TST	Z2,','
	IJMP	Z0
Z2:	DONE
	NXT
Z1:	TST	F3,')'
	DIM1
	IJMP	Z3
ZERR:	ERR	13
ARRAY:	TST	F3,'('
	ICALL	EXPR
	TST	X0,','
	ICALL	EXPR
	TST	F3,')'
	ARRAY2
	RTN
X0:	TST	F3,')'
	ARRAY1
	RTN
AVTEST:	TSTA	V0
	ICALL	ARRAY
	RTN
V0:	TSTV	VERR
	RTN
VERR:	ERR	11
S4A:	TST	S4,'NXT'
	TSTV	S4ERR
	NEXT
	STORE
	DONE
	NXT
S4ERR:	ERR	14
FN:	TST	FN0,'RN'
	RANDOM
	RTN
FN0:	TST	S17,'SP'	; DDJ V1N2, p.36 #6
	ICALL	EXPR
	TAB
	RTN
S8C:	TST	S8B,13
	NLINE
	NXT
S8B:	TST	S8,'$'
	NLINE
	NXTX
S18A:	TST	S18B,13
	LIST0
	LST
	NXT
S18B:	ICALL	EXPR
	TST	S18C,','
	ICALL	EXPR
	LIST2
	LST
	IJMP	S8A
S18C:	LIST1
	LST
	IJMP	S8A

Each of these IL instructions need to be written out in Arduino instructions in assembly language. So, for example, TST, ICALL, etc.

The original TBX 8080 code dealt with this problem like this:

;
;	INTERPRETIVE LANGUAGE PROGRAM
;
;	0b00xxxxxx	JUMP TO IL INSTRUCTION AT 00xxxxxx
;	0b01xxxxxx	CALL IL SUBROUTINE AT 00xxxxxx
;	0b10xxxxxx	COMPARE TO STRING FAIL TO IL AT 00xxxxxx 
;	0b11xxxxxx	CALL ML SUBROUTINE AT 00xxxxxx
; 
NEWPRG:	DB	hi(INIT) | 0b11000000, lo(INIT)		;CALL INIT
NEWLNE:	DB	hi(NLINE) | 0b11000000, lo(NLINE)	;CALL NLINE
	DB	hi(GETLINE) | 0b11000000, lo(GETLINE)	;CALL GETLINE
	DB	hi(NLINE) | 0b11000000, lo(NLINE)	;CALL NLINE
	DB	hi(TSTL) | 0b11000000, lo(TSTL)		;CALL TSTL
	DB	hi(DIR) | 0b00000000, lo(DIR)		;JUMP DIR
	DB	hi(INSRT) | 0b11000000, lo(INSRT)	;CALL INSRT
	DB	hi(NEWLNE) | 0b00000000, lo(NEWLNE)	;JUMP NEWLNE	
;
XEQ:	DB	hi(XINIT) | 0b11000000, lo(XINIT)	;CALL XINIT
DIR:
;
LET:	DB	hi(GOTO) | 0b10000000, lo(GOTO)		;TST <>'LET' THEN JUMP GOTO

continued...

It grouped each IL instruction into four kinds of opcodes, and applied a mask to the top two bits of each instruction. So when the Arduino program counter goes looking for the label’s address in order to process the IL opcode in the Arduino’s own machine language, it dispatches the control of the IL program using those top two bits.

Now I have the luxury of being able to address more than 16K of memory. In fact I’m only confining myself to 64KB of 256K of the Arduino Mega2560’s flash.

But I solved the problem like this, with macros:

	;; IL Opcodes

	.equ	IL_JUMP,	0b00000000
	.equ	IL_CALL,	0b01000000
	.equ	IL_COMPARE,	0b10000000
	.equ	ML_CALL,	0b11000000

	.macro IJMP label
		.byte IL_JUMP
		.word \label
	.endm

	.macro ICALL label
		.byte IL_CALL
		.word \label
	.endm

	.macro TST label, str, lastchar
		.byte IL_COMPARE
		.word \label
		.ascii "\str"
		.byte \lastchar+0x80
	.endm	
	
	.macro CALL label
		.byte ML_CALL
		.word \label
	.endm

	.macro TSTN label
		.byte IL_COMPARE
		.word \label
	.endm

	.macro TSTV label
		.byte IL_COMPARE
		.word \label
	.endm

	.macro TSTA label
		.byte IL_COMPARE
		.word \label
	.endm

	.macro TSTF label
		.byte IL_COMPARE
		.word \label
	.endm

	.macro LIT num
		CALL LIT\num
	.endm

	.macro ERR num
		CALL ERR\num
	.endm

And the IL program gets assembled like this:

	/**
	*    ┬  ┬    ┌─┐┬─┐┌─┐┌─┐┬─┐┌─┐┌┬┐
	*    │  │    ├─┘├┬┘│ ││ ┬├┬┘├─┤│││
	*    ┴  ┴─┘  ┴  ┴└─└─┘└─┘┴└─┴ ┴┴ ┴
	*/

	;; IL PROGRAM

	;; $9000 - $BFFF
	;; Twelve kilobytes.

	;; 0b00xxxxxx	Jump to IL instruction @ 00xxxxxx.
	;; 0b01xxxxxx	Call IL subroutine at 00xxxxxx.
	;; 0b10xxxxxx	Compare to string, fail to IL @ 00xxxxxx.
	;; 0b11xxxxxx	Call ML subroutine @ 00xxxxxx.

	.org 0x9000

ILSTRT:	
NEWPRG:
	CALL	INIT
ERRENT:	
	CALL	NLINE
CO:	
	CALL	GETLINE
	CALL	NLINE
	CALL	TSTL
	IJMP	DIR
	CALL	INSRT
	IJMP	CO
XEC:
	CALL XINIT
DIR:
	TST	S1, "LET", 'T'

continued...

The only difference is that I now reserve a whole byte for that tiny little bitmask.

You can see how treating everything as whole bytes is much easier. Looking at the ILXQT routine inside dandelion.S, which I am currently working on, you can see the first byte of the IL instruction is the bitmask, then the next two bytes define the 16-bit label address of the ML routine defining the IL opcode, and, then, for particularly complex instructions like TST, extra arguments.

	;; Compare string (TST instruction).
	;; Format: 0b10000000, lo8(label), hi8(label), string, lastchar+0x80

Anyway, that’s everything to report. Ask me anything.