Model I ROM Explained - Part 2

Initially set up the format specs and put in a SPACE for the sign of a positive number. This routine gets called by the FLOATING to ASCII Conversion Routine (at 0FBEH) and by the BINARY to ASCII Conversion Routine (at 0FAFH)

This routine gets called by the FLOATING to ASCII Conversion Routine (0FBEH-0FC0H) if the value being converted is either Single Precision or Double Precision. This will print a single or double precision number in free format

This routine will put the exponent and a D or E into the buffer. On entry, Register A holds the exponent and it is assumed that all FLAGs are set correctly.

This routine will calculate the two digit exponent.

This routine will print a free format zero.

This routine will print a number in fixed format.

This routine will finish up the printing of a fixed format number.

In this routine, we check to see if we can ignore the leading zero before a decimal point. We can do this if if we see the following: (in order)

If we can get rid of the zero, we put the characters on the STACK back into the buffer one position in front of where they originally were.

Note that the maximum number of STACK levels this uses is three -- one for the last entry flag, one for a possible sign, and one for a possible dollar sign.

We don't have to worry about the first character being in the buffer twice because the pointer when FOUT exits will be pointing to the second occurance.

If the number is too big for the field, we wind up here to deal with that.

This is where the PRINT USING routine will print a single or double precision number in a fixed format

This routine will print a number which is greaster than 10^16 in free format with a percent sign

This routine will print a SINGLE PRECISION number in fixed format/fixed point notation

This routine will print a SINGLE PRECISION or DOUBLE PRECISION number in fixed format/fixed point notation

This routine will print a SINGLE PRECISION or DOUBLE PREVISION number that has fractional digits

This routine will print a number without integer digits.

This routine will print trailing zeroes.

This routine will print an integer in fixed format/floating point notation.

This routine will print a SINGLE or DOUBLE PRECISION number in fixed format/floating point notation.

This routine will scale (normalize) the number in the accumulator so that all the digits are in the integer part (i.e., between 99,999 and 999,999). The signed base 10 exponent is returned in Register A. Registers D and E are unchanged.

There is a big bug in this routine which was fixed in v1.2 of the ROM. The fixing of that bug caused a renumbering from 1228H-124CH. The numbering here will show both.

This routine will see if the number in the ACCumulator is small enough yet

This routine puts leading zeroes into the input buffer. The count is held in Register A and it can be zero, but the Z FLAG needs to be set in that case. Only (HL) and Register A are affected.

This routine will put zeroes in the buffer along with commans or a decimal point in the middle. The count is held in Register A and it can be zero, but the Z FLAG needs to be set in that case. Registers B (decimal point count) and C (comma count) are updated accordingly. Everything but DE is affected.

This routine will put a possible comma count into Register C and will zero Register C if we are not using commas in the specification.

This routine will put decimal points and commas in their correct places. This subroutine should be called before the next digit is put in the buffer. Register B = the decimal point count and Register C = the comma count.

The counts tell how many more digits have to go in before the comma ;or decimal point go in.

The comma or decimal point then goes before the last digit in the count. For example, if the decimal point should come after the first digit, the decimal point count should be 2.

Part of the above routine, jumped here to test to see if a comma needs to be placed at (HL).

This routine will convert a SINGLE PRECISION or a DOUBLE PRECISION number that has been normalized to decimal digits. The decimal point count is in Register B and the comma count is in Register C. (HL) points to where the first digit will go. Routine will exit with A=0.

This routine is to convert a SINGLE precision value to an INTEGER which will be the decimal digits. Divide the integer equivalent by 100,000 and 10,000. Use the code at 1335H to convert the last 1000 to ASCII.

This routine is to calculate the next digit of the number.

This routine divides the integer portion of the current value by 100,000 using compound subtraction. The quotient is kept in Register B as an ASCII value.

This routine converts an integer into decimal digits by dividing the integer portion of the current value by 100,000 using compound subtraction. The quotient is kept in Register B as an ASCII value and A=0 on exit.

This routine computes the square root of any value in ACCumulator. It processes it by raising n to the power of 0.5. The root is left in ACCumulator as a single precision value. Single-precision values only should be used

A call to 13F2H raises the single precision value which has been saved to the STACK to the power specified in ACCumulator. The result will be returned in ACCumulator. The method of computation is e ** (y ln x).

This routine handles the exponentiation routine of X^Y. To do so, first Y is checked for 0 and, if so, then the answer is simply 1. Then we check X for 0 and, if so, then the answer is simply 0.

If neither of those scenarios is the case, then must check to see if X is positive and, if not, check to see if Y is negative and if it is even or odd.

If Y is negative, the we negate it to avoid the LOG routine giving a ?FC ERROR when we call it.

If X is negative and Y is odd, the NEG routine is pushed to the STACK as the exit rouine so that the result will be negative.

The actual math here is X^Y = EXP(Y*LOG(X)).

Single-precision only. (ACCumulator = EXP(REG1)).

To process this function we first save the original argument and multiply the ACCumulator by log2(e). The result of that is then used to determine if we will get overflow, since exp(x)=2^(x*log2(e)) where log2(e)=log(e) base 2.

We then save the integer part of this to scale the answer at the end, since 2^y=2^int(y)*2^(y-int(y)) and 2^int(y) is easy to compute.

So in the end we compute 2^(x*log2(e)-int(x*log2(e))) by p(ln(2)*(int(x*log2(e))+1)-x) where p is an approximation polynomial.

The result is then scaled by the power of 2 we previously saved.

A call to 1439H raises E (natural base) to the value in ACCumulator which must be a single precision value. The result will be returned in ACCumulator as a single precision number.

This is a general purpose summation routine which computes the series C0*X+C1*X^3+C2*X^5+C3*X^7+...+C(N)*X^(2*N+1) for I=0 to N when entered at 149AH If entered at 14A9H the series changes to SUM ((((x*c0+c1)x*c2)x+c3)x+.cN. On entry, the x is held in BC/DE and HL points to a list containing the number of terms followed by the coefficients.

The pointer to degree+1 is in (HL) and the constants should follow the egree, stored in reverse order. X is in the ACCumulator.

General polynomial evaluator routine. Pointer to degree+1 is in (HL), and that gets updated through the computation. The Constants follow the degree and should be stored in reverse order. The ACCumulator has the X. The formula is c0+c1*x+c2*x^2+c3*x^3+...+c(n-1)*x^(n-1)+c(n)*x^n

If the passed argument is 0, the last random number generated is returned. If the argument is < 0, a new sequence of random numbers is started using the argument.

To form the next random number in the sequence, we multiply the previous random number by a random constant, and add in another random constant. Then the HIGH ORDER and LOW ORDER bytes are switched, the exponent is put where it will be shifted in by normal, and the exponent in the ACCUMULATOR is set to 80H so the result will be less than 1. This is then normalized and saved for the next time.

The reason we switch the HIGH ORDER and LOW ORDER bytes is so we have a random chance of getting a number less than or greater than .5

Single-precision only.(ACCumulator = COS(ACCumulator)). A call to 1541H computes the cosine for an angle given in radians. The angle must be a floating point value in ACCumulator; the cosine will be returned in ACCumulator as a floating point value.

The formula being used is COS(X) = SIN(X+PI/2)

Single-precision only.(ACCumulator = SIN(ACCumulator)).

A call to 1549H returns the sine as a single precision value in ACCumulator. The sine must be given in radians in ACCumulator.

The actual calculation routine is:

1. Assume X <= 360 degrees.
2. Recompute x as x=x/360 so that x=< 1.
3. If x <= 90 degrees go to step 7.
4. If x <= 180 degrees then x=0.5-x and then go to step 7.
5. If x <= 270 degrees then x=0.5-x.
6. Recompute x as x=x-1.0.
7. Compute SIN using the power series.

Single-precision only.(ACCumulator = TAN(ACCumulator)).
A call to 15A8H computes the tangent of an angle in radians. The angle must be specified as a single precision value in ACCumulator. The tangent will be left in ACCumulator.
Uses the fact that TAN(x) = SIN(x) / COS(x)

Single-precision only.(ACCumulator = ATN(ACCumulator)).
A call to 15BD returns the angle in radians, for the floating point tangent value in ACCumulator. The angle will be left as a single precision value in ACCumulator.

The method of computation used in this routine is:

1. Test the sign of the tangent to see if a negative angle is in the 2nd or 4th quadrant. Set the flag to force the result to positive on exit. If the value is negative, invert the sign.
2. Test magnitude of tangent. If it is < 1 go to step 3. Otherwise, compute its reciprocal and put the return address on the STACK that will calculate pi/2 - series value.
3. Evaluate the series: (((x^2*c0+c1) x^2+c2) . c8)x
4. If the flag from step 1 is not set, then invert the sign of the series result.
5. If the original value is < 1 then return to the caller. Otherwise, compute pi/2-value from step 4 and then return.

This table stores entry locations (16-bit addresses) for function handlers (right-side expression routines).

Structure: 36 entries, each a 2-byte word (little-endian) pointing to the ROM routine for the function. Corresponds to tokens D7H–FAH (215–250 decimal, 36 functions).

Purpose: During expression evaluation, the token (minus D7H) is multiplied by 2 to index into this table. The fetched address is loaded into HL, and control jumps to it (e.g., via JP (HL) at 000CH).

This table contains all BASIC reserved words (keywords like END, FOR, SIN, etc.) in concatenated form. Each word is stored as ASCII characters, with the high bit (bit 7) set on the last character (i.e., ORed with 80H) to mark the end of the word. There are no null terminators or separators between words.

The order in the table determines the token value: the first word is token 80H (128 decimal), the second 81H, and so on up to the last (token FAH for MID$), for 466 bytes.

Purpose: During input scanning (e.g., via ROM routine at 1BC0H), the interpreter matches input strings against this table and replaces them with the corresponding 1-byte token for compact storage in the Program Statement Table (PST).

Tokens 80H–BBH are typically statements (e.g., END, FOR, IF). Tokens BCH–D6H are operators/misc (e.g., AND, OR). Tokens D7H–FAH are functions (e.g., SGN, INT, MID$).

This table stores entry locations for statement handlers (verb action routines).

Structure: 60 entries, each a 2-byte word (little-endian) pointing to the ROM routine that executes the statement. The entries correspond to tokens 80H–BBH (128–187 decimal, 60 statements).

Purpose: This table tells the interpreter where to jump to execute commands. The execution driver (at 1D5AH) fetches a token from the current line. If it's 80H–BBH, it subtracts 80H, multiplies by 2, indexes into this table, loads the address into HL, and jumps to the handler.

Tokens BC–F9H are invalid as line starters (except in specific contexts like IF...THEN) and are handled differently (e.g., within expressions).

Example:

• Program line contains tokenized BASIC "10 GOTO 100" stored as [31 30 $88]
• Interpreter reads token $88 (GOTO)
• Calculate table offset (Index = Token - $80 = $88 - $80 = 8; and then Offset = Index × 2 = 16 bytes)
• Look up handler address (Table base: 1822H; Entry location: 1822H + 16 = 1832H; Read bytes: [A9 1D] at 1832H-1833H )
• Form handler address (little-endian) ( Low byte: A9, High byte: 1D; Address: (1D << 8) | A9 = 1DA9H)
• Jump to handler at 1DA9H

The Operator Precedence Table is a 7-byte lookup table that tells the BASIC interpreter the order in which to evaluate operators in mathematical and logical expressions. Each byte contains a precedence value (higher numbers = higher precedence = evaluated first).

Structure: 7 entries (one byte each) for operators like ^ (7FH), * and / (7CH), + and - (79H), etc.

Purpose: Used during expression parsing to handle operator priority (e.g., multiplication before addition).

How it Works: When the interpreter encounters an expression like 3 + 4 * 5 ^ 2:

1. Tokenize: Break into tokens: 3, +, 4, *, 5, ^, 2
2. Look up precedence: For each operator token, read its precedence:
   • + (token $99) → precedence 79
   • * (token $9B) → precedence 7C
   • ^ (token ??) → precedence 7F
3. Build evaluation tree: Highest precedence first:
   • Step 1: 5 ^ 2 = 25 (^ has precedence 7F)
   • Step 2: 4 * 25 = 100 (* has precedence 7C)
   • Step 3: 3 + 100 = 103 (+ has precedence 79)

The Data Conversion Routine Table is a jump table containing 5 two-byte addresses (pointers) to routines that convert between different data types in TRS-80 BASIC. It's used whenever the interpreter needs to convert numbers to strings for display, parse strings into numbers, or promote integers to floats for arithmetic.

Structure: 5 entries, each a 2-byte word

Examples: To string at 0AF4H, to integer at 0A7FH

Three consecutive tables for arithmetic handlers (addition, subtraction, multiplication, division, comparison).

Structure: Each table has entries as 2-byte words pointing to operation-specific routines.

Purpose: Called when precedence requires breaking expressions (e.g., integer addition at 0BD2H).

The original ROM source code makes an interesting note about the order of these reserved words. Some reserved words are contained in other reserved words, which will cause a problem. They given examples of:

• IF J=F OR T=5 will process a FOR
• INP is part of INPUT
• IF T OR Q THEN will process a TO

This code is moved to 408E during non-disk initial setup.

This routine is called with DE as the address of the NEXT index. It scans the STACK backwards looking for a FOR push. If one is found, it gets the address of the index and compares with the DE that was in place when this routine was called. If it is equal, then it exits with A=0 and HL=Address of the variable. If it is not equal it will keep scanning until no FOR push is found and then exit with A<>0.

According to the original ROM source, this routine is part of the general storage management routines, and if designed to find a FOR entry on the STACK with the variable pointer passed in Register Pair DE.

This routine moves a variable into another area specified by the caller. On entry BC is set as the end address of the list to move (which is the upper limit); DE is set as the start address of the list to move; and HL is the end of the area to move it to.

According to the original ROM source, this routine is part of the general storage management routines, and if designed to make space by shoving everything forward and to check to make sure a reasonable amount of space remains between the top of the STACK and the highest location transferred to. On Entry, HL should be the destination of the high address, DE should be the low address to be transferred there, and BC should be the high address to be transferred there. On exit, HL=DE=Low BC=The location LOW was moved to.

This routine computes the amount of space between HL and the end of memory at FFC6. On entry, Register C should hold the number of desired bytes.

According to the original ROM source, this routine is part of the general storage management routines, and if designed to make sure that a certain number of locations remain available for the STACK. To use this routine, Register C needs to hold the number of two byte entries needed, and then do a CALL GETSTK. This routine must be called by any reoutine which puts an arbitrary amount of stuff into the STACK (such as a recursive routine like FRMEVL). It is also called by routines such as GOSUB and FOR which make permanent entries in the STACK.