TRS-80 – Level 1 ROM Disassembled

0008H – RST 08H Routine – This routine requires TWO parameters … a value as the next bit and a byte offset. DE is advanced to the next non-space and tests it against the value. If there is no match, jumps to the return value PLUS the offset. If there is match, jumps to the byte after the offset.

000EH – Display a CARRIAGE RETURN.

0010H – RST 10H Routine – This routine will send a character to the screen or to the cassette.

0018H – RST 18H Routine – This routine will parse an expression.

0020H – RST 20H Routine – This routine will compare HL and DE. NZ means no match, Z means match.

0028H – RST 28H Routine – This routine will skip forward from DE until the first non-space character, with Register A holding that character.

0030H – RST 30H Routine – This routine will continue execution.

0038H – RST 38H Routine – This routine will check a variable to make sure it exists. If it doesn’t, CARRY will be set. If it does, HL will point to the variable and NC will be set. Note that only variables A-Z and A(n) are valid in Level 1.

0066H – Non-Maskable Interrupt Routine. This would be triggered on hitting the RESET BUTTON.

0076H – Continuation point for the RST 38H routine. At this point, HL has the current pointer to the line being examined is at the top of the stack, DE has the pointer to the variable, Z/NZ is set based on whether the location of the array variable is in or out of bounds, and if Register A is greater than Register E, the CARRY FLAG is set.

0081H – Continuation point for the RST 38H routine; jumped to if the variable is “A” and no “(” was found after it. This routine will set HL to point to the RAM address which holds the variables “A” – “Z”

0082H – Continuation point for the RST 38H routine; jumped to if the variable is “B”-“Z”. Register A will contain 0-25, representing variables “A”-“Z”.

0089H – Jump to the routine to Display the “WHAT” error.

008CH – Subroutine to check to see if the character pointed to by Register Pair DE is, or is not, a digit. If a digit is found, will retuen with Register A containing the digit and NC set, or the CARRY FLAG set otherwise.

0098H – Continuation of the RST 08H routine. At this point Register A holds the next non-space character, Register Pair HL holds what used to be the value held at the Stack Pointer, and the value held at the Stack Pointer contains what used to be HL.

00A6H – Analyze a Floating Point Constant.

00B2H – Subroutine called from the FLOATING POINT CONSTANT routine at 00A6H.

00C5H – Subroutine called from the FLOATING POINT CONSTANT routine at 00A6H. This routine will accumulate the current digit and set the bits of Register B accordingly.

00D7H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here from 00B5H if we were processing characters and came across a non-digit.

00FBH – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if we have a non-digit that isn’t a “.”. This routine will check for “E” and “+“.

0105H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if we have a non-digit that isn’t a “.”, “E”, or “+“. This routine will check for “–“.

010AH – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if we have a non-digit that isn’t a “.”, “E”, or “+“, or “–“.

011CH – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if we have a non-digit that isn’t a “.” or an “E”.

0120H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if we have started processing an exponent and then hit a non-digit.

0146H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; jumped here if to process a POSITIVE exponent.

014EH – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; exit the floating point routine.

0151H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; exit the floating point routine with a HOW error.

0155H – Continuation of the FLOATING POINT CONSTANT routine at 00A6H; Clear out H’, L’, C’, and Bit 6 of Register B’ in anticipation of starting to parse.

015EH – Continuation of the FLOATING POINT CONSTANT routine at 00A6H. This basically multiplies the 24 bit digit represented by C’H’L’ by 10 and then adds in A’ with overflow going to B’ thus leaving a 32 bit result of B’C’H’L’. Specifically it accumulates the digit by multiplying the accumulator by 10 and then adding in A to the newly vacant one’s spot. Routine will return a NZ SET if an overflow occurs from the accumulation. On entry, the REGULAR REGISTER SET is active.

So at this point HL, C, and B have all been multiplied by 2.

So at this point HL, C, and B have all been multiplied by 4 total.

So at this point HL, C, and B have all been multiplied by 5 total.

So at this point HL, C, and B have all been multiplied by 10 total.

The rest of the routine is devoted to adding Register A to Register Pairs HL and BC.

018EH – Determine How Much RAM is in the System.

01A2H – Display the “HOW?” error.

01A9H – MESSAGE STORAGE AREA.

01C9H – BASIC’s READY Entry Point. If JUMPed here, the BASIC RUN STATE is cleared.

01CFH – BASIC’s READY Alternate Entry Point. If JUMPed here, the BASIC RUN STATE is not affected.

01D8H – Process a line of code in a READY loop

The line number has been found, so we will overwrite/delete the old line

If we are here we will add a new line to the program UNLESS it was just a line number, in which case we delete the line.

If we are here then we did not hit the EOL delimter. The next bunch of calls and math is first designed to make sure there is enough RAM to store the whole line, so HL is set up to be the highest RAM location needed to store the line.

0239H – Clear the 10 bytes from 409DH to 40A6H and set Register Pair DE to 4200H.

0249H – RESERVED WORD LOOKUP/VECTOR TABLE.

0340H – Part of the READY loop routine; jumped to when the instruction line being interpreted is on the command line instead of being part of a program.

The next batch of code is to try to match the instruction to a reserved word.

0351H – Continuation of the routine to parse an instruction line; jumped from 0349H if we have a first character match from the instruction line vs a reserved word.

035EH – Continuation of the routine to parse an instruction line; jumped here from 0359H if we MIGHT have a match. The following code will see if we are using an abbreviation instead.

036BH – Continuation of the routine to parse an instruction line. This loops to skip all characters until we hit an address.

0378H – Entry point for the NEW Command.

037BH – Continuation of the start-up process, following determination of the RAM in the system.

0387H – Entry point for the END Command.

038CH – Entry point for the RUN Command.

0394H – Common routine continuation point. Execute the Next Line.

03B5H – Entry point for the GOTO Command.

03C5H – Entry point for the STOP Command.

A this point, Register Pair HL contains the line number to display.

03EBH – Entry point for the CONT Command.

0401H – Entry point for the LIST Command.

0418H – Continuation of the LIST command, once a counter of 12 lines has been displayed.

042FH – Entry point for the PRINT Command.

043BH – If the PRINT was not followed by a #, it jumped here.

0443H – If the PRINT was not followed by a :, it jumped here.

044CH – If the PRINT was not followed by a CARRIAGE RETURN, it jumped here.

0452H – If the PRINT had a QUOTE, it jumped here.

0457H – If the expression to print in 0452H did not end in a CARRIAGE RETURN, it JUMPs here (the return address (0455H) + 2) as there is more to print.

0459H – Entry point for the PRINT A$ Command.

045EH – Entry point for the PRINT B$ Command.

0461H – Routine to print a string variable.

If we are here, then we got a comma, so we need to handle the display of a TAB.

0473H – Entry point for the PRINT AT Command.

If a , is found, then we are here.

048DH – Middle of the PRINT AT Routine.

If a ; is found, then we are here.

0495H – Middle of the PRINT AT Routine where a “;” was not found, so process the end of the line

049FH – Entry point for the PRINT TAB Command.

If we are here, then we are not yet on screen where we want to be, so we need to space over until we get there.

04B5H – Entry point for the CLS Command.

04B9H – Subroutine to display the contents of a string variable pointed to by Register Pair HL until either a 00H is reached OR 16 bytes have been displayed.

04C4H – Entry point for the GOSUB Command.

04E6H – Entry point for the RETURN Command.

04FEH – Entry point for the ON Command.

050BH – Part of the ON Command; jumped here if the index passed to ON was a ZERO.

050FH – Entry point for the ON x GOTO Command.

0517H – Entry point for the ON x GOSUB Command.

0526H – Part of the ON Command; turns the value/expression passed after the ON into a line number.

0539H – Part of the ON Command; parse the line number of an ON x LINE NUMBER command, and then read (and discard) characters on the BASIC line until we hit a CARRIAGE RETURN or a :.

0546H – Entry point for the FOR Command.

0555H – Entry point for the TO Command.

0560H – Entry point for the STEP Command.

0565H – Continuation of the STEP Command.

05A3H – Entry point for the NEXT Command.

05C0H – Continuation of the NEXT Command; jumped here if the FOR and NEXT variables match the current BASIC stack frame.

05F2H – Jump point to exit out of BASIC stack operations — routine restores the values from the BASIC stack into their RAM locations, clears the RETurn address, and continues processing the current BASIC line.

05F6H – Entry point for the REM and DATA Commands.

05FBH – Entry point for the IF Command.

060BH – Look for the THEN Command.

0611H – Entry point for the THEN Command.

061AH – Restore SP from a temporary storage space of 409BH and restore the current line being executed back into Register Pair HL and the associated memory location; this is jumped to at 08DCH.

0623H – Entry point for the INPUT Command.

0630H – Continuation of the INPUT Command; jumped here if the INPUT was not followed by a “#”, meaning that we are inputting from the keyboard.

0636H – Continuation of the INPUT Command.

0651H – Continuation of the INPUT Command; jumped here if there was no “;” when one was expected.

0654H – Multi-Command Routine. Used by LET, INPUT, and READ to parse the characters pointed to by Register Pair DE.

If we’re here then we didn’t get a CARRIAGE RETURN, , or “ so we are just going to copy the data to the buffer pointed to by Register Pair HL.

066FH – Routine to fill the rest of the 15 character buffer pointed to by Register Pair HL with 00H’s; jumped here if the next character is a CARRIAGE RETURN.

0678H – Parse a quoted string into a 15 character buffer pointed to by Register Pair HL.

0694H – Multi Command Subroutine; parse the next characters of a variable. Used in the LET command and the INPUT command for the characters after the “;“. If the variable does not exist, the C FLAG is set; a close array returns with the Z FLAG set; and a $ returns with register L holding either 70H (for A$) or 80H (for B$) and the Z FLAG set.

06A3H – Continuation of the above routine; jumped here if the variable found on the BASIC line being processed ended in a “$”. On exit, Register L will be either 70H if the variable is A$ or 80H if the variable is B$. DE will point to the next character on the BASIC line being processed.

06B3H – This routine is JUMPed to from the RESERVED WORD LOOKUP list, if the main commands are not found. The reserved words after this are functions, math symbols, and the like.

06B8H – Entry point for the LET Command. This is also a pass through from the exhausted RESERVE WORD LOOKUP list jump; meaning that if the ROM cannot find a command where it expected one, it is willing to assume that the line is actually a variable assignment.

06C6H – Continuation of the INPUT Command; jumped to by 06D7H and 06EBH.

06CDH – Entry point for the RESTORE Command.

06D4H – Continuation of the INPUT Command; this will parse the line. On entry, DE must point to the current character in t he BASIC line being parsed.

06F9H – Entry point for the READ Command.

073BH – Continuation of the INPUT Command; JUMPed here if a “,” wasn’t found at 06E5H.

0741H – Continuation of the INPUT Command; JUMPed here if a “,” wasn’t found at 06F3H.

0745H – Continuation of the READ Command; jumped here from 0710H when no DATA statements were found.

0749H – JUMPed here from the DATA PARSE TABLE (at 0BBFH) if the DATA statement is located, and DE now points to the first entry of that DATA statement.

074BH – This is JUMPed to by the JP (HL) in 0377H and in the DATA PARSE TABLE if DATA statement was not found. This routine loops through the characters on the BASIC line being processed until it hits a CARRIAGE RETURN

0751H – Examine the current BASIC instruction line for DATA statements. If we hit the end of the program with no DATA statements, the C FLAG will be set.

075DH – Parse an optional relational expression “>” “<” or “=“.

0763H – Entry point for a > Command.

076CH – Part of the span class=”code”>> Command; JUMPed here if the “=” was not found in 0763H, to process a straight >.

0773H – Entry point for a “<” Command.

0782H – Part of the “<” Command; JUMPed here if an “=” was NOT found (so no <=), to next check for <>.

078BH – Entry point for a = Command.

0791H – Part of the “<” Command; JUMPed here to test a straight “<” math operation.

0797H – This is the jump point in the RESERVED WORD LOOKUP TABLE for where “>“, “<” and “=” pass through. This is where we go if the relational expression was not found.

0799H – Subroutine to compare two numbers.

07A3H – Part of the NUMERIC COMPARISON routines. In these routines HL=0 means TRUE and HL=1 means FALSE. This routine sets HL to FALSE and RETurns to caller.

07A7H – Check the current BASIC program line against relational operators.

07ADH – Parse an expression. This is part of the RST 18H routine as well as other locations and is the main expression parsing routine.

07B8H – Parse an expression. This is part of the RST 18H routine as well as other locations; JUMPed here if a “–” wasn’t found, to now check for a “+“.

07C9H – Parse an expression. This is part of the RST 18H routine as well as other locations; JUMPed here if a “–” and “+” wasn’t found, to now check for a “–“.

07D4H – Parse an expression. This is part of the RST 18H routine as well as other locations; JUMPed here if a “+” was found.

07E2H – arse an expression. This is part of the RST 18H routine as well as other locations; JUMPed here if the check at 07D7H didn’t find a “*“.

07EDH – Parse an expression. This is part of the RST 18H routine as well as other locations. This will parse a primary expression.

07F2H – ???? Don’t see how we get here. Part of the PARSE AN EXPRESSION routine. Supposedly jumps here if “intrinsic function not found” to parse a regular expression.

07F8H – Part of the PARSE AN EXPRESSION routine. If we need to parse a regular expression, but the variable was not found, we need to assume that we have a constant; so we wind up here.

07FCH – Subroutine to verify that an integer is inside parenthesis, and parse it via a RST 18H call.

0806H – ??? I don’t see what jumps to this instruction. Whatever it is, its trying to get to 0807H but AF and AF’ are backwards.

0807H – Calculate an integer expression with the results into Register Pair HL.

080BH – Compute the number held in Regster Pair HL as a non-negative integer.

0814H – Verify that an integer is within parenthesis, and calculate the integer expression with the result in Register Pair HL.

0819H – Entry point for the ABS() command.

0821H – Entry point for the “MEM” command.

082FH – Entry point for the INT() command.

0838H – Entry point for the RESET Command.

083CH – Entry point for the SET Command.

0840H – Entry point for the POINT Command.

0842H – This is the main routine for graphics. On Entry A=128 for SET, 1 for RESET, and 0 for POINT.

Do some division … first let’s divide out the Y value by subtracting until it goes negative

Next, let’s get Y MOD 3 into Register H.

At this point, Register A is the number of iterations that we have to rotate the graphic mask, Register H, to the left.

Next, we need to calculate the screen location by masking B with an OR for FCH and AND for 3FH to get a value between 0 and 63 (the screen width).

If we didn’t jump away, the Bit 7 of Register A was a 0, meaning that it was not a graphic character, so we need to put one there!

At this point, Register Pair BC points to the screen location at which the revised graphic character will be placed, and Register H has the graphic mask to apply to the character.

089BH – Part of the Generic Graphics Routine; final processing of POINT command.

At this point, HL will be 0 if the SQUOT being tested if OFF and HL = 1 if the SQUOT being tested if ON.

08A5H – Part of the Generic Graphics Routine; final processing of SET command.

08A8H – Parse a variable name followed by an “=” and an expression (such as “FOR X = 4”).

08B3H – Check if the next character is a “:” and if yes, JUMP to 08BAH to check for a CARRIAGE RETURN and if not then jump to the MIDDLE of the EXECUTE NEXT LINE routine.

08BAH – Check if the next character is a CARRIAGE RETURN and if YES, keep processing the next line and if NO then RETurn.

08C2H – Very common routine to parse an integer.

08C5H – Very common jump point. This is jumped to when a command is executed that has no further parameters and, therefore, REQUIRES a CARRIAGE RETURN as the next character. It will return out of the main routine if the next character is a a CARRIAGE RETURN, and display a WHAT error otherwise.

08C9H – Display the “WHAT” error.

08F4H – Display the “SORRY” error.

08FAH – If entry is 08FAH, display a prompt of the character held in Register A then then fetch a line of input into a 53 character buffer between 40ACH and 40F3H pointed to by Register Pair DE.

If we are here, then we had a character we wanted to keep, and it wasn’t a CARRIAGE RETURN, so we need to keep getting more characters.

If we are here, then we have run out of buffer space for INPUT.

092AH – Find the line in RAM which matches the line number pointed to by Register Pair HL starting at the address held in Register Pair DE. If jumped HERE it starts at the beginning of BASIC RAM. Will set the CARRY FLAG if nothing was found.

092DH – Find the line in RAM which matches the line number pointed to by Register Pair HL starting at the address held in Register Pair DE. If no line is found, it will point to the line BEFORE where the line contained in HL should have been AND will set the CARRY and NZ FLAGs.

First we need to verify that the RAM we are searching (held in DE) isn’t less than 4200H or higher than the top of RAM (held in 406CH). First, check for too low …

.. and now, check for too high. Involves a temporary repurpose of HL.

093AH – Continuation of the FIND THE LINE NUMBER IN RAM routine, to actually do the search. Register Pair DE holds the RAM location to examine, and Register Pair HL holds the line number being looked for.

0945H – Continuation of the FIND THE LINE NUMBER IN RAM routine. Jumped here to skip to the end of the line and then to jump back to continue searching.

094FH – Display the message pointed to by Register Pair DE until a either a CARRIAGE RETURN or the contents of REGISTER A is found.

095BH – Part of the PRINT routine. Display a quoted expression pointed to by Register Pair DE and JUMP to the command line parsing routine if a CR is found, otherwise JUMP to the return address + 2 bytes.

096CH – Exit out of the prior routine based on the RST 08H call not matching a “.

096DH – Display the contents of Register Pair HL as a decimal number.

If we are here, then we need to print a zero value.

0983H – Continuation of the routine to display the contents of Register Pair HL as a decimal number; jumped here if the number is NOT a Zero.

09A4H – Continuation of the routine to display the contents of Register Pair HL as a decimal number.

09B4H – Continuation of the routine to display the contents of Register Pair HL as a decimal number.

09C6H – Continuation of the routine to display the contents of Register Pair HL as a decimal number. I will not make believe I know what is going on.

0A03H – Continuation of the routine to display the contents of Register Pair HL as a decimal number. I will not make believe I know what is going on.

0A13H – Continuation of the routine to display the contents of Register Pair HL as a decimal number. This will process the exponent display by first displaying the “E” if needed, set up to display the sign after the “E”, and load Register A with the number (negated if it was negative).

0A2BH – Continuation of the routine to display the contents of Register Pair HL as a decimal number. Display the sign, and put the number from Register B into Register A.

0A38H – Continuation of the routine to display the contents of Register Pair HL as a decimal number. This will display the number held in Register B (which was tracking how many times 10 had to be removed from Registter A) and then the number held in Register A, followed by a SPACE. It will then POP all the registers, including the FLOATING POINT STACK, and RETurn

0A4DH – Continuation of the routine to display the contents of Register Pair HL as a decimal number. Decrements B, and so long as that’s not a zero, displays a “.” and a number. Then, if a shifted C isn’t zero, loops back to the top and if it is zero, Decrements B twice, exiting if the sign changes, or redoing the routine otherwise.

0A63H – Display the line number pointed to by Register Pair DE.

0A6FH – Copy the bytes held at (DE) to (BC), backwards, until DE = HL.

0A77H – COPY the bytes, backwards, from BC through DE to HL.

0A84H – This Subroutine is the opposite of 0A9FH This routine puts the contents from the BASIC stack pointer into the various RAM locations.

0A9FH – This Subroutine will move BASIC’s stack to make room for an additional stack item (like GOSUB, FOR-LOOP) and then put those values into that BASIC stack. If it runs out of space, it will end in an error.

If we are here, then there is room to move the stack. A LOT of variables deal with a FOR LOOP so check to see if we even have one at this point.

0ACBH – Continuation of the RST 10H routine. On entry the flags are set based on BIT 2 of the status of the Cassette port.

If we are here then the character is to be sent to cassette and not the screen.

If the character to display was a CARRIAGE RETURN then we are here.

0AE6H – Continuation of the RST 10H routine. Jumped here if BIT 2 of the status of the cassette port was ZERO, meaning that we are outputting to the screen and not the cassette.

If we are here, then we are at the end of a screen line, and need to scroll the screen.

0B11H – Continuation of the RST 10H routine. Jumped here from 0AEDH if the character is a control code.

0B1AH – Continuation of the RST 10H routine. Jumped here from 0B11H if the character is a control code which is not a CARRIAGE RETURN.

0B2EH – Continuation of the RST 10H routine. Jumped here from 0B11H if the character is a control code which is not a CARRIAGE RETURN or a FORM FEED.

.

0B37H – VIDEO – Clear the line on the screen at the location pointed to by Register Pair HL.

0B40H – KEYBOARD – Check the keyboard for a keypress – If found, display it and put it into Register A. If no key, A=0 and Z FLAG is set.

If we are here, then a key was pressed when we polled, and it is stored in Register A.

Let’s make sure the key is released.

The key has been released!

0B55H – KEYBOARD – Do a little debounce and then Decode the keystroke held in Register A.

The keyboard matrix is:
3801H – @ABCDEFG
3802H – HIJKLMNO
3804H – PQRSTUVW
3808H – XYZ
3810H – 01234567
3820H – 89:;,-./
3840H – ENT CLR BRK ↑ ↓ ← → SPC

0B6EH – Continuation of the Keyboard Decode Routine; JUMPed here if we found a key pressed.

0B8EH – Continuation of the Keyboard Decode Routine; passed through since the key was not greater than @, “<“, or 0.

0B91H – Continuation of the Keyboard Decode Routine; JUMPed here from 0B76H if the key is >= @.

0B95H – Continuation of the Keyboard Decode Routine; passed through if the key was >= @, but it was unshifted.

0B98H – Continuation of the Keyboard Decode Routine; JUMPed here from 0B80H if the key is >= 0.

0B9CH – Continuation of the Keyboard Decode Routine; passed through if the key was >= 0, but it was unshifted.

0B9FH – Continuation of the Keyboard Decode Routine; JUMPed here from 0B7CH if the key is >= “<“.

0BA3H – Continuation of the Keyboard Decode Routine; JUMPed here from 0B7CH if the key is >= “<“, but it was shifted.

0BA5H – Continuation of the Keyboard Decode Routine; this will check for a SHIFT, set the FLAGS (NZ if SHIFTED), and put Register B into Register A.

0BABH – No idea what calls this!.

0BACH – Data Storage – Keyboard Decode Table.

0BB3H – Data Storage – Control Characters

0BBBH – Data Storage – Parse Table for DATA Statement

0BC3H – This routine will copy the 4 bytes pointed to by Register Pair HL into the Floating Point Stack (which is 5 bytes).

0BE8H – This routine will assign a value held at the top of the FLOATING POINT STACK to a variable in a FOUR BYTE FORMAT and the number is then removed from the FLOATING POINT STACK. The top of the stack must hold the address of the variable being set.

Now we move the SIGN BIT to the top bit of the exponent byte.

0C0BH – Convert a FLOATING number to an INTEGER; results stored in Register Pair HL.

0C2CH – Part of the CONVERT A FLOATING NUMBER TO AN INTEGER routine; JUMPed here from 0C20H if the EXPONENT was lower than 01H.

0C30H – Part of the CONVERT A FLOATING NUMBER TO AN INTEGER routine; JUMPed here from 0C25H if the EXPONENT was lower than 10H. This routine will shift a small FLOATING POINT number into the correct position based on the EXPONENT. Register A is a number less than 16.

0C56H – Set HL to 10.0 and then, by passing through, convert the value stored in Register Pair HL to a floating point number in the Floating Point Stack.

0C59H – Convert the value stored in Register Pair HL to a floating point number in the Floating Point Stack. On Entry DE still points to the current character of the BASIC command line being examined.

0C75H – This subroutine is called from 0C60H and processes the sign. If DE is negative, then DE = -DE and CARRY will be set. On entry the REGULAR REGISTER SET is active.

If we are here, then a negative number was passed. Will give some examples.

0C84H – Part of the math routines. This is MULTIPLY. If 0C84H is called, it first moves the ONES to TENS, TENS TO HUNDREDS, etc.

0C95H – Part of the math routines. This is FLOATING POINT DIVIDE. It first moves the ONES to TENS, TENS TO HUNDREDS, etc. and then divides the two numbers at the top of the FLOATING POINT STACK.

0CA6H – Part of the FLOATING POINT DIVIDE routine. This routine pushes HL to the FLOATING POINT STACK, converts the top two numbers in the FLOATING POINT STACK to to B/D/B’/D’/E’ and C/L/C’/H’/L’, and then replaces BC with -5 before JUMPing to 0CB7H.

0CB1H – Math Routine. Fetch the top 2 entries from the Floating Point Stack into their register sets, remove them from the Floating Point Stack, and do a bunch of comparisons between the two.

0CBFH – Math Routine. Floating Point Subtraction.

0CC9H – Math Routine. Continuation of the Floating Point Subtraction routine. Jumped here from 0CC2H if there are 2 numbers to work with.

0CD0H – Math Routine. Entry point to add the value held in Register Pair HL.

0CD3H – Math Routine – Floating Point Addition. On entry the ALTERNATE REGISTER SET is active.

0CEEH – Part of the Floating Point Addition routine; will check the signs of the two numbers, and if they are the same, add the two exponents together and put the numbers back into the FLOATING POINT STACK. On entry, the REGULAR REGISTER SET is active.

0CF9H – Math Routine. Flip the sign of the Floating Point number just below the Floating Point Stack pointer, POP DE, and RETurn.

0D03H – Math Routine. This routine sets the FLOATING POINT STACK registers for NUMBER 2 = the FLOATING POINT STACK registers for NUMBER 1 and with DE at the top of the stack. On entry the REGULAR REGISTER SET is active.

As a reminder, NUMBER 1 is stored in B’ (MSB), D’ (NMSB), and E’ (LSB), with the SIGN in D and the EXPONENT in E,. NUMBER 2 is stored in C’ (MSB), H’ (NMSB), and L’ (LSB), with the SIGN in H and the EXPONENT in L.

0D0DH – Set L to 80H and store the H (Sign), L (Exponent), C’ (MSB), H’ (NLSB), L’ (LSB) registers into the Floating Point Stack at one set earlier than the location pointed to by Special Index Register IX, adust IX to point to that entry (i.e., -5 bytes from where it started), POP DE, and RETurn.

0D27H – Multiply Floating Point Numbers – Number 1 is D (Sign), E (Exponent), B’, D:’ E’, and Number 2 is H (Sign), L (Exponent), C’ (MSB), H’ (NLSB), L’ (LSB).

The next instructions are C’:H’:L’ = C’:H’:L’ + A:D:E

We have finished, so prepare to exit.

0D53H – Part of the Multiply Floating Point Number Routine. This handles the SHIFTING of C, H, and L right one bit. On entry the REGULAR REGISTER SET is active, but on exit the ALTERNATE REGISTER SET is active.

0D5CH – Floating Point Number Division Routine. On entry the REGULAR registers are in effect, although DE and HL have been swapped with DE’ and HL’. No real clue what is happening.

0D85H – Part of the Floating Point Number Division Routine. On entry the REGULAR registers are in effect.

0D94H – Part of the Floating Point Division routine. On entry the REGULAR registers are in effect. If the EXPONENTS were the same between the 2 numbers (on entry) the Z FLAG will be set.

0DA0H – Part of the Floating Point Division routine.

0DA7H – Part of the Floating Point Division routine. RETurn if the Z Flag is set OR test the sign and, if positive, rotate A right, turn on the carry, rotate A left, and RETurn.

0DA8H – Part of the Floating Point Division routine. Will test the sign and, if positive, rotate A right, turn on the carry, rotate A left, and RETurn. On entry the REGULAR registers are in effect.

0DB1H – Part of the Math Routine. Flip the state of the CARRY FLAG and RETurn.

0DB3H – Part of the Floating Point math routines. This will compare the exponents of two numbers and, if equal, the mantissas. On entry the REGULAR registers are in effect.

0DBEH – Part of the Floating Point math routines. This will compare the mantissas of the numbers returning with NZ set if they don’t match and Z set if they do. On entry the REGULAR registers are in effect.

0DCBH – Floating Point Math Routine – Addition. On entry the REGULAR registers are in effect.

0DFAH – Floating Point Math Routine – Subtraction. On entry the REGULAR registers are in effect, but on exit the ALTERNATE registers are in effect.

This is a common jump point … On Entry the ALTERNATE REGISTERS are in effect.

0E11H – Part of the MATH ROUTINE. JUMPed here from 0E05H if the SIGN flag was set based on Register C. On entry the ALTERNATE REGISTER SET is active, on EXIT the REGULAR REGISTER SET is active.

0E15H – MATH ROUTINE. Test the sign of Register H, if NEGATIVE then JUMP to 0E0EH and otherwise clear the return address from the stack and error out with “HOW?”.

0E1EH – Math Subroutine. This routine will fill all the registers with various parts of two floating point numbers. On entry, the REGULAR REGISTER SET is active. On exit, the original DE is in the stack, the Z FLAG is set if the exponent NUMBER 2 is 80H, NUMBER 1 is stored in B’, D’, and E’, with the sign in D and the exponent in E, and NUMBER 2 is stored in C’, H’, and L’, with the sign in H and the exponent in L.

0E47H – Entry point RND().

0E64H – Continuation of the RND() routine; JUMPed here to calculate RND(0).

If we are here, we have processed all 3 bytes of the Random Number Generator Multiplier value table and have rotated 8 times per.

0EB2H – Byte Storage Area – Random Number Generator Multiplier Values.

0EB5H – Byte Storage Area – Constants used to Display Floating Point Numbers.

0EC4H – Parse the instruction line to see if the next characters are integers and, if so, put them into Register Pair HL. On entry the REGULAR REGISTER SET is active.

0EDAH – Continuation of the above parsing routine. On entry the REGULAR REGISTER SET is active.

0EE9H – Entry point for the CLOAD Command.

0EF4H – CASSETTE – Turn on the cassette motor, read the data header and then read the number of bytes needed to fill RAM based on the block addresses. Routine exits with Register A holding the CRC and flags set based on Register A; DE is preserved.

When bytes are written, the header including the A5H is written, then Registers H, L, D, and E; so the below loads E, D, L, and H from the cassette. The bytes then get loaded into RAM starting at the memory location held in Register Pair DE.

If we are here, then we have finished reading all the bytes which were to be placed within the read/designated RAM block of DE to HL.

0F3BH – Entry Point for the “CSAVE” Routine.

0F4BH – CASSETTE – Write the cassette header (128 0’s and then an A5 sync byte) and then H, L, D, E, then all the bytes from HL to DE, and then the checksum.

The 80 “0” bytes have now been written, time to write the SYNC byte.

Next send H, L, D, and E to the Cassette.

Next, send all the bytes from HL to DE to the Cassette.

If we are here, then all of that has been written out.

0F81H – CASSETTE – READ a BYTE to the Cassette Port. Routine reads a bit and then rotates it into Register A.

Preserve Register A so we can do all the following operations without destroying it.

If we’re here, then the bit was a 1.

Now let’s restore the original Register A and proceed.

0FA1H – CASSETTE – Read a BYTE to the Cassette Port by calling 0F81H eight times.

0FA9H – CASSETTE – Write a BYTE to the Cassette Port. On entry Register A should hold the byte to output and Register C should be tracking the CRC.

0FBFH – CASSETTE – Delay Loop of 256 (which represents writing a 0 bit to the moving cassette).

0FC5H – CASSETTE – Write a BIT to the Cassette Port.

0FE4H – CASSETTE – Turn off the cassette motor.

0FE9H – CASSETTE – Turn on the cassette motor.

0FF0H – CASSETTE – Check to see if the cassette motor is running.