Model III ROM Explained – Part 1

These 3 pages are a breakdown of the Model III ROM, with comments to help you understand what is going on. The two thing to keep in mind while reading this disassembly are:

• The ROM had to be one big long program starting from 0000H and ending at 37FFH and everything it does had to be wedged into that single long block of code. This means that jumps to other locations are a necessity because once a particular portion of the ROM executes, if it was allowed to keep going, unintended portions would also execute. With this, there is a LOT of jumping away.
• There are only so many variables and only so many Z-80 instructions. There is no Z-80 instruction, for example, LD BC,SP. With this, there is a huge amount of variable swapping. I would dare say that whatever part of the ROM isn’t jumping, is just swapping variables around. The ROM would be a fraction of the size if there were more variables and more Z-80 instructions.

To prepare these pages I used the:

• Decimal Hex Binary converter page at https://www.mathsisfun.com/binary-decimal-hexadecimal-converter.html
• The Z-80 Instruction Set page at http://clrhome.org/table/
• The ASCII Table at https://www.ascii-code.com/
• Hex Calculator page at https://www.calculator.net/hex-calculator.html

Addresses with a “*” in front of them, which are also in blue, differ from the Model I.

There is no difference between the early Model III ROM and the later Model III ROM in this range. The Model 4 ROM is also identical to the Model III ROM in this range.

0000-0004 – POWER UP ROUTINE – $RESET
A jump to this routine reinitializes the entire system starting at the “CASS?” prompt. If a disk controller is present, the Computer will attempt to load DOS UNLESS BREAK was held down before this jump.

0008 – RST 08H

000B-000F – DISK ROUTINE – “WHERE”

0010 – RST 10H

0013-0017 – KEYBOARD ROUTINE. This is jumped to from 002E (to get a byte from the Keyboard) and 0053 (to get a byte from the RS-232).

• This routine inputs a byte from an input device. When calling, DE = must contain the starting address of DCB of device. On exit, A = byte received from device, Z set if device ready. Uses AF.

0018 – RST 18H

001B-001E – DRIVER ENTRY ROUTINE – Part 1 – “PUT” or “OUTBYT”

• This routine outputs a byte to a device. When calling, A = output byte, DE = starting address of DCB of device. On exit, Z set if device ready. Uses AF.

0020 – RST 20H

0023-0027 – DISK ROUTINE – “CTLBYT”

*0028H – RST 28H Routine Vector

002B-002F – KEYBOARD ROUTINE – “$KBCHAR”

• Keyboard scanning routine. After CALLing 2BH, the A register will contain the ASCII value for the key that was pressed. The A register will contain 00H if no key was pressed at the time. Apart from the AF register pair the DE register pair is also used by the routine.
  This Routine Performs an instantaneous scan of the keyboard. If no key is depressed control is returned to the caller with the Aregister and status register set to zero. If any key (except the BREAK key) is active the ASCII value for that character is returned in the A-register. If the BREAK key is active, a RST 28 with a system request code of 01 is executed. The RST instruction results in a JUMP to the DOS Exit 400C. On non-disk systems the Exit returns, on disk systems control is passed to SYSO where the request code will be inspected and ignored, because system request codes must have bit 8 on. After inspection of the code, control is returned to the caller of 002B. Characters detected at 002B are not displayed. Uses DE, status, and A register
• This routine loads DE with address of keyboard DCB and scans keyboard. On exit, if no key pressed the A register will contain a zero byte, else the character input from the keyboard wi 11 be returned in A. Character is not echoed to video. Uses AF,DE (to save DE use routine at 03588).

0030 – RST 30H

0033-0037 – “$VDCHAR” – Display a character.
This subroutine displays a character at the current cursor location. On entry, Register A contains the character to display.

• Character print routine. A CALL 33H will print a character at the current cursor position. The A register must contain the ASCII code for the character or graphics figure that is to be printed before CALLing this routine. The DE register pair is used by the routine.
  A call to 0033H displays the character in the A-register on the video. Control codes are permitted. All registers are used.

0030 – RST 38H

003B-003F – PRINTER ROUTINE – “$PRCHAR”
This routine waits until the printer is available or until a BREAK key his pressed. If BREAK is pressed, this routine returns to the caller. On entry Register A holds the ASCII character to be output to the printer.

• Character LPRINT routine. Same as 33H but outputs to line printer. (Contents of A register will be printed).
• A call to 003BH causes the character contained in the C-register to be sent to the printer. A line count is maintained by the driver in the DCB. When a full page has been printed (66 lines), the line count is reset and the status register returned to the caller is set to zero. Control codes recognized by the printer driver are:
  • 00=Returns the printer status in the upper two bits of the A-register and sets the status as zero if not busy, and non-zero if busy.
  • OB=Unconditionally skips to the top of the next page.
  • OC=Resets the line count (DCB 4) and compares its previous value to the lines per page (DCB 3) value. If the line count was zero, no action is taken. If the line count was non-zero then a skip to the top form is performed.
  • OD=Line terminator. Causes line count to be incremented and tested for full page. Usually causes the printer to begin printing.

0040-0042 – INPUT ROUTINE – “$KBLINE”
This routine gets a full like from the keyboard. The line is terminated by a carriage return or BREAK. Characters typed are echoed to the display. On entry, B must be the maximum length of line to be accepted and (HL) must be the storage buffer which should be set to B+1. On Exit, CARRY will be set if the BREAK key was hit, Register B will contain the number of characters entered, and (HL) will contain the line from the keyboard followed by the terminating character. Register paid DE is altered in this routine.

0046-0048 – DRIVER ENTRY ROUTINE – Part 2 – “DRIVRV”

*0049-004F – KEYBOARD ROUTINE – “$KBWAIT” – Go scan the keyboard and return with the key pressed, if any, in register A.
A CALL to this memory location returns as soon as any key on keyboard is pressed. ASCII value for character entered is returned in A register. Uses A, status, and DE registers. If BREAK is hit, then it will be returned in Register A just like any other key (as an 01H). The characters are not echoed to the display.

• A call to 0049H returns as soon as any key on keyboard is pressed. ASCII value for character entered is returned in A register.

*0050-0053 – “$RSRCV” – Receive a character from the RS-232-C Interface
If the RS-232-C wait is enabled, this routine will wait for a character to be received, unless a BREAK is pressed. If the wait is NOT enabled, it returns whether a character is received or not. The character is stored in 16872. A 0 means no character received.

Difference between M1 and M3: In the Model I, locations 0050H through 005FH are a lookup table for special characters associated with the keyboard scan routine. These same locations in the Model III contain the entry points for routines associated with the RS-232-C interface C Receive character at 00S0H, Transmit character at 00SSH, Initialize RS-232-C at 00SAH). In both models, 0060H is the start of a time-delay routine, but in the Model III the three bytes starting at 0060H have been changed to a JP 01FBH instruction. The actual time delay routine (same as in the Model I except that an extra instruction is added to compensate for the faster clock speed of the Model III) has been moved to 01FBH in the Model III. Note that entry at 0063H has the same effect in both models, that is, the time delay will occur only if the z flag is reset (NZ).

*0055-0058 – “$RSTX” – Transmit a character to the RS-232-C Interface
If the RS-232-C wait is enabled, this routine will wait until the character is transmitted unless a BREAK is pressed. If the wait is NOT enabled, it returns whether a character is transmitted or not. The character is stored in Register A.

*005A-005F – “$RSINIT” – Initialize the RS-232-C Interface
Initialize the RS-232-C interface to the following: Baud=300, Word Length=8, Parity=None, Stop Bits=One, Wait for completion of character I/O.

*0060-0065 – “$DELAY” – This is a general purpose routine to be used whenever you want to pause before continuing with a program.
On entry, BC must be loaded with the delay multiplier. The actual delay will be 2.46 + (14.8 * BC) microseconds. When BC is zero, the maximum delay is used (65,535) which is about 1 second. Routine uses BC and A.

*0069 – “$INITIO” – A call to $INITIO restores all I/O drivers to their initial default conditions, including I/O routes. No entry conditions. All registers are altered.

*006C – “$ROUTE” – Change I/O Device Routing
On entry store the source device of KI, DO, RI, RO, or PR into 4222H and 4223H as the destination device in 4220H and 4221H.

0075-0104 – INITIALIZATION ROUTINE

• This is part of the Level II initialization procedure. It moves a block of memory from 18F7H to l9lEH up to 4080H to 40A7H. (reserved RAM. area).
  
  NOTE: 4080H-408DH is a division support routine.

0091-0104 – The rest of the initialization routine. Asks MEMORY SIZE ?, sets the memory pointers accordingly and prints RADIO SHACK LEVEL II BASIC , then it jumps to 1A19H which is the entry point for the BASIC command mode.

Top of a DJNZ loop of 28 iterations.

End of the DJNZ loop of 28 iterations.

001B-001F – VIDEO AND PRINTER ROUTINE

00D6 – Interpret the MEMORY SIZE response (whether it was actual via a JUMP from 00C2H or determined via a pass through), and do a memory test.

0105 – “MEMORY SIZE” Storage Area

0111 – “RADIO SHACK MODEL-III BASIC” Storage Area

012D-0131 – ?L3 ERROR ROUTINE – “L3ERR”

0132-0134 – LEVEL II BASIC “POINT” COMMAND ENTRY POINT

0135-0137 – LEVEL II BASIC SET COMMAND ENTRY POINT

0138-0139 – LEVEL II BASIC RESET COMMAND ENTRY POINT
“RESET”

013A-019CH GRAPHICS ROUTINE
“GRAPH”

• Common code for SET/RESET/POINT – A will be 0 if POINT, 80H if SET and 1 for RESET.

A this point, we have valid cordinates of X <= 128 and a Y <= 47.

These next few instructions divide the “Y” coordinate by subtraction. It will keep subtracting 3 (and tracking the number of times it does that in D) until the CARRY FLAG gets set, and then will add 3 to get the remainder.

These next few instructions fetch the “X” coordinate and do fun math to it together with the “Y” results go get a video memory offset for the graphic.

We now have the location in video memory for the graphic character. Since SET/RESET/POINT use the graphic ASCII character rather than plotting dots, we first need to make sure there is at least a graphic character already at the location.

If we are here, then we are dealing with either SET or RESET, as we would have jumped away in the prior instruction if it was the only other possible alternative, POINT.

If we are here, then we are dealing with RESET, as we would have jumped away otherwise.

Inside the RESET routine. This is common code though. It will just put the graphic character, representing the SET or RESET (held in A) onto the screen (at the location held in DE).

Inside the RESET routine. The character has been displayed (if a character was to be displayed), but we still need to make sure that we had proper syntax, so next we check for the close parenthesis and RETURN if we have it or ERROR if we do not.

Inside the SET routine. All this does is change the character accordingly and then jump back up into RESET where it displays the character, checks for the ) and RETurns.

Next is the POINT routine.

019D-01C8 – LEVEL II BASIC – “INKEY” – INKEY$ ROUTINE

If we are here, a key was pressed and it has been stored in Register A

01C9-01D2 – “$VDCLS” – Clear the video display screen.

• A CALL lC9H will clear the screen, select 64 characters and home the cursor. All registers are used.
• To use a ROM call to clear the screen, CALL 01C9H. The cursor is reset to the home position, which is 3C00H.

01D3-01D8 – LEVEL II BASIC RANDOM ROUTINE
“RANDOM“

• This is part of the RANDOM routine which takes a value out of the REFRESH register, stores it in location 40ABH and then returns.
  A call to 01D3H reseeds the random number seed (location 40AB) with the current contents of the refresh register.
• NOTE: To run a RANDOM (seed the random number generator) via a ROM call just call CALL 01D3H. This causes the contents of R (memory refresh) to be stored in 40ABH. The entire 24 bit seed is stored in 40AAH-40ACH.

*01D9-01F7H- Print Screen Routine – “$PRSCN”
This routine copies all 1024 characters from the screen to the printer. If the printer is unavailable, this routine waits until the printer becomes available. If BREAK is pressed, this routine returns to the caller.

*01D9-01E5H – Subroutine to wait for PRINTER READY, but Honor a BREAK Key. This routine used to be at 0440-044A.

*01E6H-01EC – Display the Copyright Message. This routine used to be at 37EBH-37F5H.

*01EDH-01F7H – – Enable the TIME$ Command – This routine used to be at 37DCH.

*01F8 – Turn Off The Cassette Motor – “$CSOFF”
After writing data to the cassette, this routine should be called to turn off the cassette drive. There are no entry conditions and no registers are modified.

*01FB-0201 – DELAY ROUTINE – “$DELAY”

• This is a delay loop. The BC register pair is used as the loop counter. The duration of the delay, in microseconds, is the value of BC times 14.65. Register A is used.

*202 – Message Storage Location

0210 – These instructions are never called or used.

0212H – This continues a subroutine and was JUMPed to from 022CH. It zeroes A and all flags everything and RETURNs.
Difference between M1 and M3: In the Model I, routines to define cassette drive (0212H – 021DH), reset the cassette input port FFH (021EH – 022BH), and to blink the asterisk while reading a cassette (022CH – 0234H). In the Model III, a routine to insure compatibility with programs that define the cassette drive (XOR A followed by RET, located at 0212H & 0213H), a subroutine used by the routine that begins at 01D9H (0214H 0227H), a couple of cassette-related segments (0228H – 022DH), and an EI instruction followed by JP 1Al9H (enable interrupts and return to BASIC “READY”, located at 022EH – 0231H).

0216-021A – Display a Carriage Return

021B-0227 – “$VDLINE” – Display a Line Until 03H or 0DH Reached.
This subroutine displays a line. The line must be terminated with an ASCII ETX (X’03’) or carriage return (X’0D’). If the terminator is a carriage return, it will be printed; if it is an ETX, it will not be printed. This allows VDLINE to position the cursor to the beginning of the next line or leave it at the position after the last text character. On entry (HL) shuold contain the output text, terminated by a 03H or a 0DH.

0228H – This continues a subroutine and was JUMPed to from 023DH. It puts 3000H into the memory location pointed to by the stack pointer, and JUMPs to 302AH.

022CH – BLINK ASTERISK routine – This routine is CALLED from 02E7 and alternatively displays and clears an asterisk in the upper right hand corner of the video display.

0232 – These instructions are never called or used.

*0235-0240 – CASSETTE ROUTINE – Read a Byte from Cassette – “CSIN”
After the completion of a $CSHIN call, this $CSIN routine begins inputting data, one byte at a time. This routine MUST be called often enough to keep up with the baud rate. There are no entry conditions. A is modified to hold the data byte.
Difference between M1 and M3: In the Model I, 0235H – 0240H contains the routine to read one byte from the cassette, and 0241H – 0260H contains the routine to get one bit from the cassette. In the Model III, 0235H – 023CH contain the start of the Model III routine to read one byte from cassette, 023DH – 0242H is part of the routine that begins at 0287H (writes cassette leader and sync byte), 0243H – 024CH is the actual start of the routine to search for the cassette leader and aync byte, 024DH – 0252H is the actual start of the routine to write a byte to tape, and 0253H – 025EH is a subroutine used by the system to select 500 or 1500 baud tape speed.

023D – – This continues a subroutine and was JUMPed to from 028BH to to set the cassette write vector. It just PUSHes HL, puts 3000H into HL, and JUMPs out to 0228H.

*0243-024B – CASSETTE ROUTINE – Read a Byte from Cassette

*024D-0252 – CASSETTE ROUTINE – Write a Byte to Cassette

0264 – “$CSOUT” – Output a byte to cassette.
After writing the header with $CSHWR, use this $CSOUT to write the data, one byte at a time. You MUST call $CSOUT often enough to keep up with the baud rate. Register A needs to hold the data byte on entry.
Difference between M1 and M3: In the Model I, 0264H – 0283H contains the routine to output one byte to the cassette. In the Model III, 0264H – 0266H contains a jump to 024DH (the start of the Model III routine to output one byte to cassette), followed by time data (60 seconds, 60 minutes, 24 hours) at 0266H – 0268H, followed by twelve bytes which contain the length of each of the twelve months (0264H – 0274H). This is followed by two NOPs, then starting at 0277H is a 1DH byte, a 1EH byte, the message “Diskette?”, and finally a 03H byte (at 0282H).

0266 – Storage location for the maximum number of seconds in a minute, minutes in an hour, hours in a day, and days in a month.

0284 – This subroutine is called by 2076H to turn the tape on, no header – it jumps out to 023DH.
Difference between M1 and M3: In the Model I, this area contains several cassette I/O routines, including turn on cassette, write leader and sync byte (0284H); write leader and sync byte (0287H); turn on cassette, search for leader and sync byte (0293H); search for leader and sync byte (0296H), put 2 asterisks in upper right corner of video ( part of previous routines, begins at 029FH). In the Model III, 0284H contains a JP 0287H instruction (faster than three NOPs), while 0287H is the start of the routine to turn on the cassette, write leader and sync byte. 028DH – 0292H contains the fast routine to check if BREAK is depressed. 0293H contains a JP 0243H instruction, while 0296H contains a JR 0243H (0243H is the actual start of the routine to turn on the cassette, search for leader and sync byte). 0298H – 02A0H is the machine language routine to turn on the built-in clock display (in the upper right hand corner of the video display), while 02A1H – 02A8H is the location of the corresponding routine to turn the clock display back off.

0287 – Write Leader and Sync Byte – “$CSHWR”
Each cassette record begins with a header consisting of a leader sequence and a synchronization byte. This $CSHWR routine turns on the cassette and writes out this header. There are no entry conditions. A is altered by this routine.

028DH – “$KBBRK” -Check for a BREAK key only. This is a fast key scan routine which looks solely for the BREAK key. Use this routine if you want to minimize the keyboard scan time without totally locking out the keyboard. On exit NZ will be set if BREAK was set. This subroutine is called by 0444H (in the middle of the PRINTER ROUTINE) to check for a BREAK key.

0293 – CASSETTE ROUTINE – Read the Header and Sync Bytes

0296 – CASSETTE ROUTINE – “CSHIN” – Search for Cassette Header and Sync Byte
Each cassette record begins with a header consisting of a leader sequence and synchronization byte. $CSHIN turns on the cassette drive and begins searching for this header information. The subroutine returns to the calling program after the sync-byte has been read. There are no entry conditions. Register A is altered by the routine.

0298 – Enable the Clock Display – “CLKON”
No entry conditions. A is altered by this routine.

02A1 – Disable the Clock Display – “CLKOFF”
No entry conditions. A is altered by this routine.

02A8 – These instructions are never called or used.

02A9-02B1 – LEVEL II SYSTEM ROUTINE-ENTRY POINT- “GSYSTR”

Top of a DJNZ loop of 06 characters.

End of the DJNZ loop of 06 characters.

0314-0316 – This subroutine reads two bytes from tape (providing that the tape is already running) and puts them in the HL register pair. It is used by the SYSTEM routine to read the last two bytes on tape which give the entry point. A JP (HL) can then be executed to jump to the location specified, when used for this purpose. Only HL is used by this routine.

031D – “SYSGO” – This subroutine checks to see if we have a starting address from the “*?” prompt and if not, default to 40DFH, and then JUMP to whatever that address is.

032A-0347 – OUTPUT ROUTINE – “OUTCHR” or “DSPCHR”

• This is a general purpose output routine which outputs a byte from the A register to video, tape or printer. In order to use it, the location 409CH must be loaded with -1 for tape, 0 for video or 1 for the line printer.
  Note: 409CH holds the current output device flag:
  • -1: Cassette
  • 0: Video
  • 1: Printer
• This routine outputs a byte to device determined by byte stored at (409CH) – FFH=Tape, 0=Video, l=Printer. When calling, A = output byte. Uses AF. Warning: This routine CALLs a Disk BASIC link at address 41ClH which may have to be “plugged” with a RETurn (C9H) instruction.

033A-0347 – “CRTOUT” OUTPUT ROUTINE

• To use a ROM call to print a single character at the current cursor position, and to update the cursor position, load the ASCII value of the character into the A register and then CALL 033AH.
• To display special functions using a ROM call, load the A register with the value given below for the special function and then CALL 033AH.
  1. Backspace and erase previous character – 08H
  2. Carriage return and linefeed – 0DH
  3. Turn on cursor – 0EH
  4. Turn off cursor – 0FH
  5. Convert to 32 characters per line mode – 17H
  6. Backspace cursor – 18H
  7. Advance cursor one position – 19H
  8. Downward line feed – 1AH
  9. Upward line feed – 1BH
  10. Home (cursor to upper left corner) – 1CH
  11. Move cursor to beginning of current line – 1DH
  12. Erase from cursor position to end of line – 1EH
  13. Erase from cursor position to end of screen – 1FH

0348-0357 – VIDEO ROUTINE – Get the cursor location (taking into account whether we are in 32 or 64 character mode)

This is a bug in the Model III code. The code is a holdover from the Model I to test whether or not the video display is currently in the 32-character mode. The next 2 instructions (LD A,403DH and AND 08H) was supposed to test bit 3 of memory location 403DH to make that determination, but 403DH does not hold the 32 character flag on the Model III! To fix this bug, the next 2 instructions should be LD A,(4210H) and AND 04H. This bug results in the improper operation of the TAB function when the video display is in the 32 character mode.

0358-0360 – KEYBOARD ROUTINE – “KBD2”
Here is the routine to simulate the INKEY$ function. It performs exactly the same function as 2BH but it restores all registers, whereas 2BH destroys the contents of the DE register pair. This makes 35BH more useful than 2BH.

0361-0383 – INPUT ROUTINE
“LINP2”

• This is one of the general purpose input routines (see 05D9 and 1BB3 also). This routine inputs a string from the keyboard, up to a maximum of 240 characters (F0H), and echoes them to the screen. It puts this data into a buffer located at the address pointed to by the buffer pointer at 40A7H. (e.g. If 40A7H contains 5000H the data will be stored from 5000H onwards). The string is terminated with a zero byte. The program returns from this routine as soon as the ENTER key has been pressed. When it does so, HL contains the start address of the input string and B contains the length of the string. (RST 10H can be used to make HL point to the first character of the string, if required.).
  
  NOTE: 40A7H-40A8H holds the input Buffer pointer.

0384-038A – KEYBOARD ROUTINE – “KBWT2” – Waits for keypress

038B-039B – PRINTER ROUTINE

• This routine resets device type flag at 409CH to zero (output to video display), also outputs a carriage return to the line printer if printer is not at beginning of line (determined by checking the contents of the printer line position flag at 409B – if flag contains zero, printer is at start of line). Note that if printer line position flag does not contain zero and the printer is not on line, the computer will “hang up” waiting for a “printer ready” signal.

039C-03C1 – PRINTER ROUTINE

• This is the LPRINT routine. All registers are saved. The byte to be printed should be in the A register.

03B6H – If we are here, the character sto be sent to the printer was a SKIP TO NEXT LINE (0CH) or a CARRIAGE RETURN (0DH).

*03C2H-0451H – PRINTER ROUTINE

Difference between M1 and M3: Start of I/O driver area which has been totally rearranged in the Model III. Specifically, in the Model I the area from 03C2H through 0SD0H was arranged as follows: 03C2H – 03E2H is the I/O driver entry routine, 03E3H – 0457H is the keyboard driver routine, 0458H – 058CH is the video driver routine, and 058DH – 0SD0H is the line printer driver routine. In the Model III, 03C2H – 0451H is the line printer driver routine, 0452H – 0468H is the actual location of the routine to initialize all I/O drivers, 046BH – 0472H is a routine used by the RUN/EDIT/NEW commands to unprotect the video display and to load HL with the start of BASIC program pointer at 40A4H-40A5H, and 0473H-05D0H is the video driver routine and the keyboard driver begins at 3024H in the Model III).

03E5H – Inside the PRINTER ROUTINE – If we are here, the characters to be sent to the printer are NOT control characters, so test for graphics (and jump away), and if not, put the character from the PRINTER LOOKUP TABLE into C.

*03F5-0424 – Inside the PRINTER ROUTINE – Print A Character Honoring Page Height and Width

*0403 – Inside the PRINTER ROUTINE – If we are here, then C holds the printable character to be printed as determined by the PRINTER CHARACTER TABLE.

042A – Inside the PRINTER ROUTINE – If we are here, then we have a LINE FEED or a CARRIAGE RETURN in A.

*0440-044A – Inside the PRINTER ROUTINE – Subroutine to wait for PRINTER READY, but Honor a BREAK Key

*03C2H-0451H – PRINTER ROUTINE

*03E9-03F5 – Inside the PRINTER ROUTINE – Subroutine if the character is a CONTROL CHARACTER.

*03F6-4000 – Inside the PRINTER ROUTINE – Subroutine if the memory contents of 41FBH are zero.

*040AH-040EH – Inside the PRINTER ROUTINE – Subroutine if the memory contents of 41FCH are zero.

*0414H-040EH – Inside the PRINTER ROUTINE – We have a CARRIAGE RETURN to print.

*041F – Inside the PRINTER ROUTINE – If we are here, then C holds the printable character to be printed as determined by the PRINTER CHARACTER TABLE.

*0434 – Inside the PRINTER ROUTINE – It seems that if something jumps here, we have a valid character in C to print.

*044B-0451 – Inside the PRINTER ROUTINE – Subroutine to check to see if PRINTER READY by polling port F8H

*0452-0468 – Initialize KB, DI, PR, RI, RO and RN

0469-046A – These instructions are never called or used.

*046B-0472 – This subroutine zeroes out the PROTECTED SCREEN LINES (if any) and point HL to the start of data

*0473H-04B1H – Cursor Management

*048B – Inside the CURSOR MANAGEMENT ROUTINE – If we are here, the character is not a control character, tab, or special characters.

*04B2 – Cursor Management – Move to the start of the line.

*04B7 – Cursor Management – We have EITHER a TAB or SPECIAL CHARACTER, so figure it out, and proceed accordingly.

*04CC – Cursor Management – CURSOR ON.

*04D1 – Cursor Management – CURSOR OFF (Jumped to from 0539H)

*04D4 – Cursor Management – HOME CURSOR

*04EB – Cursor Management – BACKSPACE

*04F7 – Cursor Management – CURSOR BACK

*0504 – Cursor Management – CURSOR DOWN

*0509 – Cursor Management – CURSOR FORWARD.

*050E – Cursor Management – CURSOR UP

*0513-0520 – Cursor Management – Turn on DOUBLE SIZE and put the cursor on EVEN columns only.

*0521-055F – Cursor Management – Process Special Characters

*0560 – Cursor Management – Control Characters.

*056B – Cursor Management – Special and Alternative Characters

0576 – This routine displays a character, moves forward either 1 or 2 spaces depending on if we are double size or not, and advances the screen if that character pushed the cursor beyond the end of the screen.

*0588 – Cursor Management – Scroll the Screen

*05AF – Cursor Management – CARRIAGE RETURN or LINE FEED

*05BC – Cursor Management – CLEAR TO END OF LINE

*05C5 – Cursor Management – CLEAR TO END OF SCREEN

*05D1 – These instructions are never called or used. This was used to hide the name “RON”

Difference between M1 and M3: Rumor has it that this is a malicious destruction of the “printer ready” test routine found at 05D1H-05D8H in the Model I. In the Model III, the first three bytes of the routine are changed from a LD A,(37E8H) instruction to 52H, 4FH, and 4EH (LD D,D; LD C,A; and LD C,(HL); or the ASCII characters “RON”) breaking an otherwise perfectly good routine. An equivalent routine that does work (and which would also have fit nicely into this space) resides from 044BH to 0451H in the Model III (part of the printer driver routine).

*05D1 – Message Storage Area

*05D9-0673 – ACCEPT KEYBOARD INPUT ROUTINE
“KLINE” or “LINP1” – WAIT FOR NEXT LINE (take keyboard entry until a carriage return, a break, or buffer overrun occurs).

• This is the most basic of the string input routines and is used by the two others (1BB3H and 0361H) as a subroutine. To use it, load HL with the required buffer address and the B register with the maximum buffer length required. Keyboard input over the specified maximum buffer length is ignored, and after pressing the (ENTER) key it will return with HL containing the original buffer address and B with the string length.
  A call to this memory location Accepts keyboard input and stores each character in a buffer supplied by caller. Input continues until either a carriage return or a BREAK is typed, or until the buffer is full. All edit control codes are recognized, e.g. TAB, BACKSPACE, etc.
  On exit the registers contain: HL=Buffer address, B=Number of characters transmitted excluding last, C=Orginal buffer size, A=Last character received if a carriage return or BREAK is typed. Carry Set if break key was terminator, reset otherwise. If the buffer is full, the A register will contain the buffer size.
• To use a ROM call to accept a restricted number of keyboard characters for input (n), use:
  LD HL,(40A7H)
  LD B,n
  CALL 05D9H
  Up to n characters will be accepted, after which the keyboard will simply be ignored until the ENTER (or LEFT ARROW, or BREAK, or CLEAR) key is pressed. These characters will be stored in consecutive memory cells starting at the address contained in 40A7H-40A8H (the keyboard buffer area), with a 0DH (carriage return) byte at the end. Upon completion, the HL register pair will contain the address of the first character of the stored input, and the B register will contain the number of characters entered. NOTE: No “?” is displayed as a result of the execution of the above program. If the “?” display is desired to prompt the typing of the input, precede the above program segment with:
  LD A,3FH
  CALL 033AH
  LD A,20H
  CALL 033AH

Inside the ACCEPT KEYBOARD INPUT ROUTINE. If we are here, the CLEAR key was hit.

0630 – This subroutine processes a backspace. On entry, B is the number of characters received, and C is the size of the buffer.

0641 – This subroutine sends the position command.

0661 – This subroutine is called when a BREAK key is hit.

0662H – Inside the BREAK KEY routine – Jumps here if an ENTER was hit, to have the same result, but with the CARRY FLAG untouched.

*0674 – KEYBOARD DRIVER ENTRY ROUTINE

Difference between M1 and M3: In the Model I, this is part of the power-up routine and includes the disk bootstrap routine (06A1H – 06CBH), the preferred BASIC re-entry routine (06CCH-06D1H), and the RST vectors and I/O Device Control Blocks which are relocated to RAM on power-up (06D2H-0707H, relocated to 4000H – 4035H). In the Model III, this area contains the I/O driver entry routine (0674H – 0699H) and additional code used by the LIST and LLIST commands (069AH – 0707H). Note that a jump to 06CCH will no longer get you back into BASIC in the Model III. This might be considered a major blunder in the design of the Model III ROM, both because so many available programs use this re-entry point to BASIC, and because the ROM itself has two jumps to 06CCH (one at 0072H that appears to be unused, and one at 02C3H, which is used if the BREAK key is pressed under the SYSTEM command – a bona fide BUG in the Model III ROM). A substitute re-entry to BASIC that will work with either model is to LD BC,1A18H and then JP 19AEH (this is the code presently found at 06CCH in the Model I).

069AH – This subroutine CLEARS the DATA FLAG, sets up a buffer of 255 bytes (held in D) and JUMPS to 2B8DH.

The next set of instructions tests the buffer backwards for M, E, and R, and RETURNS out if those are not found.

At this point BC, BC+1, and BC+2 were REM, so check backwards again for a : and if not, RETURN.

At this point BC, BC+1, BC+2, and BC+3 were :REM.

06E5H – This subroutine sets the DATA FLAG to “BIT 1 HIGH” to indicate that we are in a DATA command.

06EFH – This subroutine sets the DATA FLAG to “BIT 2 HIGH” to indicate that we are in a REM command.

070B-070F – SINGLE PRECISION ADDITION, REG 1 = (HL) + REG 1

• Single-precision addition (REG 1=(HL)+ACC) involving a buffer pointed to by the HL register pair and REG 1 (see arithmetic section in Part 2 of this manual for information on the ACC). This part of the program loads the BCDE registers with the value from the buffer, then passes control to 716H.

0710-0712 – SINGLE PRECISION SUBTRACTION, REG 1 = (HL) – REG 1

• Single-precision subtraction (REG 1=(HL)-REG 1). This loads the BCDE registers with the value from (HL), then passes control to 0713H.

0713-0715 – SINGLE PRECISION SUBTRACTION, REG 1 = BCDE – REG 1
“SUBSP”

• Single-precision subtraction (REG 1=BCDE-REG 1). The routine actually inverts REG 1 (i.e., 4121H) and adds it to the contents of the BCDE registers which, in effect, is a subtraction. The result will be stored in the arithmetic work area (REG 1).
• Note: If you wanted to subtract two single precision numbers, store the minuend in the BCDE registers and store the subtrahend in 4121H-4124H and then CALL 0713H. The result (in single precision format) is in 4121H-4124H in approximately 670 microseconds.

.

0716-0752 – SINGLE PRECISION ADDITION, REG 1 = BCDE + REG 1
“ADDSP”

• Single-precision addition (REG 1=BCDE+ACC). This routine adds two single-precision values and stores the result in REG 1 (i.e., 4121H) area.
• Note: If you wanted to add 2 single precision numbers via a ROM call, store one input into BCDE (with the exponent in B and the LSB in E) and the other into 4121H-4124H, and then call 0716H. The single precision result will be in 4121H-4124H approximately 1.3 milliseconds later.

0754-077C – SINGLE PRECISION MATH ROUTINE

0778H – Zero Register 1 (i.e. 4124H)

077D-07A7 – SINGLE PRECISION MATH ROUTINE

07A8-07B6 – SINGLE PRECISION MATH ROUTINE – Check for overflow if the most significant bit in the value in register A is set

07B7-07C2H SINGLE PRECISION MATH ROUTINE – Add the single precision value in BCDE to the single precision value in REG 1 (i.e., 4121H).

07C3-07D6 – SINGLE PRECISION MATH ROUTINE – Convert to a single precision number to positive.

07D7-07F7 – SINGLE PRECISION MATH ROUTINE – Shift the single precision value in register pairs BC and DE until it lines up with the single precision value in REG 1 (i.e., 4121H).

07F8-07FB – SINGLE PRECISION CONSTANT STORAGE LOCATION

07FC-0808 – SINGLE PRECISION CONSTANTS STORAGE LOCATION2

0809-0846 – LEVEL II BASIC LOG ROUTINE – LOG

• The LOG(n) routine, (REG 1=LOG (REG 1)). This routine finds the LOGarithm of the value in REG 1 (i.e., 4121H) area.
  A call to 0809H computes the natural log (base E) of the single precision value in REG 1 (i.e., 4121H). The result is returned as a single precision value in REG 1 (i.e., 4121H).
• NOTE: To use a ROM call to find LOG(X), where X is a positive single precision variable, store the value of X in 4121H-4124H and then CALL 0809H. The result (in single precision format) is in 4121H-4124Hin approximately 19 milliseconds.
  
  NOTE: A fatal error occurs if the value of the input variable is zero or negative.

0847-0891 – SINGLE PRECISION MULTIPLICATION, REG 1 = BCDE * REG 1 – “MLTSP”

• Single-precision multiplication (REG 1=BCDE*ACC).
  Multiplies the current value in WRAl by the value in (BC/DE). the product is left in WRAl.
• Note: If you wanted to multiply two single precision numbers store one operand in the BCDE registers, the other in 4121H-4124H CALL 0847H. The result (in single precision format) is in 4121H-4124H in approximately 2.2 milliseconds.

0892-0896 – SINGLE PRECISION MATH ROUTINE
This is accomplished by a circular shift of BC/DE one byte – B is lost, C is replaced by A.

0897-08Al – SINGLE PRECISION MATH ROUTINE – Divide a single precision number by 10.

08A2-0903 – SINGLE PRECISION DIVISION, REG 1 = BCDE / REG 1

• “DIVSP” – Single-precision division (REG 1=BCDE/REG 1). If REG 1=0 a ” /0 ERROR ” will result.
  This routine will divide the SINGLE PRECISION value in register pairs BC and DE by the single precision value in REG 1 (i.e., 4121H). The result is returned in REG 1.
• To use a ROM call to divide two single precision numbers, store the dividend in registers BCDE, and the divisor in 4121H-4124H and then CALL 08A2H. The result (in single precision format) is in 4121H-4124H and then pproximately 4.8 milliseconds. Overflow or /0 will error out and return to Level II.

0904-0906 – DISPLAY OV ERROR MESSAGE

0907-0913 – DOUBLE PRECISION MATH ROUTINE

0914-0930 – SINGLE PRECISION MATH ROUTINE

0931-093D – SINGLE PRECISION MATH ROUTINE

093E-0954 – SINGLE PRECISION MATH ROUTINE – Multiply the current value by 10

0955-0963 – SINGLE PRECISION MATH ROUTINE – “SIGN”. Checks the value of the sign bit for the value in REG 1.

0964-0976 – SINGLE PRECISION MATH ROUTINE – “FLOAT”. Float the signed number in B,A,D,E. Alters A,B,C,D,E,H,L

0977-0989 – LEVEL II BASIC MATH ROUTINE
“ABS“

• ABS routine (REG 1=ABS(REG 1)) input and output can be integer, single-precision or double-precision, depending on what is placed in the NTF (NTF=2, 4 or 8).
  A call to 0977H converts the value in Working Register Area 1 (WRAl) to its positive equivalent. The result is left in REG 1. If a negative integer greater than 2** 15 is encountered, it is converted to a single precision value. The data type or mode flag (40AFH) will be updated to reflect any change in mode.
• NOTE: To use a ROM call to find ABS(X),store the value of X in 4121H-4122H (integer), in 4121H-4124H (single precision), or in 411DH and then H (double precision), and store the variable type (2, 4, or 8, respectively) in 40AFH. Then CALL 0977H. The result (in the same format as the input variable) is in the same locations in which the input variable was stored. If the input was an integer, the result is also in the HL register pair.

097BH – Convert the negative value in REG 1 to its positive equivalent. Alters A,B,C,D,E,H,L

098A-0993 – LEVEL II BASIC MATH ROUTINE
“SGN” – Alters A,H,L

• SGN function (REG 1=SGN(REG 1)). After execution, NTF=2 and REG 1=-l, 0 or 1 depending on sign and value of ACC before execution.
• NOTE: To use a ROM call to find SGN(X), store the value of X in 4121H-4122H (integer), in 4121H-4124H (single precision), or in 4124H (double precision) and then store the variable type (2, 4, or 8, respectively) in 40AFH and then CALL 098AH. The result (in integer format) is in 4121H-4122H and in the HL register pair.

0994-09A3 – LEVEL II BASIC MATH ROUTINE.
“VSIGN” – Get the sign of the value in the FAC in A. Alters A,H,L

• This routine checks the sign of the ACC. NTF must be set. After execution A register=00 if REG 1=0, A=01 if ACC > 0 or A=FFH if A < 1. The Flags are also valid.

09A4-09B0 – SINGLE PRECISION MATH ROUTINE
“LDSTSA”

• Loads Single-precision value from ACC to STACK ((SP)=ACC). To retrieve this value, POP BC followed by POP DE. A, BC and HL are unchanged by this function.

09Bl-09BE – SINGLE PRECISION MATH ROUTINE
“LDSAHL”

• This routine loads four bytes from the location pointed to by HL, into the ACC. (REG 1=(HL)).
• It moves a number from memory [(HL)] to FAC. It alters B,C,D,E,H,L. Upon exit the number is in B,C,D,E and (HL):=(HL)+4

09BF-09CA – SINGLE PRECISION MATH ROUTINE
“LDRASA”

• This routine is the opposite of the 09B4H routine. It loads four bytes from REG 1 (single-precision) into the BC and DE register pairs. (BCDE=ACC). A is unchanged.
• Move FAC to registers (B,C,D,E). Alters B,C,D,E,H,L

09CB-09Dl – SINGLE PRECISION MATH ROUTINE
“LDHLSA”

• This routine is the opposite of the 9B1H routine. It loads four bytes from REG 1 to the memory location pointed to by HL. ((HL)=ACC).
• Move number from FAC to memory [(HL)]. Alters A,B,C,D,E,H,L

09D2-09DE – MOVE VALUE POINTED TO BY HL TO THE LOCATION POINTED TO BY DE
“LDDEHL”

• This is the VARIABLE MOVE Routine which moves the number of bytes specified in the type flag (40AFH) from the address in DE to the address in HL. Uses A, DE and HL.
• Move number from (DE) to (HL). Alters A,B,C,D,E,H,L. Exits with (DE):=(DE)+4 : (HL):=(HL)+4

09DF-09F3 – SINGLE PRECISION MATH ROUTINE

• Unpack the FAC and the registers. Alters A,C,H,L. When the number in the FAC is unpacked, the assumed one in the mantissa is restored, and the complement of the sign is placed in FAC+1.

09F4-09FB – LEVEL II BASIC MATH ROUTINE

• This routine is used by the double-precision logic. It moves a number of bytes (the number depending on the value stored in the NTF) from the AACC into the ACC. ((REG 1)=(AACC)).
• Move any type value from memory [(HL)] to FAC. Alters A,B,D,E,H,L

09FC-0A0B – LEVEL II BASIC MATH ROUTINE

• This is the opposite of 9F4H. ((AACC)=(REG 1)).
• Move any type value from FAC to memory [(HL)]. Alters A,B,D,E,H,L.

0A0C-0A25 – SINGLE PRECISION COMPARE
“CPSP”

• Single-precision compare. Compares REG 1 with the contents of BCDE registers. After execution of this routine, the A register will contain: A=0 if REG 1=BCDE, A=1 if ACC>BCDE or A=FFH if ACC<BCDE.
• NOTE: To use a ROM call to compare two single precision numbers, store the first input in registers BCDE, the second input in 4121H-4124H and then CALL 0A0CH. If the numbers are equal, the Z (zero) flag will be set. If they are not equal, the Z flag will be turned off. If the first input number is the smaller, the S (sign) and C (carry) flags will also be turned off. If the second input number is the smaller, the S and C flags will both be set.

0A26-0A38 – SINGLE PRECISION COMPARISON ROUTINE

0A39-0A48 – INTEGER COMPARE

• Integer compare. Compares HL with DE. After execution, A=0 if HL=DE, A=1 if HL>DE or A=FFH if HL<DE. The S and Z flags are valid.
• NOTE: To use a ROM call to compare two integers, store the first input in DE, the second in HL and then CALL 0A39H. If the numbers are equal, the Z (zero) flag will be set. If they are not equal, the Z flag will be turned off. If the first input number is the smaller, the S (sign) and C (carry) flags will also be turned off. If the second input number is the smaller, the S and C flags will both be set.

0A49-0A77 – DOUBLE PRECISION COMPARE

• Double-precision compare. Compares REG 1 with the AACC. After execution the A register will contain: A=0 if REG 1=AACC, A=1 if ACC > AACC or A=FFH if ACC < AACC. S and Z flags are valid.

0A78-0A7E – DOUBLE PRECISION COMPARE
“CPDP”

• Double-precision compare. This compare is the opposite of the A4FH compare. It compares the AACC with the ACC. (Remember that a compare is actually a subtraction that is never executed therefore a compare can be done in two ways with the same values. (A-B and B-A)). The results are the same as the A4FH routine.
• NOTE: To use a ROM call to compare two double precision number, store the first input in 411DH-4124H, and store the second input in 4127H-412EH and then CALL 0A78H. If the numbers are equal, the Z (zero) flag will be set. If they are not equal, the Z flag will be turned off. If the first input number is the smaller, the S (sign) and C (carry) flags will also be turned off. If the second input number is the smaller, the S and C flags will both be set.

0A7F-0AB0 – LEVEL II BASIC CINT ROUTINE

• CINT routine. Takes a value from ACC, converts it to an integer value and puts it back into the ACC. On completion, the HL register pair contains the LSB of the integer value, and the NTF contains 2 (Integer=2). If NTF=3 (string) a TM ERROR will be generated and control will be passed to BASIC.

• NOTE: To use a ROM call to call the CINT routine, store the single precision input variable in 4121H-4124H and then call to 0A8AH and bypass all the foregoing. After the call, the integer result would be in 4121H-4122H and in the HL register pair. Too big a number will generate a ?OV Error.

0AB1-0ACB – LEVEL II BASIC CSNG ROUTINE
“CSASP”

• CSNG routine. Takes value from ACC and converts it to single-precision. The result is put in ACC and NTF contains 4.

0ACC-0ADA – LEVEL II BASIC MATH ROUTINE
“CHGIS”

• Convert Integer to Single Precision. Alters: A,B,C,D,E,H,L.
• Note: If you wanted to convert integer to single precision via a ROM call, you would store the integer input variable in 4121H-4122H and then call to 0ACCH. The result (as a single precision number) will be in 4121H-4124H.

0ADB-0AED – LEVEL II BASIC CDBL ROUTINE
“CSADP”

• CDBL routine. Takes a value from ACC and converts it to double-precision. The result will be in ACC and NTF will be 8.

0AEE-0AF3 – LEVEL II BASIC MATH ROUTINE

0AF4-0AFA – LEVEL II BASIC MATH ROUTINE – Force REG1 to be a STRING

• This routine calls 20H (RST 20H) and returns if NTF=3 (string) else if NTF is not 3 then it generates a TM ERROR. BC, DE, and HL are saved.

0AFB-0B1E – LEVEL II BASIC MATH ROUTINE

• This routine will reset the BC and DE register pairs if the A register contains 0. (XOR A before calling this routine).
• Greatest integer function. Leaves INT(REG1) in C,D,E (signed). Assumes REG1 < 2^23 = 8388608. Assumes the exponent of REG1 is in A. Alters A,B,C,D,E

The hard case is QINT is negative non-integers. To handle this if the number is negative, we regard the 3-byte mantissa as a 3 byte integer and subtract one. Then all the fractional bits are shifted out by shifting the mantissa right. Then, if the number was negative, we add one. So if we had a negative integer, all the bits to the right of the binary point were zero. So the net effect is we have the original number in C,D,E. If the number was a negative non-integer, there is at least one non-zero bit to the right of the binary point. So the net effect is that we get the absolute value of INT(REG1) in C,D,E. C,D,E is then negated if the original number was negative so the result will be signed.

0BlF-0B25 – LEVEL II BASIC MATH ROUTINE

0B26-0B58 – LEVEL II BASIC FIX ROUTINE
“FIX”

• FIX routine. Takes a value from ACC and converts it to an integer value. The result will be in ACC. NTF will be 2 if value is smaller than 32767 else it will be 4. An error will be generated if NTF=3 (string).
  A call to 0B26H unconditionally truncates the fractional part of a floating point number in REG 1. The result is stored in WRAl and the type flag is set to integer.
• Note: If you wanted to call the FIX routine via a ROM call, you would store the single-precision input variable in 4121H-4124H, then put a 4 into 40AFH to flag as single precision, and then call to 0B26H. If the result can be an integer, it will be in 4121H-4122H and in the HL register pair. If single precision, the result will be in 4121H-4124H. If double precision, in 411DH-4124H. In all cases 40AFH will have the data mode flag as 2, 4, or 8, accordingly.
• The routine is FIX(X)=SGN(X)*INT(ABS(X))

0B37 – LEVEL II BASIC INT( ROUTINE

A call to 0B37H returns the integer portion of a floating point number. If the value is positive, the integer portion is returned. If the value is negative with a fractional part, it is rounded up before truncation. The integer portion is left in REG 1. The mode flag is updated.

Note: If you wanted to call the INT routine via a ROM call, you would store the single precision input variable in 4121H-4124H, put a 4 into 40AFH (to flag as single precision), and then call 0B3DH and bypass all the foregoing. After the call, the integer result would be in 4121H-4122H and in the HL register pair IF the absolute value of the input did not exceed 32767. Otherwise it will be in 4121H-4124H in single precision format, and 40AF will be a 2 for integer or 4 for single precision..

0B59-0B9D – LEVEL II BASIC MATH ROUTINE

0BA0-0BA9 – LEVEL II BASIC MATH ROUTINE

0BAA-0BC6 – LEVEL II BASIC MATH ROUTINE – Integer Multiply for Multiply Dimensioned Arrays. DF = BC * DE. Overflow will cause a BS ERROR. Alters A, B, C, D, and E

0BC7-0BD1 – INTEGER SUBTRACTION
“SUBINT”

• Integer subtract. (REG 1=DE-HL) The result is returned in both REG 1 and the HL register pair.
  Subtracts the value in DE from the value in HL. The difference is left in the HL register pair. DE is preserved. In the event of underflow, both values are converted to single precision and the subtraction is repeated. The result is left in REG 1 and the mode flag is updated accordingly.
• Note: If you wanted to subtract 2 integers via a ROM call, store one into DE and the subtrahend in HL (i.e., to do 26-17, DE gets 26), and then call 0BC7H. The integer result will be stored in 4121H-4122H approximately 210 microseconds later, and 40AFH will be set to 2 (to flag it as an integer). If there is an overflow, it will be converted to single precision (with 40AFH being a 4 in that case) and will be stored in 4121H-4124H.
• (HL):=(DE)-(HL). Alters: A,B,C,D,E,H,L

0BD2-0BF1 – INTEGER ADDITION
“ADDINT”

• Integer addition (REG 1=DE+HL). After execution NTF=2, or 4 if overflow has occurred, in which case the result in REG 1 will be single-precision. The result is returned in both REG 1 and the HL register pair.
  Adds the integer value in DE to the integer in HL. The sum is left in HL and the orginal contents of DE are preserved. If overflow occurs (sum exceeds 2**15), both values are converted to single precision and then added. The result would be left in Reg 1 and the mode flag would be updated.
• Note: If you wanted to add 2 integers via a ROM call, store one input into DE and the other into HL, and then call 0BD2H. The result will be in 4121H-4122H and in HL, with a 2 in 40AFH, and will take about 130 microseconds. If there is an overflow, the result will be converted to Single Precision and put into 4121H-4124H (with a 4 in 40AFH).
• (HL):=(DE)+(HL). Alters: A,B,C,D,E,H,L

0BF2-0ClE – INTEGER MULTIPLICATION
“MLTINT”

• Integer multiply. (REG 1=DE*HL). Multiplies HL by DE. The product is left in HL and DE is preserved. If overflow occurs, both values are converted to single precision and the operation is restarted. The product would be left in REG 1.
• Note: If you wanted to multiply two integers, store one input in DE, the other in HL CALL 0BF2H. The result is in 4121H-4122H and in HL, with a 2 in 40AFH (but in an overflow the result is converted to single precision format and stored in 4121H-4124H, with a 4 in 40AFH. Process takes approximately 900 microseconds.
• Alters A,B,C,D,E,H,L

This is an entry point from IDIV and is to test to see if the rsult is greater than 32767.

0ClF-0C34 – LEVEL II BASIC MATH ROUTINE

0C37-0C44 – LEVEL II BASIC MATH ROUTINE

0C45-0C5A – LEVEL II BASIC MATH ROUTINE

0C5B-0C6F – LEVEL II BASIC MATH ROUTINE – Integer Negation. Alters A,B,C,D,E,H,L.

0C70-0C76 – DOUBLE PRECISION SUBTRACTION
“SUBDP”

• Double-precision subtraction (REG 1=ACC-AACC).
  Subtracts the double precision value in REG 2 from the value in REG 1. The difference is left in REG 1.
• Note: If you wanted to subtract two double precision numbers, store the minuend in 411DH-4124H and the subtrahend in 4127H-412EH, and CALL 0C70H. The result (in double precision format) is in 411DH-4124H in approximately 1.3 milliseconds.

0C77-0CCEH -DOUBLE PRECISION ADDITION
“ADDDP”

• Double-precision addition (REG 1=ACC+AACC).
  Adds the double precision value in REG 2 to the value in REG 1. Sum is left in REG 1.
• Note: If you wanted to add 2 double precision numbers via a ROM call, store one input into 411DH-4124H and the other in 4127H-412EH. Then call 0C77H. The double precision result will be stored in 411DH-4124H approximately 1.3 milliseconds later.

0CCF-0DlF – DOUBLE PRECISION MATH ROUTINE

0D20-0D32 – DOUBLE PRECISION MATH ROUTINE

0D33-0D44 – DOUBLE PRECISION MATH ROUTINE

0D45-0D56 – DOUBLE PRECISION MATH ROUTINE

0D57-0D68 – DOUBLE PRECISION MATH ROUTINE

0D69-0D8F – DOUBLE PRECISION MATH ROUTINE

0D90-0D96 – DOUBLE PRECISION MATH ROUTINE

0D97-0DA0 – DOUBLE PRECISION MATH ROUTINE

0DAl-0DD3 – DOUBLE PRECISION MULTIPLICATION
“MLTDP”

• Double-precision multiplication (REG 1=ACC*AACC).
  Multiplies the double precision value in REG 1 by the value in REG 2. The product is left in REG 1.
• Note: If you wanted to multiply two double precision numbers store one operand in 411DH-4124H, and store the other in 4127H-412EH and then CALL 0DA1H. The result (in double precision format) is in 411DH-4124H in approximately 22 milliseconds.

0DB2 – INTEGER ADD routine – “IADD”

Adds the integer value in DE to the integer in HL. The sum is left in HL and the orginal contents of DE are preserved. If overflow occurs (sum exceeds 2**15), both values are converted to single precision and then added. The result would be left in REG 1 and the mode flag would be updated.

0DD4-0DDB – DOUBLE PRECISION CONSTANT STORAGE AREA

0DDC-0DE4 – DOUBLE PRECISION MATH ROUTINE – – Divide a double precision number by 10.

0DE5-0E38 – DOUBLE PRECISION DIVISION
“DIVDP”

• Double-precision division (REG 1=ACC / AACC).
  Divides the double precision value in WRAl by the value in REG 2. The quotient is left in REG 1.
• To use a ROM call to divide two double precision numbers, store the dividend in 411DH-4124H, and the divisor in 4127H-412EH and then CALL 0DE5H. The result (in double precision format) is in 411DH-4124H and then pproximately 42 milliseconds. Overflow or /0 will error out and return to Level II.

0E39-0E4C – DOUBLE PRECISION MATH ROUTINE – Move the double precision value in REG 1 to a temporary work area.

0E4D-0E64 – LEVEL II BASIC MATH ROUTINE – Multiply the current double precision value by 10

• This routine multiplies the current DP value by 2 by adding it to itself. First the current value is moved to a saved location, and then DP add routine adds the current value to that saved value.

0E65-0F88 – ASCII TO DOUBLE PRECISION

• This routine converts an ASCII string (pointed to by HL) to a double-precision value and stores it in the ACC. The NTF is fixed accordingly. The string must be terminated with a , or zero byte. Note that the AACC is destroyed in the process and that HL will point to the delimiter at the end of the string. The string formats must follow the same rules as in BASIC.

0E6C – ASCII to Binary Converter

• A call to 0E6CH converts the ASCII string pointed to by HL to binary. If the value is less than 2** 16 and does not contain a decimal point or an E or D descriptor (exponent), the string will be converted to its integer equivalent. If the string contains a decimal point or an E, or D descriptor or if it exceeds 2** 16 it will be converted to single or double precision. The binary value will be left in REG 1 and the mode flag will be to the proper value.
• Note: If you wanted to do this conversion via a ROM call, first have the characters assembled in consecutive memory locations, with either a comma or a 00H at the end. Load HL with the address of the first character. Call 0E6CH. If the output can be an integer, it will be in 4121H-4122H (with 40AFH being a 2). If the output has to be single precision, it will be in 4121H-4124H (with 40AFH being a 4). If the output has to be double precision, it will be in 411DH-4124H (with 40AFH being an 8).

0E83H – Process a + or – at the location of the current input buffer.

0EA4H – Inside the ASCII TO BINARY CONVERTER routine. Process a E at the location of the current input buffer.

0EE4H – Inside the ASCII TO BINARY CONVERTER routine. Process a . at the location of the current input buffer. JUMPed to from 0E89H.

0EEEH – Inside the ASCII TO BINARY CONVERTER routine. Process a % at the location of the current input buffer. JUMPed to from 0E92H.

0EFBH – Inside the ASCII TO BINARY CONVERTER routine. Convert the current value in REG 1 to either single precision or double precision based on the Z FLAG.

0F0AH – Multiply the current value by 10 Part 1 – Jumps to Part 2 based on number type.

0F18H – Divide the current value by 10 Part 1 – Jumps to Part 2 based on number type.

0F29H – Inside the ASCII TO BINARY CONVERTER routine. Process a number at the location of the current input buffer. JUMPed to from 0E84H.

0F57H – Inside the ASCII TO BINARY CONVERTER routine. At this point, the integer value in HL has the sign bit HIGH.

0F77H – Inside the ASCII TO BINARY CONVERTER routine. At this point, the number in REG 1 is double precision.

0F89-0F93 – SINGLE PRECISION MATH ROUTINE – Subroutine to add the value in register A to the single precision value in REG 1

0F94-0FA6 – LEVEL II BASIC MATH ROUTINE – Part of the ASCII TO BINARY CONVERSION routine. JUMPs here if the character at the location of the input buffer pointer in register A is numeric

0FA7-0FAE – DISPLAY MESSAGE ROUTINE

0FAF-0FBC – CONVERT BINARY TO ASCII AND DISPLAY RESULT. This is also the continuation of the DISPLAY MESSAGE routine above because it is showing an error “IN xxxx” where xxxx would be the ASCII of xxxx (the line number).

This routine converts the value in the HL register pair (which is assumed to be an integer) to ASCII and display it at the current cursor position on the video screen.

0FBDH – BINARY TO ASCII CONVERSION ROUTINE
“CSAASC”

• Conversion routine. Converts the value from REG 1 to an ASCII string delimited with a zero byte. The number type can be any of Integer, single or double-precision. After execution HL will be pointing to the start of the string. REG 1 and AACC are destroyed by the process.
• To use a ROM call to convert a number to a string of digits, and to display the latter on the video screen starting at the current cursor position, store the number in 4121H-4122H (if it’s an integer), or in 4121H-4124H (if it’s single precision), or in 411DH-4124H (if it’s double precision). Then store the variable type (2, 4, or 8, respectively) in 40AFH. Call 0FBDH and then call the WRITE MESSAGE routine at 28A7H.
  • NOTE 1: The routine at 0FBDH is the conversion routine described in Section 3.3 (a). The subroutine at 28A7H is a general program for displaying a string of characters and updating the cursor position. The string to be displayed must be terminated by a zero byte, and the HL register pair must contain the address of the first character of the string before 28A7H is called. (The routine at 0FBDH effects this setup automatically.)
  • NOTE 2: Many of the ROM routines described in this book require a numeric input (or inputs). For most of these, the instructions given for calling them have not included the storage of the variable type flag in 40AFH. The reason is that, wherever possible, the variable type flag storage has been finessed by the choice of the subroutine entry point. In the routine of this section, that has not been possible, nor was it possible for the INT, the FIX, the Number to Numeric String, the SGN, or the ABS routines. Storing a 2, 4, or 8 in 40AFH takes only 5 bytes of machine code, but there are subroutines in the Level II ROM that can reduce the required code to 3 bytes. CALL 0A9DH will store a 2 in 40AFH. CALL 0AEFH will store a 4 in 40AFH. And, finally, CALL 0AECH will store an 8 in 40AFH; this last subroutine, however, destroys the contents of the BC register pair. DISK SYSTEM CAUTION: The subroutine at 28A7H has two exits to DISK BASIC, with RAM transfer points at 41C1H and 41D0H. To use this routine safely, either be certain that DISK BASIC is in place or have your assembly language program fill locations 41C1H and 41D0H with RET’s (C9H), before calling the routine.

0FBE-0FC0 – FLOATING to ASCII Conversion Routine

• This routine converts a single or double precision number in REG 1 to its ASCII equivalent. The ASCII value is stored at the buffer pointed to by the HL register pair. As the value is converted from binary to ASCII, it is formatted as it would be if a PRINT USING statement had been invoked. The format modes that can be specified are selected by loading the following values into the A, B, and C registers as follows:
  • A=0 means do not edit; this is a binary to ASCII conversion
  • A=X means edit as follows: Bit 7=1 means edit the value, Bit 6=Print commas every third digit, Bit 5=Include leading asterisks, Bit 4=Print a leading $, Bit 3=Sign Follows Value, and Bit 1=Exponential Notation
  • B = The number of digits to the left of the decimal point.
  • C = The number of digits after the decimal point.
• Note: If you wanted to convert any integer/single/double into its character string, store the variable in 4121H-4122H for integer, 4121H-4124H for single, or in 411DH-4124H for double. Then load 40AFH with a 2, 4, or 8 depending on whether that variable was integer, single, or double. Then call 0FBDH. Upon return, the character string is stored in 4130H and on, ending with a 00H.

0FD9H is a routine which will convert the integer value in REG 1 (i.e., 4124H) to an ASCII string. Returns with register pair HL pointing to the result.