TRS-80 DOS - NEWDOS/80 v2.0 for the Model III - SYS12/SYS Disassembled

SYS12/SYS

Other Navigation

SYS12/SYS is a BASIC/CMD SYS overlay module for NEWDOS/80 v2.0 on the TRS-80 Model III. It implements the BASIC direct command REF, which lists cross-references to variables, line numbers, keywords, and filespecs within the currently loaded BASIC program. SYS12 is loaded into the overlay area starting at 4D00H when the user types REF at the BASIC READY prompt.

Command Syntax

Overlay Details

Operational Summary

Key Data Structures

Memory layout of the SYS12 overlay module from 4D00H through 51D2H.

Address	Description
4D00H-4D21H	REF command entry point and parameter type detection. Parses the first argument byte to determine the REF format (no argument, line number, quoted filespec, USR token, or variable name).
4D24H-4D47H	Quoted filespec handler. Copies up to 16 bytes to the match buffer at 51EFH, sets comparison threshold to 3000H, and sets scan mode to C3H (filespec mode).
4D49H-4D9FH	Bare variable name parser. Validates and copies the variable name, detects type suffixes ($, CFH), and routes to the initialization routine.
4DA2H-4DB3H	String variable length adjustment, type-suffix-only handler, and initialization entry.
4DB6H-4DC9H	BREAK key polling loop. Waits for user input before starting the scan.
4DCBH-4DF9H	Scan initialization and self-modifying code setup. Configures conditional jumps, column widths, and the end-of-line detection flag.
4DFCH-4E25H	End-of-line handler and multi-pass controller. Dispatches based on the iteration counter (00H=first pass, 01H=display, 02H=exit, 03H=line-number mode).
4E28H-4E70H	Variable scan entry, output header display, accumulator buffer clear, and PDRIVE table walk.
4E73H-4E7DH	Clean stack exit to BASIC via JP 2B33H.
4E80H-4EE5H	Display output controller. Formats and displays cross-reference results from the accumulator buffer with type suffixes and occurrence counts.
4EEEH-4F04H	PDRIVE table iterator. Walks PDRIVE entries and dispatches to the multi-pass controller.
4F07H-4F43H	Line-number REF entry and validation. Searches the BASIC program for a specific line number.
4F46H-4F53H	Quoted string skip handler. Skips over quoted strings in the program text.
4F55H-4F68H	GOTO/GOSUB handler and token skip to end-of-line.
4F6AH-4F77H	Line advance and header skip. Advances past end-of-line markers and line headers.
4F78H-4FB8H	Main token scanner and letter/token classifier. Core scanning loop that classifies each byte and dispatches to the appropriate handler.
4FBAH-4FF0H	Digit and numeric constant handler. Collects digits, skips leading zeros, and handles decimal points.
4FF2H-501AH	Numeric constant comparison. Compares collected digits against the search target.
501CH-5048H	Alternate comparison path and shorter name copy handler.
504BH-5070H	Ampersand prefix handler (&H, &O, &D hex/octal/decimal constants).
5073H-508EH	'A' prefix handler (AS keyword detection).
5091H-50B0H	Variable name parser from program text. Collects names and compares against the target.
50B2H-50CCH	Type suffix detection loop. Checks for $, %, !, # after variable names.
50CDH-50D8H	Array variable detection (opening parenthesis after variable name).
50D9H-50EBH	Match recording. Increments accumulator, sets scan-complete flag, stores line number.
50EEH-50FEH	Alternate variable name comparison using 51DAH pattern.
5101H-512DH	PDRIVE table duplicate check. Prevents recording the same line address twice.
512FH-5148H	Filespec match routine. Byte-by-byte comparison against the match buffer at 51EFH.
514BH-5158H	Whitespace skip utility.
515AH-5167H	Alphanumeric range check (digits 30H-39H, letters 41H-5AH).
5168H-5188H	Extended initialization and display width/PDRIVE pointer reset.
5189H-519AH	Multi-byte comparison routine (IY-indexed).
519BH-51AFH	Cursor position check and line wrap.
51B2H-51B5H	Type suffix table: $, %, !, # (4 bytes data).
51B6H-51BEH	"$EXT END" message + 0DH (9 bytes data).
51BFH-51D2H	NOP padding / runtime work area (20 bytes). This area and the memory beyond it (51D3H-51EFH+) serves as the runtime buffer space for variable names, comparison values, accumulator bytes, and filespec storage.

Complete list of runtime variables, self-modifying code locations, and work areas used by SYS12

Self-Modifying Code Locations Within SYS12

Address	Description
4E0CH	Iteration counter. Operand of LD A at 4E0BH. Written by: 4DD1H. Values: 00H = first pass, 01H = display pass, 02H = exit, 03H = line-number mode.
4E76H	Line number limit / current line number. Written by: 4D1DH (from expression evaluator), 4E17H (reset to FFFFH), 50E7H (from line header). Read by: 4EA6H (for display), 4F19H (for search).
4E7AH	Current line address. Written by: 4F70H (from program scan). Read by: 50DFH, 5087H, 5114H. Points to the current BASIC line's link pointer field.
4ED9H	Occurrence count temporary. Operand of LD DE at 4ED8H (low byte only). Written by: 4E9CH. Read by: 4EB3H. Stores the accumulator count for display.
4EEFH	PDRIVE table pointer. Operand of LD BC at 4EEEH. Written by: 5182H (init to 4300H), 512AH (updated). Read by: 5101H, 4EEEH.
4EF2H	PDRIVE field pointer. Operand of LD HL at 4EF1H. Written by: 5185H (init to 4300H), 4E6DH (updated). Read by: 4EF1H.
4FBEH/4FBFH	Column width for display wrapping. Operand of JR NC at 4FBEH. Written by: 4DEBH. Values: 30H = narrow (digits), 18H = wide (letters), 21H = initial default.
4F6DH	End-of-line detection opcode. First byte of the JP Z instruction at 4F6DH. Written by: 4DF0H (CAH = JP Z), 50DDH (C3H = JP unconditional). When CAH, end-of-line only triggers on null; when C3H, every line boundary triggers the jump.
4F7CH	Scan mode flag / opcode. First byte of the LD HL instruction at 4F7CH. Written by: 4D44H (C3H = JP for filespec mode), 4D4DH (21H = LD HL for variable mode). When C3H, the instruction becomes JP 512FH (filespec matching). When 21H, the instruction becomes LD HL,512FH (load address, continue to variable classification).
4FFCH	Conditional jump opcode (first comparison). First byte of JP instruction at 4FFCH. Written by: 4DDAH. Values: DAH (JP C) for first pass, C2H (JP NZ) for subsequent passes.
5021H	Column width for alternate comparison. Operand of JR C at 5020H. Written by: 517CH. Values: 18H (letters), 38H (digits/specials).
5085H	ON-statement address storage. Operand of LD DE at 5084H. Written by: 4DF6H (cleared to 0000H), 4FB4H (from ON token position). Read by: 5084H.
50A9H	Conditional jump opcode (second comparison). First byte of JP instruction at 50A9H. Written by: 4DDDH. Values: DAH (JP C) for first pass, C2H (JP NZ) for subsequent passes.

External Variable References

Address	Description
4020H	Screen cursor position. Read at: 51A1H. Used to determine column position for line wrapping.
40A4H	BASIC program start address. Read at: 4DCCH, 4F1DH. The starting point for all program text scans.
5D45H	Display flag (in BASIC/CMD). Written at: 4D04H. Stores the first argument byte for output formatting.

Runtime Work Areas (in NOP padding / beyond overlay)

Address	Description
51B2H-51B5H	Type suffix table: $, %, !, # (read-only data, 4 bytes).
51B6H-51BEH	"$EXT END" message (read-only data, 9 bytes).
51D3H-51D4H	Primary comparison value (length + first character of target).
51D9H	Variable name length byte.
51DAH-51DFH	Variable name characters (up to 6 bytes).
51E0H-51E4H	Digit collection buffer / comparison source for multi-byte compare.
51E5H-51EEH	10-byte accumulator buffer (occurrence counts per PDRIVE/type slot).
51EFH+	Filespec match buffer (up to 16 bytes, null-terminated).

Complete list of routines discovered in SYS12/SYS with entry addresses, brief descriptions, and calling conventions.

Entry and Parameter Parsing

Address	Description
4D00H	REF Command Entry Point. Parses the first argument byte and routes to the appropriate handler. Entry: HL points to BASIC command line text.
4D12H	Numeric Expression Handler. Calls ROM 1E5BH to evaluate a line number expression. Entry: HL points to 40H/60H token. Exit: DE=line number.
4D24H	Argument Type Detector. Tests for 22H (quote), D5H (USR), or variable name.
4D2CH	Quoted Filespec Handler. Copies up to 16 bytes to 51EFH, sets mode to C3H.
4D49H	Bare Variable Name Parser. Validates and copies up to 5 characters to 51DAH.
4D7FH	Syntax Error Exit. JP 1997H.
4D82H	Name Length Calculator. Calculates the number of characters copied, validates string-type constraints.
4D94H	Length Store. Stores length byte to (HL-1).
4D9AH	Non-String Init Entry. Calls 5171H, sets mode 02H, JP 4E2FH.
4DA2H	String Variable Adjustment. Adjusts secondary length field for string variables.
4DAAH	Type-Suffix-Only Handler. Clears 51D3H to 0000H for wildcard string search.

Initialization and Keyboard

Address	Description
4DB0H	REF Initialization. Sets BC=FFFFH, calls 5168H, enters keyboard polling.
4DB6H	Keyboard Polling Loop. Checks BREAK (bit 2), UP ARROW (bit 3), ENTER (bit 0) on row 3840H.
4DCBH	Scan State Setup. Clears A, loads 40A4H, patches conditional jumps and column widths.

Multi-Pass Controller

Address	Description
4DFCH	End-of-Line Handler. Checks scan mode (C3H vs CAH), dispatches to display or next-line processing.
4E0BH	Multi-Pass Dispatcher. Routes based on iteration counter: 00H→4E28H, 01H→4DB0H, 02H→RET, 03H→4E20H/$EXT END display.
4E20H	"$EXT END" Display. Outputs 9 bytes from 51B6H via 5D70H.
4E28H	First Pass Complete. Checks for wildcard (FFH), returns or enters display header.
4E2FH	Output Header Entry. Displays variable name, copies pattern to 51D3H, clears accumulator, dispatches by mode.
4E66H	PDRIVE Table Walk Entry. Starts at 4300H, reads link pointer, stores to 4EF2H.
4E73H	Clean Stack Exit. Unwinds stack, pushes 0000H twice, JP 2B33H.

Display Output

Address	Description
4E80H	Display Output Controller. Walks 10-byte accumulator, outputs line numbers with type separators and counts.
4E95H	Accumulator Display Loop. For each non-zero byte: calls 519EH, displays line number via 5D67H, shows separator (/ or (), suffix from 51B1H table, and count if ≥2.
4EEEH	PDRIVE Table Iterator. Compares 4EEFH vs 4EF2H, walks entries until sentinel 4340H.

Line Number Search

Address	Description
4F07H	Line-Number REF Entry. Validates search target, loads program start, walks lines comparing line numbers against BC.
4F27H	Line Search Loop. Reads link pointer + line number, skips to end-of-line, compares via SBC HL,BC.
4F41H	Search Complete. Sets iteration counter to 03H, JP 4DD0H.

Token Handlers

Address	Description
4F46H	Quoted String Skip. Pushes 4F77H as return address, scans for matching 22H or 00H.
4F55H	GOTO Handler. Scans for colons, quotes, and end-of-line within GOTO targets.
4F65H	Token Skip to End-of-Line. Skips all bytes until 00H (for REM, DATA).
4F6AH	Advance to Next Line. Increments DE past 00H, tests for end of program.
4F70H	Line Address Store. Saves DE to 4E7AH, skips 4-byte line header.
4F78H	Main Token Scanner. Core classification loop: letters→4F9BH, digits→4FBAH, space→skip, quote→4F46H, ampersand→504BH, period→4FE1H.
4F9BH	Letter/Token Classifier. Routes A (41H) to 5073H, letters to 5091H, REM to 4F65H, DATA to 4F65H, GOTO to 4F55H, ON to store+skip.

Numeric Handlers

Address	Description
4FBAH	Digit/Numeric Handler. Skips colons, collects up to 6 digits into 51DFH buffer.
4FC0H	Digit Collection Entry. Sets HL=51DFH, B=06H, handles leading zeros.
4FE1H	Numeric Skip. Skips remaining digits and decimal points.
4FF2H	Numeric Comparison. Calculates digit count, compares against 51D3H/51D4H target, calls 5189H for multi-byte match.
501CH	Alternate Comparison. Uses 51D9H/51DBH secondary pattern.
5037H	Copy Shorter Name. LDIR from 51DFH to 51DAH, calls 516EH.

Special Handlers

Address	Description
504BH	Ampersand Handler. Detects &D, &O, &H prefixes, skips hex digits.
5073H	'A' Prefix / AS Keyword. Checks for 'AS' keyword vs variable name starting with 'A'.
5091H	Variable Name Parser. Collects first two significant characters into C and B, skips remaining, compares against 51D4H target.
50A4H	Variable Comparison. Compares C,B against L,H from 51D4H.
50B2H	Type Suffix Detection. Loops through 4 suffixes at 51B5H using IY, checks for array parenthesis.
50D9H	Record Match. Increments accumulator at (HL), sets 4F6DH to C3H, reads line number from 4E7AH, stores to 4E76H.
50EEH	Alternate Name Comparison. Uses 51DAH as secondary pattern.

Utility Routines

Address	Description
5101H	PDRIVE Duplicate Check. Walks backward through table at 4EEFH checking for existing entries matching BC (4E7AH). If not found, adds new entry.
512FH	Filespec Match. Byte-by-byte comparison of program text against 51EFH buffer. On full match, routes to 50D9H.
514BH	Whitespace Skip. Advances DE past spaces (20H), tabs (09H, 0AH). Returns next non-whitespace character in A.
515AH	Alphanumeric Check. Returns NC for digits (30H-39H) and letters (41H-5AH), CARRY for others.
5161H	Letter Check. Returns NC for letters (41H-5AH), CARRY for others. Sub-entry of 515AH.
5168H	Extended Init. Stores BC to 51DAH, A=01H to 51D9H, falls through to 5171H.
516EH	Init with Length. Stores A to 51D9H, falls through to 5171H.
5171H	Display Width Init. Reads 51DAH, sets column width (18H or 38H) at 5021H, resets PDRIVE pointers to 4300H.
5189H	Multi-Byte Compare. Compares C bytes from 51E0H against (IY). Returns Z for match, NZ for mismatch.
519BH	CR + Line Wrap. Outputs CR via 5D52H then calls 519EH.
519EH	Cursor Check. Calls 5D3DH, reads cursor column from 4020H, wraps if column ≥53.

External Routines Called

4D00H - REF Command Entry Point and Parameter Type Detection

Entry point for the BASIC direct command REF. This section parses the REF command line to determine which reference format was requested: no argument (list all), a line number range (40H/60H tokens), a quoted filename (22H), a USR token (D5H), or a bare variable name. The result routes to the appropriate handler for cross-referencing variables, line numbers, or keywords in the currently loaded BASIC program.

4D24H - Quoted Filespec / USR Token / Variable Name Detection

Determines the REF argument type when it is not a line number range. Tests for a quoted filespec (22H = double-quote), the USR token (D5H), or falls through to parse a bare variable name.

4D2CH - Quoted Filespec Handler (REF "filename")

Handles the case where the user typed REF followed by a quoted filespec. Copies up to 16 bytes of the filename string into the match buffer at 51EFH, then sets the comparison threshold to 3000H (a value that exceeds all valid line numbers, effectively meaning "match in all lines") and sets the scan mode to C3H (JP opcode) to signal filespec-matching mode.

4D49H - Bare Variable Name Parser (REF varname)

Handles the case where the user typed REF followed by a variable name (e.g., REF X, REF A$, REF NUM%). Parses up to 5 characters of the variable name, detects type suffixes ($ and the string token CFH), and validates that the name contains only legal alphanumeric characters. The parsed name is stored starting at 51DAH (or 51D4H for string variables) with a length byte preceding the name.

4D7FH - Syntax Error Exit

Reports a syntax error when the REF command argument is invalid. Jumps to the ROM error handler at 1997H.

4D82H - Variable Name Length Calculation and Type Validation

After the variable name has been parsed, this section calculates the name length, validates it against the type suffix rules (string variables with a $ suffix must have 1 character, not 2+), stores the length byte, and routes to either the single-variable or multi-reference initialization path.

4DA2H - String Variable Length Adjustment

For string variables (those with a $ or CFH suffix), adjusts the secondary length field at 51D3H to include the total name length plus offset, then falls through to the BREAK-key check and main scan entry.

4DAAH - Type-Suffix-Only Handler (REF $)

Handles the case where the user typed REF followed by only a type suffix (e.g., REF $) with no variable name. This means "list all string variables." Clears the comparison value at 51D3H to 0000H and falls through to the initialization.

4DB0H - REF Initialization and BREAK Key Polling

Sets up the scan parameters by calling the initialization routine with BC=FFFFH, then enters a BREAK-key polling loop that waits for the user to press a key before starting the scan. The polling checks for the BREAK key (bit 2 of keyboard row 3840H), the @ key (bit 0), and the UP ARROW key (bit 3), using these to control whether to proceed, pause, or abort the REF listing.

4DCBH - Scan Initialization and Self-Modifying Code Setup

After the keyboard polling, initializes the scan state variables. Clears Register A, loads the BASIC program start address, stores the initial iteration count, configures the conditional JP/JR instructions via self-modifying code based on the variable type being searched, and begins the main program scan by jumping to the scan loop entry at 4F6BH.

4DFCH - End-of-Line Handler and Multi-Pass Controller

Called when the scan reaches the end of a BASIC line (the end-of-statement null byte at 4F6DH triggered a JP Z here). This routine checks the scan mode flag at 4F6DH. If C3H, all lines have been scanned and control passes to the display output at 4E80H. Otherwise, it checks whether the next line exists and routes to the line-number search at 4F07H or continues scanning. The multi-pass controller at 4E0BH dispatches based on the iteration counter: pass 0 goes to a fresh start, pass 1 re-enters the scan for additional variables, pass 2 returns to BASIC, and pass 3 exits with a formatted error message.

4E28H - First Pass Complete - Variable Scan Entry

After the first scan pass completes with iteration counter 00H, this section checks whether the search target is a wildcard (FFH at 51DAH). If so, the REF command returns to BASIC. Otherwise, it initializes the display header for the found variable and enters the output formatting section at 4E2FH.

4E2FH - REF Output Header and Variable Display

Displays the variable name header for the REF output. This section outputs the variable name (from the buffer at 51DAH) with appropriate spacing, clears the 10-byte line-number accumulator at 51E5H, and then dispatches to the appropriate scan pass based on the mode value.

4E73H - Clean Stack Exit to BASIC

Performs a clean exit from the REF command by unwinding the stack and jumping to the ROM BASIC warm-restart point at 2B33H. This is used when the scan has completed all passes (iteration counter reached 03H).

4E80H - Display Output Controller

The main display output controller. Called when the scan mode flag at 4F6DH has been set to C3H (scan complete). Checks the iteration counter at 4E0CH: if 03H, exits to BASIC via the stack cleanup at 4E73H. Otherwise, formats and displays the cross-reference results from the 10-byte accumulator buffer at 51E5H. Each byte in the buffer corresponds to a PDRIVE entry (drives 0-9), and non-zero values indicate that the variable was referenced in lines associated with that drive. The output format depends on whether the variable name starts with a letter (A-Z, using /nnnn format) or a digit/special character (using :n format).

4EEEH - PDRIVE Table Iterator

After display output is complete for iteration counter 01H, this section walks through the PDRIVE table entries starting at 4300H. For each entry, it checks whether the link pointer is non-zero (indicating a valid drive). If valid, it loads the next PDRIVE entry address and re-enters the scan. When the end of the PDRIVE table is reached (4340H sentinel), it jumps to the end-of-program handler at 4E0BH.

4F07H - Line-Number REF Entry and Validation

Entry point for the line-number REF mode (REF with a numeric argument or no argument). Validates the search target, then walks through the BASIC program text line-by-line searching for the target line number. If the line number is found, sets the iteration counter to 03H and re-enters the scan to display references.

4F46H - Quoted String Skip Handler

When a double-quote (22H) is encountered in the BASIC program text during scanning, this routine skips over the quoted string content. It searches for the matching closing quote or end-of-line (00H), then returns to the main scan loop.

4F55H - GOTO/GOSUB Statement Handler

When a GOTO token (88H) is encountered, this routine advances past the statement and scans for line number references, colons (statement separators), and quoted strings. This ensures the line numbers in GOTO/GOSUB targets are properly cross-referenced.

4F65H - Token Skip to End-of-Line

Skips all remaining bytes on the current line until the 00H end-of-line marker is found. Used for tokens like REM (93H) and DATA (FBH) whose content should not be cross-referenced.

4F6AH - Advance to Next Line

Advances DE to the next byte after the current end-of-line marker and tests whether it is the start of a new line (non-zero) or the end of the program (00H). If end-of-program, jumps to the end-of-line handler at 4DFCH.

4F70H - Line Address Store and Header Skip

Stores the current program position (DE) as the line address at 4E7AH, then advances DE past the 4-byte line header (link pointer + line number) to point to the first tokenized byte of the line.

4F78H - Main Token Scanner

The core token-scanning loop of the REF command. Reads each byte from the current BASIC line, classifies it (letter, digit, space, quote, special character, or token), and dispatches to the appropriate handler. This is where the actual cross-referencing occurs: variable names, filespecs, line numbers, and keywords are identified and matched against the search target.

4F9BH - Letter and Token Classifier

Classifies bytes at 41H and above: letters (41H-5AH) route to the variable-name parser, tokens below 5BH route to the variable handler, and specific tokens (REM=93H, DATA=FBH, GOTO=88H, ON=A3H) have specialized handlers.

4FBAH - Digit and Numeric Constant Handler

Handles bytes in the range 30H-3FH (digits, colon, semicolons). A colon (3AH) is a statement separator; digits (30H-39H) introduce a numeric constant. Numeric constants are collected into the buffer at 51DFH for comparison against the search target.

4FF2H - Numeric Constant Comparison

After collecting digits, calculates the digit count and compares the numeric constant against the search target. Compares both the digit count and the actual digits stored in the buffer at 51DFH against the target values at 51D3H/51D4H. If a match is found, the accumulator buffer entry is incremented.

501CH - Alternate Comparison Path (Longer Name Match)

When the digit count exceeds the target, checks whether this is a longer variable name that starts with the same characters as the search target. Uses the alternate comparison values at 51D9H/51DBH and the multi-byte comparison at 5189H.

5037H - Copy Shorter Name to Active Buffer

When the collected name is shorter than the primary target but may match the secondary pattern, copies the collected name from 51DFH to 51DAH and calls the extended initialization at 516EH.

504BH - Ampersand Prefix Handler (&H / &O / &D)

Handles the ampersand prefix character (26H) which introduces hex (&H), octal (&O), or decimal (&D) constants in BASIC. Reads the character after the ampersand to determine the base, then skips past the constant's digits.

5073H - 'A' Prefix Handler (AS Keyword Check)

When the character is 41H (ASCII 'A'), checks whether the next character forms the 'AS' keyword by looking for 'S' followed by a non-alphanumeric character. If 'AS' is detected, it is processed as a keyword. Otherwise, routes to the variable name parser at 5091H.

5091H - Variable Name Parser (from Program Text)

Parses a variable name from the BASIC program text. Reads characters, collecting letters and digits, and stores the first two significant characters for comparison against the search target. After the name is collected, compares it against the target variable name at 51D4H using the self-modifying conditional jump at 50A9H.

50D9H - Record Match and Continue Scan

Records a match by incrementing the accumulator byte at (HL), resets the scan mode flag to C3H (enabling the end-of-scan jump), reads the line number from the current BASIC line header, stores it at 4E76H, and continues scanning.

50EEH - Alternate Variable Name Comparison

When the first character matches but the second does not (or the comparison mode differs), this section uses the alternate comparison values at 51DAH to check for a broader match.

5101H - PDRIVE Table Duplicate Check

Checks the PDRIVE reference table at 4EEFH/4EF2H for duplicate entries before recording a new reference. Compares the current reference address against existing entries and either updates an existing entry or adds a new one.

512FH - Filespec Match Routine

Compares the current token in the BASIC program text against the filename stored at 51EFH. Called when the scan mode is C3H (filespec mode). Performs a byte-by-byte comparison of the program text against the match buffer. If a match is found, routes to the accumulator recording logic at 50D9H.

514BH - Whitespace Skip Utility

Advances DE past whitespace characters (space 20H, tab 09H, line-feed 0AH) and returns the next non-whitespace character in Register A. Returns NC for printable characters, CARRY for control characters below 09H.

515AH - Alphanumeric Range Check

Tests whether Register A contains a digit (30H-39H) or a letter (41H-5AH). Returns CARRY set if the character is NOT alphanumeric, NO CARRY if it is.

5168H - Extended Initialization Routine

Stores BC to the variable name buffer at 51DAH, writes 01H to the length byte at 51D9H, then falls through to 5171H to configure the display width and reset the PDRIVE table pointers.

5171H - Display Width and PDRIVE Pointer Initialization

Reads the first byte of the variable name at 51DAH, determines the display column width (18H for letters, 38H for digits/specials), stores it to the self-modifying code target at 5021H, and resets the PDRIVE table pointers at 4EEFH and 4EF2H to 4300H.

5189H - Multi-Byte Comparison Routine

Compares C bytes starting at 51E0H against C bytes starting at (IY). Returns Z if all bytes match, NZ if any differ. Register B is used as the loop counter (loaded from C). If C is 00H, returns immediately with Z set (empty comparison always matches).

519BH - Cursor Position Check and Line Wrap

Checks the current cursor position to determine whether there is enough room on the display line for the next reference output. If the cursor has reached column 53 (35H) or beyond, outputs a carriage return and leading spaces to start a new indented line. If there is room, outputs a space separator.

51B2H - Data Tables

Static data tables used by the REF command. These include the type suffix characters, the "$EXT END" display message, and the variable name work areas. The bytes from 51B2H through 51D2H are data, not executable code.