;Blitz! Basic tokens and interpreter disassembly ;By Mr.Mouse/XeNTaX/G*P ;---------------------- ;What follows is the tokens used in the compiled code, the address in the interpreter they are dispatched to, ;the number of operands expected that follow the token, a proposed function name and ;a description. All in a tab-delimited manner. ;---------------------- ; Token Execution Address Operands Function Name Function Description ; $00 $0AD7 0 BR_CMP_NULL Comparison: Always False ; $01 $0AD7 0 BR_CMP_LT Comparison: Less Than (<) ; $02 $0AD7 0 BR_CMP_EQ Comparison: Equal (=) ; $03 $0AD7 0 BR_CMP_LE Comparison: Less or Equal (<=) ; $04 $0AD7 0 BR_CMP_GT Comparison: Greater Than (>) ; $05 $0AD7 0 BR_CMP_NE Comparison: Not Equal (<>) ; $06 $0AD7 0 BR_CMP_GE Comparison: Greater or Equal (>=) ; $07 $B86A 0 BR_ADD Addition (FAC = ARG + FAC) ; $08 $B853 0 BR_SUB Subtraction (FAC = ARG - FAC) ; $09 $BA2B 0 BR_MUL Multiplication (FAC = ARG * FAC) ; $0A $BB12 0 BR_DIV Division (FAC = ARG / FAC) ; $0B $BF7B 0 BR_POW Exponentiation (FAC = ARG ^ FAC) ; $0C $0C2A 0 BR_AND Logical AND between ARG and FAC ; $0D $0C2A 0 BR_OR Logical OR between ARG and FAC ; $0E $0997 0 BR_NEG Negate numeric value in FAC ; $0F $09AE 0 BR_NOT Bitwise NOT on 16-bit integer in FAC ; $10 $1E07 5 BR_DIM Array allocation: (DimCount, NameH, NameL, OffsetH, OffsetL) ; $11 $1B74 0 BR_FOR_INIT Initialize FOR loop with default STEP 1 ; $12 $1B62 0 BR_FOR_STEP Initialize FOR loop with explicit STEP ; $13 $1C2A 0 BR_NEXT Increment and loop for most recent FOR frame ; $14 $1C0A 0 BR_NEXT_VAR Increment and loop with explicit Variable validation ; $15 $0C80 0 BR_CLR Clear variables, reset stacks, and initialize program ; $16 $0CA6 0 BR_CONT Continue execution after a STOP or END ; $17 $1832 0 BR_POKE Store byte from stack into address from FAC ; $18 $1856 1 BR_SYS Execute machine code at address in FAC (auto-skips one byte following) ; $19 $1D1C 2 BR_GOTO Jump to 16-bit absolute P-code address ; $1A $1D0F 2 BR_GOSUB Push return address and jump to 16-bit address ; $1B $1CE3 2 BR_GOTO_EXE Alternative GOTO dispatcher ; $1C $1CE3 2 BR_GOSUB_EXE Alternative GOSUB dispatcher ; $1D $1D30 0 BR_RETURN Pop return address from stack and jump ; $1E $0CA0 0 BR_RESTORE_DATA Reset DATA pointer to program start ; $1F $1D72 1 BR_IF_SKIP If FAC is False, skip X bytes of P-code ; $20 $1566 0 BR_FUNC_SGN Set FAC to Signum of FAC (-1, 0, 1) ; $21 $1549 0 BR_FUNC_INT Convert FAC to 16-bit integer ; $22 $1536 0 BR_FUNC_ABS Get Absolute value of FAC ; $23 $1524 0 BR_FUNC_USR Jump to User function address ; $24 $1524 0 BR_FUNC_FRE Force garbage collection and return free memory ; $25 $1595 0 BR_FUNC_POS Return current screen cursor column ; $26 $1524 0 BR_FUNC_SQR Calculate Square Root of FAC ; $27 $1524 0 BR_FUNC_RND Generate Random number into FAC ; $28 $1524 0 BR_FUNC_LOG Calculate Natural Logarithm of FAC ; $29 $1524 0 BR_FUNC_EXP Calculate Exponential of FAC ; $2A $1524 0 BR_FUNC_COS Calculate Cosine of FAC ; $2B $1524 0 BR_FUNC_SIN Calculate Sine of FAC ; $2C $1524 0 BR_FUNC_TAN Calculate Tangent of FAC ; $2D $1524 0 BR_FUNC_ATN Calculate Arctangent of FAC ; $2E $1585 0 BR_FUNC_PEEK Read memory at address in FAC into FAC ; $2F $159A 0 BR_FUNC_LEN Return length of string in FAC ; $30 $15FD 0 BR_FUNC_STR Convert numeric FAC to String ; $31 $15C8 0 BR_FUNC_VAL Convert string FAC to Numeric ; $32 $14FE 0 BR_FUNC_ASC Return PETSCII code of first char in FAC ; $33 $167A 0 BR_FUNC_CHR Convert numeric code in FAC to 1-char string ; $34 $1774 0 BR_FUNC_LEFT Extract left-most chars from string ; $35 $1774 0 BR_FUNC_RIGHT Extract right-most chars from string ; $36 $1741 0 BR_FUNC_MID Extract substring from string ; $37 $1D8D 5 BR_DEF_FN Define User Function (Name, Ptr, SkipLength) ; $38 $1DC2 0 BR_FN_PUSH Setup function parameter stack frame ; $39 $1D43 0 BR_FN_POP Restore function parameter stack frame ; $3A $0ECB 0 BR_ASSIGN_AND_NEXT_TOKEN, Store FAC into current variable ; $3B $1960 0 BR_PRINT_TAB Print TAB to current device ; $3C $18DA 0 BR_PRINT_NUM Format and Print numeric FAC ; $3D $18DA 0 BR_PRINT_NUM Format and Print numeric FAC ; $3E $18DA 0 BR_PRINT_NUM Format and Print numeric FAC ; $3F $199E 0 BR_PRINT_CR Print carriage return / newline ; $40 $196D 0 BR_PRINT_SPC Print spaces to current device ; $41 $196D 0 BR_PRINT_SPC Print spaces to current device ; $42 $19BA 0 BR_CMD_OPEN Open logical output channel ; $43 $18DA 0 BR_PRINT_NUM Format and Print numeric FAC ; $44 $19BA 0 BR_CMD_OPEN Open logical output channel ; $45 $19B0 0 BR_CLRCHN Close current channel and reset to screen ; $46 $16CD 0 BR_GET_CHAR Get single character from input device ; $47 $0E08 0 BR_ROM_SYNC Synchronize program pointer with ROM basic ; $48 $16B4 0 BR_INPUT_OPEN Open logical input channel ; $49 $0E9A 0 BR_END Terminate execution and close channels ; $4A $186B 0 BR_READ_DATA Read numeric/string item from DATA block ; $4B $186B 0 BR_READ_DATA Read numeric/string item from DATA block ; $4C $1832 0 BR_POKE Store byte into memory ; $4D $1832 0 BR_POKE Store byte into memory ; $4E $0E9D 0 BR_NEW Clear memory and perform NEW ; $4F $0EA0 0 BR_STOP Halt execution with Break message ; $50 $1A12 0 BR_SET_LINE Set current execution line pointer ; $51 $1A5C 0 BR_PARSE_BUF Process input buffer as BASIC data ; $52 $1CCC 2 BR_VAL_JUMP Validate target address before jump ; $53 $1A1D 0 BR_INPUT_GET Start interactive keyboard input ; $54 $1B1A 0 BR_SECURITY Internal security validation routine ; $55 $1A1D 0 BR_INPUT_GET Start interactive keyboard input ; $56 $0DFE 0 BR_STR_GC Free temporary strings and continue ; $57 $1A5C 0 BR_PARSE_BUF Process input buffer as BASIC data ; $58 $1D5C 0 BR_IF_THEN Conditional dispatch based on FAC ; $59 $19FD 0 BR_REST_DATA Restore data pointer to specified location ; $5A $1A06 0 BR_CLR_SRCH Reset internal search and scan flags ; $5B $1A00 0 BR_SET_DIR Set interpreter to Direct Mode ; $5C $1A09 0 BR_CLR_DIR Set interpreter to Program Mode ; $5D $1EA0 1 BR_IO_XFER Dispatch LOAD/SAVE/VERIFY (Count) ; $5E $1EA2 1 BR_IO_FAST Dispatch Fast-IO LOAD/SAVE (Count) ; $5F $1E9F 1 BR_IO_SKIP Skip IO filename and start (Count) ; $60 $1F3D 1 BR_OPEN Open Logical File (Count) ; $61 $19DA 0 BR_CLOSE Close Logical File ; $62 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $63 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $64 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $65 $1F76 0 BR_SYNTAX_ERR Trigger Syntax Error ; $66 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $67 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $68 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $69 $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6A $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6B $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6C $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6D $1F74 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6E $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $6F $1F75 0 BR_SYNTAX_ERR Trigger Syntax Error ; $70 $1F77 0 BR_SYNTAX_ERR Trigger Syntax Error ; $80 $0FD2 0 BR_READ_V0 Read Fast Variable 0 into FAC ; $81 $0FD2 0 BR_READ_V1 Read Fast Variable 1 into FAC ; $82 $0FD2 0 BR_READ_V2 Read Fast Variable 2 into FAC ; $83 $0FD2 0 BR_READ_V3 Read Fast Variable 3 into FAC ; $84 $0FD2 0 BR_READ_V4 Read Fast Variable 4 into FAC ; $85 $0FD2 0 BR_READ_V5 Read Fast Variable 5 into FAC ; $86 $0FD2 0 BR_READ_V6 Read Fast Variable 6 into FAC ; $87 $0FD2 0 BR_READ_V7 Read Fast Variable 7 into FAC ; $88 $0FD2 0 BR_READ_V8 Read Fast Variable 8 into FAC ; $89 $0FD2 0 BR_READ_V9 Read Fast Variable 9 into FAC ; $8A $0FD2 0 BR_READ_V10 Read Fast Variable 10 into FAC ; $8B $0FD2 0 BR_READ_V11 Read Fast Variable 11 into FAC ; $8C $0FD2 0 BR_READ_V12 Read Fast Variable 12 into FAC ; $8D $0FD2 0 BR_READ_V13 Read Fast Variable 13 into FAC ; $8E $0FD2 0 BR_READ_V14 Read Fast Variable 14 into FAC ; $8F $0FD2 0 BR_READ_V15 Read Fast Variable 15 into FAC ; $90 $0FD2 0 BR_READ_V16 Read Fast Variable 16 into FAC ; $91 $0FD2 0 BR_READ_V17 Read Fast Variable 17 into FAC ; $92 $0FD2 0 BR_READ_V18 Read Fast Variable 18 into FAC ; $93 $0FD2 0 BR_READ_V19 Read Fast Variable 19 into FAC ; $94 $0FD2 0 BR_READ_V20 Read Fast Variable 20 into FAC ; $95 $0FD2 0 BR_READ_V21 Read Fast Variable 21 into FAC ; $96 $0FD2 0 BR_READ_V22 Read Fast Variable 22 into FAC ; $97 $0FD2 0 BR_READ_V23 Read Fast Variable 23 into FAC ; $98 $0FD2 0 BR_READ_V24 Read Fast Variable 24 into FAC ; $99 $0FD2 0 BR_READ_V25 Read Fast Variable 25 into FAC ; $9A $0FD2 0 BR_READ_V26 Read Fast Variable 26 into FAC ; $9B $0FD2 0 BR_READ_V27 Read Fast Variable 27 into FAC ; $9C $0FD2 0 BR_READ_V28 Read Fast Variable 28 into FAC ; $9D $0FD2 0 BR_READ_V29 Read Fast Variable 29 into FAC ; $9E $0FD2 0 BR_READ_V30 Read Fast Variable 30 into FAC ; $9F $0FD2 0 BR_READ_V31 Read Fast Variable 31 into FAC ; $A0 $1065 1 BR_READ_V255 Read variable (32-255) ; $A1 $1065 1 BR_READ_V511 Read variable (256-511) ; $A2 $1065 1 BR_READ_V767 Read variable (512-767) ; $A3 $1065 2 BR_READ_VEXT Read variable with 16-bit index (768+) ; $A4 $119F 1 BR_ARY_READ Read element from Float/Int Array ; $A5 $119F 1 BR_ARY_SREAD Read element from String Array ; $A6 $10CA 1 BR_IMM_BYTE Load immediate 8-bit byte into FAC ; $A7 $10C6 2 BR_IMM_INT Load immediate 16-bit integer into FAC ; $A8 $10D9 5 BR_IMM_FLT Load immediate 5-byte Float into FAC ; $A9 $10D9 5 BR_IMM_FLT Load immediate 5-byte Float into FAC ; $AA $1139 0 BR_LOAD_PI Copy Pi constant from ROM to FAC ; $AB $115C 0 BR_LOAD_ST Load system status byte (ST) into FAC ; $AC $1143 0 BR_LOAD_TI Load system timer (TI) into FAC ; $AD $1159 0 BR_UNDEFINED Undefined - Triggers Syntax Error ; $AE $1159 0 BR_UNDEFINED Undefined - Triggers Syntax Error ; $AF $114F 0 BR_LOAD_TI$ Load system timer string (TI$) as FAC pointer ; $B0 $10A7 0 BR_SET_0 Set FAC to integer 0 ; $B1 $10A7 0 BR_SET_1 Set FAC to integer 1 ; $B2 $10A7 0 BR_SET_2 Set FAC to integer 2 ; $B3 $10A7 0 BR_SET_3 Set FAC to integer 3 ; $B4 $10A7 0 BR_SET_4 Set FAC to integer 4 ; $B5 $10A7 0 BR_SET_5 Set FAC to integer 5 ; $B6 $10A7 0 BR_SET_6 Set FAC to integer 6 ; $B7 $10A7 0 BR_SET_7 Set FAC to integer 7 ; $B8 $10A7 0 BR_SET_8 Set FAC to integer 8 ; $B9 $10A7 0 BR_SET_9 Set FAC to integer 9 ; $BA $10A7 0 BR_SET_10 Set FAC to integer 10 ; $BB $10A7 0 BR_SET_11 Set FAC to integer 11 ; $BC $10A7 0 BR_SET_12 Set FAC to integer 12 ; $BD $10A7 0 BR_SET_13 Set FAC to integer 13 ; $BE $10A7 0 BR_SET_14 Set FAC to integer 14 ; $BF $10A7 0 BR_SET_15 Set FAC to integer 15 ; $C0 $0EDB 0 BR_WRITE_V0 Store FAC into Fast Variable 0 ; $C1 $0EDB 0 BR_WRITE_V1 Store FAC into Fast Variable 1 ; $C2 $0EDB 0 BR_WRITE_V2 Store FAC into Fast Variable 2 ; $C3 $0EDB 0 BR_WRITE_V3 Store FAC into Fast Variable 3 ; $C4 $0EDB 0 BR_WRITE_V4 Store FAC into Fast Variable 4 ; $C5 $0EDB 0 BR_WRITE_V5 Store FAC into Fast Variable 5 ; $C6 $0EDB 0 BR_WRITE_V6 Store FAC into Fast Variable 6 ; $C7 $0EDB 0 BR_WRITE_V7 Store FAC into Fast Variable 7 ; $C8 $0EDB 0 BR_WRITE_V8 Store FAC into Fast Variable 8 ; $C9 $0EDB 0 BR_WRITE_V9 Store FAC into Fast Variable 9 ; $CA $0EDB 0 BR_WRITE_V10 Store FAC into Fast Variable 10 ; $CB $0EDB 0 BR_WRITE_V11 Store FAC into Fast Variable 11 ; $CC $0EDB 0 BR_WRITE_V12 Store FAC into Fast Variable 12 ; $CD $0EDB 0 BR_WRITE_V13 Store FAC into Fast Variable 13 ; $CE $0EDB 0 BR_WRITE_V14 Store FAC into Fast Variable 14 ; $CF $0EDB 0 BR_WRITE_V15 Store FAC into Fast Variable 15 ; $D0 $0EDB 0 BR_WRITE_V16 Store FAC into Fast Variable 16 ; $D1 $0EDB 0 BR_WRITE_V17 Store FAC into Fast Variable 17 ; $D2 $0EDB 0 BR_WRITE_V18 Store FAC into Fast Variable 18 ; $D3 $0EDB 0 BR_WRITE_V19 Store FAC into Fast Variable 19 ; $D4 $0EDB 0 BR_WRITE_V20 Store FAC into Fast Variable 20 ; $D5 $0EDB 0 BR_WRITE_V21 Store FAC into Fast Variable 21 ; $D6 $0EDB 0 BR_WRITE_V22 Store FAC into Fast Variable 22 ; $D7 $0EDB 0 BR_WRITE_V23 Store FAC into Fast Variable 23 ; $D8 $0EDB 0 BR_WRITE_V24 Store FAC into Fast Variable 24 ; $D9 $0EDB 0 BR_WRITE_V25 Store FAC into Fast Variable 25 ; $DA $0EDB 0 BR_WRITE_V26 Store FAC into Fast Variable 26 ; $DB $0EDB 0 BR_WRITE_V27 Store FAC into Fast Variable 27 ; $DC $0EDB 0 BR_WRITE_V28 Store FAC into Fast Variable 28 ; $DD $0EDB 0 BR_WRITE_V29 Store FAC into Fast Variable 29 ; $DE $0EDB 0 BR_WRITE_V30 Store FAC into Fast Variable 30 ; $DF $0EDB 0 BR_WRITE_V31 Store FAC into Fast Variable 31 ; $E0 $1065 1 BR_WRITE_V255 Store FAC into variable (32-255) ; $E1 $1065 1 BR_WRITE_V511 Store FAC into variable (256-511) ; $E2 $1065 1 BR_WRITE_V767 Store FAC into variable (512-767) ; $E3 $1065 2 BR_WRITE_VEXT Store FAC into variable (768+) ; $E4 $119F 1 BR_ARY_WRITE Write FAC to Float/Int Array ; $E5 $119F 1 BR_ARY_SWRITE Write FAC to String Array ; $E6 $0F4E 0 BR_VAR_CONT Secondary variable dispatch logic ; $E7 $1118 7 BR_STR_7 Inline String of length VARIABLE ; $E8 $1118 0 BR_STR_0 Inline String of length 0 ; $E9 $1118 1 BR_STR_1 Inline String of length 1 ; $EA $1118 2 BR_STR_2 Inline String of length 2 ; $EB $1118 3 BR_STR_3 Inline String of length 3 ; $EC $1118 4 BR_STR_4 Inline String of length 4 ; $ED $1118 5 BR_STR_5 Inline String of length 5 ; $EE $1118 6 BR_STR_6 Inline String of length 6 ; $EF $1118 7 BR_STR_7 Inline String of length 7 ; $F0 $1100 0 BR_SET_16 Set FAC to integer 16 ; $F1 $1100 0 BR_SET_17 Set FAC to integer 17 ; $F2 $1100 0 BR_SET_18 Set FAC to integer 18 ; $F3 $1100 0 BR_SET_19 Set FAC to integer 19 ; $F4 $1100 0 BR_SET_20 Set FAC to integer 20 ; $F5 $1100 0 BR_SET_21 Set FAC to integer 21 ; $F6 $1100 0 BR_SET_22 Set FAC to integer 22 ; $F7 $1100 0 BR_SET_23 Set FAC to integer 23 ; $F8 $1100 0 BR_SET_24 Set FAC to integer 24 ; $F9 $1100 0 BR_SET_25 Set FAC to integer 25 ; $FA $1100 0 BR_SET_26 Set FAC to integer 26 ; $FB $1100 0 BR_SET_27 Set FAC to integer 27 ; $FC $1100 0 BR_SET_28 Set FAC to integer 28 ; $FD $1100 0 BR_SET_29 Set FAC to integer 29 ; $FE $1100 0 BR_SET_30 Set FAC to integer 30 ; $FF $1100 0 BR_SET_31 Set FAC to integer 31 ;--------------------------------------------------- * = $0801 0801 1A NOP 0802 08 PHP 0803 01 00 ORA ($00,X) 0805 9E 32 30 SHX $3032,Y ; SYS2076 -> 081c 0808 37 36 RLA $36,X 080A 14 14 NOP $14,X 080C 14 14 NOP $14,X 080E 14 14 NOP $14,X 0810 14 14 NOP $14,X 0812 14 42 NOP $42,X 0814 41 54 EOR ($54,X) 0816 43 ;-------------------------------------------------- 0817 4F SRE ($4F,X) 0818 4D 00 00 EOR $0000 081B 00 BRK ;------------------------------------------------- 081C 4C 92 0C JMP L0C92 ; START of interpreter 081F 4C A7 0E JMP L0EA7 ; CONTINUE 0822 4C 81 0E JMP L0E81 ;----------------------------------------- ; hi byte jump table 0825 09 09 ORA #$09 0827 1E 1B 1B ASL $1B1B,X 082A 1C ;----------------------------------------- 082B 1C 0C NOP $0C1C,X ; 15 = 0c , 16 = 0c 082D 0C 18 18 NOP $1818 0830 1D 1D 1C ORA $1C1D,X 0833 1C 1D 0C NOP $0C1D,X 0836 1D 15 15 ORA $1515,X 0839 15 15 L0839 ORA $15,X 083B 15 15 ORA $15,X 083D 15 15 ORA $15,X 083F 15 15 ORA $15,X 0841 15 15 ORA $15,X 0843 15 15 ORA $15,X 0845 15 15 ORA $15,X 0847 15 15 ORA $15,X 0849 14 16 NOP $16,X 084B 17 17 SLO $17,X 084D 17 1D SLO $1D,X 084F 1D 1D 0E ORA $0E1D,X 0852 19 18 18 ORA $1818,Y 0855 18 CLC 0856 19 19 19 ORA $1919,Y 0859 19 18 19 ORA L1918,Y 085C 19 16 0E ORA $0E16,Y 085F 16 0E ASL $0E,X 0861 18 CLC 0862 18 CLC 0863 18 CLC 0864 18 CLC 0865 0E 0E 1A ASL $1A0E 0868 1A NOP 0869 1C 1A 1B NOP $1B1A,X 086C 1A NOP 086D 0D 1A 1D ORA $1D1A 0870 19 1A 1A ORA $1A1A,Y 0873 1A NOP 0874 1E 1E 1E ASL $1E1E,X 0877 1F 19 1F SLO $1F19,X 087A 1F 1F 1F SLO $1F1F,X 087D 1F 1F 1F SLO $1F1F,X 0880 1F 1F 1F SLO $1F1F,X 0883 1F 1F 1F SLO $1F1F,X 0886 1F 1F ;------------------------------------------------------------- lo byte jump table 0888 97 SLO $971F,X 0889 AE 07 74 LDX $7407 088C 62 JAM 088D 2A ROL A 088E 0A L088E ASL A 088F 80 A6 NOP #$A6 ; 15 = 80 0891 32 JAM 0892 56 1C LSR $1C,X 0894 0F E3 E3 SLO $E3E3 0897 30 A0 BMI L0839 0899 72 JAM 089A 66 49 ROR $49 089C 36 24 ROL $24,X 089E 24 95 BIT $95 08A0 24 24 BIT $24 08A2 24 24 BIT $24 08A4 24 24 BIT $24 08A6 24 08a7 24 BIT $24 08A8 85 9A STA $9A 08AA FD C8 FE SBC $FEC8,X 08AD 7A NOP 08AE 74 74 NOP $74,X 08B0 41 8D EOR ($8D,X) 08B2 C2 43 NOP #$43 08B4 CB 60 SBX #$60 ;-------------------------------------------------- 08B6 DA NOP 08B7 DA NOP 08B8 DA NOP 08B9 9E 6D 6D SHX $6D6D,Y 08BC BA TSX 08BD DA NOP 08BE BA TSX 08BF B0 CD BCS L088E 08C1 08 PHP 08C2 B4 9A LDY $9A,X 08C4 6B 6B ARR #$6B 08C6 32 JAM 08C7 32 JAM 08C8 9D A0 12 STA $12A0,X 08CB 5C CC 1D NOP $1DCC,X 08CE 1A NOP 08CF 1D FE 5C ORA $5CFE,X 08D2 5C FD 06 NOP $06FD,X 08D5 00 BRK 08D6 09 A0 ORA #$A0 08D8 A2 9F LDX #$9F 08DA 3D DA 75 AND $75DA,X 08DD 75 75 ADC $75,X 08DF 76 75 ROR $75,X 08E1 75 75 ADC $75,X 08E3 75 75 ADC $75,X 08E5 75 75 ADC $75,X 08E7 74 75 NOP $75,X 08E9 75 77 ADC $77,X ;------------------------------------------------ tokens c0-df: fast-track variables (32), also for 80-9f 08EB 00 BRK 08EC 07 0E SLO $0E 08EE 15 1C ORA $1C,X 08F0 23 2A RLA ($2A,X) 08F2 31 38 AND ($38),Y 08F4 3F 46 4D RLA $4D46,X 08F7 54 5B NOP $5B,X 08F9 62 L08F9 JAM 08FA 69 70 ADC #$70 08FC 77 7E RRA $7E,X 08FE 85 8C STA $8C 0900 93 9A SHA ($9A),Y 0902 A1 A8 LDA ($A8,X) 0904 AF B6 BD LAX $BDB6 0907 C4 CB CPY $CB 0909 D2 JAM 090A D9 27 ;------------------------------------------------------- 090c 03 CMP $0327,Y ; lo byte arithmetic routines start address 090D 00 BRK 090E 00 BRK 090F 10 E8 BPL L08F9 ;------------------------------------------------------- 0911 64 0A NOP $0A ; hi byte arithmetic routines start address 0913 6A ROR A ; START ARITHMETIC LO BYTE!! 0914 53 2B SRE ($2B),Y ;------------------------------------------------------ 0916 12 JAM 0917 7B 0918 B8 B8 RRA $B8B8,Y ; START ARITHMETIC HI BYTE!! 091A BA TSX 091B BB BF ;--------------------------------------------------------; INT_TO_ASCII_STRING 091D A0 02 L091D LDY #$02 091F A9 20 LDA #$20 0921 24 64 BIT $64 0923 10 05 BPL L092A 0925 20 C9 0D JSR L0DC9 ; NEGATE 64/65 0928 A9 2D LDA #$2D 092A 99 FE 00 L092A STA $00FE,Y 092D 84 71 STY $71 092F A2 00 LDX #$00 0931 86 62 STX $62 0933 A5 64 LDA $64 0935 F0 0C BEQ L0943 0937 C9 27 CMP #$27 0939 B0 13 BCS L094E 093B E8 INX 093C C9 03 CMP #$03 093E B0 0E BCS L094E 0940 E8 INX 0941 90 0B BCC L094E 0943 A5 65 L0943 LDA $65 0945 F0 4B BEQ L0992 0947 A2 02 LDX #$02 0949 C9 64 CMP #$64 094B B0 01 BCS L094E 094D E8 INX 094E BD 0B 09 L094E LDA $090B,X 0951 85 22 STA $22 0953 BD 0F 09 LDA $090F,X 0956 85 23 STA $23 0958 A0 FF LDY #$FF 095A 38 SEC 095B C8 L095B INY 095C A5 65 LDA $65 095E E5 23 SBC $23 0960 85 65 STA $65 0962 A5 64 LDA $64 0964 E5 22 SBC $22 0966 85 64 STA $64 0968 B0 F1 BCS L095B 096A A5 65 LDA $65 096C 65 23 ADC $23 096E 85 65 STA $65 0970 A5 64 LDA $64 0972 65 22 ADC $22 0974 85 64 STA $64 0976 A5 62 LDA $62 0978 D0 05 BNE L097F 097A 98 TYA 097B F0 0C BEQ L0989 097D E6 62 INC $62 097F 98 L097F TYA 0980 09 30 ORA #$30 0982 A4 71 LDY $71 0984 99 FF 00 STA $00FF,Y 0987 E6 71 INC $71 0989 E8 L0989 INX 098A E0 04 CPX #$04 098C 90 C0 BCC L094E 098E A4 71 LDY $71 0990 A5 65 LDA $65 0992 09 30 L0992 ORA #$30 0994 4C 04 BF JMP $BF04 ; save last character in accumulator to output string, set null terminator and exit with A/Y pointing to 0100 ;-------------------------------------------------------; NEGATE_FAC 0997 A5 0E LDA $0E 0999 10 06 BPL L09A1 099B 20 C9 0D JSR L0DC9 ; NEGATE 64/65 099E 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;--------------------------------------- 09A1 A5 61 L09A1 LDA $61 09A3 F0 06 BEQ L09AB 09A5 A5 66 LDA $66 09A7 49 FF EOR #$FF 09A9 85 66 STA $66 09AB 4C CB 0E L09AB JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------------; CONVERT_AND_NOT_FAC (NOT) 09AE A5 0E LDA $0E 09B0 30 03 BMI L09B5 09B2 20 42 14 JSR L1442 ; transform the floating-point value in FAC1 into a 16-bit integer stored in $64/$65 and update the type flag in $0E. 09B5 A5 64 L09B5 LDA $64 09B7 49 FF EOR #$FF 09B9 85 64 STA $64 09BB A5 65 LDA $65 09BD 49 FF EOR #$FF 09BF 85 65 STA $65 09C1 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------------ 09C4 4C 58 B6 L09C4 JMP $B658 ;-------------------------------------------------------- 09C7 AA L09C7 TAX ; STRING_CONCATENATION_ENGINE 09C8 D0 04 BNE L09CE 09CA A6 6F LDX $6F 09CC D0 06 BNE L09D4 09CE A6 65 L09CE LDX $65 09D0 D0 04 BNE L09D6 09D2 A6 64 LDX $64 09D4 86 16 L09D4 STX $16 09D6 A5 61 L09D6 LDA $61 09D8 85 6E STA $6E ;----------------------------------------------------- 09da 09DA B1 6F LDA ($6F),Y 09DC 85 69 STA $69 09DE 18 CLC 09DF 65 61 ADC $61 09E1 B0 E1 BCS L09C4 09E3 85 61 STA $61 09E5 F0 66 BEQ L0A4D 09E7 A5 33 LDA $33 09E9 A4 34 LDY $34 09EB 38 SEC 09EC E5 61 SBC $61 09EE B0 01 BCS L09F1 09F0 88 DEY 09F1 C4 32 L09F1 CPY $32 09F3 D0 02 BNE L09F7 09F5 C5 31 CMP $31 09F7 B0 03 L09F7 BCS L09FC 09F9 20 7A 1F JSR L1F7A ; FORCE_GARBAGE_COLLECT_AND_CHECK 09FC 85 33 L09FC STA $33 09FE 85 62 STA $62 0A00 85 35 STA $35 0A02 84 34 STY $34 0A04 84 63 STY $63 0A06 84 36 STY $36 0A08 A0 02 LDY #$02 0A0A B1 6F LDA ($6F),Y 0A0C 85 23 STA $23 0A0E 88 DEY 0A0F B1 6F LDA ($6F),Y 0A11 85 22 STA $22 0A13 A4 69 LDY $69 0A15 F0 19 BEQ L0A30 0A17 88 DEY 0A18 F0 07 BEQ L0A21 0A1A B1 22 L0A1A LDA ($22),Y 0A1C 91 35 STA ($35),Y 0A1E 88 DEY 0A1F D0 F9 BNE L0A1A 0A21 B1 22 L0A21 LDA ($22),Y 0A23 91 35 STA ($35),Y 0A25 A5 69 LDA $69 0A27 18 CLC 0A28 65 35 ADC $35 0A2A 85 35 STA $35 0A2C 90 02 BCC L0A30 0A2E E6 36 INC $36 0A30 A0 02 L0A30 LDY #$02 0A32 B1 64 LDA ($64),Y 0A34 85 23 STA $23 0A36 88 DEY 0A37 B1 64 LDA ($64),Y 0A39 85 22 STA $22 0A3B A4 6E LDY $6E 0A3D F0 0E BEQ L0A4D 0A3F 88 DEY 0A40 F0 07 BEQ L0A49 0A42 B1 22 L0A42 LDA ($22),Y 0A44 91 35 STA ($35),Y 0A46 88 DEY 0A47 D0 F9 BNE L0A42 0A49 B1 22 L0A49 LDA ($22),Y 0A4B 91 35 STA ($35),Y 0A4D 4C 0C 18 L0A4D JMP L180C ; PUSH_STRING_STACK (String Stack Manager) and next token ;------------------------------------------------------- 0A50 A6 65 L0A50 LDX $65 ; GENERAL_COMPARISON_ENGINE 0A52 D0 1D BNE L0A71 0A54 A6 64 LDX $64 0A56 86 16 STX $16 0A58 A6 63 LDX $63 0A5A E4 34 CPX $34 0A5C D0 13 BNE L0A71 0A5E A6 62 LDX $62 0A60 E4 33 CPX $33 0A62 D0 0D BNE L0A71 0A64 A5 61 LDA $61 0A66 F0 09 BEQ L0A71 0A68 18 CLC 0A69 65 33 ADC $33 0A6B 85 33 STA $33 0A6D 90 02 BCC L0A71 0A6F E6 34 INC $34 0A71 B1 6F L0A71 LDA ($6F),Y 0A73 AA TAX 0A74 C8 INY 0A75 B1 6F LDA ($6F),Y 0A77 85 6A STA $6A 0A79 C8 INY 0A7A B1 6F LDA ($6F),Y 0A7C 85 6B STA $6B 0A7E A5 70 LDA $70 0A80 D0 1C BNE L0A9E 0A82 A5 6F LDA $6F 0A84 85 16 STA $16 0A86 A5 6B LDA $6B 0A88 C5 34 CMP $34 0A8A D0 12 BNE L0A9E 0A8C A5 6A LDA $6A 0A8E C5 33 CMP $33 0A90 D0 0C BNE L0A9E 0A92 8A TXA 0A93 F0 09 BEQ L0A9E 0A95 18 CLC 0A96 65 6A ADC $6A 0A98 85 33 STA $33 0A9A 90 02 BCC L0A9E 0A9C E6 34 INC $34 0A9E E4 61 L0A9E CPX $61 0AA0 F0 08 BEQ L0AAA 0AA2 A0 04 LDY #$04 0AA4 90 04 BCC L0AAA 0AA6 A0 01 LDY #$01 0AA8 A6 61 LDX $61 0AAA 84 66 L0AAA STY $66 0AAC A0 FF LDY #$FF 0AAE E8 INX 0AAF C8 L0AAF INY 0AB0 CA DEX 0AB1 F0 20 BEQ L0AD3 0AB3 B1 6A LDA ($6A),Y 0AB5 D1 62 CMP ($62),Y 0AB7 F0 F6 BEQ L0AAF 0AB9 A9 01 LDA #$01 0ABB B0 02 BCS L0ABF 0ABD A9 04 LDA #$04 0ABF 25 3C L0ABF AND $3C 0AC1 F0 02 BEQ L0AC5 0AC3 A9 FF LDA #$FF 0AC5 85 64 L0AC5 STA $64 0AC7 85 65 STA $65 0AC9 A9 80 LDA #$80 0ACB 85 0E STA $0E 0ACD 0A ASL A 0ACE 85 0D STA $0D 0AD0 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 0AD3 A5 66 L0AD3 LDA $66 0AD5 10 E8 BPL L0ABF ;----------------------------------------------- TOKEN 00-06 - COMPARISONS 0AD7 A4 69 L0AD7 LDY $69 0AD9 D0 22 BNE L0AFD 0ADB A4 61 LDY $61 0ADD F0 08 BEQ L0AE7 0ADF A5 66 L0ADF LDA $66 0AE1 30 07 BMI L0AEA 0AE3 A9 04 L0AE3 LDA #$04 0AE5 D0 05 BNE L0AEC 0AE7 A9 02 L0AE7 LDA #$02 0AE9 2C A9 01 BIT $01A9 0AEC 25 3C L0AEC AND $3C 0AEE F0 02 BEQ L0AF2 0AF0 A9 FF LDA #$FF 0AF2 85 64 L0AF2 STA $64 0AF4 85 65 STA $65 0AF6 A9 80 LDA #$80 0AF8 85 0E STA $0E 0AFA 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 0AFD A5 61 L0AFD LDA $61 0AFF D0 06 BNE L0B07 0B01 A5 6E L0B01 LDA $6E 0B03 30 DE BMI L0AE3 0B05 10 E3 BPL L0AEA 0B07 A5 66 L0B07 LDA $66 0B09 45 6E EOR $6E 0B0B 30 D2 BMI L0ADF 0B0D C4 61 CPY $61 0B0F D0 1C BNE L0B2D 0B11 A5 6A LDA $6A 0B13 C5 62 CMP $62 0B15 D0 16 BNE L0B2D 0B17 A5 6B LDA $6B 0B19 C5 63 CMP $63 0B1B D0 10 BNE L0B2D 0B1D A5 6C LDA $6C 0B1F C5 64 CMP $64 0B21 D0 0A BNE L0B2D 0B23 A9 7F LDA #$7F 0B25 C5 70 CMP $70 0B27 A5 6D LDA $6D 0B29 E5 65 SBC $65 0B2B F0 BA BEQ L0AE7 0B2D 90 B0 L0B2D BCC L0ADF 0B2F B0 D0 BCS L0B01 ;-------------------------------------------------- 0B31 A0 00 L0B31 LDY #$00 ; FP_NORMALIZE_AND_DISPATCH 0B33 84 69 STY $69 0B35 84 6A STY $6A 0B37 84 6B STY $6B 0B39 A2 90 LDX #$90 0B3B A5 6C LDA $6C 0B3D 85 6E STA $6E 0B3F 10 12 BPL L0B53 0B41 49 FF EOR #$FF 0B43 85 6C STA $6C 0B45 A5 6D LDA $6D 0B47 49 FF EOR #$FF 0B49 85 6D STA $6D 0B4B E6 6D INC $6D 0B4D D0 02 BNE L0B51 0B4F E6 6C INC $6C 0B51 A5 6C L0B51 LDA $6C 0B53 D0 08 L0B53 BNE L0B5D 0B55 A2 88 LDX #$88 0B57 A5 6D LDA $6D 0B59 F0 16 BEQ L0B71 ; do comparison or arithmetic 0B5B 84 6D STY $6D 0B5D 30 06 L0B5D BMI L0B65 0B5F CA L0B5F DEX 0B60 06 6D ASL $6D 0B62 2A ROL A 0B63 10 FA BPL L0B5F 0B65 85 6A L0B65 STA $6A 0B67 A5 6D LDA $6D 0B69 85 6B STA $6B 0B6B 86 69 STX $69 0B6D 84 6C STY $6C 0B6F 84 6D STY $6D ;------------------------------------------------ 0B71 A5 0E L0B71 LDA $0E ; FP_ARITHMETIC_ROUTER 0B73 10 03 BPL L0B78 0B75 20 FF 13 JSR L13FF ;Integer to Floating-Point conversion FAC 0B78 A4 3C L0B78 LDY $3C 0B7A C0 07 CPY #$07 ; token for comparison or arithmetic 0B7C B0 03 BCS L0B81 0B7E 4C D7 0A JMP L0AD7 ; do comparison 0B81 B9 0C 09 L0B81 LDA $090C,Y ; ; get jump table for arithmetic 0B84 85 55 STA $55 0B86 B9 11 09 LDA $0911,Y 0B89 85 56 STA $56 0B8B A5 6E LDA $6E 0B8D 45 66 EOR $66 0B8F 85 6F STA $6F 0B91 A5 61 LDA $61 0B93 20 54 00 JSR $0054 ; 54-56 is JMP ABS, so JSR there , which will jump to 55/56 and return here 0B96 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN ;----------------------------------------------------- 0B99 A2 02 L0B99 LDX #$02 0B9B A5 6C LDA $6C 0B9D C5 64 CMP $64 0B9F D0 06 BNE L0BA7 0BA1 A4 6D LDY $6D 0BA3 C4 65 CPY $65 0BA5 F0 09 BEQ L0BB0 0BA7 CA L0BA7 DEX 0BA8 45 64 EOR $64 0BAA 30 12 BMI L0BBE 0BAC B0 02 BCS L0BB0 0BAE A2 04 L0BAE LDX #$04 0BB0 8A L0BB0 TXA 0BB1 25 3C AND $3C 0BB3 F0 02 BEQ L0BB7 0BB5 A9 FF LDA #$FF 0BB7 85 64 L0BB7 STA $64 0BB9 85 65 STA $65 0BBB 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 0BBE B0 EE L0BBE BCS L0BAE 0BC0 90 EE BCC L0BB0 ;---------------------------------------------------------- 0BC2 A5 61 L0BC2 LDA $61 ; SMART_MATH_ROUTINE_SELECTOR 0BC4 D0 04 BNE L0BCA 0BC6 85 64 STA $64 0BC8 F0 44 BEQ L0C0E 0BCA 24 70 L0BCA BIT $70 0BCC 10 03 BPL L0BD1 0BCE 20 1B BC JSR $BC1B ; round FAC1 0BD1 A5 64 L0BD1 LDA $64 0BD3 05 65 ORA $65 0BD5 D0 50 BNE L0C27 0BD7 A5 61 LDA $61 0BD9 C9 81 CMP #$81 0BDB 90 4A BCC L0C27 0BDD E9 90 SBC #$90 0BDF 10 46 BPL L0C27 0BE1 C9 F9 CMP #$F9 0BE3 B0 16 BCS L0BFB 0BE5 69 07 ADC #$07 0BE7 AA TAX 0BE8 A5 63 LDA $63 0BEA D0 3B BNE L0C27 0BEC A5 62 LDA $62 0BEE E8 INX 0BEF F0 06 BEQ L0BF7 0BF1 4A L0BF1 LSR A 0BF2 B0 33 BCS L0C27 0BF4 E8 INX 0BF5 D0 FA BNE L0BF1 0BF7 86 64 L0BF7 STX $64 0BF9 F0 13 BEQ L0C0E 0BFB AA L0BFB TAX 0BFC A5 63 LDA $63 0BFE 85 28 STA $28 0C00 A5 62 LDA $62 0C02 4A L0C02 LSR A 0C03 66 28 ROR $28 0C05 B0 20 BCS L0C27 0C07 E8 INX 0C08 D0 F8 BNE L0C02 0C0A 85 64 STA $64 0C0C A5 28 LDA $28 0C0E 85 65 L0C0E STA $65 0C10 24 66 BIT $66 0C12 10 03 BPL L0C17 0C14 20 C9 0D JSR L0DC9 ; NEGATE 64/65 0C17 A9 80 L0C17 LDA #$80 0C19 85 0E STA $0E 0C1B A6 3C LDX $3C 0C1D E0 07 CPX #$07 0C1F B0 03 BCS L0C24 0C21 4C 99 0B JMP L0B99 0C24 4C FE 0C L0C24 JMP L0CFE ; INT_ARITHMETIC_DISPATCH 0C27 4C 31 0B L0C27 JMP L0B31 ; FP_NORMALIZE_AND_DISPATCH ;-------------------------------------------------------; ; perform OR or AND ARG vs FAC 0C2A 20 5C 0C L0C2A JSR L0C5C ; converting a floating-point number in ARG into a 16-bit signed integer at 6c/6d ;----------------------------------------------------- 0C2D A5 0E L0C2D LDA $0E ; INT_LOGIC_DISPATCH 0C2F 30 03 BMI L0C34 0C31 20 42 14 JSR L1442 ; transform the floating-point value in FAC1 into a 16-bit signed integer stored in $64/$65 and update the type flag in $0E. 0C34 46 3C L0C34 LSR $3C 0C36 B0 0C BCS L0C44 0C38 A5 6C LDA $6C 0C3A 25 64 AND $64 0C3C 85 64 STA $64 0C3E A5 6D LDA $6D 0C40 25 65 AND $65 0C42 90 0A BCC L0C4E 0C44 A5 6C L0C44 LDA $6C 0C46 05 64 ORA $64 0C48 85 64 STA $64 0C4A A5 6D LDA $6D 0C4C 05 65 ORA $65 0C4E 85 65 L0C4E STA $65 0C50 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN ;---------------------------------------------------------- 0C53 4C 48 B2 L0C53 JMP $B248 ; do illegal quantity error then warm start 0C56 A9 00 L0C56 LDA #$00 0C58 85 6B STA $6B 0C5A F0 13 BEQ L0C6F ;-----------------------------------------------------------; converting a floating-point number into a 16-bit signed integer 0C5C A5 69 L0C5C LDA $69 ; ARG, arithmetic register , highest byte 0C5E C9 81 CMP #$81 ; check if lower than $81 0C60 90 F4 BCC L0C56 ; if so, reset 6b and jump to 0c6f 0C62 E9 90 SBC #$90 ; subtract 90 0C64 10 ED BPL L0C53 ; if not minus, means it is 90 or higher, do illegal quantity 0C66 AA TAX ; between 81 and 8f, set x to remainder (between f1-ff) 0C67 A5 6A LDA $6A ; divide 6a/6b by 2 as many times (01-0f times) (shift bits) 0C69 4A L0C69 LSR A 0C6A 66 6B ROR $6B 0C6C E8 INX 0C6D D0 FA BNE L0C69 ; do another division if needed 0C6F 06 6E L0C6F ASL $6E ; shift 6e left 0C71 90 02 BCC L0C75 ; was carry clear (meaning bit 7 of 6e was not set), jump 0c75 0C73 49 FF EOR #$FF 0C75 85 6C L0C75 STA $6C 0C77 A5 6B LDA $6B 0C79 90 02 BCC L0C7D 0C7B 49 FF EOR #$FF 0C7D 85 6D L0C7D STA $6D 0C7F 60 RTS ;------------------------------------------------------- OPCODE 15 BASIC_CLR_ROUTINE 0C80 20 E7 FF JSR $FFE7 ; close all channels and files 0C83 20 B1 0C L0C83 JSR L0CB1 ; reset all basic parameters ;------------------------------------------------------ 0C86 A5 39 LDA $39 ; Current BASIC line number is stored in 50/51 / Pointer to current string variable during memory allocation 0C88 85 50 STA $50 0C8A A5 3A LDA $3A 0C8C 85 51 STA $51 0C8E A0 06 LDY #$06 ; set y to 6 , get pointer 1f97 in A/X 0C90 D0 05 BNE L0C97 ; will always be taken ;------------------------------------------------------- START of interpreter 0C92 20 E4 0C L0C92 JSR L0CE4 0C95 A0 0A LDY #$0A ; get D1 in A, 20 in X (start of tokenized program) 0C97 B9 93 1F L0C97 LDA $1F93,Y 0C9A BE 94 1F LDX $1F94,Y 0C9D 4C 23 1D JMP L1D23 ; set Current BASIC line number / token position pointer to A/Y, RESET Y index and do next token ;------------------------------------------------------ 0CA0 20 F3 0C JSR L0CF3 ; set Pointer to start DATA item for READ from $1f9b adn 1f9c 0CA3 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;------------------------------------------------------ ;EXECUTE_CONT_COMMAND 0CA6 A5 50 LDA $50 0CA8 85 39 STA $39 0CAA A5 51 LDA $51 0CAC 85 3A STA $3A 0CAE 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;--------------------------------------------------------- ; reset all basic parameters 0CB1 A2 05 L0CB1 LDX #$05 0CB3 BD 93 1F L0CB3 LDA $1F93,X 0CB6 95 2D STA $2D,X 0CB8 CA DEX 0CB9 10 F8 BPL L0CB3 0CBB A6 2E LDX $2E 0CBD 86 60 L0CBD STX $60 0CBF 85 5F L0CBF STA $5F 0CC1 E4 30 CPX $30 0CC3 D0 04 BNE L0CC9 0CC5 C5 2F CMP $2F 0CC7 F0 13 BEQ L0CDC 0CC9 A0 01 L0CC9 LDY #$01 0CCB A9 00 LDA #$00 0CCD C8 L0CCD INY 0CCE 91 5F STA ($5F),Y 0CD0 C0 06 CPY #$06 0CD2 D0 F9 BNE L0CCD 0CD4 98 TYA 0CD5 65 5F ADC $5F 0CD7 90 E6 BCC L0CBF 0CD9 E8 INX 0CDA B0 E1 BCS L0CBD 0CDC A5 37 L0CDC LDA $37 ; Pointer to end of BASIC area is stored in start of string area 0CDE A4 38 LDY $38 0CE0 85 33 STA $33 0CE2 84 34 STY $34 0CE4 68 L0CE4 PLA ; get currnt from stack 0CE5 A8 TAY 0CE6 68 PLA 0CE7 A2 F8 LDX #$F8 ; set stack pointer to f8 0CE9 9A TXS 0CEA 48 PHA 0CEB 98 TYA 0CEC 48 PHA 0CED A9 00 LDA #$00 ; reset Current BASIC line number for CONT and INPUT switch to READ 0CEF 85 3B STA $3B 0CF1 85 11 STA $11 ;-------------------------------------------------------; 0CF3 AD 9B 1F L0CF3 LDA $1F9B ; set Pointer to next DATA item for READ 0CF6 85 41 STA $41 0CF8 AD 9C 1F LDA $1F9C 0CFB 85 42 STA $42 0CFD 60 RTS ;----------------------------------------------------------- 0CFE F0 11 L0CFE BEQ L0D11 ; INT_ARITHMETIC_DISPATCH 0D00 E0 08 CPX #$08 0D02 D0 4E BNE L0D52 0D04 A5 6D LDA $6D 0D06 E5 65 SBC $65 0D08 85 65 STA $65 0D0A A5 6C LDA $6C 0D0C E5 64 SBC $64 0D0E 4C 1C 0D JMP L0D1C 0D11 18 L0D11 CLC 0D12 A5 6D LDA $6D 0D14 65 65 ADC $65 0D16 85 65 STA $65 0D18 A5 6C LDA $6C 0D1A 65 64 ADC $64 0D1C 85 64 L0D1C STA $64 0D1E 70 03 BVS L0D23 0D20 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 0D23 A2 00 L0D23 LDX #$00 0D25 86 62 STX $62 0D27 86 63 STX $63 0D29 86 66 STX $66 0D2B 90 05 BCC L0D32 0D2D C6 66 DEC $66 0D2F 20 C9 0D JSR L0DC9 ; NEGATE 64/65 0D32 A9 00 L0D32 LDA #$00 0D34 85 0E STA $0E 0D36 85 70 STA $70 0D38 20 DB BC JSR $BCDB 0D3B 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 0D3E A5 62 L0D3E LDA $62 0D40 05 63 ORA $63 0D42 D0 EE BNE L0D32 0D44 A5 64 LDA $64 0D46 30 EA BMI L0D32 0D48 A5 66 LDA $66 0D4A 10 03 BPL L0D4F 0D4C 20 C9 0D JSR L0DC9 ; NEGATE 64/65 0D4F 4C C9 0E L0D4F JMP L0EC9 ; GET AND DO NEXT TOKEN 0D52 A5 64 L0D52 LDA $64 0D54 45 6C EOR $6C 0D56 85 66 STA $66 0D58 A5 64 LDA $64 0D5A 10 03 BPL L0D5F 0D5C 20 C9 0D JSR L0DC9 ; NEGATE 64/65 0D5F A5 6C L0D5F LDA $6C 0D61 10 10 BPL L0D73 0D63 49 FF EOR #$FF 0D65 85 6C STA $6C 0D67 A5 6D LDA $6D 0D69 49 FF EOR #$FF 0D6B 85 6D STA $6D 0D6D E6 6D INC $6D 0D6F D0 02 BNE L0D73 0D71 E6 6C INC $6C 0D73 A5 64 L0D73 LDA $64 0D75 A6 65 LDX $65 0D77 C5 6C CMP $6C 0D79 90 0A BCC L0D85 0D7B A4 6C LDY $6C 0D7D 85 6C STA $6C 0D7F A5 6D LDA $6D 0D81 86 6D STX $6D 0D83 AA TAX 0D84 98 TYA 0D85 A0 00 L0D85 LDY #$00 0D87 84 62 STY $62 0D89 84 63 STY $63 0D8B 84 64 STY $64 0D8D 84 65 STY $65 0D8F 84 6A STY $6A 0D91 84 6B STY $6B 0D93 A8 TAY 0D94 F0 46 BEQ L0DDC 0D96 85 28 STA $28 0D98 86 29 STX $29 0D9A A5 28 L0D9A LDA $28 0D9C 05 29 ORA $29 0D9E F0 9E L0D9E BEQ L0D3E 0DA0 46 28 LSR $28 0DA2 66 29 ROR $29 0DA4 90 19 BCC L0DBF 0DA6 18 CLC 0DA7 A5 65 LDA $65 0DA9 65 6D ADC $6D 0DAB 85 65 STA $65 0DAD A5 64 LDA $64 0DAF 65 6C ADC $6C 0DB1 85 64 STA $64 0DB3 A5 63 LDA $63 0DB5 65 6B ADC $6B 0DB7 85 63 STA $63 0DB9 A5 62 LDA $62 0DBB 65 6A ADC $6A 0DBD 85 62 STA $62 0DBF 06 6D L0DBF ASL $6D 0DC1 26 6C ROL $6C 0DC3 26 6B ROL $6B 0DC5 26 6A ROL $6A 0DC7 90 D1 BCC L0D9A ;--------------------------------------------- NEGATE 64/65 0DC9 A5 64 L0DC9 LDA $64 0DCB 49 FF EOR #$FF 0DCD 85 64 STA $64 0DCF A5 65 LDA $65 0DD1 49 FF EOR #$FF 0DD3 85 65 STA $65 0DD5 E6 65 INC $65 0DD7 D0 02 BNE L0DDB 0DD9 E6 64 INC $64 0DDB 60 L0DDB RTS ;-------------------------------------------- 0DDC 8A L0DDC TXA 0DDD F0 BF BEQ L0D9E 0DDF 4A LSR A 0DE0 AA TAX 0DE1 90 13 BCC L0DF6 0DE3 18 CLC 0DE4 A5 65 LDA $65 0DE6 65 6D ADC $6D 0DE8 85 65 STA $65 0DEA A5 64 LDA $64 0DEC 65 6C ADC $6C 0DEE 85 64 STA $64 0DF0 A5 63 LDA $63 0DF2 65 6B ADC $6B 0DF4 85 63 STA $63 0DF6 06 6D L0DF6 ASL $6D 0DF8 26 6C ROL $6C 0DFA 26 6B ROL $6B 0DFC 90 DE BCC L0DDC ;---------------------------------------------------BR_FREE_STR_AND_CONTINUE 0DFE A9 19 LDA #$19 0E00 85 16 STA $16 0E02 20 E0 A9 JSR $A9E0 ; FREE STRING 0E05 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;---------------------------------------------------;BR_SYNC_AND_EXECUTE (VIA ROM) 0E08 A5 39 LDA $39 0E0A A6 3A LDX $3A 0E0C 85 7A STA $7A 0E0E 86 7B STX $7B 0E10 85 3D STA $3D 0E12 86 3E STX $3E 0E14 4C E1 A7 JMP $A7E1 ; execute next basic code ;----------------------------------------------- ; do P-CODE/TOKEN below 0e (00-0d), X=TOKEN 0E17 85 3C L0E17 STA $3C ; store TOKEN in 3c 0E19 68 PLA ; get byte from stack 0E1A 30 1E BMI L0E3A ; if between 80-ff go down 0E1C D0 41 BNE L0E5F ; if not zero go down 0E1E 68 PLA ; it was zero , get next byte from stack 0E1F 85 6E STA $6E ; ARG, arithmetic register #2 (5 bytes).69-6d and sign in 6e 0E21 68 PLA ; fill ARG register 0E22 85 69 STA $69 0E24 68 PLA 0E25 85 6A STA $6A 0E27 68 PLA 0E28 85 6B STA $6B 0E2A 68 PLA 0E2B 85 6C STA $6C 0E2D 68 PLA 0E2E 85 6D STA $6D 0E30 E0 0C CPX #$0C ; was x (TOKEN) higher or equal to 12? (Either 0c or 0d, so OR or AND) 0E32 B0 03 BCS L0E37 ; then jump down and then to 0c2a 0E34 4C 71 0B JMP L0B71 ; FP_ARITHMETIC_ROUTER , else 0b71, it was between 00 and 0b do comparison or arithmetic 0E37 4C 2A 0C L0E37 JMP L0C2A ; perform OR or AND ARG vs FAC ;--------------------------------------------------- 0E3A 68 L0E3A PLA ; get address and store in 6c/cd (get int from stack ) 0E3B 85 6C STA $6C 0E3D 68 PLA 0E3E 85 6D STA $6D 0E40 E0 0C CPX #$0C ; is x c or higher 0E42 B0 15 BCS L0E59 ; if yes, go 0e59 0E44 E0 0A CPX #$0A ; is x 0a or 0b ? go 0e56 0E46 B0 0E BCS L0E56 0E48 A4 0E LDY $0E ; x is 0-9, get y from 0e ( Current numerical expression type, 00 = floating, 80 = integer ) 0E4A 10 10 BPL L0E5C ; if floating point then 0e5c 0E4C E0 07 CPX #$07 ; integer, now check x 0E4E B0 03 BCS L0E53 ; x 7 - 9 ? then jump 0E50 4C 99 0B JMP L0B99 ; 0-5 , go 0b99 0E53 4C FE 0C L0E53 JMP L0CFE ; INT_ARITHMETIC_DISPATCH 0E56 4C 31 0B L0E56 JMP L0B31 ; FP_NORMALIZE_AND_DISPATCH 0E59 4C 2D 0C L0E59 JMP L0C2D ; INT_LOGIC_DISPATCH (AND/OR) 0E5C 4C C2 0B L0E5C JMP L0BC2 ; SMART_MATH_ROUTINE_SELECTOR ;--------------------------------------- 0E5F 68 L0E5F PLA 0E60 85 6F STA $6F 0E62 68 PLA 0E63 85 70 STA $70 0E65 E0 07 CPX #$07 0E67 B0 03 BCS L0E6C 0E69 4C 50 0A JMP L0A50 ; GENERAL_COMPARISON_ENGINE 0E6C 4C C7 09 L0E6C JMP L09C7 ; STRING_CONCATENATION_ENGINE ;----------------------------------------------------------- DO P-CODE < $80 0E6F AA L0E6F TAX ; transfer code to x 0E70 C9 0E CMP #$0E ; check if lower than 0e (14) (00-0d) 0E72 90 A3 BCC L0E17 ; if so jump up 0E74 BD 7A 08 LDA $087A,X ; get jump address lo 0E77 85 55 STA $55 0E79 BD 17 08 LDA $0817,X ; get jump address hi 0E7C 85 56 STA $56 0E7E 6C 55 00 JMP ($0055) ; do the jump ;----------------------------------------------------------- 0E81 68 L0E81 PLA 0E82 68 PLA 0E83 68 PLA 0E84 68 PLA ;-----------------------------------------------------------; RESTORE POINTERS AND DO NEXT TOKEN 0E85 A5 7A L0E85 LDA $7A ; restore pointer saved before in 7a/7b to 39/3a 0E87 A6 7B LDX $7B 0E89 85 39 STA $39 0E8B 86 3A STX $3A 0E8D 24 11 BIT $11 ; check bit 6 and 7 in GET/INPUT/READ switch 0E8F 50 1F BVC L0EB0 ; if value was $40 (GET) then V would be set, if V is clear it was INPUT or READ, jump to do next TOKEN 0E91 A5 91 L0E91 LDA $91 ; this was GET, is STOP KEY pressed ($91 flag, 7F = pressed, FF = not pressed) 0E93 C9 7F CMP #$7F ; STOP KEY PRESSED? 0E95 D0 19 BNE L0EB0 ; NO, go down to increase pointer and do next token 0E97 20 B7 AB JSR $ABB7 ; YES,close input and output channels ;-----------------------------------------------------------; BR_TERMINATE_PROGRAM 0E9A 38 SEC ; SET carry 0E9B B0 04 BCS L0EA1 ; JUMP DOWN 0E9D 20 44 A6 L0E9D JSR $A644 ; perform NEW 0EA0 18 CLC ; BR_SOFT_END 0EA1 20 41 A8 L0EA1 JSR $A841 ; perform part of basic statement END 0EA4 20 B7 AB JSR $ABB7 ; close input and output channels ;-----------------------------------------------------------; CONTINUE 0EA7 68 L0EA7 PLA 0EA8 68 PLA 0EA9 20 68 A8 JSR $A868 ; continue from break line (transfer 3b/3c to 39/3a) ;----------------------------------------------------------- 0EAC 24 11 L0EAC BIT $11 ; check bit 6 and 7 in GET/INPUT/READ switch 0EAE 70 E1 BVS L0E91 ; is GET set ? Then go up again, as long as stop key is pressed, basically wait until the key is released ;-------------------------------------------------- INCREASE POINTER AND DO NEXT TOKEN 0EB0 A0 00 L0EB0 LDY #$00 ; reset current y index for pointer 0EB2 84 3B STY $3B 0EB4 E6 39 INC $39 ; increase pointer 0EB6 D0 17 BNE L0ECF ; Get token from token pointer, indexed by Y and do it 0EB8 E6 3A INC $3A 0EBA D0 13 BNE L0ECF ; Get token from token pointer, indexed by Y and do it 0EBC A0 00 L0EBC LDY #$00 ; reset Y index, add Accumulator to token pointer and do next token ;------------------------------------------------- 0EBE 18 L0EBE CLC 0EBF 65 39 L0EBF ADC $39 0EC1 85 39 STA $39 0EC3 90 0A BCC L0ECF ; Get token from token pointer, indexed by Y and do it 0EC5 E6 3A L0EC5 INC $3A 0EC7 D0 06 BNE L0ECF ; Get token from token pointer, indexed by Y and do it 0EC9 A0 00 L0EC9 LDY #$00 ; GET AND DO NEXT TOKEN RESETTING Y to 0 ;-------------------------------------------------- 0ECB E6 39 L0ECB INC $39 ; increase pointer and get next token (Y not reset first) 0ECD F0 F6 BEQ L0EC5 ;---------------------------------------------------; Get token from token pointer, indexed by Y and do it 0ECF B1 39 L0ECF LDA ($39),Y ; get p-code from location shown by current basic line number 0ED1 10 9C BPL L0E6F ; below 128 (80?), move up 0ED3 C9 C0 CMP #$C0 ; opcide 80-ff 0ED5 90 77 BCC L0F4E ; between 80 and bf? (less than c0) , jump 0ED7 C9 E0 CMP #$E0 0ED9 B0 5B BCS L0F36 ; higher than or equal to e0? jump 0EDB AA TAX ; between c0-df, set x to that -- 32 pre-assigned variables to use for speed 0EDC BC 2B 08 LDY $082B,X ; get Y index from the table 0EDF B1 2D LDA ($2D),Y ; Pointer to beginning of variable area (2d/2e)+y 0EE1 10 0B BPL L0EEE 0EE3 C8 INY 0EE4 A5 0E LDA $0E 0EE6 30 30 BMI L0F18 0EE8 20 42 14 JSR L1442 ; transform the floating-point value in FAC1 into a 16-bit integer stored in $64/$65 and update the type flag in $0E. 0EEB 4C 18 0F JMP L0F18 0EEE C8 L0EEE INY 0EEF B1 2D LDA ($2D),Y 0EF1 30 36 BMI L0F29 0EF3 A5 0E LDA $0E 0EF5 10 07 BPL L0EFE 0EF7 84 22 STY $22 0EF9 20 FF 13 JSR L13FF ; Integer to Floating-Point conversion 0EFC A4 22 LDY $22 0EFE C8 L0EFE INY 0EFF 24 70 BIT $70 0F01 10 03 BPL L0F06 0F03 20 1B BC JSR $BC1B ; round FAC1 0F06 A5 61 L0F06 LDA $61 0F08 91 2D STA ($2D),Y 0F0A C8 INY 0F0B A5 66 LDA $66 0F0D 09 7F ORA #$7F 0F0F 25 62 AND $62 0F11 91 2D STA ($2D),Y 0F13 C8 INY 0F14 A5 63 LDA $63 0F16 91 2D STA ($2D),Y 0F18 C8 L0F18 INY 0F19 A5 64 LDA $64 0F1B 91 2D STA ($2D),Y 0F1D C8 INY 0F1E A5 65 LDA $65 0F20 91 2D STA ($2D),Y 0F22 A0 00 LDY #$00 0F24 84 3B STY $3B 0F26 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 0F29 98 L0F29 TYA 0F2A 38 SEC 0F2B 65 2D ADC $2D 0F2D 85 49 STA $49 0F2F A5 2E LDA $2E 0F31 69 00 ADC #$00 0F33 4C 61 13 JMP L1361 ; BR_ASSIGN_STRING and next token ;------------------------------------------------ OPCODE E0-FF selection 0F36 C9 E6 L0F36 CMP #$E6 0F38 B0 14 BCS L0F4E ; Register is greater than or equal to data , IS A >= E6, then jump 0F3A 85 3B STA $3B ; store opcode at 3b 0F3C E6 39 INC $39 ; increase pointer 0F3E F0 0A BEQ L0F4A ; check hi pointer increase 0F40 C9 E4 L0F40 CMP #$E4 ; 0F42 90 03 BCC L0F47 ; Register is less than data, A= A0, then jump 0FD6 AA TAX ; here token 80-9f 0FD7 BC 6B 08 LDY $086B,X 0FDA B1 2D LDA ($2D),Y 0FDC 10 14 BPL L0FF2 0FDE 85 0E STA $0E 0FE0 C8 INY 0FE1 C8 INY 0FE2 B1 2D LDA ($2D),Y 0FE4 85 64 STA $64 0FE6 C8 INY 0FE7 B1 2D LDA ($2D),Y 0FE9 85 65 STA $65 0FEB A0 00 LDY #$00 0FED 84 0D STY $0D 0FEF 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 0FF2 C8 L0FF2 INY 0FF3 B1 2D LDA ($2D),Y 0FF5 10 3C BPL L1033 0FF7 85 0D STA $0D 0FF9 98 TYA 0FFA 38 SEC 0FFB 65 2D ADC $2D 0FFD 85 49 STA $49 0FFF 85 64 STA $64 1001 A5 2E LDA $2E 1003 69 00 ADC #$00 1005 85 4A STA $4A 1007 85 65 STA $65 1009 A0 02 LDY #$02 100B B1 49 LDA ($49),Y 100D 85 63 STA $63 100F 88 DEY 1010 84 0E STY $0E 1012 B1 49 LDA ($49),Y 1014 85 62 STA $62 1016 88 DEY 1017 B1 49 LDA ($49),Y 1019 85 61 STA $61 101B 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------- ; A0-FF 101E C9 A6 L101E CMP #$A6 ; compare opcode A6 1020 B0 7D BCS L109F ; Register is greater than or equal to data , IS A >= A6, then jump 1022 E6 39 INC $39 ; A0-A5 1024 F0 09 BEQ L102F 1026 A0 00 L1026 LDY #$00 1028 C9 A4 CMP #$A4 ; less than A4? 102A 90 39 BCC L1065 ; A0-A3, so go to 1065 102C 4C 9F 11 JMP L119F ; A4, A5 goto 119f 102F E6 3A L102F INC $3A ; increase hi byte 1031 D0 F3 BNE L1026 ; theoretically this may turn 0, but in reality won't ;------------------------------------------------- 1033 C8 L1033 INY ; hi byte flipped, do this 1034 B1 2D LDA ($2D),Y 1036 85 61 STA $61 1038 C8 INY 1039 B1 2D LDA ($2D),Y 103B 85 66 STA $66 103D 09 80 ORA #$80 103F 85 62 STA $62 1041 C8 INY 1042 B1 2D LDA ($2D),Y 1044 85 63 STA $63 1046 C8 INY 1047 B1 2D LDA ($2D),Y 1049 85 64 STA $64 104B C8 INY 104C B1 2D LDA ($2D),Y 104E 85 65 STA $65 1050 A0 00 LDY #$00 1052 84 0E STY $0E 1054 84 0D STY $0D 1056 84 70 STY $70 1058 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;--------------------------------------------------------- 105B B1 39 L105B LDA ($39),Y 105D E6 39 INC $39 105F D0 0A BNE L106B 1061 E6 3A INC $3A 1063 D0 06 BNE L106B ;--------------------------------------------------------; A0-A3 1065 29 03 L1065 AND #$03 1067 C9 03 CMP #$03 1069 F0 F0 BEQ L105B 106B 85 48 L106B STA $48 106D 85 60 STA $60 106F B1 39 LDA ($39),Y ; get lo byte of variable index 1071 85 47 STA $47 1073 0A ASL A ; multiply by 7 (times 8, then minus 1) 1074 26 60 ROL $60 1076 0A ASL A 1077 26 60 ROL $60 1079 0A ASL A 107A 26 60 ROL $60 107C 38 SEC 107D E5 47 SBC $47 107F A8 TAY 1080 A5 60 LDA $60 1082 E5 48 SBC $48 1084 AA TAX 1085 98 TYA 1086 18 CLC 1087 65 2D ADC $2D 1089 85 5F STA $5F 108B 8A TXA 108C 65 2E ADC $2E 108E 85 60 STA $60 1090 A5 5F LDA $5F ; skip var ID 1092 69 02 ADC #$02 1094 85 49 STA $49 1096 A5 60 LDA $60 1098 69 00 ADC #$00 109A 85 4A STA $4A 109C 4C 08 13 JMP L1308 ; BR_VAR_DISPATCH ;---------------------------------------------------; A6-FF 109F C9 E7 L109F CMP #$E7 ; compare opcode E7 10A1 B0 6F BCS L1112 ; Register is greater than or equal to data , IS A >= E7, then jump 10A3 C9 B0 CMP #$B0 10A5 90 0F BCC L10B6 ; if acc is less than $b0, go to 10b6 (so a6-af) 10A7 85 0E STA $0E ; here b0-bf 10A9 29 0F AND #$0F ;----------------------------------------------------- 10AB 85 65 L10AB STA $65 ; Store value at FAC, arithmetic register #1 (5 bytes). 61-65 10AD A0 00 LDY #$00 ; set 64 to 0 , 10AF 84 64 STY $64 10B1 84 0D STY $0D ; Current expression type. Values: $00: Numerical. $FF: String. 10B3 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;----------------------------------------------- ; A6-AF 10B6 A2 00 L10B6 LDX #$00 10B8 C9 AA CMP #$AA ; compare opcode with AA 10BA B0 7D BCS L1139 ; if equal to or greater, jump to 1139 - AA-AF 10BC A0 01 LDY #$01 ; A6-A9 10BE 85 0E STA $0E 10C0 C9 A7 CMP #$A7 ; compare opcode with a7 10C2 90 06 BCC L10CA ; jump if opcode is less than a7 10C4 D0 13 BNE L10D9 ; must be a8 or A9 , as zero flag would mean it was A7 ;------------------------------------------------- 10C6 B1 39 LDA ($39),Y ; TOKEN A7 10C8 AA TAX 10C9 C8 INY ;------------------------------------------------ ; TOKEN A6 10CA B1 39 L10CA LDA ($39),Y ; 10CC 85 65 STA $65 10CE 86 64 STX $64 10D0 C8 INY 10D1 98 TYA 10D2 A0 00 LDY #$00 10D4 84 0D STY $0D 10D6 4C BE 0E JMP L0EBE ; ;-------------------------------------------------- ; opcode a8 : set FAC from memory 10D9 B1 39 L10D9 LDA ($39),Y 10DB 85 61 STA $61 10DD C8 INY 10DE B1 39 LDA ($39),Y 10E0 85 66 STA $66 10E2 09 80 ORA #$80 10E4 85 62 STA $62 10E6 C8 INY 10E7 B1 39 LDA ($39),Y 10E9 85 63 STA $63 10EB C8 INY 10EC B1 39 LDA ($39),Y 10EE 85 64 STA $64 10F0 C8 INY 10F1 B1 39 LDA ($39),Y 10F3 85 65 STA $65 10F5 A0 00 LDY #$00 10F7 84 0D STY $0D 10F9 84 0E STY $0E 10FB A9 06 LDA #$06 10FD 4C BE 0E JMP L0EBE ;---------------------------------------------------- opcodes F0-FF 1100 85 0E L1100 STA $0E ; store opcode there Current numerical expression type. Bits: Bit #7: 0 = Floating point; 1 = Integer. 1102 29 1F AND #$1F ; isolate bits (e.g. fa --> 1a) 1104 10 A5 BPL L10AB ; if positive , jump 1106 A0 01 L1106 LDY #$01 1108 B1 39 LDA ($39),Y 110A E6 39 INC $39 110C D0 0E BNE L111C 110E E6 3A INC $3A 1110 D0 0A BNE L111C ;------------------------------------------------- 1112 F0 F2 L1112 BEQ L1106 ; was opcode zero? then jump 1114 C9 F0 CMP #$F0 ; compare opcode f0 1116 B0 E8 BCS L1100 ; Register is greater than or equal to data , IS A >= F0, then jump 1118 29 07 AND #$07 ; E7-EF (E7 as well, but not used) 111A A0 01 LDY #$01 111C 85 61 L111C STA $61 111E 84 0E STY $0E 1120 A5 39 LDA $39 1122 AA TAX 1123 18 CLC 1124 65 61 ADC $61 1126 85 39 STA $39 1128 A4 3A LDY $3A 112A 90 02 BCC L112E 112C E6 3A INC $3A 112E E8 L112E INX 112F D0 01 BNE L1132 1131 C8 INY 1132 86 62 L1132 STX $62 1134 84 63 STY $63 1136 4C 0C 18 JMP L180C ; PUSH_STRING_STACK (String Stack Manager) and next token ;------------------------------------------------- ; token AA-AF 1139 86 0D L1139 STX $0D 113B F0 2D BEQ L116A 113D C9 AC CMP #$AC 113F 90 1B BCC L115C 1141 D0 08 BNE L114B 1143 86 0E STX $0E 1145 20 7B AF JSR $AF7B ; read real time clock into FAC1 mantissa, 0HML (TI) 1148 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 114B C9 AF L114B CMP #$AF 114D 90 0A BCC L1159 114F 20 48 AF JSR $AF48 ; read real time clock into FAC1 mantissa, 0HML (TI$) 1152 A0 01 LDY #$01 1154 84 0E STY $0E 1156 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 1159 4C 08 AF L1159 JMP $AF08 ; DO SYNTAX ERROR 115C 85 0E L115C STA $0E 115E A5 90 LDA $90 1160 10 01 BPL L1163 1162 CA DEX 1163 86 64 L1163 STX $64 1165 85 65 STA $65 1167 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 116A 86 0E L116A STX $0E 116C A9 A8 LDA #$A8 ; ADDRESS OF PI CONSTANT AEA8 116E A0 AE LDY #$AE 1170 20 A2 BB JSR $BBA2 ; unpack memory (AY) into FAC1 1173 4C C9 0E JMP L0EC9 ;----------------------------------------------- 1176 B1 39 L1176 LDA ($39),Y 1178 18 CLC 1179 65 2F ADC $2F 117B 85 69 STA $69 117D C8 INY 117E B1 39 LDA ($39),Y 1180 65 30 ADC $30 1182 85 6A STA $6A 1184 E6 39 INC $39 1186 D0 02 BNE L118A 1188 E6 3A INC $3A 118A A0 00 L118A LDY #$00 118C B1 69 LDA ($69),Y 118E AA TAX 118F 18 CLC 1190 65 2F ADC $2F 1192 85 5F STA $5F 1194 C8 INY 1195 8A TXA 1196 11 69 ORA ($69),Y 1198 F0 66 BEQ L1200 119A B1 69 LDA ($69),Y 119C 4C B4 11 JMP L11B4 ;------------------------------------------------------------ BR_READ_WRITE_ARRAY 119F D0 D5 L119F BNE L1176 11A1 B1 39 LDA ($39),Y 11A3 A8 TAY 11A4 18 CLC 11A5 B1 2F LDA ($2F),Y 11A7 AA TAX 11A8 65 2F ADC $2F 11AA 85 5F STA $5F 11AC C8 INY 11AD 8A TXA 11AE 11 2F ORA ($2F),Y 11B0 F0 4E BEQ L1200 11B2 B1 2F LDA ($2F),Y 11B4 65 30 L11B4 ADC $30 11B6 85 60 STA $60 11B8 A0 01 LDY #$01 11BA B1 5F LDA ($5F),Y 11BC 85 46 STA $46 11BE 88 DEY 11BF B1 5F LDA ($5F),Y 11C1 85 45 STA $45 11C3 A0 04 LDY #$04 11C5 B1 5F LDA ($5F),Y 11C7 85 0B STA $0B 11C9 0A ASL A 11CA 69 05 ADC #$05 11CC 65 5F ADC $5F 11CE 85 58 STA $58 11D0 A9 00 LDA #$00 11D2 65 60 ADC $60 11D4 85 59 STA $59 11D6 C8 INY 11D7 68 PLA 11D8 30 17 BMI L11F1 11DA 68 PLA 11DB 85 6E STA $6E 11DD 68 PLA 11DE 85 69 STA $69 11E0 68 PLA 11E1 85 6A STA $6A 11E3 68 PLA 11E4 85 6B STA $6B 11E6 68 PLA 11E7 68 PLA 11E8 20 5C 0C JSR L0C5C 11EB A5 6D LDA $6D 11ED 48 PHA 11EE A5 6C LDA $6C 11F0 48 PHA 11F1 68 L11F1 PLA 11F2 85 72 STA $72 11F4 D1 5F CMP ($5F),Y 11F6 90 0B BCC L1203 11F8 D0 06 BNE L1200 11FA C8 INY 11FB 68 PLA 11FC D1 5F CMP ($5F),Y 11FE 90 05 BCC L1205 1200 4C 45 B2 L1200 JMP $B245 ; bad subscript error 1203 C8 L1203 INY 1204 68 PLA 1205 85 71 L1205 STA $71 1207 C6 0B DEC $0B 1209 F0 4E BEQ L1259 120B C8 L120B INY 120C 68 PLA 120D 30 17 BMI L1226 120F 68 PLA 1210 85 6E STA $6E 1212 68 PLA 1213 85 69 STA $69 1215 68 PLA 1216 85 6A STA $6A 1218 68 PLA 1219 85 6B STA $6B 121B 68 PLA 121C 68 PLA 121D 20 5C 0C JSR L0C5C 1220 A5 6D L1220 LDA $6D 1222 48 PHA 1223 A5 6C LDA $6C 1225 48 PHA 1226 68 L1226 PLA 1227 85 6C STA $6C 1229 D1 5F CMP ($5F),Y 122B 90 0B BCC L1238 122D D0 06 BNE L1235 122F C8 INY 1230 68 PLA 1231 D1 5F CMP ($5F),Y 1233 90 05 BCC L123A 1235 4C 45 B2 L1235 JMP $B245 ; bad subscript error 1238 C8 L1238 INY 1239 68 PLA 123A 85 6D L123A STA $6D 123C AA TAX 123D A5 72 LDA $72 123F 05 71 ORA $71 1241 18 CLC 1242 F0 0A BEQ L124E 1244 20 4C B3 JSR $B34C ; compute array size 1247 8A TXA 1248 65 6D ADC $6D 124A AA TAX 124B 98 TYA 124C A4 22 LDY $22 124E 65 6C L124E ADC $6C 1250 86 71 STX $71 1252 85 72 STA $72 1254 C6 0B DEC $0B 1256 D0 B3 BNE L120B 1258 8A TXA 1259 A6 72 L1259 LDX $72 125B 0A ASL A 125C 26 72 ROL $72 125E 24 45 BIT $45 1260 30 46 BMI L12A8 1262 24 46 BIT $46 1264 30 70 BMI L12D6 1266 0A ASL A 1267 26 72 ROL $72 1269 65 71 ADC $71 126B 90 02 BCC L126F 126D E8 INX 126E 18 CLC 126F 65 58 L126F ADC $58 1271 85 49 STA $49 1273 8A TXA 1274 65 72 ADC $72 1276 65 59 ADC $59 1278 85 4A STA $4A 127A 24 3B BIT $3B 127C 50 03 BVC L1281 127E 4C 29 13 JMP L1329 1281 A0 04 L1281 LDY #$04 1283 B1 49 LDA ($49),Y 1285 85 65 STA $65 1287 88 DEY 1288 B1 49 LDA ($49),Y 128A 85 64 STA $64 128C 88 DEY 128D B1 49 LDA ($49),Y 128F 85 63 STA $63 1291 88 DEY 1292 B1 49 LDA ($49),Y 1294 85 66 STA $66 1296 09 80 ORA #$80 1298 85 62 STA $62 129A 88 DEY 129B B1 49 LDA ($49),Y 129D 85 61 STA $61 129F 84 0D STY $0D 12A1 84 0E STY $0E 12A3 84 70 STY $70 12A5 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 12A8 65 58 L12A8 ADC $58 12AA 85 49 STA $49 12AC A5 72 LDA $72 12AE 65 59 ADC $59 12B0 85 4A STA $4A 12B2 A0 00 LDY #$00 12B4 24 3B BIT $3B 12B6 70 13 L12B6 BVS L12CB 12B8 C8 INY 12B9 B1 49 LDA ($49),Y 12BB 85 65 STA $65 12BD 88 DEY 12BE B1 49 LDA ($49),Y 12C0 85 64 STA $64 12C2 A9 80 LDA #$80 12C4 85 0E STA $0E 12C6 84 0D STY $0D 12C8 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 12CB A5 0E L12CB LDA $0E 12CD 30 7D BMI L134C 12CF 20 42 14 L12CF JSR L1442 12D2 A0 00 LDY #$00 12D4 F0 76 BEQ L134C 12D6 65 71 L12D6 ADC $71 12D8 90 02 BCC L12DC 12DA E8 INX 12DB 18 CLC 12DC 65 58 L12DC ADC $58 12DE 85 49 STA $49 12E0 24 3B BIT $3B 12E2 70 78 BVS L135C 12E4 85 64 STA $64 12E6 8A TXA 12E7 65 72 ADC $72 12E9 65 59 ADC $59 12EB 85 4A STA $4A 12ED 85 65 STA $65 12EF A9 FF LDA #$FF 12F1 85 0D STA $0D 12F3 A0 02 L12F3 LDY #$02 12F5 B1 64 LDA ($64),Y 12F7 85 63 STA $63 12F9 88 DEY 12FA 84 0E STY $0E 12FC B1 64 LDA ($64),Y 12FE 85 62 STA $62 1300 88 DEY 1301 B1 64 LDA ($64),Y 1303 85 61 STA $61 1305 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------ 1308 A0 00 L1308 LDY #$00 130A 24 3B BIT $3B 130C B1 5F LDA ($5F),Y 130E 30 A6 BMI L12B6 1310 C8 INY 1311 B1 5F LDA ($5F),Y 1313 10 0F BPL L1324 1315 70 4C BVS L1363 1317 85 0D STA $0D 1319 A6 49 LDX $49 131B A5 4A LDA $4A 131D 86 64 STX $64 131F 85 65 STA $65 1321 4C F3 12 JMP L12F3 1324 70 03 L1324 BVS L1329 1326 4C 81 12 JMP L1281 1329 A5 0E L1329 LDA $0E ;----------------------------------------------------- ; PACK_AND_STORE_FAC 132B 10 03 L132B BPL L1330 132D 20 FF 13 L132D JSR L13FF ; Integer to Floating-Point conversion 1330 A5 70 L1330 LDA $70 1332 10 03 BPL L1337 1334 20 1B BC JSR $BC1B ; round FAC1 1337 A0 00 L1337 LDY #$00 1339 A5 61 LDA $61 133B 91 49 STA ($49),Y 133D C8 INY 133E A5 66 LDA $66 1340 09 7F ORA #$7F 1342 25 62 AND $62 1344 91 49 STA ($49),Y 1346 C8 INY 1347 A5 63 LDA $63 1349 91 49 STA ($49),Y 134B C8 INY ;---------------------------------------------------; BR_STORE_INT_PART 134C A5 64 L134C LDA $64 134E 91 49 STA ($49),Y 1350 C8 INY 1351 A5 65 LDA $65 1353 91 49 STA ($49),Y 1355 A0 00 LDY #$00 1357 84 3B STY $3B 1359 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;---------------------------------------------------- 135C 8A L135C TXA 135D 65 72 ADC $72 135F 65 59 ADC $59 1361 85 4A L1361 STA $4A ; BR_ASSIGN_STRING 1363 A9 19 L1363 LDA #$19 1365 85 16 STA $16 1367 A5 61 LDA $61 1369 F0 48 BEQ L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next 136B A4 63 LDY $63 136D C4 34 CPY $34 136F D0 04 BNE L1375 1371 A4 62 LDY $62 1373 C4 33 CPY $33 1375 90 3C L1375 BCC L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next 1377 A5 65 LDA $65 1379 F0 38 BEQ L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next 137B A4 34 L137B LDY $34 137D A5 33 LDA $33 137F 38 SEC 1380 E5 61 SBC $61 1382 B0 01 BCS L1385 1384 88 DEY 1385 C4 32 L1385 CPY $32 1387 D0 02 BNE L138B 1389 C5 31 CMP $31 138B B0 03 L138B BCS L1390 138D 20 7A 1F JSR L1F7A ; FORCE_GARBAGE_COLLECT_AND_CHECK 1390 85 62 L1390 STA $62 1392 85 33 STA $33 1394 84 63 STY $63 1396 84 34 STY $34 1398 A0 02 LDY #$02 139A B1 64 LDA ($64),Y 139C 85 23 STA $23 139E 88 DEY 139F B1 64 LDA ($64),Y 13A1 85 22 STA $22 13A3 A4 61 LDY $61 13A5 88 DEY 13A6 F0 07 BEQ L13AF 13A8 B1 22 L13A8 LDA ($22),Y 13AA 91 33 STA ($33),Y 13AC 88 DEY 13AD D0 F9 BNE L13A8 13AF B1 22 L13AF LDA ($22),Y 13B1 91 33 STA ($33),Y ;------------------------------------------------- ; BR_STORE_STRING_DESCRIPTOR 13B3 A0 02 L13B3 LDY #$02 13B5 A5 63 LDA $63 13B7 91 49 STA ($49),Y 13B9 88 DEY 13BA A5 62 LDA $62 13BC 91 49 STA ($49),Y 13BE 88 DEY 13BF A5 61 LDA $61 13C1 91 49 STA ($49),Y 13C3 84 3B STY $3B 13C5 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;---------------------------------------------------------; RESTORE_FAC_FROM_STACK_AND_JUMP 13C8 68 L13C8 PLA 13C9 18 CLC 13CA 69 01 ADC #$01 13CC 85 55 STA $55 13CE 68 PLA 13CF 69 00 ADC #$00 13D1 85 56 STA $56 13D3 68 PLA 13D4 85 0E STA $0E 13D6 D0 0E BNE L13E6 13D8 85 70 STA $70 13DA 68 PLA 13DB 85 66 STA $66 13DD 68 PLA 13DE 85 61 STA $61 13E0 68 PLA 13E1 85 62 STA $62 13E3 68 PLA 13E4 85 63 STA $63 13E6 68 L13E6 PLA 13E7 85 64 STA $64 13E9 68 PLA 13EA 85 65 STA $65 13EC 6C 55 00 JMP ($0055) 13EF A2 00 L13EF LDX #$00 13F1 A5 66 LDA $66 13F3 10 01 BPL L13F6 13F5 CA DEX 13F6 86 64 L13F6 STX $64 13F8 86 65 STX $65 13FA A9 80 LDA #$80 13FC 85 0E STA $0E 13FE 60 RTS ;------------------------------------------------------Integer to Floating-Point conversion FAC 13FF A0 00 L13FF LDY #$00 1401 84 0E STY $0E 1403 84 70 STY $70 1405 84 61 STY $61 1407 84 62 STY $62 1409 84 63 STY $63 140B A2 90 LDX #$90 140D A5 64 LDA $64 140F 85 66 STA $66 1411 10 05 BPL L1418 1413 20 C9 0D JSR L0DC9 ; NEGATE 64/65 1416 A5 64 LDA $64 1418 D0 08 L1418 BNE L1422 141A A2 88 LDX #$88 141C A5 65 LDA $65 141E F0 16 BEQ L1436 1420 84 65 STY $65 1422 30 06 L1422 BMI L142A 1424 CA L1424 DEX 1425 06 65 ASL $65 1427 2A ROL A 1428 10 FA BPL L1424 142A 85 62 L142A STA $62 142C A5 65 LDA $65 142E 85 63 STA $63 1430 86 61 STX $61 1432 84 64 STY $64 1434 84 65 STY $65 1436 60 L1436 RTS ;------------------------------------------------- ; FAC_TYPE_CONVERT 1437 A5 0E L1437 LDA $0E 1439 29 80 AND #$80 143B C5 0C CMP $0C 143D F0 F7 BEQ L1436 143F AA TAX 1440 30 BD BMI L13FF ; Integer to Floating-Point conversion FAC ;------------------------------------------------------------ transform the floating-point value in FAC1 into a 16-bit integer stored in $64/$65 and update the type flag in $0E. 1442 24 70 L1442 BIT $70 1444 10 03 BPL L1449 1446 20 1B BC JSR $BC1B ; round FAC1 1449 A5 61 L1449 LDA $61 144B C9 81 CMP #$81 144D 90 A0 BCC L13EF 144F E9 90 SBC #$90 1451 10 45 BPL L1498 1453 A6 66 LDX $66 1455 30 28 BMI L147F 1457 C9 F9 CMP #$F9 1459 B0 10 BCS L146B 145B 69 07 ADC #$07 145D AA TAX 145E A5 62 LDA $62 1460 E8 INX 1461 F0 04 BEQ L1467 1463 4A L1463 LSR A 1464 E8 INX 1465 D0 FC BNE L1463 1467 86 64 L1467 STX $64 1469 F0 0D BEQ L1478 146B AA L146B TAX 146C A5 62 LDA $62 146E 4A L146E LSR A 146F 66 63 ROR $63 1471 E8 INX 1472 D0 FA BNE L146E 1474 85 64 L1474 STA $64 1476 A5 63 LDA $63 1478 85 65 L1478 STA $65 147A A9 80 LDA #$80 147C 85 0E STA $0E 147E 60 RTS ;--------------------------------------- 147F AA L147F TAX 1480 20 4D B9 JSR $B94D ; 2'S COMPLEMENT OF FAC MANTISSA ONLY 1483 A5 62 LDA $62 1485 38 L1485 SEC 1486 6A ROR A 1487 66 63 ROR $63 1489 E8 INX 148A D0 F9 BNE L1485 148C F0 E6 BEQ L1474 ;---------------------------------------------------; STORE (JUMP) ADDRESS IN FAC IN 14/15 148E A5 0E L148E LDA $0E ; Current numerical expression type. but here the FA value (opcode) integer if bit 7 is set, else floating 1490 10 09 BPL L149B ; if bit 7 = 0 , floating, jump to CONVERT to INTEGER 1492 A6 65 LDX $65 ; get hi byte (A), lo byte (X) from least significant FAC bytes location 1494 A5 64 LDA $64 1496 10 2B BPL L14C3 ; if $64 was between 0-7f jump down, else give error. So this pointer may only be in 0000-7fff range (the rest is reserved) 1498 4C 48 B2 L1498 JMP $B248 ; do illegal quantity error if not passing here 149B A5 66 L149B LDA $66 ; CONVERT FLOAT TO INTEGER 149D 30 F9 BMI L1498 149F 24 70 BIT $70 14A1 10 03 BPL L14A6 14A3 20 1B BC JSR $BC1B ; JSR ROUND ;ROUND INTEGER. 14A6 A5 61 L14A6 LDA $61 14A8 C9 81 CMP #$81 14AA B0 05 BCS L14B1 14AC A9 00 LDA #$00 ; set x, a to 0 and set 14/15 to 0 and leave 14AE AA TAX 14AF F0 12 BEQ L14C3 14B1 E9 91 L14B1 SBC #$91 14B3 10 E3 BPL L1498 14B5 AA TAX 14B6 A5 62 LDA $62 14B8 E8 INX 14B9 F0 06 BEQ L14C1 14BB 4A L14BB LSR A 14BC 66 63 ROR $63 14BE E8 INX 14BF D0 FA BNE L14BB 14C1 A6 63 L14C1 LDX $63 ;---------------------------------------------------; store pointer 14C3 85 15 L14C3 STA $15 ; store in 14/15, the SYS jump address 14C5 86 14 STX $14 14C7 60 RTS ;----------------------------------------------- 14C8 A5 0E L14C8 LDA $0E ; Numeric flag (integer or floating point) 14CA 10 07 BPL L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 14CC A6 65 LDX $65 14CE A5 64 LDA $64 14D0 D0 C6 BNE L1498 14D2 60 RTS ;-------------------------------------------------- ; FINDFREE Find Free Space for FRE/String manipulation 14D3 24 70 L14D3 BIT $70 14D5 10 03 BPL L14DA 14D7 20 1B BC JSR $BC1B ; round FAC1 14DA A5 66 L14DA LDA $66 14DC 30 BA BMI L1498 14DE A5 61 LDA $61 14E0 C9 81 CMP #$81 14E2 90 16 BCC L14FA 14E4 E9 89 SBC #$89 14E6 10 B0 BPL L1498 14E8 AA TAX 14E9 A5 62 LDA $62 14EB E8 INX 14EC F0 04 BEQ L14F2 14EE 4A L14EE LSR A 14EF E8 INX 14F0 D0 FC BNE L14EE 14F2 AA L14F2 TAX 14F3 86 65 L14F3 STX $65 14F5 A9 00 LDA #$00 14F7 85 64 STA $64 14F9 60 RTS ;-------------------------------------------------- 14FA A2 00 L14FA LDX #$00 14FC F0 F5 BEQ L14F3 ;------------------------------------------------- ; ASC FUNTION 14FE A6 61 LDX $61 ; ASC FUNCTION ENTRY 1500 F0 96 BEQ L1498 1502 A6 65 LDX $65 1504 D0 19 BNE L151F 1506 A5 64 LDA $64 1508 85 16 STA $16 150A A6 63 LDX $63 150C E4 34 CPX $34 150E D0 0F BNE L151F 1510 A5 62 LDA $62 1512 C5 33 CMP $33 1514 D0 09 BNE L151F 1516 18 CLC 1517 65 61 ADC $61 1519 85 33 STA $33 151B 90 02 BCC L151F 151D E6 34 INC $34 151F B1 62 L151F LDA ($62),Y 1521 4C BB 15 JMP L15BB ;--------------------------------------------------- 1524 A5 0E LDA $0E 1526 F0 03 BEQ L152B 1528 20 FF 13 JSR L13FF ; Integer to Fl oating-Point conversion 152B B1 39 L152B LDA ($39),Y ; read token again 152D 0A ASL A ; times 2 (2 bytes per jump address) 152E 69 28 ADC #$28 ; add $28 1530 20 D5 AF JSR $AFD5 ; do function dispatch 1533 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN ;--------------------------------------------------- ABS function 1536 A5 0E LDA $0E 1538 30 05 BMI L153F 153A 85 66 STA $66 153C 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 153F A5 64 L153F LDA $64 1541 10 03 BPL L1546 1543 20 C9 0D JSR L0DC9 ; NEGATE 64/65 1546 4C CB 0E L1546 JMP L0ECB ; increase pointer and get next token (Y not reset first) ;----------------------------------------------------- INT function 1549 A5 0E LDA $0E 154B 30 F9 BMI L1546 154D A5 61 LDA $61 154F C9 90 CMP #$90 1551 90 0D BCC L1560 1553 24 70 BIT $70 1555 10 03 BPL L155A 1557 20 1B BC JSR $BC1B ; round FAC1 155A 20 CC BC L155A JSR $BCCC ; perform INT() 155D 4C C9 0E JMP L0EC9 1560 20 42 14 L1560 JSR L1442 ; transform the floating-point value in FAC1 into a 16-bit integer stored in $64/$65 and update the type flag in $0E. 1563 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------------ SGN function 1566 A5 0E LDA $0E 1568 10 15 BPL L157F 156A A0 FF LDY #$FF 156C A5 64 LDA $64 156E 30 06 BMI L1576 1570 C8 INY 1571 05 65 ORA $65 1573 F0 01 BEQ L1576 1575 C8 INY 1576 98 L1576 TYA 1577 A0 00 L1577 LDY #$00 1579 AA TAX 157A 10 41 BPL L15BD ; store result and leave 157C 88 DEY 157D 30 3E BMI L15BD ; store result and leave 157F 20 2B BC L157F JSR $BC2B ; get FAC1 sign, return A = $FF -ve, A = $01 +ve (SGN) 1582 4C 77 15 JMP L1577 ; continue routine ;---------------------------------------------------- PEEK 1585 20 8E 14 JSR L148E ; STORE (JUMP) ADDRESS IN FAC IN 14/15 1588 B1 14 LDA ($14),Y 158A 85 65 L158A STA $65 ; strore in 65 158C 84 64 STY $64 158E A9 80 LDA #$80 1590 85 0E STA $0E ; 0e to 80 1592 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;--------------------------------------------------------- POS 1595 A5 D3 LDA $D3 ; Current cursor columns 1597 4C 8A 15 JMP L158A ;--------------------------------------------- ; LEN 159A A6 65 LDX $65 159C D0 19 BNE L15B7 159E A5 64 LDA $64 15A0 85 16 STA $16 15A2 A6 63 LDX $63 15A4 E4 34 CPX $34 15A6 D0 0F BNE L15B7 15A8 A5 62 LDA $62 15AA C5 33 CMP $33 15AC D0 09 BNE L15B7 15AE 18 CLC 15AF 65 61 ADC $61 15B1 85 33 STA $33 15B3 90 02 BCC L15B7 15B5 E6 34 INC $34 15B7 A5 61 L15B7 LDA $61 15B9 A0 00 L15B9 LDY #$00 15BB 84 0D L15BB STY $0D ;-------------------------------------------------- 15BD 85 65 L15BD STA $65 15BF 84 64 STY $64 15C1 A9 80 LDA #$80 15C3 85 0E STA $0E 15C5 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN ;--------------------------------------------------- ; VAL function 15C8 A4 62 LDY $62 15CA A6 63 LDX $63 15CC 86 23 STX $23 15CE 84 22 STY $22 15D0 A5 65 LDA $65 15D2 D0 19 BNE L15ED 15D4 A5 64 LDA $64 15D6 85 16 STA $16 15D8 A5 61 LDA $61 15DA F0 DD BEQ L15B9 15DC E4 34 CPX $34 15DE D0 0D BNE L15ED 15E0 C4 33 CPY $33 15E2 D0 09 BNE L15ED 15E4 18 CLC 15E5 65 62 ADC $62 15E7 85 33 STA $33 15E9 90 02 BCC L15ED 15EB E6 34 INC $34 15ED A5 61 L15ED LDA $61 15EF F0 C8 BEQ L15B9 15F1 20 B0 B7 JSR $B7B0 ; "VAL" FUNCTION 15F4 A0 00 LDY #$00 15F6 84 0D STY $0D 15F8 84 0E STY $0E 15FA 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;---------------------------------------------------- ;STR$ FUNCTION 15FD A5 0E LDA $0E 15FF 30 5C BMI L165D 1601 A5 61 LDA $61 1603 D0 04 BNE L1609 1605 85 64 STA $64 1607 F0 4B BEQ L1654 1609 24 70 L1609 BIT $70 160B 10 03 BPL L1610 160D 20 1B BC JSR $BC1B ; round FAC1 1610 A5 64 L1610 LDA $64 1612 05 65 ORA $65 1614 D0 39 BNE L164F 1616 A5 61 LDA $61 1618 C9 81 CMP #$81 161A 90 33 BCC L164F 161C E9 90 SBC #$90 161E 10 2F BPL L164F 1620 C9 F9 CMP #$F9 1622 B0 16 BCS L163A 1624 69 07 ADC #$07 1626 AA TAX 1627 A5 63 LDA $63 1629 D0 24 BNE L164F 162B A5 62 LDA $62 162D E8 INX 162E F0 06 BEQ L1636 1630 4A L1630 LSR A 1631 B0 1C BCS L164F 1633 E8 INX 1634 D0 FA BNE L1630 1636 86 64 L1636 STX $64 1638 F0 1A BEQ L1654 163A AA L163A TAX 163B A5 63 LDA $63 163D 85 28 STA $28 163F A5 62 LDA $62 1641 4A L1641 LSR A 1642 66 28 ROR $28 1644 B0 09 BCS L164F 1646 E8 INX 1647 D0 F8 BNE L1641 1649 85 64 STA $64 164B A5 28 LDA $28 164D 90 05 BCC L1654 164F 20 DD BD L164F JSR $BDDD ;FP: CONVERT INTO BUFFER 1652 D0 0C BNE L1660 1654 85 65 L1654 STA $65 1656 24 66 BIT $66 1658 10 03 BPL L165D 165A 20 C9 0D JSR L0DC9 ; NEGATE 64/65 165D 20 1D 09 L165D JSR L091D ; INT_TO_ASCII_STRING 1660 84 6D L1660 STY $6D 1662 85 51 STA $51 1664 85 6E STA $6E 1666 85 6C STA $6C 1668 A9 6B LDA #$6B 166A 85 50 STA $50 166C 84 0E STY $0E 166E 88 DEY 166F C8 L166F INY 1670 B9 00 01 LDA $0100,Y 1673 D0 FA BNE L166F 1675 84 61 STY $61 1677 4C CB 17 JMP L17CB ;--------------------------------------------- ; CHR$ (CONVERT_FAC_TO_CHR_STR) 167A A5 0E LDA $0E 167C 10 07 BPL L1685 167E A5 64 LDA $64 1680 F0 06 BEQ L1688 1682 4C 48 B2 L1682 JMP $B248 ; do illegal quantity error then warm start 1685 20 D3 14 L1685 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 1688 A9 01 L1688 LDA #$01 168A 85 61 STA $61 168C 85 0E STA $0E 168E A5 33 LDA $33 1690 A4 34 LDY $34 1692 38 SEC 1693 E9 01 SBC #$01 1695 B0 01 BCS L1698 1697 88 DEY 1698 C4 32 L1698 CPY $32 169A D0 02 BNE L169E 169C C5 31 CMP $31 169E B0 03 L169E BCS L16A3 16A0 20 7A 1F JSR L1F7A ; FORCE_GARBAGE_COLLECT_AND_CHECK 16A3 85 33 L16A3 STA $33 16A5 84 34 STY $34 16A7 85 62 STA $62 16A9 84 63 STY $63 16AB A0 00 LDY #$00 16AD A5 65 LDA $65 16AF 91 62 STA ($62),Y 16B1 4C 0C 18 JMP L180C ; PUSH_STRING_STACK (String Stack Manager) and next token ;--------------------------------------------------------- BR_OPEN_INPUT 16B4 A5 0E LDA $0E 16B6 10 08 BPL L16C0 16B8 A6 65 LDX $65 16BA A5 64 LDA $64 16BC F0 05 BEQ L16C3 16BE D0 C2 BNE L1682 16C0 20 D3 14 L16C0 JSR L14D3 16C3 86 13 L16C3 STX $13 16C5 20 C6 FF JSR $FFC6 ; open channel for input 16C8 84 3B STY $3B 16CA 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------------ ; BR_GET_STATEMENT 16CD 84 13 STY $13 16CF 20 E4 FF JSR $FFE4 ; get character from input device 16D2 48 PHA 16D3 20 CC FF JSR $FFCC ; close input and output channels 16D6 A4 0D LDY $0D 16D8 30 1A BMI L16F4 16DA 68 PLA 16DB C9 30 CMP #$30 16DD 90 04 BCC L16E3 16DF C9 3A CMP #$3A 16E1 90 01 BCC L16E4 16E3 98 L16E3 TYA 16E4 29 0F L16E4 AND #$0F 16E6 85 65 STA $65 16E8 84 64 STY $64 16EA 24 0E BIT $0E 16EC 30 03 BMI L16F1 16EE 4C 2D 13 JMP L132D ; PACK_AND_STORE_FAC , then RTS 16F1 4C 4C 13 L16F1 JMP L134C ; BR_STORE_INT_PART, then rts 16F4 68 L16F4 PLA 16F5 F0 16 BEQ L170D 16F7 A4 61 LDY $61 16F9 88 DEY 16FA D0 19 BNE L1715 16FC A6 63 LDX $63 16FE E4 34 CPX $34 1700 D0 04 BNE L1706 1702 A6 62 LDX $62 1704 E4 33 CPX $33 1706 90 0D L1706 BCC L1715 1708 91 62 STA ($62),Y 170A 4C AC 0E L170A JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;------------------------------------------------------ 170D A6 61 L170D LDX $61 170F F0 F9 BEQ L170A 1711 85 61 STA $61 1713 D0 29 BNE L173E 1715 85 69 L1715 STA $69 1717 A9 01 LDA #$01 1719 85 61 STA $61 171B A5 33 LDA $33 171D A4 34 LDY $34 171F 38 SEC 1720 E9 01 SBC #$01 1722 B0 01 BCS L1725 1724 88 DEY 1725 C4 32 L1725 CPY $32 1727 D0 02 BNE L172B 1729 C5 31 CMP $31 172B B0 03 L172B BCS L1730 172D 20 7A 1F JSR L1F7A ; FORCE_GARBAGE_COLLECT_AND_CHECK 1730 85 33 L1730 STA $33 1732 84 34 STY $34 1734 85 62 STA $62 1736 84 63 STY $63 1738 A5 69 LDA $69 173A A0 00 LDY #$00 173C 91 62 STA ($62),Y 173E 4C B3 13 L173E JMP L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next ;---------------------------------------------------------- MID$ 1741 A5 0E LDA $0E 1743 30 03 BMI L1748 1745 20 D3 14 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 1748 A5 64 L1748 LDA $64 174A D0 32 BNE L177E 174C 68 PLA 174D 10 09 BPL L1758 174F 68 PLA 1750 D0 2C BNE L177E 1752 68 PLA 1753 AA TAX 1754 D0 2E BNE L1784 1756 F0 26 BEQ L177E 1758 68 L1758 PLA 1759 30 23 BMI L177E 175B 68 PLA 175C 38 SEC 175D E9 89 SBC #$89 175F 10 1D BPL L177E 1761 A8 TAY 1762 68 PLA 1763 AA TAX 1764 68 PLA 1765 68 PLA 1766 68 PLA 1767 8A TXA 1768 C8 INY 1769 F0 19 BEQ L1784 176B 4A L176B LSR A 176C C8 INY 176D D0 FC BNE L176B 176F AA TAX 1770 D0 12 BNE L1784 1772 F0 0A BEQ L177E ;--------------------------------------------------- LEFT$/RIGHT$ 1774 A5 0E LDA $0E 1776 10 09 BPL L1781 1778 A6 65 LDX $65 177A A5 64 LDA $64 177C F0 06 BEQ L1784 177E 4C 48 B2 L177E JMP $B248 ; do illegal quantity error then warm start 1781 20 D3 14 L1781 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 1784 68 L1784 PLA 1785 85 0E STA $0E 1787 68 PLA 1788 85 50 STA $50 178A 68 PLA 178B 85 51 STA $51 178D D0 04 BNE L1793 178F A5 50 LDA $50 1791 85 16 STA $16 1793 B1 50 L1793 LDA ($50),Y 1795 85 69 STA $69 1797 B1 39 LDA ($39),Y 1799 C9 35 CMP #$35 179B 90 23 BCC L17C0 179D F0 16 BEQ L17B5 179F CA DEX 17A0 8A TXA 17A1 85 6E STA $6E 17A3 A2 00 LDX #$00 17A5 18 CLC 17A6 E5 69 SBC $69 17A8 B0 1F BCS L17C9 17AA 49 FF EOR #$FF 17AC AA TAX 17AD E4 65 CPX $65 17AF 90 18 BCC L17C9 17B1 A6 65 LDX $65 17B3 B0 14 BCS L17C9 17B5 8A L17B5 TXA 17B6 18 CLC 17B7 E5 69 SBC $69 17B9 49 FF EOR #$FF 17BB 90 0A BCC L17C7 17BD 98 TYA 17BE B0 05 BCS L17C5 17C0 98 L17C0 TYA 17C1 E4 69 CPX $69 17C3 90 02 BCC L17C7 17C5 A6 69 L17C5 LDX $69 17C7 85 6E L17C7 STA $6E 17C9 86 61 L17C9 STX $61 17CB A5 61 L17CB LDA $61 17CD F0 3D BEQ L180C ; PUSH_STRING_STACK (String Stack Manager) and next token 17CF A5 33 LDA $33 17D1 A4 34 LDY $34 17D3 38 SEC 17D4 E5 61 SBC $61 17D6 B0 01 BCS L17D9 17D8 88 DEY 17D9 C4 32 L17D9 CPY $32 17DB D0 02 BNE L17DF 17DD C5 31 CMP $31 17DF B0 03 L17DF BCS L17E4 17E1 20 7A 1F JSR L1F7A ; FORCE_GARBAGE_COLLECT_AND_CHECK 17E4 85 62 L17E4 STA $62 17E6 85 33 STA $33 17E8 84 63 STY $63 17EA 84 34 STY $34 17EC A0 01 LDY #$01 17EE B1 50 LDA ($50),Y 17F0 18 CLC 17F1 65 6E ADC $6E 17F3 85 22 STA $22 17F5 C8 INY 17F6 B1 50 LDA ($50),Y 17F8 69 00 ADC #$00 17FA 85 23 STA $23 17FC A4 61 LDY $61 17FE 88 DEY 17FF F0 07 BEQ L1808 1801 B1 22 L1801 LDA ($22),Y 1803 91 62 STA ($62),Y 1805 88 DEY 1806 D0 F9 BNE L1801 1808 B1 22 L1808 LDA ($22),Y 180A 91 62 STA ($62),Y ;---------------------------------------------------; PUSH_STRING_STACK (String Stack Manager) 180C A6 16 L180C LDX $16 ; Pointer to next expression in string stack 180E E0 1F CPX #$1F 1810 B0 1D BCS L182F 1812 A5 61 LDA $61 1814 95 00 STA $00,X 1816 A5 62 LDA $62 1818 95 01 STA $01,X 181A A5 63 LDA $63 181C 95 02 STA $02,X 181E A0 FF LDY #$FF 1820 84 0D STY $0D 1822 C8 INY 1823 86 64 STX $64 1825 84 65 STY $65 1827 8A TXA 1828 69 03 ADC #$03 182A 85 16 STA $16 182C 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 182F 4C D0 B4 L182F JMP $B4D0 ; error $19, string too complex error ;------------------------------------------------- ; EXECUTE_POKE_COMMAND 1832 86 3C STX $3C 1834 20 8E 14 JSR L148E ; STORE (JUMP?) ADDRESS IN FAC IN 14/15 1837 20 0C 1F JSR L1F0C ; EXECUTE_OPEN_COMMAND 183A A5 3C LDA $3C 183C C9 4C CMP #$4C 183E 90 10 BCC L1850 1840 86 49 STX $49 1842 D0 04 BNE L1848 1844 A2 00 LDX #$00 1846 F0 03 BEQ L184B 1848 20 0C 1F L1848 JSR L1F0C ; EXECUTE_OPEN_COMMAND 184B 20 3C B8 L184B JSR $B83C ; 184E D0 03 BNE L1853 1850 8A L1850 TXA 1851 91 14 STA ($14),Y 1853 4C AC 0E L1853 JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;----------------------------------------------------- ; SYS OPCODE 18 - REQUIRES TARGET ADDRESS IN FAC 1856 A5 39 LDA $39 ; save current pointer + 1 (carry) in 7a/7b 1858 69 00 ADC #$00 185A 85 7A STA $7A 185C A5 3A LDA $3A 185E 69 00 ADC #$00 1860 85 7B STA $7B 1862 20 8E 14 JSR L148E ; STORE (JUMP) ADDRESS IN FAC IN 14/15 1865 20 30 E1 JSR $E130 ; perform SYS from 14/15 1868 4C 85 0E JMP L0E85 ; RESTORE POINTERS AND DO NEXT TOKEN ;------------------------------------------------- ; BR_INPUT_DATA_PROCESSOR 186B 86 3C STX $3C 186D B1 41 LDA ($41),Y 186F 10 05 BPL L1876 1871 A2 2A LDX #$2A ; ?BUG ? error code 2a does not exist, points to $41 $44 "AD" in "READY" 1873 4C 37 A4 JMP $A437 ; do error #X then warm star 1876 AA L1876 TAX 1877 A5 41 LDA $41 1879 69 00 ADC #$00 187B 85 62 STA $62 187D 85 22 STA $22 187F A5 42 LDA $42 1881 69 00 ADC #$00 1883 85 63 STA $63 1885 85 23 STA $23 1887 38 SEC 1888 8A TXA 1889 65 41 ADC $41 188B 85 41 STA $41 188D 90 02 BCC L1891 188F E6 42 INC $42 1891 86 61 L1891 STX $61 1893 46 3C LSR $3C 1895 B0 03 BCS L189A 1897 4C B3 13 JMP L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next 189A 8A L189A TXA 189B 20 B0 B7 JSR $B7B0 ; "VAL" FUNCTION 189E 24 0E L189E BIT $0E 18A0 30 03 BMI L18A5 18A2 4C 30 13 JMP L1330 18A5 4C CF 12 L18A5 JMP L12CF 18A8 A6 65 L18A8 LDX $65 18AA D0 1D BNE L18C9 18AC A9 19 LDA #$19 18AE 85 16 STA $16 18B0 A6 61 LDX $61 18B2 F0 23 BEQ L18D7 18B4 A5 63 LDA $63 18B6 C5 34 CMP $34 18B8 D0 0F BNE L18C9 18BA A5 62 LDA $62 18BC C5 33 CMP $33 18BE D0 09 BNE L18C9 18C0 18 CLC 18C1 65 61 ADC $61 18C3 85 33 STA $33 18C5 90 02 BCC L18C9 18C7 E6 34 INC $34 18C9 C4 61 L18C9 CPY $61 18CB F0 0A BEQ L18D7 18CD B1 62 L18CD LDA ($62),Y 18CF 20 D2 FF JSR $FFD2 ; output character to channel 18D2 C8 INY 18D3 C4 61 CPY $61 18D5 D0 F6 BNE L18CD 18D7 4C 56 19 L18D7 JMP L1956 ;---------------------------------------------------------; PRINT_NUMERIC_EXPR 18DA A5 0E LDA $0E ; PRINT_NUMERIC_EXPR 18DC 30 5D BMI L193B 18DE D0 C8 BNE L18A8 18E0 A5 61 LDA $61 18E2 D0 04 BNE L18E8 18E4 85 64 STA $64 18E6 F0 4A BEQ L1932 18E8 24 70 L18E8 BIT $70 18EA 10 03 BPL L18EF 18EC 20 1B BC JSR $BC1B ; round FAC1 18EF A5 64 L18EF LDA $64 18F1 05 65 ORA $65 18F3 D0 38 BNE L192D 18F5 A5 61 LDA $61 18F7 10 34 BPL L192D 18F9 38 SEC 18FA E9 90 SBC #$90 18FC 10 2F BPL L192D 18FE C9 F9 CMP #$F9 1900 B0 16 BCS L1918 1902 69 07 ADC #$07 1904 AA TAX 1905 A5 63 LDA $63 1907 D0 24 BNE L192D 1909 A5 62 LDA $62 190B E8 INX 190C F0 06 BEQ L1914 190E 4A L190E LSR A 190F B0 1C BCS L192D 1911 E8 INX 1912 D0 FA BNE L190E 1914 86 64 L1914 STX $64 1916 F0 1A BEQ L1932 1918 AA L1918 TAX 1919 A5 63 LDA $63 191B 85 28 STA $28 191D A5 62 LDA $62 191F 4A L191F LSR A 1920 66 28 ROR $28 1922 B0 09 BCS L192D 1924 E8 INX 1925 D0 F8 BNE L191F 1927 85 64 STA $64 1929 A5 28 LDA $28 192B 90 05 BCC L1932 192D 20 DD BD L192D JSR $BDDD ;FP: CONVERT INTO BUFFER 1930 D0 0C BNE L193E 1932 85 65 L1932 STA $65 1934 24 66 BIT $66 1936 10 03 BPL L193B 1938 20 C9 0D JSR L0DC9 ; NEGATE 64/65 193B 20 1D 09 L193B JSR L091D ; INT_TO_ASCII_STRING 193E A2 00 L193E LDX #$00 1940 BD 00 01 L1940 LDA $0100,X 1943 F0 06 BEQ L194B 1945 20 D2 FF JSR $FFD2 ; output character to channel 1948 E8 INX 1949 D0 F5 BNE L1940 194B A9 1D L194B LDA #$1D 194D A6 13 LDX $13 194F F0 02 BEQ L1953 1951 A9 20 LDA #$20 1953 20 D2 FF L1953 JSR $FFD2 ; output character to channel 1956 A0 00 L1956 LDY #$00 1958 B1 39 LDA ($39),Y 195A C9 3D CMP #$3D 195C 90 3A BCC L1998 195E D0 3D BNE L199D ;--------------------------------------------- ; TAB 1960 A5 D3 LDA $D3 1962 38 SEC 1963 E9 0A L1963 SBC #$0A 1965 B0 FC BCS L1963 1967 49 FF EOR #$FF 1969 69 01 ADC #$01 196B 10 17 BPL L1984 ;-------------------------------------------- ; SPC 196D 86 3C STX $3C 196F A5 0E LDA $0E 1971 30 03 BMI L1976 1973 20 D3 14 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 1976 A5 64 L1976 LDA $64 1978 D0 4A BNE L19C4 197A A5 65 LDA $65 197C 46 3C LSR $3C 197E 90 04 BCC L1984 1980 E5 D3 SBC $D3 1982 90 14 BCC L1998 1984 AA L1984 TAX 1985 F0 11 BEQ L1998 1987 A0 1D LDY #$1D 1989 A5 13 LDA $13 198B F0 02 BEQ L198F 198D A0 20 LDY #$20 198F 98 L198F TYA 1990 20 D2 FF JSR $FFD2 ; output character to channel 1993 CA DEX 1994 D0 F9 BNE L198F 1996 A0 00 LDY #$00 1998 84 3B L1998 STY $3B 199A 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;----------------------------------------- ; BR_NEWLINE PRESERVE A in X 199D AA L199D TAX 199E A9 0D LDA #$0D ; BR_NEWLINE 19A0 20 D2 FF JSR $FFD2 ; output character to channel 19A3 A5 13 LDA $13 19A5 10 05 BPL L19AC 19A7 A9 0A LDA #$0A 19A9 20 D2 FF JSR $FFD2 ; output character to channel 19AC E0 43 L19AC CPX #$43 19AE 90 07 BCC L19B7 ;-------------------------------------------------------; 19B0 20 CC FF JSR $FFCC ; BR_CLRCHN_EXIT close input and output channels 19B3 A9 00 LDA #$00 19B5 85 13 STA $13 19B7 4C AC 0E L19B7 JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;------------------------------------------------------ ; BR_OPEN_OUTPUT (CMD, PRINT#) 19BA A5 0E LDA $0E 19BC F0 09 BEQ L19C7 19BE A6 65 LDX $65 19C0 A5 64 LDA $64 19C2 F0 06 BEQ L19CA 19C4 4C 48 B2 L19C4 JMP $B248 ; do illegal quantity error then warm start 19C7 20 D3 14 L19C7 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 19CA 86 13 L19CA STX $13 19CC 20 C9 FF JSR $FFC9 ; open channel for output 19CF B1 39 LDA ($39),Y 19D1 C9 44 CMP #$44 19D3 B0 C8 BCS L199D 19D5 84 3B STY $3B 19D7 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;-------------------------------------------------------BR_EXECUTE_CLOSE_AND_ERROR 19DA A5 0E LDA $0E 19DC 30 03 BMI L19E1 19DE 20 D3 14 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 19E1 A5 64 L19E1 LDA $64 19E3 D0 DF BNE L19C4 19E5 A5 65 LDA $65 19E7 20 C3 FF JSR $FFC3 ; close a specified logical file 19EA B0 03 BCS L19EF 19EC 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on 19EF C9 F0 L19EF CMP #$F0 19F1 D0 07 BNE L19FA 19F3 84 38 STY $38 19F5 86 37 STX $37 19F7 4C 83 0C JMP L0C83 19FA 4C 04 E1 L19FA JMP $E104 ; copy error to X and do error X, then warm start ;------------------------------------------ ; BR_RESTORE_DATA_POINTER 19FD A9 40 LDA #$40 19FF 2C 1a00 A9 80 BIT $80A9 ; BR_SET_DIRECT_MODE_FLAG 1A02 05 11 ORA $11 1A04 D0 07 BNE L1A0D ;------------------------------------------------ BR_CLEAR_SEARCH_FLAG 1A06 A9 BF LDA #$BF 1A08 2C 1A09 A9 7F BIT $7FA9 ; BR_CLEAR_DIRECT_MODE_FLAG 1A0B 25 11 AND $11 1A0D 85 11 L1A0D STA $11 1A0F 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;---------------------------------------------- BR_SET_LINE_POINTER 1A12 A5 39 LDA $39 1A14 85 3D STA $3D 1A16 A5 3A LDA $3A 1A18 85 3E STA $3E 1A1A 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;------------------------------------------------BR_INPUT_START 1A1D 86 3C STX $3C 1A1F A5 13 LDA $13 1A21 F0 27 BEQ L1A4A 1A23 A2 00 L1A23 LDX #$00 1A25 20 CF FF L1A25 JSR $FFCF 1A28 C9 0D CMP #$0D 1A2A F0 0B BEQ L1A37 1A2C 9D 00 02 STA $0200,X 1A2F E8 INX 1A30 E0 59 CPX #$59 1A32 D0 F1 BNE L1A25 1A34 4C 71 A5 JMP $A571 ; do string too long error 1A37 A9 00 L1A37 LDA #$00 1A39 9D 00 02 STA $0200,X 1A3C A8 L1A3C TAY 1A3D A5 90 LDA $90 1A3F 29 03 AND #$03 1A41 D0 11 BNE L1A54 1A43 AD 00 02 LDA $0200 1A46 D0 2E BNE L1A76 1A48 F0 D9 BEQ L1A23 1A4A 20 F9 AB L1A4A JSR $ABF9 ;print "? " and get BASIC inpu 1A4D A0 00 LDY #$00 1A4F AD 00 02 LDA $0200 1A52 D0 22 BNE L1A76 1A54 84 43 L1A54 STY $43 1A56 20 B7 AB JSR $ABB7 ;close input and output channels 1A59 4C AC 0E L1A59 JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;---------------------------------------------------BR_INPUT_BUFFER_PARSER_CONT 1A5C 86 3C STX $3C 1A5E A4 43 LDY $43 1A60 B9 00 02 LDA $0200,Y 1A63 F0 04 BEQ L1A69 1A65 C9 3A CMP #$3A 1A67 D0 0C BNE L1A75 1A69 A5 13 L1A69 LDA $13 1A6B D0 B6 BNE L1A23 1A6D 98 TYA 1A6E F0 E9 BEQ L1A59 1A70 20 45 AB JSR $AB45 1A73 D0 D5 BNE L1A4A 1A75 C8 L1A75 INY 1A76 B9 00 02 L1A76 LDA $0200,Y 1A79 C9 20 CMP #$20 1A7B F0 F8 BEQ L1A75 1A7D 84 7A STY $7A 1A7F A2 02 LDX #$02 1A81 86 7B STX $7B 1A83 24 0D BIT $0D 1A85 30 5F BMI L1AE6 1A87 20 79 00 JSR $0079 1A8A 20 F3 BC JSR $BCF3 ; get FAC1 from string 1A8D A4 7A LDY $7A 1A8F B9 00 02 L1A8F LDA $0200,Y 1A92 F0 16 BEQ L1AAA 1A94 C9 3A CMP #$3A 1A96 F0 12 BEQ L1AAA 1A98 C9 2C CMP #$2C 1A9A F0 0E BEQ L1AAA 1A9C 20 62 AB JSR $AB62 ; Do REDO FROM START (INPUT) 1A9F A5 3D LDA $3D 1AA1 A4 3E LDY $3E 1AA3 85 39 STA $39 1AA5 84 3A STY $3A 1AA7 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on 1AAA 84 43 L1AAA STY $43 1AAC A6 3C LDX $3C 1AAE E0 55 CPX #$55 1AB0 B0 1B BCS L1ACD 1AB2 A6 13 LDX $13 1AB4 F0 07 BEQ L1ABD 1AB6 20 CC FF JSR $FFCC ; close input and output channels 1AB9 A9 00 LDA #$00 1ABB 85 13 STA $13 1ABD AA L1ABD TAX 1ABE F0 0D BEQ L1ACD 1AC0 A0 00 LDY #$00 1AC2 B9 FC AC L1AC2 LDA $ACFC,Y 1AC5 F0 06 BEQ L1ACD 1AC7 20 D2 FF JSR $FFD2 ; output character to channel 1ACA C8 INY 1ACB D0 F5 BNE L1AC2 1ACD 24 0D L1ACD BIT $0D 1ACF 30 03 BMI L1AD4 1AD1 4C 9E 18 JMP L189E 1AD4 A4 61 L1AD4 LDY $61 1AD6 F0 0B BEQ L1AE3 1AD8 A9 00 LDA #$00 1ADA 85 65 STA $65 1ADC A9 69 LDA #$69 1ADE 85 64 STA $64 1AE0 4C 7B 13 JMP L137B 1AE3 4C B3 13 L1AE3 JMP L13B3 ; BR_STORE_STRING_DESCRIPTOR, then do next ;------------------------------------------------ 1AE6 86 6B L1AE6 STX $6B 1AE8 84 6A STY $6A 1AEA AA TAX 1AEB F0 24 BEQ L1B11 1AED C9 22 CMP #$22 1AEF D0 18 BNE L1B09 1AF1 E6 6A INC $6A 1AF3 E6 7A INC $7A 1AF5 C8 L1AF5 INY 1AF6 B9 00 02 LDA $0200,Y 1AF9 F0 16 BEQ L1B11 1AFB C9 22 CMP #$22 1AFD D0 F6 BNE L1AF5 1AFF 98 TYA 1B00 C8 INY 1B01 D0 0F BNE L1B12 1B03 C8 L1B03 INY 1B04 B9 00 02 LDA $0200,Y 1B07 F0 08 BEQ L1B11 1B09 C9 3A L1B09 CMP #$3A 1B0B F0 04 BEQ L1B11 1B0D C9 2C CMP #$2C 1B0F D0 F2 BNE L1B03 1B11 98 L1B11 TYA 1B12 38 L1B12 SEC 1B13 E5 6A SBC $6A 1B15 85 61 STA $61 1B17 4C 8F 1A JMP L1A8F ;-------------------------------------------------------BR_SECURITY_VALIDATE 1B1A 86 3C STX $3C 1B1C 8A TXA 1B1D 69 92 ADC #$92 1B1F 85 3D STA $3D 1B21 A2 05 LDX #$05 1B23 86 55 STX $55 1B25 A0 EF L1B25 LDY #$EF 1B27 AD 01 02 LDA $0201 1B2A 91 3C STA ($3C),Y 1B2C A9 40 LDA #$40 1B2E A0 FB LDY #$FB 1B30 91 3C STA ($3C),Y 1B32 AE 02 02 LDX $0202 1B35 A9 01 L1B35 LDA #$01 1B37 20 5A 1B JSR L1B5A 1B3A 0A ASL A 1B3B D0 0F BNE L1B4C 1B3D 90 0D BCC L1B4C 1B3F 2A ROL A 1B40 20 5A 1B JSR L1B5A 1B43 30 07 BMI L1B4C 1B45 CA DEX 1B46 F0 0B BEQ L1B53 1B48 C9 00 CMP #$00 1B4A F0 E9 BEQ L1B35 1B4C C6 55 L1B4C DEC $55 1B4E D0 D5 BNE L1B25 1B50 4C 9D 0E JMP L0E9D ; GO PERFORM NEW AND RESTART 1B53 C5 65 L1B53 CMP $65 1B55 D0 F5 BNE L1B4C 1B57 4C C9 0E JMP L0EC9 ; GET AND DO NEXT TOKEN 1B5A 91 3C L1B5A STA ($3C),Y 1B5C 4A LSR A 1B5D 91 3C STA ($3C),Y 1B5F B1 3C LDA ($3C),Y 1B61 60 RTS ;-------------------------------------------------------; CREATE_FOR_LOOP_FRAME 1B62 A5 0E LDA $0E 1B64 29 80 AND #$80 1B66 85 0C STA $0C 1B68 20 C8 13 JSR L13C8 ; RESTORE_FAC_FROM_STACK_AND_JUMP 1B6B 20 37 14 JSR L1437 ; FAC_TYPE_CONVERT 1B6E 20 0F BC JSR $BC0F ; copy FAC1 to ARG 1B71 4C 91 1B JMP L1B91 ;------------------------------------------------------ 1B74 A9 01 LDA #$01 1B76 A6 0E LDX $0E 1B78 30 0D BMI L1B87 1B7A A9 81 LDA #$81 1B7C 85 69 STA $69 1B7E A9 80 LDA #$80 1B80 85 6A STA $6A 1B82 0A ASL A 1B83 85 6E STA $6E 1B85 85 6B STA $6B 1B87 85 6D L1B87 STA $6D 1B89 4A LSR A 1B8A 85 6C STA $6C 1B8C 8A TXA 1B8D 29 80 AND #$80 1B8F 85 0C STA $0C ;------------------------------------------------------- 1B91 20 C8 13 L1B91 JSR L13C8 ; RESTORE_FAC_FROM_STACK_AND_JUMP 1B94 20 37 14 JSR L1437 ; FAC_TYPE_CONVERT 1B97 BA TSX 1B98 BD 01 01 L1B98 LDA $0101,X 1B9B 0A ASL A 1B9C D0 1E BNE L1BBC ;------------------------------------------------ ; 1b9e 1B9E A0 09 LDY #$09 1BA0 B0 02 BCS L1BA4 1BA2 A0 10 LDY #$10 1BA4 84 0B L1BA4 STY $0B 1BA6 A5 4A LDA $4A 1BA8 DD 03 01 CMP $0103,X 1BAB D0 05 BNE L1BB2 1BAD A5 49 LDA $49 1BAF DD 02 01 CMP $0102,X 1BB2 08 L1BB2 PHP 1BB3 8A TXA 1BB4 18 CLC 1BB5 65 0B ADC $0B 1BB7 AA TAX 1BB8 28 PLP 1BB9 D0 DD BNE L1B98 1BBB 9A TXS 1BBC BA L1BBC TSX 1BBD E0 40 CPX #$40 1BBF B0 03 BCS L1BC4 1BC1 4C 35 A4 JMP $A435 ;do out of memory error then warm start 1BC4 A5 0C L1BC4 LDA $0C 1BC6 F0 0F BEQ L1BD7 1BC8 A5 65 LDA $65 1BCA 48 PHA 1BCB A5 64 LDA $64 1BCD 48 PHA 1BCE A5 6D LDA $6D 1BD0 48 PHA 1BD1 A5 6C LDA $6C 1BD3 48 PHA 1BD4 4C F3 1B JMP L1BF3 1BD7 A5 66 L1BD7 LDA $66 1BD9 09 7F ORA #$7F 1BDB 25 62 AND $62 1BDD 85 62 STA $62 1BDF A9 EA LDA #$EA 1BE1 A0 1B LDY #$1B 1BE3 85 22 STA $22 1BE5 84 23 STY $23 1BE7 4C 43 AE JMP $AE43 ; round FAC1 and put on stack, returns to next instruction 1BEA 20 FC BB JSR $BBFC ; FAC = ARG + FAC 1BED 20 2B BC JSR $BC2B ; get FAC1 sign 1BF0 20 38 AE JSR $AE38 ; push sign, round FAC1 and put on stack 1BF3 A5 3A L1BF3 LDA $3A 1BF5 48 PHA 1BF6 A5 39 LDA $39 1BF8 48 PHA 1BF9 A5 4A LDA $4A 1BFB 48 PHA 1BFC A5 49 LDA $49 1BFE 48 PHA 1BFF A5 0C LDA $0C 1C01 48 PHA 1C02 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on ;-------------------------------------------------------- 1C05 69 08 L1C05 ADC #$08 1C07 AA TAX 1C08 D0 01 BNE L1C0B ;--------------------------------------------------- NEXT_WITH_VARIABLE (e.g. NEXT I) 1C0A BA TSX 1C0B A5 4A L1C0B LDA $4A 1C0D DD 03 01 CMP $0103,X 1C10 D0 07 BNE L1C19 1C12 A5 49 LDA $49 1C14 DD 02 01 CMP $0102,X 1C17 F0 1C BEQ L1C35 1C19 BD 01 01 L1C19 LDA $0101,X 1C1C 0A ASL A 1C1D D0 08 BNE L1C27 1C1F 8A TXA 1C20 B0 E3 BCS L1C05 1C22 69 10 ADC #$10 1C24 AA TAX 1C25 D0 E4 BNE L1C0B 1C27 4C 30 AD L1C27 JMP $AD30 ; do LDXI ERRNF ;"NEXT WITHOUT FOR". ;---------------------------------------------------- NEXT_WITHOUT_VARIABLE( e.g. NEXT ) 1C2A BA TSX ; get stack pointer 1C2B BD 03 01 LDA $0103,X ; store parent address 1C2E 85 4A STA $4A 1C30 BD 02 01 LDA $0102,X 1C33 85 49 STA $49 1C35 BD 01 01 L1C35 LDA $0101,X 1C38 0A ASL A 1C39 D0 EC BNE L1C27 ; if not zero , do next without for 1C3B 9A TXS 1C3C C8 INY 1C3D B0 26 BCS L1C65 1C3F 8A TXA 1C40 69 06 ADC #$06 1C42 48 PHA 1C43 69 06 ADC #$06 1C45 85 24 STA $24 1C47 68 PLA 1C48 20 A2 BB JSR $BBA2 ;GET QUANTITY INTO THE FAC. 1C4B BA TSX 1C4C BD 0B 01 LDA $010B,X 1C4F 85 66 STA $66 1C51 85 0C STA $0C 1C53 A5 49 LDA $49 1C55 A4 4A LDY $4A 1C57 20 67 B8 JSR $B867 ; add (AY) to FAC1 1C5A 20 D0 BB JSR $BBD0 ; pack FAC1 into variable pointer 1C5D A0 01 LDY #$01 1C5F 20 5D BC JSR $BC5D ; compare FAC1 with (AY) 1C62 4C A8 1C JMP L1CA8 1C65 BD 07 01 L1C65 LDA $0107,X 1C68 18 CLC 1C69 71 49 ADC ($49),Y 1C6B 91 49 STA ($49),Y 1C6D 85 65 STA $65 1C6F 84 0C STY $0C 1C71 88 DEY 1C72 BD 06 01 LDA $0106,X 1C75 10 02 BPL L1C79 1C77 84 0C STY $0C 1C79 71 49 L1C79 ADC ($49),Y 1C7B 91 49 STA ($49),Y 1C7D 85 64 STA $64 1C7F BD 09 01 LDA $0109,X 1C82 A8 TAY 1C83 BD 08 01 LDA $0108,X 1C86 C5 64 CMP $64 1C88 D0 04 BNE L1C8E 1C8A C4 65 CPY $65 1C8C F0 20 BEQ L1CAE 1C8E A0 00 L1C8E LDY #$00 1C90 45 64 EOR $64 1C92 30 27 BMI L1CBB 1C94 B0 02 BCS L1C98 1C96 A0 01 L1C96 LDY #$01 1C98 C4 0C L1C98 CPY $0C 1C9A D0 12 BNE L1CAE 1C9C 8A TXA 1C9D 69 08 ADC #$08 1C9F AA TAX 1CA0 9A TXS 1CA1 A0 00 LDY #$00 1CA3 84 3B STY $3B 1CA5 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;------------------------------------------ 1CA8 38 L1CA8 SEC 1CA9 BA TSX 1CAA E5 0C SBC $0C 1CAC F0 11 BEQ L1CBF 1CAE BD 05 01 L1CAE LDA $0105,X 1CB1 85 3A STA $3A 1CB3 BD 04 01 LDA $0104,X 1CB6 85 39 STA $39 1CB8 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on 1CBB B0 D9 L1CBB BCS L1C96 1CBD 90 D9 BCC L1C98 1CBF 8A L1CBF TXA 1CC0 18 CLC 1CC1 69 10 ADC #$10 1CC3 AA TAX 1CC4 9A TXS 1CC5 A0 00 LDY #$00 1CC7 84 3B STY $3B 1CC9 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;---------------------------------------------- ; BR_VALIDATE_JUMP_TARGET 1CCC 84 3B STY $3B 1CCE A5 0E LDA $0E 1CD0 10 0B BPL L1CDD 1CD2 A5 64 LDA $64 1CD4 05 65 ORA $65 1CD6 D0 44 BNE L1D1C ; EXECUTE_GOTO 1CD8 A9 02 L1CD8 LDA #$02 1CDA 4C BF 0E JMP L0EBF 1CDD A5 61 L1CDD LDA $61 1CDF D0 3B BNE L1D1C ; EXECUTE_GOTO 1CE1 F0 F5 BEQ L1CD8 ;---------------------------------------------------------- ; GOTO-GOSUB-EXECUTE 1CE3 84 3B STY $3B ; y = token pointer index 1CE5 C8 INY 1CE6 86 3C STX $3C ; x = token, store in 3c 1CE8 A5 0E LDA $0E 1CEA F0 07 BEQ L1CF3 1CEC A5 64 LDA $64 1CEE F0 06 BEQ L1CF6 1CF0 4C 48 B2 JMP $B248 ; do illegal quantity error then warm start 1CF3 20 D3 14 L1CF3 JSR L14D3 ; FINDFREE Find Free Space for FRE/String manipulation 1CF6 B1 39 L1CF6 LDA ($39),Y 1CF8 AA TAX 1CF9 A5 65 LDA $65 1CFB F0 05 BEQ L1D02 1CFD 0A ASL A 1CFE D1 39 CMP ($39),Y 1D00 90 04 BCC L1D06 1D02 8A L1D02 TXA 1D03 4C BC 0E JMP L0EBC ; reset Y index, add Accumulator to token pointer and do next token 1D06 A8 L1D06 TAY 1D07 46 3C LSR $3C 1D09 B0 12 BCS L1D1D 1D0B 88 DEY 1D0C 8A TXA 1D0D D0 02 BNE L1D11 ;------------------------------------------------------ ; PUSH_GOSUB_RETURN_ADDR 1D0F A9 02 LDA #$02 1D11 65 39 L1D11 ADC $39 1D13 48 PHA 1D14 A5 3A LDA $3A 1D16 69 00 ADC #$00 1D18 48 PHA 1D19 A9 8D LDA #$8D 1D1B 48 PHA 1D1C C8 L1D1C INY ; EXECUTE_GOTO 1D1D B1 39 L1D1D LDA ($39),Y 1D1F AA TAX 1D20 C8 INY 1D21 B1 39 LDA ($39),Y ;-----------------------------------------------------------; set Current BASIC line number / token position pointer to A/Y, RESET Y index and do next token 1D23 85 39 L1D23 STA $39 ; set Current BASIC line number / token position pointer to A/Y, RESET Y index and do next token 1D25 86 3A STX $3A 1D27 A0 00 LDY #$00 1D29 4C CF 0E JMP L0ECF ; Get token from token pointer, indexed by Y and do it ;----------------------------------------------------------- 1D2C 69 0F L1D2C ADC #$0F 1D2E AA L1D2E TAX 1D2F 9A TXS ;------------------------------------------------------- ; return 1D30 68 L1D30 PLA 1D31 C9 8D CMP #$8D ; gosub ? if so, pull the address to return to and go 1D33 F0 1E BEQ L1D53 1D35 0A ASL A 1D36 D0 08 BNE L1D40 1D38 BA TSX 1D39 8A TXA 1D3A 90 F0 BCC L1D2C 1D3C 69 07 ADC #$07 1D3E D0 EE L1D3E BNE L1D2E 1D40 4C E0 A8 L1D40 JMP $A8E0 ; return without gosub error ;---------------------------------------------------------- ;FN_PARAM_STACK_RESTORE 1D43 68 PLA 1D44 85 49 STA $49 1D46 68 PLA 1D47 85 4A STA $4A 1D49 68 L1D49 PLA 1D4A 91 49 STA ($49),Y 1D4C C8 INY 1D4D C0 05 CPY #$05 1D4F D0 F8 BNE L1D49 1D51 A0 00 LDY #$00 1D53 68 L1D53 PLA 1D54 85 3A STA $3A 1D56 68 PLA 1D57 85 39 STA $39 1D59 4C CF 0E JMP L0ECF ; Get token from token pointer, indexed by Y and do it ;------------------------------------------- ; BR_IF_THEN_DISPATCH 1D5C 84 3B STY $3B 1D5E A5 0E LDA $0E 1D60 10 09 BPL L1D6B 1D62 A5 64 LDA $64 1D64 05 65 ORA $65 1D66 D0 C8 BNE L1D30 1D68 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) 1D6B A5 61 L1D6B LDA $61 1D6D D0 C1 BNE L1D30 1D6F 4C CB 0E JMP L0ECB ; increase pointer and get next token (Y not reset first) ;---------------------------------------------------- 1D72 84 3B STY $3B ; store y for token pointer index 1D74 A5 0E LDA $0E 1D76 10 0B BPL L1D83 1D78 A5 64 LDA $64 1D7A 05 65 ORA $65 1D7C F0 09 BEQ L1D87 ; if 64/65 is 0 then increase y index and get next token/byte , which 1D7E A9 01 L1D7E LDA #$01 ; set to increase pointer by one and then 1D80 4C BF 0E JMP L0EBF ; go on with next byte/token 1D83 A5 61 L1D83 LDA $61 1D85 D0 F7 BNE L1D7E 1D87 C8 L1D87 INY ; increase y index 1D88 B1 39 L1D88 LDA ($39),Y ; get next byte , this is how much to jump to the next real token 1D8A 4C BC 0E JMP L0EBC ; reset Y index, add Accumulator to token pointer and do next token ;-------------------------------------------------- ; DEF (FN_EXECUTE_SETUP) 1D8D C8 INY 1D8E B1 39 LDA ($39),Y 1D90 18 CLC 1D91 65 2D ADC $2D 1D93 85 64 STA $64 1D95 C8 INY 1D96 B1 39 LDA ($39),Y 1D98 65 2E ADC $2E 1D9A 85 65 STA $65 1D9C C8 INY 1D9D B1 39 LDA ($39),Y 1D9F 65 2D ADC $2D 1DA1 85 6C STA $6C 1DA3 C8 INY 1DA4 B1 39 LDA ($39),Y 1DA6 65 2E ADC $2E 1DA8 85 6D STA $6D 1DAA A9 05 LDA #$05 1DAC 65 39 ADC $39 1DAE 85 6A STA $6A 1DB0 A5 3A LDA $3A 1DB2 69 00 ADC #$00 1DB4 85 6B STA $6B 1DB6 B9 6A 00 L1DB6 LDA $006A,Y 1DB9 91 64 STA ($64),Y 1DBB 88 DEY 1DBC 10 F8 BPL L1DB6 1DBE A0 05 LDY #$05 1DC0 D0 C6 BNE L1D88 ;---------------------------------------------------- ;FN_PARAM_STACK_SAVE 1DC2 A0 02 LDY #$02 1DC4 B1 39 LDA ($39),Y 1DC6 18 CLC 1DC7 65 2D ADC $2D 1DC9 85 47 STA $47 1DCB 88 DEY 1DCC B1 39 LDA ($39),Y 1DCE 65 2E ADC $2E 1DD0 85 48 STA $48 1DD2 A5 39 LDA $39 1DD4 69 03 ADC #$03 1DD6 48 PHA 1DD7 A5 3A LDA $3A 1DD9 69 00 ADC #$00 1DDB 48 PHA 1DDC B1 47 LDA ($47),Y 1DDE D0 03 BNE L1DE3 1DE0 4C AE B3 JMP $B3AE ; undefined function error 1DE3 85 3A L1DE3 STA $3A 1DE5 88 DEY 1DE6 B1 47 LDA ($47),Y 1DE8 85 39 STA $39 1DEA A0 02 LDY #$02 1DEC B1 47 LDA ($47),Y 1DEE 85 49 STA $49 1DF0 C8 INY 1DF1 B1 47 LDA ($47),Y 1DF3 85 4A STA $4A 1DF5 C8 INY 1DF6 B1 49 L1DF6 LDA ($49),Y 1DF8 48 PHA 1DF9 88 DEY 1DFA 10 FA BPL L1DF6 1DFC A5 4A LDA $4A 1DFE 48 PHA 1DFF A5 49 LDA $49 1E01 48 PHA 1E02 A5 0E LDA $0E 1E04 4C 2B 13 JMP L132B ; PACK_AND_STORE_FAC (and do next token) ;---------------------------------------------- opcode 10 CMD_DIM_CORE (DIM) 1E07 C8 INY ; iny 1E08 B1 39 LDA ($39),Y ; get next byte (e.g. 10 01 ) 1E0A 84 0C STY $0C ; store y in c 1E0C 85 0B STA $0B ; store value in b (e.g 01) 1E0E C8 INY ; iny 1E0F B1 39 LDA ($39),Y ; get next byte (e.g. 10 01 DA ) 1E11 85 45 STA $45 ; store in 45/46 (e.g DA), Name and type of current variable (45/46) ; $0045 bits #0-#6: First character of variable name. ; $0046 bits #0-#6: Second character of variable name; $00 = Variable name consists of only one character. ; $0045 bit #7 and $0046 bit #7: ; %00: Floating-point variable. ; %01: String variable. ; %10: FN function, created with DEF FN. ; %11: Integer variable. 1E13 C8 INY 1E14 B1 39 LDA ($39),Y ; get next byte in 46 (e.g. 10 01 DA AA) 1E16 85 46 STA $46 ; e.g. AA DA (46, 45) --> Z$ , string variable 1E18 A5 31 LDA $31 ; Check if variable area left. Pointer to end of variable area (32/31) set 60/5f to that 1E1A 85 5F STA $5F ; Arithmetic register #4 (5 bytes). 1E1C E5 2F SBC $2F ; subtract Pointer to beginning of array variable area 1E1E 85 69 STA $69 ; sttore that lo byte in 69 1E20 A5 32 LDA $32 ; get hibyte 1E22 85 60 STA $60 ; store in 60 1E24 E5 30 SBC $30 ; subtract hi byte of pointer to beginning of array variable area 1E26 AA TAX ; set x to that 1E27 05 69 ORA $69 ; or it with 69 1E29 F0 21 BEQ L1E4C ; if zero , the area has size 0 , jump to set up 1E2B A0 05 LDY #$05 ; 1E2D 18 CLC 1E2E B1 39 LDA ($39),Y 1E30 65 2F ADC $2F 1E32 85 6B STA $6B 1E34 88 DEY 1E35 B1 39 LDA ($39),Y 1E37 65 30 ADC $30 1E39 85 6C STA $6C 1E3B A0 01 LDY #$01 1E3D B1 6B LDA ($6B),Y 1E3F 88 DEY 1E40 11 6B ORA ($6B),Y 1E42 D0 58 BNE L1E9C 1E44 A5 69 LDA $69 1E46 91 6B STA ($6B),Y 1E48 C8 INY 1E49 8A TXA 1E4A 91 6B STA ($6B),Y ;---------------------------------------------------; create array 1E4C 20 94 B1 L1E4C JSR $B194 ; set-up array pointer to first element in array, using 0b for dimension (1, 2 or 3) , pointer in 58/59 1E4F 20 08 A4 JSR $A408 ; check available memory, do out of memory error if no room 1E52 A0 00 LDY #$00 ; 1E54 84 3B STY $3B 1E56 84 72 STY $72 ; Auxiliary pointer during array operations. 72/71 1E58 A2 05 LDX #$05 1E5A A5 45 LDA $45 ; Name and type of current variable. 46/45 1E5C 91 5F STA ($5F),Y ; store name in array area 1E5E 10 01 BPL L1E61 1E60 CA DEX 1E61 C8 L1E61 INY 1E62 A5 46 LDA $46 1E64 91 5F STA ($5F),Y 1E66 10 02 BPL L1E6A 1E68 CA DEX 1E69 CA DEX 1E6A 86 71 L1E6A STX $71 1E6C A5 0B LDA $0B ; get array dimension 1E6E A0 04 LDY #$04 ; store at position 4 (5th byte) from start of variable 1E70 91 5F STA ($5F),Y 1E72 D0 03 BNE L1E77 ; this should always be NOT zero for dim?, so jump 1E74 20 C8 13 L1E74 JSR L13C8 ; RESTORE_FAC_FROM_STACK_AND_JUMP 1E77 20 8E 14 L1E77 JSR L148E ; STORE (JUMP) ADDRESS IN FAC IN 14/15 1E7A C8 INY 1E7B E8 INX 1E7C D0 03 BNE L1E81 1E7E 18 CLC 1E7F 69 01 ADC #$01 1E81 91 5F L1E81 STA ($5F),Y 1E83 C8 INY 1E84 8A TXA 1E85 91 5F STA ($5F),Y 1E87 20 4C B3 JSR $B34C 1E8A A4 22 LDY $22 1E8C 86 71 STX $71 1E8E 85 72 STA $72 1E90 C6 0B DEC $0B 1E92 D0 E0 BNE L1E74 1E94 20 AA B2 JSR $B2AA ; COMPUTE ADDRESS OF END OF THIS ARRAY 1E97 A9 06 LDA #$06 1E99 4C BC 0E JMP L0EBC ; reset Y index, add Accumulator to token pointer and do next token 1E9C 4C 4D B2 L1E9C JMP $B24D ; FOUND THE ARRAY ;--------------------------------------------------------------------- 1E9F C8 INY ; BR_IO_SKIP_AND_START ;------------------------------------------------------ BR_IO_DISPATCHER 1EA0 84 0A STY $0A 1EA2 20 DF 1E JSR L1EDF ; BR_IO_LOAD_SAVE_FAST 1EA5 46 0C LSR $0C 1EA7 AA TAX 1EA8 F0 15 BEQ L1EBF 1EAA 20 5A E2 JSR $E25A ; set filename 1EAD C6 0B DEC $0B 1EAF F0 0E BEQ L1EBF 1EB1 20 02 1F JSR L1F02 1EB4 86 BA STX $BA 1EB6 C6 0B DEC $0B 1EB8 F0 05 BEQ L1EBF 1EBA 20 02 1F JSR L1F02 1EBD 86 B9 STX $B9 1EBF 20 C5 1E L1EBF JSR L1EC5 1EC2 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on 1EC5 A5 3C L1EC5 LDA $3C 1EC7 C9 5E CMP #$5E 1EC9 90 05 BCC L1ED0 1ECB D0 0F BNE L1EDC 1ECD 4C 59 E1 JMP $E159 ; perform SAVE 1ED0 A5 B9 L1ED0 LDA $B9 1ED2 D0 02 BNE L1ED6 1ED4 E6 B9 INC $B9 1ED6 A9 A7 L1ED6 LDA #$A7 1ED8 48 PHA 1ED9 A9 AD LDA #$AD 1EDB 48 PHA 1EDC 4C 6F E1 L1EDC JMP $E16F ; perform LOAD ;----------------------------------------------------- 1EDF 86 3C L1EDF STX $3C 1EE1 A0 01 LDY #$01 1EE3 A2 00 LDX #$00 1EE5 86 B7 STX $B7 1EE7 86 17 STX $17 1EE9 86 B9 STX $B9 1EEB 86 90 STX $90 1EED 84 0C STY $0C 1EEF 84 BA STY $BA 1EF1 84 7B STY $7B 1EF3 A9 19 LDA #$19 1EF5 85 16 STA $16 1EF7 B1 39 LDA ($39),Y 1EF9 85 0B STA $0B 1EFB E6 39 INC $39 1EFD D0 02 BNE L1F01 1EFF E6 3A INC $3A 1F01 60 L1F01 RTS ;--------------------------------------- 1F02 46 0C L1F02 LSR $0C 1F04 90 06 BCC L1F0C ; EXECUTE_OPEN_COMMAND 1F06 4C C8 14 JMP L14C8 1F09 4C 48 B2 L1F09 JMP $B248 ; do illegal quantity error then warm start ;-------------------------------------------------- ; EXECUTE_OPEN_COMMAND 1F0C 68 L1F0C PLA ; EXECUTE_OPEN_COMMAND 1F0D 18 CLC 1F0E 69 01 ADC #$01 1F10 85 45 STA $45 1F12 68 PLA 1F13 69 00 ADC #$00 1F15 85 46 STA $46 1F17 68 PLA 1F18 10 0A BPL L1F24 1F1A 68 PLA 1F1B D0 EC BNE L1F09 1F1D 68 PLA 1F1E 85 65 L1F1E STA $65 1F20 AA TAX 1F21 6C 45 00 JMP ($0045) 1F24 68 L1F24 PLA 1F25 30 E2 BMI L1F09 1F27 68 PLA 1F28 38 SEC 1F29 E9 89 SBC #$89 1F2B 10 DC BPL L1F09 1F2D A8 TAY 1F2E 68 PLA 1F2F AA TAX 1F30 68 PLA 1F31 68 PLA 1F32 68 PLA 1F33 8A TXA 1F34 C8 INY 1F35 F0 E7 BEQ L1F1E 1F37 4A L1F37 LSR A 1F38 C8 INY 1F39 D0 FC BNE L1F37 1F3B F0 E1 BEQ L1F1E ;--------------------------------------------------------BR_EXECUTE_OPEN 1F3D 20 DF 1E JSR L1EDF 1F40 20 02 1F JSR L1F02 1F43 86 B8 STX $B8 1F45 C6 0B DEC $0B 1F47 F0 20 BEQ L1F69 1F49 20 02 1F JSR L1F02 1F4C 86 BA STX $BA 1F4E E0 03 CPX #$03 1F50 90 02 BCC L1F54 1F52 C6 B9 DEC $B9 1F54 C6 0B L1F54 DEC $0B 1F56 F0 11 BEQ L1F69 1F58 20 02 1F JSR L1F02 1F5B 86 B9 STX $B9 1F5D C6 0B DEC $0B 1F5F F0 08 BEQ L1F69 1F61 20 C8 13 JSR L13C8 ; RESTORE_FAC_FROM_STACK_AND_JUMP 1F64 C6 0D DEC $0D 1F66 20 5A E2 JSR $E25A ; set filename 1F69 20 C0 FF L1F69 JSR $FFC0 ; open a logical file 1F6C B0 03 BCS L1F71 1F6E 4C AC 0E JMP L0EAC ; GET KEY OR READ/INPUT CHECK AND go on 1F71 4C EF 19 L1F71 JMP L19EF 1F74 EA NOP 1F75 EA NOP 1F76 EA NOP 1F77 4C 08 AF JMP $AF08 ;Do syntax error ;-------------------------------------------------------; FORCE_GARBAGE_COLLECT_AND_CHECK 1F7A 20 26 B5 L1F7A JSR $B526 ; garbage collection routine 1F7D A5 33 LDA $33 1F7F A4 34 LDY $34 1F81 38 SEC 1F82 E5 61 SBC $61 1F84 B0 01 BCS L1F87 1F86 88 DEY 1F87 C4 32 L1F87 CPY $32 1F89 D0 02 BNE L1F8D 1F8B C5 31 CMP $31 1F8D 90 01 L1F8D BCC L1F90 1F8F 60 RTS ;------------------------------------------------------- 1F90 4C 35 A4 L1F90 JMP $A435 ; do out of memory error then warm start ;------------------------------------------------------- COMPILED BASIC P-CODE FOLLOWS BELOW 1F93 ; START OF COMPILED BASIC PROGRAM