Acorn 6502 Tube Client 1.10 (external 65C02 3 MHz)

Print the startup banner, patch the soft reset entry to skip the banner on future resets, then wait for the host's acknowledge byte.

If the acknowledge has bit 7 set, the host is requesting code execution; otherwise enters the command prompt.

The main supervisor command prompt.

Prints a '*' prompt, reads a line of input using OSWORD 0, and passes it to OSCLI for execution. Handles Escape by acknowledging it and reporting the error.

Check whether the code at the data transfer address has a valid ROM header with a (C) string, and if so verify it is a 6502 language ROM.

Sets the current program and memory top to the transfer address, then enters the code with A=1. If the header is missing or invalid, enters with A=1 anyway (raw code entry). Generates an error if the ROM type indicates it is not a language or not 6502 code.

Note: the v1.10 ROM always enters with A=1 regardless of whether it is a RESET or OSCLI entry, and does not pass the carry flag. J.G. Harston identifies this as a bug.

Enter code at the transfer address without a valid ROM header. Loads A=1 and jumps via the memory top pointer (which has been set to the transfer address).

Note: J.G. Harston identifies a bug where raw code should be entered with A=0, and the carry should indicate whether the entry is from RESET or OSCLI.

Set up the BRK vector to point to the default error handler, then generate error 0: 'This is not a language'. The error handler must be re-established here because the previous language's handler will have been overwritten.

Set up the BRK vector to point to the default error handler, then generate error 0: 'I cannot run this code'. Called when the ROM type indicates the code is not suitable for a 6502 processor.

Default BRK handler. Clears the stack, prints the error message from the BRK instruction, and returns to the command prompt.

Parameter block passed to OSWORD 0 (read line) when reading input at the supervisor command prompt. Specifies where to store the input text, the buffer size, and the range of acceptable character codes.

Send character in A to the host via Tube R1.

Read a character from the host via the Tube.

Sends command &00 to the host, then waits for a carry byte and the character.

Wait for two bytes from Tube R2: first a carry indicator, then the data byte.

The carry byte is shifted left so bit 7 moves into the carry flag, then falls through to read the actual data byte.

Poll Tube R2 status until data is available, then read and return the byte.

An RTS used as a no-op handler for vectors that have no action (EVNTV, IND1V-IND3V in the default table).

Increment Y then fall through to skip_spaces. Called when the current character has been consumed and any following spaces should be skipped.

Advance past space characters in the string at (string_ptr),Y.

Read a hexadecimal number from the string at (string_ptr),Y into the hex accumulator at &F0/F1.

Send a CR-terminated string to the host via Tube R2.

Execute a * command. Parses the command to check for *GO and *HELP which are handled locally; all other commands are forwarded to the host via the Tube.

Print local help text showing the Tube Client version, then fall through to forward the *HELP command to the host.

Forward the command string at (string_ptr) to the host via Tube R2 with command code &02.

Tube protocol: &02 string &0D -- &7F or &80

If the response has bit 7 set, code needs to be entered (a language was selected).

Wait for the host's response byte after sending an OSCLI command. If the response has bit 7 set (&80), the host has selected a language and code needs to be entered at the transfer address. Otherwise restore A and return to the caller.

Also used by OSBYTE &8E (select language) via the check at osbyte_check_ack.

Parse *GO [address]. If an address is given, set the transfer address to it. If no address given, use the current transfer address. Falls through to execute the code.

Note: does not check for a separator after 'GO', so commands like *GOAD would be incorrectly matched. J.G. Harston identifies this as a bug.

Save the current program pointer, call enter_code, then restore the current program and memory top on return.

Note: in v1.10, the carry flag is not explicitly set before calling enter_code, so entered code cannot reliably distinguish RESET from OSCLI entry. J.G. Harston identifies this as a bug.

Entry point used by OSBYTE &8E (select language). If the function matched &8E, branches to wait for the OSCLI acknowledgement byte from the host, which may trigger code entry.

Handle OSBYTE calls. Functions &82-&84 are handled locally (memory high word, bottom/top of memory). Low functions (A < &80) send command &04 with X and A. High functions send command &06 with X, Y, and A.

Special handling for OSBYTE &8E (select language) which checks for code to enter, and &9D (fast BPUT) which returns immediately without waiting for a response.

Return the current top of user memory from &F2/F3. Falls through to the RTS at osbyte_himem_rts.

Return the bottom of user memory, fixed at &0800. Shares its RTS with osbyte_read_high_word.

Return &0000 as the high word of the address space. This indicates the 6502 has a 16-bit address space with no bank switching.

Handle OSWORD calls. OSWORD 0 (read line) is handled specially via rdline. All other functions send the control block to the host and receive the response, with block sizes determined by lookup tables.

Read a line of text from the host.

Sends command &0A with the control block parameters, then receives the input string character by character.

Tube protocol: &0A block -- &FF or &7F string &0D

Read or write information about an open file.

Sends command &0C with handle, 4-byte data word, and function code. Receives result and updated data.

Open or close a file.

For close (A=0): sends command &12, function, handle. For open (A<>0): sends command &12, function, filename.

Read a byte from an open file.

Sends command &0E with handle, waits for carry and byte.

Write a byte to an open file.

Sends command &10 with handle and byte.

Wait for Tube R2 to be free, then send byte.

Operate on whole files (load, save, read/write attributes).

Sends command &14 with 16-byte control block, filename, and function code. Receives result and updated control block.

Multiple byte read and write.

Sends command &16 with 13-byte control block and function. Receives updated control block, carry, and result.

Generate a 'Bad' error for unsupported MOS calls. Used as the default handler for USERV, IRQ2V, FSCV, and several other vectors that have no parasite-side implementation.

Indexed by OSWORD number via LDY table,X where X is the OSWORD function. Entry 0 is never used because OSWORD 0 (RDLINE) is handled separately. Entries 1-20 give the number of bytes to send from the control block to the host for each OSWORD function. Functions above &14 (20) default to sending 16 bytes.

For functions >= &80, the send length is taken from byte 0 of the control block instead of this table.

Indexed by OSWORD number via LDY table,X. Gives the number of bytes to receive back from the host into the control block. Entries 1-20 correspond to OSWORD functions &01-&14. Functions above &14 default to receiving 16 bytes.

The first byte (&80) is shared: it serves as both the OSWORD &14 send length (meaning the length is in the control block) and the unused recv slot 0.

For functions >= &80, the receive length is taken from byte 1 of the control block instead of this table.

Hardware interrupt entry point. Saves A, checks the break flag in the stacked processor status to distinguish BRK from IRQ, and dispatches accordingly.

First-level IRQ handler. Checks Tube R4 for data transfer requests, then Tube R1 for escape/event notifications. Falls through to IRQ2V if neither.

Extract the return address from the stack, subtract 1 to point to the byte after the BRK opcode (the error block), store the pointer in last_error (&FD/FE), then re-enable interrupts and dispatch via BRKV.

Process data received via Tube R1. If bit 7 is set, it is an Escape state change (stored in escape_flag). Otherwise, it is an event notification: reads the event parameters (Y, X, event number) from R1 and dispatches via EVNTV.

Called when Tube R1 data has bit 7 set, indicating an Escape state change. Shifts bit 6 of the received byte into bit 7 via ASL and stores the result in escape_flag (&FF). Bit 7 set = Escape active.

Process data received via Tube R4. If bit 7 is set, it is an error from the host: reads the error number and message via R2 into the error buffer, then executes the error via a JMP to the buffer (which starts with a BRK opcode).

If bit 7 is clear, it is a data transfer request: falls through to data_transfer_setup.

Configure the NMI handler for a data transfer.

The transfer type (0-7) from R4 selects the NMI routine and the address pointer. Types 0-3 are single/double byte transfers. Types 4-5 are release. Types 6-7 are 256-byte block transfers.

Reads the 4-byte transfer address from R4 (only the low 2 bytes are used), configures the NMI vector and transfer address, then reads the sync byte from R4.

Common exit path for data transfer setup. Restores Y from the stack, retrieves saved A from irq_a_store, and executes RTI.

Read 256 bytes from Tube R3 into memory at the address patched into the STA instruction. Used for transfer type 7 (256-byte read from host).

The target address is set up by data_transfer_setup via the transfer address pointer table.

Transfer type 0. Sends one byte from the transfer address to Tube R3, then increments the address.

Transfer type 1. Reads one byte from Tube R3 and stores it at the transfer address, then increments the address.

Transfer type 2. Sends two consecutive bytes from (data_transfer_addr) to Tube R3, incrementing the pointer after each byte.

Transfer type 3. Reads two bytes from Tube R3 and stores them at (data_transfer_addr), incrementing the pointer after each byte.