Flexigen

FLEXIGEN is a report-generation utility that loads tabular data from tape and assembles user-defined columnar reports for printing. The program allows users to define up to nine “blocks,” each specifying row and column ranges from a source data array, along with a print position and start line, which are stored in a two-dimensional array S(B,6). Data files are stored in two parts on tape: a parameters file (suffixed “P”) containing dimensions and a data file (suffixed “D”) holding the actual string array. The assembled report is built into a string array R$ dimensioned to accommodate all blocks, then printed in page-width slices using LPRINT, supporting printer widths from 20 to 132 characters. The function FN A() computes the end print position for a block, combining print-position and column-range data to streamline bounds calculations.

---

Program Analysis

Program Structure

FLEXIGEN is organized as a menu-driven application with clearly separated functional modules, each anchored at a round line number. Control flow is handled almost entirely via GO TO and GO SUB, with the main menu at line 9000–9040 dispatching to one of four modules based on a keypress.

Line Range	Module
100–109	Y/N/X confirmation subroutine
110–149	Block specification entry subroutine
190–199	“Press X to return to menu” handler
200–204	Error: no report specification present
1010–1220	Module 1: Load file from tape
2010–2999	Module 2: Enter report specification
3005–3200	Module 3: Assemble report
4005–4110	Module 4: Print report
9010–9040	Main menu

Menu Dispatch

The menu at line 9030–9040 reads a keypress and validates it by checking CODE Z$ is in the range 49–52 (characters “1” to “4”). The dispatch uses GO TO VAL Z$*1000, which multiplies the numeric value of the keypress by 1000 to jump directly to the appropriate module entry point (1000, 2000, 3000, or 4000). This is an efficient single-expression dispatch that avoids a chain of IF statements. Note that the module entry points are actually at lines 1010, 2010, 3005, and 4005 — the GO TO targets non-existent lines 1000, 2000, 3000, 4000, which causes execution to fall through to the next available line in each block.

Data Storage and File Format

The program uses a two-file tape format. The parameters file (filename suffixed “P”) is saved as a numeric array A() containing at least three elements: the row count C, the column count C1, and a third value A. The data file (suffix “D”) holds the main string array S$(C, C1*10+1). The factor of 10 in the column dimension implies each logical column occupies 10 characters in the stored string, allowing fixed-width fields to be sliced by arithmetic rather than delimiter parsing.

User-Defined Function FN A()

Line 3 defines FN A() as:

S(L,5) + 10*(S(L,4) - S(L,3) + 1)

This computes the end print position for block L by adding the start print position (S(L,5)) to ten times the number of source columns in the block (S(L,4) - S(L,3) + 1). The factor of 10 again reflects the 10-characters-per-column convention. The function is referenced in lines 3030, 3100, and 3060 to find the maximum extent of all blocks and to assign substrings into the report array.

Line 3 also executes POKE 23609,65, which sets the keyboard repetition delay — a common idiom to tune key-repeat behavior at program start.

Report Assembly

Module 3 (lines 3005–3200) performs a two-pass assembly. The first pass (lines 3020–3050) scans all blocks to find the maximum print-position extent MX, the total output row count RO, and the minimum print position MN. The report string array R$ is then dimensioned to (RO, RL) where RL is rounded up to the next multiple of the printer width PW. The number of page columns CN is thus RL/PW.

The second pass (line 3100) iterates over all blocks and rows. For each source row, it first spaces-fills the relevant column range in S$, then copies the data slice into the correct position in R$ using string slicing. This handles overlap and ensures blank padding.

Report Printing

Module 4 (lines 4005–4110) prints the assembled report in vertical slices. The outer loop iterates over page columns (L=1 TO CN), and the inner loop iterates over output rows (K=1 TO RO). Each row slice is extracted as R$(K, L*PW-PW+1 TO L*PW) and sent to the printer via LPRINT. A blank LPRINT after each page column provides a page break or column separator.

Input Validation

All INPUT statements are followed by immediate validation loops. The pattern used throughout is:

• Check numeric bounds against known dimensions (C, C1)
• Check integer constraint with INT x <> x
• Check ordering constraints (e.g., FR < SR) to ensure end > start
• Loop back to the same INPUT line on failure

Notable Anomalies

• Line 2060 branches to GO TO 2000 on “N”, but line 2000 does not exist; execution falls to 2010, restarting the report specification entry. This is consistent with the non-existent-line dispatch technique used elsewhere.
• Line 140 references GO SUB 100 but the confirmation subroutine begins at line 102. Line 100 does not exist, so execution starts at 102 — another intentional non-existent-line fall-through.
• Line 3040 references the variable PP directly rather than S(L,5). At this point in execution, PP retains the value from the last block specification input (line 134), so this comparison for minimum print position MN only reflects the last block entered, not all blocks. This appears to be a bug — the minimum across all blocks is not correctly computed.
• The variable MN is computed but never subsequently used in the program, making the minimum print-position calculation dead code.
• Line 2010 contains a typo in the print string: “SPECIFICATON” (missing an ‘I’), versus the correct spelling at line 112.