TIME

TIME CHECK is a world time zone conversion program that calculates the corresponding local time in one city or country given a known time in another. It maintains a database of city/country names paired with numerical UTC offset codes, stored as machine code data beginning at address 32552 and searched via a USR call. The program saves and loads this city database as a separate CODE block (“time C”) alongside the BASIC program itself, allowing the data to persist across sessions and grow as users add entries via the menu. Input validation routines check for alphabetic city names and numeric hour values, and the time arithmetic handles AM/PM labeling, noon, and midnight edge cases using 24-hour clock arithmetic.

---

Program Structure

The program is organized around a main menu at line 350 and uses two key pointer variables: V=200 (pointing to the header display subroutine at line 200) and W=350 (pointing to the menu entry point). GO SUB V and GO TO W are used throughout as indirect calls, a compact BASIC idiom that avoids hardcoded line numbers in repeated jumps. Menu selection at line 460 uses GO TO VAL X$*2000 to dispatch directly to line 2000, 4000, 6000, or 8000 for the four menu options.

• Lines 100–180: Alphabetic name validation subroutine
• Lines 200–230: Screen header display subroutine
• Lines 240–310: Numeric hour validation subroutine
• Lines 320–340: Invalid input error handler
• Lines 350–460: Main menu
• Lines 2000–2395: Time inquiry (menu item 1)
• Lines 2400–2690: City/country database lookup subroutine
• Lines 4000–4190: Add city/country to database (menu item 2)
• Lines 5000–5080: “Not found” handler
• Lines 6000–6320: Information screen (menu item 3)
• Lines 8000/9000: Save to tape (menu item 4)
• Lines 9900–9999: Load stub and exit

Machine Code Database Engine

The city/country database is stored as raw bytes beginning at address 32552 in RAM. Each record consists of a numeric code prefix (the city’s time as a 24-hour value when GMT is 12:00) followed by the city name and terminated by a byte value of 23. A new entry is prepended with an asterisk ("*") as a record separator at line 4090. The variable P tracks the current write offset into the data area.

Lookup is performed by a machine code routine called via USR 32552 at line 2530. Before calling it, the program POKEs the search string (appended with a █ block character as a terminator) into the data area starting at address 32513, and sets up a subroutine address via POKEs at 32604–32607. The result address of the matched record is returned in PEEK 32617 + 256 * PEEK 32618. If the returned address equals 32658 (the start of the actual data), the search failed and the program branches to line 5000.

After a successful match, lines 2543–2590 walk through memory from the match address, extracting numeric characters (ASCII 45–57, excluding 45 and 47) into B$ and uppercase alphabetic characters plus spaces, commas, and periods into D$, stopping when a byte value of 42 (*) is encountered.

Time Arithmetic

The offset code stored for each city represents the local hour when GMT is 12:00. The time difference between two cities is computed at lines 2170–2200:

1. A = VAL A$ — source city’s GMT-relative code
2. B = VAL B$ — destination city’s GMT-relative code
3. T = B - A + F — destination time = displacement + known hour

Lines 2230–2290 then normalize T into the 1–12 range and assign AM/PM, NOON, or MIDNIGHT labels. A fractional-hour check at lines 2326–2327 handles half-hour time zones: if T - INT T <> 0, the display suffix is changed from ".OO " to "0 " and T is adjusted by adding 0.3 to the integer part, which converts a decimal 0.5 into a display value of x.3 — an approximate but visible indicator of a half-hour offset rather than a true formatted output.

Save/Load Mechanism

Menu item 4 triggers line 9000, which performs two SAVE operations: first the BASIC program itself with LINE 9900 as the auto-start line, then the machine code and data block as a CODE file named "time C" covering 106+P bytes from address 32552. The load stub at line 9900 prints a message and then executes LOAD "time C" CODE followed by GO TO 350, reassembling the full program state from tape.

Input Validation

Two validation subroutines are used. The alphabetic validator (lines 100–180) scans X$ character by character, rejecting input that contains non-alphabetic characters (outside A–Z, CHR$ 65–90) other than spaces, periods, or commas, and also rejects strings with more than one consecutive space (double-space check via counter Q). The numeric validator (lines 240–310) checks that all characters are in the range CHR$ 46–57 (digits and period), counts decimal points (max one), and then validates that the numeric value is between 0 and 24 and is a whole integer (X <> INT X test at line 302).

There is a minor bug at line 260: the condition X$= CHR$ 47 compares the entire string X$ to the slash character rather than the individual character X$(A), so the slash exclusion never triggers correctly.

Notable Idioms and Anomalies

• The GO TO VAL X$*2000 dispatch at line 460 is an efficient computed-GOTO technique.
• GO SUB V with V=200 and GO TO W with W=350 provide single-point redirection for the header and menu, useful during development or modification.
• Line 2395 (GO TO W) is unreachable, placed after GO TO 9996 at line 2390.
• Line 2310 contains a commented-out PRINT statement preserved as a REM, alongside its replacement at line 2311, indicating iterative development.
• The exit screen at lines 9996–9999 prints “TEMPUS FUGITS” — a humorous if slightly incorrect Latin phrase (the correct form is “tempus fugit”) — before halting.
• Lines 2370–2380 use two consecutive INKEY$ checks without a pause between them, which on fast hardware can cause the “Y” keypress from 2370 to also satisfy 2380, making it difficult to decline another check. A PAUSE 0 between them would be more robust.