General Ledger

This program implements a general ledger accounting system, providing functions for creating ledger cards, entering transactions, generating trial balances, and producing profit-and-loss statements. Up to 30 accounts are supported, each holding up to 10 transaction entries stored in parallel arrays (date in D$, reference in E$, debit in F, credit in G), with running balances maintained in H(). The currency formatting subroutine at line 4000 uses STR$ with rounding to two decimal places, and includes fixes for leading decimal points such as “.50” becoming “0.50”. A year-end transfer routine at line 7000 clears transaction arrays and posts the closing balance as a brought-forward entry, resetting each card to a single opening entry. Data is saved to tape via a STOP/CONT pattern that allows the user to prepare the recorder before executing the SAVE command.

---

Program Analysis

Program Structure

The program is organised as a menu-driven shell (lines 10–60) dispatching to six functional modules via GOTO. The main menu loop runs from line 10 and re-enters itself after most operations via GOTO 10.

1. Lines 10–60: Main menu and dispatcher
2. Lines 100–500: Register initialisation (option 0) — DIM statements and variable resets, year entry
3. Lines 1001–1050: Open new ledger card (option 1)
4. Lines 2005–2610: Account search and transaction entry (option 2)
5. Lines 3000–3980: Trial balance and P+L statement (option 3)
6. Lines 4000–4215: Subroutines — currency formatting (4000), display transaction row (4100), display balance (4200)
7. Lines 6000–6003: Save to tape (option 4)
8. Lines 7002–7150: Year-end account transfer (option 5)

Data Structures

The program uses parallel arrays to simulate a record structure. Each account occupies a fixed block of 10 slots in the transaction arrays. Account C maps to transaction indices (C*10)+1 through C*10+10.

Array	Size	Purpose
A$(30,10)	30 × 10 chars	Account names (10-char limit)
C(30)	30	Declared but not actively used (balance stored in H)
D$(310,5)	310 × 5 chars	Transaction date
E$(310,4)	310 × 4 chars	Transaction reference
F(310)	310	Debit amounts
G(310)	310	Credit amounts
H(30)	30	Running account balance (debit positive, credit negative)
N(30)	30	Next free transaction index per account
T(30)	30	Account type: 0=balance sheet, 1=P+L
B(1), J(1), K(1)	1	Scalar placeholders (single-element arrays)

The scalar variables B, J, K, etc. are used independently of the single-element arrays of the same letter — a common Sinclair BASIC technique where DIM B(1) does not affect the plain variable B.

Currency Formatting Subroutine (line 4000)

The subroutine at line 4000 converts numeric value P into a formatted two-decimal-place string P$. It handles three edge cases:

• Values between 0 and 1 where STR$ produces ".5" — prefixed with "0" at line 4010.
• Negative values between -1 and 0 where STR$ produces "-." — corrected to "-0..." at line 4020.
• Integers with no decimal point — ".00" appended at line 4060.
• Values with only one decimal digit — a trailing "0" appended at line 4070.

Rounding is achieved via INT (P*100+.5)/100, which is the standard Sinclair BASIC two-decimal rounding idiom.

Transaction Entry Flow

Entry begins at line 2100. The variable X holds C*10, the base offset for the current account’s transaction block. N steps from X+1 up to a maximum of X+10. For each transaction, date (D$), reference (E$), debit (F), and credit (G) are collected sequentially. The running balance H(C) is updated immediately: debits add, credits subtract. A three-option sub-menu (continue, error correction, return) appears after each entry.

The error-correction path (option 2, line 2550) allows the user to reverse the last debit or credit entry by decrementing N and adjusting H(C), then re-entering from line 2320 (which is line 2325 effectively — a minor label off-by-one, jumping into the middle of the entry loop).

Trial Balance (lines 3000–3200)

The trial balance iterates over accounts 1 to O (where O holds the count of opened accounts). Positive balances are accumulated in R (debits) and negative balances in S (credits, stored as negative). The display uses TAB with LEN P$ subtracted to right-align figures in debit (column 21) and credit (column 32) positions. If the account count exceeds 14, the balance is carried forward across two screen pages using STOP/CONT as a pause mechanism (lines 3099 and 3205).

The error line at 3200 prints the difference between debit and credit totals. Ideally this should be zero; the label “ERROR:” is used to indicate any imbalance.

Profit and Loss Statement (lines 3500–3980)

P+L only processes accounts where T(C)=1. Income accounts (credit balance, i.e. H(C)<1) accumulate in S; expense accounts (H(C)>1) in R. The net result is computed as (R+S)*-1 — a negative result indicates a loss, as noted on screen.

Year-End Transfer (lines 7002–7150)

The transfer routine clears the 10-entry transaction block for the chosen account, then writes a single brought-forward ("BFD.") entry using the closing balance. If the balance is positive it is placed in the debit column (F(N)); if negative, in the credit column (G(N)). The account pointer N(C) is reset to the first slot.

Tape Save (lines 6000–6003)

Saving uses the STOP/CONT idiom: execution halts at line 6001, the user starts the tape recorder, then continues. The SAVE "G/%L" at line 6002 saves the program. After saving, GOTO 5 targets a non-existent line, which causes execution to fall through to line 8 (the next line in the program), effectively restarting cleanly from the copyright REM.

Bugs and Anomalies

• Lines 200–235 use plain variables (LET B=0, LET C=0, etc.) to initialise what are intended to be array elements, but without subscripts these reset the scalar variables only, not the array contents. The arrays themselves are left at their default zero/space values from DIM, so this is harmless in practice on first run but would not correctly re-initialise arrays if option 0 were selected after data entry.
• The trial balance loop at line 3065 uses FOR C=U TO C, where both the loop variable and the limit share the name C. The limit is evaluated once at loop start, so this works correctly, but it is unusual style.
• Line 3097 checks IF C>=O THEN GOTO 3200 to skip the page-break prompt if all accounts fit on one page, but the condition should perhaps be C>14 or similar; the current logic depends on the loop having incremented C past O naturally.
• The P+L thresholds at lines 3620 and 3630 use >1 and <1 rather than >0 and <0, meaning accounts with a balance of exactly 1 or -1 are excluded from both totals.
• Line 4100 is entered via GOSUB 4100 but the subroutine body begins at line 4106, with lines 4100–4105 absent. Execution falls through from 4100 to 4106 correctly since there are no intervening lines, but the GOSUB target is effectively line 4106.
• Line 7080 uses IF H(C)<1 (should be <0) for the credit brought-forward test, meaning a balance of exactly 0 would write a zero to the credit column rather than being skipped.