Acorn BBC BASIC II Memory Map

LOMEM: the start of variable storage. Defaults to TOP when a program is run and grows upward as variables are created (tracked by VARTOP); settable with LOMEM=.

VARTOP: the address just past the last allocated variable — where the next new variable goes. Runs from LOMEM up toward zp_stack_ptr; the two meeting is "No room".

Pointer to the top of BASIC's value stack, which grows downward from HIMEM. The stack carries expression temporaries, strings pushed during evaluation, and — across a PROC/FN call — a saved copy of the 6502 hardware stack. "No room" is raised if it descends to meet VARTOP.

HIMEM: the top of memory available to BASIC. The value stack (zp_stack_ptr) grows down from here; settable with HIMEM=. Read from the MOS (OSBYTE &84) at startup.

ERL: the line number in which the last error occurred, set by the error handler and read by the ERL function (0 in immediate mode).

PtrA offset: the offset of the next character within the program line addressed by zp_text_ptr. The interpreter reads the tokenised program through this pointer/offset pair.

PtrA: the primary program/text pointer — the base address of the line currently being interpreted. Combined with zp_text_ptr_off to fetch tokens.

RND state: the 33-bit linear-feedback shift register behind RND. &0D-&10 are a little-endian 32-bit value (bits 0-31); bit 0 of &11 is bit 32. Advanced 32 steps per RND call; reseeded by RND(-n).

TOP: the address just past the end of the tokenised program text (and the default for LOMEM). Read by the TOP pseudo-variable and set when the program is edited.

Print field width: the @%-derived field width used while formatting a number for PRINT, counting the characters emitted so far in the current field.

Number-base flag for output: 0 selects decimal, negative selects hexadecimal (set by STR$~ and PRINT ~).

ON ERROR handler address: where the interpreter jumps when an error is trapped. Reset to the default handler (&B433) at the start of each statement line; set by ON ERROR.

PAGE high byte: the start of the BASIC program as a page number (PAGE = this × 256). Read from OSHWM at startup; the PAGE pseudo-variable exposes it.

PtrB: the secondary text pointer, used by the expression evaluator and the tokeniser while zp_text_ptr (PtrA) is preserved. Paired with zp_text_ptr2_off.

PtrB offset: the offset of the next character for the secondary text pointer zp_text_ptr2.

DATA pointer: the address of the next DATA item to be READ. Set to the program start by RESTORE (or a line by RESTORE n) and advanced as items are read.

COUNT: the number of characters printed since the last newline (the print column). Used for , field alignment and the WIDTH auto-newline; read by the COUNT function.

LISTO flags: the listing-indent options set by LISTO n. Control whether LIST indents FOR/REPEAT bodies and spaces tokens.

TRACE flag: &00 = tracing off, &FF = on (TRACE ON/TRACE OFF). When on, executed line numbers are printed in brackets up to zp_trace_max.

TRACE ceiling: the highest line number that TRACE reports (TRACE n). Lines above it are not traced.

WIDTH: the print line width for the auto-newline (WIDTH n). &FF (the default) means no automatic wrap; compared against zp_count.

REPEAT stack depth: how many REPEAT loops are open, indexing repeat_stack. Not saved across a PROC/FN call, so leaving a loop via ENDPROC/GOTO leaks its entry.

GOSUB stack depth: how many GOSUB calls are open, indexing gosub_stack. Not saved across a PROC/FN call.

FOR stack depth: how many FOR loops are open (×15 gives the byte offset into for_stack). Not saved across a PROC/FN call.

Value type of the most recently fetched/evaluated value: 0 = string, positive (&40) = integer, negative = real. Drives the type dispatch throughout the evaluator.

Inline-assembler OPT flags (OPT n): bit 0 prints a listing, bit 1 enables error reporting, bit 2 assembles to the offset address O% instead of P%. &FF outside [ ] marks "not assembling".

Inline assembler: the opcode byte being built for the instruction currently being assembled, before its operand bytes are appended.

IWA — the 32-bit integer work accumulator. Holds the integer operand/result of the evaluator and the integer arithmetic primitives, and doubles as a pointer to a variable’s value during a fetch.

FWA — floating-point work accumulator A (&2E-&35): sign (&2E), overflow/guard (&2F), excess-128 exponent (&30), 32-bit mantissa MSB-first (&31-&34) and a rounding byte (&35). The main register for real arithmetic; see zp_fwb_sign.

Length of the string currently in the string work area at string_work.

General-purpose work pointer (&37-&3A). Reused widely — the tokeniser/line scanner, the variable-chain walk, the program editor — as a scratch 16-bit pointer.

Filing-system control block (&39 onward): the OSFILE / load-save parameter block. Filing is not active during arithmetic, so this overlaps the FP workspace below (zp_fwb_sign onward).

FWB — floating-point work accumulator B (&3B-&42), same layout as zp_fwa_sign. Supplies the second operand for binary floating-point operations (add, multiply, divide).

FWB overflow byte (&3C), part of zp_fwb_sign. A much-reused scratch location: outside floating point it serves as the tokeniser's line-number-arming flag (&FF after GOTO etc. means encode the next number as a line number), a variable-chain walk pointer, an array dimension-descriptor offset, and LIST's REPEAT/UNTIL indent counter. Read each use in its own context rather than assuming a single global meaning.

Floating-point temporary / scratch (&43-&47). Holds spill bytes for the FP routines and serves as the quotient build area for integer DIV/MOD.

Decimal-point-seen flag, set while parsing a number literal so a second . is rejected and the fractional digits are scaled.

Decimal exponent accumulated while parsing the E part of a real literal.

Integer-part / exponent scratch: holds the integer exponent during number parsing and the integer part of a value in EXP and the int/fraction split.

Pointer to a packed 5-byte floating-point value (a variable or an FP temporary) for the pack/unpack routines.

Pointer to the current coefficient table, used while evaluating the continued-fraction approximations in the trig functions.

Pointer to the error block currently being reported (the bytes after a BRK): the error number and message the handler is processing.

ESCFLG — the MOS escape flag. Its top bit is set when Escape is pressed; BASIC polls it between statements, acknowledges it via OSBYTE, and raises the "Escape" error.

The 6502 hardware stack (page 1), used normally for JSR/RTS and register saves. A PROC/FN call copies a snapshot of the live stack onto the BASIC value stack and restores it on return, so call nesting is bounded by free stack space rather than a fixed table.

Base for the PROC/FN call frame's LOCAL/parameter restore count: frame_local_count,X with X = the running body's stack pointer (&F5) addresses the count byte at &01FB. stmt_local bumps it as each LOCAL or parameter is saved; call_proc_fn replays that many saved values on =/ENDPROC.

The resident integer variables, four bytes each: @% here at &0400, then A%-Z% at &0404-&046B. @% sets the PRINT/STR$ number format. Two slots double as the inline assembler's counters — O% (the 'O' slot, &043C) is the offset-assembly address and P% (the 'P' slot, &0440) the program counter.

Four 5-byte packed floating-point temporaries: TEMP1 (&046C), TEMP2 (&0471), TEMP3 (&0476) and TEMP4 (&047B). The maths routines stash intermediate reals here while reusing FWA / FWB.

The −1 base for the variable chain-head table var_ptr_table: the clear loop stores var_table_base,X for X = &80…1, zeroing &0480-&04FF.

The dynamic-variable chain-head table: a two-byte head pointer per initial-character class (A-Z, a-z, _, @), addressed as &0400 + 2×char. find_variable walks the linked list of variables sharing an initial character; create_variable links a new one in at the head.

Current FOR frame, control-variable address low (offset +0): the ,X read base (X = zp_for_level) NEXT uses to match and reload the loop variable.

Current FOR frame, control-variable address high (offset +1).

Current FOR frame, control-variable type (offset +2): 5 = real, otherwise integer.

Current FOR frame, STEP byte 0 (offset +3): NEXT adds the STEP to the control variable. An integer STEP uses bytes 0-3; a real STEP adds a fifth byte at +7.

Current FOR frame, STEP byte 1 (offset +4).

Current FOR frame, STEP byte 2 (offset +5).

Current FOR frame, STEP byte 3 (offset +6).

Current FOR frame, loop-limit byte 0 (offset +8): NEXT compares the control variable against it. An integer limit uses bytes 0-3; a real limit adds a fifth byte at +C.

Current FOR frame, loop-limit byte 1 (offset +9).

Current FOR frame, loop-limit byte 2 (offset +A).

Current FOR frame, loop-limit byte 3 (offset +B).

Current FOR frame, loop-body text pointer low (offset +D): where NEXT resumes each iteration.

Current FOR frame, loop-body text pointer high (offset +E).

The FOR stack: up to 10 frames of 15 bytes each (&0500-&0595; depth in zp_for_level). Each frame holds the control-variable address and type, the STEP and limit values, and the loop-back text pointer — pushed by FOR, consulted and updated by NEXT.

Write base FOR uses to stack a new for_stack frame: control-variable address high (offset +1). The low byte goes to for_stack itself; the read-side counterpart is for_var_hi.

New-frame write base: control-variable type (offset +2).

New-frame write base: STEP byte 0 (offset +3).

New-frame write base: STEP byte 1 (offset +4).

New-frame write base: STEP byte 2 (offset +5).

New-frame write base: STEP byte 3 (offset +6).

New-frame write base: loop-limit byte 0 (offset +8).

New-frame write base: loop-limit byte 1 (offset +9).

New-frame write base: loop-limit byte 2 (offset +A).

New-frame write base: loop-limit byte 3 (offset +B).

New-frame write base: loop-body text pointer low (offset +D).

New-frame write base: loop-body text pointer high (offset +E).

The −1 read base for the REPEAT stack low bytes: UNTIL loads repeat_loop_lo,X (X = zp_repeat_level) to reload the current loop-start pointer.

REPEAT loop-start text pointers, low bytes — up to 20 nested (depth in zp_repeat_level); high bytes in repeat_stack_hi. UNTIL reloads the pointer to re-test its condition.

The −1 read base for the REPEAT stack high bytes (repeat_stack_hi); pairs with repeat_loop_lo.

High bytes of the REPEAT loop-start pointers; low bytes in repeat_stack.

The −1 read base for the GOSUB stack low bytes: RETURN loads gosub_return_lo,X (X = zp_gosub_level) to recover the return position.

GOSUB return text pointers, low bytes — up to 26 nested (depth in zp_gosub_level); high bytes in gosub_stack_hi. RETURN pops the top entry.

The −1 read base for the GOSUB stack high bytes (gosub_stack_hi); pairs with gosub_return_lo.

High bytes of the GOSUB return pointers; low bytes in gosub_stack.

The −1 base for the string work area string_work: strbuf_base,X (X = 1…length) addresses the buffer, so index 1 is the first character — the string routines fill and read it one-based.

The string work area / CALL parameter block. BASIC builds string results here — the text of STR$, the digits of a number conversion, a popped string for comparison — with the length in zp_strbuf_len. CALL also assembles its parameter block here.

The line input buffer. The line editor reads a typed line (at the > prompt or for INPUT) into here via OSWORD 0; the tokeniser then processes it in place.