mirror of https://github.com/dschmenk/VM02.git
9993 lines
207 KiB
ArmAsm
Executable File
9993 lines
207 KiB
ArmAsm
Executable File
.INCLUDE "plstub.s"
|
|
; 1: ;
|
|
; 2: ; Global constants
|
|
; 3: ;
|
|
; 4: const FALSE = 0
|
|
; FALSE = 0
|
|
; 5: const TRUE = !FALSE
|
|
; TRUE = -1
|
|
; 6: ;
|
|
; 7: ; Data and code buffer variables
|
|
; 8: ;
|
|
; 9: const iobuffer = $0800
|
|
; iobuffer = 2048
|
|
; 10: const compbuff = $6000
|
|
; compbuff = 24576
|
|
; 11: const compbuffsz = $4000
|
|
; compbuffsz = 16384
|
|
; 12: const func_dict = $5000
|
|
; func_dict = 20480
|
|
; 13: const fixup_tbl = $4000
|
|
; fixup_tbl = 16384
|
|
; 14: const argbuff = $2006
|
|
; argbuff = 8198
|
|
; 15: const inbuff = $0200
|
|
; inbuff = 512
|
|
; 16: const instr = $01FF
|
|
; instr = 511
|
|
; 17: byte inref
|
|
D0000: DS 1 ; inref
|
|
; 18: ;
|
|
; 19: ; REL file tables
|
|
; 20: ;
|
|
; 21: word datalen, codelen
|
|
D0001: DS 2 ; datalen
|
|
D0003: DS 2 ; codelen
|
|
; 22: word fixup = fixup_tbl
|
|
D0005: ; fixup
|
|
DW $4000
|
|
; 23: word numfuncs = 1
|
|
D0007: ; numfuncs
|
|
DW $0001
|
|
; 24: ;
|
|
; 25: ; Symbol table variables
|
|
; 26: ;
|
|
; 27: const idglobal_tblsz = $0800
|
|
; idglobal_tblsz = 2048
|
|
; 28: const idlocal_tblsz = $0200
|
|
; idlocal_tblsz = 512
|
|
; 29: const idglobal_tbl = $1000
|
|
; idglobal_tbl = 4096
|
|
; 30: const idlocal_tbl = $1800
|
|
; idlocal_tbl = 6144
|
|
; 31: const ctag_max = 768
|
|
; ctag_max = 768
|
|
; 32: const ctag_value = $1A00
|
|
; ctag_value = 6656
|
|
; 33: const ctag_flags = $0D00
|
|
; ctag_flags = 3328
|
|
; 34: const idval = 0
|
|
; idval = 0
|
|
; 35: const idtype = 2
|
|
; idtype = 2
|
|
; 36: const idname = 3
|
|
; idname = 3
|
|
; 37: const idrecsz = 4
|
|
; idrecsz = 4
|
|
; 38: word globals = 0
|
|
D0009: ; globals
|
|
DW $0000
|
|
; 39: word datasize = 0
|
|
D0011: ; datasize
|
|
DW $0000
|
|
; 40: word lastglobal
|
|
D0013: DS 2 ; lastglobal
|
|
; 41: byte locals = 0
|
|
D0015: ; locals
|
|
DB $00
|
|
; 42: word framesize = 0
|
|
D0016: ; framesize
|
|
DW $0000
|
|
; 43: word lastlocal
|
|
D0018: DS 2 ; lastlocal
|
|
; 44: const resolved = 1
|
|
; resolved = 1
|
|
; 45: const is_ctag = $8000
|
|
; is_ctag = 32768
|
|
; 46: const mask_ctag = $7FFF
|
|
; mask_ctag = 32767
|
|
; 47: word codetag = -1
|
|
D0020: ; codetag
|
|
DW $FFFF
|
|
; 48: ;
|
|
; 49: ; Symbol types
|
|
; 50: ;
|
|
; 51: const EXTERN_SYM = $10
|
|
; EXTERN_SYM = 16
|
|
; 52: const EXPORT_SYM = $08
|
|
; EXPORT_SYM = 8
|
|
; 53: ;
|
|
; 54: ; Compiler pointers
|
|
; 55: ;
|
|
; 56: word codeptr
|
|
D0022: DS 2 ; codeptr
|
|
; 57: word entrypoint = 0
|
|
D0024: ; entrypoint
|
|
DW $0000
|
|
; 58: byte lastop = $FF
|
|
D0026: ; lastop
|
|
DB $FF
|
|
; 59: byte perr
|
|
D0027: DS 1 ; perr
|
|
; 60: ;
|
|
; 61: ; String variables
|
|
; 62: ;
|
|
; 63: byte version[] = "PLASMA ][ COMPILER VERSION 0.8 "
|
|
D0028: ; version
|
|
DB $1F
|
|
DB $50,$4C,$41,$53,$4D,$41,$20,$5D
|
|
DB $5B,$20,$43,$4F,$4D,$50,$49,$4C
|
|
DB $45,$52,$20,$56,$45,$52,$53,$49
|
|
DB $4F,$4E,$20,$30,$2E,$38,$20
|
|
; 64: byte badfile[] = "FILE NOT FOUND"
|
|
D0060: ; badfile
|
|
DB $0E
|
|
DB $46,$49,$4C,$45,$20,$4E,$4F,$54
|
|
DB $20,$46,$4F,$55,$4E,$44
|
|
; 65: ;
|
|
; 66: ; Tokens
|
|
; 67: ;
|
|
; 68: const ID_TKN = $D6 ; V
|
|
; ID_TKN = 214
|
|
; 69: const CHR_TKN = $C3 ; C
|
|
; CHR_TKN = 195
|
|
; 70: const INT_TKN = $C9 ; I
|
|
; INT_TKN = 201
|
|
; 71: const STR_TKN = $D3 ; S
|
|
; STR_TKN = 211
|
|
; 72: const EOL_TKN = $02
|
|
; EOL_TKN = 2
|
|
; 73: const EOF_TKN = $01
|
|
; EOF_TKN = 1
|
|
; 74: const ERR_TKN = $00
|
|
; ERR_TKN = 0
|
|
; 75: ;
|
|
; 76: ; Binary operand operators
|
|
; 77: ;
|
|
; 78: const SET_TKN = $BD ; =
|
|
; SET_TKN = 189
|
|
; 79: const SETLIST_TKN = $B9 ; =,
|
|
; SETLIST_TKN = 185
|
|
; 80: const ADD_TKN = $AB ; +
|
|
; ADD_TKN = 171
|
|
; 81: const SUB_TKN = $AD ; -
|
|
; SUB_TKN = 173
|
|
; 82: const MUL_TKN = $AA ; *
|
|
; MUL_TKN = 170
|
|
; 83: const DIV_TKN = $AF ; /
|
|
; DIV_TKN = 175
|
|
; 84: const MOD_TKN = $A5 ; %
|
|
; MOD_TKN = 165
|
|
; 85: const OR_TKN = $BF ; ?
|
|
; OR_TKN = 191
|
|
; 86: const EOR_TKN = $DE ; ^
|
|
; EOR_TKN = 222
|
|
; 87: const AND_TKN = $A6 ; &
|
|
; AND_TKN = 166
|
|
; 88: const SHR_TKN = $D2 ; R
|
|
; SHR_TKN = 210
|
|
; 89: const SHL_TKN = $CC ; L
|
|
; SHL_TKN = 204
|
|
; 90: const GT_TKN = $BE ; >
|
|
; GT_TKN = 190
|
|
; 91: const GE_TKN = $C8 ; H
|
|
; GE_TKN = 200
|
|
; 92: const LT_TKN = $BC ; <
|
|
; LT_TKN = 188
|
|
; 93: const LE_TKN = $C2 ; B
|
|
; LE_TKN = 194
|
|
; 94: const NE_TKN = $D5 ; U
|
|
; NE_TKN = 213
|
|
; 95: const EQ_TKN = $C5 ; E
|
|
; EQ_TKN = 197
|
|
; 96: const LOGIC_AND_TKN = $CE ; N
|
|
; LOGIC_AND_TKN = 206
|
|
; 97: const LOGIC_OR_TKN = $CF ; O
|
|
; LOGIC_OR_TKN = 207
|
|
; 98: ;
|
|
; 99: ; Unary operand operators
|
|
; 100: ;
|
|
; 101: const AT_TKN = $C0 ; @
|
|
; AT_TKN = 192
|
|
; 102: const DOT_TKN = $AE ; .
|
|
; DOT_TKN = 174
|
|
; 103: const COLON_TKN = $BA ; :
|
|
; COLON_TKN = 186
|
|
; 104: const NEG_TKN = $AD ; -
|
|
; NEG_TKN = 173
|
|
; 105: const COMP_TKN = $A3 ; #
|
|
; COMP_TKN = 163
|
|
; 106: const LOGIC_NOT_TKN = $A1 ; !
|
|
; LOGIC_NOT_TKN = 161
|
|
; 107: const BPTR_TKN = $DE ; ^
|
|
; BPTR_TKN = 222
|
|
; 108: const WPTR_TKN = $AA ; *
|
|
; WPTR_TKN = 170
|
|
; 109: const INC_TKN = $C1 ; A
|
|
; INC_TKN = 193
|
|
; 110: const DEC_TKN = $C4 ; D
|
|
; DEC_TKN = 196
|
|
; 111: ;
|
|
; 112: ; Enclosure tokens
|
|
; 113: ;
|
|
; 114: const OPEN_PAREN_TKN = $A8 ; (
|
|
; OPEN_PAREN_TKN = 168
|
|
; 115: const CLOSE_PAREN_TKN = $A9 ; )
|
|
; CLOSE_PAREN_TKN = 169
|
|
; 116: const OPEN_BRACKET_TKN = $DB ; [
|
|
; OPEN_BRACKET_TKN = 219
|
|
; 117: const CLOSE_BRACKET_TKN = $DD ; ]
|
|
; CLOSE_BRACKET_TKN = 221
|
|
; 118: ;
|
|
; 119: ; Misc. tokens
|
|
; 120: ;
|
|
; 121: const COMMA_TKN = $AC ; ,
|
|
; COMMA_TKN = 172
|
|
; 122: const COMMENT_TKN = $BB ; ;
|
|
; COMMENT_TKN = 187
|
|
; 123: ;
|
|
; 124: ; Keyword tokens
|
|
; 125: ;
|
|
; 126: const CONST_TKN = $80
|
|
; CONST_TKN = 128
|
|
; 127: const BYTE_TKN = $81
|
|
; BYTE_TKN = 129
|
|
; 128: const WORD_TKN = $82
|
|
; WORD_TKN = 130
|
|
; 129: const IF_TKN = $83
|
|
; IF_TKN = 131
|
|
; 130: const ELSEIF_TKN = $84
|
|
; ELSEIF_TKN = 132
|
|
; 131: const ELSE_TKN = $85
|
|
; ELSE_TKN = 133
|
|
; 132: const FIN_TKN = $86
|
|
; FIN_TKN = 134
|
|
; 133: const END_TKN = $87
|
|
; END_TKN = 135
|
|
; 134: const WHILE_TKN = $88
|
|
; WHILE_TKN = 136
|
|
; 135: const LOOP_TKN = $89
|
|
; LOOP_TKN = 137
|
|
; 136: const CASE_TKN = $8A
|
|
; CASE_TKN = 138
|
|
; 137: const OF_TKN = $8B
|
|
; OF_TKN = 139
|
|
; 138: const DEFAULT_TKN = $8C
|
|
; DEFAULT_TKN = 140
|
|
; 139: const ENDCASE_TKN = $8D
|
|
; ENDCASE_TKN = 141
|
|
; 140: const FOR_TKN = $8E
|
|
; FOR_TKN = 142
|
|
; 141: const TO_TKN = $8F
|
|
; TO_TKN = 143
|
|
; 142: const DOWNTO_TKN = $90
|
|
; DOWNTO_TKN = 144
|
|
; 143: const STEP_TKN = $91
|
|
; STEP_TKN = 145
|
|
; 144: const NEXT_TKN = $92
|
|
; NEXT_TKN = 146
|
|
; 145: const REPEAT_TKN = $93
|
|
; REPEAT_TKN = 147
|
|
; 146: const UNTIL_TKN = $94
|
|
; UNTIL_TKN = 148
|
|
; 147: const DEF_TKN = $95
|
|
; DEF_TKN = 149
|
|
; 148: const OPT_TKN = $96
|
|
; OPT_TKN = 150
|
|
; 149: const DROP_TKN = $97
|
|
; DROP_TKN = 151
|
|
; 150: const DONE_TKN = $98
|
|
; DONE_TKN = 152
|
|
; 151: const RETURN_TKN = $99
|
|
; RETURN_TKN = 153
|
|
; 152: const BREAK_TKN = $9A
|
|
; BREAK_TKN = 154
|
|
; 153: const START_TKN = $9B
|
|
; START_TKN = 155
|
|
; 154: const EXIT_TKN = $9C
|
|
; EXIT_TKN = 156
|
|
; 155: const EVAL_TKN = $9D
|
|
; EVAL_TKN = 157
|
|
; 156: const FUNC_TKN = $9E
|
|
; FUNC_TKN = 158
|
|
; 157: const EXTERN_TKN = $9F
|
|
; EXTERN_TKN = 159
|
|
; 158: const ENTRY_TKN = $A0
|
|
; ENTRY_TKN = 160
|
|
; 159: const IMPORT_TKN = $A1
|
|
; IMPORT_TKN = 161
|
|
; 160: const INCLUDE_TKN = $A2
|
|
; INCLUDE_TKN = 162
|
|
; 161: ;
|
|
; 162: ; Types
|
|
; 163: ;
|
|
; 164: const CONST_TYPE = $01
|
|
; CONST_TYPE = 1
|
|
; 165: const BYTE_TYPE = $02
|
|
; BYTE_TYPE = 2
|
|
; 166: const WORD_TYPE = $04
|
|
; WORD_TYPE = 4
|
|
; 167: const VAR_TYPE = $06 ; (WORD_TYPE | BYTE_TYPE)
|
|
; VAR_TYPE = 6
|
|
; 168: const FUNC_TYPE = $08
|
|
; FUNC_TYPE = 8
|
|
; 169: const FUNC_CONST_TYPE = $09
|
|
; FUNC_CONST_TYPE = 9
|
|
; 170: const ADDR_TYPE = $0E ; (VAR_TYPE | FUNC_TYPE)
|
|
; ADDR_TYPE = 14
|
|
; 171: const LOCAL_TYPE = $10
|
|
; LOCAL_TYPE = 16
|
|
; 172: const BPTR_TYPE = $20
|
|
; BPTR_TYPE = 32
|
|
; 173: const WPTR_TYPE = $40
|
|
; WPTR_TYPE = 64
|
|
; 174: const PTR_TYPE = $60 ; (BPTR_TYPE | WPTR_TYPE)
|
|
; PTR_TYPE = 96
|
|
; 175: const XBYTE_TYPE = $22 ; (BPTR_TYPE | BYTE_TYPE)
|
|
; XBYTE_TYPE = 34
|
|
; 176: const XWORD_TYPE = $44 ; (WPTR_TYPE | WORD_TYPE)
|
|
; XWORD_TYPE = 68
|
|
; 177: const STR_TYPE = $80
|
|
; STR_TYPE = 128
|
|
; 178: ;
|
|
; 179: ; Keywords
|
|
; 180: ;
|
|
; 181: byte keywrds[]
|
|
D0075: ; keywrds
|
|
; 182: byte = "IF", IF_TKN
|
|
DB $02
|
|
DB $49,$46
|
|
DB $83
|
|
; 183: byte = "TO", TO_TKN
|
|
DB $02
|
|
DB $54,$4F
|
|
DB $8F
|
|
; 184: byte = "IS", OF_TKN
|
|
DB $02
|
|
DB $49,$53
|
|
DB $8B
|
|
; 185: byte = "OR", LOGIC_OR_TKN
|
|
DB $02
|
|
DB $4F,$52
|
|
DB $CF
|
|
; 186: byte = "FOR", FOR_TKN
|
|
DB $03
|
|
DB $46,$4F,$52
|
|
DB $8E
|
|
; 187: byte = "FIN", FIN_TKN
|
|
DB $03
|
|
DB $46,$49,$4E
|
|
DB $86
|
|
; 188: byte = "DEF", DEF_TKN
|
|
DB $03
|
|
DB $44,$45,$46
|
|
DB $95
|
|
; 189: byte = "END", END_TKN
|
|
DB $03
|
|
DB $45,$4E,$44
|
|
DB $87
|
|
; 190: byte = "AND", LOGIC_AND_TKN
|
|
DB $03
|
|
DB $41,$4E,$44
|
|
DB $CE
|
|
; 191: byte = "NOT", LOGIC_NOT_TKN
|
|
DB $03
|
|
DB $4E,$4F,$54
|
|
DB $A1
|
|
; 192: byte = "BYTE", BYTE_TKN
|
|
DB $04
|
|
DB $42,$59,$54,$45
|
|
DB $81
|
|
; 193: byte = "WORD", WORD_TKN
|
|
DB $04
|
|
DB $57,$4F,$52,$44
|
|
DB $82
|
|
; 194: byte = "DROP", DROP_TKN
|
|
DB $04
|
|
DB $44,$52,$4F,$50
|
|
DB $97
|
|
; 195: byte = "ELSE", ELSE_TKN
|
|
DB $04
|
|
DB $45,$4C,$53,$45
|
|
DB $85
|
|
; 196: byte = "NEXT", NEXT_TKN
|
|
DB $04
|
|
DB $4E,$45,$58,$54
|
|
DB $92
|
|
; 197: byte = "WHEN", CASE_TKN
|
|
DB $04
|
|
DB $57,$48,$45,$4E
|
|
DB $8A
|
|
; 198: byte = "LOOP", LOOP_TKN
|
|
DB $04
|
|
DB $4C,$4F,$4F,$50
|
|
DB $89
|
|
; 199: byte = "FUNC", FUNC_TKN
|
|
DB $04
|
|
DB $46,$55,$4E,$43
|
|
DB $9E
|
|
; 200: byte = "STEP", STEP_TKN
|
|
DB $04
|
|
DB $53,$54,$45,$50
|
|
DB $91
|
|
; 201: byte = "EXIT", EXIT_TKN
|
|
DB $04
|
|
DB $45,$58,$49,$54
|
|
DB $9C
|
|
; 202: byte = "DONE", DONE_TKN
|
|
DB $04
|
|
DB $44,$4F,$4E,$45
|
|
DB $98
|
|
; 203: byte = "WEND", ENDCASE_TKN
|
|
DB $04
|
|
DB $57,$45,$4E,$44
|
|
DB $8D
|
|
; 204: byte = "ENTRY", ENTRY_TKN
|
|
DB $05
|
|
DB $45,$4E,$54,$52,$59
|
|
DB $A0
|
|
; 205: byte = "CONST", CONST_TKN
|
|
DB $05
|
|
DB $43,$4F,$4E,$53,$54
|
|
DB $80
|
|
; 206: byte = "ELSIF", ELSEIF_TKN
|
|
DB $05
|
|
DB $45,$4C,$53,$49,$46
|
|
DB $84
|
|
; 207: byte = "WHILE", WHILE_TKN
|
|
DB $05
|
|
DB $57,$48,$49,$4C,$45
|
|
DB $88
|
|
; 208: byte = "UNTIL", UNTIL_TKN
|
|
DB $05
|
|
DB $55,$4E,$54,$49,$4C
|
|
DB $94
|
|
; 209: byte = "BREAK", BREAK_TKN
|
|
DB $05
|
|
DB $42,$52,$45,$41,$4B
|
|
DB $9A
|
|
; 210: byte = "OTHER", DEFAULT_TKN
|
|
DB $05
|
|
DB $4F,$54,$48,$45,$52
|
|
DB $8C
|
|
; 211: byte = "DOWNTO", DOWNTO_TKN
|
|
DB $06
|
|
DB $44,$4F,$57,$4E,$54,$4F
|
|
DB $90
|
|
; 212: byte = "REPEAT", REPEAT_TKN
|
|
DB $06
|
|
DB $52,$45,$50,$45,$41,$54
|
|
DB $93
|
|
; 213: byte = "RETURN", RETURN_TKN
|
|
DB $06
|
|
DB $52,$45,$54,$55,$52,$4E
|
|
DB $99
|
|
; 214: byte = "EXTERN", EXTERN_TKN
|
|
DB $06
|
|
DB $45,$58,$54,$45,$52,$4E
|
|
DB $9F
|
|
; 215: byte = "IMPORT", IMPORT_TKN
|
|
DB $06
|
|
DB $49,$4D,$50,$4F,$52,$54
|
|
DB $A1
|
|
; 216: byte = "INCLUDE", INCLUDE_TKN
|
|
DB $07
|
|
DB $49,$4E,$43,$4C,$55,$44,$45
|
|
DB $A2
|
|
; 217: byte = $FF
|
|
DB $FF
|
|
; 218: ;
|
|
; 219: ; Mathematical ops
|
|
; 220: ;
|
|
; 221: const bops_tblsz = 18 ; minus 1
|
|
; bops_tblsz = 18
|
|
; 222: byte bops_tbl[] ; Highest precedence
|
|
D0292: ; bops_tbl
|
|
; 223: byte = MUL_TKN, DIV_TKN, MOD_TKN
|
|
DB $AA
|
|
DB $AF
|
|
DB $A5
|
|
; 224: byte = ADD_TKN, SUB_TKN
|
|
DB $AB
|
|
DB $AD
|
|
; 225: byte = SHR_TKN, SHL_TKN
|
|
DB $D2
|
|
DB $CC
|
|
; 226: byte = AND_TKN
|
|
DB $A6
|
|
; 227: byte = EOR_TKN
|
|
DB $DE
|
|
; 228: byte = OR_TKN
|
|
DB $BF
|
|
; 229: byte = GT_TKN, GE_TKN, LT_TKN, LE_TKN
|
|
DB $BE
|
|
DB $C8
|
|
DB $BC
|
|
DB $C2
|
|
; 230: byte = EQ_TKN, NE_TKN
|
|
DB $C5
|
|
DB $D5
|
|
; 231: byte = LOGIC_AND_TKN
|
|
DB $CE
|
|
; 232: byte = LOGIC_OR_TKN
|
|
DB $CF
|
|
; 233: byte = COMMA_TKN
|
|
DB $AC
|
|
; 234: ; Lowest precedence
|
|
; 235: byte bops_prec[] ; Highest precedence
|
|
D0311: ; bops_prec
|
|
; 236: byte = 1, 1, 1
|
|
DB $01
|
|
DB $01
|
|
DB $01
|
|
; 237: byte = 2, 2
|
|
DB $02
|
|
DB $02
|
|
; 238: byte = 3, 3
|
|
DB $03
|
|
DB $03
|
|
; 239: byte = 4
|
|
DB $04
|
|
; 240: byte = 5
|
|
DB $05
|
|
; 241: byte = 6
|
|
DB $06
|
|
; 242: byte = 7, 7, 7, 7
|
|
DB $07
|
|
DB $07
|
|
DB $07
|
|
DB $07
|
|
; 243: byte = 8, 8
|
|
DB $08
|
|
DB $08
|
|
; 244: byte = 9
|
|
DB $09
|
|
; 245: byte = 10
|
|
DB $0A
|
|
; 246: byte = 11
|
|
DB $0B
|
|
; 247: ; Lowest precedence
|
|
; 248: byte opstack[16]
|
|
D0330: DS 16 ; opstack
|
|
; 249: byte precstack[16]
|
|
D0346: DS 16 ; precstack
|
|
; 250: word opsp = -1
|
|
D0362: ; opsp
|
|
DW $FFFF
|
|
; 251: ;
|
|
; 252: ; Scanner variables
|
|
; 253: ;
|
|
; 254: byte token, tknlen
|
|
D0364: DS 1 ; token
|
|
D0365: DS 1 ; tknlen
|
|
; 255: word scanptr, tknptr
|
|
D0366: DS 2 ; scanptr
|
|
D0368: DS 2 ; tknptr
|
|
; 256: word constval
|
|
D0370: DS 2 ; constval
|
|
; 257: word lineno = 0
|
|
D0372: ; lineno
|
|
DW $0000
|
|
; 258: ;
|
|
; 259: ; Compiler output messages
|
|
; 260: ;
|
|
; 261: byte entrypt_str[] = "START: "
|
|
D0374: ; entrypt_str
|
|
DB $07
|
|
DB $53,$54,$41,$52,$54,$3A,$20
|
|
; 262: byte dup_id[] = "DUPLICATE IDENTIFIER"
|
|
D0382: ; dup_id
|
|
DB $14
|
|
DB $44,$55,$50,$4C,$49,$43,$41,$54
|
|
DB $45,$20,$49,$44,$45,$4E,$54,$49
|
|
DB $46,$49,$45,$52
|
|
; 263: byte undecl_id[] = "UNDECLARED IDENTIFIER"
|
|
D0403: ; undecl_id
|
|
DB $15
|
|
DB $55,$4E,$44,$45,$43,$4C,$41,$52
|
|
DB $45,$44,$20,$49,$44,$45,$4E,$54
|
|
DB $49,$46,$49,$45,$52
|
|
; 264: byte bad_cnst[] = "BAD CONSTANT"
|
|
D0425: ; bad_cnst
|
|
DB $0C
|
|
DB $42,$41,$44,$20,$43,$4F,$4E,$53
|
|
DB $54,$41,$4E,$54
|
|
; 265: byte bad_offset[] = "BAD STRUCT OFFSET"
|
|
D0438: ; bad_offset
|
|
DB $11
|
|
DB $42,$41,$44,$20,$53,$54,$52,$55
|
|
DB $43,$54,$20,$4F,$46,$46,$53,$45
|
|
DB $54
|
|
; 266: byte bad_decl[] = "BAD DECLARATION"
|
|
D0456: ; bad_decl
|
|
DB $0F
|
|
DB $42,$41,$44,$20,$44,$45,$43,$4C
|
|
DB $41,$52,$41,$54,$49,$4F,$4E
|
|
; 267: byte bad_op[] = "BAD OPERATION"
|
|
D0472: ; bad_op
|
|
DB $0D
|
|
DB $42,$41,$44,$20,$4F,$50,$45,$52
|
|
DB $41,$54,$49,$4F,$4E
|
|
; 268: byte bad_stmnt[] = "BAD STATMENT"
|
|
D0486: ; bad_stmnt
|
|
DB $0C
|
|
DB $42,$41,$44,$20,$53,$54,$41,$54
|
|
DB $4D,$45,$4E,$54
|
|
; 269: byte bad_expr[] = "BAD EXPRESSION"
|
|
D0499: ; bad_expr
|
|
DB $0E
|
|
DB $42,$41,$44,$20,$45,$58,$50,$52
|
|
DB $45,$53,$53,$49,$4F,$4E
|
|
; 270: byte bad_syntax[] = "BAD SYNTAX"
|
|
D0514: ; bad_syntax
|
|
DB $0A
|
|
DB $42,$41,$44,$20,$53,$59,$4E,$54
|
|
DB $41,$58
|
|
; 271: byte estk_overflw[] = "EVAL STACK OVERFLOW"
|
|
D0525: ; estk_overflw
|
|
DB $13
|
|
DB $45,$56,$41,$4C,$20,$53,$54,$41
|
|
DB $43,$4B,$20,$4F,$56,$45,$52,$46
|
|
DB $4C,$4F,$57
|
|
; 272: byte estk_underflw[] = "EVAL STACK UNDERFLOW"
|
|
D0545: ; estk_underflw
|
|
DB $14
|
|
DB $45,$56,$41,$4C,$20,$53,$54,$41
|
|
DB $43,$4B,$20,$55,$4E,$44,$45,$52
|
|
DB $46,$4C,$4F,$57
|
|
; 273: byte local_overflw[] = "LOCAL FRAME OVERFLOW"
|
|
D0566: ; local_overflw
|
|
DB $14
|
|
DB $4C,$4F,$43,$41,$4C,$20,$46,$52
|
|
DB $41,$4D,$45,$20,$4F,$56,$45,$52
|
|
DB $46,$4C,$4F,$57
|
|
; 274: byte global_sym_overflw[] = "GLOBAL SYMBOL TABLE OVERFLOW"
|
|
D0587: ; global_sym_overflw
|
|
DB $1C
|
|
DB $47,$4C,$4F,$42,$41,$4C,$20,$53
|
|
DB $59,$4D,$42,$4F,$4C,$20,$54,$41
|
|
DB $42,$4C,$45,$20,$4F,$56,$45,$52
|
|
DB $46,$4C,$4F,$57
|
|
; 275: byte local_sym_overflw[] = "LOCAL SYMBOL TABLE OVERFLOW"
|
|
D0616: ; local_sym_overflw
|
|
DB $1B
|
|
DB $4C,$4F,$43,$41,$4C,$20,$53,$59
|
|
DB $4D,$42,$4F,$4C,$20,$54,$41,$42
|
|
DB $4C,$45,$20,$4F,$56,$45,$52,$46
|
|
DB $4C,$4F,$57
|
|
; 276: byte ctag_full[] = "CODE LABEL OVERFLOW"
|
|
D0644: ; ctag_full
|
|
DB $13
|
|
DB $43,$4F,$44,$45,$20,$4C,$41,$42
|
|
DB $45,$4C,$20,$4F,$56,$45,$52,$46
|
|
DB $4C,$4F,$57
|
|
; 277: byte no_close_paren[] = "MISSING CLOSING PAREN"
|
|
D0664: ; no_close_paren
|
|
DB $15
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $43,$4C,$4F,$53,$49,$4E,$47,$20
|
|
DB $50,$41,$52,$45,$4E
|
|
; 278: byte no_close_bracket[] = "MISSING CLOSING BRACKET"
|
|
D0686: ; no_close_bracket
|
|
DB $17
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $43,$4C,$4F,$53,$49,$4E,$47,$20
|
|
DB $42,$52,$41,$43,$4B,$45,$54
|
|
; 279: byte missing_op[] = "MISSING OPERAND"
|
|
D0710: ; missing_op
|
|
DB $0F
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $4F,$50,$45,$52,$41,$4E,$44
|
|
; 280: byte no_fin[] = "MISSING FIN"
|
|
D0726: ; no_fin
|
|
DB $0B
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $46,$49,$4E
|
|
; 281: byte no_loop[] = "MISSING LOOP"
|
|
D0738: ; no_loop
|
|
DB $0C
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $4C,$4F,$4F,$50
|
|
; 282: byte no_until[] = "MISSING UNTIL"
|
|
D0751: ; no_until
|
|
DB $0D
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $55,$4E,$54,$49,$4C
|
|
; 283: byte no_done[] = "MISSING DONE"
|
|
D0765: ; no_done
|
|
DB $0C
|
|
DB $4D,$49,$53,$53,$49,$4E,$47,$20
|
|
DB $44,$4F,$4E,$45
|
|
; 284: byte no_local_init[] = "NO INITIALIZED LOCALS"
|
|
D0778: ; no_local_init
|
|
DB $15
|
|
DB $4E,$4F,$20,$49,$4E,$49,$54,$49
|
|
DB $41,$4C,$49,$5A,$45,$44,$20,$4C
|
|
DB $4F,$43,$41,$4C,$53
|
|
; 285: ;
|
|
; 286: ; Runtime functions
|
|
; 287: ;
|
|
; 288: byte runtime0[] = "romcall"
|
|
D0800: ; runtime0
|
|
DB $07
|
|
DB $72,$6F,$6D,$63,$61,$6C,$6C
|
|
; 289: byte RUNTIME0[] = "ROMCALL"
|
|
D0808: ; RUNTIME0
|
|
DB $07
|
|
DB $52,$4F,$4D,$43,$41,$4C,$4C
|
|
; 290: byte runtime1[] = "syscall"
|
|
D0816: ; runtime1
|
|
DB $07
|
|
DB $73,$79,$73,$63,$61,$6C,$6C
|
|
; 291: byte RUNTIME1[] = "SYSCALL"
|
|
D0824: ; RUNTIME1
|
|
DB $07
|
|
DB $53,$59,$53,$43,$41,$4C,$4C
|
|
; 292: byte runtime2[] = "memset"
|
|
D0832: ; runtime2
|
|
DB $06
|
|
DB $6D,$65,$6D,$73,$65,$74
|
|
; 293: byte RUNTIME2[] = "MEMSET"
|
|
D0839: ; RUNTIME2
|
|
DB $06
|
|
DB $4D,$45,$4D,$53,$45,$54
|
|
; 294: byte runtime3[] = "memcpy"
|
|
D0846: ; runtime3
|
|
DB $06
|
|
DB $6D,$65,$6D,$63,$70,$79
|
|
; 295: byte RUNTIME3[] = "MEMCPY"
|
|
D0853: ; RUNTIME3
|
|
DB $06
|
|
DB $4D,$45,$4D,$43,$50,$59
|
|
; 296: byte runtime4[] = "cout"
|
|
D0860: ; runtime4
|
|
DB $04
|
|
DB $63,$6F,$75,$74
|
|
; 297: byte RUNTIME4[] = "COUT"
|
|
D0865: ; RUNTIME4
|
|
DB $04
|
|
DB $43,$4F,$55,$54
|
|
; 298: byte runtime5[] = "cin"
|
|
D0870: ; runtime5
|
|
DB $03
|
|
DB $63,$69,$6E
|
|
; 299: byte RUNTIME5[] = "CIN"
|
|
D0874: ; RUNTIME5
|
|
DB $03
|
|
DB $43,$49,$4E
|
|
; 300: byte runtime6[] = "prstr"
|
|
D0878: ; runtime6
|
|
DB $05
|
|
DB $70,$72,$73,$74,$72
|
|
; 301: byte RUNTIME6[] = "PRSTR"
|
|
D0884: ; RUNTIME6
|
|
DB $05
|
|
DB $50,$52,$53,$54,$52
|
|
; 302: byte runtime7[] = "rdstr"
|
|
D0890: ; runtime7
|
|
DB $05
|
|
DB $72,$64,$73,$74,$72
|
|
; 303: byte RUNTIME7[] = "RDSTR"
|
|
D0896: ; RUNTIME7
|
|
DB $05
|
|
DB $52,$44,$53,$54,$52
|
|
; 304: ;
|
|
; 305: ; Parser variables
|
|
; 306: ;
|
|
; 307: byte infunc = 0
|
|
D0902: ; infunc
|
|
DB $00
|
|
; 308: byte stack_loop = 0
|
|
D0903: ; stack_loop
|
|
DB $00
|
|
; 309: byte prevstmnt = 0
|
|
D0904: ; prevstmnt
|
|
DB $00
|
|
; 310: word retfunc_tag = 0
|
|
D0905: ; retfunc_tag
|
|
DW $0000
|
|
; 311: word break_tag = 0
|
|
D0907: ; break_tag
|
|
DW $0000
|
|
; 312: func parse_expr_01, parse_module_01
|
|
; 313: ;
|
|
; 314: ; Defines for ASM routines
|
|
; 315: ;
|
|
; 316: asm equates
|
|
C0002: ; equates()
|
|
; 317: TMP EQU $F0
|
|
TMP EQU $F0
|
|
; 318: TMPL EQU TMP
|
|
TMPL EQU TMP
|
|
; 319: TMPH EQU TMP+1
|
|
TMPH EQU TMP+1
|
|
; 320: SRC EQU TMP
|
|
SRC EQU TMP
|
|
; 321: SRCL EQU SRC
|
|
SRCL EQU SRC
|
|
; 322: SRCH EQU SRC+1
|
|
SRCH EQU SRC+1
|
|
; 323: DST EQU SRC+2
|
|
DST EQU SRC+2
|
|
; 324: DSTL EQU DST
|
|
DSTL EQU DST
|
|
; 325: DSTH EQU DST+1
|
|
DSTH EQU DST+1
|
|
; 326: ESP EQU DST+2
|
|
ESP EQU DST+2
|
|
; 327: SAVEESP EQU ESP+1
|
|
SAVEESP EQU ESP+1
|
|
; 328: SAVESP EQU SAVEESP+1
|
|
SAVESP EQU SAVEESP+1
|
|
; 329: SAVEFP EQU SAVESP+1
|
|
SAVEFP EQU SAVESP+1
|
|
; 330: SAVETMR EQU SAVEFP+2
|
|
SAVETMR EQU SAVEFP+2
|
|
; 331: SAVEINT EQU SAVETMR+2
|
|
SAVEINT EQU SAVETMR+2
|
|
; 332: TMRVEC EQU $03E8
|
|
TMRVEC EQU $03E8
|
|
; 333: INTVEC EQU $03EA
|
|
INTVEC EQU $03EA
|
|
; 334: JMPTMP: JMP (TMP)
|
|
JMPTMP: JMP (TMP)
|
|
; 335: STKOVFLW:
|
|
STKOVFLW:
|
|
; 336: LDY #$02
|
|
LDY #$02
|
|
; 337: JMP EXECRET
|
|
JMP EXECRET
|
|
; 338: BRKCHK:
|
|
BRKCHK:
|
|
; 339: LDA $C000
|
|
LDA $C000
|
|
; 340: CMP #$83 ; CTRL-C
|
|
CMP #$83 ; CTRL-C
|
|
; 341: BNE :+
|
|
BNE :+
|
|
; 342: BIT $C010
|
|
BIT $C010
|
|
; 343: LDY #$01
|
|
LDY #$01
|
|
; 344: JMP EXECRET
|
|
JMP EXECRET
|
|
; 345: :
|
|
:
|
|
; 346: end
|
|
RTS
|
|
; 347: ;
|
|
; 348: ; CALL 6502 ROUTINE
|
|
; 349: ; ROMCALL(AREG, XREG, YREG, STATUS, ADDR)
|
|
; 350: ;
|
|
; 351: asm romcall
|
|
C0004: ; romcall()
|
|
; 352: PHP
|
|
PHP
|
|
; 353: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 354: STA TMPL
|
|
STA TMPL
|
|
; 355: LDA ESTKH,X
|
|
LDA ESTKH,X
|
|
; 356: STA TMPH
|
|
STA TMPH
|
|
; 357: INX
|
|
INX
|
|
; 358: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 359: PHA
|
|
PHA
|
|
; 360: INX
|
|
INX
|
|
; 361: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 362: TAY
|
|
TAY
|
|
; 363: INX
|
|
INX
|
|
; 364: LDA ESTKL+1,X
|
|
LDA ESTKL+1,X
|
|
; 365: PHA
|
|
PHA
|
|
; 366: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 367: INX
|
|
INX
|
|
; 368: STX ESP
|
|
STX ESP
|
|
; 369: TAX
|
|
TAX
|
|
; 370: PLA
|
|
PLA
|
|
; 371: BIT ROMIN
|
|
BIT ROMIN
|
|
; 372: PLP
|
|
PLP
|
|
; 373: JSR JMPTMP
|
|
JSR JMPTMP
|
|
; 374: PHP
|
|
PHP
|
|
; 375: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 376: STA REGVALS+0
|
|
STA REGVALS+0
|
|
; 377: STX REGVALS+1
|
|
STX REGVALS+1
|
|
; 378: STY REGVALS+2
|
|
STY REGVALS+2
|
|
; 379: PLA
|
|
PLA
|
|
; 380: STA REGVALS+3
|
|
STA REGVALS+3
|
|
; 381: LDX ESP
|
|
LDX ESP
|
|
; 382: LDA #<REGVALS
|
|
LDA #<REGVALS
|
|
; 383: LDY #>REGVALS
|
|
LDY #>REGVALS
|
|
; 384: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 385: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 386: PLP
|
|
PLP
|
|
; 387: RTS
|
|
RTS
|
|
; 388: REGVALS: DS 4
|
|
REGVALS: DS 4
|
|
; 389: end
|
|
RTS
|
|
; 390: ;
|
|
; 391: ; CALL PRODOS
|
|
; 392: ; SYSCALL(CMD, PARAMS)
|
|
; 393: ;
|
|
; 394: asm syscall
|
|
C0006: ; syscall()
|
|
; 395: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 396: LDY ESTKH,X
|
|
LDY ESTKH,X
|
|
; 397: STA PARAMS
|
|
STA PARAMS
|
|
; 398: STY PARAMS+1
|
|
STY PARAMS+1
|
|
; 399: INX
|
|
INX
|
|
; 400: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 401: STA CMD
|
|
STA CMD
|
|
; 402: STX ESP
|
|
STX ESP
|
|
; 403: BIT ROMIN
|
|
BIT ROMIN
|
|
; 404: JSR $BF00
|
|
JSR $BF00
|
|
; 405: CMD: DB 00
|
|
CMD: DB 00
|
|
; 406: PARAMS: DW 0000
|
|
PARAMS: DW 0000
|
|
; 407: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 408: LDX ESP
|
|
LDX ESP
|
|
; 409: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 410: LDY #$00
|
|
LDY #$00
|
|
; 411: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 412: end
|
|
RTS
|
|
; 413: ;
|
|
; 414: ; SET MEMORY TO VALUE
|
|
; 415: ; MEMSET(VALUE, ADDR, SIZE)
|
|
; 416: ;
|
|
; 417: asm memset
|
|
C0008: ; memset()
|
|
; 418: LDY #$00
|
|
LDY #$00
|
|
; 419: LDA ESTKL+1,X
|
|
LDA ESTKL+1,X
|
|
; 420: STA DSTL
|
|
STA DSTL
|
|
; 421: LDA ESTKH+1,X
|
|
LDA ESTKH+1,X
|
|
; 422: STA DSTH
|
|
STA DSTH
|
|
; 423: INC ESTKL,X
|
|
INC ESTKL,X
|
|
; 424: INC ESTKH,X
|
|
INC ESTKH,X
|
|
; 425: SETMEM: DEC ESTKL,X
|
|
SETMEM: DEC ESTKL,X
|
|
; 426: BNE :+
|
|
BNE :+
|
|
; 427: DEC ESTKH,X
|
|
DEC ESTKH,X
|
|
; 428: BEQ MEMEXIT
|
|
BEQ MEMEXIT
|
|
; 429: : LDA ESTKL+2,X
|
|
: LDA ESTKL+2,X
|
|
; 430: STA (DST),Y
|
|
STA (DST),Y
|
|
; 431: INY
|
|
INY
|
|
; 432: BNE :+
|
|
BNE :+
|
|
; 433: INC DSTH
|
|
INC DSTH
|
|
; 434: : DEC ESTKL,X
|
|
: DEC ESTKL,X
|
|
; 435: BNE :+
|
|
BNE :+
|
|
; 436: DEC ESTKH,X
|
|
DEC ESTKH,X
|
|
; 437: BEQ MEMEXIT
|
|
BEQ MEMEXIT
|
|
; 438: : LDA ESTKH+2,X
|
|
: LDA ESTKH+2,X
|
|
; 439: STA (DST),Y
|
|
STA (DST),Y
|
|
; 440: INY
|
|
INY
|
|
; 441: BNE SETMEM
|
|
BNE SETMEM
|
|
; 442: INC DSTH
|
|
INC DSTH
|
|
; 443: BNE SETMEM
|
|
BNE SETMEM
|
|
; 444: MEMEXIT: INX
|
|
MEMEXIT: INX
|
|
; 445: INX
|
|
INX
|
|
; 446: INX
|
|
INX
|
|
; 447: end
|
|
RTS
|
|
; 448: ;
|
|
; 449: ; COPY MEMORY
|
|
; 450: ; MEMCPY(SRCADDR, DSTADDR, SIZE)
|
|
; 451: ;
|
|
; 452: asm memcpy
|
|
C0010: ; memcpy()
|
|
; 453: LDY #$00
|
|
LDY #$00
|
|
; 454: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 455: BNE :+
|
|
BNE :+
|
|
; 456: LDA ESTKH,X
|
|
LDA ESTKH,X
|
|
; 457: BEQ MEMEXIT
|
|
BEQ MEMEXIT
|
|
; 458: : LDA ESTKL+1,X
|
|
: LDA ESTKL+1,X
|
|
; 459: STA DSTL
|
|
STA DSTL
|
|
; 460: LDA ESTKH+1,X
|
|
LDA ESTKH+1,X
|
|
; 461: STA DSTH
|
|
STA DSTH
|
|
; 462: LDA ESTKL+2,X
|
|
LDA ESTKL+2,X
|
|
; 463: STA SRCL
|
|
STA SRCL
|
|
; 464: LDA ESTKH+2,X
|
|
LDA ESTKH+2,X
|
|
; 465: STA SRCH
|
|
STA SRCH
|
|
; 466: CMP DSTH
|
|
CMP DSTH
|
|
; 467: BCC REVCPY
|
|
BCC REVCPY
|
|
; 468: BNE FORCPY
|
|
BNE FORCPY
|
|
; 469: LDA SRCL
|
|
LDA SRCL
|
|
; 470: CMP DSTL
|
|
CMP DSTL
|
|
; 471: BCS FORCPY
|
|
BCS FORCPY
|
|
; 472: REVCPY: ; REVERSE DIRECTION COPY
|
|
REVCPY: ; REVERSE DIRECTION COPY
|
|
; 473: ; CLC
|
|
; 474: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 475: ADC DSTL
|
|
ADC DSTL
|
|
; 476: STA DSTL
|
|
STA DSTL
|
|
; 477: LDA ESTKH,X
|
|
LDA ESTKH,X
|
|
; 478: ADC DSTH
|
|
ADC DSTH
|
|
; 479: STA DSTH
|
|
STA DSTH
|
|
; 480: CLC
|
|
CLC
|
|
; 481: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 482: ADC SRCL
|
|
ADC SRCL
|
|
; 483: STA SRCL
|
|
STA SRCL
|
|
; 484: LDA ESTKH,X
|
|
LDA ESTKH,X
|
|
; 485: ADC SRCH
|
|
ADC SRCH
|
|
; 486: STA SRCH
|
|
STA SRCH
|
|
; 487: INC ESTKH,X
|
|
INC ESTKH,X
|
|
; 488: REVCPYLP:
|
|
REVCPYLP:
|
|
; 489: LDA DSTL
|
|
LDA DSTL
|
|
; 490: BNE :+
|
|
BNE :+
|
|
; 491: DEC DSTH
|
|
DEC DSTH
|
|
; 492: : DEC DSTL
|
|
: DEC DSTL
|
|
; 493: LDA SRCL
|
|
LDA SRCL
|
|
; 494: BNE :+
|
|
BNE :+
|
|
; 495: DEC SRCH
|
|
DEC SRCH
|
|
; 496: : DEC SRCL
|
|
: DEC SRCL
|
|
; 497: LDA (SRC),Y
|
|
LDA (SRC),Y
|
|
; 498: STA (DST),Y
|
|
STA (DST),Y
|
|
; 499: DEC ESTKL,X
|
|
DEC ESTKL,X
|
|
; 500: BNE REVCPYLP
|
|
BNE REVCPYLP
|
|
; 501: DEC ESTKH,X
|
|
DEC ESTKH,X
|
|
; 502: BNE REVCPYLP
|
|
BNE REVCPYLP
|
|
; 503: BEQ MEMEXIT
|
|
BEQ MEMEXIT
|
|
; 504: FORCPY: INC ESTKH,X
|
|
FORCPY: INC ESTKH,X
|
|
; 505: FORCPYLP:
|
|
FORCPYLP:
|
|
; 506: LDA (SRC),Y
|
|
LDA (SRC),Y
|
|
; 507: STA (DST),Y
|
|
STA (DST),Y
|
|
; 508: INC DSTL
|
|
INC DSTL
|
|
; 509: BNE :+
|
|
BNE :+
|
|
; 510: INC DSTH
|
|
INC DSTH
|
|
; 511: : INC SRCL
|
|
: INC SRCL
|
|
; 512: BNE :+
|
|
BNE :+
|
|
; 513: INC SRCH
|
|
INC SRCH
|
|
; 514: : DEC ESTKL,X
|
|
: DEC ESTKL,X
|
|
; 515: BNE FORCPYLP
|
|
BNE FORCPYLP
|
|
; 516: DEC ESTKH,X
|
|
DEC ESTKH,X
|
|
; 517: BNE FORCPYLP
|
|
BNE FORCPYLP
|
|
; 518: BEQ MEMEXIT
|
|
BEQ MEMEXIT
|
|
; 519: end
|
|
RTS
|
|
; 520: ;
|
|
; 521: ; CHAR OUT
|
|
; 522: ; COUT(CHAR)
|
|
; 523: ;
|
|
; 524: asm cout
|
|
C0012: ; cout()
|
|
; 525: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 526: INX
|
|
INX
|
|
; 527: ORA #$80
|
|
ORA #$80
|
|
; 528: BIT ROMIN
|
|
BIT ROMIN
|
|
; 529: JSR $FDED
|
|
JSR $FDED
|
|
; 530: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 531: end
|
|
RTS
|
|
; 532: ;
|
|
; 533: ; CHAR IN
|
|
; 534: ; RDKEY()
|
|
; 535: ;
|
|
; 536: asm cin
|
|
C0014: ; cin()
|
|
; 537: BIT ROMIN
|
|
BIT ROMIN
|
|
; 538: STX ESP
|
|
STX ESP
|
|
; 539: JSR $FD0C
|
|
JSR $FD0C
|
|
; 540: LDX ESP
|
|
LDX ESP
|
|
; 541: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 542: DEX
|
|
DEX
|
|
; 543: AND #$7F
|
|
AND #$7F
|
|
; 544: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 545: LDY #$00
|
|
LDY #$00
|
|
; 546: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 547: end
|
|
RTS
|
|
; 548: ;
|
|
; 549: ; PRINT STRING
|
|
; 550: ; PRSTR(STR)
|
|
; 551: ;
|
|
; 552: asm prstr
|
|
C0016: ; prstr()
|
|
; 553: LDY #$00
|
|
LDY #$00
|
|
; 554: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 555: STA SRCL
|
|
STA SRCL
|
|
; 556: LDA ESTKH,X
|
|
LDA ESTKH,X
|
|
; 557: STA SRCH
|
|
STA SRCH
|
|
; 558: BIT ROMIN
|
|
BIT ROMIN
|
|
; 559: LDA (SRC),Y
|
|
LDA (SRC),Y
|
|
; 560: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 561: BEQ :+
|
|
BEQ :+
|
|
; 562: _PRS1: INY
|
|
_PRS1: INY
|
|
; 563: LDA (SRC),Y
|
|
LDA (SRC),Y
|
|
; 564: ORA #$80
|
|
ORA #$80
|
|
; 565: JSR $FDED
|
|
JSR $FDED
|
|
; 566: TYA
|
|
TYA
|
|
; 567: CMP ESTKL,X
|
|
CMP ESTKL,X
|
|
; 568: BNE _PRS1
|
|
BNE _PRS1
|
|
; 569: : INX
|
|
: INX
|
|
; 570: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 571: end
|
|
RTS
|
|
; 572: ;
|
|
; 573: ; READ STRING
|
|
; 574: ; STR = RDSTR(PROMPTCHAR)
|
|
; 575: ;
|
|
; 576: asm rdstr
|
|
C0018: ; rdstr()
|
|
; 577: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 578: STA $33
|
|
STA $33
|
|
; 579: STX ESP
|
|
STX ESP
|
|
; 580: BIT ROMIN
|
|
BIT ROMIN
|
|
; 581: JSR $FD6A
|
|
JSR $FD6A
|
|
; 582: BIT LCBNK2
|
|
BIT LCBNK2
|
|
; 583: STX $01FF
|
|
STX $01FF
|
|
; 584: : LDA $01FF,X
|
|
: LDA $01FF,X
|
|
; 585: AND #$7F
|
|
AND #$7F
|
|
; 586: STA $01FF,X
|
|
STA $01FF,X
|
|
; 587: DEX
|
|
DEX
|
|
; 588: BPL :-
|
|
BPL :-
|
|
; 589: LDX ESP
|
|
LDX ESP
|
|
; 590: LDA #$FF
|
|
LDA #$FF
|
|
; 591: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 592: LDA #$01
|
|
LDA #$01
|
|
; 593: STA ESTKH,X
|
|
STA ESTKH,X
|
|
; 594: end
|
|
RTS
|
|
; 595: ;def toupper_11(c)
|
|
; 596: ; if c >= 'a'
|
|
; 597: ; if c <= 'z'
|
|
; 598: ; return c - $20
|
|
; 599: ; fin
|
|
; 600: ; fin
|
|
; 601: ; return c
|
|
; 602: ;end
|
|
; 603: asm toupper_11
|
|
C0020: ; toupper_11()
|
|
; 604: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 605: CMP #'a'
|
|
CMP #'a'
|
|
; 606: BCC :+
|
|
BCC :+
|
|
; 607: CMP #'z'+1
|
|
CMP #'z'+1
|
|
; 608: BCS :+
|
|
BCS :+
|
|
; 609: SEC
|
|
SEC
|
|
; 610: SBC #$20
|
|
SBC #$20
|
|
; 611: STA ESTKL,X
|
|
STA ESTKL,X
|
|
; 612: :
|
|
:
|
|
; 613: end
|
|
RTS
|
|
; 614: ;
|
|
; 615: ; EXIT
|
|
; 616: ;
|
|
; 617: asm exit
|
|
C0022: ; exit()
|
|
; 618: JSR $BF00
|
|
JSR $BF00
|
|
; 619: DB $65
|
|
DB $65
|
|
; 620: DW EXITTBL
|
|
DW EXITTBL
|
|
; 621: EXITTBL:
|
|
EXITTBL:
|
|
; 622: DB 4
|
|
DB 4
|
|
; 623: DB 0
|
|
DB 0
|
|
; 624: end
|
|
RTS
|
|
; 625: ;
|
|
; 626: ; ProDOS routines
|
|
; 627: ;
|
|
; 628: def getpfx_11(path)
|
|
C0024: ; getpfx_11()
|
|
; path = 2
|
|
; 629: byte params[3]
|
|
; params = 4
|
|
; 630:
|
|
; 631: ^path = 0
|
|
JSR _INTERP
|
|
DB $58,$07,$01 ; ENTER 7,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 632: params.0 = 1
|
|
DB $28,$04 ; LLA 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 633: params:1 = path
|
|
DB $28,$05 ; LLA 5
|
|
DB $66,$02 ; LLW 2
|
|
DB $72 ; SW
|
|
; 634: perr = syscall($C7, @params)
|
|
DB $2A,$C7 ; CB 199
|
|
DB $28,$04 ; LLA 4
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 635: return path
|
|
DB $66,$02 ; LLW 2
|
|
DB $5A ; LEAVE
|
|
; 636: end
|
|
; 637: def setpfx_11(path)
|
|
C0026: ; setpfx_11()
|
|
; path = 2
|
|
; 638: byte params[3]
|
|
; params = 4
|
|
; 639:
|
|
; 640: params.0 = 1
|
|
JSR _INTERP
|
|
DB $58,$07,$01 ; ENTER 7,1
|
|
DB $28,$04 ; LLA 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 641: params:1 = path
|
|
DB $28,$05 ; LLA 5
|
|
DB $66,$02 ; LLW 2
|
|
DB $72 ; SW
|
|
; 642: perr = syscall($C6, @params)
|
|
DB $2A,$C6 ; CB 198
|
|
DB $28,$04 ; LLA 4
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 643: return path
|
|
DB $66,$02 ; LLW 2
|
|
DB $5A ; LEAVE
|
|
; 644: end
|
|
; 645: def open_21(path, buff)
|
|
C0028: ; open_21()
|
|
; path = 2
|
|
; buff = 4
|
|
; 646: byte params[6]
|
|
; params = 6
|
|
; 647:
|
|
; 648: params.0 = 3
|
|
JSR _INTERP
|
|
DB $58,$0C,$02 ; ENTER 12,2
|
|
DB $28,$06 ; LLA 6
|
|
DB $2A,$03 ; CB 3
|
|
DB $70 ; SB
|
|
; 649: params:1 = path
|
|
DB $28,$07 ; LLA 7
|
|
DB $66,$02 ; LLW 2
|
|
DB $72 ; SW
|
|
; 650: params:3 = buff
|
|
DB $28,$09 ; LLA 9
|
|
DB $66,$04 ; LLW 4
|
|
DB $72 ; SW
|
|
; 651: params.5 = 0
|
|
DB $28,$0B ; LLA 11
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 652: perr = syscall($C8, @params)
|
|
DB $2A,$C8 ; CB 200
|
|
DB $28,$06 ; LLA 6
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 653: return params.5
|
|
DB $28,$0B ; LLA 11
|
|
DB $60 ; LB
|
|
DB $5A ; LEAVE
|
|
; 654: end
|
|
; 655: def close_11(refnum)
|
|
C0030: ; close_11()
|
|
; refnum = 2
|
|
; 656: byte params[2]
|
|
; params = 4
|
|
; 657:
|
|
; 658: params.0 = 1
|
|
JSR _INTERP
|
|
DB $58,$06,$01 ; ENTER 6,1
|
|
DB $28,$04 ; LLA 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 659: params.1 = refnum
|
|
DB $28,$05 ; LLA 5
|
|
DB $66,$02 ; LLW 2
|
|
DB $70 ; SB
|
|
; 660: perr = syscall($CC, @params)
|
|
DB $2A,$CC ; CB 204
|
|
DB $28,$04 ; LLA 4
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 661: return perr
|
|
DB $68,<D0027,>D0027 ; LAB D0027
|
|
DB $5A ; LEAVE
|
|
; 662: end
|
|
; 663: def read_31(refnum, buff, len)
|
|
C0032: ; read_31()
|
|
; refnum = 2
|
|
; buff = 4
|
|
; len = 6
|
|
; 664: byte params[8]
|
|
; params = 8
|
|
; 665:
|
|
; 666: params.0 = 4
|
|
JSR _INTERP
|
|
DB $58,$10,$03 ; ENTER 16,3
|
|
DB $28,$08 ; LLA 8
|
|
DB $2A,$04 ; CB 4
|
|
DB $70 ; SB
|
|
; 667: params.1 = refnum
|
|
DB $28,$09 ; LLA 9
|
|
DB $66,$02 ; LLW 2
|
|
DB $70 ; SB
|
|
; 668: params:2 = buff
|
|
DB $28,$0A ; LLA 10
|
|
DB $66,$04 ; LLW 4
|
|
DB $72 ; SW
|
|
; 669: params:4 = len
|
|
DB $28,$0C ; LLA 12
|
|
DB $66,$06 ; LLW 6
|
|
DB $72 ; SW
|
|
; 670: params:6 = 0
|
|
DB $28,$0E ; LLA 14
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 671: perr = syscall($CA, @params)
|
|
DB $2A,$CA ; CB 202
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 672: return params:6
|
|
DB $28,$0E ; LLA 14
|
|
DB $62 ; LW
|
|
DB $5A ; LEAVE
|
|
; 673: end
|
|
; 674: def write_31(refnum, buff, len)
|
|
C0034: ; write_31()
|
|
; refnum = 2
|
|
; buff = 4
|
|
; len = 6
|
|
; 675: byte params[8]
|
|
; params = 8
|
|
; 676:
|
|
; 677: params.0 = 4
|
|
JSR _INTERP
|
|
DB $58,$10,$03 ; ENTER 16,3
|
|
DB $28,$08 ; LLA 8
|
|
DB $2A,$04 ; CB 4
|
|
DB $70 ; SB
|
|
; 678: params.1 = refnum
|
|
DB $28,$09 ; LLA 9
|
|
DB $66,$02 ; LLW 2
|
|
DB $70 ; SB
|
|
; 679: params:2 = buff
|
|
DB $28,$0A ; LLA 10
|
|
DB $66,$04 ; LLW 4
|
|
DB $72 ; SW
|
|
; 680: params:4 = len
|
|
DB $28,$0C ; LLA 12
|
|
DB $66,$06 ; LLW 6
|
|
DB $72 ; SW
|
|
; 681: params:6 = 0
|
|
DB $28,$0E ; LLA 14
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 682: perr = syscall($CB, @params)
|
|
DB $2A,$CB ; CB 203
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 683: return params:6
|
|
DB $28,$0E ; LLA 14
|
|
DB $62 ; LW
|
|
DB $5A ; LEAVE
|
|
; 684: end
|
|
; 685: def create_41(path, access, type, aux)
|
|
C0036: ; create_41()
|
|
; path = 2
|
|
; access = 4
|
|
; type = 6
|
|
; aux = 8
|
|
; 686: byte params[12]
|
|
; params = 10
|
|
; 687:
|
|
; 688: params.0 = 7
|
|
JSR _INTERP
|
|
DB $58,$16,$04 ; ENTER 22,4
|
|
DB $28,$0A ; LLA 10
|
|
DB $2A,$07 ; CB 7
|
|
DB $70 ; SB
|
|
; 689: params:1 = path
|
|
DB $28,$0B ; LLA 11
|
|
DB $66,$02 ; LLW 2
|
|
DB $72 ; SW
|
|
; 690: params.3 = access
|
|
DB $28,$0D ; LLA 13
|
|
DB $66,$04 ; LLW 4
|
|
DB $70 ; SB
|
|
; 691: params.4 = type
|
|
DB $28,$0E ; LLA 14
|
|
DB $66,$06 ; LLW 6
|
|
DB $70 ; SB
|
|
; 692: params:5 = aux
|
|
DB $28,$0F ; LLA 15
|
|
DB $66,$08 ; LLW 8
|
|
DB $72 ; SW
|
|
; 693: params.7 = $1
|
|
DB $28,$11 ; LLA 17
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 694: params:8 = 0
|
|
DB $28,$12 ; LLA 18
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 695: params:10 = 0
|
|
DB $28,$14 ; LLA 20
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 696: perr = syscall($C0, @params)
|
|
DB $2A,$C0 ; CB 192
|
|
DB $28,$0A ; LLA 10
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 697: return perr
|
|
DB $68,<D0027,>D0027 ; LAB D0027
|
|
DB $5A ; LEAVE
|
|
; 698: end
|
|
; 699: def destroy_11(path)
|
|
C0038: ; destroy_11()
|
|
; path = 2
|
|
; 700: byte params[12]
|
|
; params = 4
|
|
; 701:
|
|
; 702: params.0 = 1
|
|
JSR _INTERP
|
|
DB $58,$10,$01 ; ENTER 16,1
|
|
DB $28,$04 ; LLA 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 703: params:1 = path
|
|
DB $28,$05 ; LLA 5
|
|
DB $66,$02 ; LLW 2
|
|
DB $72 ; SW
|
|
; 704: perr = syscall($C1, @params)
|
|
DB $2A,$C1 ; CB 193
|
|
DB $28,$04 ; LLA 4
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 705: return perr
|
|
DB $68,<D0027,>D0027 ; LAB D0027
|
|
DB $5A ; LEAVE
|
|
; 706: end
|
|
; 707: def newline_31(refnum, emask, nlchar)
|
|
C0040: ; newline_31()
|
|
; refnum = 2
|
|
; emask = 4
|
|
; nlchar = 6
|
|
; 708: byte params[4]
|
|
; params = 8
|
|
; 709:
|
|
; 710: params.0 = 3
|
|
JSR _INTERP
|
|
DB $58,$0C,$03 ; ENTER 12,3
|
|
DB $28,$08 ; LLA 8
|
|
DB $2A,$03 ; CB 3
|
|
DB $70 ; SB
|
|
; 711: params.1 = refnum
|
|
DB $28,$09 ; LLA 9
|
|
DB $66,$02 ; LLW 2
|
|
DB $70 ; SB
|
|
; 712: params.2 = emask
|
|
DB $28,$0A ; LLA 10
|
|
DB $66,$04 ; LLW 4
|
|
DB $70 ; SB
|
|
; 713: params.3 = nlchar
|
|
DB $28,$0B ; LLA 11
|
|
DB $66,$06 ; LLW 6
|
|
DB $70 ; SB
|
|
; 714: perr = syscall($C9, @params)
|
|
DB $2A,$C9 ; CB 201
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0006,>C0006 ; CALL C0006
|
|
DB $78,<D0027,>D0027 ; SAB D0027
|
|
; 715: return perr
|
|
DB $68,<D0027,>D0027 ; LAB D0027
|
|
DB $5A ; LEAVE
|
|
; 716: end
|
|
; 717: def crout
|
|
C0042: ; crout()
|
|
; 718: cout($0D)
|
|
JSR _INTERP
|
|
DB $2A,$0D ; CB 13
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 719: end
|
|
DB $5C ; RET
|
|
; 720: def prbyte_10(h)
|
|
C0044: ; prbyte_10()
|
|
; h = 2
|
|
; 721: cout('$')
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$24 ; CB 36
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 722: drop romcall(h, 0, 0, 0, $FDDA)
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $00 ; ZERO
|
|
DB $00 ; ZERO
|
|
DB $2C,$DA,$FD ; CW 64986
|
|
DB $54,<C0004,>C0004 ; CALL C0004
|
|
DB $30 ; DROP
|
|
; 723: end
|
|
DB $5A ; LEAVE
|
|
; 724: def prword_10(h)
|
|
C0046: ; prword_10()
|
|
; h = 2
|
|
; 725: cout('$')
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$24 ; CB 36
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 726: drop romcall(h >> 8, h, 0, 0, $F941)
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$08 ; CB 8
|
|
DB $1C ; SHR
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $00 ; ZERO
|
|
DB $2C,$41,$F9 ; CW 63809
|
|
DB $54,<C0004,>C0004 ; CALL C0004
|
|
DB $30 ; DROP
|
|
; 727: end
|
|
DB $5A ; LEAVE
|
|
; 728: def print_10(i)
|
|
C0048: ; print_10()
|
|
; i = 2
|
|
; 729: byte numstr[7]
|
|
; numstr = 4
|
|
; 730: byte place, sign
|
|
; place = 11
|
|
; sign = 12
|
|
; 731:
|
|
; 732: place = 6
|
|
JSR _INTERP
|
|
DB $58,$0D,$01 ; ENTER 13,1
|
|
DB $2A,$06 ; CB 6
|
|
DB $74,$0B ; SLB 11
|
|
; 733: if i < 0
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $46 ; ISLT
|
|
DB $4C,<C0050,>C0050 ; SKPFLS C0050
|
|
; 734: sign = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$0C ; SLB 12
|
|
; 735: i = -i
|
|
DB $66,$02 ; LLW 2
|
|
DB $10 ; NEG
|
|
DB $76,$02 ; SLW 2
|
|
; 736: else
|
|
DB $50,<C0051,>C0051 ; SKIP C0051
|
|
C0050:
|
|
; 737: sign = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$0C ; SLB 12
|
|
; 738: fin
|
|
C0051:
|
|
; 739: while i >= 10
|
|
C0052:
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$0A ; CB 10
|
|
DB $48 ; ISGE
|
|
DB $4C,<C0053,>C0053 ; SKPFLS C0053
|
|
; 740: i =, numstr[place] = i % 10 + '0'
|
|
DB $28,$04 ; LLA 4
|
|
DB $64,$0B ; LLB 11
|
|
DB $02 ; IDXB
|
|
DB $34 ; PUSH
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$0A ; CB 10
|
|
DB $0A ; DIV,MOD
|
|
DB $2A,$30 ; CB 48
|
|
DB $02 ; ADD
|
|
DB $36 ; PULL
|
|
DB $2E ; SWAP
|
|
DB $70 ; SB
|
|
DB $76,$02 ; SLW 2
|
|
; 741: place = place - 1
|
|
DB $64,$0B ; LLB 11
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $74,$0B ; SLB 11
|
|
; 742: loop
|
|
DB $50,<C0052,>C0052 ; SKIP C0052
|
|
C0053:
|
|
; 743: numstr[place] = i + '0'
|
|
DB $28,$04 ; LLA 4
|
|
DB $64,$0B ; LLB 11
|
|
DB $02 ; IDXB
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$30 ; CB 48
|
|
DB $02 ; ADD
|
|
DB $70 ; SB
|
|
; 744: place = place - 1
|
|
DB $64,$0B ; LLB 11
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $74,$0B ; SLB 11
|
|
; 745: if sign
|
|
DB $64,$0C ; LLB 12
|
|
DB $4C,<C0054,>C0054 ; SKPFLS C0054
|
|
; 746: numstr[place] = '-'
|
|
DB $28,$04 ; LLA 4
|
|
DB $64,$0B ; LLB 11
|
|
DB $02 ; IDXB
|
|
DB $2A,$2D ; CB 45
|
|
DB $70 ; SB
|
|
; 747: place = place - 1
|
|
DB $64,$0B ; LLB 11
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $74,$0B ; SLB 11
|
|
; 748: fin
|
|
C0054:
|
|
C0055:
|
|
; 749: numstr[place] = 6 - place
|
|
DB $28,$04 ; LLA 4
|
|
DB $64,$0B ; LLB 11
|
|
DB $02 ; IDXB
|
|
DB $2A,$06 ; CB 6
|
|
DB $64,$0B ; LLB 11
|
|
DB $04 ; SUB
|
|
DB $70 ; SB
|
|
; 750: prstr(@numstr[place])
|
|
DB $28,$04 ; LLA 4
|
|
DB $64,$0B ; LLB 11
|
|
DB $02 ; IDXB
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 751: end
|
|
DB $5A ; LEAVE
|
|
; 752: def nametostr_30(namestr, len, strptr)
|
|
C0056: ; nametostr_30()
|
|
; namestr = 2
|
|
; len = 4
|
|
; strptr = 6
|
|
; 753: ^strptr = len
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $66,$06 ; LLW 6
|
|
DB $66,$04 ; LLW 4
|
|
DB $70 ; SB
|
|
; 754: memcpy(namestr, strptr + 1, len)
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$06 ; LLW 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $66,$04 ; LLW 4
|
|
DB $54,<C0010,>C0010 ; CALL C0010
|
|
; 755: end
|
|
DB $5A ; LEAVE
|
|
; 756:
|
|
; 757: ;=====================================
|
|
; 758: ;
|
|
; 759: ; PLASMA Compiler
|
|
; 760: ;
|
|
; 761: ;=====================================
|
|
; 762:
|
|
; 763: ;
|
|
; 764: ; Error handler
|
|
; 765: ;
|
|
; 766: def parse_err_11(err)
|
|
C0058: ; parse_err_11()
|
|
; err = 2
|
|
; 767: word i
|
|
; i = 4
|
|
; 768:
|
|
; 769: drop close_11(0)
|
|
JSR _INTERP
|
|
DB $58,$06,$01 ; ENTER 6,1
|
|
DB $00 ; ZERO
|
|
DB $54,<C0030,>C0030 ; CALL C0030
|
|
DB $30 ; DROP
|
|
; 770: crout()
|
|
DB $54,<C0042,>C0042 ; CALL C0042
|
|
; 771: print_10(lineno)
|
|
DB $6A,<D0372,>D0372 ; LAW D0372
|
|
DB $54,<C0048,>C0048 ; CALL C0048
|
|
; 772: cout(':')
|
|
DB $2A,$3A ; CB 58
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 773: prstr(err)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 774: crout()
|
|
DB $54,<C0042,>C0042 ; CALL C0042
|
|
; 775: prstr(instr)
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 776: crout()
|
|
DB $54,<C0042,>C0042 ; CALL C0042
|
|
; 777: for i = inbuff to tknptr - 1
|
|
DB $2C,$00,$02 ; CW 512
|
|
C0061:
|
|
DB $6E,$04 ; DLW 4
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $3A,<C0060,>C0060 ; SKPGT C0060
|
|
DB $0C ; INCR
|
|
; 778: cout(' ')
|
|
DB $2A,$20 ; CB 32
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 779: next
|
|
DB $50,<C0061,>C0061 ; SKIP C0061
|
|
C0060:
|
|
DB $30 ; DROP
|
|
; 780: cout('^')
|
|
DB $2A,$5E ; CB 94
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 781: cin()
|
|
DB $54,<C0014,>C0014 ; CALL C0014
|
|
; 782: exit()
|
|
DB $54,<C0022,>C0022 ; CALL C0022
|
|
; 783: return ERR_TKN
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 784: end
|
|
; 785: ;
|
|
; 786: ; Fixup table and function directory
|
|
; 787: ;
|
|
; 788: def fixupword_add10(addr)
|
|
C0062: ; fixupword_add10()
|
|
; addr = 2
|
|
; 789: end
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $5A ; LEAVE
|
|
; 790: def fixupbyte_add10(addr)
|
|
C0064: ; fixupbyte_add10()
|
|
; addr = 2
|
|
; 791: end
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $5A ; LEAVE
|
|
; 792: def func_add(offset, len, flags)
|
|
C0066: ; func_add()
|
|
; offset = 2
|
|
; len = 4
|
|
; flags = 6
|
|
; 793: end
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $5A ; LEAVE
|
|
; 794: ;
|
|
; 795: ; Emit bytecode
|
|
; 796: ;
|
|
; 797: def ctag_new_01
|
|
C0068: ; ctag_new_01()
|
|
; 798: if codetag >= ctag_max
|
|
JSR _INTERP
|
|
DB $6A,<D0020,>D0020 ; LAW D0020
|
|
DB $2C,$00,$03 ; CW 768
|
|
DB $48 ; ISGE
|
|
DB $4C,<C0070,>C0070 ; SKPFLS C0070
|
|
; 799: return parse_err_11(@ctag_full)
|
|
DB $26,<D0644,>D0644 ; LA D0644
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5C ; RET
|
|
; 800: fin
|
|
C0070:
|
|
C0071:
|
|
; 801: codetag = codetag + 1
|
|
DB $6A,<D0020,>D0020 ; LAW D0020
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $7A,<D0020,>D0020 ; SAW D0020
|
|
; 802: ctag_value:[codetag] = 0
|
|
DB $2C,$00,$1A ; CW 6656
|
|
DB $6A,<D0020,>D0020 ; LAW D0020
|
|
DB $1E ; IDXW
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 803: ctag_flags.[codetag] = 0
|
|
DB $2C,$00,$0D ; CW 3328
|
|
DB $6A,<D0020,>D0020 ; LAW D0020
|
|
DB $02 ; IDXB
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 804: return codetag ? is_ctag
|
|
DB $6A,<D0020,>D0020 ; LAW D0020
|
|
DB $2C,$00,$80 ; CW 32768
|
|
DB $16 ; IOR
|
|
DB $5C ; RET
|
|
; 805: end
|
|
; 806: defopt ctag_resolve_21(tag, addr)
|
|
C0072: ; ctag_resolve_21()
|
|
; tag = 2
|
|
; addr = 4
|
|
; 807: word updtptr, nextptr
|
|
; updtptr = 6
|
|
; nextptr = 8
|
|
; 808:
|
|
; 809: tag = tag & mask_ctag
|
|
LDY #10
|
|
LDA #2
|
|
JSR ENTER
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$FF
|
|
STA ESTKL,X
|
|
LDA #$7F
|
|
STA ESTKH,X
|
|
JSR BAND
|
|
LDY #$02
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 810: if ctag_flags.[tag] & resolved
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
LDA #$0D
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JSR ADD
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR BAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0074
|
|
:
|
|
; 811: return parse_err_11(@dup_id)
|
|
DEX
|
|
LDA #<D0382
|
|
STA ESTKL,X
|
|
LDA #>D0382
|
|
STA ESTKH,X
|
|
JSR C0058
|
|
JMP LEAVE
|
|
; 812: fin
|
|
C0074:
|
|
C0075:
|
|
; 813: updtptr = ctag_value:[tag]
|
|
DEX
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
LDA #$1A
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JSR IDXW
|
|
LDY #$00
|
|
JSR LW
|
|
LDY #$06
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 814: while updtptr
|
|
INX
|
|
C0076:
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0077
|
|
:
|
|
; 815: ;
|
|
; 816: ; Update list of addresses needing resolution
|
|
; 817: ;
|
|
; 818: nextptr = *updtptr
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LW
|
|
LDY #$08
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 819: *updtptr = addr
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR SW
|
|
; 820: updtptr = nextptr
|
|
DEX
|
|
LDY #$08
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$06
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 821: loop
|
|
INX
|
|
JMP C0076
|
|
C0077:
|
|
; 822: ctag_value:[tag] = addr
|
|
DEX
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
LDA #$1A
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JSR IDXW
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR SW
|
|
; 823: ctag_flags.[tag] = ctag_flags.[tag] ? resolved
|
|
DEX
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
LDA #$0D
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JSR ADD
|
|
DEX
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
LDA #$0D
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JSR ADD
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR IOR
|
|
JSR SB
|
|
; 824: return 0
|
|
DEX
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
JMP LEAVE
|
|
; 825: end
|
|
; 826: defopt emit_byte_10(bval)
|
|
C0078: ; emit_byte_10()
|
|
; bval = 2
|
|
; 827: ^codeptr = bval
|
|
LDY #4
|
|
LDA #1
|
|
JSR ENTER
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR SB
|
|
; 828: codeptr = codeptr + 1
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 829: end
|
|
INX
|
|
JMP LEAVE
|
|
; 830: defopt emit_word_10(wval)
|
|
C0080: ; emit_word_10()
|
|
; wval = 2
|
|
; 831: *codeptr = wval
|
|
LDY #4
|
|
LDA #1
|
|
JSR ENTER
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR SW
|
|
; 832: codeptr = codeptr + 2
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 833: end
|
|
INX
|
|
JMP LEAVE
|
|
; 834: def emit_fill_10(size)
|
|
C0082: ; emit_fill_10()
|
|
; size = 2
|
|
; 835: memset(0, codeptr, size)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $00 ; ZERO
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0008,>C0008 ; CALL C0008
|
|
; 836: codeptr = codeptr + size
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $66,$02 ; LLW 2
|
|
DB $02 ; ADD
|
|
DB $7A,<D0022,>D0022 ; SAW D0022
|
|
; 837: end
|
|
DB $5A ; LEAVE
|
|
; 838: def emit_codetag_10(tag)
|
|
C0084: ; emit_codetag_10()
|
|
; tag = 2
|
|
; 839: drop ctag_resolve_21(tag, codeptr)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 840: end
|
|
DB $5A ; LEAVE
|
|
; 841: defopt emit_op_10(op)
|
|
C0086: ; emit_op_10()
|
|
; op = 2
|
|
; 842: lastop = op
|
|
LDY #4
|
|
LDA #1
|
|
JSR ENTER
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0026
|
|
; 843: ^codeptr = op
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR SB
|
|
; 844: codeptr = codeptr + 1
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 845: end
|
|
INX
|
|
JMP LEAVE
|
|
; 846: def emit_tag_10(tag)
|
|
C0088: ; emit_tag_10()
|
|
; tag = 2
|
|
; 847: word updtptr
|
|
; updtptr = 4
|
|
; 848:
|
|
; 849: if tag & is_ctag
|
|
JSR _INTERP
|
|
DB $58,$06,$01 ; ENTER 6,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $2C,$00,$80 ; CW 32768
|
|
DB $14 ; BAND
|
|
DB $4C,<C0090,>C0090 ; SKPFLS C0090
|
|
; 850: tag = tag & mask_ctag
|
|
DB $66,$02 ; LLW 2
|
|
DB $2C,$FF,$7F ; CW 32767
|
|
DB $14 ; BAND
|
|
DB $76,$02 ; SLW 2
|
|
; 851: updtptr = ctag_value:[tag]
|
|
DB $2C,$00,$1A ; CW 6656
|
|
DB $66,$02 ; LLW 2
|
|
DB $1E ; IDXW
|
|
DB $62 ; LW
|
|
DB $76,$04 ; SLW 4
|
|
; 852: if !(ctag_flags.[tag] & resolved)
|
|
DB $2C,$00,$0D ; CW 3328
|
|
DB $66,$02 ; LLW 2
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $20 ; NOT
|
|
DB $4C,<C0092,>C0092 ; SKPFLS C0092
|
|
; 853: ;
|
|
; 854: ; Add to list of tags needing resolution
|
|
; 855: ;
|
|
; 856: ctag_value:[tag] = codeptr
|
|
DB $2C,$00,$1A ; CW 6656
|
|
DB $66,$02 ; LLW 2
|
|
DB $1E ; IDXW
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $72 ; SW
|
|
; 857: fin
|
|
C0092:
|
|
C0093:
|
|
; 858: emit_word_10(updtptr)
|
|
DB $66,$04 ; LLW 4
|
|
DB $54,<C0080,>C0080 ; CALL C0080
|
|
; 859: else
|
|
DB $50,<C0091,>C0091 ; SKIP C0091
|
|
C0090:
|
|
; 860: emit_word_10(tag + compbuff)
|
|
DB $66,$02 ; LLW 2
|
|
DB $2C,$00,$60 ; CW 24576
|
|
DB $02 ; ADD
|
|
DB $54,<C0080,>C0080 ; CALL C0080
|
|
; 861: fin
|
|
C0091:
|
|
; 862: end
|
|
DB $5A ; LEAVE
|
|
; 863: def emit_iddata_30(value, size, namestr)
|
|
C0094: ; emit_iddata_30()
|
|
; value = 2
|
|
; size = 4
|
|
; namestr = 6
|
|
; 864: emit_fill_10(size)
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $66,$04 ; LLW 4
|
|
DB $54,<C0082,>C0082 ; CALL C0082
|
|
; 865: end
|
|
DB $5A ; LEAVE
|
|
; 866: def emit_data_41(vartype, consttype, constval, constsize)
|
|
C0096: ; emit_data_41()
|
|
; vartype = 2
|
|
; consttype = 4
|
|
; constval = 6
|
|
; constsize = 8
|
|
; 867: byte i
|
|
; i = 10
|
|
; 868: word size, chrptr
|
|
; size = 11
|
|
; chrptr = 13
|
|
; 869:
|
|
; 870: if consttype == 0
|
|
JSR _INTERP
|
|
DB $58,$0F,$04 ; ENTER 15,4
|
|
DB $66,$04 ; LLW 4
|
|
DB $00 ; ZERO
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0098,>C0098 ; SKPFLS C0098
|
|
; 871: size = constsize
|
|
DB $66,$08 ; LLW 8
|
|
DB $76,$0B ; SLW 11
|
|
; 872: emit_fill_10(constsize)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0082,>C0082 ; CALL C0082
|
|
; 873: elsif consttype == STR_TYPE
|
|
DB $50,<C0099,>C0099 ; SKIP C0099
|
|
C0098:
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$80 ; CB 128
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0100,>C0100 ; SKPFLS C0100
|
|
; 874: size = constsize
|
|
DB $66,$08 ; LLW 8
|
|
DB $76,$0B ; SLW 11
|
|
; 875: chrptr = constval
|
|
DB $66,$06 ; LLW 6
|
|
DB $76,$0D ; SLW 13
|
|
; 876: constsize = constsize - 1
|
|
DB $66,$08 ; LLW 8
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $76,$08 ; SLW 8
|
|
; 877: emit_byte_10(constsize)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 878: while constsize > 0
|
|
C0101:
|
|
DB $66,$08 ; LLW 8
|
|
DB $00 ; ZERO
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0102,>C0102 ; SKPFLS C0102
|
|
; 879: emit_byte_10(^chrptr)
|
|
DB $66,$0D ; LLW 13
|
|
DB $60 ; LB
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 880: chrptr = chrptr + 1
|
|
DB $66,$0D ; LLW 13
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $76,$0D ; SLW 13
|
|
; 881: constsize = constsize - 1
|
|
DB $66,$08 ; LLW 8
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $76,$08 ; SLW 8
|
|
; 882: loop
|
|
DB $50,<C0101,>C0101 ; SKIP C0101
|
|
C0102:
|
|
; 883: else
|
|
DB $50,<C0099,>C0099 ; SKIP C0099
|
|
C0100:
|
|
; 884: if vartype == WORD_TYPE
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$04 ; CB 4
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0103,>C0103 ; SKPFLS C0103
|
|
; 885: size = 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $76,$0B ; SLW 11
|
|
; 886: emit_word_10(constval)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0080,>C0080 ; CALL C0080
|
|
; 887: else
|
|
DB $50,<C0104,>C0104 ; SKIP C0104
|
|
C0103:
|
|
; 888: size = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $76,$0B ; SLW 11
|
|
; 889: emit_byte_10(constval)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 890: fin
|
|
C0104:
|
|
; 891: fin
|
|
C0099:
|
|
; 892: return size
|
|
DB $66,$0B ; LLW 11
|
|
DB $5A ; LEAVE
|
|
; 893: end
|
|
; 894: def emit_const_10(cval)
|
|
C0105: ; emit_const_10()
|
|
; cval = 2
|
|
; 895: if cval == 0
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0107,>C0107 ; SKPFLS C0107
|
|
; 896: emit_op_10($00)
|
|
DB $00 ; ZERO
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 897: elsif cval > 0 and cval < 256
|
|
DB $50,<C0108,>C0108 ; SKIP C0108
|
|
C0107:
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $44 ; ISGT
|
|
DB $66,$02 ; LLW 2
|
|
DB $2C,$00,$01 ; CW 256
|
|
DB $46 ; ISLT
|
|
DB $24 ; LAND
|
|
DB $4C,<C0109,>C0109 ; SKPFLS C0109
|
|
; 898: emit_op_10($2A)
|
|
DB $2A,$2A ; CB 42
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 899: emit_byte_10(cval)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 900: else
|
|
DB $50,<C0108,>C0108 ; SKIP C0108
|
|
C0109:
|
|
; 901: emit_op_10($2C)
|
|
DB $2A,$2C ; CB 44
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 902: emit_word_10(cval)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0080,>C0080 ; CALL C0080
|
|
; 903: fin
|
|
C0108:
|
|
; 904: end
|
|
DB $5A ; LEAVE
|
|
; 905: def emit_lb
|
|
C0110: ; emit_lb()
|
|
; 906: emit_op_10($60)
|
|
JSR _INTERP
|
|
DB $2A,$60 ; CB 96
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 907: end
|
|
DB $5C ; RET
|
|
; 908: def emit_lw
|
|
C0112: ; emit_lw()
|
|
; 909: emit_op_10($62)
|
|
JSR _INTERP
|
|
DB $2A,$62 ; CB 98
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 910: end
|
|
DB $5C ; RET
|
|
; 911: def emit_llb_10(index)
|
|
C0114: ; emit_llb_10()
|
|
; index = 2
|
|
; 912: emit_op_10($64)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$64 ; CB 100
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 913: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 914: end
|
|
DB $5A ; LEAVE
|
|
; 915: def emit_llw_10(index)
|
|
C0116: ; emit_llw_10()
|
|
; index = 2
|
|
; 916: emit_op_10($66)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$66 ; CB 102
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 917: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 918: end
|
|
DB $5A ; LEAVE
|
|
; 919: def emit_lab_10(tag)
|
|
C0118: ; emit_lab_10()
|
|
; tag = 2
|
|
; 920: emit_op_10($68)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$68 ; CB 104
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 921: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 922: end
|
|
DB $5A ; LEAVE
|
|
; 923: def emit_law_10(tag)
|
|
C0120: ; emit_law_10()
|
|
; tag = 2
|
|
; 924: emit_op_10($6A)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$6A ; CB 106
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 925: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 926: end
|
|
DB $5A ; LEAVE
|
|
; 927: def emit_sb
|
|
C0122: ; emit_sb()
|
|
; 928: emit_op_10($70)
|
|
JSR _INTERP
|
|
DB $2A,$70 ; CB 112
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 929: end
|
|
DB $5C ; RET
|
|
; 930: def emit_sw
|
|
C0124: ; emit_sw()
|
|
; 931: emit_op_10($72)
|
|
JSR _INTERP
|
|
DB $2A,$72 ; CB 114
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 932: end
|
|
DB $5C ; RET
|
|
; 933: def emit_slb_10(index)
|
|
C0126: ; emit_slb_10()
|
|
; index = 2
|
|
; 934: emit_op_10($74)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$74 ; CB 116
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 935: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 936: end
|
|
DB $5A ; LEAVE
|
|
; 937: def emit_slw_10(index)
|
|
C0128: ; emit_slw_10()
|
|
; index = 2
|
|
; 938: emit_op_10($76)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$76 ; CB 118
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 939: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 940: end
|
|
DB $5A ; LEAVE
|
|
; 941: def emit_dlb_10(index)
|
|
C0130: ; emit_dlb_10()
|
|
; index = 2
|
|
; 942: emit_op_10($6C)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$6C ; CB 108
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 943: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 944: end
|
|
DB $5A ; LEAVE
|
|
; 945: def emit_dlw_10(index)
|
|
C0132: ; emit_dlw_10()
|
|
; index = 2
|
|
; 946: emit_op_10($6E)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$6E ; CB 110
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 947: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 948: end
|
|
DB $5A ; LEAVE
|
|
; 949: def emit_sab_10(tag)
|
|
C0134: ; emit_sab_10()
|
|
; tag = 2
|
|
; 950: emit_op_10($78)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$78 ; CB 120
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 951: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 952: end
|
|
DB $5A ; LEAVE
|
|
; 953: def emit_saw_10(tag)
|
|
C0136: ; emit_saw_10()
|
|
; tag = 2
|
|
; 954: emit_op_10($7A)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$7A ; CB 122
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 955: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 956: end
|
|
DB $5A ; LEAVE
|
|
; 957: def emit_dab_10(tag)
|
|
C0138: ; emit_dab_10()
|
|
; tag = 2
|
|
; 958: emit_op_10($7C)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$7C ; CB 124
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 959: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 960: end
|
|
DB $5A ; LEAVE
|
|
; 961: def emit_daw_10(tag)
|
|
C0140: ; emit_daw_10()
|
|
; tag = 2
|
|
; 962: emit_op_10($7E)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$7E ; CB 126
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 963: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 964: end
|
|
DB $5A ; LEAVE
|
|
; 965: def emit_call_10(tag)
|
|
C0142: ; emit_call_10()
|
|
; tag = 2
|
|
; 966: emit_op_10($54)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$54 ; CB 84
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 967: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 968: end
|
|
DB $5A ; LEAVE
|
|
; 969: def emit_ical
|
|
C0144: ; emit_ical()
|
|
; 970: emit_op_10($56)
|
|
JSR _INTERP
|
|
DB $2A,$56 ; CB 86
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 971: end
|
|
DB $5C ; RET
|
|
; 972: def emit_push
|
|
C0146: ; emit_push()
|
|
; 973: emit_op_10($34)
|
|
JSR _INTERP
|
|
DB $2A,$34 ; CB 52
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 974: end
|
|
DB $5C ; RET
|
|
; 975: def emit_pull
|
|
C0148: ; emit_pull()
|
|
; 976: ;
|
|
; 977: ; Skip if last op was push
|
|
; 978: ;
|
|
; 979: if lastop == $34
|
|
JSR _INTERP
|
|
DB $68,<D0026,>D0026 ; LAB D0026
|
|
DB $2A,$34 ; CB 52
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0150,>C0150 ; SKPFLS C0150
|
|
; 980: codeptr = codeptr - 1
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $7A,<D0022,>D0022 ; SAW D0022
|
|
; 981: lastop = $FF
|
|
DB $2A,$FF ; CB 255
|
|
DB $78,<D0026,>D0026 ; SAB D0026
|
|
; 982: else
|
|
DB $50,<C0151,>C0151 ; SKIP C0151
|
|
C0150:
|
|
; 983: emit_op_10($36)
|
|
DB $2A,$36 ; CB 54
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 984: fin
|
|
C0151:
|
|
; 985: end
|
|
DB $5C ; RET
|
|
; 986: def emit_localaddr_10(index)
|
|
C0152: ; emit_localaddr_10()
|
|
; index = 2
|
|
; 987: emit_op_10($28)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$28 ; CB 40
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 988: emit_byte_10(index)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 989: end
|
|
DB $5A ; LEAVE
|
|
; 990: def emit_globaladdr_10(tag)
|
|
C0154: ; emit_globaladdr_10()
|
|
; tag = 2
|
|
; 991: emit_op_10($26)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$26 ; CB 38
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 992: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 993: end
|
|
DB $5A ; LEAVE
|
|
; 994: def emit_indexbyte
|
|
C0156: ; emit_indexbyte()
|
|
; 995: emit_op_10($02)
|
|
JSR _INTERP
|
|
DB $2A,$02 ; CB 2
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 996: end
|
|
DB $5C ; RET
|
|
; 997: def emit_indexword
|
|
C0158: ; emit_indexword()
|
|
; 998: emit_op_10($1E)
|
|
JSR _INTERP
|
|
DB $2A,$1E ; CB 30
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 999: end
|
|
DB $5C ; RET
|
|
; 1000: defopt emit_unaryop_11(op)
|
|
C0160: ; emit_unaryop_11()
|
|
; op = 2
|
|
; 1001: when op
|
|
LDY #4
|
|
LDA #1
|
|
JSR ENTER
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
; 1002: is NEG_TKN
|
|
DEX
|
|
LDA #$AD
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0163
|
|
:
|
|
; 1003: emit_op_10($10)
|
|
DEX
|
|
LDA #$10
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1004: is COMP_TKN
|
|
JMP C0162
|
|
C0163:
|
|
DEX
|
|
LDA #$A3
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0164
|
|
:
|
|
; 1005: emit_op_10($12)
|
|
DEX
|
|
LDA #$12
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1006: is LOGIC_NOT_TKN
|
|
JMP C0162
|
|
C0164:
|
|
DEX
|
|
LDA #$A1
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0165
|
|
:
|
|
; 1007: emit_op_10($20)
|
|
DEX
|
|
LDA #$20
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1008: is INC_TKN
|
|
JMP C0162
|
|
C0165:
|
|
DEX
|
|
LDA #$C1
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0166
|
|
:
|
|
; 1009: emit_op_10($0C)
|
|
DEX
|
|
LDA #$0C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1010: is DEC_TKN
|
|
JMP C0162
|
|
C0166:
|
|
DEX
|
|
LDA #$C4
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0167
|
|
:
|
|
; 1011: emit_op_10($0E)
|
|
DEX
|
|
LDA #$0E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1012: is BPTR_TKN
|
|
JMP C0162
|
|
C0167:
|
|
DEX
|
|
LDA #$DE
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0168
|
|
:
|
|
; 1013: emit_op_10($60)
|
|
DEX
|
|
LDA #$60
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1014: is WPTR_TKN
|
|
JMP C0162
|
|
C0168:
|
|
DEX
|
|
LDA #$AA
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0169
|
|
:
|
|
; 1015: emit_op_10($62)
|
|
DEX
|
|
LDA #$62
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1016: otherwise
|
|
JMP C0162
|
|
C0169:
|
|
; 1017: return FALSE
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
JMP LEAVE
|
|
; 1018: wend
|
|
C0162:
|
|
; 1019: return TRUE
|
|
LDA #$FF
|
|
STA ESTKL,X
|
|
STA ESTKH,X
|
|
JMP LEAVE
|
|
; 1020: end
|
|
; 1021: defopt emit_binaryop_11(op)
|
|
C0171: ; emit_binaryop_11()
|
|
; op = 2
|
|
; 1022: when op
|
|
LDY #4
|
|
LDA #1
|
|
JSR ENTER
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
; 1023: is MUL_TKN
|
|
DEX
|
|
LDA #$AA
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0174
|
|
:
|
|
; 1024: ;
|
|
; 1025: ; Replace MUL 2 with SHL 1
|
|
; 1026: ;
|
|
; 1027: if lastop == $2A and ^(codeptr - 1) == 2 ; CB 2
|
|
DEX
|
|
LDA D0026
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$2A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR LB
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0175
|
|
:
|
|
; 1028: codeptr = codeptr - 1
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 1029: emit_byte_10(1) ; CB 1
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0078
|
|
; 1030: emit_op_10($1A) ; SHL
|
|
DEX
|
|
LDA #$1A
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1031: else
|
|
JMP C0176
|
|
C0175:
|
|
; 1032: emit_op_10($06)
|
|
DEX
|
|
LDA #$06
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1033: fin
|
|
C0176:
|
|
; 1034: is DIV_TKN
|
|
JMP C0173
|
|
C0174:
|
|
DEX
|
|
LDA #$AF
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0177
|
|
:
|
|
; 1035: ;
|
|
; 1036: ; Replace DIV 2 with SHR 1
|
|
; 1037: ;
|
|
; 1038: if lastop == $2A and ^(codeptr - 1) == 2 ; CB 2
|
|
DEX
|
|
LDA D0026
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$2A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR LB
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0178
|
|
:
|
|
; 1039: codeptr = codeptr - 1
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 1040: emit_byte_10(1) ; CB 1
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0078
|
|
; 1041: emit_op_10($1C) ; SHR
|
|
DEX
|
|
LDA #$1C
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1042: else
|
|
JMP C0179
|
|
C0178:
|
|
; 1043: emit_op_10($08)
|
|
DEX
|
|
LDA #$08
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1044: fin
|
|
C0179:
|
|
; 1045: is MOD_TKN
|
|
JMP C0173
|
|
C0177:
|
|
DEX
|
|
LDA #$A5
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0180
|
|
:
|
|
; 1046: emit_op_10($0A)
|
|
DEX
|
|
LDA #$0A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1047: is ADD_TKN
|
|
JMP C0173
|
|
C0180:
|
|
DEX
|
|
LDA #$AB
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0181
|
|
:
|
|
; 1048: ;
|
|
; 1049: ; Replace ADD 1 with INCR
|
|
; 1050: ;
|
|
; 1051: if lastop == $2A and ^(codeptr - 1) == 1 ; CB 1
|
|
DEX
|
|
LDA D0026
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$2A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR LB
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0182
|
|
:
|
|
; 1052: codeptr = codeptr - 2
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 1053: emit_op_10($0C) ; INC_OP
|
|
LDA #$0C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1054: else
|
|
JMP C0183
|
|
C0182:
|
|
; 1055: emit_op_10($02)
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1056: fin
|
|
C0183:
|
|
; 1057: is SUB_TKN
|
|
JMP C0173
|
|
C0181:
|
|
DEX
|
|
LDA #$AD
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0184
|
|
:
|
|
; 1058: ;
|
|
; 1059: ; Replace SUB 1 with DECR
|
|
; 1060: ;
|
|
; 1061: if lastop == $2A and ^(codeptr - 1) == 1 ; CB 1
|
|
DEX
|
|
LDA D0026
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$2A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR LB
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0185
|
|
:
|
|
; 1062: codeptr = codeptr - 2
|
|
DEX
|
|
LDA D0022
|
|
STA ESTKL,X
|
|
LDA D0022+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0022
|
|
LDA ESTKH,X
|
|
STA D0022+1
|
|
; 1063: emit_op_10($0E) ; DEC_OP
|
|
LDA #$0E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1064: else
|
|
JMP C0186
|
|
C0185:
|
|
; 1065: emit_op_10($04)
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1066: fin
|
|
C0186:
|
|
; 1067: is SHL_TKN
|
|
JMP C0173
|
|
C0184:
|
|
DEX
|
|
LDA #$CC
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0187
|
|
:
|
|
; 1068: emit_op_10($1A)
|
|
DEX
|
|
LDA #$1A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1069: is SHR_TKN
|
|
JMP C0173
|
|
C0187:
|
|
DEX
|
|
LDA #$D2
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0188
|
|
:
|
|
; 1070: emit_op_10($1C)
|
|
DEX
|
|
LDA #$1C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1071: is AND_TKN
|
|
JMP C0173
|
|
C0188:
|
|
DEX
|
|
LDA #$A6
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0189
|
|
:
|
|
; 1072: emit_op_10($14)
|
|
DEX
|
|
LDA #$14
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1073: is OR_TKN
|
|
JMP C0173
|
|
C0189:
|
|
DEX
|
|
LDA #$BF
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0190
|
|
:
|
|
; 1074: emit_op_10($16)
|
|
DEX
|
|
LDA #$16
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1075: is EOR_TKN
|
|
JMP C0173
|
|
C0190:
|
|
DEX
|
|
LDA #$DE
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0191
|
|
:
|
|
; 1076: emit_op_10($18)
|
|
DEX
|
|
LDA #$18
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1077: is EQ_TKN
|
|
JMP C0173
|
|
C0191:
|
|
DEX
|
|
LDA #$C5
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0192
|
|
:
|
|
; 1078: emit_op_10($40)
|
|
DEX
|
|
LDA #$40
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1079: is NE_TKN
|
|
JMP C0173
|
|
C0192:
|
|
DEX
|
|
LDA #$D5
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0193
|
|
:
|
|
; 1080: emit_op_10($42)
|
|
DEX
|
|
LDA #$42
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1081: is GE_TKN
|
|
JMP C0173
|
|
C0193:
|
|
DEX
|
|
LDA #$C8
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0194
|
|
:
|
|
; 1082: emit_op_10($48)
|
|
DEX
|
|
LDA #$48
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1083: is LT_TKN
|
|
JMP C0173
|
|
C0194:
|
|
DEX
|
|
LDA #$BC
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0195
|
|
:
|
|
; 1084: emit_op_10($46)
|
|
DEX
|
|
LDA #$46
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1085: is GT_TKN
|
|
JMP C0173
|
|
C0195:
|
|
DEX
|
|
LDA #$BE
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0196
|
|
:
|
|
; 1086: emit_op_10($44)
|
|
DEX
|
|
LDA #$44
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1087: is LE_TKN
|
|
JMP C0173
|
|
C0196:
|
|
DEX
|
|
LDA #$C2
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0197
|
|
:
|
|
; 1088: emit_op_10($4A)
|
|
DEX
|
|
LDA #$4A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1089: is LOGIC_OR_TKN
|
|
JMP C0173
|
|
C0197:
|
|
DEX
|
|
LDA #$CF
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0198
|
|
:
|
|
; 1090: emit_op_10($22)
|
|
DEX
|
|
LDA #$22
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1091: is LOGIC_AND_TKN
|
|
JMP C0173
|
|
C0198:
|
|
DEX
|
|
LDA #$CE
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0199
|
|
:
|
|
; 1092: emit_op_10($24)
|
|
DEX
|
|
LDA #$24
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR C0086
|
|
; 1093: is COMMA_TKN
|
|
JMP C0173
|
|
C0199:
|
|
DEX
|
|
LDA #$AC
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0200
|
|
:
|
|
; 1094: ; Do nothing except move to next stanza in expression
|
|
; 1095: otherwise
|
|
JMP C0173
|
|
C0200:
|
|
; 1096: return FALSE
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
JMP LEAVE
|
|
; 1097: wend
|
|
C0173:
|
|
; 1098: return TRUE
|
|
LDA #$FF
|
|
STA ESTKL,X
|
|
STA ESTKH,X
|
|
JMP LEAVE
|
|
; 1099: end
|
|
; 1100: def emit_brtru_10(tag)
|
|
C0202: ; emit_brtru_10()
|
|
; tag = 2
|
|
; 1101: emit_op_10($4E)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$4E ; CB 78
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1102: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1103: end
|
|
DB $5A ; LEAVE
|
|
; 1104: def emit_brfls_10(tag)
|
|
C0204: ; emit_brfls_10()
|
|
; tag = 2
|
|
; 1105: emit_op_10($4C)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$4C ; CB 76
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1106: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1107: end
|
|
DB $5A ; LEAVE
|
|
; 1108: def emit_brgt_10(tag)
|
|
C0206: ; emit_brgt_10()
|
|
; tag = 2
|
|
; 1109: emit_op_10($3A)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$3A ; CB 58
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1110: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1111: end
|
|
DB $5A ; LEAVE
|
|
; 1112: def emit_brlt_10(tag)
|
|
C0208: ; emit_brlt_10()
|
|
; tag = 2
|
|
; 1113: emit_op_10($38)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$38 ; CB 56
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1114: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1115: end
|
|
DB $5A ; LEAVE
|
|
; 1116: def emit_brne_10(tag)
|
|
C0210: ; emit_brne_10()
|
|
; tag = 2
|
|
; 1117: emit_op_10($3E)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$3E ; CB 62
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1118: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1119: end
|
|
DB $5A ; LEAVE
|
|
; 1120: def emit_jump_10(tag)
|
|
C0212: ; emit_jump_10()
|
|
; tag = 2
|
|
; 1121: emit_op_10($50)
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $2A,$50 ; CB 80
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1122: emit_tag_10(tag)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0088,>C0088 ; CALL C0088
|
|
; 1123: end
|
|
DB $5A ; LEAVE
|
|
; 1124: def emit_drop
|
|
C0214: ; emit_drop()
|
|
; 1125: emit_op_10($30)
|
|
JSR _INTERP
|
|
DB $2A,$30 ; CB 48
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1126: end
|
|
DB $5C ; RET
|
|
; 1127: def emit_swap
|
|
C0216: ; emit_swap()
|
|
; 1128: emit_op_10($2E)
|
|
JSR _INTERP
|
|
DB $2A,$2E ; CB 46
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1129: end
|
|
DB $5C ; RET
|
|
; 1130: def emit_leave_10(framesize)
|
|
C0218: ; emit_leave_10()
|
|
; framesize = 2
|
|
; 1131: if framesize > 2
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0220,>C0220 ; SKPFLS C0220
|
|
; 1132: emit_op_10($5A)
|
|
DB $2A,$5A ; CB 90
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1133: else
|
|
DB $50,<C0221,>C0221 ; SKIP C0221
|
|
C0220:
|
|
; 1134: emit_op_10($5C)
|
|
DB $2A,$5C ; CB 92
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1135: fin
|
|
C0221:
|
|
; 1136: end
|
|
DB $5A ; LEAVE
|
|
; 1137: def emit_enter_20(framesize, cparams)
|
|
C0222: ; emit_enter_20()
|
|
; framesize = 2
|
|
; cparams = 4
|
|
; 1138: emit_byte_10($20)
|
|
JSR _INTERP
|
|
DB $58,$06,$02 ; ENTER 6,2
|
|
DB $2A,$20 ; CB 32
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1139: emit_byte_10($D0)
|
|
DB $2A,$D0 ; CB 208
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1140: emit_byte_10($03)
|
|
DB $2A,$03 ; CB 3
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1141: if framesize > 2
|
|
DB $66,$02 ; LLW 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0224,>C0224 ; SKPFLS C0224
|
|
; 1142: emit_op_10($58)
|
|
DB $2A,$58 ; CB 88
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1143: emit_byte_10(framesize)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1144: emit_byte_10(cparams)
|
|
DB $66,$04 ; LLW 4
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1145: fin
|
|
C0224:
|
|
C0225:
|
|
; 1146: end
|
|
DB $5A ; LEAVE
|
|
; 1147: def emit_start
|
|
C0226: ; emit_start()
|
|
; 1148: ;
|
|
; 1149: ; Save address
|
|
; 1150: ;
|
|
; 1151: entrypoint = codeptr
|
|
JSR _INTERP
|
|
DB $6A,<D0022,>D0022 ; LAW D0022
|
|
DB $7A,<D0024,>D0024 ; SAW D0024
|
|
; 1152: emit_byte_10(emit_start.[0])
|
|
DB $26,<C0226,>C0226 ; LA C0226
|
|
DB $00 ; ZERO
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1153: emit_byte_10(emit_start.[1])
|
|
DB $26,<C0226,>C0226 ; LA C0226
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1154: emit_byte_10(emit_start.[2])
|
|
DB $26,<C0226,>C0226 ; LA C0226
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $54,<C0078,>C0078 ; CALL C0078
|
|
; 1155: end
|
|
DB $5C ; RET
|
|
; 1156: def emit_exit
|
|
C0228: ; emit_exit()
|
|
; 1157: emit_op_10($00)
|
|
JSR _INTERP
|
|
DB $00 ; ZERO
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1158: emit_op_10($5C)
|
|
DB $2A,$5C ; CB 92
|
|
DB $54,<C0086,>C0086 ; CALL C0086
|
|
; 1159: end
|
|
DB $5C ; RET
|
|
; 1160: ;
|
|
; 1161: ; Lexical anaylzer
|
|
; 1162: ;
|
|
; 1163: ;def isalpha_11(c)
|
|
; 1164: ; if c >= 'A' and c <= 'Z'
|
|
; 1165: ; return TRUE
|
|
; 1166: ; elsif c >= 'a' and c <= 'z'
|
|
; 1167: ; return TRUE
|
|
; 1168: ; elsif c == '_'
|
|
; 1169: ; return TRUE
|
|
; 1170: ; fin
|
|
; 1171: ; return FALSE
|
|
; 1172: ;end
|
|
; 1173: asm isalpha_11
|
|
C0230: ; isalpha_11()
|
|
; 1174: LDY #$00
|
|
LDY #$00
|
|
; 1175: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 1176: CMP #'A'
|
|
CMP #'A'
|
|
; 1177: BCC ISALRET
|
|
BCC ISALRET
|
|
; 1178: CMP #'Z'+1
|
|
CMP #'Z'+1
|
|
; 1179: BCS :+
|
|
BCS :+
|
|
; 1180: DEY
|
|
DEY
|
|
; 1181: BNE ISALRET
|
|
BNE ISALRET
|
|
; 1182: : CMP #'a'
|
|
: CMP #'a'
|
|
; 1183: BCC ISALRET
|
|
BCC ISALRET
|
|
; 1184: CMP #'z'+1
|
|
CMP #'z'+1
|
|
; 1185: BCS :+
|
|
BCS :+
|
|
; 1186: DEY
|
|
DEY
|
|
; 1187: BNE ISALRET
|
|
BNE ISALRET
|
|
; 1188: : CMP #'_'
|
|
: CMP #'_'
|
|
; 1189: BNE ISALRET
|
|
BNE ISALRET
|
|
; 1190: DEY
|
|
DEY
|
|
; 1191: ISALRET:
|
|
ISALRET:
|
|
; 1192: STY ESTKL,X
|
|
STY ESTKL,X
|
|
; 1193: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 1194: RTS
|
|
RTS
|
|
; 1195: end
|
|
RTS
|
|
; 1196: ;def isnum_11(c)
|
|
; 1197: ; if c >= '0' and c <= '9'
|
|
; 1198: ; return TRUE
|
|
; 1199: ; fin
|
|
; 1200: ; return FALSE
|
|
; 1201: ;end
|
|
; 1202: asm isnum_11
|
|
C0232: ; isnum_11()
|
|
; 1203: LDY #$00
|
|
LDY #$00
|
|
; 1204: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 1205: CMP #'0'
|
|
CMP #'0'
|
|
; 1206: BCC :+
|
|
BCC :+
|
|
; 1207: CMP #'9'+1
|
|
CMP #'9'+1
|
|
; 1208: BCS :+
|
|
BCS :+
|
|
; 1209: DEY
|
|
DEY
|
|
; 1210: : STY ESTKL,X
|
|
: STY ESTKL,X
|
|
; 1211: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 1212: RTS
|
|
RTS
|
|
; 1213: end
|
|
RTS
|
|
; 1214: ;def isalphanum_11(c)
|
|
; 1215: ; if c >= 'A' and c <= 'Z'
|
|
; 1216: ; return TRUE
|
|
; 1217: ; elsif c >= '0' and c <= '9'
|
|
; 1218: ; return TRUE
|
|
; 1219: ; elsif c >= 'a' and c <= 'z'
|
|
; 1220: ; return TRUE
|
|
; 1221: ; elsif c == '_'
|
|
; 1222: ; return TRUE
|
|
; 1223: ; fin
|
|
; 1224: ; return FALSE
|
|
; 1225: ;end
|
|
; 1226: asm isalphanum_11
|
|
C0234: ; isalphanum_11()
|
|
; 1227: LDY #$00
|
|
LDY #$00
|
|
; 1228: LDA ESTKL,X
|
|
LDA ESTKL,X
|
|
; 1229: CMP #'0'
|
|
CMP #'0'
|
|
; 1230: BCC ISANRET
|
|
BCC ISANRET
|
|
; 1231: CMP #'9'+1
|
|
CMP #'9'+1
|
|
; 1232: BCS :+
|
|
BCS :+
|
|
; 1233: DEY
|
|
DEY
|
|
; 1234: BNE ISANRET
|
|
BNE ISANRET
|
|
; 1235: : CMP #'A'
|
|
: CMP #'A'
|
|
; 1236: BCC ISANRET
|
|
BCC ISANRET
|
|
; 1237: CMP #'Z'+1
|
|
CMP #'Z'+1
|
|
; 1238: BCS :+
|
|
BCS :+
|
|
; 1239: DEY
|
|
DEY
|
|
; 1240: BNE ISANRET
|
|
BNE ISANRET
|
|
; 1241: : CMP #'a'
|
|
: CMP #'a'
|
|
; 1242: BCC :+
|
|
BCC :+
|
|
; 1243: CMP #'z'+1
|
|
CMP #'z'+1
|
|
; 1244: BCS ISANRET
|
|
BCS ISANRET
|
|
; 1245: DEY
|
|
DEY
|
|
; 1246: BNE ISANRET
|
|
BNE ISANRET
|
|
; 1247: : CMP #'_'
|
|
: CMP #'_'
|
|
; 1248: BNE ISANRET
|
|
BNE ISANRET
|
|
; 1249: DEY
|
|
DEY
|
|
; 1250: ISANRET:
|
|
ISANRET:
|
|
; 1251: STY ESTKL,X
|
|
STY ESTKL,X
|
|
; 1252: STY ESTKH,X
|
|
STY ESTKH,X
|
|
; 1253: RTS
|
|
RTS
|
|
; 1254: end
|
|
RTS
|
|
; 1255: defopt keymatch_21(chrptr, len)
|
|
C0236: ; keymatch_21()
|
|
; chrptr = 2
|
|
; len = 4
|
|
; 1256: byte i, keypos
|
|
; i = 6
|
|
; keypos = 7
|
|
; 1257:
|
|
; 1258: keypos = 0
|
|
LDY #8
|
|
LDA #2
|
|
JSR ENTER
|
|
DEX
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
LDY #$07
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
; 1259: while keywrds[keypos] < len
|
|
INX
|
|
C0238:
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR ISLT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0239
|
|
:
|
|
; 1260: keypos = keypos + keywrds[keypos] + 2
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDY #$07
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
; 1261: loop
|
|
INX
|
|
JMP C0238
|
|
C0239:
|
|
; 1262: while keywrds[keypos] == len
|
|
C0240:
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0241
|
|
:
|
|
; 1263: for i = 1 to len
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
C0243:
|
|
LDY #$06
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
LDA ESTKH-1,X
|
|
SBC ESTKH,X
|
|
BPL :+
|
|
JMP C0242
|
|
:
|
|
INC ESTKL,X
|
|
BNE :+
|
|
INC ESTKH,X
|
|
:
|
|
; 1264: if toupper_11((chrptr).[i - 1]) <> keywrds[keypos + i]
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR ADD
|
|
JSR LB
|
|
JSR C0020
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0244
|
|
:
|
|
; 1265: break
|
|
JMP C0242
|
|
; 1266: fin
|
|
C0244:
|
|
C0245:
|
|
; 1267: next
|
|
JMP C0243
|
|
C0242:
|
|
; 1268: if i > len
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR ISGT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0246
|
|
:
|
|
; 1269: return keywrds[keypos + keywrds[keypos] + 1]
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR ADD
|
|
JSR LB
|
|
JMP LEAVE
|
|
; 1270: fin
|
|
C0246:
|
|
C0247:
|
|
; 1271: keypos = keypos + keywrds[keypos] + 2
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #<D0075
|
|
STA ESTKL,X
|
|
LDA #>D0075
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$07
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDY #$07
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
; 1272: loop
|
|
INX
|
|
JMP C0240
|
|
C0241:
|
|
; 1273: return ID_TKN
|
|
DEX
|
|
LDA #$D6
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JMP LEAVE
|
|
; 1274: end
|
|
; 1275: defopt scan_01
|
|
C0248: ; scan_01()
|
|
; 1276: ;
|
|
; 1277: ; Scan for token based on first character
|
|
; 1278: ;
|
|
; 1279: while ^scanptr and ^scanptr <= ' '
|
|
C0250:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
DEX
|
|
LDA #$20
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISLE
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0251
|
|
:
|
|
; 1280: scanptr = scanptr + 1
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1281: loop
|
|
INX
|
|
JMP C0250
|
|
C0251:
|
|
; 1282: tknptr = scanptr
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0368
|
|
LDA ESTKH,X
|
|
STA D0368+1
|
|
; 1283: if !^scanptr or ^scanptr == ';'
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
JSR NOT
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
DEX
|
|
LDA #$3B
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
JSR LOR
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0252
|
|
:
|
|
; 1284: if token <> EOF_TKN
|
|
DEX
|
|
LDA D0364
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0254
|
|
:
|
|
; 1285: token = EOL_TKN
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1286: fin
|
|
INX
|
|
C0254:
|
|
C0255:
|
|
; 1287: elsif isalpha_11(^scanptr)
|
|
JMP C0253
|
|
C0252:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
JSR C0230
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0256
|
|
:
|
|
; 1288: ;
|
|
; 1289: ; ID, either variable name or reserved word
|
|
; 1290: ;
|
|
; 1291: repeat
|
|
C0258:
|
|
; 1292: scanptr = scanptr + 1
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1293: until !isalphanum_11(^scanptr)
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR C0234
|
|
LDY #$00
|
|
JSR NOT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0258
|
|
:
|
|
C0257:
|
|
; 1294: tknlen = scanptr - tknptr;
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA D0368
|
|
STA ESTKL,X
|
|
LDA D0368+1
|
|
STA ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0365
|
|
; 1295: token = keymatch_21(tknptr, tknlen)
|
|
LDA D0368
|
|
STA ESTKL,X
|
|
LDA D0368+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA D0365
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR C0236
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1296: elsif isnum_11(^scanptr)
|
|
INX
|
|
JMP C0253
|
|
C0256:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
JSR C0232
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0259
|
|
:
|
|
; 1297: ;
|
|
; 1298: ; Number constant
|
|
; 1299: ;
|
|
; 1300: token = INT_TKN
|
|
DEX
|
|
LDA #$C9
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1301: constval = 0
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1302: repeat
|
|
INX
|
|
C0261:
|
|
; 1303: constval = constval * 10 + ^scanptr - '0'
|
|
DEX
|
|
LDA D0370
|
|
STA ESTKL,X
|
|
LDA D0370+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$0A
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR MUL
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$30
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1304: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1305: until !isnum_11(^scanptr)
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR C0232
|
|
LDY #$00
|
|
JSR NOT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0261
|
|
:
|
|
C0260:
|
|
; 1306: elsif ^scanptr == '$'
|
|
JMP C0253
|
|
C0259:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$24
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0262
|
|
:
|
|
; 1307: ;
|
|
; 1308: ; Hexadecimal constant
|
|
; 1309: ;
|
|
; 1310: token = INT_TKN;
|
|
DEX
|
|
LDA #$C9
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1311: constval = 0
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1312: repeat
|
|
INX
|
|
C0264:
|
|
; 1313: scanptr = scanptr + 1
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1314: if ^scanptr >= '0' and ^scanptr <= '9'
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
DEX
|
|
LDA #$30
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISGE
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$39
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISLE
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0265
|
|
:
|
|
; 1315: constval = (constval << 4) + ^scanptr - '0'
|
|
DEX
|
|
LDA D0370
|
|
STA ESTKL,X
|
|
LDA D0370+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SHL
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$30
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1316: elsif ^scanptr >= 'A' and ^scanptr <= 'F'
|
|
INX
|
|
JMP C0266
|
|
C0265:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$41
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISGE
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$46
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISLE
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0267
|
|
:
|
|
; 1317: constval = (constval << 4) + ^scanptr - '7'; 'A'-10
|
|
DEX
|
|
LDA D0370
|
|
STA ESTKL,X
|
|
LDA D0370+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SHL
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$37
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1318: elsif ^scanptr >= 'a' and ^scanptr <= 'f'
|
|
INX
|
|
JMP C0266
|
|
C0267:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$61
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISGE
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$66
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISLE
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0268
|
|
:
|
|
; 1319: constval = (constval << 4) + ^scanptr - 'W'; 'a'-10
|
|
DEX
|
|
LDA D0370
|
|
STA ESTKL,X
|
|
LDA D0370+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SHL
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$57
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1320: else
|
|
INX
|
|
JMP C0266
|
|
C0268:
|
|
; 1321: break;
|
|
JMP C0263
|
|
; 1322: fin
|
|
C0266:
|
|
; 1323: until !^scanptr
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
JSR NOT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0264
|
|
:
|
|
C0263:
|
|
; 1324: elsif ^scanptr == $27 ; '
|
|
JMP C0253
|
|
C0262:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$27
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0269
|
|
:
|
|
; 1325: ;
|
|
; 1326: ; Character constant
|
|
; 1327: ;
|
|
; 1328: token = CHR_TKN
|
|
DEX
|
|
LDA #$C3
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1329: if ^(scanptr + 1) <> $5C ; \
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$5C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0270
|
|
:
|
|
; 1330: constval = ^(scanptr + 1)
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1331: if ^(scanptr + 2) <> $27 ; '
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$27
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0272
|
|
:
|
|
; 1332: return parse_err_11(@bad_cnst)
|
|
DEX
|
|
LDA #<D0425
|
|
STA ESTKL,X
|
|
LDA #>D0425
|
|
STA ESTKH,X
|
|
JSR C0058
|
|
RTS
|
|
; 1333: fin
|
|
C0272:
|
|
C0273:
|
|
; 1334: scanptr = scanptr + 3
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$03
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1335: else
|
|
INX
|
|
JMP C0271
|
|
C0270:
|
|
; 1336: when ^(scanptr + 2)
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
; 1337: is 'n'
|
|
DEX
|
|
LDA #$6E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0275
|
|
:
|
|
; 1338: constval = $0D
|
|
DEX
|
|
LDA #$0D
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1339: is 'r'
|
|
INX
|
|
JMP C0274
|
|
C0275:
|
|
DEX
|
|
LDA #$72
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0276
|
|
:
|
|
; 1340: constval = $0A
|
|
DEX
|
|
LDA #$0A
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1341: is 't'
|
|
INX
|
|
JMP C0274
|
|
C0276:
|
|
DEX
|
|
LDA #$74
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0277
|
|
:
|
|
; 1342: constval = $09
|
|
DEX
|
|
LDA #$09
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1343: otherwise
|
|
INX
|
|
JMP C0274
|
|
C0277:
|
|
; 1344: constval = ^(scanptr + 2)
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1345: wend
|
|
INX
|
|
C0274:
|
|
; 1346: if ^(scanptr + 3) <> $27 ; '
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$03
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$27
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0279
|
|
:
|
|
; 1347: return parse_err_11(@bad_cnst)
|
|
DEX
|
|
LDA #<D0425
|
|
STA ESTKL,X
|
|
LDA #>D0425
|
|
STA ESTKH,X
|
|
JSR C0058
|
|
RTS
|
|
; 1348: fin
|
|
C0279:
|
|
C0280:
|
|
; 1349: scanptr = scanptr + 4
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1350: fin
|
|
INX
|
|
C0271:
|
|
; 1351: elsif ^scanptr == '"'
|
|
JMP C0253
|
|
C0269:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$22
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0281
|
|
:
|
|
; 1352: ;
|
|
; 1353: ; String constant
|
|
; 1354: ;
|
|
; 1355: token = STR_TKN
|
|
DEX
|
|
LDA #$D3
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1356: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1357: constval = scanptr
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0370
|
|
LDA ESTKH,X
|
|
STA D0370+1
|
|
; 1358: while ^scanptr and ^scanptr <> '"'
|
|
INX
|
|
C0282:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
JSR LB
|
|
DEX
|
|
LDA #$22
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISNE
|
|
JSR LAND
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0283
|
|
:
|
|
; 1359: scanptr = scanptr + 1
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1360: loop
|
|
INX
|
|
JMP C0282
|
|
C0283:
|
|
; 1361: if !^scanptr
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
JSR NOT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0284
|
|
:
|
|
; 1362: return parse_err_11(@bad_cnst)
|
|
DEX
|
|
LDA #<D0425
|
|
STA ESTKL,X
|
|
LDA #>D0425
|
|
STA ESTKH,X
|
|
JSR C0058
|
|
RTS
|
|
; 1363: fin
|
|
C0284:
|
|
C0285:
|
|
; 1364: scanptr = scanptr + 1
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1365: else
|
|
INX
|
|
JMP C0253
|
|
C0281:
|
|
; 1366: ;
|
|
; 1367: ; Potential two and three character tokens
|
|
; 1368: ;
|
|
; 1369: when ^scanptr
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
; 1370: is '>'
|
|
DEX
|
|
LDA #$3E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0287
|
|
:
|
|
; 1371: if ^(scanptr + 1) == '>'
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0288
|
|
:
|
|
; 1372: token = SHR_TKN
|
|
DEX
|
|
LDA #$D2
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1373: scanptr = scanptr + 2
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1374: elsif ^(scanptr + 1) == '='
|
|
INX
|
|
JMP C0289
|
|
C0288:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3D
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0290
|
|
:
|
|
; 1375: token = GE_TKN
|
|
DEX
|
|
LDA #$C8
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1376: scanptr = scanptr + 2
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1377: else
|
|
INX
|
|
JMP C0289
|
|
C0290:
|
|
; 1378: token = GT_TKN
|
|
DEX
|
|
LDA #$BE
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1379: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1380: fin
|
|
INX
|
|
C0289:
|
|
; 1381: is '<'
|
|
JMP C0286
|
|
C0287:
|
|
DEX
|
|
LDA #$3C
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0291
|
|
:
|
|
; 1382: if ^(scanptr + 1) == '<'
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0292
|
|
:
|
|
; 1383: token = SHL_TKN
|
|
DEX
|
|
LDA #$CC
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1384: scanptr = scanptr + 2
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1385: elsif ^(scanptr + 1) == '='
|
|
INX
|
|
JMP C0293
|
|
C0292:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3D
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0294
|
|
:
|
|
; 1386: token = LE_TKN
|
|
DEX
|
|
LDA #$C2
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1387: scanptr = scanptr + 2
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1388: elsif ^(scanptr + 1) == '>'
|
|
INX
|
|
JMP C0293
|
|
C0294:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3E
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0295
|
|
:
|
|
; 1389: token = NE_TKN
|
|
DEX
|
|
LDA #$D5
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1390: scanptr = scanptr + 2
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1391: else
|
|
INX
|
|
JMP C0293
|
|
C0295:
|
|
; 1392: token = LT_TKN
|
|
DEX
|
|
LDA #$BC
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1393: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1394: fin
|
|
INX
|
|
C0293:
|
|
; 1395: is '='
|
|
JMP C0286
|
|
C0291:
|
|
DEX
|
|
LDA #$3D
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
BNE :+
|
|
LDA ESTKH-1,X
|
|
CMP ESTKH,X
|
|
BEQ :++
|
|
: JMP C0296
|
|
:
|
|
; 1396: if ^(scanptr + 1) == '='
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$3D
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0297
|
|
:
|
|
; 1397: token = EQ_TKN
|
|
DEX
|
|
LDA #$C5
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1398: scanptr = scanptr + 2;
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1399: elsif ^(scanptr + 1) == ','
|
|
INX
|
|
JMP C0298
|
|
C0297:
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDA #$2C
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0299
|
|
:
|
|
; 1400: token = SETLIST_TKN
|
|
DEX
|
|
LDA #$B9
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1401: scanptr = scanptr + 2;
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$02
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1402: else
|
|
INX
|
|
JMP C0298
|
|
C0299:
|
|
; 1403: token = SET_TKN;
|
|
DEX
|
|
LDA #$BD
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1404: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1405: fin
|
|
INX
|
|
C0298:
|
|
; 1406: otherwise
|
|
JMP C0286
|
|
C0296:
|
|
; 1407: ;
|
|
; 1408: ; Simple single character tokens
|
|
; 1409: ;
|
|
; 1410: token = ^scanptr ? $80
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR LB
|
|
DEX
|
|
LDA #$80
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR IOR
|
|
LDA ESTKL,X
|
|
STA D0364
|
|
; 1411: scanptr = scanptr + 1
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDA ESTKL,X
|
|
STA D0366
|
|
LDA ESTKH,X
|
|
STA D0366+1
|
|
; 1412: wend
|
|
INX
|
|
C0286:
|
|
; 1413: fin
|
|
INX
|
|
C0253:
|
|
; 1414: tknlen = scanptr - tknptr
|
|
DEX
|
|
LDA D0366
|
|
STA ESTKL,X
|
|
LDA D0366+1
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA D0368
|
|
STA ESTKL,X
|
|
LDA D0368+1
|
|
STA ESTKH,X
|
|
JSR SUB
|
|
LDA ESTKL,X
|
|
STA D0365
|
|
; 1415: return token
|
|
LDA D0364
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
RTS
|
|
; 1416: end
|
|
; 1417: def rewind_10(ptr)
|
|
C0301: ; rewind_10()
|
|
; ptr = 2
|
|
; 1418: scanptr = ptr
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $7A,<D0366,>D0366 ; SAW D0366
|
|
; 1419: end
|
|
DB $5A ; LEAVE
|
|
; 1420: ;
|
|
; 1421: ; Get next line of input
|
|
; 1422: ;
|
|
; 1423: def nextln_01
|
|
C0303: ; nextln_01()
|
|
; 1424: byte i, chr
|
|
; i = 2
|
|
; chr = 3
|
|
; 1425:
|
|
; 1426: scanptr = inbuff
|
|
JSR _INTERP
|
|
DB $58,$04,$00 ; ENTER 4,0
|
|
DB $2C,$00,$02 ; CW 512
|
|
DB $7A,<D0366,>D0366 ; SAW D0366
|
|
; 1427: ^instr = read_31(inref, inbuff, $7F)
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $68,<D0000,>D0000 ; LAB D0000
|
|
DB $2C,$00,$02 ; CW 512
|
|
DB $2A,$7F ; CB 127
|
|
DB $54,<C0032,>C0032 ; CALL C0032
|
|
DB $70 ; SB
|
|
; 1428: inbuff[^instr] = $00
|
|
DB $2C,$00,$02 ; CW 512
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $60 ; LB
|
|
DB $02 ; IDXB
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 1429: if ^instr
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $60 ; LB
|
|
DB $4C,<C0305,>C0305 ; SKPFLS C0305
|
|
; 1430: lineno = lineno + 1
|
|
DB $6A,<D0372,>D0372 ; LAW D0372
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $7A,<D0372,>D0372 ; SAW D0372
|
|
; 1431: if !(lineno & $0F)
|
|
DB $6A,<D0372,>D0372 ; LAW D0372
|
|
DB $2A,$0F ; CB 15
|
|
DB $14 ; BAND
|
|
DB $20 ; NOT
|
|
DB $4C,<C0307,>C0307 ; SKPFLS C0307
|
|
; 1432: cout('.')
|
|
DB $2A,$2E ; CB 46
|
|
DB $54,<C0012,>C0012 ; CALL C0012
|
|
; 1433: fin
|
|
C0307:
|
|
C0308:
|
|
; 1434: ; cout('>')
|
|
; 1435: ; prstr(instr)
|
|
; 1436: ; crout
|
|
; 1437: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 1438: else
|
|
DB $50,<C0306,>C0306 ; SKIP C0306
|
|
C0305:
|
|
; 1439: ^instr = 0
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 1440: ^inbuff = $00
|
|
DB $2C,$00,$02 ; CW 512
|
|
DB $00 ; ZERO
|
|
DB $70 ; SB
|
|
; 1441: token = DONE_TKN
|
|
DB $2A,$98 ; CB 152
|
|
DB $78,<D0364,>D0364 ; SAB D0364
|
|
; 1442: fin
|
|
C0306:
|
|
; 1443: return ^instr
|
|
DB $2C,$FF,$01 ; CW 511
|
|
DB $60 ; LB
|
|
DB $5A ; LEAVE
|
|
; 1444: end
|
|
; 1445: ;
|
|
; 1446: ; Alebraic op to stack op
|
|
; 1447: ;
|
|
; 1448: def push_op_21(op, prec)
|
|
C0309: ; push_op_21()
|
|
; op = 2
|
|
; prec = 4
|
|
; 1449: opsp = opsp + 1
|
|
JSR _INTERP
|
|
DB $58,$06,$02 ; ENTER 6,2
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $7A,<D0362,>D0362 ; SAW D0362
|
|
; 1450: if opsp == 16
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $2A,$10 ; CB 16
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0311,>C0311 ; SKPFLS C0311
|
|
; 1451: return parse_err_11(@estk_overflw)
|
|
DB $26,<D0525,>D0525 ; LA D0525
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1452: fin
|
|
C0311:
|
|
C0312:
|
|
; 1453: opstack[opsp] = op
|
|
DB $26,<D0330,>D0330 ; LA D0330
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $02 ; IDXB
|
|
DB $66,$02 ; LLW 2
|
|
DB $70 ; SB
|
|
; 1454: precstack[opsp] = prec
|
|
DB $26,<D0346,>D0346 ; LA D0346
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $02 ; IDXB
|
|
DB $66,$04 ; LLW 4
|
|
DB $70 ; SB
|
|
; 1455: return 0
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1456: end
|
|
; 1457: def pop_op_01
|
|
C0313: ; pop_op_01()
|
|
; 1458: if opsp < 0
|
|
JSR _INTERP
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $00 ; ZERO
|
|
DB $46 ; ISLT
|
|
DB $4C,<C0315,>C0315 ; SKPFLS C0315
|
|
; 1459: return parse_err_11(@estk_underflw)
|
|
DB $26,<D0545,>D0545 ; LA D0545
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5C ; RET
|
|
; 1460: fin
|
|
C0315:
|
|
C0316:
|
|
; 1461: opsp = opsp - 1
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $7A,<D0362,>D0362 ; SAW D0362
|
|
; 1462: return opstack[opsp + 1]
|
|
DB $26,<D0330,>D0330 ; LA D0330
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $5C ; RET
|
|
; 1463: end
|
|
; 1464: def tos_op_01
|
|
C0317: ; tos_op_01()
|
|
; 1465: if opsp < 0
|
|
JSR _INTERP
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $00 ; ZERO
|
|
DB $46 ; ISLT
|
|
DB $4C,<C0319,>C0319 ; SKPFLS C0319
|
|
; 1466: return 0
|
|
DB $00 ; ZERO
|
|
DB $5C ; RET
|
|
; 1467: fin
|
|
C0319:
|
|
C0320:
|
|
; 1468: return opstack[opsp]
|
|
DB $26,<D0330,>D0330 ; LA D0330
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $5C ; RET
|
|
; 1469: end
|
|
; 1470: def tos_op_prec_11(tos)
|
|
C0321: ; tos_op_prec_11()
|
|
; tos = 2
|
|
; 1471: if opsp <= tos
|
|
JSR _INTERP
|
|
DB $58,$04,$01 ; ENTER 4,1
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $66,$02 ; LLW 2
|
|
DB $4A ; ISLE
|
|
DB $4C,<C0323,>C0323 ; SKPFLS C0323
|
|
; 1472: return 100
|
|
DB $2A,$64 ; CB 100
|
|
DB $5A ; LEAVE
|
|
; 1473: fin
|
|
C0323:
|
|
C0324:
|
|
; 1474: return precstack[opsp]
|
|
DB $26,<D0346,>D0346 ; LA D0346
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $5A ; LEAVE
|
|
; 1475: end
|
|
; 1476: ;
|
|
; 1477: ; Symbol table
|
|
; 1478: ;
|
|
; 1479: defopt idmatch_41(nameptr, len, idptr, idcnt)
|
|
C0325: ; idmatch_41()
|
|
; nameptr = 2
|
|
; len = 4
|
|
; idptr = 6
|
|
; idcnt = 8
|
|
; 1480: byte i
|
|
; i = 10
|
|
; 1481:
|
|
; 1482: while idcnt
|
|
LDY #11
|
|
LDA #4
|
|
JSR ENTER
|
|
C0327:
|
|
DEX
|
|
LDY #$08
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0328
|
|
:
|
|
; 1483: if len == (idptr).idname
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$03
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ISEQ
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0329
|
|
:
|
|
; 1484: for i = 1 to len
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
C0332:
|
|
LDY #$0A
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
INX
|
|
LDA ESTKL-1,X
|
|
CMP ESTKL,X
|
|
LDA ESTKH-1,X
|
|
SBC ESTKH,X
|
|
BPL :+
|
|
JMP C0331
|
|
:
|
|
INC ESTKL,X
|
|
BNE :+
|
|
INC ESTKH,X
|
|
:
|
|
; 1485: if (nameptr).[i - 1] <> (idptr).idname.[i]
|
|
DEX
|
|
LDY #$02
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$0A
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
JSR ADD
|
|
JSR LB
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$03
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
DEX
|
|
LDY #$0A
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ISNE
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0333
|
|
:
|
|
; 1486: break
|
|
JMP C0331
|
|
; 1487: fin
|
|
C0333:
|
|
C0334:
|
|
; 1488: next
|
|
JMP C0332
|
|
C0331:
|
|
; 1489: if i > len
|
|
LDY #$0A
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
DEX
|
|
LDY #$04
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
LDY #$00
|
|
JSR ISGT
|
|
INX
|
|
LDA ESTKL-1,X
|
|
ORA ESTKH-1,X
|
|
BNE :+
|
|
JMP C0335
|
|
:
|
|
; 1490: return idptr
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
JMP LEAVE
|
|
; 1491: fin
|
|
C0335:
|
|
C0336:
|
|
; 1492: fin
|
|
C0329:
|
|
C0330:
|
|
; 1493: idptr = idptr + (idptr).idname + idrecsz
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDY #$06
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$03
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
JSR LB
|
|
JSR ADD
|
|
DEX
|
|
LDA #$04
|
|
STA ESTKL,X
|
|
STY ESTKH,X
|
|
JSR ADD
|
|
LDY #$06
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 1494: idcnt = idcnt - 1
|
|
LDY #$08
|
|
LDA (FRMP),Y
|
|
STA ESTKL,X
|
|
INY
|
|
LDA (FRMP),Y
|
|
STA ESTKH,X
|
|
DEX
|
|
LDA #$01
|
|
STA ESTKL,X
|
|
LDY #$00
|
|
STY ESTKH,X
|
|
JSR SUB
|
|
LDY #$08
|
|
LDA ESTKL,X
|
|
STA (FRMP),Y
|
|
INY
|
|
LDA ESTKH,X
|
|
STA (FRMP),Y
|
|
; 1495: loop
|
|
INX
|
|
JMP C0327
|
|
C0328:
|
|
; 1496: return 0
|
|
DEX
|
|
LDY #$00
|
|
STY ESTKL,X
|
|
STY ESTKH,X
|
|
JMP LEAVE
|
|
; 1497: end
|
|
; 1498: ;def dumpsym_20(idptr, idcnt)
|
|
; 1499: ; while idcnt
|
|
; 1500: ; prword_10((idptr):idval)
|
|
; 1501: ; cout(' ')
|
|
; 1502: ; prbyte_10((idptr).idtype)
|
|
; 1503: ; cout(' ')
|
|
; 1504: ; prstr(@(idptr).idname)
|
|
; 1505: ; cout('=')
|
|
; 1506: ; if (idptr).idtype & ADDR_TYPE
|
|
; 1507: ; if (idptr):idval & is_ctag
|
|
; 1508: ; prword_10(ctag_value:[(idptr):idval & mask_ctag])
|
|
; 1509: ; else
|
|
; 1510: ; prword_10((idptr):idval + compbuff)
|
|
; 1511: ; fin
|
|
; 1512: ; else
|
|
; 1513: ; prword_10((idptr):idval)
|
|
; 1514: ; fin
|
|
; 1515: ; crout()
|
|
; 1516: ; idptr = idptr + (idptr).idname + idrecsz
|
|
; 1517: ; idcnt = idcnt - 1
|
|
; 1518: ; loop
|
|
; 1519: ;end
|
|
; 1520: def id_lookup_21(nameptr, len)
|
|
C0337: ; id_lookup_21()
|
|
; nameptr = 2
|
|
; len = 4
|
|
; 1521: word idptr
|
|
; idptr = 6
|
|
; 1522:
|
|
; 1523: idptr = idmatch_41(nameptr, len, idlocal_tbl, locals)
|
|
JSR _INTERP
|
|
DB $58,$08,$02 ; ENTER 8,2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$18 ; CW 6144
|
|
DB $68,<D0015,>D0015 ; LAB D0015
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $76,$06 ; SLW 6
|
|
; 1524: if idptr
|
|
DB $66,$06 ; LLW 6
|
|
DB $4C,<C0339,>C0339 ; SKPFLS C0339
|
|
; 1525: return idptr
|
|
DB $66,$06 ; LLW 6
|
|
DB $5A ; LEAVE
|
|
; 1526: fin
|
|
C0339:
|
|
C0340:
|
|
; 1527: idptr = idmatch_41(nameptr, len, idglobal_tbl, globals)
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $76,$06 ; SLW 6
|
|
; 1528: if idptr
|
|
DB $66,$06 ; LLW 6
|
|
DB $4C,<C0341,>C0341 ; SKPFLS C0341
|
|
; 1529: return idptr
|
|
DB $66,$06 ; LLW 6
|
|
DB $5A ; LEAVE
|
|
; 1530: fin
|
|
C0341:
|
|
C0342:
|
|
; 1531: return parse_err_11(@undecl_id)
|
|
DB $26,<D0403,>D0403 ; LA D0403
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1532: end
|
|
; 1533: def idglobal_lookup_21(nameptr, len)
|
|
C0343: ; idglobal_lookup_21()
|
|
; nameptr = 2
|
|
; len = 4
|
|
; 1534: return idmatch_41(nameptr, len, idglobal_tbl, globals)
|
|
JSR _INTERP
|
|
DB $58,$06,$02 ; ENTER 6,2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $5A ; LEAVE
|
|
; 1535: end
|
|
; 1536: def idlocal_add_41(namestr, len, type, size)
|
|
C0345: ; idlocal_add_41()
|
|
; namestr = 2
|
|
; len = 4
|
|
; type = 6
|
|
; size = 8
|
|
; 1537: if idmatch_41(namestr, len, @idlocal_tbl, locals)
|
|
JSR _INTERP
|
|
DB $58,$0A,$04 ; ENTER 10,4
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$18 ; CW 6144
|
|
DB $68,<D0015,>D0015 ; LAB D0015
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $4C,<C0347,>C0347 ; SKPFLS C0347
|
|
; 1538: return parse_err_11(@dup_id)
|
|
DB $26,<D0382,>D0382 ; LA D0382
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1539: fin
|
|
C0347:
|
|
C0348:
|
|
; 1540: (lastlocal):idval = framesize
|
|
DB $6A,<D0018,>D0018 ; LAW D0018
|
|
DB $6A,<D0016,>D0016 ; LAW D0016
|
|
DB $72 ; SW
|
|
; 1541: (lastlocal).idtype = type ? LOCAL_TYPE
|
|
DB $6A,<D0018,>D0018 ; LAW D0018
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $66,$06 ; LLW 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $16 ; IOR
|
|
DB $70 ; SB
|
|
; 1542: nametostr_30(namestr, len, lastlocal + idname)
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $6A,<D0018,>D0018 ; LAW D0018
|
|
DB $2A,$03 ; CB 3
|
|
DB $02 ; ADD
|
|
DB $54,<C0056,>C0056 ; CALL C0056
|
|
; 1543: locals = locals + 1
|
|
DB $68,<D0015,>D0015 ; LAB D0015
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $78,<D0015,>D0015 ; SAB D0015
|
|
; 1544: lastlocal = lastlocal + idrecsz + len
|
|
DB $6A,<D0018,>D0018 ; LAW D0018
|
|
DB $2A,$04 ; CB 4
|
|
DB $02 ; ADD
|
|
DB $66,$04 ; LLW 4
|
|
DB $02 ; ADD
|
|
DB $7A,<D0018,>D0018 ; SAW D0018
|
|
; 1545: if lastlocal > idlocal_tbl + idlocal_tblsz
|
|
DB $6A,<D0018,>D0018 ; LAW D0018
|
|
DB $2C,$00,$18 ; CW 6144
|
|
DB $2C,$00,$02 ; CW 512
|
|
DB $02 ; ADD
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0349,>C0349 ; SKPFLS C0349
|
|
; 1546: prstr(@local_sym_overflw)
|
|
DB $26,<D0616,>D0616 ; LA D0616
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 1547: exit
|
|
DB $54,<C0022,>C0022 ; CALL C0022
|
|
; 1548: fin
|
|
C0349:
|
|
C0350:
|
|
; 1549: framesize = framesize + size
|
|
DB $6A,<D0016,>D0016 ; LAW D0016
|
|
DB $66,$08 ; LLW 8
|
|
DB $02 ; ADD
|
|
DB $7A,<D0016,>D0016 ; SAW D0016
|
|
; 1550: if framesize > 255
|
|
DB $6A,<D0016,>D0016 ; LAW D0016
|
|
DB $2A,$FF ; CB 255
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0351,>C0351 ; SKPFLS C0351
|
|
; 1551: prstr(@local_overflw)
|
|
DB $26,<D0566,>D0566 ; LA D0566
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 1552: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1553: fin
|
|
C0351:
|
|
C0352:
|
|
; 1554: return TRUE
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5A ; LEAVE
|
|
; 1555: end
|
|
; 1556: def iddata_add_41(namestr, len, type, size)
|
|
C0353: ; iddata_add_41()
|
|
; namestr = 2
|
|
; len = 4
|
|
; type = 6
|
|
; size = 8
|
|
; 1557: if idmatch_41(namestr, len, idglobal_tbl, globals)
|
|
JSR _INTERP
|
|
DB $58,$0A,$04 ; ENTER 10,4
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $4C,<C0355,>C0355 ; SKPFLS C0355
|
|
; 1558: return parse_err_11(@dup_id)
|
|
DB $26,<D0382,>D0382 ; LA D0382
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1559: fin
|
|
C0355:
|
|
C0356:
|
|
; 1560: (lastglobal):idval = datasize
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $6A,<D0011,>D0011 ; LAW D0011
|
|
DB $72 ; SW
|
|
; 1561: (lastglobal).idtype = type
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $66,$06 ; LLW 6
|
|
DB $70 ; SB
|
|
; 1562: nametostr_30(namestr, len, lastglobal + idname)
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$03 ; CB 3
|
|
DB $02 ; ADD
|
|
DB $54,<C0056,>C0056 ; CALL C0056
|
|
; 1563: emit_iddata_30(datasize, size, lastglobal + idname)
|
|
DB $6A,<D0011,>D0011 ; LAW D0011
|
|
DB $66,$08 ; LLW 8
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$03 ; CB 3
|
|
DB $02 ; ADD
|
|
DB $54,<C0094,>C0094 ; CALL C0094
|
|
; 1564: globals = globals + 1
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $7A,<D0009,>D0009 ; SAW D0009
|
|
; 1565: lastglobal = lastglobal + idrecsz + len
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$04 ; CB 4
|
|
DB $02 ; ADD
|
|
DB $66,$04 ; LLW 4
|
|
DB $02 ; ADD
|
|
DB $7A,<D0013,>D0013 ; SAW D0013
|
|
; 1566: if lastglobal > idglobal_tbl + idglobal_tblsz
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $2C,$00,$08 ; CW 2048
|
|
DB $02 ; ADD
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0357,>C0357 ; SKPFLS C0357
|
|
; 1567: prstr(@global_sym_overflw)
|
|
DB $26,<D0587,>D0587 ; LA D0587
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 1568: exit
|
|
DB $54,<C0022,>C0022 ; CALL C0022
|
|
; 1569: fin
|
|
C0357:
|
|
C0358:
|
|
; 1570: datasize = datasize + size
|
|
DB $6A,<D0011,>D0011 ; LAW D0011
|
|
DB $66,$08 ; LLW 8
|
|
DB $02 ; ADD
|
|
DB $7A,<D0011,>D0011 ; SAW D0011
|
|
; 1571: return TRUE
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5A ; LEAVE
|
|
; 1572: end
|
|
; 1573: def iddata_size_30(type, varsize, initsize)
|
|
C0359: ; iddata_size_30()
|
|
; type = 2
|
|
; varsize = 4
|
|
; initsize = 6
|
|
; 1574: if varsize > initsize
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $66,$04 ; LLW 4
|
|
DB $66,$06 ; LLW 6
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0361,>C0361 ; SKPFLS C0361
|
|
; 1575: datasize = datasize + emit_data_41(0, 0, 0, varsize - initsize)
|
|
DB $6A,<D0011,>D0011 ; LAW D0011
|
|
DB $00 ; ZERO
|
|
DB $00 ; ZERO
|
|
DB $00 ; ZERO
|
|
DB $66,$04 ; LLW 4
|
|
DB $66,$06 ; LLW 6
|
|
DB $04 ; SUB
|
|
DB $54,<C0096,>C0096 ; CALL C0096
|
|
DB $02 ; ADD
|
|
DB $7A,<D0011,>D0011 ; SAW D0011
|
|
; 1576: else
|
|
DB $50,<C0362,>C0362 ; SKIP C0362
|
|
C0361:
|
|
; 1577: datasize = datasize + initsize
|
|
DB $6A,<D0011,>D0011 ; LAW D0011
|
|
DB $66,$06 ; LLW 6
|
|
DB $02 ; ADD
|
|
DB $7A,<D0011,>D0011 ; SAW D0011
|
|
; 1578: fin
|
|
C0362:
|
|
; 1579: ; if datasize <> codeptr - compbuff
|
|
; 1580: ; prstr(@emiterr)
|
|
; 1581: ; keyin_01()
|
|
; 1582: ; fin
|
|
; 1583: end
|
|
DB $5A ; LEAVE
|
|
; 1584: def idglobal_add_41(namestr, len, type, value)
|
|
C0363: ; idglobal_add_41()
|
|
; namestr = 2
|
|
; len = 4
|
|
; type = 6
|
|
; value = 8
|
|
; 1585: if idmatch_41(namestr, len, idglobal_tbl, globals)
|
|
JSR _INTERP
|
|
DB $58,$0A,$04 ; ENTER 10,4
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $54,<C0325,>C0325 ; CALL C0325
|
|
DB $4C,<C0365,>C0365 ; SKPFLS C0365
|
|
; 1586: return parse_err_11(@dup_id)
|
|
DB $26,<D0382,>D0382 ; LA D0382
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1587: fin
|
|
C0365:
|
|
C0366:
|
|
; 1588: (lastglobal):idval = value
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $66,$08 ; LLW 8
|
|
DB $72 ; SW
|
|
; 1589: (lastglobal).idtype = type
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $66,$06 ; LLW 6
|
|
DB $70 ; SB
|
|
; 1590: nametostr_30(namestr, len, lastglobal + idname)
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$03 ; CB 3
|
|
DB $02 ; ADD
|
|
DB $54,<C0056,>C0056 ; CALL C0056
|
|
; 1591: globals = globals + 1
|
|
DB $6A,<D0009,>D0009 ; LAW D0009
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $7A,<D0009,>D0009 ; SAW D0009
|
|
; 1592: lastglobal = lastglobal + idrecsz + len
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2A,$04 ; CB 4
|
|
DB $02 ; ADD
|
|
DB $66,$04 ; LLW 4
|
|
DB $02 ; ADD
|
|
DB $7A,<D0013,>D0013 ; SAW D0013
|
|
; 1593: if lastglobal > idglobal_tbl + idglobal_tblsz
|
|
DB $6A,<D0013,>D0013 ; LAW D0013
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $2C,$00,$08 ; CW 2048
|
|
DB $02 ; ADD
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0367,>C0367 ; SKPFLS C0367
|
|
; 1594: prstr(@global_sym_overflw)
|
|
DB $26,<D0587,>D0587 ; LA D0587
|
|
DB $54,<C0016,>C0016 ; CALL C0016
|
|
; 1595: exit
|
|
DB $54,<C0022,>C0022 ; CALL C0022
|
|
; 1596: fin
|
|
C0367:
|
|
C0368:
|
|
; 1597: return TRUE
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5A ; LEAVE
|
|
; 1598: end
|
|
; 1599: def idfunc_add_31(namestr, len, tag)
|
|
C0369: ; idfunc_add_31()
|
|
; namestr = 2
|
|
; len = 4
|
|
; tag = 6
|
|
; 1600: return idglobal_add_41(namestr, len, FUNC_TYPE, tag)
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$08 ; CB 8
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0363,>C0363 ; CALL C0363
|
|
DB $5A ; LEAVE
|
|
; 1601: end
|
|
; 1602: def idconst_add_31(namestr, len, value)
|
|
C0371: ; idconst_add_31()
|
|
; namestr = 2
|
|
; len = 4
|
|
; value = 6
|
|
; 1603: return idglobal_add_41(namestr, len, CONST_TYPE, value)
|
|
JSR _INTERP
|
|
DB $58,$08,$03 ; ENTER 8,3
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0363,>C0363 ; CALL C0363
|
|
DB $5A ; LEAVE
|
|
; 1604: end
|
|
; 1605: def idglobal_init
|
|
C0373: ; idglobal_init()
|
|
; 1606: word ctag
|
|
; ctag = 2
|
|
; 1607:
|
|
; 1608: lineno = 0
|
|
JSR _INTERP
|
|
DB $58,$04,$00 ; ENTER 4,0
|
|
DB $00 ; ZERO
|
|
DB $7A,<D0372,>D0372 ; SAW D0372
|
|
; 1609: codeptr = compbuff
|
|
DB $2C,$00,$60 ; CW 24576
|
|
DB $7A,<D0022,>D0022 ; SAW D0022
|
|
; 1610: lastop = $FF
|
|
DB $2A,$FF ; CB 255
|
|
DB $78,<D0026,>D0026 ; SAB D0026
|
|
; 1611: entrypoint = 0
|
|
DB $00 ; ZERO
|
|
DB $7A,<D0024,>D0024 ; SAW D0024
|
|
; 1612: datasize = 0
|
|
DB $00 ; ZERO
|
|
DB $7A,<D0011,>D0011 ; SAW D0011
|
|
; 1613: globals = 0
|
|
DB $00 ; ZERO
|
|
DB $7A,<D0009,>D0009 ; SAW D0009
|
|
; 1614: lastglobal = idglobal_tbl
|
|
DB $2C,$00,$10 ; CW 4096
|
|
DB $7A,<D0013,>D0013 ; SAW D0013
|
|
; 1615: codetag = -1
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $7A,<D0020,>D0020 ; SAW D0020
|
|
; 1616: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1617: drop idfunc_add_31(@runtime0 + 1, runtime0, ctag)
|
|
DB $26,<D0800,>D0800 ; LA D0800
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0800,>D0800 ; LAB D0800
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1618: drop idfunc_add_31(@RUNTIME0 + 1, RUNTIME0, ctag)
|
|
DB $26,<D0808,>D0808 ; LA D0808
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0808,>D0808 ; LAB D0808
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1619: drop ctag_resolve_21(ctag, @romcall)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0004,>C0004 ; LA C0004
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1620: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1621: drop idfunc_add_31(@runtime1 + 1, runtime1, ctag)
|
|
DB $26,<D0816,>D0816 ; LA D0816
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0816,>D0816 ; LAB D0816
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1622: drop idfunc_add_31(@RUNTIME1 + 1, RUNTIME1, ctag)
|
|
DB $26,<D0824,>D0824 ; LA D0824
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0824,>D0824 ; LAB D0824
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1623: drop ctag_resolve_21(ctag, @syscall)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0006,>C0006 ; LA C0006
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1624: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1625: drop idfunc_add_31(@runtime2 + 1, runtime2, ctag)
|
|
DB $26,<D0832,>D0832 ; LA D0832
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0832,>D0832 ; LAB D0832
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1626: drop idfunc_add_31(@RUNTIME2 + 1, RUNTIME2, ctag)
|
|
DB $26,<D0839,>D0839 ; LA D0839
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0839,>D0839 ; LAB D0839
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1627: drop ctag_resolve_21(ctag, @memset)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0008,>C0008 ; LA C0008
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1628: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1629: drop idfunc_add_31(@runtime3 + 1, runtime3, ctag)
|
|
DB $26,<D0846,>D0846 ; LA D0846
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0846,>D0846 ; LAB D0846
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1630: drop idfunc_add_31(@RUNTIME3 + 1, RUNTIME3, ctag)
|
|
DB $26,<D0853,>D0853 ; LA D0853
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0853,>D0853 ; LAB D0853
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1631: drop ctag_resolve_21(ctag, @memcpy)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0010,>C0010 ; LA C0010
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1632: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1633: drop idfunc_add_31(@runtime4 + 1, runtime4, ctag)
|
|
DB $26,<D0860,>D0860 ; LA D0860
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0860,>D0860 ; LAB D0860
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1634: drop idfunc_add_31(@RUNTIME4 + 1, RUNTIME4, ctag)
|
|
DB $26,<D0865,>D0865 ; LA D0865
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0865,>D0865 ; LAB D0865
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1635: drop ctag_resolve_21(ctag, @cout)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0012,>C0012 ; LA C0012
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1636: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1637: drop idfunc_add_31(@runtime5 + 1, runtime5, ctag)
|
|
DB $26,<D0870,>D0870 ; LA D0870
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0870,>D0870 ; LAB D0870
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1638: drop idfunc_add_31(@RUNTIME5 + 1, RUNTIME5, ctag)
|
|
DB $26,<D0874,>D0874 ; LA D0874
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0874,>D0874 ; LAB D0874
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1639: drop ctag_resolve_21(ctag, @cin)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0014,>C0014 ; LA C0014
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1640: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1641: drop idfunc_add_31(@runtime6 + 1, runtime6, ctag)
|
|
DB $26,<D0878,>D0878 ; LA D0878
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0878,>D0878 ; LAB D0878
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1642: drop idfunc_add_31(@RUNTIME6 + 1, RUNTIME6, ctag)
|
|
DB $26,<D0884,>D0884 ; LA D0884
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0884,>D0884 ; LAB D0884
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1643: drop ctag_resolve_21(ctag, @prstr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0016,>C0016 ; LA C0016
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1644: ctag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$02 ; SLW 2
|
|
; 1645: drop idfunc_add_31(@runtime7 + 1, runtime7, ctag)
|
|
DB $26,<D0890,>D0890 ; LA D0890
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0890,>D0890 ; LAB D0890
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1646: drop idfunc_add_31(@RUNTIME7 + 1, RUNTIME7, ctag)
|
|
DB $26,<D0896,>D0896 ; LA D0896
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $68,<D0896,>D0896 ; LAB D0896
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0369,>C0369 ; CALL C0369
|
|
DB $30 ; DROP
|
|
; 1647: drop ctag_resolve_21(ctag, @rdstr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $26,<C0018,>C0018 ; LA C0018
|
|
DB $54,<C0072,>C0072 ; CALL C0072
|
|
DB $30 ; DROP
|
|
; 1648: end
|
|
DB $5A ; LEAVE
|
|
; 1649: def idlocal_init
|
|
C0375: ; idlocal_init()
|
|
; 1650: locals = 0
|
|
JSR _INTERP
|
|
DB $00 ; ZERO
|
|
DB $78,<D0015,>D0015 ; SAB D0015
|
|
; 1651: framesize = 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $7A,<D0016,>D0016 ; SAW D0016
|
|
; 1652: lastlocal = idlocal_tbl
|
|
DB $2C,$00,$18 ; CW 6144
|
|
DB $7A,<D0018,>D0018 ; SAW D0018
|
|
; 1653: end
|
|
DB $5C ; RET
|
|
; 1654: ;
|
|
; 1655: ; Parser
|
|
; 1656: ;
|
|
; 1657: def parse_term_01
|
|
C0377: ; parse_term_01()
|
|
; 1658: when scan_01()
|
|
JSR _INTERP
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
; 1659: is ID_TKN
|
|
DB $2A,$D6 ; CB 214
|
|
DB $3E,<C0380,>C0380 ; SKPNE C0380
|
|
; 1660: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1661: is INT_TKN
|
|
DB $50,<C0379,>C0379 ; SKIP C0379
|
|
C0380:
|
|
DB $2A,$C9 ; CB 201
|
|
DB $3E,<C0381,>C0381 ; SKPNE C0381
|
|
; 1662: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1663: is CHR_TKN
|
|
DB $50,<C0379,>C0379 ; SKIP C0379
|
|
C0381:
|
|
DB $2A,$C3 ; CB 195
|
|
DB $3E,<C0382,>C0382 ; SKPNE C0382
|
|
; 1664: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1665: is STR_TKN
|
|
DB $50,<C0379,>C0379 ; SKIP C0379
|
|
C0382:
|
|
DB $2A,$D3 ; CB 211
|
|
DB $3E,<C0383,>C0383 ; SKPNE C0383
|
|
; 1666: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1667: is OPEN_PAREN_TKN
|
|
DB $50,<C0379,>C0379 ; SKIP C0379
|
|
C0383:
|
|
DB $2A,$A8 ; CB 168
|
|
DB $3E,<C0384,>C0384 ; SKPNE C0384
|
|
; 1668: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0385,>C0385 ; SKPFLS C0385
|
|
; 1669: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5C ; RET
|
|
; 1670: fin
|
|
C0385:
|
|
C0386:
|
|
; 1671: if token <> CLOSE_PAREN_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$A9 ; CB 169
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0387,>C0387 ; SKPFLS C0387
|
|
; 1672: return parse_err_11(@no_close_paren)
|
|
DB $30 ; DROP
|
|
DB $26,<D0664,>D0664 ; LA D0664
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5C ; RET
|
|
; 1673: fin
|
|
C0387:
|
|
C0388:
|
|
; 1674: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1675: wend
|
|
DB $50,<C0379,>C0379 ; SKIP C0379
|
|
C0384:
|
|
C0379:
|
|
DB $30 ; DROP
|
|
; 1676: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5C ; RET
|
|
; 1677: end
|
|
; 1678: def parse_constval_21(valptr, sizeptr)
|
|
C0390: ; parse_constval_21()
|
|
; valptr = 2
|
|
; sizeptr = 4
|
|
; 1679: byte mod, type
|
|
; mod = 6
|
|
; type = 7
|
|
; 1680: word idptr
|
|
; idptr = 8
|
|
; 1681:
|
|
; 1682: mod = 0
|
|
JSR _INTERP
|
|
DB $58,$0A,$02 ; ENTER 10,2
|
|
DB $00 ; ZERO
|
|
DB $74,$06 ; SLB 6
|
|
; 1683: type = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$07 ; SLB 7
|
|
; 1684: *valptr = 0
|
|
DB $66,$02 ; LLW 2
|
|
DB $00 ; ZERO
|
|
DB $72 ; SW
|
|
; 1685: while !parse_term_01()
|
|
C0392:
|
|
DB $54,<C0377,>C0377 ; CALL C0377
|
|
DB $20 ; NOT
|
|
DB $4C,<C0393,>C0393 ; SKPFLS C0393
|
|
; 1686: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 1687: is SUB_TKN
|
|
DB $2A,$AD ; CB 173
|
|
DB $3E,<C0395,>C0395 ; SKPNE C0395
|
|
; 1688: mod = mod ? 1
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1689: is COMP_TKN
|
|
DB $50,<C0394,>C0394 ; SKIP C0394
|
|
C0395:
|
|
DB $2A,$A3 ; CB 163
|
|
DB $3E,<C0396,>C0396 ; SKPNE C0396
|
|
; 1690: mod = mod ? 2
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$02 ; CB 2
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1691: is LOGIC_NOT_TKN
|
|
DB $50,<C0394,>C0394 ; SKIP C0394
|
|
C0396:
|
|
DB $2A,$A1 ; CB 161
|
|
DB $3E,<C0397,>C0397 ; SKPNE C0397
|
|
; 1692: mod = mod ? 4
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$04 ; CB 4
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1693: is AT_TKN
|
|
DB $50,<C0394,>C0394 ; SKIP C0394
|
|
C0397:
|
|
DB $2A,$C0 ; CB 192
|
|
DB $3E,<C0398,>C0398 ; SKPNE C0398
|
|
; 1694: mod = mod ? 8
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$08 ; CB 8
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1695: otherwise
|
|
DB $50,<C0394,>C0394 ; SKIP C0394
|
|
C0398:
|
|
; 1696: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1697: wend
|
|
C0394:
|
|
DB $30 ; DROP
|
|
; 1698: loop
|
|
DB $50,<C0392,>C0392 ; SKIP C0392
|
|
C0393:
|
|
; 1699: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 1700: is STR_TKN
|
|
DB $2A,$D3 ; CB 211
|
|
DB $3E,<C0401,>C0401 ; SKPNE C0401
|
|
; 1701: *valptr = constval
|
|
DB $66,$02 ; LLW 2
|
|
DB $6A,<D0370,>D0370 ; LAW D0370
|
|
DB $72 ; SW
|
|
; 1702: ^sizeptr = tknlen - 1
|
|
DB $66,$04 ; LLW 4
|
|
DB $68,<D0365,>D0365 ; LAB D0365
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $70 ; SB
|
|
; 1703: type = STR_TYPE
|
|
DB $2A,$80 ; CB 128
|
|
DB $74,$07 ; SLB 7
|
|
; 1704: if mod
|
|
DB $64,$06 ; LLB 6
|
|
DB $4C,<C0402,>C0402 ; SKPFLS C0402
|
|
; 1705: return parse_err_11(@bad_op)
|
|
DB $30 ; DROP
|
|
DB $26,<D0472,>D0472 ; LA D0472
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1706: fin
|
|
C0402:
|
|
C0403:
|
|
; 1707: is CHR_TKN
|
|
DB $50,<C0400,>C0400 ; SKIP C0400
|
|
C0401:
|
|
DB $2A,$C3 ; CB 195
|
|
DB $3E,<C0404,>C0404 ; SKPNE C0404
|
|
; 1708: *valptr = constval
|
|
DB $66,$02 ; LLW 2
|
|
DB $6A,<D0370,>D0370 ; LAW D0370
|
|
DB $72 ; SW
|
|
; 1709: ^sizeptr = 1
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$01 ; CB 1
|
|
DB $70 ; SB
|
|
; 1710: type = BYTE_TYPE
|
|
DB $2A,$02 ; CB 2
|
|
DB $74,$07 ; SLB 7
|
|
; 1711: is INT_TKN
|
|
DB $50,<C0400,>C0400 ; SKIP C0400
|
|
C0404:
|
|
DB $2A,$C9 ; CB 201
|
|
DB $3E,<C0405,>C0405 ; SKPNE C0405
|
|
; 1712: *valptr = constval
|
|
DB $66,$02 ; LLW 2
|
|
DB $6A,<D0370,>D0370 ; LAW D0370
|
|
DB $72 ; SW
|
|
; 1713: ^sizeptr = 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $70 ; SB
|
|
; 1714: type = WORD_TYPE
|
|
DB $2A,$04 ; CB 4
|
|
DB $74,$07 ; SLB 7
|
|
; 1715: is ID_TKN
|
|
DB $50,<C0400,>C0400 ; SKIP C0400
|
|
C0405:
|
|
DB $2A,$D6 ; CB 214
|
|
DB $3E,<C0406,>C0406 ; SKPNE C0406
|
|
; 1716: ^sizeptr = 2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $70 ; SB
|
|
; 1717: idptr = id_lookup_21(tknptr, tknlen)
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $68,<D0365,>D0365 ; LAB D0365
|
|
DB $54,<C0337,>C0337 ; CALL C0337
|
|
DB $76,$08 ; SLW 8
|
|
; 1718: if !idptr
|
|
DB $66,$08 ; LLW 8
|
|
DB $20 ; NOT
|
|
DB $4C,<C0407,>C0407 ; SKPFLS C0407
|
|
; 1719: return parse_err_11(@bad_cnst)
|
|
DB $30 ; DROP
|
|
DB $26,<D0425,>D0425 ; LA D0425
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1720: fin
|
|
C0407:
|
|
C0408:
|
|
; 1721: type = (idptr).idtype
|
|
DB $66,$08 ; LLW 8
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $60 ; LB
|
|
DB $74,$07 ; SLB 7
|
|
; 1722: *valptr = (idptr):idval
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$08 ; LLW 8
|
|
DB $62 ; LW
|
|
DB $72 ; SW
|
|
; 1723: if type & VAR_TYPE and !(mod & 8)
|
|
DB $64,$07 ; LLB 7
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$08 ; CB 8
|
|
DB $14 ; BAND
|
|
DB $20 ; NOT
|
|
DB $24 ; LAND
|
|
DB $4C,<C0409,>C0409 ; SKPFLS C0409
|
|
; 1724: return parse_err_11(@bad_cnst)
|
|
DB $30 ; DROP
|
|
DB $26,<D0425,>D0425 ; LA D0425
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1725: fin
|
|
C0409:
|
|
C0410:
|
|
; 1726: otherwise
|
|
DB $50,<C0400,>C0400 ; SKIP C0400
|
|
C0406:
|
|
; 1727: return parse_err_11(@bad_cnst)
|
|
DB $30 ; DROP
|
|
DB $26,<D0425,>D0425 ; LA D0425
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1728: wend
|
|
C0400:
|
|
DB $30 ; DROP
|
|
; 1729: if mod & 1
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0412,>C0412 ; SKPFLS C0412
|
|
; 1730: *valptr = -*valptr
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$02 ; LLW 2
|
|
DB $62 ; LW
|
|
DB $10 ; NEG
|
|
DB $72 ; SW
|
|
; 1731: fin
|
|
C0412:
|
|
C0413:
|
|
; 1732: if mod & 2
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0414,>C0414 ; SKPFLS C0414
|
|
; 1733: *valptr = #*valptr
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$02 ; LLW 2
|
|
DB $62 ; LW
|
|
DB $12 ; COMP
|
|
DB $72 ; SW
|
|
; 1734: fin
|
|
C0414:
|
|
C0415:
|
|
; 1735: if mod & 4
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$04 ; CB 4
|
|
DB $14 ; BAND
|
|
DB $4C,<C0416,>C0416 ; SKPFLS C0416
|
|
; 1736: *valptr = !*valptr
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$02 ; LLW 2
|
|
DB $62 ; LW
|
|
DB $20 ; NOT
|
|
DB $72 ; SW
|
|
; 1737: fin
|
|
C0416:
|
|
C0417:
|
|
; 1738: return type
|
|
DB $64,$07 ; LLB 7
|
|
DB $5A ; LEAVE
|
|
; 1739: end
|
|
; 1740: def ispostop_01
|
|
C0418: ; ispostop_01()
|
|
; 1741: when token
|
|
JSR _INTERP
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 1742: is OPEN_PAREN_TKN
|
|
DB $2A,$A8 ; CB 168
|
|
DB $3E,<C0421,>C0421 ; SKPNE C0421
|
|
; 1743: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1744: is OPEN_BRACKET_TKN
|
|
DB $50,<C0420,>C0420 ; SKIP C0420
|
|
C0421:
|
|
DB $2A,$DB ; CB 219
|
|
DB $3E,<C0422,>C0422 ; SKPNE C0422
|
|
; 1745: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1746: is DOT_TKN
|
|
DB $50,<C0420,>C0420 ; SKIP C0420
|
|
C0422:
|
|
DB $2A,$AE ; CB 174
|
|
DB $3E,<C0423,>C0423 ; SKPNE C0423
|
|
; 1747: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1748: is COLON_TKN
|
|
DB $50,<C0420,>C0420 ; SKIP C0420
|
|
C0423:
|
|
DB $2A,$BA ; CB 186
|
|
DB $3E,<C0424,>C0424 ; SKPNE C0424
|
|
; 1749: return TRUE
|
|
DB $30 ; DROP
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5C ; RET
|
|
; 1750: wend
|
|
DB $50,<C0420,>C0420 ; SKIP C0420
|
|
C0424:
|
|
C0420:
|
|
DB $30 ; DROP
|
|
; 1751: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5C ; RET
|
|
; 1752: end
|
|
; 1753: def parse_value_11(rvalue)
|
|
C0426: ; parse_value_11()
|
|
; rvalue = 2
|
|
; 1754: byte cparams, deref, type, emit_val
|
|
; cparams = 4
|
|
; deref = 5
|
|
; type = 6
|
|
; emit_val = 7
|
|
; 1755: word optos, idptr, value
|
|
; optos = 8
|
|
; idptr = 10
|
|
; value = 12
|
|
; 1756: byte elem_type, elem_size
|
|
; elem_type = 14
|
|
; elem_size = 15
|
|
; 1757: word elem_offset
|
|
; elem_offset = 16
|
|
; 1758:
|
|
; 1759: deref = rvalue
|
|
JSR _INTERP
|
|
DB $58,$12,$01 ; ENTER 18,1
|
|
DB $66,$02 ; LLW 2
|
|
DB $74,$05 ; SLB 5
|
|
; 1760: optos = opsp
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $76,$08 ; SLW 8
|
|
; 1761: type = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$06 ; SLB 6
|
|
; 1762: emit_val = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$07 ; SLB 7
|
|
; 1763: value = 0
|
|
DB $00 ; ZERO
|
|
DB $76,$0C ; SLW 12
|
|
; 1764:
|
|
; 1765: ;
|
|
; 1766: ; Parse pre-ops
|
|
; 1767: ;
|
|
; 1768: while !parse_term_01()
|
|
C0428:
|
|
DB $54,<C0377,>C0377 ; CALL C0377
|
|
DB $20 ; NOT
|
|
DB $4C,<C0429,>C0429 ; SKPFLS C0429
|
|
; 1769: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 1770: is ADD_TKN
|
|
DB $2A,$AB ; CB 171
|
|
DB $3E,<C0431,>C0431 ; SKPNE C0431
|
|
; 1771: is BPTR_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0431:
|
|
DB $2A,$DE ; CB 222
|
|
DB $3E,<C0432,>C0432 ; SKPNE C0432
|
|
; 1772: if deref
|
|
DB $64,$05 ; LLB 5
|
|
DB $4C,<C0433,>C0433 ; SKPFLS C0433
|
|
; 1773: drop push_op_21(token, 0)
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $00 ; ZERO
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 1774: else
|
|
DB $50,<C0434,>C0434 ; SKIP C0434
|
|
C0433:
|
|
; 1775: type = type ? BPTR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$20 ; CB 32
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1776: deref = deref + 1
|
|
DB $64,$05 ; LLB 5
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $74,$05 ; SLB 5
|
|
; 1777: fin
|
|
C0434:
|
|
; 1778: is WPTR_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0432:
|
|
DB $2A,$AA ; CB 170
|
|
DB $3E,<C0435,>C0435 ; SKPNE C0435
|
|
; 1779: if deref
|
|
DB $64,$05 ; LLB 5
|
|
DB $4C,<C0436,>C0436 ; SKPFLS C0436
|
|
; 1780: drop push_op_21(token, 0)
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $00 ; ZERO
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 1781: else
|
|
DB $50,<C0437,>C0437 ; SKIP C0437
|
|
C0436:
|
|
; 1782: type = type ? WPTR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$40 ; CB 64
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1783: deref = deref + 1
|
|
DB $64,$05 ; LLB 5
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $74,$05 ; SLB 5
|
|
; 1784: fin
|
|
C0437:
|
|
; 1785: is AT_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0435:
|
|
DB $2A,$C0 ; CB 192
|
|
DB $3E,<C0438,>C0438 ; SKPNE C0438
|
|
; 1786: deref = deref - 1
|
|
DB $64,$05 ; LLB 5
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $74,$05 ; SLB 5
|
|
; 1787: is SUB_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0438:
|
|
DB $2A,$AD ; CB 173
|
|
DB $3E,<C0439,>C0439 ; SKPNE C0439
|
|
; 1788: drop push_op_21(token, 0)
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $00 ; ZERO
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 1789: is COMP_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0439:
|
|
DB $2A,$A3 ; CB 163
|
|
DB $3E,<C0440,>C0440 ; SKPNE C0440
|
|
; 1790: drop push_op_21(token, 0)
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $00 ; ZERO
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 1791: is LOGIC_NOT_TKN
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0440:
|
|
DB $2A,$A1 ; CB 161
|
|
DB $3E,<C0441,>C0441 ; SKPNE C0441
|
|
; 1792: drop push_op_21(token, 0)
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $00 ; ZERO
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 1793: otherwise
|
|
DB $50,<C0430,>C0430 ; SKIP C0430
|
|
C0441:
|
|
; 1794: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1795: wend
|
|
C0430:
|
|
DB $30 ; DROP
|
|
; 1796: loop
|
|
DB $50,<C0428,>C0428 ; SKIP C0428
|
|
C0429:
|
|
; 1797: ;
|
|
; 1798: ; Determine terminal type
|
|
; 1799: ;
|
|
; 1800: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 1801: is INT_TKN
|
|
DB $2A,$C9 ; CB 201
|
|
DB $3E,<C0444,>C0444 ; SKPNE C0444
|
|
; 1802: type = type ? CONST_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1803: value = constval
|
|
DB $6A,<D0370,>D0370 ; LAW D0370
|
|
DB $76,$0C ; SLW 12
|
|
; 1804: is CHR_TKN
|
|
DB $50,<C0443,>C0443 ; SKIP C0443
|
|
C0444:
|
|
DB $2A,$C3 ; CB 195
|
|
DB $3E,<C0445,>C0445 ; SKPNE C0445
|
|
; 1805: type = type ? CONST_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1806: value = constval
|
|
DB $6A,<D0370,>D0370 ; LAW D0370
|
|
DB $76,$0C ; SLW 12
|
|
; 1807: is ID_TKN
|
|
DB $50,<C0443,>C0443 ; SKIP C0443
|
|
C0445:
|
|
DB $2A,$D6 ; CB 214
|
|
DB $3E,<C0446,>C0446 ; SKPNE C0446
|
|
; 1808: idptr = id_lookup_21(tknptr, tknlen)
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $68,<D0365,>D0365 ; LAB D0365
|
|
DB $54,<C0337,>C0337 ; CALL C0337
|
|
DB $76,$0A ; SLW 10
|
|
; 1809: if !idptr
|
|
DB $66,$0A ; LLW 10
|
|
DB $20 ; NOT
|
|
DB $4C,<C0447,>C0447 ; SKPFLS C0447
|
|
; 1810: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1811: fin
|
|
C0447:
|
|
C0448:
|
|
; 1812: if !(idptr).idtype
|
|
DB $66,$0A ; LLW 10
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $60 ; LB
|
|
DB $20 ; NOT
|
|
DB $4C,<C0449,>C0449 ; SKPFLS C0449
|
|
; 1813: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1814: fin
|
|
C0449:
|
|
C0450:
|
|
; 1815: type = type ? (idptr).idtype
|
|
DB $64,$06 ; LLB 6
|
|
DB $66,$0A ; LLW 10
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $60 ; LB
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1816: value = (idptr):idval
|
|
DB $66,$0A ; LLW 10
|
|
DB $62 ; LW
|
|
DB $76,$0C ; SLW 12
|
|
; 1817: is CLOSE_PAREN_TKN
|
|
DB $50,<C0443,>C0443 ; SKIP C0443
|
|
C0446:
|
|
DB $2A,$A9 ; CB 169
|
|
DB $3E,<C0451,>C0451 ; SKPNE C0451
|
|
; 1818: type = type ? WORD_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$04 ; CB 4
|
|
DB $16 ; IOR
|
|
DB $74,$06 ; SLB 6
|
|
; 1819: emit_val = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$07 ; SLB 7
|
|
; 1820: otherwise
|
|
DB $50,<C0443,>C0443 ; SKIP C0443
|
|
C0451:
|
|
; 1821: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1822: wend
|
|
C0443:
|
|
DB $30 ; DROP
|
|
; 1823: ;
|
|
; 1824: ; Constant optimizations
|
|
; 1825: ;
|
|
; 1826: if type & CONST_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0453,>C0453 ; SKPFLS C0453
|
|
; 1827: cparams = TRUE
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $74,$04 ; SLB 4
|
|
; 1828: while optos < opsp and cparams
|
|
C0455:
|
|
DB $66,$08 ; LLW 8
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $46 ; ISLT
|
|
DB $64,$04 ; LLB 4
|
|
DB $24 ; LAND
|
|
DB $4C,<C0456,>C0456 ; SKPFLS C0456
|
|
; 1829: when tos_op_01()
|
|
DB $54,<C0317,>C0317 ; CALL C0317
|
|
; 1830: is NEG_TKN
|
|
DB $2A,$AD ; CB 173
|
|
DB $3E,<C0458,>C0458 ; SKPNE C0458
|
|
; 1831: drop pop_op_01()
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $30 ; DROP
|
|
; 1832: value = -value
|
|
DB $66,$0C ; LLW 12
|
|
DB $10 ; NEG
|
|
DB $76,$0C ; SLW 12
|
|
; 1833: is COMP_TKN
|
|
DB $50,<C0457,>C0457 ; SKIP C0457
|
|
C0458:
|
|
DB $2A,$A3 ; CB 163
|
|
DB $3E,<C0459,>C0459 ; SKPNE C0459
|
|
; 1834: drop pop_op_01()
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $30 ; DROP
|
|
; 1835: value = #value
|
|
DB $66,$0C ; LLW 12
|
|
DB $12 ; COMP
|
|
DB $76,$0C ; SLW 12
|
|
; 1836: is LOGIC_NOT_TKN
|
|
DB $50,<C0457,>C0457 ; SKIP C0457
|
|
C0459:
|
|
DB $2A,$A1 ; CB 161
|
|
DB $3E,<C0460,>C0460 ; SKPNE C0460
|
|
; 1837: drop pop_op_01()
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $30 ; DROP
|
|
; 1838: value = !value
|
|
DB $66,$0C ; LLW 12
|
|
DB $20 ; NOT
|
|
DB $76,$0C ; SLW 12
|
|
; 1839: otherwise
|
|
DB $50,<C0457,>C0457 ; SKIP C0457
|
|
C0460:
|
|
; 1840: cparams = FALSE
|
|
DB $00 ; ZERO
|
|
DB $74,$04 ; SLB 4
|
|
; 1841: wend
|
|
C0457:
|
|
DB $30 ; DROP
|
|
; 1842: loop
|
|
DB $50,<C0455,>C0455 ; SKIP C0455
|
|
C0456:
|
|
; 1843: fin
|
|
C0453:
|
|
C0454:
|
|
; 1844: ;
|
|
; 1845: ; Parse post-ops
|
|
; 1846: ;
|
|
; 1847: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 1848: while ispostop_01()
|
|
C0462:
|
|
DB $54,<C0418,>C0418 ; CALL C0418
|
|
DB $4C,<C0463,>C0463 ; SKPFLS C0463
|
|
; 1849: if token == OPEN_BRACKET_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$DB ; CB 219
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0464,>C0464 ; SKPFLS C0464
|
|
; 1850: ;
|
|
; 1851: ; Array
|
|
; 1852: ;
|
|
; 1853: if !emit_val
|
|
DB $64,$07 ; LLB 7
|
|
DB $20 ; NOT
|
|
DB $4C,<C0466,>C0466 ; SKPFLS C0466
|
|
; 1854: if type & ADDR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$0E ; CB 14
|
|
DB $14 ; BAND
|
|
DB $4C,<C0468,>C0468 ; SKPFLS C0468
|
|
; 1855: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0470,>C0470 ; SKPFLS C0470
|
|
; 1856: emit_localaddr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0152,>C0152 ; CALL C0152
|
|
; 1857: else
|
|
DB $50,<C0471,>C0471 ; SKIP C0471
|
|
C0470:
|
|
; 1858: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 1859: fin
|
|
C0471:
|
|
; 1860: elsif type & CONST_TYPE
|
|
DB $50,<C0469,>C0469 ; SKIP C0469
|
|
C0468:
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0472,>C0472 ; SKPFLS C0472
|
|
; 1861: emit_const_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1862: fin
|
|
C0472:
|
|
C0469:
|
|
; 1863: emit_val = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$07 ; SLB 7
|
|
; 1864: fin ; !emit_val
|
|
C0466:
|
|
C0467:
|
|
; 1865: if type & PTR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$60 ; CB 96
|
|
DB $14 ; BAND
|
|
DB $4C,<C0473,>C0473 ; SKPFLS C0473
|
|
; 1866: emit_lw()
|
|
DB $54,<C0112,>C0112 ; CALL C0112
|
|
; 1867: fin
|
|
C0473:
|
|
C0474:
|
|
; 1868: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0475,>C0475 ; SKPFLS C0475
|
|
; 1869: return 0
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 1870: fin
|
|
C0475:
|
|
C0476:
|
|
; 1871: if token <> CLOSE_BRACKET_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$DD ; CB 221
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0477,>C0477 ; SKPFLS C0477
|
|
; 1872: return parse_err_11(@no_close_bracket)
|
|
DB $26,<D0686,>D0686 ; LA D0686
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1873: fin
|
|
C0477:
|
|
C0478:
|
|
; 1874: if type & WORD_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$04 ; CB 4
|
|
DB $14 ; BAND
|
|
DB $4C,<C0479,>C0479 ; SKPFLS C0479
|
|
; 1875: type = WPTR_TYPE
|
|
DB $2A,$40 ; CB 64
|
|
DB $74,$06 ; SLB 6
|
|
; 1876: emit_indexword()
|
|
DB $54,<C0158,>C0158 ; CALL C0158
|
|
; 1877: else
|
|
DB $50,<C0480,>C0480 ; SKIP C0480
|
|
C0479:
|
|
; 1878: type = BPTR_TYPE
|
|
DB $2A,$20 ; CB 32
|
|
DB $74,$06 ; SLB 6
|
|
; 1879: emit_indexbyte()
|
|
DB $54,<C0156,>C0156 ; CALL C0156
|
|
; 1880: fin
|
|
C0480:
|
|
; 1881: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 1882: elsif token == DOT_TKN or token == COLON_TKN
|
|
DB $50,<C0465,>C0465 ; SKIP C0465
|
|
C0464:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$AE ; CB 174
|
|
DB $40 ; ISEQ
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$BA ; CB 186
|
|
DB $40 ; ISEQ
|
|
DB $22 ; LOR
|
|
DB $4C,<C0481,>C0481 ; SKPFLS C0481
|
|
; 1883: ;
|
|
; 1884: ; Dot and Colon
|
|
; 1885: ;
|
|
; 1886: if token == DOT_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$AE ; CB 174
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0482,>C0482 ; SKPFLS C0482
|
|
; 1887: elem_type = BPTR_TYPE
|
|
DB $2A,$20 ; CB 32
|
|
DB $74,$0E ; SLB 14
|
|
; 1888: else
|
|
DB $50,<C0483,>C0483 ; SKIP C0483
|
|
C0482:
|
|
; 1889: elem_type = WPTR_TYPE
|
|
DB $2A,$40 ; CB 64
|
|
DB $74,$0E ; SLB 14
|
|
; 1890: fin
|
|
C0483:
|
|
; 1891: if parse_constval_21(@elem_offset, @elem_size)
|
|
DB $28,$10 ; LLA 16
|
|
DB $28,$0F ; LLA 15
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $4C,<C0484,>C0484 ; SKPFLS C0484
|
|
; 1892: ;
|
|
; 1893: ; Constant structure offset
|
|
; 1894: ;
|
|
; 1895: if !emit_val
|
|
DB $64,$07 ; LLB 7
|
|
DB $20 ; NOT
|
|
DB $4C,<C0486,>C0486 ; SKPFLS C0486
|
|
; 1896: if type & VAR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $4C,<C0488,>C0488 ; SKPFLS C0488
|
|
; 1897: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0490,>C0490 ; SKPFLS C0490
|
|
; 1898: emit_localaddr_10(value + elem_offset)
|
|
DB $66,$0C ; LLW 12
|
|
DB $66,$10 ; LLW 16
|
|
DB $02 ; ADD
|
|
DB $54,<C0152,>C0152 ; CALL C0152
|
|
; 1899: else
|
|
DB $50,<C0491,>C0491 ; SKIP C0491
|
|
C0490:
|
|
; 1900: ; emit_globaladdr_10(value + elem_offset)
|
|
; 1901: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 1902: emit_const_10(elem_offset)
|
|
DB $66,$10 ; LLW 16
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1903: drop emit_binaryop_11(ADD_TKN)
|
|
DB $2A,$AB ; CB 171
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $30 ; DROP
|
|
; 1904: fin
|
|
C0491:
|
|
; 1905: elsif type & CONST_TYPE
|
|
DB $50,<C0489,>C0489 ; SKIP C0489
|
|
C0488:
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0492,>C0492 ; SKPFLS C0492
|
|
; 1906: value = value + elem_offset
|
|
DB $66,$0C ; LLW 12
|
|
DB $66,$10 ; LLW 16
|
|
DB $02 ; ADD
|
|
DB $76,$0C ; SLW 12
|
|
; 1907: emit_const_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1908: else ; FUNC_TYPE
|
|
DB $50,<C0489,>C0489 ; SKIP C0489
|
|
C0492:
|
|
; 1909: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 1910: emit_const_10(elem_offset)
|
|
DB $66,$10 ; LLW 16
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1911: drop emit_binaryop_11(ADD_TKN)
|
|
DB $2A,$AB ; CB 171
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $30 ; DROP
|
|
; 1912: fin
|
|
C0489:
|
|
; 1913: emit_val = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$07 ; SLB 7
|
|
; 1914: else
|
|
DB $50,<C0487,>C0487 ; SKIP C0487
|
|
C0486:
|
|
; 1915: if elem_offset <> 0
|
|
DB $66,$10 ; LLW 16
|
|
DB $00 ; ZERO
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0493,>C0493 ; SKPFLS C0493
|
|
; 1916: emit_const_10(elem_offset)
|
|
DB $66,$10 ; LLW 16
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1917: drop emit_binaryop_11(ADD_TKN)
|
|
DB $2A,$AB ; CB 171
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $30 ; DROP
|
|
; 1918: fin
|
|
C0493:
|
|
C0494:
|
|
; 1919: fin ; !emit_val
|
|
C0487:
|
|
; 1920: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 1921: elsif token == OPEN_BRACKET_TKN
|
|
DB $50,<C0485,>C0485 ; SKIP C0485
|
|
C0484:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$DB ; CB 219
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0495,>C0495 ; SKPFLS C0495
|
|
; 1922: ;
|
|
; 1923: ; Array of arrays
|
|
; 1924: ;
|
|
; 1925: if !emit_val
|
|
DB $64,$07 ; LLB 7
|
|
DB $20 ; NOT
|
|
DB $4C,<C0496,>C0496 ; SKPFLS C0496
|
|
; 1926: if type & ADDR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$0E ; CB 14
|
|
DB $14 ; BAND
|
|
DB $4C,<C0498,>C0498 ; SKPFLS C0498
|
|
; 1927: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0500,>C0500 ; SKPFLS C0500
|
|
; 1928: emit_localaddr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0152,>C0152 ; CALL C0152
|
|
; 1929: else
|
|
DB $50,<C0501,>C0501 ; SKIP C0501
|
|
C0500:
|
|
; 1930: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 1931: fin
|
|
C0501:
|
|
; 1932: elsif type & CONST_TYPE
|
|
DB $50,<C0499,>C0499 ; SKIP C0499
|
|
C0498:
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0502,>C0502 ; SKPFLS C0502
|
|
; 1933: emit_const_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 1934: fin
|
|
C0502:
|
|
C0499:
|
|
; 1935: emit_val = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$07 ; SLB 7
|
|
; 1936: fin ; !emit_val
|
|
C0496:
|
|
C0497:
|
|
; 1937: repeat
|
|
C0504:
|
|
; 1938: if emit_val > 1
|
|
DB $64,$07 ; LLB 7
|
|
DB $2A,$01 ; CB 1
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0505,>C0505 ; SKPFLS C0505
|
|
; 1939: emit_indexword()
|
|
DB $54,<C0158,>C0158 ; CALL C0158
|
|
; 1940: emit_lw()
|
|
DB $54,<C0112,>C0112 ; CALL C0112
|
|
; 1941: fin
|
|
C0505:
|
|
C0506:
|
|
; 1942: emit_val = emit_val + 1
|
|
DB $64,$07 ; LLB 7
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $74,$07 ; SLB 7
|
|
; 1943: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0507,>C0507 ; SKPFLS C0507
|
|
; 1944: return parse_err_11(@bad_expr)
|
|
DB $26,<D0499,>D0499 ; LA D0499
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1945: fin
|
|
C0507:
|
|
C0508:
|
|
; 1946: if token <> CLOSE_BRACKET_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$DD ; CB 221
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0509,>C0509 ; SKPFLS C0509
|
|
; 1947: return parse_err_11(@no_close_bracket)
|
|
DB $26,<D0686,>D0686 ; LA D0686
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1948: fin
|
|
C0509:
|
|
C0510:
|
|
; 1949: until scan_01() <> OPEN_BRACKET_TKN
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $2A,$DB ; CB 219
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0504,>C0504 ; SKPFLS C0504
|
|
C0503:
|
|
; 1950: if elem_type & WPTR_TYPE
|
|
DB $64,$0E ; LLB 14
|
|
DB $2A,$40 ; CB 64
|
|
DB $14 ; BAND
|
|
DB $4C,<C0511,>C0511 ; SKPFLS C0511
|
|
; 1951: emit_indexword()
|
|
DB $54,<C0158,>C0158 ; CALL C0158
|
|
; 1952: else
|
|
DB $50,<C0512,>C0512 ; SKIP C0512
|
|
C0511:
|
|
; 1953: emit_indexbyte()
|
|
DB $54,<C0156,>C0156 ; CALL C0156
|
|
; 1954: fin
|
|
C0512:
|
|
; 1955: else
|
|
DB $50,<C0485,>C0485 ; SKIP C0485
|
|
C0495:
|
|
; 1956: return parse_err_11(@bad_offset)
|
|
DB $26,<D0438,>D0438 ; LA D0438
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1957: fin
|
|
C0485:
|
|
; 1958: type = elem_type
|
|
DB $64,$0E ; LLB 14
|
|
DB $74,$06 ; SLB 6
|
|
; 1959: elsif token == OPEN_PAREN_TKN
|
|
DB $50,<C0465,>C0465 ; SKIP C0465
|
|
C0481:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$A8 ; CB 168
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0513,>C0513 ; SKPFLS C0513
|
|
; 1960: ;
|
|
; 1961: ; Function call
|
|
; 1962: ;
|
|
; 1963: if !emit_val and type & VAR_TYPE
|
|
DB $64,$07 ; LLB 7
|
|
DB $20 ; NOT
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $24 ; LAND
|
|
DB $4C,<C0514,>C0514 ; SKPFLS C0514
|
|
; 1964: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0516,>C0516 ; SKPFLS C0516
|
|
; 1965: emit_localaddr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0152,>C0152 ; CALL C0152
|
|
; 1966: else
|
|
DB $50,<C0517,>C0517 ; SKIP C0517
|
|
C0516:
|
|
; 1967: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 1968: fin
|
|
C0517:
|
|
; 1969: fin
|
|
C0514:
|
|
C0515:
|
|
; 1970: if !(type & FUNC_CONST_TYPE)
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$09 ; CB 9
|
|
DB $14 ; BAND
|
|
DB $20 ; NOT
|
|
DB $4C,<C0518,>C0518 ; SKPFLS C0518
|
|
; 1971: emit_push()
|
|
DB $54,<C0146,>C0146 ; CALL C0146
|
|
; 1972: fin
|
|
C0518:
|
|
C0519:
|
|
; 1973: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 1974: if token <> CLOSE_PAREN_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$A9 ; CB 169
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0520,>C0520 ; SKPFLS C0520
|
|
; 1975: return parse_err_11(@no_close_paren)
|
|
DB $26,<D0664,>D0664 ; LA D0664
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 1976: fin
|
|
C0520:
|
|
C0521:
|
|
; 1977: if type & FUNC_CONST_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$09 ; CB 9
|
|
DB $14 ; BAND
|
|
DB $4C,<C0522,>C0522 ; SKPFLS C0522
|
|
; 1978: emit_call_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0142,>C0142 ; CALL C0142
|
|
; 1979: else
|
|
DB $50,<C0523,>C0523 ; SKIP C0523
|
|
C0522:
|
|
; 1980: emit_pull()
|
|
DB $54,<C0148,>C0148 ; CALL C0148
|
|
; 1981: emit_ical()
|
|
DB $54,<C0144,>C0144 ; CALL C0144
|
|
; 1982: fin
|
|
C0523:
|
|
; 1983: emit_val = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$07 ; SLB 7
|
|
; 1984: type = WORD_TYPE
|
|
DB $2A,$04 ; CB 4
|
|
DB $74,$06 ; SLB 6
|
|
; 1985: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 1986: fin
|
|
C0513:
|
|
C0465:
|
|
; 1987: loop
|
|
DB $50,<C0462,>C0462 ; SKIP C0462
|
|
C0463:
|
|
; 1988: if emit_val
|
|
DB $64,$07 ; LLB 7
|
|
DB $4C,<C0524,>C0524 ; SKPFLS C0524
|
|
; 1989: if rvalue
|
|
DB $66,$02 ; LLW 2
|
|
DB $4C,<C0526,>C0526 ; SKPFLS C0526
|
|
; 1990: if deref and type & PTR_TYPE
|
|
DB $64,$05 ; LLB 5
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$60 ; CB 96
|
|
DB $14 ; BAND
|
|
DB $24 ; LAND
|
|
DB $4C,<C0528,>C0528 ; SKPFLS C0528
|
|
; 1991: if type & BPTR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$20 ; CB 32
|
|
DB $14 ; BAND
|
|
DB $4C,<C0530,>C0530 ; SKPFLS C0530
|
|
; 1992: emit_lb()
|
|
DB $54,<C0110,>C0110 ; CALL C0110
|
|
; 1993: else
|
|
DB $50,<C0531,>C0531 ; SKIP C0531
|
|
C0530:
|
|
; 1994: emit_lw()
|
|
DB $54,<C0112,>C0112 ; CALL C0112
|
|
; 1995: fin
|
|
C0531:
|
|
; 1996: fin
|
|
C0528:
|
|
C0529:
|
|
; 1997: fin
|
|
C0526:
|
|
C0527:
|
|
; 1998: else ; emit_val
|
|
DB $50,<C0525,>C0525 ; SKIP C0525
|
|
C0524:
|
|
; 1999: if type & CONST_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$01 ; CB 1
|
|
DB $14 ; BAND
|
|
DB $4C,<C0532,>C0532 ; SKPFLS C0532
|
|
; 2000: emit_const_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0105,>C0105 ; CALL C0105
|
|
; 2001: elsif deref
|
|
DB $50,<C0533,>C0533 ; SKIP C0533
|
|
C0532:
|
|
DB $64,$05 ; LLB 5
|
|
DB $4C,<C0534,>C0534 ; SKPFLS C0534
|
|
; 2002: if type & FUNC_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$08 ; CB 8
|
|
DB $14 ; BAND
|
|
DB $4C,<C0535,>C0535 ; SKPFLS C0535
|
|
; 2003: emit_call_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0142,>C0142 ; CALL C0142
|
|
; 2004: elsif type & VAR_TYPE
|
|
DB $50,<C0536,>C0536 ; SKIP C0536
|
|
C0535:
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $4C,<C0537,>C0537 ; SKPFLS C0537
|
|
; 2005: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0538,>C0538 ; SKPFLS C0538
|
|
; 2006: if type & BYTE_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0540,>C0540 ; SKPFLS C0540
|
|
; 2007: emit_llb_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0114,>C0114 ; CALL C0114
|
|
; 2008: else
|
|
DB $50,<C0541,>C0541 ; SKIP C0541
|
|
C0540:
|
|
; 2009: emit_llw_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0116,>C0116 ; CALL C0116
|
|
; 2010: fin
|
|
C0541:
|
|
; 2011: else
|
|
DB $50,<C0539,>C0539 ; SKIP C0539
|
|
C0538:
|
|
; 2012: if type & BYTE_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0542,>C0542 ; SKPFLS C0542
|
|
; 2013: emit_lab_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0118,>C0118 ; CALL C0118
|
|
; 2014: else
|
|
DB $50,<C0543,>C0543 ; SKIP C0543
|
|
C0542:
|
|
; 2015: emit_law_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0120,>C0120 ; CALL C0120
|
|
; 2016: fin
|
|
C0543:
|
|
; 2017: fin
|
|
C0539:
|
|
; 2018: elsif type & PTR_TYPE
|
|
DB $50,<C0536,>C0536 ; SKIP C0536
|
|
C0537:
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$60 ; CB 96
|
|
DB $14 ; BAND
|
|
DB $4C,<C0544,>C0544 ; SKPFLS C0544
|
|
; 2019: if type & BPTR_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$20 ; CB 32
|
|
DB $14 ; BAND
|
|
DB $4C,<C0545,>C0545 ; SKPFLS C0545
|
|
; 2020: emit_lb()
|
|
DB $54,<C0110,>C0110 ; CALL C0110
|
|
; 2021: else
|
|
DB $50,<C0546,>C0546 ; SKIP C0546
|
|
C0545:
|
|
; 2022: emit_lw()
|
|
DB $54,<C0112,>C0112 ; CALL C0112
|
|
; 2023: fin
|
|
C0546:
|
|
; 2024: fin
|
|
C0544:
|
|
C0536:
|
|
; 2025: else
|
|
DB $50,<C0533,>C0533 ; SKIP C0533
|
|
C0534:
|
|
; 2026: if type & LOCAL_TYPE
|
|
DB $64,$06 ; LLB 6
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0547,>C0547 ; SKPFLS C0547
|
|
; 2027: emit_localaddr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0152,>C0152 ; CALL C0152
|
|
; 2028: else
|
|
DB $50,<C0548,>C0548 ; SKIP C0548
|
|
C0547:
|
|
; 2029: emit_globaladdr_10(value)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0154,>C0154 ; CALL C0154
|
|
; 2030: fin
|
|
C0548:
|
|
; 2031: fin
|
|
C0533:
|
|
; 2032: fin ; emit_val
|
|
C0525:
|
|
; 2033: while optos < opsp
|
|
C0549:
|
|
DB $66,$08 ; LLW 8
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $46 ; ISLT
|
|
DB $4C,<C0550,>C0550 ; SKPFLS C0550
|
|
; 2034: if !emit_unaryop_11(pop_op_01())
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $54,<C0160,>C0160 ; CALL C0160
|
|
DB $20 ; NOT
|
|
DB $4C,<C0551,>C0551 ; SKPFLS C0551
|
|
; 2035: return parse_err_11(@bad_op)
|
|
DB $26,<D0472,>D0472 ; LA D0472
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2036: fin
|
|
C0551:
|
|
C0552:
|
|
; 2037: loop
|
|
DB $50,<C0549,>C0549 ; SKIP C0549
|
|
C0550:
|
|
; 2038: return type
|
|
DB $64,$06 ; LLB 6
|
|
DB $5A ; LEAVE
|
|
; 2039: end
|
|
; 2040: def parse_constexpr_21(valptr, sizeptr)
|
|
C0553: ; parse_constexpr_21()
|
|
; valptr = 2
|
|
; sizeptr = 4
|
|
; 2041: byte type, size1, size2
|
|
; type = 6
|
|
; size1 = 7
|
|
; size2 = 8
|
|
; 2042: word val1, val2
|
|
; val1 = 9
|
|
; val2 = 11
|
|
; 2043:
|
|
; 2044: type = parse_constval_21(@val1, @size1)
|
|
JSR _INTERP
|
|
DB $58,$0D,$02 ; ENTER 13,2
|
|
DB $28,$09 ; LLA 9
|
|
DB $28,$07 ; LLA 7
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2045: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0555,>C0555 ; SKPFLS C0555
|
|
; 2046: return 0
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2047: fin
|
|
C0555:
|
|
C0556:
|
|
; 2048: size2 = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$08 ; SLB 8
|
|
; 2049: when scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
; 2050: is ADD_TKN
|
|
DB $2A,$AB ; CB 171
|
|
DB $3E,<C0558,>C0558 ; SKPNE C0558
|
|
; 2051: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2052: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0559,>C0559 ; SKPFLS C0559
|
|
; 2053: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2054: fin
|
|
C0559:
|
|
C0560:
|
|
; 2055: *valptr = val1 + val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $02 ; ADD
|
|
DB $72 ; SW
|
|
; 2056: is SUB_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0558:
|
|
DB $2A,$AD ; CB 173
|
|
DB $3E,<C0561,>C0561 ; SKPNE C0561
|
|
; 2057: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2058: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0562,>C0562 ; SKPFLS C0562
|
|
; 2059: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2060: fin
|
|
C0562:
|
|
C0563:
|
|
; 2061: *valptr = val1 - val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $04 ; SUB
|
|
DB $72 ; SW
|
|
; 2062: is MUL_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0561:
|
|
DB $2A,$AA ; CB 170
|
|
DB $3E,<C0564,>C0564 ; SKPNE C0564
|
|
; 2063: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2064: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0565,>C0565 ; SKPFLS C0565
|
|
; 2065: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2066: fin
|
|
C0565:
|
|
C0566:
|
|
; 2067: *valptr = val1 * val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $06 ; MUL
|
|
DB $72 ; SW
|
|
; 2068: is DIV_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0564:
|
|
DB $2A,$AF ; CB 175
|
|
DB $3E,<C0567,>C0567 ; SKPNE C0567
|
|
; 2069: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2070: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0568,>C0568 ; SKPFLS C0568
|
|
; 2071: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2072: fin
|
|
C0568:
|
|
C0569:
|
|
; 2073: *valptr = val1 + val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $02 ; ADD
|
|
DB $72 ; SW
|
|
; 2074: is MOD_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0567:
|
|
DB $2A,$A5 ; CB 165
|
|
DB $3E,<C0570,>C0570 ; SKPNE C0570
|
|
; 2075: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2076: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0571,>C0571 ; SKPFLS C0571
|
|
; 2077: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2078: fin
|
|
C0571:
|
|
C0572:
|
|
; 2079: *valptr = val1 % val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $0A ; DIV,MOD
|
|
DB $72 ; SW
|
|
; 2080: drop
|
|
DB $30 ; DROP
|
|
; 2081: is AND_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0570:
|
|
DB $2A,$A6 ; CB 166
|
|
DB $3E,<C0573,>C0573 ; SKPNE C0573
|
|
; 2082: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2083: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0574,>C0574 ; SKPFLS C0574
|
|
; 2084: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2085: fin
|
|
C0574:
|
|
C0575:
|
|
; 2086: *valptr = val1 & val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $14 ; BAND
|
|
DB $72 ; SW
|
|
; 2087: is OR_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0573:
|
|
DB $2A,$BF ; CB 191
|
|
DB $3E,<C0576,>C0576 ; SKPNE C0576
|
|
; 2088: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2089: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0577,>C0577 ; SKPFLS C0577
|
|
; 2090: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2091: fin
|
|
C0577:
|
|
C0578:
|
|
; 2092: *valptr = val1 ? val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $16 ; IOR
|
|
DB $72 ; SW
|
|
; 2093: is EOR_TKN
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0576:
|
|
DB $2A,$DE ; CB 222
|
|
DB $3E,<C0579,>C0579 ; SKPNE C0579
|
|
; 2094: type = parse_constval_21(@val2, @size2)
|
|
DB $28,$0B ; LLA 11
|
|
DB $28,$08 ; LLA 8
|
|
DB $54,<C0390,>C0390 ; CALL C0390
|
|
DB $74,$06 ; SLB 6
|
|
; 2095: if !type
|
|
DB $64,$06 ; LLB 6
|
|
DB $20 ; NOT
|
|
DB $4C,<C0580,>C0580 ; SKPFLS C0580
|
|
; 2096: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2097: fin
|
|
C0580:
|
|
C0581:
|
|
; 2098: *valptr = val1 ^ val2
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $66,$0B ; LLW 11
|
|
DB $18 ; XOR
|
|
DB $72 ; SW
|
|
; 2099: otherwise
|
|
DB $50,<C0557,>C0557 ; SKIP C0557
|
|
C0579:
|
|
; 2100: *valptr = val1
|
|
DB $66,$02 ; LLW 2
|
|
DB $66,$09 ; LLW 9
|
|
DB $72 ; SW
|
|
; 2101: wend
|
|
C0557:
|
|
DB $30 ; DROP
|
|
; 2102: if size1 > size2
|
|
DB $64,$07 ; LLB 7
|
|
DB $64,$08 ; LLB 8
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0583,>C0583 ; SKPFLS C0583
|
|
; 2103: ^sizeptr = size1
|
|
DB $66,$04 ; LLW 4
|
|
DB $64,$07 ; LLB 7
|
|
DB $70 ; SB
|
|
; 2104: else
|
|
DB $50,<C0584,>C0584 ; SKIP C0584
|
|
C0583:
|
|
; 2105: ^sizeptr = size2
|
|
DB $66,$04 ; LLW 4
|
|
DB $64,$08 ; LLB 8
|
|
DB $70 ; SB
|
|
; 2106: fin
|
|
C0584:
|
|
; 2107: return type
|
|
DB $64,$06 ; LLB 6
|
|
DB $5A ; LEAVE
|
|
; 2108: end
|
|
; 2109: def parse_expr_01
|
|
C0000: ; parse_expr_01()
|
|
; 2110: byte prevmatch, matchop, i
|
|
; prevmatch = 2
|
|
; matchop = 3
|
|
; i = 4
|
|
; 2111: word optos
|
|
; optos = 5
|
|
; 2112:
|
|
; 2113: matchop = 0
|
|
JSR _INTERP
|
|
DB $58,$07,$00 ; ENTER 7,0
|
|
DB $00 ; ZERO
|
|
DB $74,$03 ; SLB 3
|
|
; 2114: optos = opsp
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $76,$05 ; SLW 5
|
|
; 2115: repeat
|
|
C0587:
|
|
; 2116: prevmatch = matchop
|
|
DB $64,$03 ; LLB 3
|
|
DB $74,$02 ; SLB 2
|
|
; 2117: matchop = 0
|
|
DB $00 ; ZERO
|
|
DB $74,$03 ; SLB 3
|
|
; 2118: if parse_value_11(1)
|
|
DB $2A,$01 ; CB 1
|
|
DB $54,<C0426,>C0426 ; CALL C0426
|
|
DB $4C,<C0588,>C0588 ; SKPFLS C0588
|
|
; 2119: matchop = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $74,$03 ; SLB 3
|
|
; 2120: for i = 0 to bops_tblsz
|
|
DB $00 ; ZERO
|
|
C0591:
|
|
DB $6C,$04 ; DLB 4
|
|
DB $2A,$12 ; CB 18
|
|
DB $3A,<C0590,>C0590 ; SKPGT C0590
|
|
DB $0C ; INCR
|
|
; 2121: if token == bops_tbl[i]
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $26,<D0292,>D0292 ; LA D0292
|
|
DB $64,$04 ; LLB 4
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0592,>C0592 ; SKPFLS C0592
|
|
; 2122: matchop = 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $74,$03 ; SLB 3
|
|
; 2123: if bops_prec[i] >= tos_op_prec_11(optos)
|
|
DB $26,<D0311,>D0311 ; LA D0311
|
|
DB $64,$04 ; LLB 4
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $66,$05 ; LLW 5
|
|
DB $54,<C0321,>C0321 ; CALL C0321
|
|
DB $48 ; ISGE
|
|
DB $4C,<C0594,>C0594 ; SKPFLS C0594
|
|
; 2124: if !emit_binaryop_11(pop_op_01())
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $20 ; NOT
|
|
DB $4C,<C0596,>C0596 ; SKPFLS C0596
|
|
; 2125: return parse_err_11(@bad_op)
|
|
DB $30 ; DROP
|
|
DB $26,<D0472,>D0472 ; LA D0472
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2126: fin
|
|
C0596:
|
|
C0597:
|
|
; 2127: fin
|
|
C0594:
|
|
C0595:
|
|
; 2128: drop push_op_21(token, bops_prec[i])
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $26,<D0311,>D0311 ; LA D0311
|
|
DB $64,$04 ; LLB 4
|
|
DB $02 ; IDXB
|
|
DB $60 ; LB
|
|
DB $54,<C0309,>C0309 ; CALL C0309
|
|
DB $30 ; DROP
|
|
; 2129: break
|
|
DB $50,<C0590,>C0590 ; SKIP C0590
|
|
; 2130: fin
|
|
C0592:
|
|
C0593:
|
|
; 2131: next
|
|
DB $50,<C0591,>C0591 ; SKIP C0591
|
|
C0590:
|
|
DB $30 ; DROP
|
|
; 2132: fin
|
|
C0588:
|
|
C0589:
|
|
; 2133: until matchop <> 2
|
|
DB $64,$03 ; LLB 3
|
|
DB $2A,$02 ; CB 2
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0587,>C0587 ; SKPFLS C0587
|
|
C0586:
|
|
; 2134: if matchop == 0 and prevmatch == 2
|
|
DB $64,$03 ; LLB 3
|
|
DB $00 ; ZERO
|
|
DB $40 ; ISEQ
|
|
DB $64,$02 ; LLB 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $40 ; ISEQ
|
|
DB $24 ; LAND
|
|
DB $4C,<C0598,>C0598 ; SKPFLS C0598
|
|
; 2135: return parse_err_11(@missing_op)
|
|
DB $26,<D0710,>D0710 ; LA D0710
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2136: fin
|
|
C0598:
|
|
C0599:
|
|
; 2137: while optos < opsp
|
|
C0600:
|
|
DB $66,$05 ; LLW 5
|
|
DB $6A,<D0362,>D0362 ; LAW D0362
|
|
DB $46 ; ISLT
|
|
DB $4C,<C0601,>C0601 ; SKPFLS C0601
|
|
; 2138: if !emit_binaryop_11(pop_op_01())
|
|
DB $54,<C0313,>C0313 ; CALL C0313
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $20 ; NOT
|
|
DB $4C,<C0602,>C0602 ; SKPFLS C0602
|
|
; 2139: return parse_err_11(@bad_op)
|
|
DB $26,<D0472,>D0472 ; LA D0472
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2140: fin
|
|
C0602:
|
|
C0603:
|
|
; 2141: loop
|
|
DB $50,<C0600,>C0600 ; SKIP C0600
|
|
C0601:
|
|
; 2142: return matchop or prevmatch
|
|
DB $64,$03 ; LLB 3
|
|
DB $64,$02 ; LLB 2
|
|
DB $22 ; LOR
|
|
DB $5A ; LEAVE
|
|
; 2143: end
|
|
; 2144: def parse_setlist_21(addr, type)
|
|
C0604: ; parse_setlist_21()
|
|
; addr = 2
|
|
; type = 4
|
|
; 2145: word nexttype, nextaddr, idptr, saveptr
|
|
; nexttype = 6
|
|
; nextaddr = 8
|
|
; idptr = 10
|
|
; saveptr = 12
|
|
; 2146:
|
|
; 2147: if !(type & VAR_TYPE)
|
|
JSR _INTERP
|
|
DB $58,$0E,$02 ; ENTER 14,2
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $20 ; NOT
|
|
DB $4C,<C0606,>C0606 ; SKPFLS C0606
|
|
; 2148: emit_push()
|
|
DB $54,<C0146,>C0146 ; CALL C0146
|
|
; 2149: fin
|
|
C0606:
|
|
C0607:
|
|
; 2150: nexttype = 0
|
|
DB $00 ; ZERO
|
|
DB $76,$06 ; SLW 6
|
|
; 2151: nextaddr = 0
|
|
DB $00 ; ZERO
|
|
DB $76,$08 ; SLW 8
|
|
; 2152: if scan_01() == ID_TKN
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $2A,$D6 ; CB 214
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0608,>C0608 ; SKPFLS C0608
|
|
; 2153: idptr = id_lookup_21(tknptr, tknlen)
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $68,<D0365,>D0365 ; LAB D0365
|
|
DB $54,<C0337,>C0337 ; CALL C0337
|
|
DB $76,$0A ; SLW 10
|
|
; 2154: if !idptr
|
|
DB $66,$0A ; LLW 10
|
|
DB $20 ; NOT
|
|
DB $4C,<C0610,>C0610 ; SKPFLS C0610
|
|
; 2155: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2156: fin
|
|
C0610:
|
|
C0611:
|
|
; 2157: nexttype = (idptr).idtype
|
|
DB $66,$0A ; LLW 10
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $60 ; LB
|
|
DB $76,$06 ; SLW 6
|
|
; 2158: if type & VAR_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $4C,<C0612,>C0612 ; SKPFLS C0612
|
|
; 2159: nextaddr = (idptr):idval
|
|
DB $66,$0A ; LLW 10
|
|
DB $62 ; LW
|
|
DB $76,$08 ; SLW 8
|
|
; 2160: fin
|
|
C0612:
|
|
C0613:
|
|
; 2161: fin
|
|
C0608:
|
|
C0609:
|
|
; 2162: saveptr = tknptr
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $76,$0C ; SLW 12
|
|
; 2163: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 2164: if nexttype & VAR_TYPE and token == SET_TKN
|
|
DB $66,$06 ; LLW 6
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$BD ; CB 189
|
|
DB $40 ; ISEQ
|
|
DB $24 ; LAND
|
|
DB $4C,<C0614,>C0614 ; SKPFLS C0614
|
|
; 2165: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2166: if type & LOCAL_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0616,>C0616 ; SKPFLS C0616
|
|
; 2167: if type & BYTE_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0618,>C0618 ; SKPFLS C0618
|
|
; 2168: emit_slb_10(nextaddr)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0126,>C0126 ; CALL C0126
|
|
; 2169: else
|
|
DB $50,<C0619,>C0619 ; SKIP C0619
|
|
C0618:
|
|
; 2170: emit_slw_10(nextaddr)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0128,>C0128 ; CALL C0128
|
|
; 2171: fin
|
|
C0619:
|
|
; 2172: else
|
|
DB $50,<C0617,>C0617 ; SKIP C0617
|
|
C0616:
|
|
; 2173: if type & BYTE_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0620,>C0620 ; SKPFLS C0620
|
|
; 2174: emit_sab_10(nextaddr)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0134,>C0134 ; CALL C0134
|
|
; 2175: else
|
|
DB $50,<C0621,>C0621 ; SKIP C0621
|
|
C0620:
|
|
; 2176: emit_saw_10(nextaddr)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0136,>C0136 ; CALL C0136
|
|
; 2177: fin
|
|
C0621:
|
|
; 2178: fin
|
|
C0617:
|
|
; 2179: elsif nexttype & VAR_TYPE and token == SETLIST_TKN
|
|
DB $50,<C0615,>C0615 ; SKIP C0615
|
|
C0614:
|
|
DB $66,$06 ; LLW 6
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$B9 ; CB 185
|
|
DB $40 ; ISEQ
|
|
DB $24 ; LAND
|
|
DB $4C,<C0622,>C0622 ; SKPFLS C0622
|
|
; 2180: if !parse_setlist_21(nextaddr, nexttype)
|
|
DB $66,$08 ; LLW 8
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0604,>C0604 ; CALL C0604
|
|
DB $20 ; NOT
|
|
DB $4C,<C0623,>C0623 ; SKPFLS C0623
|
|
; 2181: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2182: fin
|
|
C0623:
|
|
C0624:
|
|
; 2183: else
|
|
DB $50,<C0615,>C0615 ; SKIP C0615
|
|
C0622:
|
|
; 2184: tknptr = saveptr
|
|
DB $66,$0C ; LLW 12
|
|
DB $7A,<D0368,>D0368 ; SAW D0368
|
|
; 2185: rewind_10(tknptr)
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $54,<C0301,>C0301 ; CALL C0301
|
|
; 2186: nexttype = parse_value_11(0)
|
|
DB $00 ; ZERO
|
|
DB $54,<C0426,>C0426 ; CALL C0426
|
|
DB $76,$06 ; SLW 6
|
|
; 2187: if nexttype <> 0
|
|
DB $66,$06 ; LLW 6
|
|
DB $00 ; ZERO
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0625,>C0625 ; SKPFLS C0625
|
|
; 2188: if token == SET_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$BD ; CB 189
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0627,>C0627 ; SKPFLS C0627
|
|
; 2189: emit_push()
|
|
DB $54,<C0146,>C0146 ; CALL C0146
|
|
; 2190: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2191: emit_pull()
|
|
DB $54,<C0148,>C0148 ; CALL C0148
|
|
; 2192: emit_swap()
|
|
DB $54,<C0216,>C0216 ; CALL C0216
|
|
; 2193: if nexttype & (BYTE_TYPE ? BPTR_TYPE)
|
|
DB $66,$06 ; LLW 6
|
|
DB $2A,$02 ; CB 2
|
|
DB $2A,$20 ; CB 32
|
|
DB $16 ; IOR
|
|
DB $14 ; BAND
|
|
DB $4C,<C0629,>C0629 ; SKPFLS C0629
|
|
; 2194: emit_sb()
|
|
DB $54,<C0122,>C0122 ; CALL C0122
|
|
; 2195: else
|
|
DB $50,<C0630,>C0630 ; SKIP C0630
|
|
C0629:
|
|
; 2196: emit_sw()
|
|
DB $54,<C0124,>C0124 ; CALL C0124
|
|
; 2197: fin
|
|
C0630:
|
|
; 2198: fin
|
|
C0627:
|
|
C0628:
|
|
; 2199: elsif token == SETLIST_TKN
|
|
DB $50,<C0626,>C0626 ; SKIP C0626
|
|
C0625:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$B9 ; CB 185
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0631,>C0631 ; SKPFLS C0631
|
|
; 2200: if !parse_setlist_21(0, nexttype)
|
|
DB $00 ; ZERO
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0604,>C0604 ; CALL C0604
|
|
DB $20 ; NOT
|
|
DB $4C,<C0632,>C0632 ; SKPFLS C0632
|
|
; 2201: return FALSE
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2202: fin
|
|
C0632:
|
|
C0633:
|
|
; 2203: else
|
|
DB $50,<C0626,>C0626 ; SKIP C0626
|
|
C0631:
|
|
; 2204: return parse_err_11(@bad_syntax)
|
|
DB $26,<D0514,>D0514 ; LA D0514
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2205: fin
|
|
C0626:
|
|
; 2206: fin
|
|
C0615:
|
|
; 2207: if type & VAR_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$06 ; CB 6
|
|
DB $14 ; BAND
|
|
DB $4C,<C0634,>C0634 ; SKPFLS C0634
|
|
; 2208: if type & LOCAL_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0636,>C0636 ; SKPFLS C0636
|
|
; 2209: if type & BYTE_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0638,>C0638 ; SKPFLS C0638
|
|
; 2210: emit_slb_10(addr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0126,>C0126 ; CALL C0126
|
|
; 2211: else
|
|
DB $50,<C0639,>C0639 ; SKIP C0639
|
|
C0638:
|
|
; 2212: emit_slw_10(addr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0128,>C0128 ; CALL C0128
|
|
; 2213: fin
|
|
C0639:
|
|
; 2214: else
|
|
DB $50,<C0637,>C0637 ; SKIP C0637
|
|
C0636:
|
|
; 2215: if type & BYTE_TYPE
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0640,>C0640 ; SKPFLS C0640
|
|
; 2216: emit_sab_10(addr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0134,>C0134 ; CALL C0134
|
|
; 2217: else
|
|
DB $50,<C0641,>C0641 ; SKIP C0641
|
|
C0640:
|
|
; 2218: emit_saw_10(addr)
|
|
DB $66,$02 ; LLW 2
|
|
DB $54,<C0136,>C0136 ; CALL C0136
|
|
; 2219: fin
|
|
C0641:
|
|
; 2220: fin
|
|
C0637:
|
|
; 2221: else
|
|
DB $50,<C0635,>C0635 ; SKIP C0635
|
|
C0634:
|
|
; 2222: emit_pull()
|
|
DB $54,<C0148,>C0148 ; CALL C0148
|
|
; 2223: emit_swap()
|
|
DB $54,<C0216,>C0216 ; CALL C0216
|
|
; 2224: if type & (BYTE_TYPE ? BPTR_TYPE)
|
|
DB $66,$04 ; LLW 4
|
|
DB $2A,$02 ; CB 2
|
|
DB $2A,$20 ; CB 32
|
|
DB $16 ; IOR
|
|
DB $14 ; BAND
|
|
DB $4C,<C0642,>C0642 ; SKPFLS C0642
|
|
; 2225: emit_sb()
|
|
DB $54,<C0122,>C0122 ; CALL C0122
|
|
; 2226: else
|
|
DB $50,<C0643,>C0643 ; SKIP C0643
|
|
C0642:
|
|
; 2227: emit_sw()
|
|
DB $54,<C0124,>C0124 ; CALL C0124
|
|
; 2228: fin
|
|
C0643:
|
|
; 2229: fin
|
|
C0635:
|
|
; 2230: return TRUE
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $5A ; LEAVE
|
|
; 2231: end
|
|
; 2232: def parse_stmnt_01
|
|
C0644: ; parse_stmnt_01()
|
|
; 2233: byte type, i
|
|
; type = 2
|
|
; i = 3
|
|
; 2234: word tag_prevbrk, tag_else, tag_endif, tag_while, tag_wend
|
|
; tag_prevbrk = 4
|
|
; tag_else = 6
|
|
; tag_endif = 8
|
|
; tag_while = 10
|
|
; tag_wend = 12
|
|
; 2235: word tag_repeat, tag_for, tag_choice, idptr, saveptr, addr, stepdir
|
|
; tag_repeat = 14
|
|
; tag_for = 16
|
|
; tag_choice = 18
|
|
; idptr = 20
|
|
; saveptr = 22
|
|
; addr = 24
|
|
; stepdir = 26
|
|
; 2236:
|
|
; 2237: if token <> END_TKN and token <> DONE_TKN
|
|
JSR _INTERP
|
|
DB $58,$1C,$00 ; ENTER 28,0
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$87 ; CB 135
|
|
DB $42 ; ISNE
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$98 ; CB 152
|
|
DB $42 ; ISNE
|
|
DB $24 ; LAND
|
|
DB $4C,<C0646,>C0646 ; SKPFLS C0646
|
|
; 2238: prevstmnt = token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $78,<D0904,>D0904 ; SAB D0904
|
|
; 2239: fin
|
|
C0646:
|
|
C0647:
|
|
; 2240: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 2241: is IF_TKN
|
|
DB $2A,$83 ; CB 131
|
|
DB $3E,<C0649,>C0649 ; SKPNE C0649
|
|
; 2242: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2243: tag_else = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$06 ; SLW 6
|
|
; 2244: tag_endif = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$08 ; SLW 8
|
|
; 2245: emit_brfls_10(tag_else)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0204,>C0204 ; CALL C0204
|
|
; 2246: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 2247: repeat
|
|
C0651:
|
|
; 2248: while parse_stmnt_01()
|
|
C0652:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0653,>C0653 ; SKPFLS C0653
|
|
; 2249: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2250: loop
|
|
DB $50,<C0652,>C0652 ; SKIP C0652
|
|
C0653:
|
|
; 2251: if token <> ELSEIF_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$84 ; CB 132
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0654,>C0654 ; SKPFLS C0654
|
|
; 2252: break
|
|
DB $50,<C0650,>C0650 ; SKIP C0650
|
|
; 2253: fin
|
|
C0654:
|
|
C0655:
|
|
; 2254: emit_jump_10(tag_endif)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2255: emit_codetag_10(tag_else)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2256: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0656,>C0656 ; SKPFLS C0656
|
|
; 2257: return 0
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2258: fin
|
|
C0656:
|
|
C0657:
|
|
; 2259: tag_else = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$06 ; SLW 6
|
|
; 2260: emit_brfls_10(tag_else)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0204,>C0204 ; CALL C0204
|
|
; 2261: until FALSE
|
|
DB $00 ; ZERO
|
|
DB $4C,<C0651,>C0651 ; SKPFLS C0651
|
|
C0650:
|
|
; 2262: if token == ELSE_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$85 ; CB 133
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0658,>C0658 ; SKPFLS C0658
|
|
; 2263: emit_jump_10(tag_endif)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2264: emit_codetag_10(tag_else)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2265: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 2266: while parse_stmnt_01()
|
|
C0660:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0661,>C0661 ; SKPFLS C0661
|
|
; 2267: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2268: loop
|
|
DB $50,<C0660,>C0660 ; SKIP C0660
|
|
C0661:
|
|
; 2269: emit_codetag_10(tag_endif)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2270: else
|
|
DB $50,<C0659,>C0659 ; SKIP C0659
|
|
C0658:
|
|
; 2271: emit_codetag_10(tag_else)
|
|
DB $66,$06 ; LLW 6
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2272: emit_codetag_10(tag_endif)
|
|
DB $66,$08 ; LLW 8
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2273: fin
|
|
C0659:
|
|
; 2274: if token <> FIN_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$86 ; CB 134
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0662,>C0662 ; SKPFLS C0662
|
|
; 2275: return parse_err_11(@no_fin)
|
|
DB $30 ; DROP
|
|
DB $26,<D0726,>D0726 ; LA D0726
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2276: fin
|
|
C0662:
|
|
C0663:
|
|
; 2277: is FOR_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0649:
|
|
DB $2A,$8E ; CB 142
|
|
DB $3E,<C0664,>C0664 ; SKPNE C0664
|
|
; 2278: stack_loop = stack_loop + 1
|
|
DB $68,<D0903,>D0903 ; LAB D0903
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $78,<D0903,>D0903 ; SAB D0903
|
|
; 2279: tag_for = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$10 ; SLW 16
|
|
; 2280: tag_prevbrk = break_tag
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $76,$04 ; SLW 4
|
|
; 2281: break_tag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2282: if scan_01() <> ID_TKN
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $2A,$D6 ; CB 214
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0665,>C0665 ; SKPFLS C0665
|
|
; 2283: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2284: fin
|
|
C0665:
|
|
C0666:
|
|
; 2285: idptr = id_lookup_21(tknptr, tknlen)
|
|
DB $6A,<D0368,>D0368 ; LAW D0368
|
|
DB $68,<D0365,>D0365 ; LAB D0365
|
|
DB $54,<C0337,>C0337 ; CALL C0337
|
|
DB $76,$14 ; SLW 20
|
|
; 2286: if idptr
|
|
DB $66,$14 ; LLW 20
|
|
DB $4C,<C0667,>C0667 ; SKPFLS C0667
|
|
; 2287: type = (idptr).idtype
|
|
DB $66,$14 ; LLW 20
|
|
DB $2A,$02 ; CB 2
|
|
DB $02 ; ADD
|
|
DB $60 ; LB
|
|
DB $74,$02 ; SLB 2
|
|
; 2288: addr = (idptr):idval
|
|
DB $66,$14 ; LLW 20
|
|
DB $62 ; LW
|
|
DB $76,$18 ; SLW 24
|
|
; 2289: else
|
|
DB $50,<C0668,>C0668 ; SKIP C0668
|
|
C0667:
|
|
; 2290: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2291: fin
|
|
C0668:
|
|
; 2292: if scan_01() <> SET_TKN
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $2A,$BD ; CB 189
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0669,>C0669 ; SKPFLS C0669
|
|
; 2293: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2294: fin
|
|
C0669:
|
|
C0670:
|
|
; 2295: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0671,>C0671 ; SKPFLS C0671
|
|
; 2296: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2297: fin
|
|
C0671:
|
|
C0672:
|
|
; 2298: emit_codetag_10(tag_for)
|
|
DB $66,$10 ; LLW 16
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2299: if type & LOCAL_TYPE
|
|
DB $64,$02 ; LLB 2
|
|
DB $2A,$10 ; CB 16
|
|
DB $14 ; BAND
|
|
DB $4C,<C0673,>C0673 ; SKPFLS C0673
|
|
; 2300: if type & BYTE_TYPE
|
|
DB $64,$02 ; LLB 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0675,>C0675 ; SKPFLS C0675
|
|
; 2301: emit_dlb_10(addr)
|
|
DB $66,$18 ; LLW 24
|
|
DB $54,<C0130,>C0130 ; CALL C0130
|
|
; 2302: else
|
|
DB $50,<C0676,>C0676 ; SKIP C0676
|
|
C0675:
|
|
; 2303: emit_dlw_10(addr)
|
|
DB $66,$18 ; LLW 24
|
|
DB $54,<C0132,>C0132 ; CALL C0132
|
|
; 2304: fin
|
|
C0676:
|
|
; 2305: else
|
|
DB $50,<C0674,>C0674 ; SKIP C0674
|
|
C0673:
|
|
; 2306: if type & BYTE_TYPE
|
|
DB $64,$02 ; LLB 2
|
|
DB $2A,$02 ; CB 2
|
|
DB $14 ; BAND
|
|
DB $4C,<C0677,>C0677 ; SKPFLS C0677
|
|
; 2307: emit_dab_10(addr)
|
|
DB $66,$18 ; LLW 24
|
|
DB $54,<C0138,>C0138 ; CALL C0138
|
|
; 2308: else
|
|
DB $50,<C0678,>C0678 ; SKIP C0678
|
|
C0677:
|
|
; 2309: emit_daw_10(addr)
|
|
DB $66,$18 ; LLW 24
|
|
DB $54,<C0140,>C0140 ; CALL C0140
|
|
; 2310: fin
|
|
C0678:
|
|
; 2311: fin
|
|
C0674:
|
|
; 2312: stepdir = 1
|
|
DB $2A,$01 ; CB 1
|
|
DB $76,$1A ; SLW 26
|
|
; 2313: if token == TO_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$8F ; CB 143
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0679,>C0679 ; SKPFLS C0679
|
|
; 2314: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2315: elsif token == DOWNTO_TKN
|
|
DB $50,<C0680,>C0680 ; SKIP C0680
|
|
C0679:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$90 ; CB 144
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0681,>C0681 ; SKPFLS C0681
|
|
; 2316: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2317: stepdir = -1
|
|
DB $2C,$FF,$FF ; CW -1
|
|
DB $76,$1A ; SLW 26
|
|
; 2318: fin
|
|
C0681:
|
|
C0680:
|
|
; 2319: if stepdir > 0
|
|
DB $66,$1A ; LLW 26
|
|
DB $00 ; ZERO
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0682,>C0682 ; SKPFLS C0682
|
|
; 2320: emit_brgt_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0206,>C0206 ; CALL C0206
|
|
; 2321: else
|
|
DB $50,<C0683,>C0683 ; SKIP C0683
|
|
C0682:
|
|
; 2322: emit_brlt_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0208,>C0208 ; CALL C0208
|
|
; 2323: fin
|
|
C0683:
|
|
; 2324: if token == STEP_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$91 ; CB 145
|
|
DB $40 ; ISEQ
|
|
DB $4C,<C0684,>C0684 ; SKPFLS C0684
|
|
; 2325: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2326: if stepdir > 0
|
|
DB $66,$1A ; LLW 26
|
|
DB $00 ; ZERO
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0686,>C0686 ; SKPFLS C0686
|
|
; 2327: drop emit_binaryop_11(ADD_TKN)
|
|
DB $2A,$AB ; CB 171
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $30 ; DROP
|
|
; 2328: else
|
|
DB $50,<C0687,>C0687 ; SKIP C0687
|
|
C0686:
|
|
; 2329: drop emit_binaryop_11(SUB_TKN)
|
|
DB $2A,$AD ; CB 173
|
|
DB $54,<C0171,>C0171 ; CALL C0171
|
|
DB $30 ; DROP
|
|
; 2330: fin
|
|
C0687:
|
|
; 2331: else
|
|
DB $50,<C0685,>C0685 ; SKIP C0685
|
|
C0684:
|
|
; 2332: if stepdir > 0
|
|
DB $66,$1A ; LLW 26
|
|
DB $00 ; ZERO
|
|
DB $44 ; ISGT
|
|
DB $4C,<C0688,>C0688 ; SKPFLS C0688
|
|
; 2333: drop emit_unaryop_11(INC_TKN)
|
|
DB $2A,$C1 ; CB 193
|
|
DB $54,<C0160,>C0160 ; CALL C0160
|
|
DB $30 ; DROP
|
|
; 2334: else
|
|
DB $50,<C0689,>C0689 ; SKIP C0689
|
|
C0688:
|
|
; 2335: drop emit_unaryop_11(DEC_TKN)
|
|
DB $2A,$C4 ; CB 196
|
|
DB $54,<C0160,>C0160 ; CALL C0160
|
|
DB $30 ; DROP
|
|
; 2336: fin
|
|
C0689:
|
|
; 2337: fin
|
|
C0685:
|
|
; 2338: while parse_stmnt_01()
|
|
C0690:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0691,>C0691 ; SKPFLS C0691
|
|
; 2339: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2340: loop
|
|
DB $50,<C0690,>C0690 ; SKIP C0690
|
|
C0691:
|
|
; 2341: if token <> NEXT_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$92 ; CB 146
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0692,>C0692 ; SKPFLS C0692
|
|
; 2342: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2343: fin
|
|
C0692:
|
|
C0693:
|
|
; 2344: emit_jump_10(tag_for)
|
|
DB $66,$10 ; LLW 16
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2345: emit_codetag_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2346: emit_drop()
|
|
DB $54,<C0214,>C0214 ; CALL C0214
|
|
; 2347: break_tag = tag_prevbrk
|
|
DB $66,$04 ; LLW 4
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2348: stack_loop = stack_loop - 1
|
|
DB $68,<D0903,>D0903 ; LAB D0903
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $78,<D0903,>D0903 ; SAB D0903
|
|
; 2349: is WHILE_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0664:
|
|
DB $2A,$88 ; CB 136
|
|
DB $3E,<C0694,>C0694 ; SKPNE C0694
|
|
; 2350: tag_while = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$0A ; SLW 10
|
|
; 2351: tag_wend = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$0C ; SLW 12
|
|
; 2352: tag_prevbrk = break_tag
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $76,$04 ; SLW 4
|
|
; 2353: break_tag = tag_wend
|
|
DB $66,$0C ; LLW 12
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2354: emit_codetag_10(tag_while)
|
|
DB $66,$0A ; LLW 10
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2355: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2356: emit_brfls_10(tag_wend)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0204,>C0204 ; CALL C0204
|
|
; 2357: while parse_stmnt_01()
|
|
C0695:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0696,>C0696 ; SKPFLS C0696
|
|
; 2358: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2359: loop
|
|
DB $50,<C0695,>C0695 ; SKIP C0695
|
|
C0696:
|
|
; 2360: if token <> LOOP_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$89 ; CB 137
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0697,>C0697 ; SKPFLS C0697
|
|
; 2361: return parse_err_11(@no_loop)
|
|
DB $30 ; DROP
|
|
DB $26,<D0738,>D0738 ; LA D0738
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2362: fin
|
|
C0697:
|
|
C0698:
|
|
; 2363: emit_jump_10(tag_while)
|
|
DB $66,$0A ; LLW 10
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2364: emit_codetag_10(tag_wend)
|
|
DB $66,$0C ; LLW 12
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2365: break_tag = tag_prevbrk
|
|
DB $66,$04 ; LLW 4
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2366: is REPEAT_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0694:
|
|
DB $2A,$93 ; CB 147
|
|
DB $3E,<C0699,>C0699 ; SKPNE C0699
|
|
; 2367: tag_repeat = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$0E ; SLW 14
|
|
; 2368: tag_prevbrk = break_tag
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $76,$04 ; SLW 4
|
|
; 2369: break_tag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2370: emit_codetag_10(tag_repeat)
|
|
DB $66,$0E ; LLW 14
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2371: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 2372: while parse_stmnt_01()
|
|
C0700:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0701,>C0701 ; SKPFLS C0701
|
|
; 2373: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2374: loop
|
|
DB $50,<C0700,>C0700 ; SKIP C0700
|
|
C0701:
|
|
; 2375: if token <> UNTIL_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$94 ; CB 148
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0702,>C0702 ; SKPFLS C0702
|
|
; 2376: return parse_err_11(@no_until)
|
|
DB $30 ; DROP
|
|
DB $26,<D0751,>D0751 ; LA D0751
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2377: fin
|
|
C0702:
|
|
C0703:
|
|
; 2378: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2379: emit_brfls_10(tag_repeat)
|
|
DB $66,$0E ; LLW 14
|
|
DB $54,<C0204,>C0204 ; CALL C0204
|
|
; 2380: emit_codetag_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2381: break_tag = tag_prevbrk
|
|
DB $66,$04 ; LLW 4
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2382: is CASE_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0699:
|
|
DB $2A,$8A ; CB 138
|
|
DB $3E,<C0704,>C0704 ; SKPNE C0704
|
|
; 2383: stack_loop = stack_loop + 1
|
|
DB $68,<D0903,>D0903 ; LAB D0903
|
|
DB $2A,$01 ; CB 1
|
|
DB $02 ; ADD
|
|
DB $78,<D0903,>D0903 ; SAB D0903
|
|
; 2384: tag_choice = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$12 ; SLW 18
|
|
; 2385: tag_prevbrk = break_tag
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $76,$04 ; SLW 4
|
|
; 2386: break_tag = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2387: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2388: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2389: while token <> ENDCASE_TKN
|
|
C0705:
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$8D ; CB 141
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0706,>C0706 ; SKPFLS C0706
|
|
; 2390: when token
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
; 2391: is OF_TKN
|
|
DB $2A,$8B ; CB 139
|
|
DB $3E,<C0708,>C0708 ; SKPNE C0708
|
|
; 2392: if !parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $20 ; NOT
|
|
DB $4C,<C0709,>C0709 ; SKPFLS C0709
|
|
; 2393: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2394: fin
|
|
C0709:
|
|
C0710:
|
|
; 2395: emit_brne_10(tag_choice)
|
|
DB $66,$12 ; LLW 18
|
|
DB $54,<C0210,>C0210 ; CALL C0210
|
|
; 2396: while parse_stmnt_01()
|
|
C0711:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0712,>C0712 ; SKPFLS C0712
|
|
; 2397: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2398: loop
|
|
DB $50,<C0711,>C0711 ; SKIP C0711
|
|
C0712:
|
|
; 2399: emit_jump_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2400: emit_codetag_10(tag_choice)
|
|
DB $66,$12 ; LLW 18
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2401: tag_choice = ctag_new_01()
|
|
DB $54,<C0068,>C0068 ; CALL C0068
|
|
DB $76,$12 ; SLW 18
|
|
; 2402: is DEFAULT_TKN
|
|
DB $50,<C0707,>C0707 ; SKIP C0707
|
|
C0708:
|
|
DB $2A,$8C ; CB 140
|
|
DB $3E,<C0713,>C0713 ; SKPNE C0713
|
|
; 2403: drop scan_01()
|
|
DB $54,<C0248,>C0248 ; CALL C0248
|
|
DB $30 ; DROP
|
|
; 2404: while parse_stmnt_01()
|
|
C0714:
|
|
DB $54,<C0644,>C0644 ; CALL C0644
|
|
DB $4C,<C0715,>C0715 ; SKPFLS C0715
|
|
; 2405: drop nextln_01()
|
|
DB $54,<C0303,>C0303 ; CALL C0303
|
|
DB $30 ; DROP
|
|
; 2406: loop
|
|
DB $50,<C0714,>C0714 ; SKIP C0714
|
|
C0715:
|
|
; 2407: if token <> ENDCASE_TKN
|
|
DB $68,<D0364,>D0364 ; LAB D0364
|
|
DB $2A,$8D ; CB 141
|
|
DB $42 ; ISNE
|
|
DB $4C,<C0716,>C0716 ; SKPFLS C0716
|
|
; 2408: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2409: fin
|
|
C0716:
|
|
C0717:
|
|
; 2410: otherwise
|
|
DB $50,<C0707,>C0707 ; SKIP C0707
|
|
C0713:
|
|
; 2411: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2412: wend
|
|
C0707:
|
|
DB $30 ; DROP
|
|
; 2413: loop
|
|
DB $50,<C0705,>C0705 ; SKIP C0705
|
|
C0706:
|
|
; 2414: emit_codetag_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0084,>C0084 ; CALL C0084
|
|
; 2415: emit_drop()
|
|
DB $54,<C0214,>C0214 ; CALL C0214
|
|
; 2416: break_tag = tag_prevbrk
|
|
DB $66,$04 ; LLW 4
|
|
DB $7A,<D0907,>D0907 ; SAW D0907
|
|
; 2417: stack_loop = stack_loop - 1
|
|
DB $68,<D0903,>D0903 ; LAB D0903
|
|
DB $2A,$01 ; CB 1
|
|
DB $04 ; SUB
|
|
DB $78,<D0903,>D0903 ; SAB D0903
|
|
; 2418: is BREAK_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0704:
|
|
DB $2A,$9A ; CB 154
|
|
DB $3E,<C0719,>C0719 ; SKPNE C0719
|
|
; 2419: if break_tag
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $4C,<C0720,>C0720 ; SKPFLS C0720
|
|
; 2420: emit_jump_10(break_tag)
|
|
DB $6A,<D0907,>D0907 ; LAW D0907
|
|
DB $54,<C0212,>C0212 ; CALL C0212
|
|
; 2421: else
|
|
DB $50,<C0721,>C0721 ; SKIP C0721
|
|
C0720:
|
|
; 2422: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2423: fin
|
|
C0721:
|
|
; 2424: is RETURN_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0719:
|
|
DB $2A,$99 ; CB 153
|
|
DB $3E,<C0722,>C0722 ; SKPNE C0722
|
|
; 2425: if infunc
|
|
DB $68,<D0902,>D0902 ; LAB D0902
|
|
DB $4C,<C0723,>C0723 ; SKPFLS C0723
|
|
; 2426: for i = 1 to stack_loop
|
|
DB $2A,$01 ; CB 1
|
|
C0726:
|
|
DB $6C,$03 ; DLB 3
|
|
DB $68,<D0903,>D0903 ; LAB D0903
|
|
DB $3A,<C0725,>C0725 ; SKPGT C0725
|
|
DB $0C ; INCR
|
|
; 2427: emit_drop()
|
|
DB $54,<C0214,>C0214 ; CALL C0214
|
|
; 2428: next
|
|
DB $50,<C0726,>C0726 ; SKIP C0726
|
|
C0725:
|
|
DB $30 ; DROP
|
|
; 2429: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2430: emit_leave_10(framesize)
|
|
DB $6A,<D0016,>D0016 ; LAW D0016
|
|
DB $54,<C0218,>C0218 ; CALL C0218
|
|
; 2431: else
|
|
DB $50,<C0724,>C0724 ; SKIP C0724
|
|
C0723:
|
|
; 2432: return parse_err_11(@bad_stmnt)
|
|
DB $30 ; DROP
|
|
DB $26,<D0486,>D0486 ; LA D0486
|
|
DB $54,<C0058,>C0058 ; CALL C0058
|
|
DB $5A ; LEAVE
|
|
; 2433: fin
|
|
C0724:
|
|
; 2434: is EXIT_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0722:
|
|
DB $2A,$9C ; CB 156
|
|
DB $3E,<C0727,>C0727 ; SKPNE C0727
|
|
; 2435: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2436: emit_exit()
|
|
DB $54,<C0228,>C0228 ; CALL C0228
|
|
; 2437: is DROP_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0727:
|
|
DB $2A,$97 ; CB 151
|
|
DB $3E,<C0728,>C0728 ; SKPNE C0728
|
|
; 2438: drop parse_expr_01()
|
|
DB $54,<C0000,>C0000 ; CALL C0000
|
|
DB $30 ; DROP
|
|
; 2439: emit_drop()
|
|
DB $54,<C0214,>C0214 ; CALL C0214
|
|
; 2440: is ELSE_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0728:
|
|
DB $2A,$85 ; CB 133
|
|
DB $3E,<C0729,>C0729 ; SKPNE C0729
|
|
; 2441: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2442: is ELSEIF_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0729:
|
|
DB $2A,$84 ; CB 132
|
|
DB $3E,<C0730,>C0730 ; SKPNE C0730
|
|
; 2443: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2444: is FIN_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0730:
|
|
DB $2A,$86 ; CB 134
|
|
DB $3E,<C0731,>C0731 ; SKPNE C0731
|
|
; 2445: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2446: is LOOP_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0731:
|
|
DB $2A,$89 ; CB 137
|
|
DB $3E,<C0732,>C0732 ; SKPNE C0732
|
|
; 2447: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2448: is UNTIL_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0732:
|
|
DB $2A,$94 ; CB 148
|
|
DB $3E,<C0733,>C0733 ; SKPNE C0733
|
|
; 2449: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2450: is NEXT_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0733:
|
|
DB $2A,$92 ; CB 146
|
|
DB $3E,<C0734,>C0734 ; SKPNE C0734
|
|
; 2451: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2452: is OF_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0734:
|
|
DB $2A,$8B ; CB 139
|
|
DB $3E,<C0735,>C0735 ; SKPNE C0735
|
|
; 2453: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2454: is DEFAULT_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0735:
|
|
DB $2A,$8C ; CB 140
|
|
DB $3E,<C0736,>C0736 ; SKPNE C0736
|
|
; 2455: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2456: is ENDCASE_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0736:
|
|
DB $2A,$8D ; CB 141
|
|
DB $3E,<C0737,>C0737 ; SKPNE C0737
|
|
; 2457: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2458: is END_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0737:
|
|
DB $2A,$87 ; CB 135
|
|
DB $3E,<C0738,>C0738 ; SKPNE C0738
|
|
; 2459: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2460: is DONE_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0738:
|
|
DB $2A,$98 ; CB 152
|
|
DB $3E,<C0739,>C0739 ; SKPNE C0739
|
|
; 2461: return FALSE
|
|
DB $30 ; DROP
|
|
DB $00 ; ZERO
|
|
DB $5A ; LEAVE
|
|
; 2462: is IFUNC_TKN
|
|
DB $50,<C0648,>C0648 ; SKIP C0648
|
|
C0739:
|
|
Bad ID type
|
|
START: ; JSR INTERP
|
|
Bad ID type
|
|
DB $5C ; RET
|