Language Reference - CRT Basic

CRT Basic implements the structured BASIC dialect common to early-90s DOS programs: optional line numbers, named procedures, typed variables by suffix, and the classic SCREEN graphics environment.

This page documents what the interpreter currently supports. The project is under active development: unsupported statements fail with an error naming the statement and the source line, and support grows program by program.

• Files are read as CP437 with CRLF tolerated — the natural format of DOS-era .bas files.
• Comments: ' anywhere, or REM as a statement. Both run to end of line.
• Statement separators: newline or :. Multiple statements per line work (A = 1 : B = 2).
• Line continuation: a _ as the last non-blank character of a line joins it with the next.
• Case: keywords and variable names are case-insensitive.
• Numbers: decimal (3.25), exponents (1.5e3, 2D+10), hex &HFF, octal &O17, and type-suffixed literals (1024&, 1.5#).
• Labels: numeric (1 IF x THEN GOTO 2) or alphanumeric (MainLoop:). Targets for GOTO, GOSUB and ON ERROR GOTO.

A variable's type comes from its name suffix:

A name without a suffix gets a default type: SINGLE, unless changed by DEFINT / DEFLNG / DEFSNG / DEFDBL / DEFSTR letter ranges (DEFINT A-Z makes every plain name an INTEGER). The default applies by first letter and is module-wide, independent of where the DEFxxx statement appears.

Important consequences:

• x and x! are the same variable (under the default rules); x% is a different one.
• Numbers are computed in double precision inside expressions and narrowed to the variable's type on store. y = 0.1 + 0.2 keeps full precision during the addition, then narrows to SINGLE when assigned.
• DIM name AS INTEGER fixes a suffix-less name's type the same way a suffix would.
• LET is accepted as an explicit-assignment keyword (LET x = 1 is plain assignment, including LET a(i) = v).
• CONST name = expr [, …] defines module-level named constants (may reference earlier constants); reassigning one raises Duplicate definition.
• Unassigned numeric variables read as 0, strings as "".

Truth values: comparisons return -1 for true and 0 for false. Any nonzero number is true in IF / WHILE conditions. AND, OR and NOT are bitwise operations on integers, exactly as classic BASIC defines them.

DIM scores(0 TO 50)          ' explicit bounds
DIM grid(10, 20)             ' 0-based, two dimensions
DIM SHARED high%(9)          ' visible inside SUBs
DIM names$(20) AS STRING     ' AS type form

• An array used without DIM is auto-dimensioned 0 TO 10 per dimension on first indexed use — the classic default.
• Indexing out of range raises Subscript out of range.
• A scalar and an array may share one name: xo = 42 and xo(3) = 7 use independent storage and never disturb each other (QB45 behavior, oracle-verified).
• ERASE name frees an array; it can be re-=DIM=med afterwards.
• Element types follow the same suffix rules as scalars; INTEGER arrays narrow and range-check each stored element.

Precedence, weakest first:

Semantics worth knowing:

• / is floating-point division; \ and MOD round both operands to integers (half-to-even) first, then divide / take the remainder.
• Division by zero raises Division by zero.
• + on two strings concatenates.
• Comparison of strings is by exact/lexicographic string order; comparing a string to a number raises Type mismatch.

Numbers print the way classic BASIC formats them:

• A leading space for non-negative values and a trailing space — PRINT 1 emits " 1 ".
• SINGLE values print with float32's ~7 significant digits; DOUBLE expressions (a #-suffixed literal or variable anywhere inside) print with 16 significant digits, using D±xx scientific notation outside the fixed range.
• , advances to the next 14-column print zone; ; prints compactly. A trailing separator suppresses the newline.

Whole glyph cells are painted when text lands in a graphics mode — see Text is pixels for why that matters.

Programs read keys through INKEY$ (single key, non-blocking) and INPUT$(n) (up to n bytes). Printable keys arrive as their character (Enter as CHR$(13)). Cursor keys, function keys and editing keys arrive as the classic two-byte sequence CHR$(0) followed by the scancode — INKEY$ returns both bytes in one call, INPUT$ hands them out across successive reads.

In headless mode input never blocks: both functions simply drain whatever a driver pushed into the keyboard queue and return "" when it is empty.

DEF SEG, PEEK and POKE operate on an emulated 1 MiB real-mode address space (physical address = segment * 16 + offset, wrapping at 20 bits). Most of it is plain RAM; one region is live.

CRT Basic behaves as if the qbext mouse TSR (qbasicapps "Mouse driver") is always loaded: the IVT slot of INT 79h holds a far pointer to an 8-byte data table, and mouse events from the window frontend (or a headless driver) accumulate into it. Programs that speak the TSR protocol — discover the pointer with DEF SEG = 0 and =PEEK(&H79 * 4

• n)=, verify the magic word 1983, then read-and-reset the fields —

work unmodified.

Table layout (little-endian words):

Like the real driver, movement deltas wrap at 16 bits (read them as signed, e.g. via VAL("&H" + HEX$(...))), button bits stay latched until the consumer POKEs the field back to 0, and a field reading 0 means "no new activity". A button held down re-arms its bit after every consumer reset for the whole depression — the real TSR polls the live button state (INT 33h function 03h) on every timer tick, so a program that reads-and-resets each frame sees the bit set on every frame until the physical release (plus one stale latched read). In the window frontend, mouse motion is converted to video-mode pixels before being accumulated, so movement feels 1:1 at any window size.

Runtime errors are fatal by default and always name the source line (plus the offending source text when available). Trap them with ON ERROR GOTO label; RESUME retries the trapped statement, RESUME NEXT continues after it, RESUME label jumps. ON ERROR GOTO 0 disables trapping.

Common runtime errors: Overflow (integer store out of range), Division by zero, Subscript out of range, Type mismatch, Out of DATA, Input past end of file, File not found, Bad file number, Label not found.