8-Bit Software

BC6A Set Variable to value from BASIC Stack

Submitted by Steve Fewell

Description:

If the variable type (location &39) is #&80 then the variable is a String (which needs to be appended with a
terminating '<cr>' character); so:

* [&BC95] Load A with the last byte on the BASIC stack (&04-&05).

    This is the length of the String value. Store this value in X.

* If the length of the String is zero then store #&0D '&lt;cr&gt;' at the end of the String

    value and jump to &BCE1 to restore the stack space used by the String value (without overwriting the SWA).

* Set Y to 1

*   1) [&BC9C] Load the character at the BASIC stack location offset with Y

*   2) Decrement Y

*   3) Store the character loaded from the BASIC stack in the variable's value location (pointed to

          by &37-&38)

*   4) Increment Y by 2 - so that Y points to the next character to read from the BASIC Stack

*   5) Decrement X (the number of characters that we still need to process)

*   6) If X is not zero then jump back to step 1) to get the next character from the BASIC stack

* [&BCA6] Store #&0D '<cr>' at the end of the String value and jump to &BCE1 to restore

    the stack space used by the String value (without extracting it to the SWA).

If the variable type (location &39) is less than #&80 then the variable is an Integer (#&04), or a byte
(#&00), or Floating-Point (#&05); [i.e. Numeric], so:

* [&BCAA] Load the byte from the top of the BASIC stack (pointed to by &04-&05)

* Store the byte loaded from the BASIC stack to the variable's value location byte 1 (pointed to by

    &37-&38)

* Set Y to #&04 (as the length of the Integer will be 4 bytes)

* If the value in location &39 is zero then the value on the BASIC stack was 1-byte in length,

    so jump to &BCCE to set A to Y, clear the carry and jump to &BCFD to move the BASIC

    stack up A (i.e. 4) bytes [to ignore the other 3 bytes (which are zero)] and exit.

* Load the next byte from the BASIC Stack (pointed to by [&04-&05] + 1) & set Y to 1

* Store the byte in byte 2 of the variable's value location (pointed to by (&37-&38) + 1)

* Load the next byte from the BASIC Stack (pointed to by [&04-&05] + 2) & set Y to 2

* Store the byte in byte 3 of the variable's value location (pointed to by (&37-&38) + 2)

* Load the next byte from the BASIC Stack (pointed to by [&04-&05] + 3) & set Y to 3

* Store the byte in byte 4 of the variable's value location (pointed to by (&37-&38) + 3)

* Increment Y to 4

* Compare Y with the value at location &39 (i.e. the variable type, or the variable byte length)

* If Y is more than or equal to the value of location #&39, then jump to &BCCE to set A to Y,

    clear the carry and jump to &BCFD to move the BASIC Stack up A (i.e. 4) bytes

    and exit.

* Otherwise:

       1) Load the next byte from the BASIC Stack (pointed to by [&04-&05] + 4) & set Y to 4

       2) Store the byte in byte 5 of the variable's value location (pointed to by (&37-&38) + 4)

       3) Increment Y to 5

       4) [&BCCE] Set A to Y (5) and clear the carry flag

       5) Jump to &BCFD to move the BASIC Stack up A (i.e. 5) bytes

Otherwise, the variable type (location &39) is #&81 (String - without a '<cr>'), so:

* [&BC72] Set X to the Byte at the top of the BASIC Stack (pointed to by (&04-&05))

* If X is zero then [&BC8D] Set Y to #&03, Store the byte from the BASIC stack (#&00)

    in the location pointed to by (&37-&38) + Y and jump to &BCE1 to restore the stack space

    used by the String (Y bytes) without overwriting the SWA

* Load the first 2 bytes pointed to by (&37-&38) i.e. the String variable value's address and

    subtract 1 from the variable's address.

* [&BC83] Store the String variable value's address [minus 1] in locations &39-&3A

* Set Y to 1

* [&BC85] Keep on loading the next byte from the BASIC stack (offset Y), storing it at the address

    of the variable's value (&39-&3A, offset Y), incrementing Y and decrementing X

    until X has reached zero (i.e. we have copied the entire String value from the BASIC stack to the String

    variable's value - thus replacing the String variable's current value with its original value).

* [&BC8D] Load A with the first byte from the BASIC stack (the length of the String variable on the

    Stack) and store the String length byte as the String variable's length (i.e. the address pointed to by

    &37-&38 - plus an offset value of 3).

* Jump to &BCE1 to restore the Stack Space used by the String (i.e. the number of bytes specified in A)

* Note: As we are restoring the String variable's original value - there is no need to check whether the

    String variable has enough space allocated to hold the String value.

Disassembly for the Set Variable to value from BASIC Stack routine