Altair BASIC 3.2 (4K)

[Index] [Previous] [Next]

1.18 Variable Management

Dim

Declares an array. Note that the start of this function handler is some way down in the block (at 0716).

Get next program character and return if null byte at end of line has been reached.

0711 2B DimContd DCX H

0712 D7 RST NextChar

0713 C8 RZ

Syntax check for a comma.

0714 CF RST SyntaxCheck

0715 2C ','

Set return address to DimContd above.

0716 011107 Dim LXI B,DimContd

0719 C5 PUSH B

Set A to a non-zero number before falling into GetVar+1. This indicates to GetVar that we're declaring rather than accessing an array.

071A F6AF ORI AF

GetVar

Given that HL points to a variable name that's been encountered during program interpretation, this function will return in DE a pointer to that variable's value. If the variable does not exist, then (space permitting) this function also allocates and initialises it.

??? Signalling this is a real call to GetVar, not dropped in from DIM

071B AF GetVar XRA A

071C 325B01 STA DIM_OR_EVAL

Get variable name into BC, B=first char and C=(optional) second char. Notice we Syntax Error out if the first character is not alphabetic.

071F 46 MOV B,M

0720 CD8004 CALL CharIsAlpha

0723 DAD001 JC SyntaxError

0726 AF XRA A

0727 4F MOV C,A

0728 D7 RST NextChar

0729 D22E07 JNC 072E

072C 4F MOV C,A

072D D7 RST NextChar

If next char is '(' then we're dealing with an array and so jump to GetArrayVar (the following block) to deal with it.

072E D628 SUI '('

0730 CA8A07 JZ GetArrayVar

Preserve program ptr on stack, and get VAR_ARRAY_BASE into DE and VAR_BASE into HL. This is where we iterate through the stored variables (ie from VAR_BASE to VAR_ARRAY_BASE) to see if the variable has already been declared.

0733 E5 PUSH H

0734 2A6901 LHLD VAR_ARRAY_BASE

0737 EB XCHG

0738 2A6701 LHLD VAR_BASE

Loop to find the variable if it's already been allocated. If HL==DE then we've reached VAR_ARRAY_BASE without finding it, and so can jump ahead to allocate a new variable.

073B E7 FindVarLoop RST CompareHLDE

073C CA5207 JZ AllocNewVar

073F 79 MOV A,C

0740 96 SUB M

0741 23 INX H

0742 C24707 JNZ 0747

0745 78 MOV A,B

0746 96 SUB M

0747 23 INX H

0748 CA8207 JZ 0782

074B 23 INX H

074C 23 INX H

074D 23 INX H

074E 23 INX H

074F C33B07 JMP FindVarLoop

Prepare to alloc a new variable, but first we have to do something slightly bizarre... we check the return address to see if it's the expression evaluator that's called us, and if it is then we exit without allocating. Notice that (assuming we haven't been called by the evaluator) the prog ptr on the stack is kept in place.

0752 E1 AllocNewVar POP H HL=prog ptr

0753 E3 XTHL (SP)=prog ptr, HL=ret.addr.

0754 D5 PUSH D

0755 11F606 LXI D,06F6 an address inside EvalTerm

0758 E7 RST CompareHLDE

0759 D1 POP D

075A CA8507 JZ AlreadyAllocd

075D E3 XTHL (SP)=ret.addr, HL=prog ptr.

075E E5 PUSH H Prog ptr back on stack

Allocate memory for the variable. We need a space of 6 bytes to be inserted before the array variables storage pointed to by VAR_ARRAY_BASE, so we copy that block up 6 bytes in memory.

075F C5 PUSH B Preserve var name on stack

0760 010600 LXI B,0006

0763 2A6B01 LHLD VAR_TOP

0766 E5 PUSH H

0767 09 DAD B

0768 C1 POP B

0769 E5 PUSH H

076A CDA701 CALL CopyMemoryUp

076D E1 POP H

076E 226B01 SHLD VAR_TOP

Update VAR_ARRAY_BASE cos the array block has been moved up 6 bytes.

0771 60 MOV H,B

0772 69 MOV L,C

0773 226901 SHLD VAR_ARRAY_BASE

Initialise the new variable to zero.

0776 2B InitVarLoop DCX H

0777 3600 MVI M,00

0779 E7 RST CompareHLDE

077A C27607 JNZ InitVarLoop

Restore variable name to DE and write it to the first 2 bytes of the variable's storage.

077D D1 POP D

077E 73 MOV M,E

077F 23 INX H

0780 72 MOV M,D

0781 23 INX H

Swap HL and DE so that DE points to the variable value, then restore the prog ptr to HL and return

0782 EB XCHG

0783 E1 POP H

0784 C9 RET

Function exit for when called by EvalTerm. Here we set FACCUM to zero (don't know why), restore the prog ptr to HL and return.

0785 327201 AlreadyAllocd STA FACCUM+3 A was set to zero at 075A.

0788 E1 POP H

0789 C9 RET

GetArrayVar

Accesses or allocates an array variable. The contents of DIM_OR_EVAL indicate whether we're dealing with an array declaration (ie a DIM statement) or whether an array element is being accessed. In the former case DIM_OR_EVAL is 0xEF, otherwise it is 0.

Preserve variable name on stack.

078A C5 GetArrayVar PUSH B

Push declare-or-access flag on stag

078B 3A5B01 LDA DIM_OR_EVAL

078E F5 PUSH PSW

Get array subscript into CDE

078F CD8804 CALL GetSubscript

Syntax check for closing bracket ')'

0792 CF RST SyntaxCheck

0793 29 ')'

Restore declare-or-access flag

0794 F1 POP PSW

0795 325B01 STA DIM_OR_EVAL

Get variable name from stack into DE; HL becomes the subscript previously in DE; previous value of HL goes on stack.

0798 E3 XTHL

0799 EB XCHG

Multiply the subscript by 4 and stick it on the stack.

079A 29 DAD H

079B 29 DAD H

079C E5 PUSH H

Load HL with the base of array storage and LXI into FindArray+2

079D 2A6901 LHLD VAR_ARRAY_BASE

07A0 01C109 LXI B,....

Find the array loop. First thing we do is advance the array ptr by {subscript}

07A1 C1 FindArray POP B

07A2 09 DAD B

07A3 EB XCHG

If we've reached VAR_TOP then we know the array has not already been declared, so we can jump forward to allocate it.

07A4 E5 PUSH H

07A5 2A6B01 LHLD VAR_TOP

07A8 E7 RST CompareHLDE

07A9 EB XCHG

07AA D1 POP D

07AB CACD07 JZ AllocArray

Advance to the next array in the block.

07AE F7 RST PushNextWord

07AF E3 XTHL

07B0 E7 RST CompareHLDE

07B1 E1 POP H

07B2 F7 RST PushNextWord

07B3 C2A107 JNZ FindArray

Array found. If we're in a DIM statement then this is a duplicate definition error. You can only DIM an array the once.

07B6 3A5B01 LDA DIM_OR_READ

07B9 B7 ORA A

07BA 1E12 MVI E,12

07BC C2D501 JNZ Error

Array element retrieval. First we ???

07BF D1 POP D

07C0 1B DCX D

07C1 E3 XTHL

If the subscript is greater than or equal to the number of array elements, then 'Bad Subscript' error.

07C2 E7 RST CompareHLDE

07C3 1E10 MVI E,10

07C5 D2D501 JNC Error

Return with DE pointing to the element value, and HL the prog ptr.

07C8 D1 POP D

07C9 19 DAD D

07CA D1 POP D

07CB EB XCHG

07CC C9 RET

Allocate space for the array. Here, DE holds the array name and HL points to where it is going to be stored. We start by storing the array name.

07CD 73 AllocArray MOV M,E

07CE 23 INX H

07CF 72 MOV M,D

07D0 23 INX H

If DIM_OR_EVAL is zero (indicating array access), then jump ahead with DE=????

07D1 112C00 LXI D,002C

07D4 3A5B01 LDA 015B

07D7 B7 ORA A

07D8 CAE107 JZ 07E1

DIM_OR_EVAL is not zero, therefore we're declaring the array. Here we restore the array elements size to DE, save it again, add 4, and write that value to follow the array name.

07DB D1 POP D

07DC D5 PUSH D

07DD 13 INX D

07DE 13 INX D

07DF 13 INX D

07E0 13 INX D

Write out array size.

07E1 D5 PUSH D

07E2 73 MOV M,E

07E3 23 INX H

07E4 72 MOV M,D

07E5 23 INX H

07E6 E5 PUSH H

Check the new VAR_TOP won't interfere with the stack, and update VAR_TOP.

07E7 19 DAD D

07E8 CDC301 CALL CheckEnoughMem

07EB 226B01 SHLD VAR_TOP

Initialise all array elements to 0.

07EE D1 POP D

07EF 2B InitElements DCX H

07F0 3600 MVI M,00

07F2 E7 RST 4

07F3 C2EF07 JNZ InitElements

07F6 C3BF07 JMP 07BF

[Index] [Previous] [Next]