Model I ROM Explained – Part 3

2003 – UE ERROR entry point – “GOERR”

2008-2038 – LEVEL II BASIC AUTO ROUTINE – “AUTO”

2039-2066 – LEVEL II BASIC IF ROUTINE – “IF”

2056H – LEVEL II BASIC ELSE ROUTINE – “FALSIF”

2067-206E – LEVEL II BASIC LPRINT ROUTINE – FOR v1.0 ONLY – “LPRINT”

206F-2177 – LEVEL II BASIC PRINT@ ROUTINE – FOR v1.0 ONLY – “PRINT”

20DDH – LEVEL II BASIC PRINT@ ROUTINE – Jumped here if we are sure we are using the display – “ISTTY”

20FE – This routine outputs a carriage return (0DH) to a device determined by flag stored at (409CH) – “CRDO”

2108 – This is the jump point for a continuation of the PRINT# code – “COMPRT” .

2137 – TAB logic – “TABER”

2153H – Displaying to Screen – “TTYIST”

2169 – This routine resets the device type flag at 409CH to zero (output to video display), also turns off cassette drive if necessary. CALLs Disk BASIC link at 41BEH prior to return – “FINPRT” .

2178-217E – MESSAGE STORAGE LOCATION FOR REDO MESSAGE
– “TRYAGN”

217F-2285 – LEVEL II BASIC INPUT AND READ ROUTINES – “TRMNOK”

219A – INPUT logic – “INPUT”

21EF – READ logic – “READ”

226A-226E – For ROM v1.0 – Test for FD Error
Removed in ROM v1.2 because this was not needed.

*226A-226E – For ROM v1.2 – Replaced with NOPS

2286-2295 – MESSAGE STORAGE LOCATION – “EXIGNT”

2296-22B5 – FIND THE NEXT DATA STATEMENT ROUTINE – “DATLOP”

22B6-2336 – LEVEL II BASIC NEXT ROUTINE – “NEXT”

22EAH – Part of the NEXT code, where we process the variable as an integer – “INTNXT”

2313H – Part of the NEXT code, jumped to continue after skipping over the integer processing – “FINNXT”

2313H – Part of the NEXT code, jumped if we haven’t hit the TO counter yet – “LOOPDN”

2335-27C8 – EVALUATE EXPRESSION – “FRMPRN” and “FRMEVL”

23D4-23D6 – Part of the Evaluation Routine – “EPSTK”

23D4-23D6 – Part of the Evaluation Routine – “ANDORD”

23D4-23D6 – Part of the Evaluation Routine – “FINREL”

2406 – Part of the Evaluation Routine – “APPLOP”

2438 – Part of the Evaluation Routine – “STKDBL”

2460H – Part of the Evaluation Routine – “FACDBL”

2472H – Part of the Evaluation Routine – “STKSNG”

247CH – Part of the Evaluation Routine – “FACSNG”

2490 – Integer divide – “INTDIV”

249F – Evaluate a Variable, Constant, or Function Call – “EVAL”

24E7-24FE VARPTR logic – “NTERL”

24E7-24E8 NTERL

CP 0C0H CP $VARPTR FE C0

Check to see if the character at the location of the current BASIC program pointer in Register A is a VARPTR token

24E9-24EA

JR NZ,24FFH JR NZ,NTVARP20 14

Jump back to 24FFH if the character at the location of the current BASIC program pointer in Register A isn’t a VARPTR token

24EB

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

24EC-24ED

RST 08H⇒ 28 SYNCHK “(“ CF 28

Since the character at the location of the current BASIC program pointer in HL must be a ( , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

24EE-24F0

CALL 260DH CALL PTRGETCD 0D 26

Call the FIND ADDRESS OF VARIABLE routine at 260DH which searches the Variable List Table for a variable name which matches the name in the string pointed to in HL, and return the address of that variable in DE (and if there is no variable, it creates it, zeroes it, and returns THAT location)

24F1-24F2 VARRET

RST 08H⇒ 29 SYNCHK “)” CF 29

Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine which compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call. If there is a match, control is returned to address of the RST 08 instruction + 2 with the next symbol in the A Register and HL incremented by one. If the two characters do not match, a syntax error message is given and control returns to the Input Phase)

24F3

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

24F4

EX DE,HL EB

Swap DE and HL so that HL now holds the value to return

24F5

LD A,H 7C

Load Register A with MSB of the variable’s address in Register H to make sure that it isn’t undefined.

24F6

OR L B5

Combine the LSB of the variable’s address in Register L with the MSB of the variable’s address in Register A. This type of pattern is used to check for something being zero

24F7-24F9

JP Z,1E4AH JP Z,FCERRCA 4A 1E

Display a ?FC ERROR if the variable’s address in HL is equal to zero, meaning that the variable is undefined

24FA-24FC

CALL 0A9AH CALL MAKINTCD 9A 0A

Save the variable’s address in HL as an integer into ACCumulator

24FD

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

24FE

RET C9

Return to the execution driver

24FF – Other Function Routine – Jumped here if it wasn’t VARPTR to see what else it might have been – “NTVARP”

24FF-2500 NTVARP

CP 0C1H CP USRTK FE C1

Check to see if the character at the location of the current BASIC program pointer in Register A is a USR token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2501-2503

JP Z,27FEH JP Z,USRFNCA FE 27

Jump to 27FEH if the character at the location of the current BASIC program pointer in Register A is a USR token

2504-2505

CP 0C5H CP INSRTK FE C5

Check to see if the character at the location of the current BASIC program pointer in Register A is a INSTR token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2501-2503

JP Z,419DH JP Z,INSTRCA FE 27

If the character at the location of the current BASIC program pointer in Register A is a INSTR token, jump to DOS to deal with it.

2509-250A

CP 0C8H CP $MEM FE C8

Check to see if the character at the location of the current BASIC program pointer in Register A is a MEM token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

250B-250D

JP Z,27C9H JP Z,MEMCA C9 27

If the character at the location of the current BASIC program pointer in Register A is a MEM token, jump to the RETURN AMOUNT OF FREE MEMORY routine at 27C9H which computes the amount of memory remaining between the end of the variable list and the end of the STACK and puts the result in ACCumulator as a SINGLE PRECISION number

250E-250F

CP 0C7H CP $TIME FE C7

Check to see if the character at the location of the current BASIC program pointer in Register A is a TIME$ token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

250B-250D

JP Z,417DH JP Z,TIMECA C9 27

If the character at the location of the current BASIC program pointer in Register A is a MEM token, jump to DOS to deal with it.

2513-2514

CP 0C6H CP $POINT FE C6

Check to see if the character at the location of the current BASIC program pointer in Register A is a POINT token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2515-2517

JP Z,0132H JP Z,POINTCA 32 01

Jump to 0132H if the character at the location of the current BASIC program pointer in Register A is a POINT token

2518-2519

CP 0C9H CP $INKEY FE C9

Check to see if the character at the location of the current BASIC program pointer in Register A is an INKEY$ token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

251A-251C

JP Z,019DH JP Z,INKEYCA 9D 01

Jump to 019DH if the character at the location of the current BASIC program pointer in Register A is an INKEY$ token

251D-251E

CP 0C4H CP $STRING FE C4

Check to see if the character at the location of the current BASIC program pointer in Register A is a STRING$ token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

241F-2421

JP Z,2A2FH JP Z,STRNG$7A

Jump to 2A2FH if the character at the location of the current BASIC program pointer in Register A is a STRING$ token

2522-2523

CP 0BEH CP FNTK FE BE

Check to see if the character at the location of the current BASIC program pointer in Register A is a FN token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

241F-2421

JP Z,4155H JP Z,FNDOER 7A

If the character at the location of the current BASIC program pointer in Register A is a FN token, jump to DOS to deal with it.

2527-2528

SUB 0D7H SUB ONEFUN D6 D7

Check to see if the character at the location of the current BASIC program pointer in Register A is a function name between the SGN and MID$ token

2529-252B

JP NC,254EH JP NC,ISFUND2 4E 25

Jump to 254EH if the character at the location of the current BASIC program pointer in Register A is a SGN to MID$ token. The original ROM source notes that there is no need to check for an upper bound because functions are the highest allowed characters

252CH – Other Function Routine – If we pass through to here, the only other possibility is that it is a function in parenthesis – “PARCHK”

252C-252E PARCHK

CALL 2335H CALL FRMPRNCD 35 23

GOSUB to 2335H to recursively evaluate the expression at the location of the current BASIC program pointer in HL

252F-2530

RST 08H⇒ 29 SYNCHK “)” CF 29

Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2531

RET C9

Return out of this routine

2532 – Binary Minus Routine – “DOMIN”

2532 DOMIN

LD D,7DH 16 7D

Load Register D with a precedence value below “^” but above everything else since its a uniary minus.

2534-2536

CALL 233AH CALL LPOPERCD 3A 23

GOSUB to 233AH to evaluate the variable at the location of the current BASIC program pointer in HL

2537-2539

LD HL,(40F3H) LD HL,(TEMP2) 2A F3 40

Load HL with the value of the current BASIC program pointer.
Note: 40F3H-40F4H is a temporary storage location

253A

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK so we know where to continue

253B-253D

CALL 097BH CALL VNEGCD 7B 09

Invert the sign of the current value in ACCumulator

253E LABBCK

POP HL E1

According to the original ROM source, this is where functions that don’t return string values return. Restore the code string address from the STACK and put it in HL. We need this because we return here after executing functions SNG( to MID$(

253F

RET C9

Return to the expression evaluation

2540 – Math Routine – “ISVAR”

According to the original ROM source code, this routine loads a variable to the ACC and sets the NTF. The HL must point to the ASCII variable name. After execution the HL will point to the character following the last character of the variable used. The value of the variable will be loaded in the ACC. For strings however (NTF=3), the ACC will contain the address of the first three bytes which contain the string length and string address (see Level II BASIC manual). Also note that if the variable cannot be found it will be created and given a value of zero.

2540-2542 ISVAR

CALL 260DH CALL PTRGETCD 0D 26

Get the pointer to the variable held in Register Pair DE by calling the FIND ADDRESS OF VARIABLE routine at 260DH which searches the Variable List Table for a variable name which matches the name in the string pointed to in HL, and return the address of that variable in DE (and if there is no variable, it creates it, zeroes it, and returns THAT location)

2543 RETVAR

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2544

EX DE,HL EB

Swap DE and HL so that the pointer to the variable value is now held in Register Pair HL. This is the pointer to a descriptor, not the actual variable.

2545-2547

LD (4121H),HL LD (FACLO),HL 22 21 41

In case it is a string, we will store the pointer to the descriptor in FACLO.

2548

RST 20H GETYPEE7

We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in ACCumulator and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH). The results are returned as follows:

• Integer = NZ/C/M/E and A is -1
• String = Z/C/P/E and A is 0
• Single Precision = NZ/C/P/O and A is 1
• and Double Precision is NZ/NC/P/E and A is 5.

2549-254B

CALL NZ,09F7H CALL NZ,VMOVFMC4 F7 09

If we had a string, then we are just going to leave a pointer in the ACCumulator. If not, the we need to actually transfer the value into th ACCumulator using the pointer in Register Pair HL. With this, if that test shows we do NOT have a STRING, call 09F7H to move data

254C

POP HL E1

Restore the value of the current BASIC program pointer to Register Pair HL

254D

RET C9

Return to the caller

254E – This routine processes an expression for SNG( to MID$( – “ISFUN”

254E-254F ISFUN

LD B,00H 06 00

Load Register B with zero

2550

RLCA 07

Set A to be 2 * (token – D7H)

2551

LD C,A 4F

Save the new token

2552

PUSH BC C5

Save 0/2*(token-D7) on STACK

2553

RST 10H CHRGETD7

Get the next character from the tokenized string by calling RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2554

LD A,C 79

Prepare to look for the function number

2555 NUMGFN

CP 41H CP NUMGFN FE 41

Test the adjusted token to see if it is past 2 * LASNUM – 2 * ONEFUN + 1. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2557

JR C,256FH JR C,OKNORM38 16

If the CARRY FLAG is set, then the function is past that last number, so JUMP to 256FH if the token is SGN( to CHR$( . If not, it is a LEFT$ – MID$

2559

CALL 2335H CALL FRMPRNCD 35 23

Otherwise, it must be a normal function so GOSUB to 2335H to capture the “(” and the first argument. This routine will evaluate the expression part of the calling sequence (which requires 2 or parameters)

The original source code has this to say about being here:

Most functions take a single argument. The return address of these functions is a small routine that checks to make sure valtyp is 0 (numeric) and pops off the text pointer. so normal functions that return string results (i.e. chr$) must pop off the return address of labbck, and pop off the text pointer and then return to FRMEVL.

The so called “funny” functions can take more than one argument, the first of which must be string and the second of which must be a number between 0 and 256. The text pointer is passed to these functions so additional arguments can be read. The text pointer is passed in Register Pair DE. The close parenthesis must be checked and return is directly to FRMEVL with Register Pair HL setup as the text pointer pointing beyond the “)”.

The pointer to the descriptor of the string argument is stored on the STACK underneath the value of the integer argument (2 bytes).

The first argument is ALWAY a string. The second is always an integer.

255C

RST 08H⇒ 2C SYNCHK “,” CF 2C

We need TWO arguments, so there needs to be a “,”. With this we use RST 08H to test for a ,

255E

CALL 0AF4H CALL CHKSTRCD F4 0A

GOSUB to 0AF4H to ensure the current variable is a string, otherwise it is an error

2561

EX DE,HL EB

Swap DE and HL so that DE will now point to the position in the current BASIC program being evaluated and HL is the address of the current variable (which MUST be a string)

2562

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the string descriptor address held at the memory location pointed to by ACCumulator

2565

EX (SP),HL E3

Put the pointer to the string descriptor onto the STACK and put the function number into Register Pair HL

2566

PUSH HL E5

Save function number (i.e., 00 / 2*(token-D7H)) to the STACK

2567

EX DE,HL EB

Swap DE and HL so that HL will now point to the position in the current BASIC program being evaluated.

2568

CALL 2B1CH CALL GETBYTCD 1C 2B

Evaluate n portion of the string function. Register E will contain the value of the formula.

256B

EX DE,HL EB

Swap DE and HL so that HL will now hold the integer value of the second argument and DE will point to the position in the current BASIC program being evaluated.

256C

EX (SP),HL E3

Swap (SP) and HL so that HL will now hold the function number, and the integer value of the second argument will be at the top of the STACK

256D

JR 2583H JR FINGO18 14

Jump down to 2583H to process the token

256F-2571 OKNORM

CALL 252CH CALL PARCHKCD 2C 25

Next we need to check out the argument (and make sure it is followed by a “)”) via a single variable parameter call. First, GOSUB to 252CH to evaluate the expression at the location of the current BASIC program pointer in HL

2572

EX (SP),HL E3

Swap (SP) and HL so that HL will now hold the function number [0 + 2 * (token – D7H)], and the pointer to the position in the current BASIC program being evaluated will be at the top of the STACK.

The original source code has this to say about being here:

We next have to check to see if a special coercion must be done for one of the transcendental functions ( RND , SQR , COS , SIN , TAN , ATN , LOG , and EXP ).

Since these functions do not look at VALTYP, but rather assume the argument passed in the ACCumulator is single precision, we MUST call FRCSNG before dispatching to them.

2573

LD A,L 7D

Load Register A with the function number [i.e., 2 * (token – D7H)]

2574-2575 BOTCON

CP 0CH CP (SQRTK-ONEFUN)*2 FE 0C

Check to see if the operator token in Register A is one less than SQR . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2576-2577

JR C,257FH JR C,NOTFRF38 07

Jump down to 257FH to avoid forcing the argument if the operator token in Register A is SGN to SQR

2578-2579 TOPCON

CP 1BH CP (ATNTK-ONEFUN)*2+1 FE 1B

Check to see if the operator token in Register A is bigger than ATN() . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

257A

PUSH HL E5

Save the function number (i.e., 0 + 2*(token – D7H)) to the stop of the STACK

257B-257D

CALL C,0AB1H CALL C,FRCSNGDC B1 0A

If we are still here, then we need to force the ACCumulator into Single Precision, so CALL the CONVERT TO SINGLE PRECISION routine at 0AB1H (which converts the contents of ACCumulator [4121H] from integer or double precision into single precision)

257F-2581 NOTFRF

LD DE,253EH LD DE,LABBCK 11 3E 25

Load DE with a return address of 253EH for once the function is executed

2582

PUSH DE D5

Save the value of the return address in DE to the STACK so it will act as the return adddress

2583-2585 FINGO

LD BC,1608H LD BC,FUNDSP 01 08 16

Load BC with the function dispatch/jump table address

2586 DISPAT

ADD HL,BC 09

Add the jump table pointer in BC (i.e., the offset) with the value of the operator token in HL

2587

LD C,(HL) 4E

Load Register C with the LSB of the jump address at the location of the jump table pointer in HL

2588

INC HL 23

Bump the value of the jump table pointer in HL

2589

LD H,(HL) 66

Load Register H with the MSB of the jump address at the location of the jump table pointer in HL

258A

LD L,C 69

Load Register L with the LSB of the jump address in Register C

258B

JP (HL) E9

Perform the function.

258C – Part of the Formula Evaluation Code – “STRCMP”

According to the original ROM source, this routine will compare two strings, one with the description in Register Pair DE and the other in FACLO/FACLO+1. On exit:

• A = 0 if the strings are equal
• A = 377 if BCDE > FACLO
• A = 1 if BCDE < FACLO

This routine will do a relational comparison of two strings.
It will load A with the length of the first string and BC with the string’s address. Then it will load D with the length of the second string and HL with the string’s address.

258C-258E STRCMP

CALL 29D7H CALL FRESTRCD D7 29

First we need to free up the FAC string and get the pointer to the FAC descriptor into Register Pair HL. We do this via a GOSUB to 29D7H to check to see if there is enough memory for the string

258F

LD A,(HL) 7E

Load Register A with the LSB of the length of the string in the FACLO

2590

INC HL 23

Bump the value of the string’s VARPTR in HL so that HL points to the LSB of the string address

2591

LD C,(HL) 4E

Load Register C with the LSB of the string in the FACLO

2592

INC HL 23

Bump the value of the string’s VARPTR in HL so that HL points to the MSB of the string address

2593

LD B,(HL) 46

Load Register B with the MSB of the string in the FACLO. Register Pair BC now points to the FACLO string.

2594

POP DE D1

Put the STACK string pointer into Register Pair DE

2595

PUSH BC C5

Save the pointer to the FACLO string data

2596

PUSH AF F5

Save the FACLO string’s length in Register A to the STACK

2597-2599

CALL 29DEH CALL FRETMPCD DE 29

Free up the STACK string and RETURN with the pointer to the STACK string descriptor in Register Pair HL.

259A

POP DE D1

Get the length of the FACLO string from the STACK and put it in Register D

259B

LD E,(HL) 5E

Load Register E with the STACK / BCDE string’s length

259C

INC HL 23

Bump the pointer to the STACK / BCDE string’s entry in HL

259D

LD C,(HL) 4E

Load Register C with the LSB of the STACK / BCDE string’s address

259E

INC HL 23

Bump the pointer to the STACK / BCDE string’s entry in HL

259F

LD B,(HL) 46

Load Register B with the MSB of the STACK / BCDE string’s address

25A0

POP HL E1

Get the second character pointer from the STACK and put it in HL

25A1 CSLOOP

LD A,E 7B

Load Register A with the length of the STACK / BCDE string in Register E

25A2

OR D B2

Combine the FACLO string’s length in Register D with the STACK / BCDE string’s length in Register A

25A3

RET Z C8

If both string lengths are the same, then we are done, so return out of the routine since there aren’t any characters left in either string to be compared

25A4

LD A,D 7A

Load Register A with the FACLO string’s length in Register D

25A5-25A6

SUB 01H D6 01

Check to see if the FACLO string’s length in Register A is equal to zero, by setting the CARRY FLAG and turning Register A into 255 if Register D was 0.

25A7

RET C D8

If the CARRY FLAG is set, then the FACLO string has run out of characters, so RETurn

25A8

XOR A AF

If we are here, then FACLO wasn’t out of characters, so we next need to see if the STACK / BCDE string ended first. First we load Register A with zero

25A9

CP E BB

Check to see if the STACK / BCDE string’s length in Register E is equal to zero. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

25AA

INC A 3C

Bump the value in Register A for a return code of A = 1

25AB

RET NC D0

Return if there aren’t any more characters in the STACK / BCDE string to be compared

25AC

DEC D 15

If we are STILL here, then neither string has ended. First, decrement the value of the FACLO string’s length in Register D

25AD

DEC E 1D

Decrement the value of the STACK / BCDE string’s length in Register E

25AE

LD A,(BC) 0A

Load Register A with the character at the location of the STACK / BCDE string pointer in BC

25AF

CP (HL) BE

Compare the character at the location of the STACK / BCDE string pointer in Register A with the character at the location of the FACLO string pointer in HL. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

25B0

INC HL 23

Bump the value of the first string pointer in HL

25B1

INC BC 03

Bump the value of the second string pointer in BC

25B2-25B3

JR Z,25A1H JR Z,CSLOOP28 ED

Loop back to 25A1H to keep going if the characters match

25B4

CCF 3F

If we are here, then the NZ FLAG was set and the strings are NOT equal. Since they are not equal, reverse the CARRY flag

25B5-25B7

JP 0960H JP SIGNSC3 60 09

Jump back to 0960H to set up Register A based on the CARRY FLAG.

25B8 DOCMP

INC A 3C

Bump the value of the current precedence value in Register A

25B9

ADC A,A 8F

Adjust the value of the current precedence value in Register A. Depending on which routine called this this will give either (A) a 1 with a NC if 0 or a 0 with C if FF or (B) 4=Less, 2=Equal, 1=Greater

25BA

POP BC C1

Get the last operator value from the STACK and put it in BC

25BB

AND B A0

Combine the precedence value in Register B with the precedence value in Register A to see if any of the bits match.

25BC-25BD

ADD A,FFH C6 FF

Adjust the value in Register A. This will give a 0 if both are equal and a CARRY if they are unequal

25BE

SBC A,A 9F

Check to see if the precedence values in registers A and B match. This will set A=0 if equal, and, depending on the routine which called this, either an A+1 or a A=377 if unequal

25BF-25C1

CALL 098DH CALL CONIACD 8D 09

Convert Register A to a signed integer via a CALL to 098DH. This will set the current value to 00 if A is positive, and to FF if A is negative.
If the values match, set the current result in zero. If they do not match, set the current result to -1

25C2-25C3

JR 25D6H JR RETAPG18 12

At this point we want to return from the operator application place so the text pointer will get set up to what it was when LPOPER returned. To do this we jump forward to 25D6H to continue with the expression evaluation

25C4 – NOT Routine – “NOTER”

25C4-25C5 NOTER

LD D,5AH 16 5A

NOT has a precedence value of 90, so we need a dummy entry of 90 on the STACK

25C6-25C8

CALL 233AH CALL LPOPERCD 3A 23

Go evaluate the expression with a dummy entry of 90 on the STACK

25C9-25CB

CALL 0A7FH CALL FRCINTCD 7F 0A

We need the argument to be an integer so CALL the CONVERT TO INTEGER routine at 0A7FH (where the contents of ACCumulator are converted from single or double precision to integer and deposited into HL)

25CC

LD A,L 7D

The next bunch of instructions are to complement Register Pair HL. First, load Register A with the LSB of the integer value

25CD

CPL 2F

Compliment the LSB of the integer value in Register A

25CE

LD L,A 6F

Load Register L with the adjusted LSB of the integer value in Register A

25CF

LD A,H 7C

Load Register A with the MSB of the integer value in Register H

25D0

CPL 2F

Compliment the MSB of the integer value in Register A

25D1

LD H,A 67

Load Register H with the adjusted MSB of the integer value in Register A

25D2-25D4

LD (4121H),HL LD (FACLO),HL 22 21 41

Save the complimented integer value in HL as the current result in ACCumulator

25D5

POP BC C1

Clean up the STACK

25D6-25D8 RETAPG

JP 2346H JP RETAOPC3 46 23

Jump back to 2346H to continue with the expression evaluation. We need to do this because FRMEVL, after seeing a precedence level of 90, thinks it is applying an operator, which it isn’t. It has the text pointer stored in TEXT 2 so we need to JUMP to RETAOP to re-fetch that pointer.

25D9 – The RST 20H code – “GETYPR”

This is the TEST DATA MODE, which determines the type of the current value in ACCumulator and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).TYPE   CODE   ZERO   CARRY   NEG   PARITY   A-Register
INT     02     NZ      C      N      E         -1
STR     03      Z      C      P      E          0
SNG     04     NZ      C      P      O          1
DBL     08     NZ     NC      P      E          5

25D9-25DBH GETPYR

LD A,(40AFH) LD A,(VALTYP) 3A AF 40

Load Register A with the current value of the number type flag.
Note: 40AFH holds Current number type flag

25DC-25DD

CP 08H FE 08

Check to see if the current value in ACCumulator is double precision (02=INT, 03=STR, 04=SNG, 08=DBL). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

25DE-25DF CGETYP

JR NC,25E5H JR NC,NCASE30 05

If that test shows that we have a DOUBLE PRECISION number, jump forward to 25E5H

25E0-25E1

SUB 03H D6 03

If the number is not double precision, subtract 3

25E2

OR A B7

Set the status flags of the adjusted number type flag in Register A

25E3

SCF 37

Set the Carry flag

25E4

RET C9

RETurn to CALLer

25E5-25E6 NCASE

SUB 03H D6 03

We are dealing with a double precision number so adjust the value of the current number type flag in Register A

25E7

OR A B7

Test the value of the current number type flag in Register A, which will exit without the CARRY flag set

25E8

RET C9

RETurn to CALLer

25E9 – AND and OR Routines – “DANDOR”

According to the original ROM source, this routine applies the AND and OR operators and should be used to implement all logical operators

Whenever an operator is applied, its precedence is in Register B

This fact is used to distinguish between AND and OR

The right hand argument is coerced to integer, just as the left hand one was when it was pushed on the STACK

25E9 DANDOR

PUSH BC C5

B has he precedence value, so save BC to the STACK. The precedence value for OR is 70.

25EA-25EC

CALL 0A7FH CALL FRCINTCD 7F 0A

We need the right hand argument to be an integer, so GOSUB the CONVERT TO INTEGER routine at 0A7FH (where the contents of ACCumulator are converted from single or double precision to integer and deposited into HL)

25ED

POP AF F1

Get the precedence value from the STACK and put it in Register A so that we can detemined between span class=”code”>AND and OR

25EE

POP DE D1

Get the left hand argument from the STACK and put it in DE

25EF-25F1

LD BC,27FAH LD BC,GIVINT 01 FA 27

Load BC with a return address of 27FAH

25F2

PUSH BC C5

Save the value of the return address in BC to the STACK

25F3-25F4

CP 46H FE 46

Check to see if the operator value in Register A is an OR token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

25F5-25F6

JR NZ,25FDH JR NZ,NOTOR20 06

If Register A was not 46H then we have an AND , so jump forward a few instructions to 25FDH (to the AND code) if the operator value in Register A isn’t an OR token

25F7 – OR logic.

25F7

LD A,E 7B

Load Register A with the LSB of the first value in Register E

25F8

OR L B5

Combine the LSB of the first value in Register A with the LSB of the second value in Register L

25F9

LD L,A 6F

Load Register L with the ORed value in Register A

25FA

LD A,H 7C

Load Register A with the MSB of the second value in Register H

25FB

OR D B2

Combine the MSB of the first value in Register D with the MSB of the second value in Register A

25FC

RET C9

Return to 27FAH (=convert the result to integer and return that integer calue to 2346H)

25FD – AND logic – “NOTOR”

25FD NOTOR

LD A,E 7B

Load Register A with the LSB of the first value in Register E

25FE

AND L A5

Combine the LSB of the first value in Register A with the LSB of the second value in Register L

25FF

LD L,A 6F

Load Register L with the ANDed value in Register A

2600

LD A,H 7C

Load Register A with the MSB of the second value in Register H

2601

AND D A2

Combine the MSB of the first value in Register D with the MSB of the second value in Register A

2602

RET C9

Return to 27FAH (=Make the result an integer and return to 2346H)

2603 – Dimension and Variable Searching Routine – “DIMCON”

2603 DIMCON

DEC HL 2B

Decrement the value of the BASIC program pointer in HL so that we can see what the prior character was

2604

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2605

RET Z C8

If the CHGRGET routine returned a Z FLAG, then we have a terminator; so RETurn since this is the end of the BASIC statement

2606-2607

RST 08H⇒ 2C SYNCHK “,” CF 2C

Since the character at the location of the current BASIC program pointer in HL must be a , , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2608 – DIM logic – “DIM”

The original ROM source code states that this DIM code sets DIMFLG and then falls into the variable search routine, which then looks at DIMFLG at three different points:

1. If an entry is found, dimflg being on indicates a “doubly dimensioned” variable
2. When a new entry is being built dimflg’s being on indicates the indices should be used for the size of each indice. otherwise the default of ten is used.
3. When the build entry code finishes, only if dimflg is off will indexing be done

2608-260A DIM

LD BC,2603H D BC,DIMCON 01 03 26

Load BC with a return address of 2603H

260B

PUSH BC C5

Save the return address of 2603H (in BC) to the STACK

260C-260D

OR AFH F6 AF

This is part of a Z-80 trick. If passed through, then this will just OR A to force A to be non-zero. It will then skip the next instruction

260D – Variable location and creation logic – “PTRGET” .

The original ROM source code states that this routine will read the variable name at the current text position and put a pointer to its value in Register Pair DE. Register Pair HL is then updated to point to the character after the variable name and VALTYP is set up. Evaluating subscripts in a variable name can cause recursive calls to PTRGET so at that point all values must be stored on the STACK. On RETurn, [a] does not reflect the value of the terminating character.

This routine will return the address of a variable in memory or create it if it is not found. In order to use this routine, the HL must point to the variable name (ASCII). Then, after execution, HL will point to the character following the variable name and the location of the variable will be returned in the DE Register Pair. For integer, single or doubleprecision (NTF=2, 4 or 8) the address returned in DE will be the same as for the VARPTR command under BASIC. (see Level II BASIC manual on VARPTR) For strings (NTF=3) however the address returned in DE will point to the first of three bytes containing the string length and string address.
This entry point searches the Variable List Table (VLT) for a variable name which matches the name in the string pointed to by HL. If the variable exists, its address is returned in DE. If it is not defined, then it is created with an initial value ofzero and its address is returned in DE. Dimensioned and non-dimensioned variables may be located, and suffixs for data mode may be included in the name string. A byte of machine zeros must terminate the name string. All registers are used.

260D PTRGET

XOR A AF

If JUMPed here, then A is set to ZERO. As a reminder, if passed through from the above routine, A will be NOT ZERO.

260E-2610

LD (40AEH),A LD (DIMFLG),A 32 AE 40

Save the value in Register A as the current variable location/creation flag.
Note: 40AEH holds LOCATE/CREATE variable flag

2611

LD B,(HL) 46

Load Register B with the first character of the variable name

2612-2614 PTRGT2

CALL 1E3DH CALL ISLETCD 3D 1E

GOSUB to 1E3DH to make sure the first character of the variable name is a letter

2615-2617

JP C,1997H JP C,SNERRDA 97 19

Display a ?SN ERROR if the first character of the variable name isn’t a letter

2618

XOR A AF

Zero Register A

2619

LD C,A 4F

Set up to assume that there is no second character by zeroing Register C

261A

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

261B-261C

JR C,2622H JR C,ISSEC38 05

Jump to 2622H if the character at the location of the current BASIC program pointer in Register A is numeric

261D-261F

CALL 1E3DH CALL ISLETCD 3D 1E

GOSUB to 1E3DH to check to see if the character at the location of the current BASIC program pointer is a letter. This will set the CARRY FLAG.

2620-2621

JR C,262BH JR C,NOSEC38 09

Jump to 262BH if the character at the location of the current BASIC program pointer in Register A isn’t a letter

2622 ISSEC

LD C,A 4F

If we are here, then the second character was a number, so save it in Register C

2623 EATEM

RST 10H CHRGETD7

We now need bump the value of the current BASIC program pointer until it points to the next character, call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2624-2625

JR C,2623H JR C,EATEM38 FD

Loop back one OPCODE to keep eating characters until a non-numeric character is found

2626-2628

CALL 1E3DH CALL ISLETCD 3D 1E

Go check to see if the character at the location of the current BASIC program pointer in HL is alphabetic

2629-262A

JR NC,2623H JR NC,EATEM30 F8

Jump back to 2623H if the character at the location of the current BASIC program pointer in HL is alphabetic

262B-262D NOSEC

LD DE,2652H LD DE,HAVTYP 11 52 26

Load DE with a return address of 2652H. Done to save time/RAM from using JUMPs instead.

262E

PUSH DE D5

Save the value of the return address in DE to the STACK

262F-2630

LD D,02H 16 02

Load Register D with an integer number type flag

2631-2632

CP 25H FE 25

Check to see if the character at the location of the current BASIC program pointer in Register A is a % . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2633

RET Z C8

Return if the character at the location of the current BASIC program pointer in Register A is a %

2634

INC D 14

Bump Register D so that it will be equal to a string number type flag (02=INT, 03=STR, 04=SNG, 08=DBL)

2635-2636

CP 24H FE 24

Check to see if the character at the location of the current BASIC program pointer in Register A is a $ . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2637

RET Z C8

Return if the character at the location of current BASIC program pointer in Register A is a $

2638

INC D 14

Bump Register D so that it will be equal to a single precision number type flag (02=INT, 03=STR, 04=SNG, 08=DBL)

2639-263A

CP 21H FE 21

Check to see if the character at the location of the current BASIC program pointer in Register A is a ! . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

263B

RET Z C8

Return if the character at the location of the current BASIC program pointer in Register A is a !

263C-263D

LD D,08H 16 08

Load Register D with a double precision number type flag. We have to do this because 04H (SNG) would bump to 05H if we just did another INC, but we need 08H for DBL

263E-263F

CP 23H FE 23

Check to see if the character at the location of the current BASIC program pointer in Register A is a # . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2640

RET Z C8

Return if the character at the location of the current BASIC program pointer in Register A is a #

2641

LD A,B 78

Load Register A with the first character of the variable name from Register B

2642-2643

SUB 41H D6 41

Adjust the value of the first character of the variable name in Register A so that it is in the range of 0 to 25 for a table offset

2644-2645

AND 7FH E6 7F

Get rid of the user-defined function bit in Register B by ANDing it against 0111 1111

2646

LD E,A 5F

Next we need to build a two byte offset so first load Register E with the adjusted first character of the variable name in Register A

2647-2648

LD D,00H 16 00

Load Register D with zero

2649

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

264A-264C

LD HL,4101H LD HL,DEFTBL 21 01 41

Load HL with the starting address of the variable declaration table.
NOTE: 4101H-411AH holds Variable Declaration Table

264D

ADD HL,DE 19

Add the offset to the top of the table

264E

LD D,(HL) 56

Load Register D with the number type value from the variable declaration table pointer in HL

264F

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2650

DEC HL 2B

Decrement the value of the current BASIC program pointer in HL as there was no marking character

2651

RET C9

Return with data type in D

2652 HAVTYP

LD A,D 7A

Load Register A with the value of the number type flag in Register D

2653-2655

LD (40AFH),A LD (VALTYP),A 32 AF 40

Save the number type flag for the current variable name from Register A.
NOTE: 40AFH holds Current number type flag

2656

RST 10H CHRGETD7

We want to skip the “type marker” so we need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2657-2659

LD A,(40DCH) LD A,(SUBFLG) 3A DC 40

Load Register A with the FOR flag. Why the FOR flag? It doubles as a “should we allow arrays here” flag!

265A

OR A B7

Test the value of the FOR flag in Register A

265B-265D

JP NZ,2664H JP NZ,NOARYSC2 64 26

Jump to 2664H if a arrays are not permitted

265E

LD A,(HL) 7E

Re-fetch the next element of the code string by loading Register A with the character at the location of the current BASIC program pointer in HL

265F-2660

SUB 28H D6 28

Next, test for an array by checking to see if the character at the location of the current BASIC program pointer in Register A is a (

2661-2663

JP Z,26E9H JP Z,ISARYCA E9 26

If the Z FLAG is set then we have an array (meaning, it is a subscripted variable), so JUMP to 26E9H

2664 NOARYS

XOR A AF

Zero Register A so that we can allow for parenthesis now

2665-2667

LD (40DCH),A LD (SUBFLG),A 32 DC 40

Set the “permit arrays” array flag to ‘no subscript’.
Note: 40DCH holds FOR flag

2668

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2669

PUSH DE D5

Save the number type flag for the variable in DE to the STACK

266A-266C

LD HL,(40F9H) LD HL,(VARTAB) 2A F9 40

Load HL with the value of the simple variables pointer, which will be t he place to start the search.

• Note: 40F9H-40FAH holds the starting address of the simple variable storage area.

266D LOPFND

EX DE,HL EB

Swap DE and HL so that DE will not point to the place to start the search. We don’t care what happens to HL

266E-2670

LD HL,(40FBH) LD HL,(ARYTAB) 2A FB 40

Load HL with the pointer to the end of simple variables. 40FBH-40FCH holds the starting address of the BASIC array variable storage area

2671

RST 18H COMPARDF

Now we need to see if we have reached the end of the table so we compare the value of the simple variables pointer in DE with the array variables pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2672

POP HL E1

Get the number type flag for the variable from STACK and put it in HL

2673-2674

JR Z,268EH JR Z,NOTFNS28 19

If the Z FLAG is set (because the simple variables pointer in DE is greater than or equal to the array variables pointer) then the variable was not found, and so we need to create a new variable. To do this we JUMP to 268EH

2675

LD A,(DE) 1A

Load Register A with the number type flag for the variable at the location of the simple variables pointer in DE

2676

LD L,A 6F

Preserve Register A into Register L so we know how many entries to skip.

2677

CP H BC

Compare the number type flag for the variable in Register H to the number type flag in Register A. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2678

INC DE 13

Bump the value of the current simple variables pointer in DE to the 2nd character name for this entry

2679-267A

JR NZ,2686H JR NZ,NOTIT120 0B

If the NZ FLAG is set then we did not have the right type of variable and need to skip it VIA a JUMP to 2686H

267B

LD A,(DE) 1A

Since the type matches, compare the 1st characters by loading Register A with the first character of variable name at the location of the simple variables pointer in DE

267C

CP C B9

Compare the character at the location of the simple variables pointer in Register A with the first character of the variable name in Register C. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

267D-2637

JR NZ,2686H JR NZ,NOTIT120 07

Jump to 2686H if the first characters of the variable names don’t match

267F

INC DE 13

Bump the value of the current simple variables pointer in DE

2680

LD A,(DE) 1A

Load Register A with the second character of the variable name at the location of the simple variables pointer in DE

2681

CP B B8

Compare the character at the location of the simple variables pointer in Register A with the first character of the variable name in Register B. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2682-2684

JP Z,26CCH JP Z,FINPTRCA CC 26

Jump to 26CCH if the character at the location of the simple variables pointer in Register A matches the first character of the variable name in Register B

2685-2686

LD A,13H 3E 13

Z-80 Trick to skip the next INC DE if continuing through

2686 NOTIT1

INC DE 13

Bump to the next entry in the simple variable list part 1

2687

INC DE 13

Bump the value of the simple variables pointer in DE part 2

2688

PUSH HL E5

Save the number type flag for the variable in HL to the STACK so that it can be re-loaded at 2672H

2689-268A

LD H,00H 26 00

Load Register H with zero so that Register Pair HL is the number of bytes to skip, but in 16 bits.

268B

ADD HL,DE 19

Add the value of the simple variables pointer in DE to the value of the number type flag in HL

268C-268D

JR 266DH JR LOPFND18 DF

Loop back to 266DH to keep searching

268E NOTFNS

LD A,H 7C

Load Register A with the length for the variable in Register H

268F

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2690

EX (SP),HL E3

Exchange (SP) and HL so that Register Pair HL now holds the return address and the value of the current BASIC program pointer is now at the top of the STACK

2691

PUSH AF F5

Save length of the variable in Register A to the STACK

2692

PUSH DE D5

Save the current variable table position from DE to the STACK

2693-2695

LD DE,24F1H LD DE,VARRET 11 F1 24

Load DE with a VARPTR locator return address of 24F1H

2696

RST 18H COMPARDF

Now we need to check to see if this was a VARPTR or not, so we compare the return address in DE with the return address in HL by calling the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2697-2698

JR Z,26CFH JR Z,VARNOT28 36

If the Z FLAG is set, then this was a VARPTR call, so JUMP forward to 26CFH.

2699-269B

LD DE,2543H LD DE,RETVAR 11 43 25

Next we need to see if EVAL called this routine. Load DE with a return address of the find address of variables routine at 2543H

269C

RST 18H COMPARDF

We need to see if we were called from the ‘find address of variable’ routine so we need to compare the return address in DE with the return address in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

269D

POP DE D1

Restore the current variable table position from the STACK and put it in DE

269E-269F

JR Z,26D5H JR Z,FINZER28 35

If this routine is called to locate the variables address, we JUMP to 26D5H as we do not need to create a new variable, and instead we zero out the FAC and skip the RETurn.

26A0

POP AF F1

Clear the STACK and put the value of the number type flag for the variable from the STACK and put it in Register A

26A1

EX (SP),HL E3

Swap (SP) and HL so that the value of the current BASIC program pointer is now in Register Pair HL

26A2

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

26A3

PUSH BC C5

Save the variable’s address in BC to the STACK as we are about to use both Register B and Register C

26A4

LD C,A 4F

Load Register C with the value of the number type flag for the variable in Register A

26A5-26A6

LD B,00H 06 00

Load Register B with zero so that the number type flag for the variable can be represented in 16 bits

26A7

PUSH BC C5

Save the variable’s number type flag in BC to the STACK

26A8

INC BC 03

Bump the value of the variable’s number type flag in BC

26A9

INC BC 03

Bump the value of the variable’s number type flag in BC

26AA

INC BC 03

Bump the value of the variable’s number type flag in BC. Now the variable’s length includes room for the addresses as well.

26AB-26AD

LD HL,(40FDH) LD HL,(STREND) 2A FD 40

Load HL with the value of the free memory pointer.
Note: 40FDH-40FEH holds Free memory pointer

26AE

PUSH HL E5

Save the value of the free memory pointer in HL to the STACK

26AF

ADD HL,BC 09

Add the value of the variable’s number type flag in BC to the value of the free memory pointer in HL

26B0

POP BC C1

Restore the high address from the STACK and put it in BC

26B1

PUSH HL E5

Save the value of the high address pointer in HL to the STACK

26B2-26B4

CALL 1955H CALL BLTUCD 55 19

Block transfer the variable information and make sure we do not overflow the STACK space via a GOSUB to BLTU.

26B5

POP HL E1

Get the value of the new free memory pointer (i.e., STREND) from the STACK and put it in HL

26B6-26B8

LD (40FDH),HL LD (STREND),HL 22 FD 40

Save the value of the new free memory pointer in HL to lock in that variable space.
NOTE: 40FDH-40FEH holds Free memory pointer

26B9

LD H,B 60

Load Register H with the MSB of the new array variables pointer in Register B

26BA

LD L,C 69

Load Register L with the LSB of the new array variables pointer in Register C. HL will now point to the end of the new variable.

26BB-26BD

LD (40FBH),HL LD (ARYTAB),HL 22 FB 40

Save the value of the new array variables pointer in HL. 40FBH-40FCH holds the starting address of the BASIC array variable storage area

26BE ZEROER

DEC HL 2B

At this point, HL is retuned pointing to the end of the variable, so we need to zero backwards to DE which points to the start of the variable table. First, decrement the value of the array variables pointer in HL

26BF-26C0

LD (HL),00H 36 00

Zero the location of the memory pointer in HL

26C1

RST 18H COMPARDF

Now we need to check to see if the variable has been completely zeroed, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

26C2-26CJ

JR NZ,26BEH R NZ,ZEROER20 FA

Loop back to 26BEH until the variable has been cleared

26C4

POP DE D1

Get the value of the variable’s number type flag from the STACK and put it in DE

26C5

LD (HL),E 73

Save the value of the number type flag in Register E at the location of the memory pointer in HL

26C6

INC HL 23

Bump the value of the memory pointer in HL

26C7

POP DE D1

Get the 2nd character of the variable’s name from the STACK and put it in DE

26C8

LD (HL),E 73

Save the first character of the variable’s name in Register E at the location of the memory pointer in HL

26C9

INC HL 23

Bump the value of the memory pointer in HL

26CA

LD (HL),D 72

Save the first character of the variable’s name in Register D at the location of the memory pointer in HL

26CB

EX DE,HL EB

Load DE with the value of the variable pointer in from HL

26CC FINPTR

INC DE 13

Bump the value of the variable pointer in DE so that it points to the value

26CD

POP HL E1

Restore the value of the current BASIC program pointer from the STACK into Register Pair HL

26CE

RET C9

RETurn to CALLer

26CF VARNOT

LD D,A 57

On entry, the Z FLAG was set, meaning that A=0. Zero out Register D with the value of Register AA

26D0

LD E,A 5F

Zero out Register E

26D1

POP AF F1

Clean up the STACK (which was the PUSHed DE)

26D2

POP AF F1

Clean up the STACK (which was the length)

26D3

EX (SP),HL E3

Swap (SP) and HL so that the return return is now at the top of the STACK and the pointer in current BASIC program pointer is restored to HL

26D4

RET C9

Return to the VARPTR routine

26D5 – This routine is ZERO out all variable types and skip any RETurn – “FINZER”

26D5-26D7 FINZER

LD (4124H),A LD (FAC),A 32 24 41

Zero ACCumulator so that all single-precision and double-precision variables become zero

26D8

POP BC C1

Clean up the STACK (i.e., remove the length of the variable)

26D9

LD H,A 67

Zero Register H to clear out integers as well

26DA

LD L,A 6F

Zero Register L to clear out integers as well

26DB-26DD

LD (4121H),HL LD (FACLO),HL 22 21 41

Zero the string pointer location in ACCumulator

26DE

RST 20H GETYPEE7

We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in ACCumulator and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH). The results are returned as follows:

• Integer = NZ/C/M/E and A is -1
• String = Z/C/P/E and A is 0
• Single Precision = NZ/C/P/O and A is 1
• and Double Precision is NZ/NC/P/E and A is 5.

26DF-26E0

JR NZ,26E7H JR NZ,POPHR220 06

If the NZ FLAG is set then we do NOT have a string, in which case we are done because we have zeroed out all the number types. JUMP to 26E7H

26E1-26E3

LD HL,1928H LD HL,REDDY-1 21 28 19

If we are here, then we have a string, and need to zero that out. First, load HL with the character before the starting address of the Level II BASIC READY message, which is a 00H!

26E4-26E6

LD (4121H),HL LD (FACLO),HL 22 21 41

Save the value in HL as the current string pointer, which is now null.

26E7 POPHR2

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

26E8

RET C9

RETurn (from the EVAL routine) to CALLer

26E9 – This routine handles a subscripted variables – “ISARY”

According to the original ROM source, ARRAYs have the following format:

• Descriptor – Low Byte – Second Character (200 bit is string)
• Descriptor – High Byte – First character
• Length of array in core in bytes
• Number of dimensions (1 byte)
• Then, for each dimension starting with the first, a list of the max index+1 (2 bytes each)
• The associated value

On entry D = the type of variable, B = the 1st character of the variable name, C = the 2nd character of the variable name, and HL = the current position in the input string.

26E9 ISARY

PUSH HL E5

Save the DIMFLG and VALTYP for recursion

26EA-26EC

LD HL,(40AEH) LD HL,(DIMFLG) 2A AE 40

Load HL with the value of the locate/create flag.
Note: 40AEH holds LOCATE/CREATE variable flag and will be a 0 if in locate mode and anything other than zero if in create mode

26ED

EX (SP),HL E3

Swap (SP) and HL so that the the value of the current BASIC program pointer is back into Register Pair HL, and the DIMFLG and VALTYP are moved to the top of the STACK

26EE

LD D,A 57

Zero Register D (which will hold the number of dimension)

26EF INDLOP

PUSH DE D5

Save the number of dimension (held in Register D) to the STACK

26F0

PUSH BC C5

Save the variable’s name in BC to the STACK

26F1-26F3

CALL 1E45H CALL INTIDXCD 45 1E

Go evaluate the array subscript/index at the location of the current BASIC program pointer in HL up to a ) or , . Return with the binary value in DE

26F4

POP BC C1

Get the variable’s name from the STACK (1st and 2nd character) and put it in BC

26F5

POP AF F1

Get the variable’s number of dimension so far from the STACK and put it in Register A

26F6

EX DE,HL EB

Swap DE and HL, so that DE will now be the value of the current BASIC program pointer and HL will now hold the array subscript

26F7

EX (SP),HL E3

Swap (SP) and HL so that HL will now hold DIMFLG and VALTYP and the array subscript will be at the stop of the STACK

26F8

PUSH HL E5

Save the DIMGFLG and VALTYP (in HL) to the STACK

26F9

EX DE,HL EB

Swap DE and HL so that the value of the current BASIC program pointer is now in Register Pair HL, and the DIMFLG and VALTYP are now in DE.

26FA

INC A 3C

Bump the number of dimensions evaluated in Register A

26FB

LD D,A 57

Load Register D with the number of dimensions evaluated in Register A

26FC

LD A,(HL) 7E

Load Register A with the character at the location of the current BASIC program pointer in HL

26FD-26FE

CP 2CH FE 2C

Check to see if the character at the location of the current BASIC program pointer in Register A is a , . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

26FF-2700

JR Z,26EFH JR Z,INDLOP28 EE

If the character at the location of the current BASIC program pointer in Register A is a , , then we have more dimensions to process, so JUMP back to INDLOP to process again

2701-2702

RST 08H⇒ 29 SYNCHK “)” CF 29

Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2703-2705 SUBSOK

LD (40F3H),HL LD (TEMP2),HL 22 F3 40

Save the value of the current BASIC program pointer in HL into the TEMP2 storage area.

2706

POP HL E1

Get the DIMFLG and VALTYP from the STACK and put it in HL.

2707-2709

LD (40AEH),HL LD (DIMFLG),HL 22 AE 40

Save the value of the DIMFLG and VALTYP into the DIMFLG location in RAM.
NOTE: 40AEH holds LOCATE/CREATE variable flag

270A

PUSH DE D5

Save the number of subscripts/dimensions evaluated (held in DE) to the STACK

At this point, Register BC holds the variable name, the pointer to the BASIC program is in TEMP2, all of the indexes are on the STACK, as is the number of dimensions.

270B-270D

LD HL,(40FBH) LD HL,(ARYTAB) 2A FB 40

We are now going to start the serach! First, load HL with the value of the array variables pointer as the starting point. 40FBH-40FCH holds the starting address of the BASIC array variable storage area

270E-270F

LD A,19H 3E 19

Z-80 Trick to skip the next command of ADD HL,DE if falling through

270F LOPFDA

ADD HL,DE 19

Advance past the current array as we know it isn’t the correct one. Note: 40FBH-40FCH holds the array variables pointer

2710

EX DE,HL EB

Swap DE and HL so that DE holds the current search point. We don’t care about HL.

2711-2713

LD HL,(40FDH) LD HL,(STREND) 2A FD 40

Load HL with the place to STOP the search (i.e., the value of the free memory pointer).
Note: 40FDH-40FEH holds Free memory pointer

2714

EX DE,HL EB

Swap DE and HL so that DE now holds the place to stop the search and HL holds the current search point.

2715

RST 18H COMPARDF

Now we need to see if we have reached the end of the search by comparing the END point to the CURRENT point, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2716-2718

LD A,(40AFH) LD A,(VALTYP) 3A AF 40

Load Register A with the value of the current number type flag.
Note: 40AFH holds Current number type flag

2719-271A

JR Z,2742H JR Z,NOTFDD28 27

If the Z FLAG is set, then we have run out of places to search and are finished, without finding the array, so JUMP out of this loop to 2742H

271B

CP (HL) BE

Compare the value of the variable’s number type flag in Register A with the value of the number type flag at the location of the array variables pointer in HL. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

271C

INC HL 23

Bump the value of the array variables pointer in HL

271D-271E

JR NZ,2727H R NZ,NMARY220 08

Jump forward (but still in this loop) to 2727H if the number type flags don’t match

271F

LD A,(HL) 7E

Load Register A with the first character of the variable name at the location of the array variables pointer in HL

2720

CP C B9

Check to see if the first character of the variable at the location of the array variable pointer in Register A matches the first character of the variable name in Register C. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2721

INC HL 23

Bump the value of the array variables pointer in HL

2722-2723

JR NZ,2728H R NZ,NMARY120 04

Jump forward (but still in this loop) to 2728H if the first characters of the variable names don’t match

2724

LD A,(HL) 7E

Load Register A with the second character of the variable name at the location of the array variables pointer in HL

2725

CP B B8

Compare the second character of the variable name at the location of the array variables pointer in Register A matches the second character of the variable name in Register B. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2726-2727

LD A,23H 3E 23

This part of a Z-80 Trick. Will load A with 23H if passing through, and not do the following INC HL.

2727 NMARY2

INC HL 23

Bump the value of the array variables pointer in HL

2728 NMARY1

INC HL 23

Bump the value of the array variables pointer in HL. HL should now point to the LENGTH entry of the array being looked at

2729

LD E,(HL) 5E

Load Register E with the LSB of the LENGTH of the array being looked at

272A

INC HL 23

Bump the value of the array variables pointer in HL

272B

LD D,(HL) 56

Load Register D with the MSB of the LENGTH of the array being looked at

272C

INC HL 23

Bump the value of the array variables pointer in HL

272D-272E

JR NZ,270FH R NZ,LOPFDA20 E0

If the NZ FLAG is set, then we do not have a match ,and we need to skuip this entry and try again via a JUMP back to 270FH

272F-2731

LD A,(40AEH) LD A,(DIMFLG) 3A AE 40

Load Register A with the value of the locate/create flag to see if this was a “DIM” instruction.
Note: 40AEH holds LOCATE/CREATE variable flag

2732

OR A B7

Since a LD command does not set any flags, we must OR A to set the flags against A. In this case, to check the status of the locate/create flag in Register A

2733-2734

LD E,12H 1E 12

Prepare for an error if this routine was NOT called by “DIM” by loading Register E with the ?DD ERROR code

2735-2737

JP NZ,19A2H JP NZ,ERRORC2 A2 19

If the NZ FLAG is set, then this was not called from DIM, and we need to throw a REDIMENTIONED ARRAY error (i.e., ?DD ERROR ) since that variable already exists

At this point TEMP2 still holds the pointer to the position in the BASIC line being evaluated AND we have located the variable we were looking or. HL will point beyond the LENGTH to the number of dimensions. All indices are on the STACK, followed by the number of dimensions.

2738

POP AF F1

Get the number of dimension evaluated from the STACK and put it in Register A

2739

SUB (HL) 96

To do the actual erasure we need to make suyre that the number given now and when the array was set up are the same so we compare the number of subscripts evaluated in Register A with the number of subscripts for the array at the location of the array variables pointer in HL (meaning, the number which was DIM med)

273A-273C

JP Z,2795H JP Z,GETDEFCA 95 27

If they match then we are done so JUMP down to 2795H to read the indices

273D – ?BS ERROR entry point – “BSER”

273D-273E BSER

LD E,10H 1E 10

Load Register E with a ?BS ERROR code

273F-2741

JP 19A2H JP ERRORC3 A2 19

Display a ?BS ERROR message if the number of subscripts evaluated in Register A doesn’t match the number of subscripts for the array at the location of the array variable pointer in HL

2742 – Part of the ARRAY routines. Jumped here when a variable isn’t found in the ARRAY table – “NOTFDD”

The original ROM source lays out the steps which the ROM takes to build an entry when a variable isn’t found in the array table:

Put down the descriptor

Set up the number of dimensions

Make sure there is room for the new entry

Remember the VARPTR

Set the VALTYP

Hold 2 bytes for the size

Loop

1. Get an index
2. Put number+1 down at the VARPTR
3. Increase the VARPTR
4. Decmrent the number of DIMs
5. Go back to the LOOP until the number of DIMs hits Zero

Call REASON with Register Pair HL holding the last location of the variable

Update STREND

Zero out backwards

Make the tally include MAXDIMS

Put down TALLY

If called by DIM, RETurn

If not called by DIM, then index into the variable as if it was found when initially searched for.

2742 NOTFDD

LD (HL),A 77

Save the variable type for the array in Register A at the location of the array variables pointer in HL

2743

INC HL 23

Bump the value of the array variables pointer in HL so it points to the 2nd character in the variable name (since they are saved in last, first order)

2744

LD E,A 5F

Load Register E with the variable type flag for the current variable

2745-2746

LD D,00H 16 00

Zero Register D so that Register Pair DE can be the size of one value of the type VALTYP

2747

POP AF F1

Get the number of dimensions evaluated from the STACK and put it in Register A

2748

LD (HL),C 71

Save the second character of the variable’s name in Register C at the location of the array variables pointer in HL

2749

INC HL 23

Bump the value of the array variables pointer in HL to now point to the 1st character in the variable name (since they are saved in last, first order)

274A

LD (HL),B 70

Save the first character of the variable’s name in Register B at the location of the array variables pointer in HL

274B

INC HL 23

Bump the value of the array variables pointer in HL to the LSB of the offset to the next entry

274C

LD C,A 4F

In preparation for the next CALL, load Register C with the number of two byte entries needed to store the size of each dimension

274D-274F

CALL 1963H CALL GETSTKCD 63 19

Figure the amount of memory space left between HL and the free memory and get the space needed as set in Register C

2750

INC HL 23

Next we need to make room (i.e., skip over) the size of each dimension so … Bump the value of the array variables pointer in HL

2751

INC HL 23

Bump the value of the array variables pointer in HL. These 2 INC’s skip over the offset entry

2752-2754

LD (40D8H),HL LD (TEMP3),HL 22 D8 40

Next we need to secure space for the dimenion entries by saving the location in which to put the size (which is the address of the maximum number of indices) into a temporary ram location.
Note: 40D8H-40D9H holds temporary storage location

2755

LD (HL),C 71

Save the number of dimension at the location of the array variables pointer in HL

2756

INC HL 23

Bump the value of the array variables pointer in HL to point to the first subscript entry in the array table

2757-2759

LD A,(40AEH) LD A,(DIMFLG) 3A AE 40

Load Register A with the value of the locate/create flag so we can check to see if this routine was called from a DIM function.
Note: 40AEH holds LOCATE/CREATE variable flag

275A

RLA 17

Set the CARRY flag accordingly

275B

LD A,C 79

Load Register A with the number of dimension evaluated in Register C

275C-275E LOPPTA

LD BC,000BH 01 0B 00

Top of a loop assuming we did not get here from “DIM”. Load BC with the default number of 11, which is the most entries an array can have without a DIM

275F-2760

JR NC,2763H JR NC,NOTDIM30 02

If the NC flag is set, then we did not arrive here from DIM, so JUMP forward to 2763H if the array is being created because it certainly wasn’t found

2761

POP BC C1

Get a subscript/index from the STACK and put it in BC

2762

INC BC 03

Bump the value of the subscript in BC by one for the ZERO entry.

2763 NOTDIM

LD (HL),C 71

Top of a loop. Save the LSB of the subscript’s value in Register C at the location of the array variables pointer in HL

2764

INC HL 23

Bump the value of the array variables pointer in HL

2765

LD (HL),B 70

Save the MSB of the subscript’s value in Register B at the location of the array variables pointer in HL

2766

INC HL 23

Bump the value of the array variables pointer in HL

2767

PUSH AF F5

Save the number of dimensions evaluated in Register A (and the CARRY aflag results from DIMFLG) to the STACK

2768-276A

CALL 0BAAH CALL UMULTCD AA 0B

Go multiply the size of the subscript by the value of the number type flag to determine the amount of memory necessary for the subscript

276B

POP AF F1

Get the number of domensions that the CARRY FLAG (DIMFLG) from the STACK and put it in Register A

276C

DEC A 3D

Decrement the counter of the number of dimensions to check by one

276D-276E

JR NZ,275CH JR NZ,LOPPTA20 ED

Jump back to 275CH if there are anymore subscripts to be evaluated

276F

PUSH AF F5

If we are here, then all dimensions have been processed and allocation. Next, save the number of subscripts evaluated (and the DIMFLG) in Register Pair AF to the STACK

2770

LD B,D 42

Load Register B with the MSB of the array’s length in Register D

2771

LD C,E 4B

Load Register C with the LSB of the array’s length in Register E. Now BC = size of the array in bytes

2772

EX DE,HL EB

Swap DE and HL so that DE now has the start of the values and HL has the end of the values

2773

ADD HL,DE 19

Add the length of the array in HL to the value of the array variable pointer in DE

2774-2775

JR C,273DH JR C,BSER38 C7

If that addition triggered the CARRY FLAG then we are out of RAM so JUMP back to 273DH and throw a ?BS ERROR

2776-2778

CALL 196CH
CALL REASONCD 6C 19

We now know there is room in RAM, so GOSUB to “REASON” to make sure there is room for the values

2779-277B

LD (40FDH),HL LD (STREND),HL 22 FD 40

Update the end of storage pointer with the end of the array (held in HL).
Note: 40FDH-40FEH holds free memory pointer

277C ZERITA

DEC HL 2B

Now we need to zero the new array. First, decrement the value of the array pointer in HL

277D-277E

LD (HL),00H 36 00

Zero the location of the array pointer in HL

277F

RST 18H COMPARDF

Now we need to compare the array pointer in HL with the array variables pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2780-2781

JR NZ,277CH JR NZ,ZERITA20 FA

If the NZ FLAG is set, then we have more entries to ZERO, so loop until the array has been cleared

2782

INC BC 03

Load BC with the array’s length in bytes plus one so as to make room for the byte which holds the number of dimensions for this array variable

2783

LD D,A 57

Zero Register D

2784-2786

LD HL,(40D8H) HL,(TEMP3) 2A D8 40

Load HL with the array variables pointer (=the number of indices).
Note: 40D8H-40D9H holds Temporary storage location

2787

LD E,(HL) 5E

Load Register E with the number of dimension for the array at the location of the array variables pointer in HL

2788

EX DE,HL EB

Swap DE and HL so that HL now holds the number of dimensions and DE holds the value of the array variables pointer

2789

ADD HL,HL 29

Multiply the number of subscripts for the array in HL by two

278A

ADD HL,BC 09

Add the length of the array in BC (i.e., the size) to the number of subscripts times two in HL so that we have the total number of bytes used

278B

EX DE,HL EB

Swap DE and HL so that DE now holds the total number of bytes to be used for the array and HL holds the value of the array variables pointer

278C

DEC HL 2B

We now need to insert the size of the array in bytes into the array holding area, but that is 2 bytes back so … decrement the value of the array variables pointer in HL

278D

DEC HL 2B

Decrement the value of the array variables pointer in HL

278E

LD (HL),E 73

Save the LSB of the size of the array in Register E at the location of the array variables pointer in HL

278F

INC HL 23

Bump the value of the array variables pointer in HL

2790

LD (HL),D 72

Save the MSB of size of the array array in Register D at the location of the array variables pointer in HL

2791

INC HL 23

Bump the value of the array variables pointer in HL

2792

POP AF F1

Get the value of the DIMFLG (i.e., the CARRY BIT) and a 0 into Register A

2793-2794

JR C,27C5H JR C,FINNNOW38 30

Jump forward to 27C5H if the array is being created

At this point, HL points beyond the SIZE of the array to the NUMBER OF DIMENSIONS in the array. So what we need to do next is

• We need NUMDIM to equal the number of dimensions and CURTOL to be 0
• Start a loop:
  • Get a new index value
  • Pop the new maximum into CURMAX
  • Make sure the index value isn’t too big
  • Multiply CURTOL by CURMAX
  • Add the index to CURTOL
  • Reduce NUMDIM by 1
  • LOOP BACK if NUMDIM isn’t yet 0
• Set an OFFSET as CURTOL*4 (which is the VALTYP for extended).

2795 GETDEF

LD B,A 47

Zero Register B

2796

LD C,A 4F

Zero Register C. Now BC = 0 = CURTOL

2797

LD A,(HL) 7E

Load Register A with the number of dimensions for the array at the location of the array variables pointer in HL

2798

INC HL 23

Bump the value of the array variables pointer in HL to one entry past the number of dimensions

2799

LD D,0E1H 16 E1

Z-80 Trick to hide the next instruction (POP HL) if proceeding downward

279A INLPNM

POP HL E1

Get the array variables pointer from the STACK and put it in HL

279B

LD E,(HL) 5E

Next, we want DE to be the maximum for the current index entry, so first load Register E with the LSB of the subscript limit at the location of the array variables pointer in HL

279C

INC HL 23

Bump the value of the array variables pointer in HL

279D

LD D,(HL) 56

Load Register D with the MSB of the subscript limit at the location of the array variables pointer in HL

279E

INC HL 23

Bump the value of the array variables pointer in HL

279F

EX (SP),HL E3

Swap HL and (SP) so that HL now points to the currrent index, and the pointer to the array variable goes to the top of the STACK

27A0

PUSH AF F5

Save the number of dimensions for the array in Register A to the STACK

27A1

RST 18H COMPARDF

Now we need to compare the subscript limit in DE with the subscript for the array in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

27A2-27A4

JP NC,273DH JP NC,BSERD2 3D 27

If the current inex is too big, then we need to throw a ?BS ERROR via a JUMP to 273DH

27A5-27A7

CALL 0BAAH CALL UMULTCD AA 0B

CURTOL = CURTOL * the current maximum subscript

27A8

ADD HL,DE 19

Add the index to CURTOL

27A9

POP AF F1

Get the number of dimensions for the array from the STACK and put it in Register A

27AA

DEC A 3D

We checked one, so cross one off the list and see if there are anymore dimensions to be evaluated

27AB

LD B,H 44

Load Register B with the MSB of the subscript pointer in Register H

27AC

LD C,L 4D

Load Register C with the LSB of the subscript pointer in Register L. Now BC = CURTOL for the start of the next loop.

27AD-27AE

JR NZ,279AH JR NZ,INLPNM20 EB

Loop back to 279AH until all of the subscripts have been evaluated

27AF-27B1

LD A,(40AFH) LD A,(VALTYP) 3A AF 40

Get the number type flag for the current array; which also doubles for how big the values are
NOTE: 40AFH holds Current number type flag

27B2
27B3

LD B,H
LD C,L 44

We are going to need to multiply by THREE, so we need to save the original value into BC as well.

27B4

ADD HL,HL 29

Multiply the subscript pointer in HL by two

27B5-27B6

SUB 04H D6 04

Check the value of the number type flag in Register A because we would be done if we have an integer or a string.

27B7-27B8

JR C,27BDH JR C,DMLVAL38 04

Jump forward to 27BDH if the current number type is an integer or string

27B9

ADD HL,HL 29

It isn’t an integer or a string so once again multiply the subscript pointer in HL by two (so now it is multiplied by 4)

27BA-27BB

JR Z,27C2H JR Z,DONMUL28 06

Jump forward to 27C2H if the current number type is single precision as we then have enough bytes.

27BC

ADD HL,HL 29

It must be double precision, so once again multiply the subscript pointer in HL by two (so now it is multiplied by 8)

27BD DMLVAL

OR A B7

Set the flags

27BE-27C0

JP PO,27C2H JP PO,DONMULE2 C2 27

Jump forward to 27C2H if the current number type isn’t a string

27C1

ADD HL,BC 09

The current number type is a string so add the value of the original subscript pointer in BC to the subscript pointer in HL

27C2 DONMUL

POP BC C1

Get the value of the array variables pointer from the STACK and put it in BC

27C3

ADD HL,BC 09

Add the value of the array variables pointer in BC to the subscript pointer in HL to get the place where the size value needs to be stored

27C4

EX DE,HL EB

Load DE with the variable pointer in HL

27C5-27C7 FINNNOW

LD HL,(40F3H) LD HL,(TEMP2) 2A F3 40

Get the value of the current BASIC program pointer and put it in HL.
Note: 40F3H-40F4H is a temporary storage location

27C8

RET C9

RETurn to CALLer

27C9-27D3 – LEVEL II BASIC MEM ROUTINE – “MEM”

This is the RETURN AMOUNT OF FREE MEMORY routine at 27C9H which computes the amount of memory remaining between the end of the variable list and the end of the STACK and puts the result in ACCumulator as a SINGLE PRECISION number.

27C9 MEM

XOR A AF

Zero Register A and the status flags

27CA

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

27CB-27CD

LD (40AFH),A LD (VALTYP),A 32 AF 40

Zero the number type flag.
NOTE: 40AFH holds Current number type flag

27CE-27D0

CALL 27D4H CALL FRECD D4 27

Determine how much space there is via a GOSUB to the FRE routine at 27D4H

27D1

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

27D2

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

27D3

RET C9

Return to BASIC

27D4-27F4 – LEVEL II BASIC FRE ROUTINE – “FRE”

27D4-27D6 FRE

LD HL,(40FDH) LD HL,(STREND) 2A FD 40

Load HL with the start of free memory pointer (which is also the end of the variable and text space).
NOTE: 40FDH-40FEH holds Free memory pointer

27D7

EX DE,HL EB

Load DE with the value of the free memory pointer in HL for subtraction

27D8-27DA

LD HL,0000H 21 00 00

Zero HL

27DB

ADD HL,SP 39

Add the value in HL (which is zero) to the current value of the STACK pointer so that the STACK pointer is now in HL

27DC

RST 20H GETYPEE7

We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in ACCumulator and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH). The results are returned as follows:

• Integer = NZ/C/M/E and A is -1
• String = Z/C/P/E and A is 0
• Single Precision = NZ/C/P/O and A is 1
• and Double Precision is NZ/NC/P/E and A is 5.

27DD-27DE

JR NZ,27ECH JR NZ,GIVDBL20 0D

If that test shows we do NOT have a STRING (meaning this was really a MEM call, jump to forward to 27ECH

27DF-27E1

CALL 29DAH CALL FREFACCD DA 29

Free up the argument and set up to give some free string space

27E2-27E1

CALL 28E6H CALL GARBA2CD E6 28

Do garbage collection to free up space

27E5-27E7

LD HL,(40A0H) LD HL,(STKTOP) 2A A0 40

Load HL with the start of string space pointer / bottom of free space.
NOTE: 40A0H-40A1H holds the start of string space pointer

27E8

EX DE,HL EB

Load DE with the start of string space pointer in HL

27E9-27EB

LD HL,(40D6H) LD HL,(FRETOP) 2A D6 40

Load HL with the next available location in string space pointer / top of free space.
NOTE: 40D6H-40D7H holds the next available location in string space pointer

The next routine subtracts DE from HL and then floats the result leaving it in FAC.

27EC GIVDBL

LD A,L 7D

Prepare to do HL = HL – DE. First, load Register A with the LSB of the next available location in string space pointer in Register L

27ED

SUB E 93

Subtract the LSB of the start of string space pointer in Register E from the LSB of the next available location in string space pointer in Register A

27EE

LD L,A 6F

Load Register L with the LSB of the amount of string space remaining in Register A

27EF

LD A,H 7C

Load Register A with the MSB of the next available location in string space pointer in Register H

27F0

SBC A,D 9A

Subtract the MSB of the string space pointer in Register D from the MSB of the next available location of string space pointer in Register A

27F1

LD H,A 67

Load Register H with the MSB of the amount of string space remaining in Register A

27F2-27F4

JP 0C66H JP INEG2C3 66 0C

Jump to 0C66H to convert the difference between HL and DE to single precision and then RETurn out of the routine

27F5-27FD – LEVEL II BASIC POS( ROUTINE – “POS”

27F5-27F7 POS

LD A,(40A6H) LD A,(TTYPOS) 3A A6 40

Load Register A with the current cursor line position.
Note: 40A6H holds the current cursor line position

27F8 SNGFLT

LD L,A 6F

Load Register L with the value of the current cursor line position in Register A.

27F9

XOR A AF

Zero Register A

27FA GIVINT

LD H,A 67

Load Register H with zero, so now HL is 00 + cursor position

27FB-27FD

JP 0A9AH JP MAKINTC3 9A 0A

Jump to 0A9AH to make A an unsigned integer

27FE-2818 – LEVEL II BASIC USR(x) ROUTINE – “USRFN”

27FE-2780 USRFN

CALL 41A9H CALL USROUT CD A9 41

GOSUB to DOS to see if DOS wants to deal with this

2801

RST 10H CHRGETD7

We need the next character so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2802-2804

CALL 252CH CALL PARCHKCD 2C 25

GOSUB to 252CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in ACCumulator

2805

PUSH HL E5

Save the value of the current BASIC program pointer in HL (=the address of the next element in the code string) to the STACK

2806-2808

LD HL,0890H LD HL,POPHRT 21 90 08

Load HL with the return address of 0890H which will clear the STACK before returning to BASIC

2809

PUSH HL E5

Save the value of the return address in HL to the STACK

280A-280C

LD A,(40AFH) LD A,(VALTYP) 3A AF 40

Load Register A with the value of the current number type flag for the argument provided.
Note: 40AFH holds Current number type flag

280D

PUSH AF F5

Save the value of the current number type flag in Register A.
(02=INT, 03=STR, 04=SNG, 08=DBL)

280E-280F

CP 03H FE 03

Check to see if the current value is a string. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2810-2812

CALL Z,29DAH CALL Z,FREFACCC DA 29

If the current result is a string then GOSUB to 29DAH to get the free the space and get the string address into HL

2813

POP AF F1

Restore the number type flag into Register A

2814

EX DE,HL EB

Load DE with the (possible) value of the pointer to the string (in HL)

2815-2817

LD HL,(408EH) 2A 8E 40

Load HL with the starting address of the machine language subroutine. In TRSDOS, 408EH is a variable called MAXFIL which holds the value the user entered when answering the prompted “FILES?” question. This would definitely NOT be the right address under DOS.

2818

JP (HL)E9

Jump to (HL) to run the routine

2819-2827 – CONVERSION ROUTINE – “DOCNVF”

Usually called by LET to convert the result of arithmetic routines to the proper destination type.

2819 DOCNVF

PUSH HL E5

Save the pointer to the current character in the BASIC program being evaluated to the STACK

281A-281B

AND 07H E6 07

Mask the value of the current number type flag in Register A to force the formula type to conform to the variable type that it is assigned to

281C-281E

LD HL,18A1H LD HL,FRCTBL 21 A1 18

Load HL with the address of the arithmetic conversion routines

281F

LD C,A 4F

Load Register C with the value of the number type flag in Register A.
(02=INT, 03=STR, 04=SNG, 08=DBL)

2820-2821

LD B,00H 06 00

Zero Register B. Now BC holds 00 + type and will be the two byte offset into the table

2822

ADD HL,BC 09

Add the offset (of BC) to the base arithmetic conversion routines, to find the right jump point

2823-2825

CALL 2586H CALL DISPATCD 86 25

GOSUB to 2586H to convert the current result in REG l to its proper number type

2826

POP HL E1

Restore the pointer to the current character in the BASIC program being evaluated to HL

2827

RET C9

RETurn to CALLer

2828-2835 – Routine to see if we are in DIRECT MODE and ERROR OUT if so – “ERRDIR”

Usually called from the INPUT routine. On entry HL has the current line number in binary.

2828 ERRDIR

PUSH HL E5

Save whatever was in HL to the STACK

2829-282B

LD HL,(40A2H) LD HL,(CURLIN) 2A A2 40

Load HL with the value of the current BASIC line number (which is stored at 40A2H-40A3H).

282C

INC HL 23

Bump the value of the current BASIC line number in HL to enable us to test for a direct statement. Direct is 65535 so bumping by 1 will give us a ZERo

282D

LD A,H 7C

Load Register A with the MSB of the current BASIC line number in Register H

282E

OR L B5

Combine the LSB of the current BASIC line number in Register L with the MSB of the current BASIC line number in Register A. If H and L are both ZERO then the Z FLAG will be set.

282F

POP HL E1

Restore whatever was in HL on entry back into HL

2830

RET NZ C0

Return if there is a line number (i.e., this isn’t the command mode) and otherwise fall through to the ?ID ERROR routine

2831 – ID ERROR entry point.

2831-2832

LD E,16H 1E 16

Load Register E with the ?ID ERROR code

2833-2835

JP 19A2H JP ERRORC3 A2 19

Display an ?ID ERROR if this is the command mode

2836-2856 – STRING ROUTINE – STR$ logic – “STR$”

2836-2838 STR$

CALL 0FBDH CALL FOUTCD BD 0F

GOSUB to 0FBDH to convert the current result in ACCumulator to an ASCII string

2839-283B STR$1

CALL 2865H CALL STRLITCD 65 28

Scan it and turn it into a string (make a temporary string work area entry)

283C-283E

CALL 29DAH CALL FREFACCD DA 29

Load HL with the string’s VARPTR and free up the temp

283F-2841

LD BC,2A2BH LD BC,FINBCK 01 2B 2A

Load BC with a return address of 2A2BH (which cleans the STACK and then jumps to 2884H)

2842

PUSH BC C5

Save the value of the return address in BC to the STACK

The next routine, STRCPY, creates a copy of the string pointed to by Register Pair HL. On exit, DE points to DSCTMP which has the string information.

2843 STRCPY

LD A,(HL) 7E

Load Register A with the string’s length at the location of the string’s VARPTR in HL

2844

INC HL 23

Bump the value of the string’s VARPTR in HL

2845

PUSH HL E5

Save the value of the string’s VARPTR in HL to the STACK

2846-2848

CALL 28BFH CALL GETSPACD BF 28

GOSUB to 28BFH to test the remaining string area to make sure that the new string will fit

2849

POP HL E1

Reload HL with the string’s VARPTR. This is the destination to where the string should be copied.

284A

LD C,(HL) 4E

Load Register C with the LSB of the string’s address at the location of the string’s VARPTR in HL

284B

INC HL 23

Bump the value of the string’s VARPTR in HL

284C

LD B,(HL) 46

Load Register B with the MSB of the string’s address at the location of the string’s VARPTR in HL

284D-284F

CALL 285AH CALL STRAD2CD 5A 28

GOSUB to 285AH to save the string’s length and the string’s address at 40D3H, so as to set up DSCTMP

2850

PUSH HL E5

Save the pointer to STRAD2 (which is 40D3H) to the STACK

2851

LD L,A 6F

Load Register L with the string’s length (from Register A)

2852-2854

CALL 29CEH CALL MOVSTRCD CE 29

GOSUB to 29CEH to move L characters from the temp area (of BC) to the string data area (in DE)

2855

POP DE D1

Restore the pointer to DSCTMP (40D3H) into Register Pair DE

2856

RET C9

RETurn to CALLer

2857-2864 – STRING ROUTINE – “STRINI”

2857-2859 STRINI

CALL 28BFH CALL GETSPACD BF 28

GOSUB to 28BFH to make sure that there is enough string space remaining for the string length of Register A characters. Get the address of the next string area in DE. Then save A and DE at 40D3H-40D5H

285A STRAD2

LD HL,40D3H LD HL,DSCTMP 21 D3 40

Load HL with the address of the temporary string parameter storage area.
Note: 40D3H-40D5H holds Used for temporary string VARPTR’s

285D STRAD1

PUSH HL E5

Save the address of the temporary string parameter area in HL to the STACK

285E

LD (HL),A 77

Save the string’s length in Register A at the location of the temporary string parameter storage pointer in HL

285F PUTDEI

INC HL 23

The next instructions are to set up DE to be the pointer to free space. First, bump the value of the temporary string parameter storage pointer in HL

2860

LD (HL),E 73

Save the LSB of the string’s address in Register E at the location of the temporary string parameter storage pointer in HL

2861

INC HL 23

Bump the value of the temporary string parameter storage pointer in HL

2862

LD (HL),D 72

Save the MSB of the string’s address in Register D at the location of the temporary string parameter storage pointer in HL

2863

POP HL E1

Get the address of the temporary string parameter storage area from the STACK and put it in HL

2864

RET C9

RETurn to CALLer

2865-28A5 – STRING ROUTINE – “STRLIT”

STRLT2 takes the string literal whose first character is pointed by HL+1 and builds a descriptor for it. Leading quotes should be skipped before the CALL to this routine.

The descriptor is initially built in DSCTMP, but PUTNEW transfers it into a temporary RAM area and leaves a pointer at the temporary in FACLO.

All characters other than zero (that terminate the string) should be set up in Registers B and D. If the terminator is a quote, the quote is skipped over.

On EXIT, the character after the string literal is pointed to by Register Pair HL and is in Register A. No flags are set.

2865 STRLIT

DEC HL 2B

Decrement the value of the current BASIC program pointer in HL

2866-2867 STRLTI

LD B,22H 06 22

Load Register B with a “ (which is really the end of the quote search character)

2868 STRLT3

LD D,B 50

Load Register D with a “ (which is really the ending search character)

2869 STRLT2

PUSH HL E5

Save the address of the current BASIC program pointer in HL to the STACK. This is ALSO the pointer to the start of the literal string being worked on.

286A-286B

LD C,0FFH 0E FF

Load Register C with a -1

286C STRGET

INC HL 23

Bump the value of the current BASIC program pointer in HL to skip over that initial “

286D

LD A,(HL) 7E

Load Register A with the character at the location of the current BASIC program pointer in HL

286E

INC C 0C

Bump the counter in Register C

286F

OR A B7

Check to see if the character at the location of the current BASIC program pointer in Register A is an end of the BASIC line character

2870-2871

JR Z,2878H JR Z,STRFIN28 06

Jump to 2878H if the character at the location of the current BASIC program pointer in Register A is an end of the BASIC line character

2872

CP D BA

Check to see if the character at the location of the current BASIC program pointer in Register A is the same as the terminating character in Register D. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2873-2874

JR Z,2878H JR Z,STRFIN28 03

Jump to 2878H if the character at the location of the current BASIC program pointer in Register A is the same as the terminating character in Register D

2875

CP B B8

Check to see if the character at the location of the current BASIC program pointer in Register A is the same at the terminating character in Register B. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2876-2877

JR NZ,286CH JR NZ,STRGET20 F4

Loop back to 286CH if the character at the location of the current BASIC program pointer in Register A isn’t the same as the terminating character in Register B or D

2878-2879 STRFIN

CP 22H FE 22

Check to see if the character at the location of the current BASIC program pointer in Register A is a quote. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

287A-287C

CALL Z,1D78H CALL Z,CHRGTRCC 78 1D

If it was a quote, then GOSUB to 1D78H to bump the value of the current BASIC program pointer in HL until it points to the next character (i.e., skip the quote)

287D

EX (SP),HL E3

Exchange the value of the current BASIC program pointer in HL with the string’s address to the STACK

287E

INC HL 23

Bump the string’s address in HL until it points to the first character of the string

287F

EX DE,HL EB

Load DE with the temporary pointer string’s address in HL

2880

LD A,C 79

Load Register A with the string’s length from Register C

2881-2883

CALL 285AH CALL STRAD2CD 5A 28

GOSUB to 285AH to save the string’s length and the string’s address into 40D3H (i.e., DSCTMP)

2884-2886 PUTNEW

LD DE,40D3H LD DE,DSCTMP 11 D3 40

Load DE with the address of the string parameter storage area.
Note: 40D3H-40D5H holds Used for temporary string VARPTR’s

2887-2888

LD A,D5H 3E D5

This seems to be garbage, but 2888H is a JUMP point in DOS Basic to process a new string in the DEF FN routine. When JUMPed to 2888H, a PUSH DE is processed

2888 PUTTMP

PUSH DE D5

Save a pointer to the stat of the string to the STACK

2889-288B

LD HL,(40B3H) LD HL,(TEMPPT) 2A B3 40

Load HL with the first avaialble free location in the temporary string work area in HL. This will serve as the string’s VARPTR in ACCumulator.
Note: 40B3H-40B4H holds the next available location in the temporary string work area pointer

288C-288E

LD (4121H),HL LD (FACLO),HL 22 21 41

Save the value of the next available location in the temporary string work area in HL. This is where the result string descriptor will be

288F-2890

LD A,03H 3E 03

Load Register A with the string number type flag

2891-2893

LD (40AFH),A LD (VALTYP),A 32 AF 40

Save the value in Register A as the current number type flag.
Note: 40AFH holds current number type flag

2894-2896

CALL 09D3H CALL VMOVECD D3 09

Move the value into the temporary string work area in HL

2897-2899

LD DE,40D6H LD DE,FRETOP 11 D6 40

Depending on how we got here, DE will be different. If the jump was into PUTTMP, then DE will NOT equal FRETOP.

289A

RST 18H COMPARDF

We need to do some checking, as FRETOP is just beyond the temporary string storage areas, so if TEMPPT points to it, then there are no free temporary storage areas left! To do this we check to see if the updated temporary string work area location in HL isn’t greater than the ending address of the temporary string work area in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

289B-289D

LD (40B3H),HL LD (TEMPPT),HL 22 B3 40

Save the new temporary string pointer in HL as the next available location in the temporary string work area.
Note: 40B3H-40B4H holds the next available location in the temporary string work area pointer

289E

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

289F

LD A,(HL) 7E

Load Register A with the character at the location of the current BASIC program pointer in HL

28A0

RET NZ C0

Return if the updated temporary string work area location wasn’t beyond the end of the temporary string work area (meaning it overflowed, because if it overflowed .)

28A1 – ST ERROR entry point.

28A1-28A2

LD E,1EH 1E 1E

Load Register E with a ?ST ERROR code

28A3-28A5

JP 19A2H JP ERRORC3 A2 19

Display a ?ST ERROR message if the temporary string work area has overflowed

28A6-28BE – DISPLAY MESSAGE ROUTINE – “STROUI”

According to the original ROM source, this routine will print the string pointed to by Register Pair HL. The string MUST be terminated by a 00H. If the string exists below DSCTMP, then it is copied into string space first.

28A6 STROUI

INC HL 23

Bump the value of the current BASIC program pointer in HL

EXAMPLE: Suppose that we have the following symbolic setup:
TITL DEFM ‘INSIDE LEVEL II’
DEFB 0
Then, the instructions:
LD HL,TITL
CALL 28A7H
CALL STROUT
will cause “INSIDE LEVEL II” to be displayed at the current cursor position and the cursor position to be updated.

NOTE: If the subroutine at 28A7H is used by an assembly language program that is itself entered by a USR call, the return from the assembly language program may encounter the embarrassment of a TM error, with control passing to the Level II monitor. This occurs because the subroutine at 28A7H leaves a 3 in location 40AFH, while the USR structure requires a 2 in 40AFH upon returning. The malady is cured by storing a 2 in 40AFH before returning, or by jumping to 0A9AH instead of executing the simple RET. The problem would not occur in the first place if the assembly language program returns the value of an integer variable to the BASIC program, and it might not occur if some other ROM routine is called after the subroutine at 28A7H and before returning – if the other subroutine produces an integer output. DISK SYSTEM CAUTION: See the DISK SYSTEM CAUTION of Section 8.1 regarding the exits to DISK BASIC from the subroutine at 28A7H.

28A7-28A9H
“STROUT”

CALL 2865H CALL STRLITCD 65 28

Go build a temporary string work area entry for the message at FACLOthe location of the current BASIC program pointer in HL

If the routine entry is at STRPRT, then it just prints the string whose descriptor is held in FACLO

28AA-28AC STRPRT

CALL 29DAH CALL FREFACCD DA 29

GOSUB to 29DAH to build a temporary string work area entry for the message pointed to by FACLO

28AD-28AF

CALL 09C4H CALL GETBCDCD C4 09

Go get the string’s length in Register D and the string’s address in BC

28B0

INC D 14

Bump the value of the string’s length in Register D in preparation for the following loop which starts with a DEC D

28B1 STRPR2

DEC D 15

Top of a loop. Decrement the value of the string’s length in Register D

28B2

RET Z C8

Return if all of the characters in the string have been sent to the current output device.

28B3

LD A,(BC) 0A

Load Register A with the character at the location of the string pointer in BC

28B4-28B6

CALL 032AH CALL OUTDOCD 2A 03

Go send the character in Register A to the current output device

28B7-28B8

CP 0DH FE 0D

Check to see if the character in Register A is a CARRIAGE RETURN . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

28B9-28BB

CALL Z,2103H CALL Z,CRFINCC 03 21

Jump to 2103H if the character in Register A is a carriage return

28BC

INC BC 03

Bump the value of the string pointer in BC

28BD-28BE

JR 28B1H JR STRPR218 F2

Loop until all of the characters in the string have been sent to the current output device

28BF-28D9 – STRING ROUTINE – “GETSPA”

This routine will get space for a character string, and it might force garbage collection as well. The number of characters is in Register A. On exit, DE will point to the string, but if it could not allocate space, then an ?OS ERROR is thrown instead.

28BF GETSPA

OR A B7

Make sure A is not zero. A ZERO FLAG will signal that garbage collection has happened

28C0-28C1

LD C,0F1H 0E F1

Z-80 Trick. If passing through, the C just changes and the POP AF which follows is ignored.

28C1 TRYGI2

POP AF F1

Get the string’s length from the STACK and put it in Register A

28C2

PUSH AF F5

Save the length of the string in Register A to the STACK

28C3-28C5

LD HL,(40A0H) LD HL,(STKTOP) 2A A0 40

Load HL with the poinmter to the bottom of the string space. 40A0H-40A1H holds the start of string space pointer

28C6

EX DE,HL EB

Move the bottom of the string space pointer into DE. We don’t care what happens to HL

28C7-28C9

LD HL,(40D6H) LD HL,(FRETOP) 2A D6 40

Load HL with the pointer to the TOP of free space.
Note: 40D6H-40D7H holds the next available location in string space pointer

28CA

CPL 2F

Complement the string’s length in Register A so that it is negative

28CB

LD C,A 4F

The next two instructions put the negative of the number of characters into Register Pair BC. First, load Register C with the negative string’s length in Register A

28CC-28CD

LD B,0FFH 06 FF

Load Register B with a -1 so that BC will be the negative length of the string

28CE

ADD HL,BC 09

Add the negative string’s length in BC to the top of free space pointer in HL

28CF

INC HL 23

Bump the value of the adjusted next available location in string space pointer in HL

28D0

RST 18H COMPARDF

We need to make sure there is enough room for the string, so we need to compare these by checking to see if the adjusted next available location in string space pointer in HL is less than the start of string space pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

28D1-28D2

JR C,28DAH JR C,GARBAG38 07

If the CARRY FLAG is set then we do not have enough room for the string, so lets JUMP forward to 28DAH to do some garbae collection.

28D3-28D5

LD (40D6H),HL LD (FRETOP),HL 22 D6 40

Save the value in HL as new bottom of MEMORY

28D6

INC HL 23

Bump the value of HL to point to the string

28D7

EX DE,HL EB

Load DE with the pointer to the string

28D8 PPSWRT

POP AF F1

Get the string’s length from the STACK and put it in Register A

28D9

RET C9

RETurn to CALLer

28DA-298E – STRING ROUTINE – “GARBAG”

28DA GARBAG

POP AF F1

Get the garbage collection code which was PUSHed

28DB-28DC

LD E,1AH 1E 1A

Load Register E with an ?OS ERROR code

28DD-28DF

JP Z,19A2H JP Z,ERRORCA A2 19

If the Z FLAG is set, then we already tried garbage collection and still have no RAM left for the string, so display a ?OS ERROR if there isn’t enough string space available for the string and we had already reorganized string space

28E0

CP A BF

Otherwise, set the flags to say that we have already done the garbage collection. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

28E1

PUSH AF F5

Save the garbage collection flag to the STACK

28E2-28E4

LD BC,28C1H LD BC,TRYGI2 01 C1 28

Load BC with a return address of 28C1H (which would retry allocation)

28E5

PUSH BC C5

Save that return address to the STACK

28E6-28E8 GARBA2

LD HL,(40B1H) LD HL,(MEMSIZ) 2A B1 40

Load HL with the top of memory pointer.
Note: 40B1H-40B2H holds MEMORY SIZE? pointer

28E9-28EB FNDVAR

LD (40D6H),HL LD (FRETOP),HL 22 D6 40

Save the top of BASIC memory pointer in HL as the next available location in string space pointer.
Note: 40D6H-40D7H holds the next available location in string space pointer

28EC-28EE

LD HL,0000H 21 00 00

Zero HL

28EF

PUSH HL E5

Save the value in HL to the STACK to indicate that we didn’t find a variable on this pass

28F0-28F2

LD HL,(40A0H) LD HL,(STKTOP) 2A A0 40

Load HL with the start of string space pointer to force DVARS to ignore strings in the program text (literals and data).
NOTE: 40A0H-40A1H holds the start of string space pointer

28F3

PUSH HL E5

Save high address (start of string space pointer in HL) to the STACK

28F4-28F6

LD HL,40B5H LD HL,TEMPST 21 B5 40

Load HL with the start of the temporary string work area pointer.
Note: 40B5H-40D2H holds Temporary string work area

28F7
“TVAR”

EX DE,HL EB

Load DE with the start of the temporary string work area pointer in HL

28F8-28FA

LD HL,(40B3H) LD HL,(TEMPPT) 2A B3 40

Load HL with the next available location in the temporary string work area pointer.
NOTE: 40B3H-40B4H holds the next available location in the temporary string work area pointer

28FB

EX DE,HL EB

Exchange the start of the temporary string work area pointer in DE with the next available location in the temporary string work area pointer in HL

28FC

RST 18H COMPARDF

We need to see if 40B3H is pointing to the first entry (40B5H) – if the start of the temporary string work area pointer in HL is the same as the next available location in the temporary string work area pointer, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

28FD-28FF

LD BC,28F7H LD BC,TVAR 01 F7 28

Load BC with a return address of 28F7H

2900-2902

JP NZ,294AH JP NZ,DVAR2C2 4A 29

Jump to 294AH to do the temporary variable garbage collection if the temporary string work area isn’t empty

2903 SVARS

LD HL,(40F9H) LD HL,(VARTAB) 2A F9 40

Load HL with the start of the simple variables pointer.
NOTE: 40F9H-40FAH holds the starting address of the simple variable storage area

2906 SVAR

EX DE,HL EB

Load DE with the simple variables pointer in HL

2907-2909

LD HL,(40FBH) LD HL,(ARYTAB) 2A FB 40

Load HL with the start of the array variables pointer (which is also the end of the simple variables). 40FBH-40FCH holds the starting address of the BASIC array variable storage area

290A

EX DE,HL EB

Swap DE and HL so that DE holds the end and HL holds the start.

290B

RST 18H COMPARDF

Now we need to check to see if the simple variables pointer in HL is the same as the array variables pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

290C-290D

JR Z,2921H JR Z,ARYVAR28 13

If the Z FLAG is set then we are at the end of the simple variable. If so, we then need to do the string type variables so we jump forward to 2921H.

290E

LD A,(HL) 7E

Load Register A with second character of the variable name

290F

INC HL 23

Bump the value of the simple variables pointer in HL

2910

INC HL 23

Bump the simple variables pointer in HL

2911

INC HL 23

Bump the value of the simple variables pointer in HL. HL should now point to the value of the variable.

2912-2913

CP 03H FE 03

Check to see if the variable at the location of the simple variables pointer is a string. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2914-2915

JR NZ,291AH JR NZ,SKPVAR20 04

Jump to 291AH if the variable at the location of the simple variables pointer in HL isn’t a string

2916-2918

CALL 294BH CALL DVARSCD 4B 29

GOSUB to 294BH to do collect the string

2919

XOR A AF

Zero Register A to indicate that we should not be skipping anything else.

291A SKPVAR

LD E,A 5F

Zero Register E

291B-291C

LD D,00H 16 00

Zero Register D. Now DE should be the number of characters to skip.

291D

ADD HL,DE 19

Add the number of characters to skip (held in DE) to the simple variables pointer in HL

291E-291F

JR 2906H JR SVAR18 E6

Loop back to 2906H until all of the simple variables have been checked

2920 ARYVA2

POP BC C1

Clean up the STACK

2921 ARYVAR

EX DE,HL EB

Load DE with the value of the array variables pointer (ARTVAR) in HL

2922-2924

LD HL,(40FDH) LD HL,(STREND) 2A FD 40

Load HL with the end of the arrays / start of free memory pointer.
Note: 40FDH-40FEH holds Free memory pointer

2925

EX DE,HL EB

Exchange the value of the array variables pointer in DE with the value of the free memory pointer in HL

2926

RST 18H COMPARDF

We need to see if we are donee with arrays, so we check to see if the array variables pointer in HL is the same as the free memory pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2927-2929

JP Z,296BH JP Z,GRBPASCA 6B 29

Jump if the array variables pointer in Register HL is the same as the start of the free memory pointer in DE

292A

LD A,(HL) 7E

Load Register A with the number type flag at the location of the array variables pointer in HL

292B

INC HL 23

Bump the value of the array variables pointer in HL

292C-292E

CALL 09C2H CALL MOVRMCD C2 09

Get the length of the array into Register Pair BC via a CALL to 09C2H (which loads a SINGLE PRECISION value pointed to by HL into Register Pairs BC and DE)

292F

PUSH HL E5

Save the pointer to the DIMS to the STACK

2930

ADD HL,BC 09

Add the value of the offset to the next array in BC to the value of the array variables pointer in HL

2931-2932

CP 03H FE 03

Check to see if the array being examined is a string. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2933-2934

JR NZ,2920H JR NZ,ARYVA220 EB

If the array being examined isn’t a string then skip it via a JUMP to 2920H

2935-2937

LD (40D8H),HL LD (TEMP3),HL 22 D8 40

Save the address of the end of the array being examined.
Note: 40D8H-40D9H holds Temporary storage location

2938

POP HL E1

Get the value of the array variables pointer from the STACK and put it in HL

2939

LD C,(HL) 4E

Load Register C with the number of subscripts for the array at the location of the array variables pointer in HL

293A-293B

LD B,00H 06 00

Zero Register B so that BC holds the number of dimensions

293C

ADD HL,BC 09

Add the number of subscripts in the array in BC to the value of the array variables pointer in HL

293D

ADD HL,BC 09

Add the number of subscripts in the array in BC to the value of the array variables pointer in HL. Now we should be past the DIMs because we added twice the DIMs and they are 2 bytes each.

293E

INC HL 23

Bump the value of the array variables pointer in HL one more time to account for #DIMs.

293F ARYSTR

EX DE,HL EB

Load DE with the value of the current position in the array variables pointer in HL

2940-2942

LD HL,(40D8H) LD HL,(TEMP3) 2A D8 40

Load HL with the address of the end of this array.
Note: 40D8H-40D9H holds Temporary storage location

2943

EX DE,HL EB

Swap DE and HL so that HL now points to the current position

2944

RST 18H COMPARDF

We need to test for the end of the array space so we need to check to see if the array variables pointer in HL is the same as the address of the next array in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2945-2946

JR Z,2921H JR Z,ARYVAR28 DA

If the Z FLAG is set then we are at the end of an array so JUMP to 2921H to try the next array

2947-2948

LD BC,293FH LD BC,ARYSTR 01 3F 29

Load BC with a return address of 293FH

294A DVAR2

PUSH BC C5

Save the value in BC to the STACK

294B DVAR and DVARS

XOR A AF

Zero Register A so we can test for a null string

294C

OR (HL) B6

Load Register A with the length of the string at the location of the array variables pointer in HL

294D

INC HL 23

Bump the value of the array variables pointer in HL

294E

LD E,(HL) 5E

Load Register E with the LSB of the string’s address at the location of the array variables pointer in HL

294F

INC HL 23

Bump the value of the array variables pointer in HL

2950

LD D,(HL) 56

Load Register D with the MSB of the string’s address at the location of the array variables pointer in HL. DE should now point to the value of the array.

2951

INC HL 23

Bump the value of the array variables pointer in HL

2952

RET Z C8

Return if the string’s length in Register A is equal to zero

2953
2954

LD B,H
LD C,L 44

Let BC = HL

2955-2957

LD HL,(40D6H) LD HL,(FRETOP) 2A D6 40

Load HL with the location of the the top of string free space.
NOTE: 40D6H-40D7H holds the next available location in string space pointer

2958

RST 18H COMPARDF

We need to see if this string’s pointer is LESS than the top of free string space by checking to see if the string’s address in DE is in string space, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2959
295A

LD H,B
LD L,C 60

Let HL = BC

295B

RET C D8

If this string’s pointer is NOT less than the top of string free space, then there is no need to continue working on it, so RETurn

295C

POP HL E1

Get the return address from the STACK and put it in HL

295D

EX (SP),HL E3

Swap (SP) and HL so that the return address is back on the STACK and HL holds the maximum number seen

295E

RST 18H COMPARDF

Now we need to check to see if the string’s address in DE is below the start of string space pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

295F

EX (SP),HL E3

Swap (SP) and HL so that the return address is back in HL and the STACK holds the maximum number seen

2960

PUSH HL E5

Save the return address in HL to the STACK

2961
2962

LD H,B
LD L,C 60

Let HL = BC

2963

RET NC D0

Return if the string’s address in DE is below the string space pointer

2964

POP BC C1

Get the return address from the STACK and put it in BC

2965

POP AF F1

Clean up the STACK (remove the MAX SEEN)

2966

POP AF F1

Clean up the STACK (remove the VARIABLE POINTER)

2967

PUSH HL E5

Save the value of the array variables pointer in HL to the STACK

2968

PUSH DE D5

Save the new MAX pointer in DE to the STACK

2969

PUSH BC C5

Save the value of the return address in BC to the STACK

296A

RET C9

RETurn to CALLer

If we are here, we have made one complete pass through the string variables.

296B GRBPAS

POP DE D1

Load DE with the address of the last string put into the temporary string work area (aka the MAX pointer)

296C

POP HL E1

Get the variable pointer from the STACK and put it in HL

296D

LD A,L 7D

Load Register A with the LSB of the variable pointer in Register L

296E

OR H B4

Combine the MSB of the temporary string work area pointer in Register H with the LSB of the temporary string work area pointer in Register A

296F

RET Z C8

If HL=0 then we are at the end of the garbage collection, so return

2970

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL, currently just past the string descriptor

2971

LD B,(HL) 46

Load Register B with the MSB of the string’s address at the location of the temporary string work area pointer in HL

2972

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL

2973

LD C,(HL) 4E

Load Register C with the LSB of the string’s address at the location of the temporary string work area pointer in HL. BC will now point to the string data.

2974

PUSH HL E5

Save the value of the temporary string work area pointer in HL to the STACK. This will be needed to update the pointer after the string is moved.

2975

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL

2976

LD L,(HL) 6E

Load Register L with the string’s length at the location of the temporary string work area pointer in HL

2977-2978

LD H,00H 26 00

Zero Register H so that HL is now the string’s character count

2979

ADD HL,BC 09

Add the length of the string in HL to the string’s address in BC. HL now points just beyond the string.

297A

LD D,B 50

Load Register D with the MSB of the string’s address in Register B

297B

LD E,C 59

Load Register E with the LSB of the string’s address in Register C. DE now is the original pointer to the string.

297C

DEC HL 2B

Decrement the value of the string’s ending address in HL to avoid moving one beyond the string

297D

LD B,H 44

Load Register B with the MSB of the string’s ending address in Register H

297E

LD C,L 4D

Load Register C with the LSB of the string’s ending address in Register L. BC now points to the top of the string

297F-2981

LD HL,(40D6H) LD HL,(FRETOP) 2A D6 40

Load HL with the top of free space.
NOTE: 40D6H-40D7H holds the next available location in string space pointer

2982-2984

CALL 1958H CALL BLTUCCD 58 19

Move the string from the temporary storage location to string space

2985

POP HL E1

Get back the pointer to the description of the variable from the STACK and put it in HL

2986

LD (HL),C 71

Save the LSB of the string’s permanent address (held in Register C) to (HL)

2987

INC HL 23

Bump the value of the temporary string work area pointer in HL

2988

LD (HL),B 70

Save the MSB of the string’s permanent address (held in Register C) to (HL)

2989

LD L,C 69

Load Register L with the LSB of the string’s address in Register C

298A

LD H,B 60

Load Register H with the MSB of the string’s address in Register B. Register Pair HL will now be the new pointer to the string.

298B

DEC HL 2B

Decrement the string’s address in HL to adjust FRETOP

298C-298E

JP 28E9H JP FNDVARC3 E9 28

Jump to 28E9H to try to find the high again.

298F-29C5 – STRING ADDITION ROUTINE – Concatenate two strings – “CAT”

This routine concatenates two strings. The first is pointed to by FACLO and HL points to the character after the “+” sign in on the command line.

298F CAT

PUSH BC C5

Save the precedence/operator value in BC to the STACK

2990

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2991-2993

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the first string’s VARPTR (from ACCumulator)

2994

EX (SP),HL E3

Exchange the value of the first string’s VARPTR in HL with the value of the current BASIC program to the STACK

2995-2997

CALL 249FH CALL EVALCD 9F 24

GOSUB to 249FH to evaluate the expression at the location of the current BASIC program pointer in HL

2998

EX (SP),HL E3

Exchange the value of the current BASIC program pointer in HL with the value of the first string’s VARPTR to the STACK

2999-299B

CALL 0AF4H CALL CHKSTRCD F4 0A

Go make sure the current result in ACCumulator is a string

299C

LD A,(HL) 7E

Load Register A with the first string’s length at the location of the first string’s VARPTR in HL

299D

PUSH HL E5

Save the value of the first string’s descriptor (VARPTR) in HL to the STACK

299E-29A0

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the second string’s VARPTR in ACCumulator

29A1

PUSH HL E5

Save the second string’s VARPTR in HL to the STACK

29A2

ADD A,(HL) 86

Add the length of the second string at the location of the second string’s VARPTR in HL to the length of the first string in Register A

29A3-29A4

LD E,1CH 1E 1C

Load Register E with a ?LS ERROR code

in case the two string lengths are not less than 256.

29A5-29A7

JP C,19A2H JP C,ERRORDA A2 19

Display a ?LS ERROR message if the combined lengths of the strings is greater than 255

29A8-29AA

CALL 2857H CALL STRINICD 57 28

Go make sure that there is enough string space for the new string

29AB

POP DE D1

Get the second string’s VARPTR from the STACK and put it in DE

29AC-29AE

CALL 29DEH CALL FRETMPCD DE 29

Go update the temporary string work area

29AF

EX (SP),HL E3

Exchange the second string’s VARPTR in HL with the first string’s VARPTR to the STACK

29B0-29B2

CALL 29DDH CALL FRETM2CD DD 29

Go update the temporary string work area

29B3

PUSH HL E5

Save the value of the first string’s VARPTR in HL to the STACK

29B4-29B6 INCSTR

LD HL,(40D4H) LD HL,(DSCTMP+1) 2A D4 40

Load HL with the pointer to the first string’s address

29B7

EX DE,HL EB

Load DE with the first string’s address in HL

29B8-29BA

CALL 29C6H CALL MOVINSCD C6 29

Go move the first string to its temporary storage location

29BB-29BD

CALL 29C6H CALL MOVINSCD C6 29

Go move the second string to its temporary storage location

29BE-29C0

LD HL,2349H LD HL,TSTOP 21 49 23

Load HL with the return address

29C1

EX (SP),HL E3

Exchange the value of the return address in HL with the value of the current BASIC program pointer to the STACK

29C2

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

29C3-29C5

JP 2884H JP PUTNEWC3 84 28

Jump to 2884H to RETurn to TSTOP

29C6-29D6 – STRING ROUTINE – This will move strings using the STACK – “MOVINS”

On entry, the STACK should have the count/source address and DE should have the destination address

29C6 MOVINS

POP HL E1

Load HL with the value of the return address to the STACK

29C7

EX (SP),HL E3

Swap (SP) and HL so that the return address is now at the top of the STACK and the string’s descriptor/VARPTR is in Register Pair HL.

29C8 – STRING MOVE ROUTINE
On entry HL points to the string control block for the string to be moved, and DE contains the destination address. All registers are used. The string length and address are not moved. String control blocks have the format: X=String Length; ADDR = String Address.

29C8

LD A,(HL) 7E

Load Register A with the string’s length at the location of the string’s VARPTR in HL

29C9

INC HL 23

Bump the value of the string’s VARPTR in HL

29CA

LD C,(HL) 4E

Load Register C with the LSB of the string’s address at the location of the string’s VARPTR in HL

29CB

INC HL 23

Bump the value of the string’s VARPTR in HL

29CC

LD B,(HL) 46

Load Register B with the MSB of the string’s address at the location of the string’s VARPTR in HL. BC now points to the string data.

29CD

LD L,A 6F

Load Register L with the string’s length in Register A

29CE MOVSTR

INC L 2C

Increment the value of the string’s length in Register L in preparation for the next instruction which is a loop.

29CF MOVLP

DEC L 2D

Decrement the value of the string’s length in Register L

29D0

RET Z C8

If L hits zero then we have moved all the characters, so RETurn

29D1

LD A,(BC) 0A

If we are here then we still have characters to move. First, load Register A with the character at the location of the string pointer in BC

29D2

LD (DE),A 12

Save the character in Register A at the location of the string storage pointer in DE

29D3

INC BC 03

Bump the value of the string pointer in BC

29D4

INC DE 13

Bump the value of the string storage pointer in DE

29D5-29D6

JR 29CFH JR MOVLP18 F8

Loop until the string has been completely moved

29D7-29F4 – STRING ROUTINE – “FRESTR”

According to the original ROM source code, FRETMP is passed a pointer to a string descriptor in Register Pair DE and is returned in Register Pair HL. All the other registers are modified. A check to is made to see if the string descriptor in Register Pair DE points to is the last temporary descriptor allocated by PUTNEW. If so, the temporary is freed up by the updating of TEMPPT. If a temporary is freed up, a further check is made to see if the string data that that string temporary pointed to is the the lowest part of string space in use. If so, FRETMP is updated to reflect the fact that that space is no longer in use.

This routine is a contination of VAL , FRE , and PRINT processing. A jump to here would include the need to get a string’s VARPTR and put it in HL.

29D7-29D9 FRESTR

CALL 0AF4H CALL CHKSTRCD F4 0A

GOSUB to 0AF4H to make sure that the current result in REG l is a string

29DA-29DC FREFAC

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the string’s VARPTR in ACCumulator

29DD FRETM2

EX DE,HL EB

Load DE with the value of the string’s VARPTR in HL

29DE-29E0 FRETMP

CALL 29F5H CALL FRETMSCD F5 29

Check to see if the string is the last entry in the temporary string work area

29E1

EX DE,HL EB

Load HL with the value of the string’s VARPTR in DE

29E2

RET NZ C0

Return if the string isn’t the last entry in the temporary string work area

29E3

PUSH DE D5

Save the value of the string’s VARPTR in DE to the STACK

29E4

LD D,B 50

Load Register D with the MSB of the string’s address in Register B

29E5

LD E,C 59

Load Register E with the LSB of the string’s address in Register C. DE now points to the string.

29E6

DEC DE 1B

Decrement the value of the string’s address in DE

29E7

LD C,(HL) 4E

Load Register C with the string’s length at the location of the string’s VARPTR in HL

29E8-29EA

LD HL,(40D6H) LD HL,(FRETOP) 2A D6 40

Load HL with the next available location in string space pointer for the purpose of testing to see if this is the FIRST one in the string space.
Note: 40D6H-40D7H holds the next available location in string space pointer

29EB

RST 18H COMPARDF

We need to see if the current string is the last one defined in the string area by seeing if the string’s address in DE is the same as the next available location in string space pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

29EC-29ED

JR NZ,29F3H JR NZ,NOTLST20 05

Jump forward to 29F3H if the string’s address in DE isn’t the same as the next available location in string space pointer in HL

29EE

LD B,A 47

If is the last one defined then we need to update the current string pointer so first we load Register B with the value in Register A

29EF

ADD HL,BC 09

Add the length of the string in BC to the next available location in string space pointer in HL

29F0-29F2

LD (40D6H),HL LD (FRETOP),HL 22 D6 40

Save the adjusted next available location in string space pointer in HL.
Note: 40D6H-40D7H holds the next available location in string space pointer

29F3 NOTLST

POP HL E1

Get the string’s VARPTR from the STACK and put it in HL

29F4

RET C9

RETurn to CALLer

29F5-2A02 – STRING ROUTINE – – “FRETMS”
Test to see if the string in DE is the last string used in the temporary string work area.

29F5-29F7 FRETMS

LD HL,(40B3H) LD HL,(TEMPPT) 2A B3 40

Load HL with the temporary string work area pointer.
Note: 40B3H-40B4H holds the next available location in the temporary string work area pointer

29F8

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL which backs up two words

29F9

LD B,(HL) 46

Load Register B with the MSB of the string’s address at the location of the temporary string work area pointer in HL

29FA

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL

29FB

LD C,(HL) 4E

Load Register C with the LSB of the string’s address at the location of the temporary string work area pointer in HL

29FC

DEC HL 2B

Decrement the value of the temporary string work area pointer in HL

29FD

RST 18H COMPARDF

We want to see if Register Pairr DE points to the last by checking to see if the string’s VARPTR in DE matches the temporary string work area pointer in HL, so we call the COMPARE DE:HL routine at RST 18H.
NOTE:

• The RST 18H routine The result of the comparison is returned in the status Register as: CARRY SET=HL<DE; NO CARRY=HL>DE; NZ=Unequal; Z=Equal.

29FE

RET NZ C0

If the Z FLAG is set then we are done freeing space, so RETURN

29FF-2A01

LD (40B3H),HL LD (TEMPPT),HL 22 B3 40

Save the value of the temporary string work area pointer in HL.
Note: 40B3H-40B4H holds the next available location in the temporary string work area pointer

2A02

RET C9

RETurn to CALLer

2A03-2A0E – LEVEL II BASIC LEN ROUTINE – “LEN”

2A03-2A05 LEN

LD BC,27F8H LD BC,SNGFLT 01 F8 27

Load BC with the return address of 27F8H

2A06

PUSH BC C5

Save the return address of 27F8H (in BC) to the STACK

2A07-2A09 LEN1

CALL 29D7H CALL FRESTRCD D7 29

GOSUB to 29D7H to free up the temporary variable pointed to by FACLO

2A0A

XOR A AF

Zero Register A so as to force a numeric flag

2A0B

LD D,A 57

Zero Register D so that DE can be used when E is set.

2A0C

LD A,(HL) 7E

Load Register A with the string’s length at the location of the string’s VARPTR in HL

2A0D

OR A B7

Set the flags according to the string’s length in Register A

2A0E

RET C9

RETurn to CALLer

2A0F-2A1E – LEVEL II BASIC ASC ROUTINE – “ASC”

2A0F-2A11 ASC

LD BC,27F8H LD BC,SNGFLT 01 F8 27

Load BC with the return address of 27F8H

2A12

PUSH BC C5

Save the return address of 27F8H (in BC) to the STACK

2A13-2A15 ASC2

CALL 2A07H CALL LEN1CD 07 2A

GOSUB to 2A07H (which itself is a GOSUB to 29D7H) to get string’s VARPTR into HL and the string’s length into Register A

2A16-2A18

JP Z,1E4AH JP Z,FCERRCA 4A 1E

If the Z FLAG is set, then this was a null string (bad argument), so display a ?FC ERROR

2A19

INC HL 23

Bump the value of the string’s VARPTR in HL

2A1A

LD E,(HL) 5E

Load Register E with the LSB of the address of the string’s data at the location of the string’s VARPTR in HL

2A1B

INC HL 23

Bump the value of the string’s VARPTR in HL

2A1C

LD D,(HL) 56

Load Register D with the MSB of the address of the string’s data at the location of the string’s VARPTR in HL

2A1D

LD A,(DE) 1A

Load Register A with the first character at the location of the string pointer in DE

2A1E

RET C9

RETurn to CALLer

2A1F-2A2E – LEVEL II BASIC CHR$ ROUTINE – “CHR$”

2A1F-2A20 CHR$

LD A,01H 3E 01

Load Register A with the length of the string to be created

2A21-2A23

CALL 2857H CALL STRINICD 57 28

GOSUB to 2857H to save the string’s length in Register A and value and set up the string’s address

2A24-2A26

CALL 2B1FH CALL CONINTCD 1F 2B

GOSUB to 2B1FH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE

2A27-2A29 SETSTR

LD HL,(40D4H) LD HL,(DSCTMP+1) 2A D4 40

Load HL with the temporary string’s address

2A2A

LD (HL),E 73

Save the character in Register E at the location of the string pointer in HL

2A2B FINBCK

POP BC C1

Clean up the STACK so that the RETURN address is another one that is next in the STACK.

2A2C-2A2E

JP 2884H JP PUTNEWC3 84 28

Jump to 2884H

2A2F-2A60 – LEVEL II BASIC STRING$ ROUTINE – “STRNG$”

2A2F

RST 10H CHRGETD7

We have the STRING$ command, but now we need the next character so we call a RST 10H to bump the value of the current BASIC program pointer until it points to the next character, call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2A30-2A31

RST 08H⇒ 28 SYNCHK “(“ CF 28

Since the character at the location of the current BASIC program pointer in HL must be a ( , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2A32-2A34

CALL 2B1CH CALL GETBYTCD 1C 2B

This will get the string length required (which we will call “N”) via a GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE

2A34

DEC HL 2B

Backspace the code string. This is a Z-80 trick because this code was part of the above call instruction

2A35

PUSH DE D5

Save the string’s length (“N”) (currently in DE) to the STACK

2A36-2A37

RST 08 ⇒ 2C SYNCHK “,” CF 2C

Now we have STRING$(nnn so the next character needs to be a , . To test for the character at the location of the current BASIC program pointer in HL being a , , call the COMPARE SYMBOL routine which compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call. If there is a match, control is returned to address of the RST 08 instruction + 2 with the next symbol in the A Register and HL incremented by one. If the two characters do not match, a syntax error message is given and control returns to the Input Phase)

2A38-2A3A

CALL 2337H CALL FRMEVLCD 37 23

Now we have STRING$(xxx, and an expression so GOSUB to 2337H to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in ACCumulator

2A3B-2A3C

RST 08H⇒ 29 SYNCHK “)” CF 29

Now we have STRING$(nnn,X . Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2A3D

EX (SP),HL E3

We are now done with getting STRING$(nnn,X) . Next we must exchange the value of the current BASIC program pointer in HL with the string’s length (“N”) in the STACK

2A3E

PUSH HL E5

Save the string’s length (“N”) in HL to the STACK so that we can test it to make sure it is an integer

2A3F

RST 20H GETYPEE7

We need to check the value of the current data type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in ACCumulator and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH). The results are returned as follows:

• Integer = NZ/C/M/E and A is -1
• String = Z/C/P/E and A is 0
• Single Precision = NZ/C/P/O and A is 1
• and Double Precision is NZ/NC/P/E and A is 5.

2A40-2A41

JR Z,2A47H JR Z,STRSTR28 05

If that test shows “N” is a a STRING, jump to down to 2A47H

2A42-2A44

CALL 2B1FH CALL CONINTCD 1F 2B

We now know that “N” is at least a number, so we GOSUB to 2B1FH to convert the current result in ACCumulator to an integer and return with the 8-bit result in Register A

2A45-2A46

JR 2A4AH JR CALSPA18 03

Skip the next instruction (which would load the string address and 1st character) by jumping to 2A4AH

2A47-2A49 STRSTR

CALL 2A13H CALL ASC2CD 13 2A

Go get the first character in the string and return with it in Register A. This is the character that will be repeated

2A4A CALSPA

POP DE D1

Get the “N” from the STACK and put it in DE (well, actually, Register E)

2A4B

PUSH AF F5

Save the character for the string (held in Register A) to the STACK

2A4C SPACE2

PUSH AF F5

and then save it to the STACK again

2A4D

LD A,E 7B

Load Register A with “N” (held in Register E)

2A4E-2A4F

CALL 2857H CALL STRINICD 57 28

GOSUB to 2857H to allocate N bytes in the temporary string work area

2A51

LD E,A 5F

Load Register E with “N” (held in Register A)

2A52

POP AF F1

Get the character for the string (“X”) from the STACK and put it in Register A

2A53

INC E 1C

To set the status flags we need to increase and then decrease E. First, bump the value of the string’s length in Register E

2A54

DEC E 1D

. and then decrement the string’s length in Register E

2A55-2A56

JR Z,2A2BH JR Z,FINBCK28 D4

If “N” was zero (so that the string is now complete), jump back to 2A2BH

2A57-2A59

LD HL,(40D4H) LD HL,(DSCTMP+1) 2A D4 40

If we are here, we have not finished building the STRING$ string so now we load HL with the string’s address and get ready to loop

2A5A SPLP$

LD (HL),A 77

Save the character in Register A (“X”) at the location of the string pointer in HL

2A5B

INC HL 23

Bump the value of the string pointer in HL

2A5C

DEC E 1D

Decrement the string’s length in Register E

2A5D-2A5E

JR NZ,2A5AH20 FB

Loop back to 2A5AH to keep filling (HL) until the string of X’s has been completed

2A5F-2A60

JR 2A2BH JR FINBCK18 CA

Jump back to 2A2BH to put the temp description to finish

2A61-2A90 – LEVEL II BASIC LEFT$( ROUTINE – “LEFT$”

On entry, HL=address of LEFT$$, the STACK = string address, STACK+1 = n, and DE = code string address.

2A61-2A63 LEFT$

CALL 2ADFH CALL PREAMCD DF 2A

Go check the syntax. The character at the location of the current BASIC program pointer in HL must be a )

2A64

XOR A AF

Zero Register A because the string pointer never changes

2A65 LEFT3

EX (SP),HL E3

Exchange the value of the current BASIC program pointer in HL with the string’s VARPTR to the STACK

2A66

LD C,A 4F

Zero Register C

2A67-2A68

LD A,0E5H 3E E5

Z-80 Trick. By adding a 3E at 2A67, it masks out 2A68H if passing through by making the Z-80 think the instruction is LD A,0E5H

2A68 LEFTUS

PUSH HL E5

Save the value of the string’s VARPTR in HL to the STACK. This is actually a dummy push to offset for the extra POP command in PUTNEW

2A69 LEFT2

PUSH HL E5

Save the value of the string’s VARPTR in HL to the STACK

2A6A

LD A,(HL) 7E

Load Register A with the string’s length at the location of the string’s VARPTR in HL

2A6B

CP B B8

Check to see if the new string’s length in Register B is greater than the string’s length in Register A. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2A6C-2A6D

JR C,2A70H JR C,ALLSTR38 02

Jump to 2A70H if the new string’s length in Register B is greater than the string’s length in Register A

2A6E

LD A,B 78

Load Register A with the new string’s TRUNCATED length in Register B

2A6F-2A71

LD DE,000EH 11 0E 00

Z-80 Trick. This is a LD DE,000EH which is irrelevant and only executed if continuing through. If, however, one was to jump to 2A70H instead, a proper opcode would occur

2A70-2A7l ALLSTR

LD C,00H 0E 00

Since Register C tracks the offset, Zero Register C

2A72

PUSH BC C5

Save the offset in BC to the STACK

2A73-2A75

CALL 28BFH CALL GETSPACD BF 28

Go see if there is enough string space for the new string

2A76

POP BC C1

Get the offset from the STACK and put it in BC

2A77

POP HL E1

Get the string’s VARPTR from the STACK and put it in HL

2A78

PUSH HL E5

Save the string’s VARPTR in HL to the STACK

2A79

INC HL 23

Bump HL to now point to the address of the string

2A7A

LD B,(HL) 46

Load Register B with the LSB of the string’s address at the location of the string’s VARPTR in HL

2A7B

INC HL 23

Bump the value of the string’s VARPTR in HL

2A7C

LD H,(HL) 66

Load Register H with the MSB of the string’s address at the location of the string’s VARPTR in HL

2A7D

LD L,B 68

Load Register L with the LSB of the string’s address in Register B

2A7E-2A7F

LD B,00H 06 00

Zero Register B so that BC can be used

2A80

ADD HL,BC 09

Add the string’s length in BC to the string’s address in HL

2A81

LD B,H 44

Load Register B with the MSB of the string’s ending address in Register H

2A82

LD C,L 4D

Load Register C with the LSB of the string’s ending address in Register L

2A83-2A85

CALL 285AH CALL STRAD2CD 5A 28

Go save the string’s length (held in A) and the string’s starting address (held in DE)

2A86

LD L,A 6F

Load Register L with the string’s length (i.e., the number of characters to move) held in Register A

2A87-2A89

CALL 29CEH CALL MOVSTRCD CE 29

Go move L characers frm BC to DE

2A8A

POP DE D1

Clean up the STACK

2A8B-2A8D

CALL 29DEH CALL FRETMPCD DE 29

Go update the temporary string work area

2A8E-2A90

JP 2884H JP PUTNEWC3 84 28

Jump to 2884H to put the temp variable in the temp list

2A91-2A99 – LEVEL II BASIC RIGHT$ ROUTINE – “RIGHT$”

2A91-2A93

CALL 2ADFH CALL PREAMCD DF 2A

Go check the syntax. The character at the location of the current BASIC program pointer in HL must be a )

2A94

POP DE D1

Get the string’s VARPTR from the STACK and put it in DE

2A95

PUSH DE D5

Save the string’s VARPTR in DE to the STACK

2A96

LD A,(DE) 1A

Load Register A with the string’s length (held at the location of the string’s VARPTR in DE)

2A97

SUB B 90

Subtract the new string’s length in Register B from the string’s length in Register A to isolate the number of bytes

2A98-2A99

JR 2A65H JR LEFT318 CB

Jump to the LEFT$( code

2A9A-2AC4 – LEVEL II BASIC MID$ ROUTINE – “MID$”

The original ROM source code clarifies that if the number provided is greater than the actual length of the string, a NULL value is returned. If the second number (the number of characters) exceeds the end of the string, the maximum amount of available characters are returned.

2A9A MID$

EX DE,HL EB

Load HL with the value of the current BASIC program pointer (held in DE)

2A9B

LD A,(HL) 7E

Load Register A with the terminal character, currently held at the location of the current BASIC program pointer in HL

2A9C-2A9E

CALL 2AE2H CALL PREAM2CD E2 2A

GOSUB to 2AE2H to get the offset in Register B and the string’s VARPTR in DE

2A9F

INC B 04

We need to set the status flags to correspond to the offset position value so we first bump the value of the string’s position in Register B

2AA0

DEC B 05

… and then we decrement the value of the string’s offset position in Register B

2AA1-2AA3

JP Z,1E4AH JP Z,FCERRCA 4A 1E

If the starting position (held in B) is 0, display ?FC ERROR

2AA4

PUSH BC C5

Save the value of the offset position (held in Register B) to the STACK

2AA5-2AA6

LD E,0FFH 1E FF

Load Register E with the default string’s length of 256 in case no number of bytes are given

2AA7-2AA8

CP 29H CP “)” FE 29

More syntax checking. Here we need to test for a ) at the location of the current BASIC program pointer. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2AA9-2AAA

JR Z,2AB0H JR Z,MID228 05

Jump to 2AB0H if the character at the location of the current BASIC program pointer in Register A is a )

2AAB-2AAC

RST 08H⇒ 2C SYNCHK “,” CF 2C

If it wasn’t a ) , it had best be a , so we need to test the character at the location of the current BASIC program pointer in HL by calling the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2AAD-2AAF

CALL 2B1CH CALL GETBYTCD 1C 2B

Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE. Now the byte count is in DE as an integer

2AB0-2AB1

RST 08H⇒ 29 SYNCHK “)” CD 29

Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2AB2

POP AF F1

Get the offset from the STACK and put it in Register A

2AB3

EX (SP),HL E3

Exchange the value of the current BASIC program pointer in HL with the value of the string’s VARPTR to the STACK

2AB4-2AB6

LD BC,2A69H LD BC,LEFT2 01 69 2A

Load BC with 2A69H as the return address (which is in the LEFT$ routine)

2AB7

PUSH BC C5

Save the return address in BC to the STACK

2AB8

DEC A 3D

Decrement the value of the requested offset in Register A so that we have a starting position minus 1

2AB9

CP (HL) BE

Compare the string’s length at the location of the string’s VARPTR in HL with the value of the offset in Register A. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2ABA-2ABB

LD B,00H 06 00

Zero Register B

2ABC

RET NC D0

If the offset pointer ispast the end of the string we are going to return a null

2ABD

LD C,A 4F

Load Register C with the offset in Register A

2ABE

LD A,(HL) 7E

Load Register A with the string’s length at the location of the string’s VARPTR in HL

2ABF

SUB C 91

Subtract the index (the second argument) in Register C from the string’s length in Register A

2AC0

CP E BB

Compare the new string’s length in Register E with the adjusted string’s length in Register A to see if we are going to truncate. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2AC1

LD B,A 47

Load Register B with the calculated string’s length in Register A

2AC2

RET C D8

If we are not going to truncate, then just use the partial string we already have and Return to 2A69H

2AC3

LD B,E 43

Load Register B with the new string’s truncated length in Register E

2AC4

RET C9

Return to 2A69H aka LEFT2

2AC5-2ADE – LEVEL II BASIC VAL ROUTINE – “VAL”

2AC5-2AC7 VAL

CALL 2A07H CALL LEN1CD 07 2A

Go get the string’s length in Register A and the string’s VARPTR in HL

2AC8-2ACA

JP Z,27F8H JP Z,SNGFLTCA F8 27

Jump to 27F8H if the string’s length in Register A is equal to zero

2ACB

LD E,A 5F

Load Register E with the string’s length at the location of the string’s VARPTR in HL.

The original ROM source explains that we need to do some fancy footwork here to handle the case where the two strings are stored next to each other.

2ACC

INC HL 23

Bump the value of the string’s VARPTR in HL

2ACD

LD A,(HL) 7E

Load Register A with the LSB of the string’s address at the location of the string’s VARPTR in HL

2ACE

INC HL 23

Bump the value of the string’s VARPTR in HL

2ACF

LD H,(HL) 66

Load Register H with the MSB of the string’s address at the location of the string’s VARPTR in HL

2AD0

LD L,A 6F

Load Register L with the LSB of the string’s address in Register A

2AD1

PUSH HL E5

Save the value of the string’s address in HL to the STACK

2AD2

ADD HL,DE 19

Add the string’s length in DE to the string’s address in HL

2AD3

LD B,(HL) 46

Load Register B with the last character of the string at the location of the string pointer in HL

2AD4

LD (HL),D 72

Save the zero in Register D at the location of the string pointer in HL

2AD5

EX (SP),HL E3

Exchange the string’s ending address in HL with the string’s address to the STACK

2AD6

PUSH BC C5

Save the last character of the string in Register B to the STACK

2AD7

LD A,(HL) 7E

Load Register A with the first character of the argument

2AD8-2ADA

CALL 0E65H CALL FINDBLCD 65 0E

Call the ASCII TO DOUBLE routine at 0E65H (which converts the ASCII string pointed to by HL to its double precision equivalent; with output left in ACCumulator)

2ADB

POP BC C1

Get the modified character of the next string into Register B

2ADC

POP HL E1

Get the pointer to the modified character back into HL

2ADD

LD (HL),B 70

Restore the character.

2ADE

RET C9

RETurn to CALLer

2ADF-2A6 – STRING ROUTINE – “PREAM”

This is called by LEFT$ , MID$ , and RIGHT$ to test for the ending “)” character. On entry, the STACK has the string address, byte count, and return address. On exit the STACK has the string address, DE and B each have the byte count.

2ADF PREAM

EX DE,HL EB

Load HL with the value of the current BASIC program pointer in DE

2AE0-2AE1

RST 08H⇒ 29 SYNCHK “)” CF 29

Since the character at the location of the current BASIC program pointer in HL must be a ) , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2AE2 PREAM2

POP BC C1

Get the return address from the STACK and put it in BC

2AE3

POP DE D1

Get the number of bytes to isolate from the string (from the STACK) and put it in DE

2AE4

PUSH BC C5

Save the return address in BC to the STACK

2AE5

LD B,E 43

Load Register B with the number of bytes in Register E

2AE6

RET C9

RETurn to CALLer

2AE7H-2AEE – Process a LEFT-HAND-SIDE MID$ – “ISMID$”

2AE7-2AE8 ISMID$

CP 7AH CP MIDTK-$END FE 7A

This routine is designed to handle a left-size MID$ call. So check to see if the character at the location of the current BASIC program pointer in Register A is trying to process a left hand side MID$. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2AE9-2AEB

JP NZ,1997H JP NZ,SNERRC2 97 19

Display a ?SN ERROR message if that is not what is going on.

2AEC-2AEE

JP 41D9H JP DLHSMDC3 D9 41

JUMP to DOS to see if DOS wants to deal with this.

2AEF-2AF7 – LEVEL II BASIC INP ROUTINE – “FNINP”

2AEF-2AF1 FNINP

CALL 2B1FH CALL CONINTCD 1F 2B

Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the port number in Register A

2AF2-2AF4

LD (4094H),A LD (STAINP+1),A 32 94 40

Save the value of the port number (from Register A) into 4094H, which is in the middle of a routine.

2AF5-2AF1

CALL 4093H CALL STAINP CD 1F 2B

Perform in INP on the channel held in Register A

2AF8-2AFA

JP 27F8H JP SNGFLTC3 F8 27

Evaluate the results and return them

2AF8-2B00 – LEVEL II BASIC OUT ROUTINE – “FNOUT”

2AFB-2AFD FNOUT

CALL 2B0EH CALL SETIOCD 0E 2B

Get the I/O Port Ready

2AFB-2AFD

JP 4096H JP OUTWRDCD 0E 2B

Do the OUT and RETurn

2B01-2B0D – EVALUATE EXPRESSION ROUTINE
“GETINT”
This evaluates an expression and leaves the result in DE as an integer.

2B01 GETINT

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2B02-2B04 GETIN2

CALL 2337H CALL FRMEVLCD 37 23

Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in ACCumulator

2B05 – This routine takes the value from the ACC, converts it to an integer value and places the result in the DE Register Pair. The Z flag will be set if the result in DE is smaller than or equal to 255 (FFH). (DE = INT (ACC)).

2B05 INTFR2

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2B06-2B08

CALL 0A7FH CALL FRCINTCD 7F 0A

Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of ACCumulator are converted from single or double precision to integer and deposited into HL)

2B09

EX DE,HL EB

Load DE with the integer result in HL

2B0A

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2B0B

LD A,D 7A

Load Register A with the MSB of the integer result in Register D

2B0C

OR A B7

Test the value of the MSB in Register A

2B0D

RET C9

RETurn to CALLer

2B0E-2B16 – EVALUATE EXPRESSION ROUTINE – OUT continues here – “SETIO”

2B0E-2B10 SETIO

CALL 2B1CH CALL GETBYTCD 1C 2B

GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the 8-bit value in Register A

2B11-2B13

LD (4094H),A LD (STAINP+1),A 32 94 40

Save the 8-bit value in Register A in the DOS address of 4094H to set up for WAIT

2B14-2B16

LD (4097H),A LD (OUTWRD+1),A 32 97 40

Save the 8-bit value in Register A in the DOS address of 4097H to set up for OUT

2B17-2B1A – CHECK SYNTAX ROUTINE – This checks to see if the next character is a “ and contnues on to 2B1CH if it is, and errors out if it isn’t.

2B17-2B18

RST 08H⇒ 2E SYNCHK “,” CF 2E

Since the character at the location of the current BASIC program pointer in HL must be a “,”, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2B19-2B1A

JR 2B1CH JR GETBYT18 01

Jump forward to 2B1CH

2B1B-2B28 – EVALUATE EXPRESSION ROUTINE – This is called by PRINT TAB – “GTBYTC” .

2B1B GTBYTC

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2B1C – Common Conversion Routine – “GETBYT”

This routine converts a numeric ASCII string pointed to by the HL into a hexadecimal value and places the result in the A register. If the result is larger than 255 (FFH) then an FC ERROR (Illegal function call) will be generated. After execution the HL will point to the delimiter. If the delimiter is a zero byte or a colon (3AH) then the Z flag will be set. Any other delimiter will cause the Z flag to be reset.

2B1C-2B1E GETBYT

CALL 2337H CALL FRMEVLCD 37 23

GOSUB to 2337H to evaluate the formula/expression at the location of the current BASIC program pointer in HL and return with the result in REG l

2B1F-2B21 CONINT

CALL 2B05H CALL INTFR2CD 05 2B

GOSUB to 2B05H to convert the result in ACCumulator to an integer and return with the integer result in DE. Flags are set based on Register D.

2B22-2B24

JP NZ,1E4AH JP NZ,FCERRC2 4A 1E

If the result is greater than 255, display a ?FC ERROR message

2B25

DEC HL 2B

Decrement the value of the current BASIC program pointer in HL

2B26

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2B27

LD A,E 7B

Load Register A with the 8-bit result in Register E so that both A and E have the result.

2B28

RET C9

RETurn to CALLer

2B29-2B2D – LEVEL II BASIC LLIST ROUTINE – “LLIST”

This routine sets the output device flag to PRINTER and then flows through to the LIST command.

2B29-2B2A LLIST

LD A,01H 3E 01

Load Register A with the printer output device code

2B2B-2B2D

LD (409CH),A LD (PRTFLG),A 32 9C 40

Save the value in Register A as the current output device flag.
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer

2B2E-2B74 – LEVEL II BASIC LIST ROUTINE – “LIST”

On entry the STACK has the return address, then the first basic line number to be listed, then the last basic line number to be listed.

2B2E LIST

POP BC C1

Get rid of the the return address on the STACK

2B2F-2B31

CALL 1B10H CALL SCNLINCD 10 1B

Go evaluate the range of line numbers given at the location of the current BASIC program pointer in HL

2B32

PUSH BC C5

Save the address of the first BASIC line (held in BC) to the STACK

2B33-2B35 LIST4

LD HL,FFFFH 21 FF FF

Load HL with a -1. This is because the below loop starts with a INC HL, so as to turn the first line number into 0

2B36-2B38

LD (40A2H),HL LD (CURLIN),HL 22 A2 40

Save the value in HL as the current BASIC line number (which is stored at 40A2H-40A3H).

2B39

POP HL E1

Get the address of the first BASIC line to be listed (from the STACK) and put it in HL

2B3A

POP DE D1

Get the value of the last BASIC line number to be listed (from the STACK) and put it in DE

2B3B

LD C,(HL) 4E

Load Register C with the LSB of the next BASIC line pointer at the location of the memory pointer in HL

2B3C

INC HL 23

Bump the value of the memory pointer in HL

2B3D

LD B,(HL) 46

Load Register B with the MSB of the next BASIC line pointer at the location of the memory pointer in HL

2B3E

INC HL 23

Bump the value of the memory pointer in HL

2B3F

LD A,B 78

Load Register A with the MSB of the next BASIC line pointer in Register B

2B40

OR C B1

Combine the LSB of the next BASIC line pointer in Register C with the MSB of the next BASIC line pointer in Register A. This will let us test for the end of the BASIC program

2B41-2B43

JP Z,1A19H JP Z,READYCA 19 1A

If we are at the elast line, then STOP and JUMP to 1A19H to the READY PROMPT.

2B44-2B46

CALL 41DFH CALL EXCHDSCD DF 41

GOSUB to DOS to see if DOS wants to do anything here.

2B47-2B49

CALL 1D9BH CALL ISCNTCCD 9B 1D

Go scan the keyboard to see if the BREAK key or the shift – @ key was pressed

2B4A

PUSH BC C5

Save the address of the next BASIC line in BC to the STACK

2B4B

LD C,(HL) 4E

We now want to push the line number, but we have to load BC with it first. Load Register C with the LSB of the BASIC line number at the location of the memory pointer in HL

2B4C

INC HL 23

Bump the value of the memory pointer in HL

2B4D

LD B,(HL) 46

Load Register B with the MSB of the BASIC line number at the location of the memory pointer in HL

2B4E

INC HL 23

Bump the value of the memory pointer in HL

2B4F

PUSH BC C5

Save the BASIC line number in BC to the STACK

2B50

EX (SP),HL E3

Swap (SP) and HL so that the line number is now in HL

2B51

EX DE,HL EB

Swap DE and HL so that the last BASIC line number is now in HL

2B52

RST 18H COMPARDF

We need to see if we are outside the last number in the specified range so compare the BASIC line number in DE with the last BASIC line number in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2B53

POP BC C1

Get the pointer to the location on the BASIC program line being processed and put it in BC

2B54-2B56

JP C,1A18H JP C,STPRDYDA 18 1A

If the BASIC line number in DE is greater than the last BASIC line number in HL then we have gone past the end, so we are done processing!

2B57

EX (SP),HL E3

Swap (SP) and HL so that the last BASIC line number is now on the STACK

2B58

PUSH HL E5

Save the address of the next BASIC line in HL to the STACK

2B59

PUSH BC C5

Save the pointer to the location on the BASIC program line being processed to the STACK

2B5A

EX DE,HL EB

Load HL with the BASIC line number (from DE)

2B5B-2B5D

LD (40ECH),HL LD (DOT),HL 22 EC 40

Save the BASIC line number in HL into DOT for use later in EDIT or LIST.
Note: 40ECH-40EDH holds EDIT line number

2B5E-2B60

CALL 0FAFH CALL LINPRTCD AF 0F

Call the HL TO ASCII routine at 0FAFH (which converts the value in the HL (assumed to be an integer) to ASCII and display it at the current cursor position on the video screen) to display the current BASIC line number

2B61-2B62

LD A,20H 3E 20

Load Register A with a space

2B63

POP HL E1

Get the value of the memory pointer from the STACK and put it in HL

2B64-2B66

CALL 032AH CALL OUTDOCD 2A 03

Go send the space in Register A to the current output device

2B67-2B69

CALL 2B7EH CALL BUFLINCD 7E 2B

GOSUB to 2B7EH move the BASIC line at the location of the memory pointer in HL into the input buffer and untokenize the BASIC line

2B6A-2B6C

LD HL,(40A7H) LD HL,(BUFPNT) 2A A7 40

Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer

2B6D-2B6F

CALL 2B75H CALL LISPRTCD 75 2B

Since we need to send the BASIC line in the input buffer to the current output device we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device

2B70-2B72

CALL 20FEH CALL CRDOCD FE 20

Go send a carriage return to the current output device

2B73-2B74

JR 2B33H JR LIST418 BE

Loop back to 2B33H until the listing is complete

2B75-2B7D – DISPLAY MESSAGE ROUTINE – “LISPRT”

This is the PRINT MESSAGE routine which writes string pointed to by HL to the current output device. String must be terminated by a byte of zeros. This call is different from 28A7H because it does not use the literal string pool area, but it does use the same display routine and it takes the same DOS Exit at 41C1H. Uses all registers. This routine can be called without loading the BASIC utility, if a C9H (RET) is stored in 41C1H.

This routine outputs a string to device indicated by device type flag stored at 409CH. String must end with zero byte. On entry, HL registers must point to address of start of string. Calls routine at 032AH.

2B75 “LISPRT”

LD A,(HL) 7E

Load Register A with the character at the location of the memory pointer in HL

2B76

OR A B7

Check to see if the character in Register A is an end of the string character (00H)

2B77

RET Z C8

Return if the character in Register A is an end of the string character

2B78-2B7A

CALL 032AH CALL OUTDOCD 2A 03

Go send the character in Register A to the current output device

2B7B

INC HL 23

Bump the value of the memory pointer in HL

2B7C-2B7D

JR 2B75H JR LISPRT18 F7

Loop back to 2B75H until all of the characters have been sent to the current output device

2B7E-2BC5 – UNTOKENIZE ROUTINE – “BUFLIN”

This routine is called by LIST and EDIT . It moves the line pointed to by HL to the input buffer area and then expands each token into the appropriate key word.

2B7E BUFLIN

PUSH HL E5

Save the BASIC line pointer in HL to the STACK

2B7F-2B81

LD HL,(40A7H) LD HL,(BUFPNT) 2A A7 40

Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer

2B82
2B83

LD B,H
LD C,L 44

LET Register Pair BC = Register Pair HL

2B84

POP HL E1

Get the value of the BASIC line pointer from the STACK and put it in HL

2B85-2B86

LD D,FFH LD D,BUFLEN 16 FF

Load Register D with the maximum length of an untokenized line

2B87-2B88

JR 2B8CH JR PLOOP218 03

Jump forward to 2B8CH into the middle of the move/expand code

2B89 PLOOP

INC BC 03

Top of a loop. Bump the value of the input buffer pointer in BC

2B8A

DEC D 15

Decrement the character count in Register D

2B8B

RET Z C8

Return if 256 characters have been moved into the input buffer

2B8C PLOOP2

LD A,(HL) 7E

Load Register A with the character at the location of the BASIC line pointer in HL

2B8D

OR A B7

Set the status flags to enable us to check to see if the character in Register A is a reserved word (in which case the P FLAG will be set) or an end of the BASIC line character (in which case the Z FLAG will be set)

2B8E

INC HL 23

Bump the value of the BASIC line pointer in HL to the next character in the code string

2B8F

LD (BC),A 02

Save the character at the location of the input buffer pointer (held in Register A)to the memory location held by BC. If the character was a 00H terminator, then the terminator will also be copied.

2B90

RET Z C8

Return if the character in Register A is an end of the BASIC line character

2B91-2B93

JP P,2B89H JP P,PLOOPF2 89 2B

If the character in A is just a regular character (i.e., not a token), then JUMP back to 2B89H

2B94-2B95

CP 0FBH CP SNGQTK FE FB

Check to see if the character in Register A is a ‘ token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2B96-2B97

JR NZ,2BA0H JR NZ,NTQTTK20 08

Jump forward to 2BA0H if the character in Register A isn’t a ‘ token

This is where the infamous ROM bug which can crash Level II sits. It assumes that a ‘ has room to move backwards 4 characters, which it might not!

2B98-2B9B

DEC BC
DEC BC
DEC BC
DEC BC 0B

First, backspace 4 characters to compensat for “:REM” which is otherwise hidden from the user’s view. Decrement the value of the input buffer pointer in BC

2B9C-2B9F

INC D
INC D
INC D
INC D 14

Then, bump the value of the character counter in Register D 4 times

A REM isn’t the only TOKEN with a hidden add-on. ELSE also has a hidden colon in front of it. So let’s now deal with that.

2BA0-2BA1 NRQTTK

CP 95H CP $ELSE FE 95

Check to see if the character in Register A is an ELSE token. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2BA2-2BA4

CALL Z,0B24H CALL Z,DCXVBRTCC 24 0B

If it was an ELSE we need to backspace the expanded buffer pointer to NOT print the hidden “:”. To do this, go back to 0B24H to decrement the value of the input buffer pointer if the character in Register A is an ELSE token

2BA4

DEC BC 0B

This is NOT executed in the regular process of the ROM. This is a mid-instruction jump point from DOS BASIC if the DOS routine which analyzes the INPUT command determines that the routine which called the DOS VECTOR was > the location in ROM for the LIST command

2BA5-2BA6

SUB 7FH D6 7F

Next, we need to get rid of the SIGN BIT and add one, so subtract 7F to get the number of the entry we are looking for in token list

2BA7

PUSH HL E5

Save the value of the BASIC line pointer in HL to the STACK. Register L holds the reserved word number at this point.

2BA8

LD E,A 5F

Load Register E with the character in Register A

2BA9-2BAB

LD HL,1650H LD HL,RESLST 21 50 16

Load HL with the starting address of the reserved words list

2BAC LOPRES

LD A,(HL) 7E

Load Register A with the character at the location of the reserved words list pointer in HL

2BAD

OR A B7

Test the value of the character in Register A. The P FLAG will be set on the first character of each TOKEN because it has the high bit set.

2BAE

INC HL 23

Bump the value of the reserved words list pointer in HL

2BAF-2BB1

JP P,2BACH JP P,LOPRESF2 AC 2B

If the character at the location of the reserved words pointer in Register A doesn’t have bit 7 set then Jump back to 2BACH.

2BB2

DEC E 1D

Decrement the counter

2BB3-2BB4

JR NZ,2BACH JR NZ,LOPRES20 F7

Jump back to 2BACH if this isn’t the reserved word for the token

2BB5-2BB6

AND 7FH E6 7F

Reset bit 7 of the character in Register A by ANDing it against 0111 1111. This is to eliminate the MSB for “EDIT” and for disk I/O

2BB7 MORPUR

LD (BC),A 02

Save the character in Register A at the location of the input buffer pointer in BC

2BB8

INC BC 03

Bump the value of the input buffer pointer in BC

2BB9

DEC D 15

Decrement the value of the character counter in Register D

2BBA-2BBC

JP Z,28D8H JP Z,PPSWRTCA D8 28

If the Z FLAG has been set, then the character counter for the buffer has been exhausted and the buffer is now full, so JUMP back to 28D8H

2BBD

LD A,(HL) 7E

Load Register A with the character at the location of the reserved words pointer in HL

2BBE

INC HL 23

Bump the reserved words pointer in HL

2BBF

OR A B7

Test the value of the character in Register A

2BC0-2BC2

JP P,2BB7H JP P,MORPURF2 B7 2B

Keep getting characters in this reserved word until we hit the next reserved word

2BC3

POP HL E1

Get the value of the BASIC line pointer from the STACK and put it in HL

2BC4-2BC5

JR 2B8CH JR PLOOP218 C6

Jump back to 2B8CH to continue processing the BASIC line being interpreted

2BC6-2BF4 – LEVEL II BASIC DELETE ROUTINE – “DELETE”

2BC6-2BC8 DELETE

CALL 1B10H CALL SCNLINCD 10 1B

GOSUB to 1B10H to evaluate the line numbers at the location of the current BASIC program pointer in HL

2BC9

POP DE D1

Get the value of the last BASIC line number to be deleted (in binary) from the STACK and put it in DE

2BCA

PUSH BC C5

Save the address of the first BASIC line to be deleted in BC to the STACK

2BCB

PUSH BC C5

Save the address of the first BASIC line to be deleted in BC to the STACK AGAIN!

2BCC-2BCE

CALL 1B2CH CALL FNDLINCD 2C 1B

GOSUB to 1B2CH to the SEARCH FOR LINE NUMBER routine which looks for the line number specified in DE so as to get the address of the last line to be deleted.Returns C/Z with the line found in BC, NC/Z with line number is too large and HL/BC having the next available location, or NC/NZ with line number not found, and BC has the first available one after that

2BCF-2BD0

JR NC,2BD6H JR NC,FCERRG30 05

Since the first line number provided MUST be found, if FNDLIN returns with the NC FLAG set (i.e., not found) we must JUMP to 2BD6H to show a ?FC ERROR

2BD1
2BD2

LD D,H
LD E,L 54

Let Register Pair DE = Register Pair HL

2BD3

EX (SP),HL E3

Exchange the last BASIC line’s address in HL with the first BASIC line’s address to the STACK

2BD4

PUSH HL E5

Save the pointer to the first line in range to the STACK

2BD5

RST 18H COMPARDF

We need to check to see if the first BASIC line’s address in HL is greater than or equal to the last BASIC line’s address in DE, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2BD6-2BD8 FCERRG

JP NC,1E4AH JP NC,FCERRD2 4A 1E

Display a ?FC ERROR message if the first BASIC lines address in HL is greater than or equal to the last BASIC line’s address in DE

2BD9-2BDB

LD HL,1929H LD HL,REDDY 21 29 19

Load HL with the starting address of the BASIC READY message

2BDC-2BDE

CALL 28A7H CALL STROUTCD A7 28

Call the WRITE MESSAGE routine at 28A7H to print the message pointed to by HL.

2BDF

POP BC C1

Get the first BASIC line’s address from the STACK and put it in BC

2BE0-2BE2

LD HL,1AE8H LD HL,FINI 21 E8 1A

Load HL with the return address

2BE3

EX (SP),HL E3

Swap (SP) and HL so that HL now points to the next BASIC line’s address …

2BE4 DEL

EX DE,HL EB

and then put it into DE

2BE5-2BE7

LD HL,(40F9H) LD HL,(VARTAB) 2A F9 40

Load HL with the end of the BASIC program pointer.

• Note: 40F9H-40FAH holds the starting address of the simple variable storage area.

2BE8 MLOOP

LD A,(DE) 1A

Load Register A with the character at the location of the memory pointer in DE

2BE9

LD (BC),A 02

Save the character in Register A at the location of the memory pointer in BC

2BEA

INC BC 03

Bump the value of the memory pointer in BC

2BEB

INC DE 13

Bump the value of the memory pointer in DE

2BEC

RST 18H COMPARDF

Now we need to check to see if the memory pointer in DE equals the end of the BASIC program pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2BED-2BEE

JR NZ,2BE8H JR NZ,MLOOP20 F9

Loop back to 2BE8H until the memory pointer in DE equals the end of the BASIC program pointer in HL

2BEF

LD H,B 60

Load Register H with the MSB of the memory pointer in Register B

2BF0

LD L,C 69

Load Register L with the LSB of the memory pointer in Register C

2BF1-2BF3

LD (40F9H),HL LD (VARTAB),HL 22 F9 40

Save the value in HL as the new end of the BASIC program pointer.

• Note: 40F9H-40FAH holds the starting address of the simple variable storage area.

2BF4

RET C9

RETurn to CALLer

2BF5-2C1E – LEVEL II BASIC CSAVE ROUTINE – “CSAVE”

The original ROM source code says that the CSAVE command dump’s BASIC’s core. Three D3H’s are written, followed by a 1 character filename. At the end 3 zeros in a row are written.

2BF5-2BF7 CSAVE

CALL 0284H CALL CWRTONCD 84 02

Calls the WRITE LEADER routine at 0284H (which writes a Level II leader on the cassette unit set in Register A)

2BF8

CALL 2337H CALL FRMEVLCD 37 23

2BFAH Go evaluate the rest of the CSAVE expression at the location of the current BASIC program pointer in HL and return with the result in REG l

2BFB

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK so we can get it back at the end of the routine

2BFC-2BFE

CALL 2A13H CALL ASC2CD 13 2A

Go get the starting address of the filename into DE

2BFF-2C00

LD A,D3H 3E D3

Load Register A with the filename header byte (=D3H which is a “S” with the sign bit on)

2C01-2C03

CALL 0264H CALL CASOUTCD 64 02

the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A Register to the cassette drive selected in the A register), which in this case the filename header byte

2C04-2C06

CALL 0261H CALL TWOCSOCD 61 02

Go write the filename header byte in Register A twice more

2C07

LD A,(DE) 1A

Load Register A with the first character of the filename at the location of the filename pointer in DE

2C08-2C0A

CALL 0264H CALL CASOUTCD 64 02

the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A Register to the cassette drive selected in the A register), which in this case is the filename

2C0B-2C0D

LD HL,(40A4H) LD HL,(TXTTAB) 2A A4 40

Load HL with the start of the BASIC program pointer.

• Note: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).

2C0E

EX DE,HL EB

Load DE with the start of the BASIC program pointer in HL

2C0F-2C11

LD HL,(40F9H) LD HL,(VARTAB) 2A F9 40

Load HL with the end of the BASIC program pointer.

• Note: 40F9H-40FAH holds the starting address of the simple variable storage area.

2C12 LOPSCO

LD A,(DE) 1A

Top of a loop. We are going to loop from DE (start of program) to HL (end of program) now. Load Register A with the character at the location of the memory pointer in DE

2C13

INC DE 13

Bump the value of the memory pointer in DE

2C14-2C16

CALL 0264H CALL CASOUTCD 64 02

the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A Register to the cassette drive selected in the A register)

2C17

RST 18H COMPARDF

Now we need to check to see if the memory pointer in DE is equal to the end of the BASIC program pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2C18-2C19

JR NZ,2C12H JR NZ,LOPCSO20 F8

Loop back to 2C12H until the memory pointer in DE is equal to the end of the BASIC program pointer in HL

2C1A-2C1C

CALL 01F8H CALL CTOFFCD F8 01

All done! GOSUB 01F8H to turn the cassette recorder off

2C1D

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2C1E

RET C9

RETurn to CALLer

2C1F-2CA4 – LEVEL II BASIC CLOAD ROUTINE – ROM v1.0 – “CLOAD”

2C1F-2C21 CLOAD

CALL 0293H CALL CSRDONCD 93 02

Go turn on the cassette recorder

2C22

LD A,(HL) 7E

Load Register A with the character at the location of the current BASIC program pointer in HL

2C23-2C24

SUB 0B2H SUB $PRINT D6 B2

Check to see if the character at the location of the current BASIC program pointer in Register A is a ? , meaning that CLOAD? was requested.

2C25-2C26

JR Z,2C29H JR Z,CLOADP28 02

Jump to the CLOAD? routine at 2C29H if the character at the location of the current BASIC program pointer in Register A is a ?

2C27

XOR A AF

OK – So this is now a straight CLOAD . First, zero Register A

2C28

LD BC,232F 01 2F 23

Z-80 Trick! The next instruction would set the flag for a CLOAD? which we don’t want if we are passing through because we need A to be 0, so 2C28H starts with a 01H which would be a meaningless LOAD statement and assumes that the following instruction at 2C29H is what to load it with, effectively skipping 2C29H. BUT, if you jump to 2C29H you get the actual XOR command and keep going

2C29 CLOADP

CPL 2F

Load Register A with a -1 for CLOAD? . It will still be a 0 if this is CLOAD

2C2A

INC HL 23

Bump the value of the current BASIC program pointer in HL until it points to the next character after the ? in CLOAD?

2C2B

PUSH AF F5

Save the CLOAD / CLOAD? flag in Register A to the STACK

2C2C

DEC HL 2B

Decrement the value of the current BASIC program pointer in HL so we can see if we are at the end

2C2D

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2C2E-2C2F

LD A,00H 3E 00

Zero Register A to allow for any filename

2C30-2C31

JR Z,2C39H JR Z,CLNONM28 07

Jump if the character at the location of the current BASIC program pointer in HL is an end of the BASIC statement character

2C32-2C34

CALL 2337H CALL FRMEVLCD 37 23

To get the filename we need to GOSUB to 2337H to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in ACCumulator

2C35-2C37

CALL 2A13H CALL ASC2CD 13 2A

Make sure the length is good, and save the pointer to the filename to Register Pair DE

2C38

LD A,(DE) 1A

Load Register A with the first character of the filename at the location of the filename pointer in DE

2C39 CLNONM

LD L,A 6F

Load Register L with the filename in Register A

2C3A

POP AF F1

Get the value of the CLOAD / CLOAD? flag from the STACK and put it in Register A

2C3B

OR A B7

Test the value of the CLOAD / CLOAD? flag in Register A (since CPL doesn’t set any flags)

2C3C

LD H,A 67

Load Register H with the value of the CLOAD / CLOAD? flag in Register A

2C3D-2C3F

LD (4121H),HL LD (FACLO),HL 22 21 41

Save the value of the CLOAD / CLOAD? flag and the filename in HL in ACCumulator

2C40-2C42

CALL Z,1B4DH CALL Z,SCRTCHCC 4D 1B

Call the NEW routine at 1B4D if it is a CLOAD

2C43-2C45

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the CLOAD / CLOAD? flag and the filename in ACCumulator

*2C1F-2CA4 – LEVEL II BASIC CLOAD ROUTINE – ROM v1.3

*2C1F

SUB 0B2H

Test for CLOAD?

*2C21

JR Z,2C25H

Jump to 2C25H if it is CLOAD?

*2C23

XOR A

So we know that we have a CLOAD and not a CLOAD?, so clear Register A and continue

*2C24

01

Z-80 Trick! The next instruction would set the flag for a CLOAD? which we don’t want if we are passing through because we need A to be 0, so 2C28H starts with a 01H which would be a meaningless LOAD statement and assumes that the following instruction at 2C29H is what to load it with, effectively skipping 2C29H. BUT, if you jump to 2C29H you get the actual XOR command and keep going

*2C25

CPL

Since A is Zero going into this command, once this complement code is exected, A=-1 if CLOAD?, 0000 if CLOAD

*2C26

INC HL

Increment HL to the filname of the CLOAD / CLOAD? flag

*2C27

PUSH AF

Save the CLOAD / CLOAD? flag in Register A to the STACK

*2C28

LD A,(HL)

Set the next element from the code string, which should be the filename

*2C29

OR A

Set status flags

*2C2A

JR Z,2C33H

If it is the EOL, jump to 2C33H

*2C2C

CALL 2337H CALL FRMEVL

Call 2337H to get the filename

*2C2F

CALL 2A13H CALL ASC2

Call 2A13H to get the address of the filename into DE

*2C32

LD A,(DE)

Get the filename

*2C33

LD L,A

Move the filename into Register L

*2C34

POP AF

Restore the CLOAD / CLOAD? flag

*2C35

OR A

Set the status Register according to that flag

*2C36

LD H,A

H will now hold CLOAD / CLOAD? flag, and L will hold the filename

*2C37

LD (4121H),HL LD (FACLO),HL

Put the flag and filename into ACCumulator

*2C3A

CALL Z,1B4DH CALL Z,SCRTCH

If the flag is a CLOAD, call the NEW routine at 1B4DH

*2C3D

LD HL,0000H

Cause the drive to be selected

*2C40

CALL 0293H CALL CSRDON

Call 2093H to get the leader and sync byte from the cassette

*2C43

LD HL,(4121H) LD HL,(FACLO)

Restore the CLOAD / CLOAD? flag and filename

Common code between ROM v1.0 and v1.2 continues here.

2C46

EX DE,HL EB

Load D with the CLOAD/CLOAD? flag and load Register E with the filename

2C47-2C48 LOPCLK

LD B,03H 06 03

Load Register B with the number of header bytes

2C49-2C4B LOPCL2

CALL 0235H CALL CASINCD 35 02

Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in Register A, and returns the byte in Register A)

2C4C-2C4D

SUB 0D3H D6 D3

Check to see if the character in Register A is a filename header byte

2C4E-2C4F

JR NZ,2C47H JR NZ,LOPCLK20 F7

Loop if the character in Register A isn’t a filename header byte

2C50-2C51

DJNZ 2C49H DJNZ LOPCL210 F7

Loop back to 2C49H until three filename header bytes have been read

2C52-2C54

CALL 0235H CALL CASINCD 35 02

Now that the header is out of the way, let’s start working on the filename. GOSUB to 0235H to the READ ONE BYTE FROM CASSETTE (which reads one byte from the cassette drive specified in Register A, and returns the byte in Register A)

2C55

INC E 1C

We need to test to see if a filename was even given so we have to increase and decrease E to set flags . Bump the value of the filename in Register E

2C56

DEC E 1D

Decrement the value of the filename in Register E

2C57-2C58

JR Z,2C5CH JR Z,NONAMC28 03

Jump to 2C5CH (to pretend the filename matched) if no filename was specified

2C59

CP E BB

If we are here, then the user has supplied a filename which is held in Register E AND we have the first byte from the tape in Register A, so we need to compare the filename specified in Register E with the character in Register A. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2C5A-2C5B

JR NZ,2C93H JR NZ,SKPFIL20 37

Jump to 2C93H (to skip to the end of that file) if the filename specified in Register E doesn’t match the byte read from tape in Register A

2C5C-2C5E NONAMC

LD HL,(40A4H) LD HL,(TXTTAB) 2A A4 40

If we are here, the filename on tape matches the filename given so lets start loading. Load HL with the start of the BASIC program pointer.

• Note: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).

This loop is going to read a byte, compare it to the next byte in the program memory, jump away if it doesn’t match AND CLOAD? was chosen, write (or overwrite) that byte to memory, check for a zero, and loop back if no zero was found.

2C5F-2C60 DOCRS

LD B,03H 06 03

Load Register B with the number of zeros to look for to stop the load (which is 3)

2C61-2C63 DOCSMR

CALL 0235H CALL CASINCD 35 02

Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in Register A, and returns the byte in Register A)

2C64

LD E,A 5F

Preserve the character that was just read from tape into Register E

2C65

SUB (HL) 96

Compare the character we just read from the tape (held in Register A) with the character at the location of the memory pointer in HL by subtracting them

2C66

AND D A2

Combine the subtracted result in Register A with the value of the CLOAD / CLOAD? flag in Register D. Why is this tricky? Because D is always 0 for a CLOAD, so when you AND against 0, you always get 0. If this was CLOAD?, nothing would happen as a result of this.

2C67-2C68

JR NZ,2C8AH JR NZ,NOGOOD20 21

Jump to 2C8AH if CLOAD? was selected but the bytes don’t match

2C69

LD (HL),E 73

At this point either CLOAD? was selected and the bytes match, or CLOAD was selected. Either way, save the character we read from the tape (held in Register E) to the location of the memory pointer in HL

2C6A-2C6C

CALL 196CH
CALL REASONCD 6C 19

Make sure there is more room, and toss a ?OM ERROR if there isn’t.

2C6D

LD A,(HL) 7E

Load Register A with the character at the location of the memory pointer in HL

2C6E

OR A B7

Check to see if the byte just read in Register A is equal to zero

2C6F

INC HL 23

Bump the value of the memory pointer in HL

2C70-2C71

JR NZ,2C5FH JR NZ,DOCRS20 ED

Loop if the byte in Register A isn’t equal to zero (meaning that it isn’t end of program or end of statement)

2C72-2C74

CALL 022CH CALL BCASINCD 2C 02

Call the BLINK ASTERISK routine at 022CH which alternatively displays and clears an asterisk in the upper right hand corner of the video display

2C75-2C76

DJNZ 2C61H DJNZ DOCSMR10 EA

Do that loop until three zeros in a row have been read from the cassette recorder

2C77-2C79

LD (40F9H),HL LD (VARTAB),HL 22 F9 40

By this point, HL will have been incremented all the way through the program. Save the value of the memory pointer in HL as the new end of the BASIC program pointer.

• Note: 40F9H-40FAH holds the starting address of the simple variable storage area.

2C7A-2C7C OKCASS

LD HL,1929H LD HL,REDDY 21 29 19

Load HL with the starting address of the BASIC READY message

2C75-2C76

DJNZ 2C61H DJNZ DOCSMR10 EA

Do that loop until three zeros in a row have been read from the cassette recorder

2C80-2C82

CALL 01F8H CALL CTOFFCD F8 01

Go turn off the cassette recorder

2C83-2C85

LD HL,(40A4H) LD HL,(TXTTAB) 2A A4 40

Load HL with the start of the BASIC program pointer.

• Note: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).

2C86

PUSH HL E5

Save the start of the BASIC program pointer in HL to the STACK. FINI will need this value there.

2C87-2C89

JP 1AE8H JP FINIC3 E8 1A

Jump to 1AE8H to reinitialize the BASIC interpreter and continue

2C8A-2C8C NOGOOD

LD HL,2CA5H LD HL,NOOKCS 21 A5 2C

Load HL with the starting address of the BAD message

2C8D-2C8F

CALL 28A7H CALL STROUTCD A7 28

Call the WRITE MESSAGE routine at 28A7H to print the message pointed to by HL.
NOTE:

• The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
• The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
• If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).

2C90-2C92

JP 1A18 JP STPRDYC3 18 1A

JUMP to STPRDY to pop NEWSTT from the STACK and then fall into the READY routine

2C93-2C95 SKPFIL

LD (3C3EH),A 32 3E 3C

Go display the filename on the video display

2C96-2C97 ZERSRF

LD B,03H 06 03

Load Register B with the number of zeros to be found to stop the search

2C98-2C9A GETCHZ

CALL 0235H CALL CASINCD 35 02

Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in Register A, and returns the byte in Register A)

2C9B

OR A B7

Check to see if the character in Register A is equal to zero

2C9C-2C9D

JR NZ,2C96H JR NZ,ZERSRF20 F8

Loop if the character in Register A isn’t equal to zero

2C9E-2C9F

DJNZ 2C98H DJNZ GETCHZ10 F8

Loop until three zeros in a row have been read from the cassette recorder

2CA0-2CA2

CALL 0296H CALL CSRDON + 3CD 96 02

Calls the READ CASSETTE LEADER routine at 0296 (which reads from the cassette recorder selected in Register A until the end-of-leader marker of A5H is found; and flashes the cursor while doing this)

2CA3-2CA4

JR 2C47H JR LOPCLK18 A2

Jump back to 2C47H

2CA5-2CA9 – MESSAGE STORAGE LOCATION – “NOOKCS”

2CA5-2CA9 NOOKCS

“BAD” + 0DH + 00H 42

The BAD message is stored here

2CAA-2CB0 – LEVEL II BASIC PEEK ROUTINE – “PEEK”

The original ROM source code says that PEEK only accepts positive numbers up to 32767 and POKE will only take an address up to 32767. Negative numbers can be used to refer to locations higher than 32767, the correspondence is given by subtracting 65536 from locations higher than 32767 or by specifying a positive number up to 65535

On entry, ACCumulator to have the peek location, and on exit ACCumulator to have the peeked value.

2CAA-2CAC PEEK

CALL 0A7FH CALL FRCINTCD 7F 0A

Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of ACCumulator are converted from single or double precision to integer and deposited into HL)

2CAD

LD A,(HL) 7E

Load Register A with the value at the location of the memory pointer in HL

2CAE-2CB0

JP 27F8H JP SNGFLTC3 F8 27

Go save the 8-bit value in Register A as the current result in ACCumulator

2CB1-2CBC – LEVEL II BASIC POKE ROUTINE – “POKE”

2CB1-2CB3 POKE

CALL 2B02H CALL GETIN2CD 02 2B

Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE

2CB4

PUSH DE D5

Save the address the user wants to POKE to (held in DE) to the STACK

2CB5-2CB6

RST 08H⇒ 2E SYNCHK “,” CF 2E

Since the character at the location of the current BASIC program pointer in HL must be a , , call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2CB7-2CB9

CALL 2B1CH CALL GETBYTCD 1C 2B

GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the 8-bit value in Register A

2CBA

POP DE D1

Get the address the user wants to POKE to from the STACK and put it in DE

2CBB

LD (DE),A 12

Save the value the user wanted to poke (held in Register A) in the location that the user wants to POKE to (held in DE)

2CBC

RET C9

RETurn to CALLer

2CBD-2E52 – LEVEL II BASIC USING ROUTINE – “PRINUS”

The original ROM source code says that we wind up here after the “USING” clause in a PRINT statement is recognized. The idea is to scan the using string until the value list is exhausted, finding string and numeric fields to print values out of the list in, and just outputing any characters that aren’t part of a print field

Vernon Hester has reported an error in the PRINT USING routine. A PRINT USING statement with a negative sign at the end of the field prints a negative sign after negative numbers and prints a space for positive numbers. However, if the field specifiers in the string also has two asterisks at the beginning of the field, the ROM prints an asterisk instead of a space after a positive number.

   Example: PRINT USING “**####-“;1234 will display **1234* instead of **1234 SPACE

2CBD-2CBF PRINUS

CALL 2338H CALL FRMCHKCD 38 23

Go evaluate the string expression at the location of the current BASIC program pointer in HL

2CC0-2CC2

CALL 0AF4H CALL CHKSTRCD F4 0A

Go make sure the expression that was just evaluated was a string

2CC3-2CC4

RST 08H⇒ 3B SYNCHK “;” CF 3B

Since the character at the location of the current BASIC program pointer in HL must be a “;”, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL Register to the value in the location following the RST 08 call.

• If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
• If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2CC5

EX DE,HL EB

Swap DE and HL so that DE now holds the current BASIC program pointer

2CC6-2CC8

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the USING string’s VARPTR

2CC9-2CCA

JR 2CD3H JR INIUS18 08

Jump down to 2CD3H to continue

2CCB-2CCD REUSST

LD A,(40DEH) LD A,(FLGINP) 3A DE 40

Load Register A with the value of the READ/INPUT flag, which is being used here to track if we printed out a value on the prior scan.

2CCE

OR A B7

Check to see if that flag indivates that we did, or did not, print out a value last time.

2CCF-2CD0

JR Z,2CDDH JR Z,FCERR328 0C

If we did not print out a value last time, we have an error, so JUMP down to 2CDDH

2CD1

POP DE D1

Restore the pointer to the “USING” string decription from the STACK into DE

2CD2

EX DE,HL EB

Swap DE and HL so that HL will hold the pointer to the “USING” string descriptor and DE will hold the pointer to the position on the BASIC line being evaluated.

2CD3 INIUS

PUSH HL E5

Save the pointer to the “USING” string descriptor (i.e., the USING string’s VARPTR) in HL to the STACK

2CD4

XOR A AF

Zero Register A and all the flags.

2CD5-2CD7

LD (40DEH),A LD (FLGINP),A 32 DE 40

Clear the flag we are using to see if we printed the values or not.

2CD8

CP D BA

Turn the Z FLAG off so as to indicate the value list has not ended yet. This is accomplished by checking to see if the value in D is equal to zero by checking it against A which was XOR’d to 0 above. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2CD9

PUSH AF F5

Save the flag indicating if the value list has ended or not to the STACK

2CDA

PUSH DE D5

Save the pointer into the value list to the STACK

2CDB

LD B,(HL) 46

Load Register B with the USING string’s length

2CDC

OR B B0

Check to see if the USING string’s length in Register B is equal to zero

2CDD-2CDF FCERR3

JP Z,1E4AH JP Z,FCERRCA 4A 1E

If the USING string is NULL then display a ?FC ERROR

2CE0

INC HL 23

Bump the pointer to the USING string’s data in HL by 1

2CE1

LD C,(HL) 4E

Load Register C with the LSB of the USING string’s address at the location of the USING string’s VARPTR in HL

2CE2

INC HL 23

Bump the value of the USING string’s VARPTR in HL

2CE3

LD H,(HL) 66

Load Register H with the MSB of the USING string’s address at the location of the USING string’s VARPTR in HL

2CE4

LD L,C 69

Load Register L with the LSB of the USING string’s address in Register C

2CE5-2CE6

JR 2D03H JR PRCCHR18 1C

Jump down to 2D03H to loop to scan the USING string

2CE7 BGSTRF

LD E,B 58

Load Register E with the USING string’s length

2CE8

PUSH HL E5

Save the pointer to the USING string pointer in HL to the top of the STACK

2CE9-2CEA

LD C,02H 0E 02

Since the \\ string field length is two plus number of enclosed spaces, add two

2CEB LPSTRF

LD A,(HL) 7E

Load Register A with the character at the location of the USING string pointer in HL

2CEC

INC HL 23

Bump the value of the USING string data pointer in HL

2CED-2CEE

CP 25H CP CSTRNG FE 25

Check to see if the character in Register A is a %, which acts as a field terminator. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2CEF-2CF1

JP Z,2E17H JP Z,ISSTRFCA 17 2E

If it is a “%” then JUMP to 2E17H to evaluate a string and print

2CF2-2CF3

CP 20H FE 20

Check to see if the character in Register A is a ” “, which acts as a field extender. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2CF4-2CF5

JR NZ,2CF9H JR NZ,NOSTRF20 03

If the character is not a field extender, then it isn’t a string field, so JUMP down a few opcodes to 2CF9H

2CF6

INC C 0C

Increment the field width (tracked in in Register C)

2CF7-2CF8

DJNZ 2CEBH DJNZ LPSTRF10 F2

Decrement the USING string’s length in Register B and loop back to keep scanning for the field terminator or more characters

If we are here, then a string field was not found. The “USING” string character count and the pointer into its data MUST be restored and the “\” printed.

2CF9 NOSTRF

POP HL E1

Restore the pointer to the “USING” string’s data into Register Pair HL

2CFA

LD B,E 43

Load Register B with the USING string’s length

2CFB-2CFC

LD A,25H LD A,CSTRNG 3E 25

Restore the character into Register Adiv>

At this point we need to print the character held in Register A since it wasn’t part of any field

2CFD-2CFF NEWUCH

CALL 2E49H CALL PLSPRTCD 49 2E

If a + came before the character, make sure to print it

2D00-2D02

CALL 032AH CALL OUTDOCD 2A 03

Once that has been printed, now we print the character in Register A since we know it isn’t part of a field

2D03 PRCCHR

XOR A AF

We need to set Register Pair DE to 0 so that if we jump away, some of the flags are already ZERO, thus preventing us from printing a second “+”. To do this, first zero Register A and clear the flags

2D04

LD E,A 5F

Zero Register E

2D05

LD D,A 57

Zero Register D

2D06-2D08 PLSFIN

CALL 2E49H CALL PLSPRTCD 49 2E

Go print a leading + if necessary (i.e., to allow for multiple plusses)

2D09

LD D,A 57

Set the “plus flag” in Register D based on Register A. Note, since this is a loop, A could (and is) set to different values below.

2D0A

LD A,(HL) 7E

Load Register A with the next field description character in the USING string

2D0B

INC HL 23

Bump the value of the USING string pointer in HL

2D0C-2D0D

CP 21H CP “!” FE 21

Check to see if the character in Register A is a ! (which represents a single string character). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D0E-2D10

JP Z,2E14H JP Z,SMSTRFCA 14 2E

Jump if the character in Register A is a !

2D11-2D12

CP 23H CP “#” FE 23

Check to see if the character in Register A is a # (which represents the start of a numeric field). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D13-2D14

JR Z,2D4CH JR Z,NUMNUM28 37

Jump if the character in Register A is a #

2D15

DEC B 05

Since every other possibility is actually a two character field, decrement the value of the string’s length in Register B onem ore time

2D16-2D18

JP Z,2DFEH JP Z,REUSINCA FE 2D

If the USING list is exhausted (because we have a Z from that DEC), JUMP to REUSIN to reuse the USING string.

Now we parse all the 2 character USING fields.

2D19-2D1A

CP 2BH CP “+” FE 2B

Check to see if the character in Register A is a + (i.e., a leading PLUS). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D1B-2D1C

LD A,08H 3E 08

Set Register A to feed Register D (at the top of the loop) with an 08H to force a leading + in case a numeric field starts

2D1D-2D1E

JR Z,2D06H JR Z,PLSFIN28 E7

Jump if the character in Register A was a +

2D1F

DEC HL 2B

Decrement the value of the USING string pointer so we can re-get the character.

2D20

LD A,(HL) 7E

Load Register A with the (current) character at the location of the USING string pointer in HL

2D21

INC HL 23

Bump the value of the USING string pointer in HL

2D22-2D23

CP 2EH CP “.” FE 2E

Check to see if the character in Register A is a . (i.e., a numeric field with trailing digits). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D24-2D25

JR Z,2D66H JR Z,DOTNUM28 40

Jump if the character in Register A is a . to scan with Register E holding the number of digits before the “.” as 0

2D26-2D27

CP 25H CP CSTRNG FE 25

Check to see if the character in Register A is a % (i.e., a really big string field). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D28-2D29

JR Z,2CE7H JR Z,BGSTRF28 BD

Jump to see if it is really a string field if the character in Register A is a %

2D2A

CP (HL) BE

Check to see if the next character matches the current character in the the USING string. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D2B-2D2C

JR NZ,2CFDH JR NZ,NEWUCH20 D0

If the NZ flag is set, then we can’t have a $$ or a ** , so all remaining possibilities are exhausted, so JUMP to NEWUCH

2D2D-2D2E

CP 24H CP “$” FE 24

Check to see if the double character is a $ . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D2F-2D30

JR Z,2D45H JR Z,DOLRNM28 14

Jump to set up the flag bit if the match is $$

2D31-2D32

CP 2AH CP “*” FE 2A

Check to see if the double character is a ** . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D33-2D34

JR NZ,2CFDH JR NZ,NEWUCH20 C8

If the NZ FLAG is set, then the character is simply not part of a field since all the possibilties have been tested. If so, JUMP

2D35

LD A,B 78

Prepare to test to see if the “USING” string is long enough for a **$ by first loading Register A with the USING string’s length

2D36-2D37

CP 02H FE 02

Check to see if the USING string’s length in Register A is at least two. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D38

INC HL 23

Bump the value of the USING string pointer in HL

2D39-2D3A

JR C,2D3EH JR C,NOTSPC38 03

Jump to 2D3EH if the USING string’s length in Register A isn’t at least two

2D3B

LD A,(HL) 7E

Load Register A with the character at the location of the USING string pointer in HL

2D3C-2D3D

CP 24H CP “$” FE 24

Check to see if the character in Register A is a $ . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D3E-2D3F
NOTSPC

LD A,20H 3E 20

Set the * bit in Register A

2D40-2D41

JR NZ,2D49H JR NZ,SPCNUM20 07

If we did not ultimately get a **$ then JUMP (noting we do NOT set the dollar sign flag)

2D42

DEC B 05

Decrement the value of the USING string’s length to take the $ into account

2D43

INC E 1C

Bump the field width tracker to account for the floating dollar sign

2D44-2D45

CP 0AFH FE AF

Z-80 Trick to skip over a XOR A if passing through by processing it as a CP AFH . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D45 DOLRNM

XOR A AF

This is $ processing for PRINT USING. Clear Register A.

2D46-2D47

ADD A,10H C6 10

Mask Register A to set the bit for a floating dollar sign flag.

2D48

INC HL 23

Bump the value of the USING string pointer in HL to go past the special characters

2D49 SPCNUM

INC E 1C

Since two characters specify the field size, start off with E=1

2D4A

ADD A,D 82

Combine the bits in Register D into the flag tracker

2D4B

LD D,A 57

Preserve the modified flag tracker into Register D.

2D4C NUMNUM

INC E 1C

Bump the number of characters to the left of the decimal point in Register E

2D4D-2D4E

LD C,00H 0E 00

Set the number of digits to the right of the decimal point (tracked in Register C) to 0

2D4F

DEC B 05

Check to see if there are any more characters by decrementing the value of the string’s length in Register B

2D50-2D51

JR Z,2D99H JR Z,ENDNUS28 47

If the Z FLAG is set because we ran out of the characters to scan, then JUMP to ENDNUS because we are done scanning this particular numeric field.

2D52

LD A,(HL) 7E

Load Register A with the next character at the location of the USING string pointer in HL

2D53

INC HL 23

Bump the value of the USING string pointer in HL

2D54-2D55

CP 2EH CP “.” FE 2E

Check to see if the character in Register A is a . (i.e., a trailing digit). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D56-2D57

JR Z,2D70H JR Z,AFTDOT28 18

If yes, then need to use a special scan loop to scan after the decimal point, so JUMP to AFTDOT

2D58-2D59

CP 23H CP “#” FE 23

Check to see if the character in Register A is a # (i.e., a leading digit). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D5A-2D

JR Z,2D4CH JR Z,NUMNUM28 F0

If yes, increment the count and keep scanning via a JUMP to NUMNUM

2D5C-2D5D

CP 2CH CP “,” FE 2C

Check to see if the character in Register A is a , . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D5E-2D5F

JR NZ,2D7AH JR NZ,FINNUM20 1A

If there is no comma, then JUMP to FINNUM because there are no more leading digits and we need to check for “^^^”

2D60

LD A,D 7A

If we are here, then a comma was requested. Turn on the COMMA bit

2D61-2D62

OR 40H F6 40

Mask the flag in Register A for ,

2D63

LD D,A 57

Load Register D with the value of the flag in Register A

2D64-2D65

JR 2D4CH JR NUMNUM18 E6

Jump to 2D4CH to keep scanning

2D66 – Part of the PRINT USING Routine – “DOTNUM”

Jumped here when a “.” is seen in the USING string. THis means that we are starting a numeric field ONLY if it is followed by a “#”

2D66 DOTNUM

LD A,(HL) 7E

Load Register A with the next character of the USING string

2D67-2D68

CP 23H FE 23

Check to see if the character in Register A is a # (i.e., a numeric field following a “.”). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D69-2D6A

LD A,2EH LD A,”.” 3E 2E

Load Register A with a decimal point

2D6B-2D6C

JR NZ,2CFDH JR NZ,NEWUCH20 90

If it isn’t a “.” then JUMP AWAY to NEWUCH with A holding a “.” so that a “.” will get printed

2D6D-2D6E

LD C,01H 0E 01

If it was a “.” then we have a numeric field to process. First, set C with the number of characters to the right of the decimal point

2D6F

INC HL 23

Bump the value of the USING string pointer in HL

2D70 AFTDOT

INC C 0C

Bump the number of digits to the right of the decimal point (tracked in Register C)

2D71

DEC B 05

Decrement the value of the USING STRING’s length to test to see if there are more characters

2D72-2D73

JR Z,2D99H JR Z,ENDNUS28 25

If the USING string length is now ZERO, JUMP to ENDNUS to stop scanning

2D74

LD A,(HL) 7E

Load Register A with the character at the location of the USING string pointer in HL

2D75

INC HL 23

Bump the value of the USING string pointer in HL

2D76-2D77

CP 23H FE 23

Check to see if the character in Register A is a # ; meaning that there are more digits after the decimal point. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D78-2D79

JR Z,2D70H JR Z,AFTDOT28 F6

If there are more digits, JUMP to AFTDOT to increment the count and keep scanning

2D7A – Part of the PRINT USING Routine – “FINNUM”

Now we move on to check the “^^^^” that indicates scientific notation

2D7A FINNUM

PUSH DE D5

Save the value of the flag (tracked in D) and the number of leading digits (tracked in E) to the STACK

2D7B-2D7D

LD DE,2D97H LD DE,NOTSCI 11 97 2D

Load DE with the return address in case this is not a scientific notation

2D7E

PUSH DE D5

Save the value of the return address in DE to the STACK

2D7F
2D80

LD D,H
LD E,L 54

Let DE = HL in case we need to rememer HL

2D81-2D82

CP 5BH FE 5B

Check to see if the character in Register A is an up arrow. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D83

RET NZ C0

Return if the character in Register A isn’t an up arrow

2D84

CP (HL) BE

Check to see if the character at the location of the USING string pointer in HL is an up arrow. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D85

RET NZ C0

Return to 2D97 if the character at the location of the USING string pointer in HL isn’t an up arrow (meaning we do not have a ^^ format)

2D86

INC HL 23

Bump the value of the USING string pointer in HL

2D87

CP (HL) BE

Check to see if there is a third up arrow at the location of the USING string pointer in HL. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D88

RET NZ C0

Return to 2D97 if the character at the location of the USING string pointer in HL isn’t an up arrow (meaning we do not have a ^^^ format)

2D89

INC HL 23

Bump the value of the USING string pointer in HL

2D8A

CP (HL) BE

Check to see if the character at the location of the USING string pointer in HL is a fourth up arrow. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2D8B

RET NZ C0

Return to 2D97 if the character at the location of the USING string pointer in HL isn’t an up arrow (meaning we do not have a ^^^^ format)

2D8C

INC HL 23

Bump the value of the USING string pointer in HL. If we are here we have a #.^^^^ format

2D8D

LD A,B 78

Now we need to check if there were enough characters for a ^^^^ . First load Register A with the value of the USING string’s length in Register B

2D8E-2D8F

SUB 04H D6 04

Check to see if there are at least 4 characters left in the USING string

2D90

RET C D8

Return to 2D97 if there aren’t at least four characters left in the USING string

2D91

POP DE D1

If there are at least 4 characters left, then clean up the STACK by removing the NOTSCI return address

2D92

POP DE D1

Get the flag and the count of the characters to the left of the decimal point from the STACK and put it in DE

2D93

LD B,A 47

Load Register B with the new USING string’s length in Register A

2D94

INC D 14

Set the exponential notation flag (tracked in Register D)

2D95

INC HL 23

Bump the value of the USING string pointer in HL

2D96

JP Z,0D1EBH CA EB D1

Z-80 Trick! If passing through this won’t do anything because the Z FLAG won’t be set AND the EX DE,HL won’t be executed because it doesn’t see that instruction.

2D97 “NOTSCI”

EX DE,HL EB

(Ignored if passing through) Restore the old HL into HL

2D98

POP DE D1

(Ignored if passing through) Restore the flags into Register D and the number of leading digits into Register E

2D99 ENDNUS

LD A,D 7A

We need to test to see if the ‘leading plus’ flag is on, so we load Register A with the value of the edit flag in Register D

2D9A

DEC HL 2B

Decrement the value of the USING string pointer in HL

2D9B

INC E 1C

Bump the number of characters to the left of the decimal point in Register E to take into account the leading plus

2D9C-2D9D

AND 08H E6 08

Mask Register A to NOT check for a trailing sign

2D9E-2D9F

JR NZ,2DB5H JR NZ,ENDNUM20 15

If that AND leaves us with a NZ, then we are all done with the field, so JUMP to ENDNUM

2DA0

DEC E 1D

Otherwise, since we don’t have a leading plus, we don’t increment the number of digits before the decimal point … so decrement the number of characters to the left of the decimal point in Register E

2DA1

LD A,B 78

Check to see if there are more characters by first loading Register A with the USING string’s length from Register B

2DA2

OR A B7

Check to see if this is the end of the USING string

2DA3-2DA4

JR Z,2DB5H JR Z,ENDNUM28 10

If we are out of characters, then we are all done, so JUMP to ENDNUM

2DA5

LD A,(HL) 7E

If there ARE more characters, then fill Register A with the character at the location of the USING string pointer in HL

2DA6-2DA7

SUB 2DH SUB “-“ D6 2D

Check to see if the character in Register A is a – (i.e., a trailing minus)

2DA8-2DA9

JR Z,2DB0H JR Z,SGNTRL28 06

If it is, then JUMP to SGNTRL to set the trailing sign flag

2DAA-2DAB

CP 0FEH CP “+” – “-“ FE FE

Check to see if the character in Register A is a + (i.e., a trailing plus). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2DAC-2DAD

JR NZ,2DB5H JR NZ,ENDNUM20 07

If its NOT, then we are done scanning, so JUMP to ENDNUM

2DAE-2DAF

LD A,08H 3E 08

If we are here then we did have a trailing “+” so first set the flag for a POSITIVE “+”

2DB0-2DB1 SGNTRL

ADD A,04H C6 04

Then set the flag for a trailing sign

2DB2

ADD A,D 82

Combine the value of the flag in Register D with the value of the flag in Register A

2DB3

LD D,A 57

Load Register D with the current flags

2DB4

DEC B 05

Decrement the value of the USING string’s length in Register B by 1 to account for the trailing sign

2DB5 – Part of the PRINT USING Routine – “ENDNUM”

Jump point for when we figure out that we are at the end of a string of digits within a USING string

2DB5 ENDNUM

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2DB6

POP AF F1

Load Register A with the flag that tells us whether there are more values to process in the value list.

2DB7-2DB8

JR Z,2E09H JR Z,FLDFIN28 50

If there are no more values in the value list to process, then JUMP to FLDFIN because we are done with the PRINT

2DB9

PUSH BC C5

Save the number of characters remaining to be processed in the USING string (held in B) and the trailing digits (held in C) to the STACK

2DBA

PUSH DE D5

Save the flags (held in D) and the number of leading digits (held in E) to the STACK

2DBB-2DBD

CALL 2337H CALL FRMEVLCD 37 23

Read a value from the value list by CALLING the routine to evaluate the expression at the location of the current BASIC program pointer and return with the result in ACCumulator

2DBE

POP DE D1

Restore the flags (held in D) and the number of leading digits (held in E) from the STACK

2DBF

POP BC C1

Restore the number of characters remaining to be processed in the USING string (held in B) and the trailing digits (held in C) from the STACK

2DC0

PUSH BC C5

Save the number of characters remaining to be processed in the USING string (held in B) and the trailing digits (held in C) to the STACK

2DC1

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2DC2

LD B,E 43

Set Register B to hold the number of leading digits (i.e., the number of characters to the left of the decimal point)

2DC3

LD A,B 78

We need to test to make sure the total number if digits does not exceed 24, so first load Register A with the number of characters to the left of the decimal point in Register B

2DC4

ADD A,C 81

Then add the number of characters to the right of the decimal point in Register C to the number of characters to the left of the decimal point in Register A

2DC5-2DC6

CP 19H FE 19

Check to see if the total number of characters in Register A is greater than 24. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2DC7-2DC9

JP NC,1E4AH JP NC,FCERRD2 4A 1E

Display a FC ERROR message if the total number of digits is greater than 24

2DCA

LD A,D 7A

Load Register A with the flags (held in Register D)

2DCB-2DCC

OR 80H F6 80

Turn on the “USING” bit in the flags

2DCD-2DCF

CALL 0FBEH CALL PUFOUTCD BE 0F

Prepare to print by calling the FLOATING TO ASCII routine at 0FBEH (whcih converts a single or double precision number in ACCumulator to its ASCII equivalent which will be stored at the buffer pointed to by HL using the format codes in the A, B, and C registers

2DD0-2DD2

CALL 28A7H CALL STROUTCD A7 28

Call the WRITE MESSAGE routine at 28A7H to print the message pointed to by HL.
NOTE:

• The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
• The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
• If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).

2DD3 FNSTRF

POP HL E1

Top of a loop. Get the value of the current BASIC program pointer from the STACK and put it in HL

2DD4

DEC HL 2B

Decrement the value of the current BASIC program pointer in HL so we can test to see what the terminator was

2DD5

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2DD6

SCF 37

Set the Carry flag to indicate that a CRLF is desired

2DD7-2DD8

JR Z,2DE6H JR Z,CRDNUS28 0D

If the character at the location of the current BASIC program pointer in Register A is an end of the BASIC statement character, then we need to print a CRLF, so JUMP to CRDNUS

2DD9-2DDB

LD (40DEH),A LD (FLGINP),A 32 DE 40

Set the flag that the value HAS been printed!

2DDC-2DDD

CP 3BH CP “;” FE 3B

Check to see if the character at the location of the current BASIC program pointer in Register A is a semicolon. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2DDE-2DDF

JR Z,2DE5H JR Z,SEMUSN28 05

If so, then we have a legal delimiter, so JUMP to SEMUSN

2DE0-2DE1

CP 2CH CP “,” FE 2C

Check to see if the character at the location of the current BASIC program pointer in Register A is a comma. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2DE2-2DE4

JP NZ,1997H JP NZ,SNERRC2 97 19

If not a comma, then we have no more valid delimiters (it wasnt a “;” or a “,”) so go to the Level II BASIC error routine and display an SN ERROR message if the character at the location of the current BASIC program pointer in Register A isn’t a comma

2DE5 SEMUSN

RST 10H CHRGETD7

We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.

The RST 10H routine parses the characters starting at HL+1 for the first non-SPACE,non-09H,non-0BH character it finds. On exit, Register A will hold that character, and the C FLAG is set if its alphabetic, and NC FLAG if its alphanumeric. All strings must have a 00H at the end.

2DE6 CRDNUS

POP BC C1

Restore the number of characters remaining to be procesed in the USING string into Register B

2DE7

EX DE,HL EB

Swap DE and HL so that DE will point to the location of the current BASIC program pointer. We don’t care about HL.

2DE8

POP HL E1

Restore the position in the USING string from the STACK and put it in HL

2DE9

PUSH HL E5

Save the position in the USING string (held in HL) to the STACK

2DEA

PUSH AF F5

Save the flag that indicates whether or not the value list has terminated to the STACK

2DEB

PUSH DE D5

Save the value of the current BASIC program pointer (held in DE) to the STACK

The original ROM source code indicates that since FRMEVL may have forced some garbage collection, we cannot rely on the pointer of characters remaining to be scanned. Instead, we have to use the number of characters scanned prior to calling FRMEVL as an offset to the “USING” string’s data after FRMEVL.

2DEC

LD A,(HL) 7E

Load Register A with the USING string’s length at the location of the USING string’s VARPTR in HL

2DED

SUB B 90

Subtract the number of characers which were already scanned

2DEE

INC HL 23

Bump the pointer to the “USING” strings string data

2DEF

LD C,(HL) 4E

Load Register C with the LSB of the USING string’s address at the location of the USING string’s VARPTR in HL

2DF0

INC HL 23

Bump the value of the USING string’s VARPTR in HL

2DF1

LD H,(HL) 66

Load Register H with the MSB of the USING string’s address at the location of the USING string’s VARPTR in HL

2DF2

LD L,C 69

Load Register L with the LSB of the USING string’s address in Register C

2DF3-2DF4

LD D,00H 16 00

Zero Register D so that Register Pair DE can be a 16 bit offset of whatever is held in A.

2DF5

LD E,A 5F

Load Register E with the USING string’s offset in Register A

2DF6

ADD HL,DE 19

Add the USING string’s offset in DE to the USING string’s address in HL to get us the new pointer into the USING string’s string data into HL

2DF7

LD A,B 78

Load Register A with the number of characters left to scan

2DF8

OR A B7

Check to see if this is the end of the USING string

2DF9-2DFB

JP NZ,2D03H JP NZ,PRCCHRC2 03 2D

If there are still more string characters to scan, JUMP to PRCCHR to do so

2DFC-2DFD

JR 2E04H JR FINUSI18 06

Jump to 2E04H if this is the actual end of the entire USING string

2DFE-2E00 – Part of the PRINT USING Routine – “REUSIN”

We will wind up here when we are done processing a numeric field

2DFE-2E00 REUSIN

CALL 2E49H CALL PLSPRTCD 49 2E

GOSUB to 2E49H print a + if necessary

2E01-2E03

CALL 032AH CALL OUTDOCD 2A 03

Go send the FINAL character (held in Register A) to the current output device

2E04 FINUSI

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2E05

POP AF F1

Restore the flag which indicates whether or not the value list has ended into Register A

2E06-2E08

JP NZ,2CCBH JP NZ,REUSSTC2 CB 2C

If the value list has NOT ended, JUMP back to REUSST to reuse the USING string

2E09-2E0B FLDFIN

CALL C,20FEH CALL C,CRDODC FE 20

If we are here, then we didn’t have a , or ; after the PRINT USING, so we GOSUB to 20FEH to send a carriage return to the current output device if necessary

2E0C

EX (SP),HL E3

Swap (SP) with HL so that HL will now point to the “USING” string’s descriptor and (SP) will hold the value of the current BASIC program pointer

2E0D-2E0F

CALL 29DDH CALL FRETM2CD DD 29

Free the RAM holding the USING string

2E10

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2E11-2E13

JP 2169H JP FINPRTC3 69 21

Return to 2169H

2E14-2E15 – Part of the PRINT USING Routine – “SMSTRF”

We will wind up here when the “!” indicating a single character string field has been scanned

2E14-2E15 SMSTRF

LD C,01H 0E 01

Set the field width to 1

2E16-2E17

LD A,0F1H 3E F1

Z-80 Trick. By putting a 3E in front of the F1 (which is POP AF , to clear the STACK) that POP AF gets skipped if flowing down in the code

2E17 ISSTRF

POP AF F1

(Skipped if passing down) Clear the STACK *dumping the HL that was being saved in case it turned out that this wasn’t actually a string)

2E18

DEC B 05

Decrement the USING string character count (tracked in Register B)

2E19-2E1B

CALL 2E49H CALL PLSPRTCD 49 2E

If there was a “+” before the field, then print it

2E1C

POP HL E1

Get the value of the current BASIC program pointer from the STACK and put it in HL

2E1D

POP AF F1

Get the flag which indicates whether there are more values in the value list into Register A

2E1E-2E1F

JR Z,2E09H JR Z,FLDFIN28 E9

If there are no more values in the value list, then we are done so JUMP back to 2E09H

2E20

PUSH BC C5

Save the number of characters still to be scanned from the USING string (tracked in B) to the STACK

2E21-2E23

CALL 2337H CALL FRMEVLCD 37 23

Read a value by GOSUBing to FRMEVL which will evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in ACCumulator

2E24-2E26

CALL 0AF4H CALL CHKSTRCD F4 0A

Go make sure the current result in ACCumulator is a string

2E27

POP BC C1

Restore the field width (a/k/a the number of characters to be printed) into Register C

2E28

PUSH BC C5

Save the USING string’s length and the number of characters to be printed in BC to the STACK

2E29

PUSH HL E5

Save the value of the current BASIC program pointer in HL to the STACK

2E2A-2E2C

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the string’s VARPTR in ACCumulator

2E2D

LD B,C 41

Load Register B with field width (a/k/a the number of characters to be printed)

2E2E-2E2F

LD C,00H 0E 00

Zero Register C so that we can use the LEFT$ routine

2E30

PUSH BC C5

Save the length of the string to be printed in Register B to the STACK (as we will need that for space padding)

2E31-2E33

CALL 2A68H CALL LEFTUSCD 68 2A

Truncate the string to B characters via a call to the LEFT$ routine

2E34-2E36

CALL 28AAH CALL STRPRTCD AA 28

Print the string to the current output device

2E37-2E39

LD HL,(4121H) LD HL,(FACLO) 2A 21 41

Load HL with the string’s VARPTR in ACCumulator so we can see if we need to pad the string

2E3A

POP AF F1

Get the field width (a/k/a the length of the string to be printed) from the STACK and put it in Register A

2E3B

SUB (HL) 96

Determine the amount of padding needed into Register A by subtracting the string’s length at the location of the string’s VARPTR in HL from the length of the string to be printed in Register A

2E3C

LD B,A 47

Save the amount of padding needed into Register B

2E3D-2E3E

LD A,20H 3E 20

Load Register A with a SPACE

2E3F

INC B 04

Bump the number of spaces in Register B because the loop startes with a DEC B

This loop will print all the spaces needed and then jump to 2DD3H.

2E40 UPRTSP

DEC B 05

Top of a loop. Decrement the number of spaces in Register B

2E41-2E43

JP Z,2DD3H JP Z,FNSTRFCA D3 2D

If all of the spaces have been printed, Jump back to 2DD3H to see if the value list ended and to resume scanning

2E44-2E46

CALL 032AH CALL OUTDOCD 2A 03

Go send a space to the current output device

2E47-2E48

JR 2E40H JR UPRTSP18 F7

LOOP back to 2E40H to print all the spaces

2E49 – Part of the PRINT USING Routine – “PLSPRT”

When a “+” is detected in the “USING” string and a numeric field follows, a bit in Register D should be set, otherwise + should be printed. Since deciding whether a numeric field follows is very difficult, the bit is always set in Register D. At the point it is decided a character is not part of a numeric field, this routine is called to see if the bit in Register D is set, which means a plus preceded the character and should be printed

2E49 PLSPRT

PUSH AF F5

Save the current character (held in Register A) to the STACK

2E4A

LD A,D 7A

We need to test the PLUS BIT in D, so first load Register A with the value in Register D

2E4B

OR A B7

Check to see if Register A is equal to zero as that would be the ONLY bit which could be turned on at this particular point in the routine.

2E4C-2E4D

LD A,2BH LD A,”+” 3E 2B

Prepare to print the + by loading Register A with a +

2E4E-2E50

CALL NZ,032AH CALL NZ,OUTDOC4 2A 03

If the bit was set (i.e., A was non-zero), then send a + to the current output device

2E51

POP AF F1

Get the current character from the STACK and put it in Register A

2E52

RET C9

RETurn to CALLer

2E53-2FFA – LEVEL II BASIC EDIT ROUTINE – “ERREDT”

According to the original ROM source, the EDIT command takes a single line number as its argument. If that line doesn’t exist, and error is thrown. If the line does exist, the line number is then typed, and the system waits for the user to enter any of the valid commands.

Register C holds the number of characters in the line, Register B holds the current character position (with 0 being the first character) and Register Pair HL points to the current character

2E53-2E55 ERREDT

LD (409AH),A LD (ERRFLG),A 32 9A 40

Reset the EDIT flag.
Note: 409AH holds the ERROR/RESUME flag

2E56-2E58

LD HL,(40EAH) LD HL,(ERRLIN) 2A EA 40

Load HL with the line number to be edited.
Note: 40EAH-40EBH holds the line number with error

2E59

OR H B4

OR Register A with the MSB of the error line number in Register H

2E5A

AND L A5

Combine the LSB of the error line number in Register L with the MSB of the line number in Register A. It will be FFH if this was a direct command rather than being part of a program

2E5B

INC A 3C

Bump the combined value of the error line number in Register A. If this was a direct call from the command line, this will turn A from FFH into 00H

2E5C

EX DE,HL EB

Swap DE and HL so that DE now holds the line number to edit.

2E5D

RET Z C8

If there was no line number, return if Level II BASIC

2E5E-2E5F

JR 2E64H JR EREDIT18 04

otherwise, continue via a JUMP to 2E64H

Now that the above code is out of the way (it was the code which would enter EDIT if there was an error in a line number), let us actually process the EDIT command

2E60-2E62 EDIT

CALL 1E4FH CALL LINSPCCD 4F 1E

Get the first line number by calling 1E4F – returns in in DE

2E63

RET NZ C0

If the zero flag got set, there was no line number, so return

2E64 EREDIT

POP HL E1

Clean up the STACK (i.e., discard the NEWSTT return address)

2E65 EEDITS

EX DE,HL EB

Load HL with the line number to be edited in DE

2E66-2E68

LD (40ECH),HL LD (DOT),HL 22 EC 40

Save the value of the line number to be edited (in HL) to the memory location that cares about such things.
Note: 40ECH-40EDH holds EDIT/LIST line number

2E69

EX DE,HL EB

Load HL with the line number to be edited

2E6A-2E6C

CALL 1B2CH CALL FNDLINCD 2C 1B

Find that line number via a GOSUB to the SEARCH FOR LINE NUMBER routine at 1B2CH which looks for the line number specified in DE. Returns C/Z with the line found in BC, NC/Z with line number is too large and HL/BC having the next available location, or NC/NZ with line number not found, and BC has the first available one after that

2E6D-2E6F

JP NC,1ED9H JP NC,USERRD2 D9 1E

If the BASIC line number doesn’t exist, display a ?UL ERROR

2E70
2E71

LD H,B
LD L,C 60

At this point, the line number has been found. Let HL=BC so that HL also points to the location in RAM of the line number being edited

2E72
2E73

INC HL
INC HL 23

Bump the value of the memory pointer in HL twice to now point to the first byte of the line.

2E74

LD C,(HL) 4E

Load Register C with first byte of the line number being edited

2E75

INC HL 23

Bump the value of the memory pointer in HL to point to the second byte of the line being edited

2E76

LD B,(HL) 46

Load Register B with second byte of the line number being edited

2E77

INC HL 23

Bump the value of the memory pointer in HL to now point to the first byte of the actual line

2E78

PUSH BC C5

Save the line number to the STACK

2E79-2E7B

CALL 2B7EH CALL BUFLINCD 7E 2B

GOSUB to 2B7EH move the BASIC line at the location of the memory pointer in HL into a memory buffer and untokenize the BASIC line

2E7C LLED

POP HL E1

Get the value of the line number from the STACK and put it in HL

2E7D INLED

PUSH HL E5

Save the value of the line number in HL to the STACK

2E7E-2E80

CALL 0FAFH CALL LINPRTCD AF 0F

Convert the line number to ASCII and print it out by calling the HL TO ASCII routine at 0FAFH (which converts the value in the HL (assumed to be an integer) to ASCII and display it at the current cursor position on the video screen)

2E81-2E82

LD A,20H 3E 20

Load Register A with a space

2E83-2E85

CALL 032AH CALL OUTDOCD 2A 03

Go display the space in Register A

2E86-2E88

LD HL,(40A7H) LD HL,(BUFPNT) 2A A7 40

Load HL with the starting address of the expanded version of the current line from the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer

2E89-2E8A

LD A,0EH 3E 0E

Load Register A with the “turn on the cursor” character

2E8B-2E8D

CALL 032AH CALL OUTDOCD 2A 03

Go turn on the cursor

2E8E

PUSH HL E5

Save the value of the input buffer pointer (in HL) to the STACK

2E8F-2E90

LD C,FFH 0E FF

Load Register C with the number of characters examined so far with FFH because the next line is going to INC it by 1 to make it 0

2E91 LENLP

INC C 0C

Bump the number of characters examined so far in Register C

2E92

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2E93

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2E94

INC HL 23

Bump the value of the input buffer pointer in HL

2E95-2E96

JR NZ,2E91H JR NZ,LENLP20 FA

Loop back to 2E91H until the end of the BASIC line has been found

2E97

POP HL E1

At this point, C will be the maximum number of characters in the line at issue. Put the start of the expanded buffer into HL

2E98

LD B,A 47

Set the current position in the BASIC line being edited (tracked by Register B) to ZERO

2E99-2E9A DISPED

LD D,00H 16 00

Assume the repetition count for the upcoming command (tracked by Register D) is zero

2E9B-2E9D DISPI

CALL 0384H CALL INCHRCD 84 03

Go scan the keyboard to wait for the user command

2D9E-2E9F DISP

SUB 30H 20 15

We need to test to see if the character was alphabetic or alphanumeric so we subtract 30H from it

2EA0-2EA1

JR C,2EB0H JR C,NOTDGI38 0E

Jump down to 2EB0H if the character in Register A is alphabetic

2EA2-2EA3

CP 0AH FE 0A

Check to see if the character is Register A is numeric. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EA4-2EA5

JR NC,2EB0H JR NC,NOTDGI30 0A

Jump to 2EB0H if the character in Register A isn’t numeric

2EA6

LD E,A 5F

Load Register E with the binary value of the character in Register A

2EA7

LD A,D 7A

Put the repetition value into Register A

2EA8

RLCA 07

Multiply the value in Register A by two (so now A has multiplied by 2)

2EA9

RLCA 07

Multiply the value in Register A by two (so now A has multiplied by 4)

2EAA

ADD A,D 82

Add the value in Register D to the value in Register A (so now A has multiplied by 5)

2EAB

RLCA 07

Multiply the value in Register A by two (so now A has multiplied by 10). Now the “ones place” is empty.

2EAC

ADD A,E 83

Add the value in Register E to the value in Register A in the “ones place”

2EAD

LD D,A 57

Load Register D with the value in Register A

2EAE-2EAF

JR 2E9BH JR DISPI18 EB

Loop until a nonnumeric character is pressed

2EB0H – LEVEL II BASIC EDIT ROUTINE – “NOTDGI”

While getting user command input within an edit, we wind up here if the user enters a non-numeric character (i.e., the actual command, and not just the repetition number which precedes it)

2EB0 NOTDGI

PUSH HL E5

Save the value of the input buffer pointer in HL to the STACK

2EB1-2EB3

LD HL,2E99H LD HL,DISPED 21 99 2E

Load HL with the return address of 2E99H

2EB4

EX (SP),HL E3

Exchange the value of the return address in HL with the value of the input buffer pointer to the STACK

2EB5

DEC D 15

We need to test if the command was preceded by a number so we need to set the flags by first decrementing the numeric value in Register D

2EB6

INC D 14

… and then incrementing the numeric value in Register D to set the flags

2EB7-2EB9

JP NZ,2EBBH JP NZ,NTZERDC2 BB 2E

If we had a received a repetition count already, then JUMP to 2EBBH

2EBA

INC D 14

Otherwise, set the repetition count (held in Register D) to be one

2EBB-2EBC NTZERD

CP 0D8H FE D8

Check to see if the character in Register A is a BACKSPACE character. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EBD-2EBF

JP Z,2FD2H JP Z,DELEDCA D2 2F

If the character in Register A is a BACKSPACE character, JUMP to DELED

2EC0-2EC1

CP 0DDH FE DD

Check to see if the character in Register A is a CARRIAGE RETURN . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EC2-2EC4

JP Z,2FE0H JP Z,CREDCA E0 2F

If the character in Register A is a CARRIAGE RETURN , JUMP to CRED

2EC5-2EC6

CP 0F0H FE F0

Check to see if the character in Register A is a SPACE . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EC7-2EC8

JR Z,2F0AH JR Z,SPED28 41

If the character in Register A is a SPACE , JUMP to SPED

That’s it for non-alphabetic instructions, so we need to need to convert a lower case command to upper case

2EC9-2ECA

CP 31H FE 31

Check to see if the character in Register A is lowercase. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2ECB-2ECC

JR C,2ECFH JR C,NOTLW438 02

Jump if the character in Register A isn’t lowercase

2ECD-2ECE

SUB 20H D6 20

Convert the lowercase character in Register A to uppercase

2ECF-2ED0 NOTLW4

CP 21H FE 21

Check to see if the character in Register A is a Q (i.e., QUIT the edit). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2ED1-2ED3

JP Z,2FF6H JP Z,QEDCA F6 2F

Jump if the character in Register A is a Q (i.e., QUIT)

2ED4-2ED5

CP 1CH FE 1C

Check to see if the character in Register A is an L . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2ED6-2ED7

JP Z,2F40H JP Z,LEDCA 40 2F

Jump if the character in Register A is an L (i.e., BRANCH)

2ED9-2EDA

CP 23H FE 23

Check to see if the character in Register A is an S . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EDB-2EDC

JR Z,2F1CH JR Z,SED28 3F

Jump if the character in Register A is an S (i.e., SEARCH)

2EDD-2EDE

CP 19H FE 19

Check to see if the character in Register A is an I . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EDF-2EE1

JP Z,2F7DH JP Z,IEDCA 7D 2F

Jump if the character in Register A is an I (i.e., INSERT)

2EE2-2EE3

CP 14H FE 14

Check to see if the character in Register A is a D . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EE4-2EE6

JP Z,2F4AH JP Z,DEDCA 4A 2F

Jump if the character in Register A is a D (i.e., DELETE)

2EE7-2EE8

CP 13H FE 13

Check to see if the character in Register A is a C . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EE9-2EEB

JP Z,2F65H JP Z,CEDCA 65 2F

Jump if the character in Register A is a C (i.e., CHANGE)

2EEC-2EED

CP 15H FE 15

Check to see if the character in Register A is an E . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EEE-2EF0

JP Z,2FE3H JP Z,EEDCA E3 2F

Jump if the character in Register A is an E (i.e., END)

2EF1-2EF2

CP 28H FE 28

Check to see if the character in Register A is an X . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EF3-2EF5

JP Z,2F78H JP Z,XEDCA 78 2F

Jump if the character in Register A is an X (i.e., EXTEND)

2EF6-2EF7

CP 1BH FE 1B

Check to see if the character in Register A is a K . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EF8-2EF9

JR Z,2F16H JR Z,KED28 1C

Jump if the character in Register A is a K (i.e., KILL)

2EFA-2EFB

CP 18H FE 18

Check to see if the character in Register A is an H . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2EFC-2EFE

JP Z,2F75H JP Z,HEDCA 75 2F

Jump if the character in Register A is an H (i.e., HACK off the rest of the line and then enter INSERT mode)

2EFF-2F00

CP 11H FE 11

Check to see if the character in Register A is an A (i.e., AGAIN). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2F01

RET NZ C0

Return if the character in Register A isn’t an A

2F02 – EDIT Command – Cancel and Restore Logic.

2F02

POP BC C1

Clean up the STACK (i.e., remove the DISPI return address)

2F03

POP DE D1

Get the BASIC line number from the STACK and put it in DE

2F04-2F06

CALL 20FEH CALL CRDOCD FE 20

Go print a carriage return on the video display if necessary

2F07-2F09

JP 2E65H JP EEDITSC3 65 2E

Jump back to 2E65H to re-enter the EDIT routine

2F0A – This routine prints a string of text to the display, printer or tape – “SPED”

This routine it uses 032AH to do this. HL must point to the first character of the string. (409CH must be set before calling this routine, see 32AH). String must be delimited with a zero byte.
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer

2F0A SPED

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2F0B

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2F0C

RET Z C8

Return if the character in Register A is an end of the BASIC line character

2F0D

INC B 04

Bump the character position in Register B

2F0E-2F10

CALL 032AH CALL OUTDOCD 2A 03

Go display the character in Register A

2F11

INC HL 23

Bump the value of the pointer in HL

2F12

DEC D 15

Decrement the number of times to perform the operation in Register D

2F13-2F14

JR NZ,2F0AH JR NZ,SPED20 F5

Loop until done

2F15

RET C9

RETurn to CALLer

2F16 – EDIT Command – KILL Logic – “KED” .

2F16 KED

PUSH HL E5

Save the current character position in the buffer in HL to the STACK

2F17-2F19

LD HL,2F5FH LD HL,TYPSLH 21 5F 2F

Load HL with the return address of 2F5FH (which will print the final !

2F1A

EX (SP),HL E3

Exchange the value of the return address in HL with the value of the input buffer pointer to the STACK

2F1B

SCF 37

Set the KILL/SEARCH flag for KILL since CARRY flag signals KILL

2F1C SED

PUSH AF F5

Save the KILL/SEARCH flag to the STACK

2F1D-2F1F

CALL 0384H CALL INCHRCD 84 03

Go scan the keyboard for the character the user wants to SEARCH for

2F20

LD E,A 5F

Save the character the user wants to SEARCH for into Register E

2F21

POP AF F1

Get the KILL/SEARCH flag from the STACK

2F22

PUSH AF F5

Save the KILL/SEARCH flag to the STACK

2F23-2F25

CALL C,2F5FH CALL C,TYPSLHDC 5F 2F

If KILL (because the CARRY flag was set) then GOSUB to 2F5FH to print a !

2F26 SRCALP

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2F27

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2F28-2F2A

JP Z,2F3EH JP Z,POPARTCA 3E 2F

Jump down to 2F3EH if the character in Register A is an end of the BASIC line character

2F2B-2F2D

CALL 032AH CALL OUTDOCD 2A 03

Go display the character in Register A

2F2E

POP AF F1

Get the KILL/SEARCH flag from the STACK

2F2F

PUSH AF F5

Save the KILL/SEARCH flag to the STACK

2F30-2F32

CALL C,2FA1H CALL C,DELCHRDC A1 2F

If the CARRY flag is set, that means we are in KILL mode so GOSUB to 2FA1H to delete the character from the input buffer

2F33-2F34

JR C,2F37H JR C,NOTSRC38 02

Jump to 2F37H if KILL. Note, we do not move the HL pointer in this case because DELCHR already moved it.

2F35

INC HL 23

If we are here, it must be SEARCH! So bump to the next character

2F36

INC B 04

Bump the value of the character position in Register B

2F37 NOTSRC

LD A,(HL) 7E

Regardless of whether we are SEARCH or KILL, load Register A with the character at the location of the current input buffer pointer in HL

2F38

CP E BB

Check to see if the character in Register A is the same as the character to be located (i.e., the one specified by the user) in Register E. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2F39-2F3A

JR NZ,2F26H JR NZ,SRCALP20 EB

Loop back to 2F26H until the character to be located is found

2F3B

DEC D 15

Decrement the number of times to perform the operation in Register D (as initially specified by the user by entering a number before the command)

2F3C-2F3D

JR NZ,2F26H JR NZ,SRCALP20 E8

Loop until done

2F3E POPART

POP AF F1

Get the KILL/SEARCH flag from the STACK

2F3F

RET C9

RETurn to CALLer

2F40 – EDIT Command – LIST Logic – “LED” .

2F40-2F42 LED

CALL 2B75H CALL LISPRTCD 75 2B

Since we need to display the line being edited we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device

2F43-2F45

CALL 20FEH CALL CRDOCD FE 20

Go display a carriage return if necessary

2F46

POP BC C1

Clear off the RETURN address to DISPED

2F47-2F49

JP 2E7CH JP LLEDC3 7C 2E

Jump to 2E7CH (to display the current line number and await the next EDIT command)

2F4A – EDIT Command – DELETE Logic – “DED”

2F4A DED

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2F4B

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2F5C

RET Z 15

Return if the character in Register A is an end of the BASIC line character

2F4D-2F4E

LD A,21H LD A,”!” 3E 21

Load Register A with an !

2F4F-2F51

CALL 032AH CALL OUTDOCD 2A 03

Go display the ! in Register A

2F52 DELLP

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2F53

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2F54-2F5B

JR Z,2F5FH JR Z,TYPSLH28 09

Jump to 2F5FH if the character in Register A is an end of the BASIC line character

2F56-2F58

CALL 032AH CALL OUTDOCD 2A 03

Go display the character in Register A

2F59-2F5B

CALL 2FA1H CALL DELCHRCD A1 2F

Go delete the character from the input buffer

2F5C

DEC D 15

Decrement the number of times to perform the operation in Register D (as initially specified by the user by entering a number before the command)

2F5D-2F5E

JR NZ,2F52H JR NZ,DELLP20 F3

Loop until done

2F5F-2F60 TYPSLH

LD A,21H LD A,”!” 3E 21

Load Register A with an !

2F61-2F63

CALL 032AH CALL OUTDOCD 2A 03

Go display the ! in Register A

2F64

RET C9

RETurn to CALLer

2F65 – EDIT Command – CHANGE Logic – “CED” .

2F65 CED

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2F66

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2F67

RET Z C8

Return if the character in Register A is an end of the BASIC line character

2F68-2F6A

CALL 0384H CALL INCHRCD 84 03

Go get the character to put in the input buffer from the keyboard

2F6B

LD (HL),A 77

Save the character in Register A at the memory location of the input buffer pointer in HL

2F6C-2F6E

CALL 032AH CALL OUTDOCD 2A 03

Go display the character in Register A

2F6F

INC HL 23

Bump the value of the input buffer pointer in HL

2F70

INC B 04

Bump the character position in Register B

2F71

DEC D 15

Decrement the number of times to perform the operation in Register D (as initially specified by the user by entering a number before the command)

2F72-2F73

JR NZ,2F65H JR NZ,CED20 F1

Loop until done

2F74

RET C9

RETurn to CALLer

2F75 – EDIT Command – HACK/INSERT Logic – “HED”

2F75-2F76 HED

LD (HL),00H 36 00

Set the line end to be the current position.

2F77

LD C,B 48

Load Register C with the character position in Register B which will now be the line length

2F78-2F79 XED

LD D,0FFH 16 FF

Prepare for the next CALL to find the end of the line by loading Register D with the number of times to perform the operation

2F7A-2F7C

CALL 2F0AH CALL SPEDCD 0A 2F

GOSUB to 2F0AH to display the Register BASIC line if necessary

2F7D-2F7F IED

CALL 0384H CALL INCHRCD 84 03

Go get the character to be inserted from the keyboard

2F80

OR A B7

Check to see if a key was pressed

2F81-2F83

JP Z,2F7DH JP Z,IEDCA 7D 2F

Loop back to 2F7DH until a key is pressed

2F84-2F85

CP 08H FE 08

Check to see if the character in Register A is a backspace character . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2F86-2F87

JR Z,2F92H JR Z,TYPARW28 0A

Jump to 2F92H if the character in Register A is a backspace character

2F88-2F89

CP 0DH FE 0D

Check to see if the character in Register A is a carriage return . If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2F8A-2F8C

JP Z,2FE0H JP Z,CREDCA E0 2F

Jump to 2FE0H if the character in Register A is a carriage return

2F8D-2F8E

CP 1BH FE 1B

Check to see if the character in Register A is a shift up arrow (also known as an ESCape). If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2F8F

RET Z C8

Return if the character in Register A is shift up arrow

2F90-2F91

JR NZ,2FB0H JR NZ,NTARRW20 1E

Jump to 2FB0H to add the new character to the current line

2F92 – EDIT Command – BACKSPACE CURSOR Logic – “TYPARW” .

2F92-2F93 TYPARW

LD A,08H 3E 08

Load Register A with a backspace the cursor character

2F94 TYPAR1

DEC B 05

Decrement the character position in Register B

2F95

INC B 04

Bump the character position in Register B

2F96-2F97

JR Z,2FB7H JR Z,DINGI28 1F

If this is the first character of the BASIC line Jump forward to 2FB7H

2F98-2F9A

CALL 032AH CALL OUTDOCD 2A 03

Go backspace the cursor on the video display

2F9B

DEC HL 2B

Decrement the value of the input buffer pointer in HL

2F9C

DEC B 05

Decrement the character position in Register B

2F9D-2F9F

LD DE,2F7DH LD DE,IED 11 7D 2F

Load DE with a return address of 2F7DH

2FA0

PUSH DE D5

Save the value of the return address in DE to the STACK

2FA1 – LEVEL II BASIC EDIT ROUTINE – “DELCHR”

This subroutine will delete the character pointed to by Register Pair HL and will correct Register C

2FA1 DELCHR

PUSH HL E5

Save the value of the input buffer pointer in HL to the STACK

2FA2

DEC C 0D

Decrement the character position in Register C

2FA3 CMPRSS

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2FA4

OR A B7

Check to see if the character in Register A is an end of the BASIC line character

2FA5

SCF 37

Set the Carry flag to signal that DELCHR was called

2FA6-2FA8

JP Z,0890H JP Z,POPHRTCA 90 08

If the character in Register A is an end of the BASIC line character then we are done compressing so Jump to 0890H

2FA9

INC HL 23

Bump the value of the input buffer pointer in HL

2FAA

LD A,(HL) 7E

Load Register A with the character at the location of the input buffer pointer in HL

2FAB

DEC HL 2B

Decrement the value of the input buffer pointer in HL

2FAC

LD (HL),A 77

Save the character in Register A at the location of the current input buffer pointer in HL

2FAD

INC HL 23

Bump the value of the input buffer pointer in HL

2FAE-2FAF

JR 2FA3H JR CMPRSS18 F3

Loop back to 2FA3H to keep crunching the line

2FB0 – EDIT Command – ADD A CHARACTER Logic – “NTARRW” .

2FB0 NTARRW

PUSH AF F5

Save the character to be inserted in Register A to the STACK

2FB1

LD A,C 79

Load Register A with the number of characters in the input buffer (i.e., the length of the line) in Register C

2FB2-2FB3

CP FFH CP BUFLEN FE FF

We need to make sure we aren’t trying to make the line too long, so check for the maximum BASIC line length. If they match, the Z FLAG is set, and otherwise the NZ FLAG is set. If A < the checked value, then the C FLAG is set. If A >= the checked value, the NC FLAG is set.

2FB4-2FB5

JR C,2FB9H JR C,OKINS38 03

Jump forward to 2FB9H if the maximum BASIC line length hasn’t been reached

2FB6

POP AF F1

Get the character to be inserted from the STACK and put it in Register A

2FB7-2FB8 DINGI

JR 2F7DH JR IED18 C4

The character needs to be ESCape, so jump back to 2F7DH

2FB9 OKINS

SUB B 90

Subtract the character position in Register B from the number of characters in the input buffer in Register A. This should give the current byte position

2FBA

INC C 0C

Bump the number of characters in the input buffer in Register C

2FBB

INC B 04

Bump the character position in Register B

2FBC

PUSH BC C5

Save the character position and the number of characters in the input buffer in BC to the STACK

2FBD

EX DE,HL EB

Load DE with the input buffer pointer in HL

2FBE

LD L,A 6F

Load Register L with the number of bytes to move

2FBF-2FC0

LD H,00H 26 00

Zero Register H so that the number of bytes to move can be done in a 16 bit Register Pair.

2FC1

ADD HL,DE 19

Add the value of the input buffer pointer in DE to the character count in HL

2FC2

LD B,H 44

Load Register B with the MSB of the end of the BASIC line pointer in Register H

2FC3

LD C,L 4D

Load Register C with the LSB of the end of the BASIC line pointer in Register L

2FC4

INC HL 23

Bump the value of the end of the BASIC line pointer in HL

2FC5-2FC7

CALL 1958H CALL BLTUCCD 58 19

Go move the line up out character

2FC8

POP BC C1

Get the character position and the number of characters in the input buffer from the STACK and put it in BC

2FC9

POP AF F1

Get the character to be inserted from the STACK and put it in Register A

2FCA

LD (HL),A 77

Save the character in Register A at the location of the current input buffer pointer in HL

2FCB-2FCD

CALL 032AH CALL OUTDOCD 2A 03

Go display the character in Register A

2FCE

INC HL 23

Bump the value of the input buffer pointer in HL

2FCF-2FD1

JP 2F7DH JP IEDC3 7D 2F

Jump back to 2F7DH to get more characters

2FD2 – EDIT Command – BACKSPACE Logic – “DELED” .

2FD2 DELED

LD A,B 78

Top of a loop. Test to see if we are moving back past the first character by first loading Register A with the number of times to backspace in Register B

2FD3

OR A B7

Check to see if this is the start of the BASIC line

2FD4

RET Z C8

Return if this is the start of the BASIC line

2FD5

DEC B 05

Decrement the character position in Register B

2FD6

DEC HL 2B

Decrement the value of the buffer pointer in HL

2FD7-2FD8

LD A,08H 3E 08

Load Register A with a backspace the cursor character

2FD9-2FDB

CALL 032AH CALL OUTDOCD 2A 03

Backspace the cursor on the video display

2FDC

DEC D 15

Decrement the number of times to perform the operation in Register D

2FDD-2FDE

JR NZ,2FD2H JR NZ,DELED20 F3

Loop until done

2FDF

RET C9

RETurn to CALLer

2FE0-2FE2 CRED

CALL 2B75H CALL LISPRTCD 75 2B

Since we need to display the rest of the BASIC line, we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device

2FE3-2FE5 EED

CALL 20FEH CALL CRDOCD FE 20

Go display a carriage return if necessary

2FE6

POP BC C1

Clean up the STACK (to remove the DISPED return address)

2FE7

POP DE D1

Get the BASIC line number (in binary) from the STACK and put it in DE

2FE8

LD A,D 7A

Load Register A with the MSB of the BASIC line number in Register D

2FE9

AND E A3

Combine the LSB of the BASIC line number in Register E with the MSB of the BASIC line number in Register A

2FEA

INC A 3C

Bump the combined BASIC line number in Register A

2FEB-2FED EDITRT

LD HL,(40A7H) LD HL,(BUFPNT) 2A A7 40

Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer

2FEE

DEC HL 2B

Decrement the value of the input buffer pointer in HL

2FEF

RET Z C8

Return if this is the Level II BASIC command mode

2FF0

SCF 37

Set the Carry flag to to fool the INSERT code; this flags the line number has having been seen

2FF1

INC HL 23

Bump the value of the input buffer pointer in HL

2FF2

PUSH AF F5

Save the command mode flag in AF to the STACK

2FF3-2FF5

JP 1A98H JP EDENTC3 98 1A

Jump to entry point in the main Level II processing code

2FF6 – EDIT Command – QUIT Logic – “QED” .

2FF6 QED

POP BC C1

Get rid of the DISPED return address

2FF7

POP DE D1

Get the line number off of the stack

2FF8-2FFA

JP 1A19H JP READYC3 19 1A

Jump to the Level II BASIC READY routine

2FFB-2FFF

NOP 00

THE END OF THE LEVEL II BASIC ROMS

2FFB-2FFF

NOP 00

Nothing here

*2FFB-2FFC

SBC A,0C3H

In ROM v1.2 this is just garbage

2FF8-2FFA

JP 1A19H JP READYC3 19 1A

Jump to the Level II BASIC READY routine