Home Asset Manager

Home Asset Manager is a valuables inventory program that lets users add, delete, search, list, and save records describing household assets with fields for date, serial number, model, description, price, and location. Each record is stored as a fixed-length string in a DIM D$(MAX,RLEN) array, with record indices tracked via a packed string U$ whose characters serve as array row pointers, allowing up to 255 records. The program calculates available memory at runtime using PEEK on system variables 16386/16387 and 16412/16413 to determine how many records will fit before dimensioning the array. A machine code routine at line 9800–9830 is used for fast string searching, invoked via USR 16524 after POKEing the search key into address 16514. The listing routine at line 7000 supports output to screen, printer, or both, and can accumulate running totals for fields whose names begin with a period.

---

Program Analysis

Program Structure

The program is organized into clearly labeled REM-delineated sections, each reachable via computed GO TO at line 1250 (GOTO VAL "1000+1000*VAL C$"), which dispatches menu choices 1–6 to line 2000 (Add), 3000 (Delete), 4000 (Find/Search), 5000 (Save), 6000 (Quit), and 7000 (List). Control returns to the main loop at line 1000 after most operations.

Line Range	Section
10–860	Initialization, screen template, field definitions
1000–1250	Main display/menu loop
2000–2240	Add record
3000–3090	Delete record
4000–4550	Search/Find
5000–5080	Save to tape
6000–6020	Quit
7000–7250	List records
8000–8790	Utility subroutines (pause, print, totals)
9800–9830	Machine code search wrapper

Initialization and Memory Calculation

Lines 20–860 perform a detailed initialization sequence. Constants like O=PI/PI (i.e., 1) and Z=O-O (i.e., 0) are used throughout as integer substitutes, a common ZX81 BASIC idiom to avoid slow integer-parsing of literals. The screen template string S$ is built by concatenation of block-graphic border characters and spaces to create a framed display area.

At line 550, available free RAM is computed directly from system variables:

• PEEK 16386 + PEEK 16387*256 — RAMTOP (top of usable RAM)
• PEEK 16412 + PEEK 16413*256 — start of the display file or variables area

After subtracting 400 bytes of overhead, MAX is calculated as how many fixed-length records of size RLEN+5 will fit, capped at 255 (line 565) because record indices are stored as single characters in U$, whose CODE values must fit in one byte.

Record Storage Scheme

Records are stored in D$(MAX,RLEN), a two-dimensional string array where each row is one fixed-length record. The record length RLEN is computed at runtime by summing the field widths F(1) through F(FLDS) (lines 510–540). Six fields are defined:

Field	Name	Width
1	DATE	8
2	SERIAL	15
3	MODEL	10
4	DESCRPT	15
5	.PRICE	8
6	PLACE	10

The “active record index” string U$ tracks which rows of D$ are in use. Each character’s CODE value is the row index into D$. Free row indices are tracked in E$, initialized at lines 860–880 by appending CHR$ B for each possible index from 1 to MAX. When a record is added, a character is consumed from the front of E$ and appended to U$.

Machine Code Usage

Line 10 contains a REM statement with embedded machine code bytes: itemtype='https://schema.org/Blog' itemscope='itemscope' class="wp-singular computer_media-template-default single single-computer_media postid-51725 wp-custom-logo wp-embed-responsive wp-theme-astra wp-child-theme-astra-child ast-desktop ast-separate-container ast-left-sidebar astra-4.12.6 group-blog ast-blog-single-style-1 ast-custom-post-type ast-single-post ast-inherit-site-logo-transparent ast-hfb-header ast-full-width-primary-header ast-box-layout ast-normal-title-enabled astra-addon-4.12.4"B itemtype='https://schema.org/Blog' itemscope='itemscope' class="wp-singular computer_media-template-default single single-computer_media postid-51725 wp-custom-logo wp-embed-responsive wp-theme-astra wp-child-theme-astra-child ast-desktop ast-separate-container ast-left-sidebar astra-4.12.6 group-blog ast-blog-single-style-1 ast-custom-post-type ast-single-post ast-inherit-site-logo-transparent ast-hfb-header ast-full-width-primary-header ast-box-layout ast-normal-title-enabled astra-addon-4.12.4"B...\C9. This is a Z80 routine loaded into the REM area, invoked via USR 16524 at line 9820. The search subroutine (lines 9800–9830) POKEs the search character into address 16514, then calls the machine code routine and uses 255-USR 16524 to derive a result. This is a standard technique for embedding and calling machine code within a REM statement on this platform.

Search Mechanism

The search routine (lines 4000–4200) calls the Add subroutine at line 2115 to collect search key values into buffer B$. It then iterates over all records in U$, comparing each field in the record against the corresponding field from B$ after stripping trailing spaces (subroutine at 4500). A record matches if every non-empty search field matches as a prefix of the stored field value (Y$(TO LEN X$)=X$). Matching record indices are collected into L$, which is then temporarily substituted for U$ to display results via the List routine.

The delete operation at lines 3000–3090 uses the machine code search subroutine (via GOSUB 9800) to locate the current record’s index J within U$, then splices it out with string slicing.

Navigation and Display

The main loop at line 1015–1170 implements a blinking cursor effect by alternating POKEs at two display file addresses (D+67 and D+98) between two block graphic characters, toggled by FL=NOT FL. The variable D is the display file address computed from system variable at DF (16396).

Record browsing is handled by lines 8500–8530: pressing CHR$ 113 (“q”) increments CR (current record pointer into U$) and pressing CHR$ 112 (“p”) decrements it, with boundary checks. The menu selection animation at lines 1220–1240 scrolls a cursor character down the screen using a FOR loop with STEP -O (i.e., step –1).

Listing and Totals

The List routine (lines 7000–7250) outputs to screen, printer, or both depending on the user’s choice, using a shared output subroutine at line 8100 that conditionally calls LPRINT and/or PRINT. Fields whose names begin with "." (here, .PRICE) are automatically summed into array T(FLDS) at line 7115, and totals are printed by the subroutine at line 8600. A pagination counter LCNT pauses screen output when a page fills.

Notable Techniques and Idioms

• O=PI/PI and Z=O-O as integer constants 1 and 0 to speed execution and reduce program size.
• VAL "expression" used in computed GO TO targets and initializations (e.g., line 105 SZ=VAL "22-1-MS") — a known memory-saving technique.
• Packed index string U$ using character codes as array row pointers — a compact record-tracking approach within BASIC’s string capabilities.
• Free memory probing via PEEK on system variables before dimensioning arrays, allowing the program to adapt to whatever RAM is available.
• The GOSUB 2115 call from line 4030 re-uses the Add record input section mid-program, with a sentinel check at line 2180 (IF C$="3" THEN RETURN) to distinguish search-mode entry from actual adds.
• The blinking cursor at lines 1152–1156 uses direct POKE to the display file rather than PRINT AT, avoiding screen flicker from redrawing.

Bugs and Anomalies

• Line 1100 uses TAB O (TAB 1) repeatedly in a single PRINT statement to create column separations — these are literal TAB 1 calls, which may not provide the expected spacing since TAB moves to an absolute column position, not a relative one, and repeated TAB 1 calls after text has already passed column 1 would have no effect.
• The field-width loop at lines 4070–4110 slices T$ and Z$ starting from index 1 each time within the loop but also advances by slicing from F(F)+1, so the first field would correctly use T$(1 TO F(1)) and subsequent iterations also work correctly due to repeated re-slicing — this is slightly inefficient but functionally correct.
• Line 570 prints “RECORDS AVAILIBLE” — a misspelling of “available” that would appear on screen during initialization.
• The loop at lines 4042–4044 (FOR H=1 TO 10: NEXT H) is an empty delay loop with no effect in FAST mode (line 4056 sets FAST after this loop, but the delay itself is before FAST). It likely served as a brief pause before the FAST search begins.
• Line 6020 (GOTO 1000) is unreachable because line 6010 is STOP, so the program can only continue from the Quit section if the user does a CONTINUE command.