8-Bit Software

The BBC and Master Computer Public Domain Library

Last updated

89EB Assemble Assembly instruction/statement

Submitted by Steve Fewell

Description:

[89EB] Get the first non-space character from BASIC Text Pointer A.
Set Y and location &3D (the Mnemonic Code LSB location) to 0.
If the next character is ':', then jump to &8A5E to store current instruction (if any) and exit.
If the next character is '<cr>' [carriage return], then jump to &8A5E to store current instruction (if any) and exit.
Note: No need to check for 'ELSE', as 'ELSE' is invalid in assembly mode.

If next character is '\' then jump to &8A5E (Store current instruction (if any) and skip comment).

If the next characer is '.' then we need to create a label, as follows:
* Call routine &98AE to evaluate the variable name (and create it if the variable doesn't already exist
and isn't a direct memory access.
* If the zero flag is set on return from &98AE, then a variable was not specified, so generate 'Syntax error'.
* If the carry flag is set on return from &98AE, then the variable was a String-variable, so generate 'Syntax
error' as an address value cannot be stored in a string variable.
* Push variable address and type details (&2A-&2B) to the stack.
* Set the IWA value to P% (&0440-&0441).
* Store variable type (#&40 - Integer) in location &27.
* Call routine &B32B to set the Numberic variable (details on Stack) to the IWA Integer value.
* Call routine &9275 to update the BASIC Text Pointer A offset to equal the Text Pointer B offset value.
* Store the BASIC Text Pointer A offset value in location &4E.
* return to &89EB to skip spaces, and check for end of statement.
Decrement the BASIC Text Pointer A offset value (as the character we got last was not recognised as having a special function).

[&8A04] Encode and validate the 3-character Mnemonic value
Set X to 3 (as we will check the next 3 characters to see if they match an assembly Mnemonic Code).
[&8A06] Get next character from PTR A.
If the character is negative, then we have found a BASIC token, check the token for a Mnemonic code, as follows [&8A38]:
* If token is &80 ('AND'), then set X (Mnemonic position in Mnemonic lookup table) to #&29 and jump
to &8A5E to process the assembly Mnemonic.
* If token is &82 ('EOR'), then set X (Mnemonic position in Mnemonic lookup table) to #&2A and jump
to &8A5E to process the assembly Mnemonic.
* If token is &84 ('OR'), then check next character. If next character is 'A' or 'a' (zeroing Bit 5 of the ASCII
value removes the upper-lower case distinction) then Set X (Mnemonic position in Mnemonic lookup table) to &2B, &
jump to &8A5E to process the assembly Mnemonic. Otherwise (next character is not 'A' or 'a') issue a 'Syntax error',
as the Assembly Mnemonic 'ORA' is not present, and we do not have a valid Assembly Mnemonic code.
* Otherwise (as the token isn't 'AND', 'OR' or 'EOR'), the token is not a valid Assembly Mnemonic, so generate a
'Syntax error'.
If the character is a space (' '), then jump to &8A22 to check the mnemonic code found so far (as space terminates
the Mnemonic code).

Now, before we test the Mnemonic, we need to compact each character of the Mnemonic (usually 3 characters in total)
into a 2-byte code. This has 2 main advantages: (1) it saves space, and (2) it strips off the case bit from the ASCII
character, so that Mnemonics are recognised irrespective of whether they appear in upper or lower case (or a mixture
of both).
Set Y to 5 (as we will pack each character into 5-bits).
Multiply the current ASCII character by 8 (by shifting all bits left 3 places, and loosing the top 3 bits).
This leaves us with the bottom 5 bits of the ASCII code. The character has now lost it's case distinction
(bit 5), so now 'A' and 'a' result in the same 5-bit value. Additionally, the #&40 (64) offset is removed,
so that 'A' is now 1, 'B' is 2, etc...
Now, move the top 5-bits of the character (the bits that are left after the earlier shift), into the bottom bit of
the 2-byte location &3D-&3E. &3D-&3E will (after all 3 Mnemonic characters have been processed in this
way) contain the 2-byte Mnemonic Code, which will uniquely identify the Assembly Mnemonic.
Decrement X (number of characters to process), and, if X is not 0, jump back to &8A06 to process the next character.

[&8A22] Check the Mnemonic code:
Now that a maximum of 3 characters have been encoded, and &3D-&3E contain 15 bits from the 3-character
Assembly Mnemonic. the coded Mnemonic (&3D-&3E) needs to be checked against the Mnemonic code lookup tables
located between address &884D and &88D6.
The Encoded Mnemonic LSB value (&3D) is looked up in the Mnemonic LSB lookup table (&884D-&8891)
(looking at the last value in the table first, then moving down towards the first value).
When a matching LSB Mnemonic value is found, the Mnemonic MSB value is then checked against the
corresponding entry in the Mnemonic MSB table (&8893-&88D6). If both codes matche then we have a valid Mnemonic
Code, so jump to &8A5E to process the Mnemonic statement.

Otherwise, continue searching with the next Mnemonic LSB code in the Mnemonic LSB table (&884D-&8891).
If the end of the Assembly Mnemonic LSB table (&884D-&8891) is reached, and the encoded Mnemonic 2-byte code
was not matched against the entries in the table, then an invalid Mnemonic was specified, so issue a 'Syntax error'.

[&8A53] A valid Assembly Mnemonic has been found! Now, start to process it
Now, X points to the position of the Assembly Mnemonic in the lookup tables.
Store the default opcode (from the Default Opcode lookup table, located at &88D7-&891B at position X) in
location &29.
Set Y = 1 (default length of Assembly Instruction is 1-byte (i.e. a single-byte Mnemonic code with no parameters)).

The Mnemonic codes in the Mnemonic lookup tables are listed in an order that enables them to be processed more easily.
I.e. the first &1F (31) Mnemonics are single-byte Instructions.

1) Check if we have a single-byte Mnemonic
If X (the Mnemonic position) is less than #&20 then we have a single-byte Mnemonic (i.e. One of the following:
BRK, CLC, CLD, CLI, CLV, DEX, DEY, INX, INY, NOP, PHA, PHP, PLA, PLP, RTI, RTS, SEC, SED, SEI, TAX, TAY, TSX, TXA, TXS,
TYA, DEA, INA, PHY, PHX, PLY, or PLX).
Single byte instructions have no parameters, and no indexing modes, so the Default Opcode (&29) is the Opcode
that we need to use, so jump to &8A5E to store the assembly instruction.

2) Check if we have a branch-statement Mnemonic
If X (Mnemonic position) is < #&29 then the Mnemonic is a Branch statement (i.e. one of: BCC, BCS, BEQ, BMI, BNE,
BPL, BVC, BVS or BRA), so process as follows:
* Get the Integer result of the expression at BASIC Text pointer A (or 'Type mismatch' error if a String value was found).
* The Integer result will be a 16-bit address value (in &2A-&2B).
* Subtract the current physical location (P% + 1) from the address specified (by the result value).
* (Now, Y is the LSB difference, and A is the MSB difference in the address values).
* If Y is 0 then subtract 1 from A and decrement Y (difference is &100, treated as &FFFF (-1)).
* If A is 0 then: * Check Y; if Y is negative (top bit set) then issue 'Out of range' error.
                     * Otherwise, goto &8ADF with Y = number of Bytes to branch, as Y is within the valid range of 1 to 127.
* If A is &FF and Y is negative, then we are branching backwards (to a previous instruction), and the branch is
within the required ramge of -1 to -128, so goto &8ADF with Y = number of bytes to branch.
* Otherwise, if OPT flag bit 2 is not set (errors are not reported), then skip the out of range error, and set Y
(the number of bytes to branch) to 0 (as a placemaker, until we have the actual Branch value), and goto &8ADF.
* [Note: OPT flag bit 2 is not set for OPT codes 0, 1, 4 & 5 (don't report errors); and it is set for 2, 3, 6
& 7 (report errors))]
* Otherwise, if OPT flag bit 2 is set then issue an 'Out of range' error.
* [8ADF]: Now we have a valid branch, so Store Y (bytes to branch) in &2A, set Y to 2 (length of instruction),
and jump to &8A5E to store the assembly instruction.

3) Process Mnemonics AND, EOR, ORA, ADC, CMP, LDA, SBC (and also used by STA, see later)
If X (Mnemonic position) is < #&30 then the Mnemonic is one of the following: AND, EOR, ORA, ADC, CMP, LDA or SBC,
so process as follows:
* If the next non-space character is '#' then we have an immediate value indexing mode. Process as follows:
* Add 8 to the defalt opcode (in location &29)
* Get the Integer result of the expression at BASIC Text Pointer A (Type mismatch error if a String value was found).
* Issue a 'Byte' error if the Integer result is more than 255 (#&FF).
* Set Y to 2 (length of instruction is 2 bytes) and goto &8A5E to store the instruction.
* This handles the following Mnemonic instructions:
*     AND#nn (opcode &29).
*     EOR#nn (opcode &49).
*     ORA#nn (opcode &09).
*     ADC#nn (opcode &69).
*     CMP#nn (opcode &C9).
*     LDA#nn (opcode &A9).
*     SBC#nn (opcode &E9).
*     [Note: STA does not have an immediate mode, so for STA Mnemonic, this routine is entered at &8B07].
* [8B07] If the next non-space character is not '(' then we have an absolute or zero page addressing mode. So:
* [8B44] Get the Integer result of the expression at BASIC Text Pointer A (Type mismatch error if a String value was found).
* If the next non-space character is ',' [comma] then process index-offset mode as follows:
     > Add 16 to default opcode value (&29).
     > If next character is 'Y' then add 8 to the Opcode, set Y (length of instruction) to 3, & goto &8A5E to
       store the instruction.
     > -- This handles the following Mnemonic instructions:
     >       AND abs,Y (opcode &39).
     >       EOR abs,Y (opcode &59).
     >       ORA abs,Y (opcode &19).
     >       ADC abs,Y (opcode &79).
     >       CMP abs,Y (opcode &D9).
     >       LDA abs,Y (opcode &B9).
     >       SBC abs,Y (opcode &F9).
     >       STA abs,Y (opcode &99).
     > Otherwise, add 4 to the Opcode.
     > If the Integer value is a 16-bit address (more than 255) then add 8 to Opcode,
       set Y to 3 (instruction is 3 bytes long) and goto &8A5E to store the instruction.
     > -- This handles the following Mnemonic instructions:
     >       AND abs (opcode &2D).
     >       EOR abs (opcode &4D).
     >       ORA abs (opcode &0D).
     >       ADC abs (opcode &6D).
     >       CMP abs (opcode &CD).
     >       LDA abs (opcode &AD).
     >       SBC abs (opcode &ED).
     >       STA abs (opcode &8D).
     >       AND abs,X (opcode &3D).
     >       EOR abs,X (opcode &5D).
     >       ORA abs,X (opcode &1D).
     >       ADC abs,X (opcode &7D).
     >       CMP abs,X (opcode &DD).
     >       LDA abs,X (opcode &BD).
     >       SBC abs,X (opcode &FD).
     >       STA abs,X (opcode &9D).
     > Otherwise, we have an 8-bit address, so set Y to 2 (length of instruction is 2 bytes),
       and goto &8A5E to store the instruction.
     > -- This handles the following Mnemonic instructions:
     >       AND zp (opcode &25).
     >       EOR zp (opcode &45).
     >       ORA zp (opcode &05).
     >       ADC zp (opcode &65).
     >       CMP zp (opcode &C5).
     >       LDA zp (opcode &A5).
     >       SBC zp (opcode &E5).
     >       STA zp (opcode &85).
     >       AND zp,X (opcode &35).
     >       EOR zp,X (opcode &55).
     >       ORA zp,X (opcode &15).
     >       ADC zp,X (opcode &75).
     >       CMP zp,X (opcode &D5).
     >       LDA zp,X (opcode &B5).
     >       SBC zp,X (opcode &F5).
     >       STA zp,X (opcode &95).
* [8B0B] If the next non-space character is '(' then we have an indirect addressing mode. So:
* Get the Integer result of the expression at BASIC Text Pointer A (Type mismatch error if a String value was found).
* If the next character is ")" then we do not have an indirectly indexed instruction, so process as follows:
     > Add 16 to default opcode value (&29).
     > If next character is not ',' [comma] then Add 1 to the opcode and issue 'Byte' error
if the integer value is > 255; otherwise, set Y to 2 (length of instruction) and goto &8A5E to store the instruction.
     > -- This handles the following Mnemonic instructions:
     >       AND(zp) (opcode &32).
     >       EOR(zp) (opcode &52).
     >       ORA(zp) (opcode &12).
     >       ADC(zp) (opcode &72).
     >       CMP(zp) (opcode &D2).
     >       LDA(zp) (opcode &B2).
     >       SBC(zp) (opcode &F2).
     >       STA(zp) (opcode &92).
     > If next character is ',' [comma] then issue 'Index' error if the next non-space character
        is not 'Y' or 'y', or 'Byte' error if the Integer result is > 255; otherwise,
set Y to 2 (length of instruction) and goto &8A5E to store the instruction.
     > -- This handles the following Mnemonic instructions:
     >       AND(zp),Y (opcode &31).
     >       EOR(zp),Y (opcode &51).
     >       ORA(zp),Y (opcode &11).
     >       ADC(zp),Y (opcode &71).
     >       CMP(zp),Y (opcode &D1).
     >       LDA(zp),Y (opcode &B1).
     >       SBC(zp),Y (opcode &F1).
     >       STA(zp),Y (opcode &91).
     > .
     > .
     > .
* Otherwise (next character is not ')') issue 'Index' error if a ',' [Comma] is not the next non-space character.
* Issue 'Index' error if the next non-space character after the ',' is not 'X' or 'x'.
* Issue 'Index' error if the next non-space character after the 'X', or 'x', is not ')'.
* Issue 'Byte' error if the Integer value is more than 255.
* [Note: no opcode changes for this indexing mode, as the opcode used is the default Opcode for the Mnemonic].
* Set Y to 2 (length of instruction is 2 bytes) and goto &8A5E to store the instruction.
* This handles the following Mnemonic instructions:
*     AND(zp,X) (opcode &21).
*     EOR(zp,X) (opcode &41).
*     ORA(zp,X) (opcode &01).
*     ADC(zp,X) (opcode &61).
*     CMP(zp,X) (opcode &C1).
*     LDA(zp,X) (opcode &A1).
*     SBC(zp,X) (opcode &E1).
*     STA(zp,X) (opcode &81).

4) Process Mnemonic STA
If X (Mnemonic position) is < #&41 then the Mnemonic is STA. STA is handled in the same way as AND, EOR, ORA, ADC,
CMP, LDA and SBC, except that it doesn't have an immediate '#' addressing mode.
so process by jumping to &8B07 (above), which skips the Immediate addressing mode and continues to process the
other addressing modes.

5) Process Mnemonics ASL, LSR, ROL, ROR, DEC and INC (and also used by BIT, see later)
[&8B67] If X (Mnemonic position) is < #&36 then the Mnemonic is one of the following: ASL, LSR, ROL, ROR, DEC or INC,
so process as follows:
* If the next non-space character is 'A' or 'a' then the Mnemonic could be an Accumulator operator, so:
* Check the next character after the 'A' or 'a'. If the next character is not valid variable name character
('A'-'Z','a'-'z','0'-'9','_' or '£') then the A refers to the Accumulator, so:
      * If X (Mnemonic position) < #&34 (ASL, LSR, ROL or ROR) then add 4 to the opcode (&29).
      * Otherwise, if X = #&34 (DEC) then set the opcode to #&3A.
      * Otherwise, if X = #&35 (INC) then set the opcode to #&1A.
      * Set Y to 1 (length of instruction) and goto &8A5E to store the instruction.
      -- This handles the following Mnemonic instructions:
           ASL A (opcode &0A).
           LSR A (opcode &4A).
           ROL A (opcode &2A).
           ROR A (opcode &6A).
           DEC A (opcode &3A).
           INC A (opcode &1A).
           [Note: BIT does not have an accumulator mode, so for BIT Mnemonic, this routine is entered at &8B74].
* Otherwise:
      * [&8B74] Get the Integer result of the expression at BASIC Text pointer A.
      * Get the next non-space character at BASIC Text pointer A.
      * If the next character is "," [comma] then :
           * Add 16 to the Opcode (&29).
           * If the next non-space character is not "X" or "x" then 'Index' error
      * [8B61] If 16-bit Integer then add 8 to Opcode (&29), Set Y = 3 and Store instruction.
      * Otherwise, Set Y to 2 and Store instruction.
      * This handles the following Mnemonic instructions:
           ASL abs (opcode &0E).
           LSR abs (opcode &4E).
           ROL abs (opcode &2E).
           ROR abs (opcode &6E).
           DEC abs (opcode &CE).
           INC abs (opcode &EE).
           BIT abs (opcode &2C).
           ASL abs,X (opcode &1E).
           LSR abs,X (opcode &5E).
           ROL abs,X (opcode &3E).
           ROR abs,X (opcode &7E).
           DEC abs,X (opcode &DE).
           INC abs,X (opcode &FE).
           BIT abs,X (opcode &3C).
           ASL zp (opcode &06).
           LSR zp (opcode &46).
           ROL zp (opcode &26).
           ROR zp (opcode &66).
           DEC zp (opcode &C6).
           INC zp (opcode &E6).
           BIT zp (opcode &24).
           ASL zp,X (opcode &16).
           LSR zp,X (opcode &56).
           ROL zp,X (opcode &36).
           ROR zp,X (opcode &76).
           DEC zp,X (opcode &D6).
           INC zp,X (opcode &F6).
           BIT zp,X (opcode &34).

6) Process Mnemonics CLR and STZ
If X (Mnemonic position) is < #&38 then the Mnemonic is one of the following: CLR or STZ.
Both of these Mnemonics represent the same Opcode (default Opcode value=&9C). Process as follows:

* Get the Integer result of the expression at BASIC Text pointer A (or 'Type mismatch' error if a String value was found).
* If Integer is an 8-bit address then set X to #&0F, Opcode (&29) to #&64 and Y to 2.
* If Integer is a 16-bit address then set X to #&01 and Y to 3.
* [8BB7] Store Y to the Stack.
* If the next non-space characetr is not "," then pop Y and Store Intruction.
* If the next non-space character is not 'X' or 'x', then issue a 'Index' error.
* Otherwise, add (1 + X) to the Opcode value (&29), Pop Y from the stack (length of instruction), and Store instruction.
* This handles the following Mnemonic instructions:
    STZ (or CLR) zp (opcode &64).
    STZ (or CLR) zp,X (opcode &74).
    STZ (or CLR) abs (opcode &9C).
    STZ (or CLR) abs,X (opcode &9E).

7) Process Mnemonics CPX, CPY, TSB or TRB
If X (Mnemonic position) is < #&3C then the Mnemonic is one of the following: CPX, CPY, TSB or TRB,
so process as follows:
* If the Mnemonic is CPX or CPY then check for Immediaate mode (TSB and TRB do not have an Immediate addressing mode):
      If the next non-space character is '#' then [8BE7] Get Integer value of expression, if the Integer is greater than
      255 then issue 'Byte' error, otherwise set Y to 2, and Store Intruction.
      This handles the following Mnemonic instructions:
         CPX# nn (Opcode &E0)
         CPY# nn (Opcode &C0)
      Otherwise (if char not '#'), decrement BASIC Text Pointer A offset.
* [&8BD9] Get Integer result of expression from BASIC Text Pointer A (Convert Float value to Integer or issue 'Type mismatch'
    error if a String value was found).
* [&8B5E] Add 4 to the Opcode value (&29).
* If Integer is an 8-bit value (< 256) then (zero page addressing mode) Set Y to 2 (length is 2 bytes) & Store Instruction.
* Otherwise (Integer is an 16-bit value) (> 255), Add 8 to Opcode (&29), Set Y to 3 (length is 3 bytes) and Store Instruction.
* This handles the following Mnemonic instructions:
     CPX zp (opcode &E4).
     CPY zp (opcode &C4).
     TSB zp (opcode &04).
     TRB zp (opcode &14).
     CPX abs (opcode &EC).
     CPY abs (opcode &CC).
     TSB abs (opcode &0C).
     TRB abs (opcode &1C).

8) Process Mnemonics BIT, JSR and JMP
If X (Mnemonic position) is < #&3F then the Mnemonic is one of the following: BIT, JSR or JMP,
so process as follows:
* If the Mnemonic is BIT, then:
* [&8BDE] If the next non-space character is not '#' then goto &8B74 (in step 5 above) to process BIT in the same
way as the Absolute, Absolute,X, Zero Page and Zero Page,X addressing modes for Mnemonics ASL, LSR, ROL, ROR, DEC and INC.
* Otherwise, we have BIT with Immediate mode addressing (which couldn't be handled by &8B74, as ASL, LSR, ROL, ROR,
DEC and INC do not have an immediate mode. Process as follows:
* Set the Opcode (&29) to #&89 (Instruction: BIT# nn).
* [&8BF2] Get Integer result of the expression at BASIC Text Pointer A.
* If the Integer result is > 255 then issue 'Byte' error. Otherwise set Y to 2 and Store Instruction.
* This handles the following Mnemonic instruction:
     BIT#nn (opcode &89).
* If the Mnemonic is JSR, then:
* [&8BFB] Get Integer value of the expression at BASIC Text Pointer A.
* Set Y to 3 (length of instruction is 3 bytes) and goto &8A5E to store the instruction.
* This handles the following Mnemonic instruction:
     JSR abs (opcode &20).
* If the Mnemonic is JMP, then:
* If the next non-space character is not '(' then Decrement BASIC Text Pointer A offset and get Integer result of
expression at Text Pointer A, Set Y to 3 and Store Instruction.
  This handles the following Mnemonic instruction:
     JMP abs (opcode &4C - the default opcode for JMP).
* Otherwise:
* Add 32 to the opcode (&29).
* Get the Integer result of expression at BASIC Text pointer A ('Type mismatch' error if String found).
* If the next non-space character is ')' then Set Y to 3 and Store Instruction.
  This handles the following Mnemonic instruction:
     JMP (abs) (opcode &6C).
* Otherwise:
* Issue 'Index' error if the next non-space character is not ',' [comma].
* Add 16 to the Opcode (&29).
* Issue 'Index' error if the next non-space character is not 'X' or 'x'.
* Issue 'Index' error if the next non-space character is not ')'.
* Set Y to 3 (length of instruction is 3 bytes) and goto &8A5E to store the instruction.
* This handles the following Mnemonic instruction:
     JMP (abs,X) (opcode &7C).

9) Process Mnemonics LDX, LDY, STX or STY
If X (Mnemonic position) is < #&44 then the Mnemonic is one of the following: LDX, LDY, STX or STY,
so process as follows:
* Load Encoded Mnemonic LSB byte in A.
* EOR the LSB Mnemonic code with #&01 (to reverse bit 0) and AND it with #&1F (to clear the top 3 bits).
(Now A contains the last letter of the Mnemonic code (minus 64).
* Store A to the Stack.
* If the Mnemonic is LDX or LDY then:
* (LDX and LDY have Immediate and Absolute,X (or Absolute,Y) addressing modes that STX and STY do not have).
* [&8C38] If the next non-space character is '#' then Retrieve A from the stack (as no longer needed), Get Integer result from
expression at BASIC text pointer A, Set Y to 2, issue 'Byte' error if Integer is > 255; otherwise Store Instruction.
    This handles the following Mnemonic instructions:
      LDX#nn (opcode &A2).
      LDY#nn (opcode &A0).
* Otherwise:
* [&8C40] Decrement BASIC Text Pointer A offset & get the Integer result of the expression at Text Pointer A.
* Retrieve A from the stack and store it in location &37.
* If the next non-space character is ',' [comma] then:
         * Get the next non-space character and AND the value with #&1F (to remove
            the &64 ASCII letter offset, and also removes case sensitivity).
         * Compare the result with &37 location. If equal then issue 'Index' error, as
            the Index character after the comma is the same as the register operator in the Mnemonic - which is invalid.
         * Add 16 to the Opcode (&29) and continue with &8B5E, below:
* [&8B5E] Add 4 to the opcode (&29).
* If the Integer is > 255 (16-bit address) then add 8 to the Opcode (&29), Set Y to 3 and Store Instruction.
* Otherwise (Integer is < 256 (8-bit zero-page address)), so set Y to 2 and Store Instruction.
* This handles the following Mnemonic instructions:
*     LDX abs (opcode &AE).
*     LDY abs (opcode &AC).
*     LDX abs,Y (opcode &BE).
*     LDY abs,X (opcode &BC).
*     LDX zp (opcode &A6).
*     LDY zp (opcode &A4).
*     LDX zp,Y (opcode &B6).
*     LDY zp,X (opcode &B4).
* If the Mnemonic is STX or STY then:
* (STX and STY do not have the Immediate and Absolute,X (or Absolute,Y) addressing modes that LDX and LDY have).
* [&8C59] Get the Integer result of the expression at Text Pointer A.
* Retrieve A from the stack and store it in location &37.
* If the next non-space character is ',' [comma] then:
         * Get the next non-space character and AND the value with #&1F (to remove
            the &64 ASCII letter offset (and also removes case sensitivity)).
         * Compare the result with &37 location. If equal then issue 'Index' error, as
            the Index character after the comma is the same as the register operator in the Mnemonic - which is invalid.
         * Add 16 to the Opcode (&29).
         * If the Integer is > 255 then issue 'Byte' error as only zero page addressing is allowed (STX zp,Y & STY zp,X).
         * Otherwise, continue with &8B61, below:
* [&8B61] If the Integer is > 255 (16-bit address) then add 8 to the Opcode (&29), Set Y to 3 and Store Instruction.
* Otherwise (Integer is < 256 (8-bit zero-page address)), so set Y to 2 and Store Instruction.
* This handles the following Mnemonic instructions:
*     STX abs (opcode &8E).
*     STY abs (opcode &8C).
*     STX zp (opcode &86).
*     STY zp (opcode &84).
*     STX zp,Y (opcode &96).
*     STY zp,X (opcode &94).

10) Process Pseudo Mnemonic OPT
If X (Mnemonic position) is = #&44 then the Mnemonic is OPT so process as follows:
* Get the Integer result of the expression at Text Pointer A.
* Store LSB of the Integer result (&2A) in &28 [OPT flag location].
* Set Y to 0 (No bytes to store) and goto &8A5E to store the instruction (nothing!) & exit.

11) Process Pseudo Mnemonic EQU
If X (Mnemonic position) is = #&45 then the Mnemonic is EQU so process as follows:
* Increment BASIC Text Pointer A offset and get the next character after the EQU Mnemonic.
* AND the character code with #&DF to clear the case bit (bit 5), Now we have the Upper Case representation of the letter.
* If the next character is 'B' then Get Integer result of the expression at BASIC Stack pointer A, Store IWA value in
   locations &29 - &2C. Set Y to 1 (as we will store only the first byte (&2A) of the IWA value) and goto &8A5E to store.
* If the next character is 'W' then Get Integer result of the expression at BASIC Stack pointer A, Store IWA value in
   locations &29 - &2C. Set Y to 2 (as we will store 2 bytes of the IWA value) and goto &8A5E to store.
* If the next character is 'D' then Get Integer result of the expression at BASIC Stack pointer A, Store IWA value in
   locations &29 - &2C. Set Y to 4 (as we will store 4 bytes of the IWA value) and goto &8A5E to store.
* If the next character is not 'S' then issue 'Syntax' error as the Instruction Line does not contain a valid Mnemonic.
* If the next character is 'S' then Store &28 (OPT flag) to the stack (for safe keeping), Get the result of the expression
   at BASIC Stack pointer A, ('Type mismatch' error if not String value). Retrieve OPT Flag from the Stack. Call &9275
   to set BASIC Text Pointer A Offset to BASIC Text Pointer B Offset. Set Y to #&FF (to indicate that the storage bytes
   are in the SWA) and goto &8A5E to store.



[&8A5E] Store Assembly Instruction
Now, &29 contains the appropriate Opcode and &2A-&2B contain any parameters, and Y contains the length (number
of bytes) of the Assembly instruction.
Store Y (Length of instruction) in location &39.
Store P% LSB (&0440) in location &37.
Store P% MSB (&0441) in location &38.
X = P% MSB and A = P% LSB.
If OPT (&28) >= 4 (relocate), then X = O% MSB (&043D) and A = O% LSB (&043C).
Store A in &3A and X in &3B.
Now: &37-&38 contain the execution location (P%) and &3A-&3B contain the physical location (P%,
or O% (if OPT > 3)).

If the number of bytes (Y) is 0 then exit (RTS), as there are no instruction bytes to store.
If the number of bytes is a negative value, then the storage length is determined by the length of the SWA,
as we are storing a String value (EQUS), so, copy the SWA value (&0600-&0600+&36) to the physical location
(&3A-&3B), and increment P% (&0400-&0441) by 1 for each byte stored.
Otherwise, copy locations &29 to (&28 + Number of Bytes (Y)) to the physical location (&3A-&3B), and
increment P% by 1 for each byte stored.
Note: Y is used as an offset pointer when copying, so no need to increment the physical location pointer, &3A-&3B.

If carry flag is set (meaning that OPT (&28) was >= 4 --> as no statements between &8A67 and &8A98
affect the carry flag), then increment O% for each byte stored.
Exit (RTS), as the assembly instruction has now been stored.

Table of Assembly instructions and Opcodes (Included here for reference)

[where: 'rel' represents a relative address (i.e. +06), 'abs' an absolute (or 16-bit) address i.e. 8005), 'zp' a zero-page
(or 8-bit) address (i.e. 56) and 'nn' a literal].
[a '*' represents an Instruction that is not in the 6502 processor, and is new for the 6502C12 (BBC Master) processor].
Opcode Instruction         Opcode Instruction
00 BRK         80 BRA rel *
01 ORA (zp,X)         81 STA (zp,X)
02 ---         82 ---
03 ---         83 ---
04 TSB zp *         84 STY zp
05 ORA zp         85 STA zp
06 ASL zp         86 STX zp
07 ---         87 ---
08 PHP         88 DEY
09 ORA #nn         89 BIT #nn *
0A ASL A         8A TXA
0B ---         8B ---
0C TSB abs *         8C STY abs
0D ORA abs         8D STA abs
0E ASL abs         8E STX abs
0F ---         8F ---
10 BPL rel         90 BCC rel
11 ORA (zp),Y         91 STA (zp),Y
12 ORA (zp) *         92 STA (zp) *
13 ---         93 ---
14 TRB zp *         94 STY zp
15 ORA zp,X         95 STA zp,X
16 ASL zp,X         96 STX zp,Y
17 ---         97 ---
18 CLC         98 TYA
19 ORA abs,Y         99 STA abs,Y
1A INC A *         9A TXS
1B ---         9B ---
1C TRB abs *         9C STZ abs *
1D ORA abs,X         9D STA abs,X
1E ASL abs,X         9E STZ abs,X *
1F ---         9F ---
20 JSR abs         A0 LDY #nn
21 AND (zp,X)         A1 LDA (zp,X)
22 ---         A2 LDX #nn
23 ---         A3 ---
24 BIT zp         A4 LDY zp
25 AND zp         A5 LDA zp
26 ROL zp         A6 LDX zp
27 ---         A7 ---
28 PLP         A8 TAY
29 AND #nn         A9 LDA #nn
2A ROL A         AA TAX
2B ---         AB ---
2C BIT abs         AC LDY abs
2D AND abs         AD LDA abs
2E ROL abs         AE LDX abs
2F ---         AF ---
30 BMI rel         B0 BCS rel
31 AND (zp),Y         B1 LDA (zp),Y
32 AND (zp) *         B2 LDA (zp) *
33 ---         B3 ---
34 BIT zp,X *         B4 LDY zp
35 AND zp,X         B5 LDA zp,X
36 ROL zp,X         B6 LDX sp,Y
37 ---         B7 ---
38 SEC         B8 CLV
39 AND abs,Y         B9 LDA abs,Y
3A DEC A *         BA TSX
3B ---         BB ---
3C BIT abs,X *         BC LDY abs,X
3D ORA abs,X         BD LDA abs,X
3E ASL abs,X         BE LDX abs,Y
3F ---         BF ---
40 RTI         C0 CPY #nn
41 EOR (zp,X)         C1 CMP (zp,X)
42 ---         C2 ---
43 ---         C3 ---
44 ---         C4 CPY zp
45 EOR zp         C5 CMP zp
46 LSR zp         C6 DEC zp
47 ---         C7 ---
48 PHA         C8 INY
49 EOR #nn         C9 CMP #nn
4A LSR A         CA DEX
4B ---         CB ---
4C JMP abs         CC CPY abs
4D EOR abs         CD CMP abs
4E LSR abs         CE DEC abs
4F ---         CF ---
50 BVC rel         D0 BNE rel
51 EOR (zp),Y         D1 CMP (zp),Y
52 EOR (zp) *         D2 CMP (zp) *
53 ---         D3 ---
54 ---         D4 ---
55 EOR zp,X         D5 CMP zp,X
56 LSR zp,X         D6 DEC zp,X
57 ---         D7 ---
58 CLI         D8 CLD
59 EOR abs,Y         D9 CMP abs,Y
5A PHY *         DA PHX *
5B ---         DB ---
5C ---         DC ---
5D EOR abs,X         DD CMP abs,X
5E LSR abs,X         DE DEC abs,X
5F ---         DF ---
60 RTS         E0 CPX #nn
61 ADC (zp,X)         E1 SBC (zp,X)
62 ---         E2 ---
63 ---         E3 ---
64 STZ zp *         E4 CPX zp
65 ADC zp         E5 SBC zp
66 ROR zp         E6 INC zp
67 ---         E7 ---
68 PLA         E8 INX
69 ADC #nn         E9 SBC #nn
6A ROR A         EA NOP
6B ---         EB ---
6C JMP (abs)         EC CPX abs
6D ADC abs         ED SBC abs
6E ROR abs         EE INC abs
6F ---         EF ---
70 BCS rel         F0 BEQ rel
71 ADC (zp),Y         F1 SBC (zp),Y
72 ADC (zp) *         F2 SBC (zp) *
73 ---         F3 ---
74 STZ zp,X *         F4 ---
75 ADC zp,X         F5 SBC zp,X
76 ROR zp,X         F6 INC zp,X
77 ---         F7 ---
78 SEI         F8 SED
79 ADC abs,Y         F9 SBC abs,Y
7A PLY *         FA PLX *
7B ---         FB ---
7C JMP (abs,X) *         FC ---
7D ADC abs,X         FD SBC abs,X
7E ROR abs,X         FE INC abs,X
7F ---         FF ---


[&884D-&891B] Assembly Mnemonic and default Opcode tables

There are 3 tables are stored at locations &884D-&8891 (Mnemonic MSB), &8892-&88D6 (Mnemonic LSB) and
&88D7-&891B (default Opcode). These tables help to decode the Assembly Mnemonics and to obtain the correct opcodes.
The values contained in these tables is as follows:
Num Address Encoded Mnemonic MSB byte        Address Encoded Mnemonic LSB byte        Address Default Opcode        Mnemonic
01 884D 4B        8892 0A        88D7 00        BRK
02 884E 83        8893 0D        88D8 18        CLC
03 884F 84        8894 0D        88D9 D8        CLD
04 8850 89        8895 0D        88DA 58        CLI
05 8851 96        8896 0D        88DB B8        CLV
06 8852 B8        8897 10        88DC CA        DEX
07 8853 B9        8898 10        88DD 88        DEY
08 8854 D8        8899 25        88DE E8        INX
09 8855 D9        889A 25        88DF C8        INY
0A 8856 F0        889B 39        88E0 EA        NOP
0B 8857 01        889C 41        88E1 48        PHA
0C 8858 10        889D 41        88E2 08        PHP
0D 8859 81        889E 41        88E3 68        PLA
0E 885A 90        889F 41        88E4 28        PLP
0F 885B 89        88A0 4A        88E5 40        RTI
10 885C 93        88A1 4A        88E6 60        RTS
11 885D A3        88A2 4C        88E7 38        SEC
12 885E A4        88A3 4C        88E8 F8        SED
13 885F A9        88A4 4C        88E9 78        SEI
14 8860 38        88A5 50        88EA AA        TAX
15 8861 39        88A6 50        88EB A8        TAY
16 8862 78        88A7 52        88EC BA        TSX
17 8863 01        88A8 53        88ED 8A        TXA
18 8864 13        88A9 53        88EE 9A        TXS
19 8865 21        88AA 53        88EF 98        TYA
1A 8866 A1        88AB 10        88F0 3A        DEA [New 6502C12 Mnemonic]
1B 8867 C1        88AC 25        88F1 1A        INA [New 6502C12 Mnemonic]
1C 8868 19        88AD 41        88F2 5A        PHY [New 6502C12 Mnemonic]
1D 8869 18        88AE 41        88F3 DA        PHX [New 6502C12 Mnemonic]
1E 886A 99        88AF 41        88F4 7A        PLY [New 6502C12 Mnemonic]
1F 886B 98        88B0 41        88F5 FA        PLX [New 6502C12 Mnemonic] [End of single-byte Mnemonics]
20 886C 63        88B1 08        88F6 90        BCC [Start of Branch Mnemonics]
21 886D 73        88B2 08        88F7 B0        BCS
22 886E B1        88B3 08        88F8 F0        BEQ
23 886F A9        88B4 09        88F9 30        BMI
24 8870 C5        88B5 09        88FA D0        BNE
25 8871 0C        88B6 0A        88FB 10        BPL
26 8872 C3        88B7 0A        88FC 50        BVC
27 8873 D3        88B8 0A        88FD 70        BVS
28 8874 41        88B9 0A        88FE 80        BRA [New 6502C12 Mnemonic] [End of Branch Mnemonics]
29 8875 C4        88BA 05        88FF 21        AND
2A 8876 F2        88BB 15        8900 41        EOR
2B 8877 41        88BC 3E        8901 01        ORA
2C 8878 83        88BD 04        8902 61        ADC
2D 8879 B0        88BE 0D        8903 C1        CMP
2E 887A 81        88BF 30        8904 A1        LDA
2F 887B 43        88C0 4C        8905 E1        SBC
30 887C 6C        88C1 06        8906 06        ASL
31 887D 72        88C2 32        8907 46        LSR
32 887E EC        88C3 49        8908 26        ROL
33 887F F2        88C4 49        8909 66        ROR
34 8880 A3        88C5 10        890A C6        DEC
35 8881 C3        88C6 25        890B E6        INC
36 8882 92        88C7 0D        890C 9C        CLR
37 8883 9A        88C8 4E        890D 9C        STZ
38 8884 18        88C9 0E        890E E0        CPX
39 8885 19        88CA 0E        890F C0        CPY
3A 8886 62        88CB 52        8910 00        TSB
3B 8887 42        88CC 52        8911 10        TRB
3C 8888 34        88CD 09        8912 24        BIT
3D 8889 B0        88CE 29        8913 4C        JMP
3E 888A 72        88CF 2A        8914 20        JSR
3F 888B 98        88D0 30        8915 A2        LDX
40 888C 99        88D1 30        8016 A0        LDY
41 888D 81        88D2 4E        8917 81        STA
42 888E 98        88D3 4E        8918 86        STX
43 888F 99        88D4 4E        8919 8A        STY
44 8890 14        88D5 3E        891A 3A        OPT
45 8891 35        88D6 16        891B 85        EQU


Disassembly for the Assemble Assembly instruction/statement routine

89D4   032 174 152 20 AE 98 JSR &98AE Evaluate variable name & create new variable
89D7 \ 240 092 F0 5C BEQ 92 --> &8A35 [JMP &9B69 Syntax error]
89D9 Z 176 090 B0 5A BCS 90 --> &8A35 [JMP &9B69 Syntax error]
89DB C 032 067 188 20 43 BC JSR &BC43 Push &2A, &2B & &2C to the 6502 Stack
89DE   032 132 173 20 84 AD JSR &AD84 Set IWA to P%
89E1 ' 133 039 85 27 STA &27
89E3 + 032 043 179 20 2B B3 JSR &B32B Set numeric variable
89E6 u 032 117 146 20 75 92 JSR &9275 Set PTR A Offset to PTR B Offset
89E9 N 132 078 84 4E STY &4E
89EB   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
89EE   160 000 A0 00 LDY#&00
89F0 d= 100 061 64 3D STZ &3D
89F2 : 201 058 C9 3A CMP#&3A
89F4 h 240 104 F0 68 BEQ 104 --> &8A5E Store current instruction (if any) and exit
89F6   201 013 C9 0D CMP#&0D
89F8 d 240 100 F0 64 BEQ 100 --> &8A5E Store current instruction (if any) and exit
89FA \ 201 092 C9 5C CMP#&5C
89FC ` 240 096 F0 60 BEQ 96 --> &8A5E Store current instruction (if any) and exit
89FE . 201 046 C9 2E CMP#&2E
8A00   240 210 F0 D2 BEQ -46 --> &89D4 Create label
8A02   198 010 C6 0A DEC &0A
8A04   162 003 A2 03 LDX#&03
8A06   164 010 A4 0A LDY &0A
8A08   230 010 E6 0A INC &0A
8A0A   177 011 B1 0B LDA (&0B),Y
8A0C 0* 048 042 30 2A BMI 42 --> &8A38 Check for BASIC tokens that are also Mnemonics
8A0E   201 032 C9 20 CMP#&20
8A10   240 016 F0 10 BEQ 16 --> &8A22
8A12   160 005 A0 05 LDY#&05
8A14   010 0A ASL A
8A15   010 0A ASL A
8A16   010 0A ASL A
8A17   010 0A ASL A
8A18 &= 038 061 26 3D ROL &3D
8A1A &> 038 062 26 3E ROL &3E
8A1C   136 88 DEY
8A1D   208 248 D0 F8 BNE -8 --> &8A17
8A1F   202 CA DEX
8A20   208 228 D0 E4 BNE -28 --> &8A06
8A22 E 162 069 A2 45 LDX#&45
8A24 = 165 061 A5 3D LDA &3D
8A26 L 221 076 136 DD 4C 88 CMP &884C,X
8A29   208 007 D0 07 BNE 7 --> &8A32
8A2B   188 145 136 BC 91 88 LDY &8891,X
8A2E > 196 062 C4 3E CPY &3E
8A30 ! 240 033 F0 21 BEQ 33 --> &8A53
8A32   202 CA DEX
8A33   208 241 D0 F1 BNE -15 --> &8A26
8A35 Li 076 105 155 4C 69 9B JMP &9B69 Syntax error
8A38 ) 162 041 A2 29 LDX#&29
8A3A   201 128 C9 80 CMP#&80
8A3C   240 021 F0 15 BEQ 21 --> &8A53
8A3E   232 E8 INX
8A3F   201 130 C9 82 CMP#&82
8A41   240 016 F0 10 BEQ 16 --> &8A53
8A43   232 E8 INX
8A44   201 132 C9 84 CMP#&84
8A46   208 237 D0 ED BNE -19 --> &8A35 [JMP &9B69 Syntax error]
8A48   230 010 E6 0A INC &0A
8A4A   200 C8 INY
8A4B   177 011 B1 0B LDA (&0B),Y
8A4D ) 041 223 29 DF AND#&DF
8A4F A 201 065 C9 41 CMP#&41
8A51   208 226 D0 E2 BNE -30 --> &8A35 [JMP &9B69 Syntax error]
8A53   189 214 136 BD D6 88 LDA &88D6,X
8A56 ) 133 041 85 29 STA &29
8A58   160 001 A0 01 LDY#&01
8A5A   224 032 E0 20 CPX#&20
8A5C H 176 072 B0 48 BCS 72 --> &8AA6
8A5E @ 173 064 004 AD 40 04 LDA &0440
8A61 7 133 055 85 37 STA &37
8A63 9 132 057 84 39 STY &39
8A65 ( 166 040 A6 28 LDX &28
8A67   224 004 E0 04 CPX#&04
8A69 A 174 065 004 AE 41 04 LDX &0441
8A6C 8 134 056 86 38 STX &38
8A6E   144 006 90 06 BCC 6 --> &8A76
8A70 < 173 060 004 AD 3C 04 LDA &043C
8A73 = 174 061 004 AE 3D 04 LDX &043D
8A76 : 133 058 85 3A STA &3A
8A78 ; 134 059 86 3B STX &3B
8A7A   152 98 TYA
8A7B ( 240 040 F0 28 BEQ 40 --> &8AA5
8A7D   016 004 10 04 BPL 4 --> &8A83
8A7F 6 164 054 A4 36 LDY &36
8A81 " 240 034 F0 22 BEQ 34 --> &8AA5
8A83   136 88 DEY
8A84 ) 185 041 000 B9 29 00 LDA &0029,Y
8A87 $9 036 057 24 39 BIT &39
8A89   016 003 10 03 BPL 3 --> &8A8E
8A8B   185 000 006 B9 00 06 LDA &0600,Y
8A8E : 145 058 91 3A STA (&3A),Y
8A90 @ 238 064 004 EE 40 04 INC &0440
8A93   208 003 D0 03 BNE 3 --> &8A98
8A95 A 238 065 004 EE 41 04 INC &0441
8A98   144 008 90 08 BCC 8 --> &8AA2
8A9A < 238 060 004 EE 3C 04 INC &043C
8A9D   208 003 D0 03 BNE 3 --> &8AA2
8A9F = 238 061 004 EE 3D 04 INC &043D
8AA2   152 98 TYA
8AA3   208 222 D0 DE BNE -34 --> &8A83
8AA5 ` 096 60 RTS
8AA6 ) 224 041 E0 29 CPX#&29
8AA8 < 176 060 B0 3C BCS 60 --> &8AE6
8AAA o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8AAD   024 18 CLC
8AAE * 165 042 A5 2A LDA &2A
8AB0 @ 237 064 004 ED 40 04 SBC &0440
8AB3   168 A8 TAY
8AB4 + 165 043 A5 2B LDA &2B
8AB6 A 237 065 004 ED 41 04 SBC &0441
8AB9   192 001 C0 01 CPY#&01
8ABB   136 88 DEY
8ABC   233 000 E9 00 SBC#&00
8ABE   240 027 F0 1B BEQ 27 --> &8ADB
8AC0   026 1A INC A
8AC1   208 003 D0 03 BNE 3 --> &8AC6
8AC3   152 98 TYA
8AC4 0 048 025 30 19 BMI 25 --> &8ADF
8AC6 ( 165 040 A5 28 LDA &28
8AC8 ) 041 002 29 02 AND#&02
8ACA   240 018 F0 12 BEQ 18 --> &8ADE
8ACC   ... Out of range error...
8ADB   152 98 TYA
8ADC 0 048 232 30 E8 BMI -24 --> &8AC6
8ADE   168 A8 TAY
8ADF * 132 042 84 2A STY &2A
8AE1   160 002 A0 02 LDY#&02
8AE3 L^ 076 094 138 4C 5E 8A JMP &8A5E Store current instruction (if any) and exit
8AE6 0 224 048 E0 30 CPX#&30
8AE8   176 022 B0 16 BCS 22 --> &8B00
8AEA   032 223 140 20 DF 8C JSR &8CDF Get next non-space char (PTR A) and compare with '#'
8AED   208 024 D0 18 BNE 24 --> &8B07
8AEF   032 204 140 20 CC 8C JSR &8CCC Add 8 to Opcode (&29)
8AF2 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8AF5 + 165 043 A5 2B LDA &2B
8AF7   240 232 F0 E8 BEQ -24 --> &8AE1
8AF9   ... Byte error...
8B00 A 224 065 E0 41 CPX#&41
8B02 c 208 099 D0 63 BNE 99 --> &8B67
8B04   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8B07 ( 201 040 C9 28 CMP#&28
8B09 9 208 057 D0 39 BNE 57 --> &8B44
8B0B o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8B0E   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8B11 ) 201 041 C9 29 CMP#&29
8B13   208 023 D0 17 BNE 23 --> &8B2C
8B15   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8B18   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8B1B   240 004 F0 04 BEQ 4 --> &8B21
8B1D ) 230 041 E6 29 INC &29
8B1F   128 212 80 D4 BRA -44 --> &8AF5 If IWA = 8-bit value, Y = 2 & Store assembly instruction; otherwise, Byte error
8B21   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8B24 ) 041 223 29 DF AND#&DF
8B26 Y 201 089 C9 59 CMP#&59
8B28   240 203 F0 CB BEQ -53 --> &8AF5 If IWA = 8-bit value, Y = 2 & Store assembly instruction; otherwise, Byte error
8B2A   128 016 80 10 BRA 16 --> &8B3C Index error
8B2C , 201 044 C9 2C CMP#&2C
8B2E   208 012 D0 0C BNE 12 --> &8B3C Index error
8B30   032 215 140 20 D7 8C JSR &8CD7 Compare next non-space [PTR A] character with 'X' or 'x'
8B33   208 007 D0 07 BNE 7 --> &8B3C Index error
8B35   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8B38 ) 201 041 C9 29 CMP#&29
8B3A   240 185 F0 B9 BEQ -71 --> &8AF5 If IWA = 8-bit value, Y = 2 & Store assembly instruction; otherwise, Byte error
8B3C   ... Index error...
8B44 m 032 109 146 20 6D 92 JSR &926D Decrement TEXT POINTER A offset & evaluate Expression [PTR A] & convert result to integer
8B47   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8B4A   208 018 D0 12 BNE 18 --> &8B5E
8B4C   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8B4F   032 215 140 20 D7 8C JSR &8CD7 Compare next non-space [PTR A] character with 'X' or 'x'
8B52   240 010 F0 0A BEQ 10 --> &8B5E
8B54 Y 201 089 C9 59 CMP#&59
8B56   208 228 D0 E4 BNE -28 --> &8B3C Index error
8B58   032 204 140 20 CC 8C JSR &8CCC Add 8 to Opcode (&29)
8B5B L 076 254 139 4C FE 8B JMP &8BFE Set number of bytes (Y) = 3 & Store assembly instruction
8B5E   032 207 140 20 CF 8C JSR &8CCF Add 4 to Opcode (&29)
8B61 + 165 043 A5 2B LDA &2B
8B63   208 243 D0 F3 BNE -13 --> &8B58
8B65   128 144 80 90 BRA -112 --> &8AF7 If IWA = 8-bit value, Y = 2 & Store assembly instruction; otherwise, Byte error
8B67 6 224 054 E0 36 CPX#&36
8B69 6 176 054 B0 36 BCS 54 --> &8BA1
8B6B   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8B6E ) 041 223 29 DF AND#&DF
8B70 A 201 065 C9 41 CMP#&41
8B72   240 018 F0 12 BEQ 18 --> &8B86
8B74 m 032 109 146 20 6D 92 JSR &926D Decrement TEXT POINTER A offset & evaluate Expression [PTR A] & convert result to integer
8B77   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8B7A   208 229 D0 E5 BNE -27 --> &8B61
8B7C   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8B7F   032 215 140 20 D7 8C JSR &8CD7 Compare next non-space [PTR A] character with 'X' or 'x'
8B82   240 221 F0 DD BEQ -35 --> &8B61
8B84   128 182 80 B6 BRA -74 --> &8B3C Index error
8B86   200 C8 INY
8B87   177 011 B1 0B LDA (&0B),Y
8B89   032 132 141 20 84 8D JSR &8D84 Check for Variable name character or digit (in A)
8B8C   176 230 B0 E6 BCS -26 --> &8B74
8B8E   160 022 A0 16 LDY#&16
8B90 4 224 052 E0 34 CPX#&34
8B92   144 006 90 06 BCC 6 --> &8B9A
8B94   208 002 D0 02 BNE 2 --> &8B98
8B96 6 160 054 A0 36 LDY#&36
8B98 ) 132 041 84 29 STY &29
8B9A   032 207 140 20 CF 8C JSR &8CCF Add 4 to Opcode (&29)
8B9D   160 001 A0 01 LDY#&01
8B9F _ 128 095 80 5F BRA 95 --> &8C00
8BA1 8 224 056 E0 38 CPX#&38
8BA3 % 176 037 B0 25 BCS 37 --> &8BCA
8BA5 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8BA8   160 003 A0 03 LDY#&03
8BAA   162 001 A2 01 LDX#&01
8BAC + 165 043 A5 2B LDA &2B
8BAE   208 007 D0 07 BNE 7 --> &8BB7
8BB0   162 015 A2 0F LDX#&0F
8BB2 d 169 100 A9 64 LDA#&64
8BB4 ) 133 041 85 29 STA &29
8BB6   136 88 DEY
8BB7 Z 090 5A PHY
8BB8   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8BBB   208 010 D0 0A BNE 10 --> &8BC7
8BBD   032 215 140 20 D7 8C JSR &8CD7 Compare next non-space [PTR A] character with 'X' or 'x'
8BC0   208 194 D0 C2 BNE -62 --> &8B84
8BC2   138 8A TXA
8BC3 e) 101 041 65 29 ADC &29
8BC5 ) 133 041 85 29 STA &29
8BC7 z 122 7A PLY
8BC8 6 128 054 80 36 BRA 54 --> &8C00
8BCA < 224 060 E0 3C CPX#&3C
8BCC   176 028 B0 1C BCS 28 --> &8BEA
8BCE : 224 058 E0 3A CPX#&3A
8BD0   176 007 B0 07 BCS 7 --> &8BD9
8BD2   032 223 140 20 DF 8C JSR &8CDF Get next non-space char (PTR A) and compare with '#'
8BD5   240 016 F0 10 BEQ 16 --> &8BE7
8BD7   198 010 C6 0A DEC &0A
8BD9 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8BDC   128 128 80 80 BRA -128 --> &8B5E
8BDE   032 223 140 20 DF 8C JSR &8CDF Get next non-space char (PTR A) and compare with '#'
8BE1   208 145 D0 91 BNE -111 --> &8B74
8BE3   160 137 A0 89 LDY#&89
8BE5 ) 132 041 84 29 STY &29
8BE7 L 076 242 138 4C F2 8A JMP &8AF2 Get Integer value; if 8-bit value, Y = 2 & Store assembly instruction; otherwise, Byte error
8BEA   240 242 F0 F2 BEQ -14 --> &8BDE
8BEC > 224 062 E0 3E CPX#&3E
8BEE   240 011 F0 0B BEQ 11 --> &8BFB
8BF0 7 176 055 B0 37 BCS 55 --> &8C29
8BF2   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8BF5 ( 201 040 C9 28 CMP#&28
8BF7   240 010 F0 0A BEQ 10 --> &8C03
8BF9   198 010 C6 0A DEC &0A
8BFB o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8BFE   160 003 A0 03 LDY#&03
8C00 L^ 076 094 138 4C 5E 8A JMP &8A5E Store current instruction (if any) and exit
8C03   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8C06   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8C09 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8C0C   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8C0F ) 201 041 C9 29 CMP#&29
8C11   240 235 F0 EB BEQ -21 --> &8BFE Set number of bytes (Y) = 3 & Store assembly instruction
8C13 , 201 044 C9 2C CMP#&2C
8C15   208 015 D0 0F BNE 15 --> &8C26
8C17   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8C1A   032 215 140 20 D7 8C JSR &8CD7 Compare next non-space [PTR A] character with 'X' or 'x'
8C1D   208 007 D0 07 BNE 7 --> &8C26
8C1F   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8C22 ) 201 041 C9 29 CMP#&29
8C24   240 216 F0 D8 BEQ -40 --> &8BFE Set number of bytes (Y) = 3 & Store assembly instruction
8C26 L< 076 060 139 4C 3C 8B JMP &8B3C Index error
8C29 D 224 068 E0 44 CPX#&44
8C2B M 176 077 B0 4D BCS 77 --> &8C7A
8C2D = 165 061 A5 3D LDA &3D
8C2F I 073 001 49 01 EOR#&01
8C31 ) 041 031 29 1F AND#&1F
8C33 H 072 48 PHA
8C34 A 224 065 E0 41 CPX#&41
8C36 ! 176 033 B0 21 BCS 33 --> &8C59
8C38   032 223 140 20 DF 8C JSR &8CDF Get next non-space char (PTR A) and compare with '#'
8C3B   208 003 D0 03 BNE 3 --> &8C40
8C3D h 104 68 PLA
8C3E   128 167 80 A7 BRA -89 --> &8BE7
8C40 m 032 109 146 20 6D 92 JSR &926D Decrement TEXT POINTER A offset & evaluate Expression [PTR A] & convert result to integer
8C43 h 104 68 PLA
8C44 7 133 055 85 37 STA &37
8C46   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8C49   208 145 D0 91 BNE -111 --> &8BDC
8C4B   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8C4E ) 041 031 29 1F AND#&1F
8C50 7 197 055 C5 37 CMP &37
8C52   208 210 D0 D2 BNE -46 --> &8C26
8C54   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8C57   128 131 80 83 BRA -125 --> &8BDC
8C59 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8C5C h 104 68 PLA
8C5D 7 133 055 85 37 STA &37
8C5F   032 229 140 20 E5 8C JSR &8CE5 Compare next non-space [PTR A] character with ','
8C62   208 019 D0 13 BNE 19 --> &8C77
8C64   032 224 142 20 E0 8E JSR &8EE0 Get next non-space char (PTR A)
8C67 ) 041 031 29 1F AND#&1F
8C69 7 197 055 C5 37 CMP &37
8C6B   208 185 D0 B9 BNE -71 --> &8C26
8C6D   032 201 140 20 C9 8C JSR &8CC9 Add 16 to Opcode (&29)
8C70 + 165 043 A5 2B LDA &2B
8C72   240 003 F0 03 BEQ 3 --> &8C77
8C74 L 076 249 138 4C F9 8A JMP &8AF9 Byte error
8C77 La 076 097 139 4C 61 8B JMP &8B61
8C7A   208 011 D0 0B BNE 11 --> &8C87
8C7C o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8C7F * 165 042 A5 2A LDA &2A
8C81 ( 133 040 85 28 STA &28
8C83   160 000 A0 00 LDY#&00
8C85 * 128 042 80 2A BRA 42 --> &8CB1
8C87   162 001 A2 01 LDX#&01
8C89   164 010 A4 0A LDY &0A
8C8B   230 010 E6 0A INC &0A
8C8D   177 011 B1 0B LDA (&0B),Y
8C8F ) 041 223 29 DF AND#&DF
8C91 B 201 066 C9 42 CMP#&42
8C93   240 018 F0 12 BEQ 18 --> &8CA7
8C95   232 E8 INX
8C96 W 201 087 C9 57 CMP#&57
8C98   240 013 F0 0D BEQ 13 --> &8CA7
8C9A   162 004 A2 04 LDX#&04
8C9C D 201 068 C9 44 CMP#&44
8C9E   240 007 F0 07 BEQ 7 --> &8CA7
8CA0 S 201 083 C9 53 CMP#&53
8CA2   240 019 F0 13 BEQ 19 --> &8CB7
8CA4 Li 076 105 155 4C 69 9B JMP &9B69 Syntax error
8CA7   218 DA PHX
8CA8 o 032 111 146 20 6F 92 JSR &926F Evaluate Expression at BASIC Text pointer A convert result to integer
8CAB ) 162 041 A2 29 LDX#&29
8CAD   032 198 189 20 C6 BD JSR &BDC6 Save Integer (IWA) to zero page location
8CB0 z 122 7A PLY
8CB1 L^ 076 094 138 4C 5E 8A JMP &8A5E Store current instruction (if any) and exit
8CB4 L 076 146 144 4C 92 90 JMP &9092 Type mismatch error
8CB7 ( 165 040 A5 28 LDA &28
8CB9 H 072 48 PHA
8CBA / 032 047 157 20 2F 9D JSR &9D2F Ptr B = Ptr A & Get result of expression
8CBD   208 245 D0 F5 BNE -11 --> &8CB4
8CBF h 104 68 PLA
8CC0 ( 133 040 85 28 STA &28
8CC2 u 032 117 146 20 75 92 JSR &9275 Set PTR A Offset to PTR B Offset
8CC5   160 255 A0 FF LDY#&FF
8CC7   128 232 80 E8 BRA -24 --> &8CB1