Apple-2-Tools
/
VM02
mirror of https://github.com/dschmenk/VM02.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
VM02/plasma2/plide.s

14767 lines
332 KiB
ArmAsm
Executable File
Raw Permalink Blame History

.INCLUDE "plstub.s"
; 1: ;
; 2: ; Global constants
; 3: ;
; 4: const FALSE = 0
; FALSE = 0
; 5: const TRUE = !FALSE
; TRUE = -1
; 6: ;
; 7: ; Hardware constants
; 8: ;
; 9: const csw = $0036
; csw = 54
; 10: const speaker = $C030
; speaker = 49200
; 11: const showgraphics = $C050
; showgraphics = 49232
; 12: const showtext = $C051
; showtext = 49233
; 13: const showfull = $C052
; showfull = 49234
; 14: const showmix = $C053
; showmix = 49235
; 15: const showpage1 = $C054
; showpage1 = 49236
; 16: const showpage2 = $C055
; showpage2 = 49237
; 17: const showlores = $C056
; showlores = 49238
; 18: const showhires = $C057
; showhires = 49239
; 19: const pushbttn1 = $C061
; pushbttn1 = 49249
; 20: const pushbttn2 = $C062
; pushbttn2 = 49250
; 21: const pushbttn3 = $C063
; pushbttn3 = 49251
; 22: const keyboard = $C000
; keyboard = 49152
; 23: const keystrobe = $C010
; keystrobe = 49168
; 24: const keyenter = $8D
; keyenter = 141
; 25: const keyspace = $A0
; keyspace = 160
; 26: const keyarrowup = $8B
; keyarrowup = 139
; 27: const keyarrowdown = $8A
; keyarrowdown = 138
; 28: const keyarrowleft = $88
; keyarrowleft = 136
; 29: const keyarrowright = $95
; keyarrowright = 149
; 30: const keyescape = $9B
; keyescape = 155
; 31: const keyctrla = $81
; keyctrla = 129
; 32: const keyctrlb = $82
; keyctrlb = 130
; 33: const keyctrlc = $83
; keyctrlc = 131
; 34: const keyctrld = $84
; keyctrld = 132
; 35: const keyctrle = $85
; keyctrle = 133
; 36: const keyctrli = $89
; keyctrli = 137
; 37: const keyctrlk = $8B
; keyctrlk = 139
; 38: const keyctrll = $8C
; keyctrll = 140
; 39: const keyctrln = $8E
; keyctrln = 142
; 40: const keyctrlo = $8F
; keyctrlo = 143
; 41: const keyctrlp = $90
; keyctrlp = 144
; 42: const keyctrlq = $91
; keyctrlq = 145
; 43: const keyctrlr = $92
; keyctrlr = 146
; 44: const keyctrls = $93
; keyctrls = 147
; 45: const keyctrlt = $94
; keyctrlt = 148
; 46: const keyctrlu = $95
; keyctrlu = 149
; 47: const keyctrlv = $96
; keyctrlv = 150
; 48: const keyctrlw = $97
; keyctrlw = 151
; 49: const keyctrlx = $98
; keyctrlx = 152
; 50: const keyctrlz = $9A
; keyctrlz = 154
; 51: const keydelete = $FF
; keydelete = 255
; 52: const getbuff = $01FF
; getbuff = 511
; 53: const argbuff = $2006
; argbuff = 8198
; 54: word txtscrn[] = $0400,$0480,$0500,$0580,$0600,$0680,$0700,$0780
D0000: ; txtscrn
DW $0400
DW $0480
DW $0500
DW $0580
DW $0600
DW $0680
DW $0700
DW $0780
; 55: word = $0428,$04A8,$0528,$05A8,$0628,$06A8,$0728,$07A8
DW $0428
DW $04A8
DW $0528
DW $05A8
DW $0628
DW $06A8
DW $0728
DW $07A8
; 56: word = $0450,$04D0,$0550,$05D0,$0650,$06D0,$0750,$07D0
DW $0450
DW $04D0
DW $0550
DW $05D0
DW $0650
DW $06D0
DW $0750
DW $07D0
; 57: ;
; 58: ; Data and text buffer constants
; 59: ;
; 60: const machid = $BF98
; machid = 49048
; 61: const maxlines = 626
; maxlines = 626
; 62: const maxfill = 640
; maxfill = 640
; 63: const iobuffer = $0800
; iobuffer = 2048
; 64: const databuff = $0C00
; databuff = 3072
; 65: const strlinbuf = $1000
; strlinbuf = 4096
; 66: const strheapmap = $1500
; strheapmap = 5376
; 67: const strheapmsz = $70 ; = memory@16 bytes per bit map, 128 bytes per 8 bit map, 1K bytes per 8 byte map
; strheapmsz = 112
; 68: const maxlnlen = 79
; maxlnlen = 79
; 69: const strheap = $7000
; strheap = 28672
; 70: const strheasz = $3800
; strheasz = 14336
; 71: const codebuff = $A800
; codebuff = 43008
; 72: const codebuffsz = $1000
; codebuffsz = 4096
; 73: const pgjmp = 16
; pgjmp = 16
; 74: const changed = 1
; changed = 1
; 75: const insmode = 2
; insmode = 2
; 76: const showcurs = 4
; showcurs = 4
; 77: const uppercase = 8
; uppercase = 8
; 78: const shiftlock = 128
; shiftlock = 128
; 79: ;
; 80: ; Editor variables
; 81: ;
; 82: byte nullstr[] = ""
D0048: ; nullstr
DB $00
; 83: byte version[] = "PLASMA ][ IDE VERSION 0.8 "
D0049: ; version
DB $1A
DB $50,$4C,$41,$53,$4D,$41,$20,$5D
DB $5B,$20,$49,$44,$45,$20,$56,$45
DB $52,$53,$49,$4F,$4E,$20,$30,$2E
DB $38,$20
; 84: byte errorstr[] = "ERROR: $"
D0076: ; errorstr
DB $08
DB $45,$52,$52,$4F,$52,$3A,$20,$24
; 85: byte okstr[] = "OK"
D0085: ; okstr
DB $02
DB $4F,$4B
; 86: byte perr
D0088: DS 1 ; perr
; 87: byte outofmem[] = "OUT OF MEMORY!"
D0089: ; outofmem
DB $0E
DB $4F,$55,$54,$20,$4F,$46,$20,$4D
DB $45,$4D,$4F,$52,$59,$21
; 88: byte losechng[] = "LOSE CHANGES TO FILE (Y/N)?"
D0104: ; losechng
DB $1B
DB $4C,$4F,$53,$45,$20,$43,$48,$41
DB $4E,$47,$45,$53,$20,$54,$4F,$20
DB $46,$49,$4C,$45,$20,$28,$59,$2F
DB $4E,$29,$3F
; 89: ;byte emiterr[] = "EMIT CODE/DATA MISMATCH"
; 90: byte untitled[] = "UNTITLED"
D0132: ; untitled
DB $08
DB $55,$4E,$54,$49,$54,$4C,$45,$44
; 91: byte txtfile[64] = "UNTITLED.PLA"
D0141: ; txtfile
DB $0C
DB $55,$4E,$54,$49,$54,$4C,$45,$44
DB $2E,$50,$4C,$41
DS $33
; 92: byte flags = 0
D0192: ; flags
DB $00
; 93: byte flash = 0
D0193: ; flash
DB $00
; 94: byte cursx, cursy, scrnleft, curscol, underchr, curschr
D0194: DS 1 ; cursx
D0195: DS 1 ; cursy
D0196: DS 1 ; scrnleft
D0197: DS 1 ; curscol
D0198: DS 1 ; underchr
D0199: DS 1 ; curschr
; 95: word cursrow, scrntop, cursptr
D0200: DS 2 ; cursrow
D0202: DS 2 ; scrntop
D0204: DS 2 ; cursptr
; 96: word numlines = 0
D0206: ; numlines
DW $0000
; 97: word cutbuf = 0
D0208: ; cutbuf
DW $0000
; 98: word keyin_01
D0210: DS 2 ; keyin_01
; 99: ;
; 100: ; Predeclared functions
; 101: ;
; 102: func cmdmode
; 103: ;
; 104: ; Compiler variables
; 105: ;
; 106: ;
; 107: ; Tokens
; 108: ;
; 109: const ID_TKN = $D6 ; V
; ID_TKN = 214
; 110: const CHR_TKN = $C3 ; C
; CHR_TKN = 195
; 111: const INT_TKN = $C9 ; I
; INT_TKN = 201
; 112: const STR_TKN = $D3 ; S
; STR_TKN = 211
; 113: const EOL_TKN = $02
; EOL_TKN = 2
; 114: const EOF_TKN = $01
; EOF_TKN = 1
; 115: const ERR_TKN = $00
; ERR_TKN = 0
; 116: ;
; 117: ; Binary operand operators
; 118: ;
; 119: const SET_TKN = $BD ; =
; SET_TKN = 189
; 120: const SETLIST_TKN = $B9 ; =,
; SETLIST_TKN = 185
; 121: const ADD_TKN = $AB ; +
; ADD_TKN = 171
; 122: const SUB_TKN = $AD ; -
; SUB_TKN = 173
; 123: const MUL_TKN = $AA ; *
; MUL_TKN = 170
; 124: const DIV_TKN = $AF ; /
; DIV_TKN = 175
; 125: const MOD_TKN = $A5 ; %
; MOD_TKN = 165
; 126: const OR_TKN = $BF ; ?
; OR_TKN = 191
; 127: const EOR_TKN = $DE ; ^
; EOR_TKN = 222
; 128: const AND_TKN = $A6 ; &
; AND_TKN = 166
; 129: const SHR_TKN = $D2 ; R
; SHR_TKN = 210
; 130: const SHL_TKN = $CC ; L
; SHL_TKN = 204
; 131: const GT_TKN = $BE ; >
; GT_TKN = 190
; 132: const GE_TKN = $C8 ; H
; GE_TKN = 200
; 133: const LT_TKN = $BC ; <
; LT_TKN = 188
; 134: const LE_TKN = $C2 ; B
; LE_TKN = 194
; 135: const NE_TKN = $D5 ; U
; NE_TKN = 213
; 136: const EQ_TKN = $C5 ; E
; EQ_TKN = 197
; 137: const LOGIC_AND_TKN = $CE ; N
; LOGIC_AND_TKN = 206
; 138: const LOGIC_OR_TKN = $CF ; O
; LOGIC_OR_TKN = 207
; 139: ;
; 140: ; Unary operand operators
; 141: ;
; 142: const AT_TKN = $C0 ; @
; AT_TKN = 192
; 143: const DOT_TKN = $AE ; .
; DOT_TKN = 174
; 144: const COLON_TKN = $BA ; :
; COLON_TKN = 186
; 145: const NEG_TKN = $AD ; -
; NEG_TKN = 173
; 146: const COMP_TKN = $A3 ; #
; COMP_TKN = 163
; 147: const LOGIC_NOT_TKN = $A1 ; !
; LOGIC_NOT_TKN = 161
; 148: const BPTR_TKN = $DE ; ^
; BPTR_TKN = 222
; 149: const WPTR_TKN = $AA ; *
; WPTR_TKN = 170
; 150: const INC_TKN = $C1 ; A
; INC_TKN = 193
; 151: const DEC_TKN = $C4 ; D
; DEC_TKN = 196
; 152: ;
; 153: ; Enclosure tokens
; 154: ;
; 155: const OPEN_PAREN_TKN = $A8 ; (
; OPEN_PAREN_TKN = 168
; 156: const CLOSE_PAREN_TKN = $A9 ; )
; CLOSE_PAREN_TKN = 169
; 157: const OPEN_BRACKET_TKN = $DB ; [
; OPEN_BRACKET_TKN = 219
; 158: const CLOSE_BRACKET_TKN = $DD ; ]
; CLOSE_BRACKET_TKN = 221
; 159: ;
; 160: ; Misc. tokens
; 161: ;
; 162: const COMMA_TKN = $AC ; ,
; COMMA_TKN = 172
; 163: const COMMENT_TKN = $BB ; ;
; COMMENT_TKN = 187
; 164: ;
; 165: ; Keyword tokens
; 166: ;
; 167: const CONST_TKN = $80
; CONST_TKN = 128
; 168: const BYTE_TKN = $81
; BYTE_TKN = 129
; 169: const WORD_TKN = $82
; WORD_TKN = 130
; 170: const IF_TKN = $83
; IF_TKN = 131
; 171: const ELSEIF_TKN = $84
; ELSEIF_TKN = 132
; 172: const ELSE_TKN = $85
; ELSE_TKN = 133
; 173: const FIN_TKN = $86
; FIN_TKN = 134
; 174: const END_TKN = $87
; END_TKN = 135
; 175: const WHILE_TKN = $88
; WHILE_TKN = 136
; 176: const LOOP_TKN = $89
; LOOP_TKN = 137
; 177: const CASE_TKN = $8A
; CASE_TKN = 138
; 178: const OF_TKN = $8B
; OF_TKN = 139
; 179: const DEFAULT_TKN = $8C
; DEFAULT_TKN = 140
; 180: const ENDCASE_TKN = $8D
; ENDCASE_TKN = 141
; 181: const FOR_TKN = $8E
; FOR_TKN = 142
; 182: const TO_TKN = $8F
; TO_TKN = 143
; 183: const DOWNTO_TKN = $90
; DOWNTO_TKN = 144
; 184: const STEP_TKN = $91
; STEP_TKN = 145
; 185: const NEXT_TKN = $92
; NEXT_TKN = 146
; 186: const REPEAT_TKN = $93
; REPEAT_TKN = 147
; 187: const UNTIL_TKN = $94
; UNTIL_TKN = 148
; 188: const IFUNC_TKN = $95
; IFUNC_TKN = 149
; 189: const NFUNC_TKN = $96
; NFUNC_TKN = 150
; 190: const DROP_TKN = $97
; DROP_TKN = 151
; 191: const DONE_TKN = $98
; DONE_TKN = 152
; 192: const RETURN_TKN = $99
; RETURN_TKN = 153
; 193: const BREAK_TKN = $9A
; BREAK_TKN = 154
; 194: const START_TKN = $9B
; START_TKN = 155
; 195: const EXIT_TKN = $9C
; EXIT_TKN = 156
; 196: const EVAL_TKN = $9D
; EVAL_TKN = 157
; 197: const FUNC_TKN = $9E
; FUNC_TKN = 158
; 198: ;
; 199: ; Types
; 200: ;
; 201: const CONST_TYPE = $01
; CONST_TYPE = 1
; 202: const BYTE_TYPE = $02
; BYTE_TYPE = 2
; 203: const WORD_TYPE = $04
; WORD_TYPE = 4
; 204: const VAR_TYPE = $06 ; (WORD_TYPE | BYTE_TYPE)
; VAR_TYPE = 6
; 205: const FUNC_TYPE = $08
; FUNC_TYPE = 8
; 206: const FUNC_CONST_TYPE = $09
; FUNC_CONST_TYPE = 9
; 207: const ADDR_TYPE = $0E ; (VAR_TYPE | FUNC_TYPE)
; ADDR_TYPE = 14
; 208: const LOCAL_TYPE = $10
; LOCAL_TYPE = 16
; 209: const BPTR_TYPE = $20
; BPTR_TYPE = 32
; 210: const WPTR_TYPE = $40
; WPTR_TYPE = 64
; 211: const PTR_TYPE = $60 ; (BPTR_TYPE | WPTR_TYPE)
; PTR_TYPE = 96
; 212: const XBYTE_TYPE = $22 ; (BPTR_TYPE | BYTE_TYPE)
; XBYTE_TYPE = 34
; 213: const XWORD_TYPE = $44 ; (WPTR_TYPE | WORD_TYPE)
; XWORD_TYPE = 68
; 214: const STR_TYPE = $80
; STR_TYPE = 128
; 215: ;
; 216: ; Keywords
; 217: ;
; 218: byte keywrds[]
D0212: ; keywrds
; 219: byte = "IF", IF_TKN
DB $02
DB $49,$46
DB $83
; 220: byte = "TO", TO_TKN
DB $02
DB $54,$4F
DB $8F
; 221: byte = "IS", OF_TKN
DB $02
DB $49,$53
DB $8B
; 222: byte = "OR", LOGIC_OR_TKN
DB $02
DB $4F,$52
DB $CF
; 223: byte = "FOR", FOR_TKN
DB $03
DB $46,$4F,$52
DB $8E
; 224: byte = "FIN", FIN_TKN
DB $03
DB $46,$49,$4E
DB $86
; 225: byte = "DEF", IFUNC_TKN
DB $03
DB $44,$45,$46
DB $95
; 226: byte = "END", END_TKN
DB $03
DB $45,$4E,$44
DB $87
; 227: byte = "AND", LOGIC_AND_TKN
DB $03
DB $41,$4E,$44
DB $CE
; 228: byte = "NOT", LOGIC_NOT_TKN
DB $03
DB $4E,$4F,$54
DB $A1
; 229: byte = "BYTE", BYTE_TKN
DB $04
DB $42,$59,$54,$45
DB $81
; 230: byte = "WORD", WORD_TKN
DB $04
DB $57,$4F,$52,$44
DB $82
; 231: byte = "DROP", DROP_TKN
DB $04
DB $44,$52,$4F,$50
DB $97
; 232: byte = "ELSE", ELSE_TKN
DB $04
DB $45,$4C,$53,$45
DB $85
; 233: byte = "NEXT", NEXT_TKN
DB $04
DB $4E,$45,$58,$54
DB $92
; 234: byte = "WHEN", CASE_TKN
DB $04
DB $57,$48,$45,$4E
DB $8A
; 235: byte = "LOOP", LOOP_TKN
DB $04
DB $4C,$4F,$4F,$50
DB $89
; 236: byte = "FUNC", FUNC_TKN
DB $04
DB $46,$55,$4E,$43
DB $9E
; 237: byte = "STEP", STEP_TKN
DB $04
DB $53,$54,$45,$50
DB $91
; 238: byte = "EXIT", EXIT_TKN
DB $04
DB $45,$58,$49,$54
DB $9C
; 239: byte = "DONE", DONE_TKN
DB $04
DB $44,$4F,$4E,$45
DB $98
; 240: byte = "WEND", ENDCASE_TKN
DB $04
DB $57,$45,$4E,$44
DB $8D
; 241: byte = "CONST", CONST_TKN
DB $05
DB $43,$4F,$4E,$53,$54
DB $80
; 242: byte = "ELSIF", ELSEIF_TKN
DB $05
DB $45,$4C,$53,$49,$46
DB $84
; 243: byte = "WHILE", WHILE_TKN
DB $05
DB $57,$48,$49,$4C,$45
DB $88
; 244: byte = "UNTIL", UNTIL_TKN
DB $05
DB $55,$4E,$54,$49,$4C
DB $94
; 245: byte = "BREAK", BREAK_TKN
DB $05
DB $42,$52,$45,$41,$4B
DB $9A
; 246: byte = "OTHER", DEFAULT_TKN
DB $05
DB $4F,$54,$48,$45,$52
DB $8C
; 247: byte = "DOWNTO", DOWNTO_TKN
DB $06
DB $44,$4F,$57,$4E,$54,$4F
DB $90
; 248: byte = "REPEAT", REPEAT_TKN
DB $06
DB $52,$45,$50,$45,$41,$54
DB $93
; 249: byte = "DEFOPT", NFUNC_TKN
DB $06
DB $44,$45,$46,$4F,$50,$54
DB $96
; 250: byte = "RETURN", RETURN_TKN
DB $06
DB $52,$45,$54,$55,$52,$4E
DB $99
; 251: byte = $FF
DB $FF
; 252: ;
; 253: ; Mathematical ops
; 254: ;
; 255: const bops_tblsz = 18 ; minus 1
; bops_tblsz = 18
; 256: byte bops_tbl[] ; Highest precedence
D0405: ; bops_tbl
; 257: byte = MUL_TKN, DIV_TKN, MOD_TKN
DB $AA
DB $AF
DB $A5
; 258: byte = ADD_TKN, SUB_TKN
DB $AB
DB $AD
; 259: byte = SHR_TKN, SHL_TKN
DB $D2
DB $CC
; 260: byte = AND_TKN
DB $A6
; 261: byte = EOR_TKN
DB $DE
; 262: byte = OR_TKN
DB $BF
; 263: byte = GT_TKN, GE_TKN, LT_TKN, LE_TKN
DB $BE
DB $C8
DB $BC
DB $C2
; 264: byte = EQ_TKN, NE_TKN
DB $C5
DB $D5
; 265: byte = LOGIC_AND_TKN
DB $CE
; 266: byte = LOGIC_OR_TKN
DB $CF
; 267: byte = COMMA_TKN
DB $AC
; 268: ; Lowest precedence
; 269: byte bops_prec[] ; Highest precedence
D0424: ; bops_prec
; 270: byte = 1, 1, 1
DB $01
DB $01
DB $01
; 271: byte = 2, 2
DB $02
DB $02
; 272: byte = 3, 3
DB $03
DB $03
; 273: byte = 4
DB $04
; 274: byte = 5
DB $05
; 275: byte = 6
DB $06
; 276: byte = 7, 7, 7, 7
DB $07
DB $07
DB $07
DB $07
; 277: byte = 8, 8
DB $08
DB $08
; 278: byte = 9
DB $09
; 279: byte = 10
DB $0A
; 280: byte = 11
DB $0B
; 281: ; Lowest precedence
; 282: byte opstack[16]
D0443: DS 16 ; opstack
; 283: byte precstack[16]
D0459: DS 16 ; precstack
; 284: word opsp = -1
D0475: ; opsp
DW $FFFF
; 285: ;
; 286: ; Symbol table variables
; 287: ;
; 288: const idglobal_tblsz = 2048
; idglobal_tblsz = 2048
; 289: const idlocal_tblsz = 512
; idlocal_tblsz = 512
; 290: const idglobal_tbl = $1600
; idglobal_tbl = 5632
; 291: const idlocal_tbl = $1E00
; idlocal_tbl = 7680
; 292: const ctag_max = 640
; ctag_max = 640
; 293: const ctag_value = $800
; ctag_value = 2048
; 294: const ctag_flags = $D80
; ctag_flags = 3456
; 295: const idval = 0
; idval = 0
; 296: const idtype = 2
; idtype = 2
; 297: const idname = 3
; idname = 3
; 298: const idrecsz = 4
; idrecsz = 4
; 299: word globals = 0
D0477: ; globals
DW $0000
; 300: word datasize = 0
D0479: ; datasize
DW $0000
; 301: word lastglobal
D0481: DS 2 ; lastglobal
; 302: byte locals = 0
D0483: ; locals
DB $00
; 303: word framesize = 0
D0484: ; framesize
DW $0000
; 304: word lastlocal
D0486: DS 2 ; lastlocal
; 305: const resolved = 1
; resolved = 1
; 306: const is_ctag = $8000
; is_ctag = 32768
; 307: const mask_ctag = $7FFF
; mask_ctag = 32767
; 308: word codetag = -1
D0488: ; codetag
DW $FFFF
; 309: word codeptr, entrypoint = 0
D0490: DS 2 ; codeptr
D0492: ; entrypoint
DW $0000
; 310: byte lastop = $FF
D0494: ; lastop
DB $FF
; 311: ;
; 312: ; Scanner variables
; 313: ;
; 314: const inbuff = $0200
; inbuff = 512
; 315: const instr = $01FF
; instr = 511
; 316: byte token, tknlen
D0495: DS 1 ; token
D0496: DS 1 ; tknlen
; 317: byte parserrpos, parserr = 0
D0497: DS 1 ; parserrpos
D0498: ; parserr
DB $00
; 318: word scanptr, tknptr, parserrln
D0499: DS 2 ; scanptr
D0501: DS 2 ; tknptr
D0503: DS 2 ; parserrln
; 319: word constval
D0505: DS 2 ; constval
; 320: word lineno = 0
D0507: ; lineno
DW $0000
; 321: ;
; 322: ; Compiler output messages
; 323: ;
; 324: byte entrypt_str[] = "START: "
D0509: ; entrypt_str
DB $07
DB $53,$54,$41,$52,$54,$3A,$20
; 325: byte comp_ok_msg[] = "COMPILATION COMPLETE"
D0517: ; comp_ok_msg
DB $14
DB $43,$4F,$4D,$50,$49,$4C,$41,$54
DB $49,$4F,$4E,$20,$43,$4F,$4D,$50
DB $4C,$45,$54,$45
; 326: byte dup_id[] = "DUPLICATE IDENTIFIER"
D0538: ; 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
; 327: byte undecl_id[] = "UNDECLARED IDENTIFIER"
D0559: ; 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
; 328: byte bad_cnst[] = "BAD CONSTANT"
D0581: ; bad_cnst
DB $0C
DB $42,$41,$44,$20,$43,$4F,$4E,$53
DB $54,$41,$4E,$54
; 329: byte bad_offset[] = "BAD STRUCT OFFSET"
D0594: ; bad_offset
DB $11
DB $42,$41,$44,$20,$53,$54,$52,$55
DB $43,$54,$20,$4F,$46,$46,$53,$45
DB $54
; 330: byte bad_decl[] = "BAD DECLARATION"
D0612: ; bad_decl
DB $0F
DB $42,$41,$44,$20,$44,$45,$43,$4C
DB $41,$52,$41,$54,$49,$4F,$4E
; 331: byte bad_op[] = "BAD OPERATION"
D0628: ; bad_op
DB $0D
DB $42,$41,$44,$20,$4F,$50,$45,$52
DB $41,$54,$49,$4F,$4E
; 332: byte bad_stmnt[] = "BAD STATMENT"
D0642: ; bad_stmnt
DB $0C
DB $42,$41,$44,$20,$53,$54,$41,$54
DB $4D,$45,$4E,$54
; 333: byte bad_expr[] = "BAD EXPRESSION"
D0655: ; bad_expr
DB $0E
DB $42,$41,$44,$20,$45,$58,$50,$52
DB $45,$53,$53,$49,$4F,$4E
; 334: byte bad_syntax[] = "BAD SYNTAX"
D0670: ; bad_syntax
DB $0A
DB $42,$41,$44,$20,$53,$59,$4E,$54
DB $41,$58
; 335: byte estk_overflw[] = "EVAL STACK OVERFLOW"
D0681: ; 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
; 336: byte estk_underflw[] = "EVAL STACK UNDERFLOW"
D0701: ; 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
; 337: byte local_overflw[] = "LOCAL FRAME OVERFLOW"
D0722: ; 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
; 338: byte global_sym_overflw[] = "GLOBAL SYMBOL TABLE OVERFLOW"
D0743: ; 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
; 339: byte local_sym_overflw[] = "LOCAL SYMBOL TABLE OVERFLOW"
D0772: ; 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
; 340: byte ctag_full[] = "CODE LABEL OVERFLOW"
D0800: ; 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
; 341: byte no_close_paren[] = "MISSING CLOSING PAREN"
D0820: ; 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
; 342: byte no_close_bracket[] = "MISSING CLOSING BRACKET"
D0842: ; 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
; 343: byte missing_op[] = "MISSING OPERAND"
D0866: ; missing_op
DB $0F
DB $4D,$49,$53,$53,$49,$4E,$47,$20
DB $4F,$50,$45,$52,$41,$4E,$44
; 344: byte no_fin[] = "MISSING FIN"
D0882: ; no_fin
DB $0B
DB $4D,$49,$53,$53,$49,$4E,$47,$20
DB $46,$49,$4E
; 345: byte no_loop[] = "MISSING LOOP"
D0894: ; no_loop
DB $0C
DB $4D,$49,$53,$53,$49,$4E,$47,$20
DB $4C,$4F,$4F,$50
; 346: byte no_until[] = "MISSING UNTIL"
D0907: ; no_until
DB $0D
DB $4D,$49,$53,$53,$49,$4E,$47,$20
DB $55,$4E,$54,$49,$4C
; 347: byte no_done[] = "MISSING DONE"
D0921: ; no_done
DB $0C
DB $4D,$49,$53,$53,$49,$4E,$47,$20
DB $44,$4F,$4E,$45
; 348: byte no_local_init[] = "NO INITIALIZED LOCALS"
D0934: ; 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
; 349: ;
; 350: ; Runtime messages
; 351: ;
; 352: byte brkmsg[] = "CTRL-C BREAK"
D0956: ; brkmsg
DB $0C
DB $43,$54,$52,$4C,$2D,$43,$20,$42
DB $52,$45,$41,$4B
; 353: byte stkovflwmsg[] = "STACK OVERFLOW/UNDERFLOW ERROR"
D0969: ; stkovflwmsg
DB $1E
DB $53,$54,$41,$43,$4B,$20,$4F,$56
DB $45,$52,$46,$4C,$4F,$57,$2F,$55
DB $4E,$44,$45,$52,$46,$4C,$4F,$57
DB $20,$45,$52,$52,$4F,$52
; 354: ;
; 355: ; Runtime functions
; 356: ;
; 357: byte runtime0[] = "romcall"
D1000: ; runtime0
DB $07
DB $72,$6F,$6D,$63,$61,$6C,$6C
; 358: byte RUNTIME0[] = "ROMCALL"
D1008: ; RUNTIME0
DB $07
DB $52,$4F,$4D,$43,$41,$4C,$4C
; 359: byte runtime1[] = "syscall"
D1016: ; runtime1
DB $07
DB $73,$79,$73,$63,$61,$6C,$6C
; 360: byte RUNTIME1[] = "SYSCALL"
D1024: ; RUNTIME1
DB $07
DB $53,$59,$53,$43,$41,$4C,$4C
; 361: byte runtime2[] = "memset"
D1032: ; runtime2
DB $06
DB $6D,$65,$6D,$73,$65,$74
; 362: byte RUNTIME2[] = "MEMSET"
D1039: ; RUNTIME2
DB $06
DB $4D,$45,$4D,$53,$45,$54
; 363: byte runtime3[] = "memcpy"
D1046: ; runtime3
DB $06
DB $6D,$65,$6D,$63,$70,$79
; 364: byte RUNTIME3[] = "MEMCPY"
D1053: ; RUNTIME3
DB $06
DB $4D,$45,$4D,$43,$50,$59
; 365: byte runtime4[] = "cout"
D1060: ; runtime4
DB $04
DB $63,$6F,$75,$74
; 366: byte RUNTIME4[] = "COUT"
D1065: ; RUNTIME4
DB $04
DB $43,$4F,$55,$54
; 367: byte runtime5[] = "cin"
D1070: ; runtime5
DB $03
DB $63,$69,$6E
; 368: byte RUNTIME5[] = "CIN"
D1074: ; RUNTIME5
DB $03
DB $43,$49,$4E
; 369: byte runtime6[] = "prstr"
D1078: ; runtime6
DB $05
DB $70,$72,$73,$74,$72
; 370: byte RUNTIME6[] = "PRSTR"
D1084: ; RUNTIME6
DB $05
DB $50,$52,$53,$54,$52
; 371: byte runtime7[] = "rdstr"
D1090: ; runtime7
DB $05
DB $72,$64,$73,$74,$72
; 372: byte RUNTIME7[] = "RDSTR"
D1096: ; RUNTIME7
DB $05
DB $52,$44,$53,$54,$52
; 373: ;
; 374: ; Parser variables
; 375: ;
; 376: byte infunc = 0
D1102: ; infunc
DB $00
; 377: byte stack_loop = 0
D1103: ; stack_loop
DB $00
; 378: byte prevstmnt = 0
D1104: ; prevstmnt
DB $00
; 379: word retfunc_tag = 0
D1105: ; retfunc_tag
DW $0000
; 380: word break_tag = 0
D1107: ; break_tag
DW $0000
; 381: func parse_expr_01, parse_module_01
; 382: ;
; 383: ; Utility functions
; 384: ;
; 385: ; Defines for ASM routines
; 386: ;
; 387: asm equates
C0003: ; equates()
; 388: TMP EQU $F0
TMP EQU $F0
; 389: TMPL EQU TMP
TMPL EQU TMP
; 390: TMPH EQU TMP+1
TMPH EQU TMP+1
; 391: SRC EQU TMP
SRC EQU TMP
; 392: SRCL EQU SRC
SRCL EQU SRC
; 393: SRCH EQU SRC+1
SRCH EQU SRC+1
; 394: DST EQU SRC+2
DST EQU SRC+2
; 395: DSTL EQU DST
DSTL EQU DST
; 396: DSTH EQU DST+1
DSTH EQU DST+1
; 397: ESP EQU DST+2
ESP EQU DST+2
; 398: SAVEESP EQU ESP+1
SAVEESP EQU ESP+1
; 399: SAVESP EQU SAVEESP+1
SAVESP EQU SAVEESP+1
; 400: SAVEFP EQU SAVESP+1
SAVEFP EQU SAVESP+1
; 401: SAVETMR EQU SAVEFP+2
SAVETMR EQU SAVEFP+2
; 402: SAVEINT EQU SAVETMR+2
SAVEINT EQU SAVETMR+2
; 403: TMRVEC EQU $03E8
TMRVEC EQU $03E8
; 404: INTVEC EQU $03EA
INTVEC EQU $03EA
; 405: JMPTMP: JMP (TMP)
JMPTMP: JMP (TMP)
; 406: STKOVFLW:
STKOVFLW:
; 407: LDY #$02
LDY #$02
; 408: JMP EXECRET
JMP EXECRET
; 409: BRKCHK:
BRKCHK:
; 410: LDA $C000
LDA $C000
; 411: CMP #$83 ; CTRL-C
CMP #$83 ; CTRL-C
; 412: BNE :+
BNE :+
; 413: BIT $C010
BIT $C010
; 414: LDY #$01
LDY #$01
; 415: JMP EXECRET
JMP EXECRET
; 416: :
:
; 417: end
RTS
; 418: ;
; 419: ; ENTER MODULE UNDER TEST
; 420: ;
; 421: asm execentry
C0005: ; execentry()
; 422: LDA ESTKL,X
LDA ESTKL,X
; 423: STA TMPL
STA TMPL
; 424: LDA ESTKH,X
LDA ESTKH,X
; 425: STA TMPH
STA TMPH
; 426: STX SAVEESP
STX SAVEESP
; 427: TSX
TSX
; 428: STX SAVESP
STX SAVESP
; 429: LDA FRMPL
LDA FRMPL
; 430: STA SAVEFP
STA SAVEFP
; 431: LDA FRMPH
LDA FRMPH
; 432: STA SAVEFP+1
STA SAVEFP+1
; 433: LDA TMRVEC
LDA TMRVEC
; 434: STA SAVETMR
STA SAVETMR
; 435: LDA TMRVEC+1
LDA TMRVEC+1
; 436: STA SAVETMR+1
STA SAVETMR+1
; 437: LDA INTVEC
LDA INTVEC
; 438: STA SAVEINT
STA SAVEINT
; 439: LDA INTVEC+1
LDA INTVEC+1
; 440: STA SAVEINT+1
STA SAVEINT+1
; 441: LDA #<BRKCHK
LDA #<BRKCHK
; 442: STA TMRVEC
STA TMRVEC
; 443: LDA #>BRKCHK
LDA #>BRKCHK
; 444: STA TMRVEC+1
STA TMRVEC+1
; 445: LDA #<STKOVFLW
LDA #<STKOVFLW
; 446: STA INTVEC
STA INTVEC
; 447: LDA #>STKOVFLW
LDA #>STKOVFLW
; 448: STA INTVEC+1
STA INTVEC+1
; 449: LDX #ESTKSZ/2
LDX #ESTKSZ/2
; 450: JSR JMPTMP
JSR JMPTMP
; 451: LDY #$00
LDY #$00
; 452: EXECRET:
EXECRET:
; 453: STY TMP
STY TMP
; 454: BIT ROMIN
BIT ROMIN
; 455: BIT $C054
BIT $C054
; 456: BIT $C051
BIT $C051
; 457: BIT $C058
BIT $C058
; 458: JSR $FB39 ; SET TEXT MODE
JSR $FB39 ; SET TEXT MODE
; 459: BIT LCBNK2
BIT LCBNK2
; 460: LDA SAVEFP
LDA SAVEFP
; 461: STA FRMPL
STA FRMPL
; 462: LDA SAVEFP+1
LDA SAVEFP+1
; 463: STA FRMPH
STA FRMPH
; 464: LDA SAVETMR
LDA SAVETMR
; 465: STA TMRVEC
STA TMRVEC
; 466: LDA SAVETMR+1
LDA SAVETMR+1
; 467: STA TMRVEC+1
STA TMRVEC+1
; 468: LDA SAVEINT
LDA SAVEINT
; 469: STA INTVEC
STA INTVEC
; 470: LDA SAVEINT+1
LDA SAVEINT+1
; 471: STA INTVEC+1
STA INTVEC+1
; 472: LDX SAVESP
LDX SAVESP
; 473: TXS
TXS
; 474: LDX SAVEESP
LDX SAVEESP
; 475: LDY TMP
LDY TMP
; 476: STY ESTKL,X
STY ESTKL,X
; 477: LDY #$00
LDY #$00
; 478: STY ESTKH,X
STY ESTKH,X
; 479: end
RTS
; 480: ;
; 481: ; CALL 6502 ROUTINE
; 482: ; ROMCALL(AREG, XREG, YREG, STATUS, ADDR)
; 483: ;
; 484: asm romcall
C0007: ; romcall()
; 485: PHP
PHP
; 486: LDA ESTKL,X
LDA ESTKL,X
; 487: STA TMPL
STA TMPL
; 488: LDA ESTKH,X
LDA ESTKH,X
; 489: STA TMPH
STA TMPH
; 490: INX
INX
; 491: LDA ESTKL,X
LDA ESTKL,X
; 492: PHA
PHA
; 493: INX
INX
; 494: LDA ESTKL,X
LDA ESTKL,X
; 495: TAY
TAY
; 496: INX
INX
; 497: LDA ESTKL+1,X
LDA ESTKL+1,X
; 498: PHA
PHA
; 499: LDA ESTKL,X
LDA ESTKL,X
; 500: INX
INX
; 501: STX ESP
STX ESP
; 502: TAX
TAX
; 503: PLA
PLA
; 504: BIT ROMIN
BIT ROMIN
; 505: PLP
PLP
; 506: JSR JMPTMP
JSR JMPTMP
; 507: PHP
PHP
; 508: BIT LCBNK2
BIT LCBNK2
; 509: STA REGVALS+0
STA REGVALS+0
; 510: STX REGVALS+1
STX REGVALS+1
; 511: STY REGVALS+2
STY REGVALS+2
; 512: PLA
PLA
; 513: STA REGVALS+3
STA REGVALS+3
; 514: LDX ESP
LDX ESP
; 515: LDA #<REGVALS
LDA #<REGVALS
; 516: LDY #>REGVALS
LDY #>REGVALS
; 517: STA ESTKL,X
STA ESTKL,X
; 518: STY ESTKH,X
STY ESTKH,X
; 519: PLP
PLP
; 520: RTS
RTS
; 521: REGVALS: DS 4
REGVALS: DS 4
; 522: end
RTS
; 523: ;
; 524: ; CALL PRODOS
; 525: ; SYSCALL(CMD, PARAMS)
; 526: ;
; 527: asm syscall
C0009: ; syscall()
; 528: LDA ESTKL,X
LDA ESTKL,X
; 529: LDY ESTKH,X
LDY ESTKH,X
; 530: STA PARAMS
STA PARAMS
; 531: STY PARAMS+1
STY PARAMS+1
; 532: INX
INX
; 533: LDA ESTKL,X
LDA ESTKL,X
; 534: STA CMD
STA CMD
; 535: STX ESP
STX ESP
; 536: JSR $BF00
JSR $BF00
; 537: CMD: DB 00
CMD: DB 00
; 538: PARAMS: DW 0000
PARAMS: DW 0000
; 539: BIT LCBNK2
BIT LCBNK2
; 540: LDX ESP
LDX ESP
; 541: STA ESTKL,X
STA ESTKL,X
; 542: LDY #$00
LDY #$00
; 543: STY ESTKH,X
STY ESTKH,X
; 544: end
RTS
; 545: ;
; 546: ; SET MEMORY TO VALUE
; 547: ; MEMSET(VALUE, ADDR, SIZE)
; 548: ;
; 549: asm memset
C0011: ; memset()
; 550: LDY #$00
LDY #$00
; 551: LDA ESTKL+1,X
LDA ESTKL+1,X
; 552: STA DSTL
STA DSTL
; 553: LDA ESTKH+1,X
LDA ESTKH+1,X
; 554: STA DSTH
STA DSTH
; 555: INC ESTKL,X
INC ESTKL,X
; 556: INC ESTKH,X
INC ESTKH,X
; 557: SETMEM: DEC ESTKL,X
SETMEM: DEC ESTKL,X
; 558: BNE :+
BNE :+
; 559: DEC ESTKH,X
DEC ESTKH,X
; 560: BEQ MEMEXIT
BEQ MEMEXIT
; 561: : LDA ESTKL+2,X
: LDA ESTKL+2,X
; 562: STA (DST),Y
STA (DST),Y
; 563: INY
INY
; 564: BNE :+
BNE :+
; 565: INC DSTH
INC DSTH
; 566: : DEC ESTKL,X
: DEC ESTKL,X
; 567: BNE :+
BNE :+
; 568: DEC ESTKH,X
DEC ESTKH,X
; 569: BEQ MEMEXIT
BEQ MEMEXIT
; 570: : LDA ESTKH+2,X
: LDA ESTKH+2,X
; 571: STA (DST),Y
STA (DST),Y
; 572: INY
INY
; 573: BNE SETMEM
BNE SETMEM
; 574: INC DSTH
INC DSTH
; 575: BNE SETMEM
BNE SETMEM
; 576: MEMEXIT: INX
MEMEXIT: INX
; 577: INX
INX
; 578: INX
INX
; 579: end
RTS
; 580: ;
; 581: ; COPY MEMORY
; 582: ; MEMCPY(SRCADDR, DSTADDR, SIZE)
; 583: ;
; 584: asm memcpy
C0013: ; memcpy()
; 585: LDY #$00
LDY #$00
; 586: LDA ESTKL,X
LDA ESTKL,X
; 587: BNE :+
BNE :+
; 588: LDA ESTKH,X
LDA ESTKH,X
; 589: BEQ MEMEXIT
BEQ MEMEXIT
; 590: : LDA ESTKL+1,X
: LDA ESTKL+1,X
; 591: STA DSTL
STA DSTL
; 592: LDA ESTKH+1,X
LDA ESTKH+1,X
; 593: STA DSTH
STA DSTH
; 594: LDA ESTKL+2,X
LDA ESTKL+2,X
; 595: STA SRCL
STA SRCL
; 596: LDA ESTKH+2,X
LDA ESTKH+2,X
; 597: STA SRCH
STA SRCH
; 598: CMP DSTH
CMP DSTH
; 599: BCC REVCPY
BCC REVCPY
; 600: BNE FORCPY
BNE FORCPY
; 601: LDA SRCL
LDA SRCL
; 602: CMP DSTL
CMP DSTL
; 603: BCS FORCPY
BCS FORCPY
; 604: REVCPY: ; REVERSE DIRECTION COPY
REVCPY: ; REVERSE DIRECTION COPY
; 605: ; CLC
; 606: LDA ESTKL,X
LDA ESTKL,X
; 607: ADC DSTL
ADC DSTL
; 608: STA DSTL
STA DSTL
; 609: LDA ESTKH,X
LDA ESTKH,X
; 610: ADC DSTH
ADC DSTH
; 611: STA DSTH
STA DSTH
; 612: CLC
CLC
; 613: LDA ESTKL,X
LDA ESTKL,X
; 614: ADC SRCL
ADC SRCL
; 615: STA SRCL
STA SRCL
; 616: LDA ESTKH,X
LDA ESTKH,X
; 617: ADC SRCH
ADC SRCH
; 618: STA SRCH
STA SRCH
; 619: INC ESTKH,X
INC ESTKH,X
; 620: REVCPYLP:
REVCPYLP:
; 621: LDA DSTL
LDA DSTL
; 622: BNE :+
BNE :+
; 623: DEC DSTH
DEC DSTH
; 624: : DEC DSTL
: DEC DSTL
; 625: LDA SRCL
LDA SRCL
; 626: BNE :+
BNE :+
; 627: DEC SRCH
DEC SRCH
; 628: : DEC SRCL
: DEC SRCL
; 629: LDA (SRC),Y
LDA (SRC),Y
; 630: STA (DST),Y
STA (DST),Y
; 631: DEC ESTKL,X
DEC ESTKL,X
; 632: BNE REVCPYLP
BNE REVCPYLP
; 633: DEC ESTKH,X
DEC ESTKH,X
; 634: BNE REVCPYLP
BNE REVCPYLP
; 635: BEQ MEMEXIT
BEQ MEMEXIT
; 636: FORCPY: INC ESTKH,X
FORCPY: INC ESTKH,X
; 637: FORCPYLP:
FORCPYLP:
; 638: LDA (SRC),Y
LDA (SRC),Y
; 639: STA (DST),Y
STA (DST),Y
; 640: INC DSTL
INC DSTL
; 641: BNE :+
BNE :+
; 642: INC DSTH
INC DSTH
; 643: : INC SRCL
: INC SRCL
; 644: BNE :+
BNE :+
; 645: INC SRCH
INC SRCH
; 646: : DEC ESTKL,X
: DEC ESTKL,X
; 647: BNE FORCPYLP
BNE FORCPYLP
; 648: DEC ESTKH,X
DEC ESTKH,X
; 649: BNE FORCPYLP
BNE FORCPYLP
; 650: BEQ MEMEXIT
BEQ MEMEXIT
; 651: end
RTS
; 652: ;
; 653: ; CHAR OUT
; 654: ; COUT(CHAR)
; 655: ;
; 656: asm cout
C0015: ; cout()
; 657: LDA ESTKL,X
LDA ESTKL,X
; 658: INX
INX
; 659: ORA #$80
ORA #$80
; 660: BIT ROMIN
BIT ROMIN
; 661: JSR $FDED
JSR $FDED
; 662: BIT LCBNK2
BIT LCBNK2
; 663: end
RTS
; 664: ;
; 665: ; CHAR IN
; 666: ; RDKEY()
; 667: ;
; 668: asm cin
C0017: ; cin()
; 669: BIT ROMIN
BIT ROMIN
; 670: STX ESP
STX ESP
; 671: JSR $FD0C
JSR $FD0C
; 672: LDX ESP
LDX ESP
; 673: BIT LCBNK2
BIT LCBNK2
; 674: DEX
DEX
; 675: AND #$7F
AND #$7F
; 676: STA ESTKL,X
STA ESTKL,X
; 677: LDY #$00
LDY #$00
; 678: STY ESTKH,X
STY ESTKH,X
; 679: end
RTS
; 680: ;
; 681: ; PRINT STRING
; 682: ; PRSTR(STR)
; 683: ;
; 684: asm prstr
C0019: ; prstr()
; 685: LDY #$00
LDY #$00
; 686: LDA ESTKL,X
LDA ESTKL,X
; 687: STA SRCL
STA SRCL
; 688: LDA ESTKH,X
LDA ESTKH,X
; 689: STA SRCH
STA SRCH
; 690: BIT ROMIN
BIT ROMIN
; 691: LDA (SRC),Y
LDA (SRC),Y
; 692: STA ESTKL,X
STA ESTKL,X
; 693: BEQ :+
BEQ :+
; 694: _PRS1: INY
_PRS1: INY
; 695: LDA (SRC),Y
LDA (SRC),Y
; 696: ORA #$80
ORA #$80
; 697: JSR $FDED
JSR $FDED
; 698: TYA
TYA
; 699: CMP ESTKL,X
CMP ESTKL,X
; 700: BNE _PRS1
BNE _PRS1
; 701: : INX
: INX
; 702: BIT LCBNK2
BIT LCBNK2
; 703: end
RTS
; 704: ;
; 705: ; READ STRING
; 706: ; STR = RDSTR(PROMPTCHAR)
; 707: ;
; 708: asm rdstr
C0021: ; rdstr()
; 709: LDA ESTKL,X
LDA ESTKL,X
; 710: STA $33
STA $33
; 711: STX ESP
STX ESP
; 712: BIT ROMIN
BIT ROMIN
; 713: JSR $FD6A
JSR $FD6A
; 714: BIT LCBNK2
BIT LCBNK2
; 715: STX $01FF
STX $01FF
; 716: : LDA $01FF,X
: LDA $01FF,X
; 717: AND #$7F
AND #$7F
; 718: STA $01FF,X
STA $01FF,X
; 719: DEX
DEX
; 720: BPL :-
BPL :-
; 721: LDX ESP
LDX ESP
; 722: LDA #$FF
LDA #$FF
; 723: STA ESTKL,X
STA ESTKL,X
; 724: LDA #$01
LDA #$01
; 725: STA ESTKH,X
STA ESTKH,X
; 726: end
RTS
; 727: ;
; 728: ; EXIT
; 729: ;
; 730: asm exit
C0023: ; exit()
; 731: JSR $BF00
JSR $BF00
; 732: DB $65
DB $65
; 733: DW EXITTBL
DW EXITTBL
; 734: EXITTBL:
EXITTBL:
; 735: DB 4
DB 4
; 736: DB 0
DB 0
; 737: end
RTS
; 738: ;
; 739: ; ProDOS routines
; 740: ;
; 741: def getpfx_11(path)
C0025: ; getpfx_11()
; path = 2
; 742: byte params[3]
; params = 4
; 743:
; 744: ^path = 0
JSR INTERP
DB $58,$07,$01 ; ENTER 7,1
DB $66,$02 ; LLW 2
DB $00 ; ZERO
DB $70 ; SB
; 745: params.0 = 1
DB $28,$04 ; LLA 4
DB $2A,$01 ; CB 1
DB $70 ; SB
; 746: params:1 = path
DB $28,$05 ; LLA 5
DB $66,$02 ; LLW 2
DB $72 ; SW
; 747: perr = syscall($C7, @params)
DB $2A,$C7 ; CB 199
DB $28,$04 ; LLA 4
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 748: return path
DB $66,$02 ; LLW 2
DB $5A ; LEAVE
; 749: end
; 750: def setpfx_11(path)
C0027: ; setpfx_11()
; path = 2
; 751: byte params[3]
; params = 4
; 752:
; 753: 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
; 754: params:1 = path
DB $28,$05 ; LLA 5
DB $66,$02 ; LLW 2
DB $72 ; SW
; 755: perr = syscall($C6, @params)
DB $2A,$C6 ; CB 198
DB $28,$04 ; LLA 4
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 756: return path
DB $66,$02 ; LLW 2
DB $5A ; LEAVE
; 757: end
; 758: def open_21(path, buff)
C0029: ; open_21()
; path = 2
; buff = 4
; 759: byte params[6]
; params = 6
; 760:
; 761: 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
; 762: params:1 = path
DB $28,$07 ; LLA 7
DB $66,$02 ; LLW 2
DB $72 ; SW
; 763: params:3 = buff
DB $28,$09 ; LLA 9
DB $66,$04 ; LLW 4
DB $72 ; SW
; 764: params.5 = 0
DB $28,$0B ; LLA 11
DB $00 ; ZERO
DB $70 ; SB
; 765: perr = syscall($C8, @params)
DB $2A,$C8 ; CB 200
DB $28,$06 ; LLA 6
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 766: return params.5
DB $28,$0B ; LLA 11
DB $60 ; LB
DB $5A ; LEAVE
; 767: end
; 768: def close_11(refnum)
C0031: ; close_11()
; refnum = 2
; 769: byte params[2]
; params = 4
; 770:
; 771: 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
; 772: params.1 = refnum
DB $28,$05 ; LLA 5
DB $66,$02 ; LLW 2
DB $70 ; SB
; 773: perr = syscall($CC, @params)
DB $2A,$CC ; CB 204
DB $28,$04 ; LLA 4
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 774: return perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $5A ; LEAVE
; 775: end
; 776: def read_31(refnum, buff, len)
C0033: ; read_31()
; refnum = 2
; buff = 4
; len = 6
; 777: byte params[8]
; params = 8
; 778:
; 779: 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
; 780: params.1 = refnum
DB $28,$09 ; LLA 9
DB $66,$02 ; LLW 2
DB $70 ; SB
; 781: params:2 = buff
DB $28,$0A ; LLA 10
DB $66,$04 ; LLW 4
DB $72 ; SW
; 782: params:4 = len
DB $28,$0C ; LLA 12
DB $66,$06 ; LLW 6
DB $72 ; SW
; 783: params:6 = 0
DB $28,$0E ; LLA 14
DB $00 ; ZERO
DB $72 ; SW
; 784: perr = syscall($CA, @params)
DB $2A,$CA ; CB 202
DB $28,$08 ; LLA 8
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 785: return params:6
DB $28,$0E ; LLA 14
DB $62 ; LW
DB $5A ; LEAVE
; 786: end
; 787: def write_31(refnum, buff, len)
C0035: ; write_31()
; refnum = 2
; buff = 4
; len = 6
; 788: byte params[8]
; params = 8
; 789:
; 790: 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
; 791: params.1 = refnum
DB $28,$09 ; LLA 9
DB $66,$02 ; LLW 2
DB $70 ; SB
; 792: params:2 = buff
DB $28,$0A ; LLA 10
DB $66,$04 ; LLW 4
DB $72 ; SW
; 793: params:4 = len
DB $28,$0C ; LLA 12
DB $66,$06 ; LLW 6
DB $72 ; SW
; 794: params:6 = 0
DB $28,$0E ; LLA 14
DB $00 ; ZERO
DB $72 ; SW
; 795: perr = syscall($CB, @params)
DB $2A,$CB ; CB 203
DB $28,$08 ; LLA 8
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 796: return params:6
DB $28,$0E ; LLA 14
DB $62 ; LW
DB $5A ; LEAVE
; 797: end
; 798: def create_41(path, access, type, aux)
C0037: ; create_41()
; path = 2
; access = 4
; type = 6
; aux = 8
; 799: byte params[12]
; params = 10
; 800:
; 801: 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
; 802: params:1 = path
DB $28,$0B ; LLA 11
DB $66,$02 ; LLW 2
DB $72 ; SW
; 803: params.3 = access
DB $28,$0D ; LLA 13
DB $66,$04 ; LLW 4
DB $70 ; SB
; 804: params.4 = type
DB $28,$0E ; LLA 14
DB $66,$06 ; LLW 6
DB $70 ; SB
; 805: params:5 = aux
DB $28,$0F ; LLA 15
DB $66,$08 ; LLW 8
DB $72 ; SW
; 806: params.7 = $1
DB $28,$11 ; LLA 17
DB $2A,$01 ; CB 1
DB $70 ; SB
; 807: params:8 = 0
DB $28,$12 ; LLA 18
DB $00 ; ZERO
DB $72 ; SW
; 808: params:10 = 0
DB $28,$14 ; LLA 20
DB $00 ; ZERO
DB $72 ; SW
; 809: perr = syscall($C0, @params)
DB $2A,$C0 ; CB 192
DB $28,$0A ; LLA 10
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 810: return perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $5A ; LEAVE
; 811: end
; 812: def destroy_11(path)
C0039: ; destroy_11()
; path = 2
; 813: byte params[12]
; params = 4
; 814:
; 815: 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
; 816: params:1 = path
DB $28,$05 ; LLA 5
DB $66,$02 ; LLW 2
DB $72 ; SW
; 817: perr = syscall($C1, @params)
DB $2A,$C1 ; CB 193
DB $28,$04 ; LLA 4
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 818: return perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $5A ; LEAVE
; 819: end
; 820: def newline_31(refnum, emask, nlchar)
C0041: ; newline_31()
; refnum = 2
; emask = 4
; nlchar = 6
; 821: byte params[4]
; params = 8
; 822:
; 823: 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
; 824: params.1 = refnum
DB $28,$09 ; LLA 9
DB $66,$02 ; LLW 2
DB $70 ; SB
; 825: params.2 = emask
DB $28,$0A ; LLA 10
DB $66,$04 ; LLW 4
DB $70 ; SB
; 826: params.3 = nlchar
DB $28,$0B ; LLA 11
DB $66,$06 ; LLW 6
DB $70 ; SB
; 827: perr = syscall($C9, @params)
DB $2A,$C9 ; CB 201
DB $28,$08 ; LLA 8
DB $54,<C0009,>C0009 ; CALL C0009
DB $78,<D0088,>D0088 ; SAB D0088
; 828: return perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $5A ; LEAVE
; 829: end
; 830:
; 831: ;=====================================
; 832: ;
; 833: ; Editor
; 834: ;
; 835: ;=====================================
; 836:
; 837: def crout
C0043: ; crout()
; 838: cout($0D)
JSR INTERP
DB $2A,$0D ; CB 13
DB $54,<C0015,>C0015 ; CALL C0015
; 839: end
DB $5C ; RET
; 840: def bell
C0045: ; bell()
; 841: drop romcall(0, 0, 0, 0, $FBDD)
JSR INTERP
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $2C,$DD,$FB ; CW 64477
DB $54,<C0007,>C0007 ; CALL C0007
DB $30 ; DROP
; 842: end
DB $5C ; RET
; 843: ;
; 844: ; Memory management routines
; 845: ;
; 846: defopt strcpy_20(srcstr, dststr)
C0047: ; strcpy_20()
; srcstr = 2
; dststr = 4
; 847: byte strlen
; strlen = 6
; 848:
; 849: strlen = ^srcstr
LDY #7
LDA #2
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR LB
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
; 850: while (srcstr).[strlen] == $8D or (srcstr).[strlen] == $A0
INX
C0049:
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
JSR ADD
JSR LB
DEX
LDA #$8D
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
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
JSR ADD
JSR LB
DEX
LDA #$A0
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
JSR LOR
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0050
:
; 851: strlen = strlen - 1
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
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
; 852: loop
INX
JMP C0049
C0050:
; 853: ^dststr = strlen
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
LDY #$00
STY ESTKH,X
JSR SB
; 854: memcpy(srcstr + 1, dststr + 1, strlen)
DEX
LDY #$02
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 ADD
DEX
LDY #$04
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 ADD
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0013
; 855: end
JMP LEAVE
; 856: defopt heapaddr_21(ofst, mask)
C0051: ; heapaddr_21()
; ofst = 2
; mask = 4
; 857: word addr
; addr = 6
; 858:
; 859: addr = (ofst << 7) + strheap
LDY #8
LDA #2
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$07
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SHL
DEX
STY ESTKL,X
LDA #$70
STA ESTKH,X
JSR ADD
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 860: while !(mask & 1)
INX
C0053:
DEX
LDY #$04
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 BAND
JSR NOT
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0054
:
; 861: addr = addr + 16
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$10
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 862: mask = mask >> 1
LDY #$04
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 SHR
LDY #$04
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 863: loop
INX
JMP C0053
C0054:
; 864: return addr
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JMP LEAVE
; 865: end
; 866: defopt sizemask_11(size)
C0055: ; sizemask_11()
; size = 2
; 867: if size <= 16
LDY #4
LDA #1
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$10
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0057
:
; 868: return $01
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 869: elsif size <= 32
JMP C0058
C0057:
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$20
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0059
:
; 870: return $03
DEX
LDA #$03
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 871: elsif size <= 48
JMP C0058
C0059:
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$30
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0060
:
; 872: return $07
DEX
LDA #$07
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 873: elsif size <= 64
JMP C0058
C0060:
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$40
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0061
:
; 874: return $0F
DEX
LDA #$0F
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 875: elsif size <= 80
JMP C0058
C0061:
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDA #$50
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0062
:
; 876: return $1F
DEX
LDA #$1F
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 877: fin
C0062:
C0058:
; 878: return 0
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 879: end
; 880: defopt heapalloc_11(size)
C0063: ; heapalloc_11()
; size = 2
; 881: byte szmask, i
; szmask = 4
; i = 5
; 882: word mapmask
; mapmask = 6
; 883:
; 884: szmask = sizemask_11(size)
LDY #8
LDA #1
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JSR C0055
LDY #$04
LDA ESTKL,X
STA (FRMP),Y
; 885: for i = strheapmsz - 1 downto 0
LDA #$70
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDA #$01
STA ESTKL,X
STY ESTKH,X
JSR SUB
C0066:
LDY #$05
LDA ESTKL,X
STA (FRMP),Y
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
INX
LDA ESTKL,X
CMP ESTKL-1,X
LDA ESTKH,X
SBC ESTKH-1,X
BPL :+
JMP C0065
:
LDA ESTKL,X
BNE :+
DEC ESTKH,X
: DEC ESTKL,X
; 886: if strheapmap.[i] <> $FF
DEX
STY ESTKL,X
LDA #$15
STA ESTKH,X
DEX
LDY #$05
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
JSR LB
DEX
LDA #$FF
STA ESTKL,X
STY ESTKH,X
JSR ISNE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0067
:
; 887: mapmask = szmask
DEX
LDY #$04
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 888: repeat
INX
C0070:
; 889: if strheapmap.[i] & mapmask
DEX
LDY #$00
STY ESTKL,X
LDA #$15
STA ESTKH,X
DEX
LDY #$05
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
JSR LB
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JSR BAND
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0071
:
; 890: mapmask = mapmask << 1
DEX
LDY #$06
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 SHL
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 891: else
INX
JMP C0072
C0071:
; 892: strheapmap.[i] = strheapmap.[i] ? mapmask
DEX
LDY #$00
STY ESTKL,X
LDA #$15
STA ESTKH,X
DEX
LDY #$05
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
DEX
STY ESTKL,X
LDA #$15
STA ESTKH,X
DEX
LDY #$05
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
JSR LB
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JSR IOR
LDY #$00
JSR SB
; 893: return heapaddr_21(i, mapmask)
LDY #$05
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JSR C0051
JMP LEAVE
; 894: fin
C0072:
; 895: until mapmask & $100
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDY #$00
STY ESTKL,X
LDA #$01
STA ESTKH,X
JSR BAND
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0070
:
C0069:
; 896: fin
C0067:
C0068:
; 897: next
JMP C0066
C0065:
; 898: bell()
INX
JSR C0045
; 899: prstr(@outofmem)
DEX
LDA #<D0089
STA ESTKL,X
LDA #>D0089
STA ESTKH,X
JSR C0019
; 900: return 0
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 901: end
; 902: def freestr_10(strptr)
C0073: ; freestr_10()
; strptr = 2
; 903: byte mask, ofst
; mask = 4
; ofst = 5
; 904:
; 905: if strptr and strptr <> @nullstr
JSR INTERP
DB $58,$06,$01 ; ENTER 6,1
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $26,<D0048,>D0048 ; LA D0048
DB $42 ; ISNE
DB $24 ; LAND
DB $4C,<C0075,>C0075 ; SKPFLS C0075
; 906: mask = sizemask_11(^strptr + 1)
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $54,<C0055,>C0055 ; CALL C0055
DB $74,$04 ; SLB 4
; 907: ofst = (strptr - strheap) >> 4
DB $66,$02 ; LLW 2
DB $2C,$00,$70 ; CW 28672
DB $04 ; SUB
DB $2A,$04 ; CB 4
DB $1C ; SHR
DB $74,$05 ; SLB 5
; 908: mask = mask << (ofst & $07)
DB $64,$04 ; LLB 4
DB $64,$05 ; LLB 5
DB $2A,$07 ; CB 7
DB $14 ; BAND
DB $1A ; SHL
DB $74,$04 ; SLB 4
; 909: ofst = ofst >> 3
DB $64,$05 ; LLB 5
DB $2A,$03 ; CB 3
DB $1C ; SHR
DB $74,$05 ; SLB 5
; 910: strheapmap.[ofst] = strheapmap.[ofst] & #mask
DB $2C,$00,$15 ; CW 5376
DB $64,$05 ; LLB 5
DB $02 ; IDXB
DB $2C,$00,$15 ; CW 5376
DB $64,$05 ; LLB 5
DB $02 ; IDXB
DB $60 ; LB
DB $64,$04 ; LLB 4
DB $12 ; COMP
DB $14 ; BAND
DB $70 ; SB
; 911: fin
C0075:
C0076:
; 912: end
DB $5A ; LEAVE
; 913: def newstr_11(strptr)
C0077: ; newstr_11()
; strptr = 2
; 914: byte strlen
; strlen = 4
; 915: word newptr
; newptr = 5
; 916:
; 917: strlen = ^strptr
JSR INTERP
DB $58,$07,$01 ; ENTER 7,1
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $74,$04 ; SLB 4
; 918: while (strptr).[strlen] == $8D or (strptr).[strlen] == $A0
C0079:
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $2A,$8D ; CB 141
DB $40 ; ISEQ
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $2A,$A0 ; CB 160
DB $40 ; ISEQ
DB $22 ; LOR
DB $4C,<C0080,>C0080 ; SKPFLS C0080
; 919: strlen = strlen - 1
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$04 ; SLB 4
; 920: loop
DB $50,<C0079,>C0079 ; SKIP C0079
C0080:
; 921: if strlen == 0
DB $64,$04 ; LLB 4
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0081,>C0081 ; SKPFLS C0081
; 922: return @nullstr
DB $26,<D0048,>D0048 ; LA D0048
DB $5A ; LEAVE
; 923: fin
C0081:
C0082:
; 924: newptr = heapalloc_11(strlen + 1)
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $54,<C0063,>C0063 ; CALL C0063
DB $76,$05 ; SLW 5
; 925: if newptr
DB $66,$05 ; LLW 5
DB $4C,<C0083,>C0083 ; SKPFLS C0083
; 926: memcpy(strptr, newptr, strlen + 1)
DB $66,$02 ; LLW 2
DB $66,$05 ; LLW 5
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $54,<C0013,>C0013 ; CALL C0013
; 927: ^newptr = strlen
DB $66,$05 ; LLW 5
DB $64,$04 ; LLB 4
DB $70 ; SB
; 928: return newptr
DB $66,$05 ; LLW 5
DB $5A ; LEAVE
; 929: fin
C0083:
C0084:
; 930: return @nullstr
DB $26,<D0048,>D0048 ; LA D0048
DB $5A ; LEAVE
; 931: end
; 932: def inittxtbuf
C0085: ; inittxtbuf()
; 933: word i
; i = 2
; 934:
; 935: memset(0, strheapmap, strheapmsz)
JSR INTERP
DB $58,$04,$00 ; ENTER 4,0
DB $00 ; ZERO
DB $2C,$00,$15 ; CW 5376
DB $2A,$70 ; CB 112
DB $54,<C0011,>C0011 ; CALL C0011
; 936: memset(@nullstr, strlinbuf, maxfill * 2)
DB $26,<D0048,>D0048 ; LA D0048
DB $2C,$00,$10 ; CW 4096
DB $2C,$80,$02 ; CW 640
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $54,<C0011,>C0011 ; CALL C0011
; 937: entrypoint = 0
DB $00 ; ZERO
DB $7A,<D0492,>D0492 ; SAW D0492
; 938: numlines = 0
DB $00 ; ZERO
DB $7A,<D0206,>D0206 ; SAW D0206
; 939: cursrow = 0
DB $00 ; ZERO
DB $7A,<D0200,>D0200 ; SAW D0200
; 940: curscol = 0
DB $00 ; ZERO
DB $78,<D0197,>D0197 ; SAB D0197
; 941: cursx = 0
DB $00 ; ZERO
DB $78,<D0194,>D0194 ; SAB D0194
; 942: cursy = 0
DB $00 ; ZERO
DB $78,<D0195,>D0195 ; SAB D0195
; 943: scrnleft = 0
DB $00 ; ZERO
DB $78,<D0196,>D0196 ; SAB D0196
; 944: scrntop = 0
DB $00 ; ZERO
DB $7A,<D0202,>D0202 ; SAW D0202
; 945: cutbuf = 0
DB $00 ; ZERO
DB $7A,<D0208,>D0208 ; SAW D0208
; 946: end
DB $5A ; LEAVE
; 947: ;
; 948: ; Case conversion/printing routines
; 949: ;
; 950: def caseconv_11(chr)
C0087: ; caseconv_11()
; chr = 2
; 951: if flags & uppercase
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$08 ; CB 8
DB $14 ; BAND
DB $4C,<C0089,>C0089 ; SKPFLS C0089
; 952: if chr & $E0 == $E0
DB $66,$02 ; LLW 2
DB $2A,$E0 ; CB 224
DB $14 ; BAND
DB $2A,$E0 ; CB 224
DB $40 ; ISEQ
DB $4C,<C0091,>C0091 ; SKPFLS C0091
; 953: chr = chr - $E0
DB $66,$02 ; LLW 2
DB $2A,$E0 ; CB 224
DB $04 ; SUB
DB $76,$02 ; SLW 2
; 954: fin
C0091:
C0092:
; 955: fin
C0089:
C0090:
; 956: return chr
DB $66,$02 ; LLW 2
DB $5A ; LEAVE
; 957: end
; 958: def strupper_10(strptr)
C0093: ; strupper_10()
; strptr = 2
; 959: byte i, chr
; i = 4
; chr = 5
; 960:
; 961: for i = ^strptr downto 1
JSR INTERP
DB $58,$06,$01 ; ENTER 6,1
DB $66,$02 ; LLW 2
DB $60 ; LB
C0096:
DB $6C,$04 ; DLB 4
DB $2A,$01 ; CB 1
DB $38,<C0095,>C0095 ; SKPLT C0095
DB $0E ; DECR
; 962: chr = (strptr).[i]
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $74,$05 ; SLB 5
; 963: if chr & $E0 == $E0
DB $64,$05 ; LLB 5
DB $2A,$E0 ; CB 224
DB $14 ; BAND
DB $2A,$E0 ; CB 224
DB $40 ; ISEQ
DB $4C,<C0097,>C0097 ; SKPFLS C0097
; 964: (strptr).[i] = chr - $E0
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $64,$05 ; LLB 5
DB $2A,$E0 ; CB 224
DB $04 ; SUB
DB $70 ; SB
; 965: fin
C0097:
C0098:
; 966: next
DB $50,<C0096,>C0096 ; SKIP C0096
C0095:
DB $30 ; DROP
; 967: end
DB $5A ; LEAVE
; 968: def strlower_10(strptr)
C0099: ; strlower_10()
; strptr = 2
; 969: byte i, chr
; i = 4
; chr = 5
; 970:
; 971: for i = ^strptr downto 1
JSR INTERP
DB $58,$06,$01 ; ENTER 6,1
DB $66,$02 ; LLW 2
DB $60 ; LB
C0102:
DB $6C,$04 ; DLB 4
DB $2A,$01 ; CB 1
DB $38,<C0101,>C0101 ; SKPLT C0101
DB $0E ; DECR
; 972: chr = (strptr).[i]
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $74,$05 ; SLB 5
; 973: if chr & $E0 == $00
DB $64,$05 ; LLB 5
DB $2A,$E0 ; CB 224
DB $14 ; BAND
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0103,>C0103 ; SKPFLS C0103
; 974: (strptr).[i] = chr + $E0
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $64,$05 ; LLB 5
DB $2A,$E0 ; CB 224
DB $02 ; ADD
DB $70 ; SB
; 975: fin
C0103:
C0104:
; 976: next
DB $50,<C0102,>C0102 ; SKIP C0102
C0101:
DB $30 ; DROP
; 977: end
DB $5A ; LEAVE
; 978: def txtupper
C0105: ; txtupper()
; 979: word i, strptr
; i = 2
; strptr = 4
; 980:
; 981: flags = flags ? uppercase
JSR INTERP
DB $58,$06,$00 ; ENTER 6,0
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$08 ; CB 8
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 982: for i = numlines - 1 downto 0
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
C0108:
DB $6E,$02 ; DLW 2
DB $00 ; ZERO
DB $38,<C0107,>C0107 ; SKPLT C0107
DB $0E ; DECR
; 983: strupper_10(strlinbuf:[i])
DB $2C,$00,$10 ; CW 4096
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $62 ; LW
DB $54,<C0093,>C0093 ; CALL C0093
; 984: next
DB $50,<C0108,>C0108 ; SKIP C0108
C0107:
DB $30 ; DROP
; 985: end
DB $5A ; LEAVE
; 986: def txtlower
C0109: ; txtlower()
; 987: word i, strptr
; i = 2
; strptr = 4
; 988:
; 989: flags = flags & #uppercase
JSR INTERP
DB $58,$06,$00 ; ENTER 6,0
DB $68,<D0192,>D0192 ; LAB D0192
DB $2C,$F7,$FF ; CW -9
DB $14 ; BAND
DB $78,<D0192,>D0192 ; SAB D0192
; 990: for i = numlines - 1 downto 0
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
C0112:
DB $6E,$02 ; DLW 2
DB $00 ; ZERO
DB $38,<C0111,>C0111 ; SKPLT C0111
DB $0E ; DECR
; 991: strlower_10(strlinbuf:[i])
DB $2C,$00,$10 ; CW 4096
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $62 ; LW
DB $54,<C0099,>C0099 ; CALL C0099
; 992: next
DB $50,<C0112,>C0112 ; SKIP C0112
C0111:
DB $30 ; DROP
; 993: end
DB $5A ; LEAVE
; 994: def prbyte_10(h)
C0113: ; prbyte_10()
; h = 2
; 995: cout('$')
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$24 ; CB 36
DB $54,<C0015,>C0015 ; CALL C0015
; 996: 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,<C0007,>C0007 ; CALL C0007
DB $30 ; DROP
; 997: end
DB $5A ; LEAVE
; 998: def prword_10(h)
C0115: ; prword_10()
; h = 2
; 999: cout('$')
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$24 ; CB 36
DB $54,<C0015,>C0015 ; CALL C0015
; 1000: 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,<C0007,>C0007 ; CALL C0007
DB $30 ; DROP
; 1001: end
DB $5A ; LEAVE
; 1002: def print_10(i)
C0117: ; print_10()
; i = 2
; 1003: byte numstr[7]
; numstr = 4
; 1004: byte place, sign
; place = 11
; sign = 12
; 1005:
; 1006: place = 6
JSR INTERP
DB $58,$0D,$01 ; ENTER 13,1
DB $2A,$06 ; CB 6
DB $74,$0B ; SLB 11
; 1007: if i < 0
DB $66,$02 ; LLW 2
DB $00 ; ZERO
DB $46 ; ISLT
DB $4C,<C0119,>C0119 ; SKPFLS C0119
; 1008: sign = 1
DB $2A,$01 ; CB 1
DB $74,$0C ; SLB 12
; 1009: i = -i
DB $66,$02 ; LLW 2
DB $10 ; NEG
DB $76,$02 ; SLW 2
; 1010: else
DB $50,<C0120,>C0120 ; SKIP C0120
C0119:
; 1011: sign = 0
DB $00 ; ZERO
DB $74,$0C ; SLB 12
; 1012: fin
C0120:
; 1013: while i >= 10
C0121:
DB $66,$02 ; LLW 2
DB $2A,$0A ; CB 10
DB $48 ; ISGE
DB $4C,<C0122,>C0122 ; SKPFLS C0122
; 1014: 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
; 1015: place = place - 1
DB $64,$0B ; LLB 11
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$0B ; SLB 11
; 1016: loop
DB $50,<C0121,>C0121 ; SKIP C0121
C0122:
; 1017: 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
; 1018: place = place - 1
DB $64,$0B ; LLB 11
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$0B ; SLB 11
; 1019: if sign
DB $64,$0C ; LLB 12
DB $4C,<C0123,>C0123 ; SKPFLS C0123
; 1020: numstr[place] = '-'
DB $28,$04 ; LLA 4
DB $64,$0B ; LLB 11
DB $02 ; IDXB
DB $2A,$2D ; CB 45
DB $70 ; SB
; 1021: place = place - 1
DB $64,$0B ; LLB 11
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$0B ; SLB 11
; 1022: fin
C0123:
C0124:
; 1023: 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
; 1024: prstr(@numstr[place])
DB $28,$04 ; LLA 4
DB $64,$0B ; LLB 11
DB $02 ; IDXB
DB $54,<C0019,>C0019 ; CALL C0019
; 1025: end
DB $5A ; LEAVE
; 1026: def nametostr_30(namestr, len, strptr)
C0125: ; nametostr_30()
; namestr = 2
; len = 4
; strptr = 6
; 1027: ^strptr = len
JSR INTERP
DB $58,$08,$03 ; ENTER 8,3
DB $66,$06 ; LLW 6
DB $66,$04 ; LLW 4
DB $70 ; SB
; 1028: 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,<C0013,>C0013 ; CALL C0013
; 1029: end
DB $5A ; LEAVE
; 1030: ;def toupper_11(c)
; 1031: ; if c >= 'a'
; 1032: ; if c <= 'z'
; 1033: ; return c - $20
; 1034: ; fin
; 1035: ; fin
; 1036: ; return c
; 1037: ;end
; 1038: asm toupper_11
C0127: ; toupper_11()
; 1039: LDA ESTKL,X
LDA ESTKL,X
; 1040: AND #$7F
AND #$7F
; 1041: CMP #'a'
CMP #'a'
; 1042: BCC :+
BCC :+
; 1043: CMP #'z'+1
CMP #'z'+1
; 1044: BCS :+
BCS :+
; 1045: SEC
SEC
; 1046: SBC #$20
SBC #$20
; 1047: : STA ESTKL,X
: STA ESTKL,X
; 1048: end
RTS
; 1049: asm clrhibit_10(strptr)
C0129: ; clrhibit_10()
; strptr = 2
; 1050: LDY #$02 ; strptr
LDY #4
LDA #1
JSR ENTER
LDY #$02 ; strptr
; 1051: LDA (FRMP),Y
LDA (FRMP),Y
; 1052: STA SRCL
STA SRCL
; 1053: INY
INY
; 1054: LDA (FRMP),Y
LDA (FRMP),Y
; 1055: STA SRCH
STA SRCH
; 1056: LDY #$00
LDY #$00
; 1057: LDA (SRC),Y
LDA (SRC),Y
; 1058: BEQ :+
BEQ :+
; 1059: TAY
TAY
; 1060: CLHILP: LDA (SRC),Y
CLHILP: LDA (SRC),Y
; 1061: AND #$7F
AND #$7F
; 1062: STA (SRC),Y
STA (SRC),Y
; 1063: DEY
DEY
; 1064: BNE CLHILP
BNE CLHILP
; 1065: :
:
; 1066: end
JMP LEAVE
; 1067: asm sethibit_10(strptr)
C0131: ; sethibit_10()
; strptr = 2
; 1068: LDY #$02 ; strptr
LDY #4
LDA #1
JSR ENTER
LDY #$02 ; strptr
; 1069: LDA (FRMP),Y
LDA (FRMP),Y
; 1070: STA SRCL
STA SRCL
; 1071: INY
INY
; 1072: LDA (FRMP),Y
LDA (FRMP),Y
; 1073: STA SRCH
STA SRCH
; 1074: LDY #$00
LDY #$00
; 1075: LDA (SRC),Y
LDA (SRC),Y
; 1076: BEQ :+
BEQ :+
; 1077: TAY
TAY
; 1078: STHILP: LDA (SRC),Y
STHILP: LDA (SRC),Y
; 1079: ORA #$80
ORA #$80
; 1080: STA (SRC),Y
STA (SRC),Y
; 1081: DEY
DEY
; 1082: BNE STHILP
BNE STHILP
; 1083: :
:
; 1084: end
JMP LEAVE
; 1085: asm cpyln_20(srcstr, dststr)
C0133: ; cpyln_20()
; srcstr = 2
; dststr = 4
; 1086: LDY #$02 ; srcstr
LDY #6
LDA #2
JSR ENTER
LDY #$02 ; srcstr
; 1087: LDA (FRMP),Y
LDA (FRMP),Y
; 1088: STA SRCL
STA SRCL
; 1089: INY
INY
; 1090: LDA (FRMP),Y
LDA (FRMP),Y
; 1091: STA SRCH
STA SRCH
; 1092: INY ; dststr
INY ; dststr
; 1093: LDA (FRMP),Y
LDA (FRMP),Y
; 1094: STA DSTL
STA DSTL
; 1095: INY
INY
; 1096: LDA (FRMP),Y
LDA (FRMP),Y
; 1097: STA DSTH
STA DSTH
; 1098: LDY #$00
LDY #$00
; 1099: LDA (SRC),Y
LDA (SRC),Y
; 1100: TAY
TAY
; 1101: LDA #$00
LDA #$00
; 1102: INY
INY
; 1103: STA (DST),Y
STA (DST),Y
; 1104: DEY
DEY
; 1105: BEQ :++
BEQ :++
; 1106: CPLNLP: LDA (SRC),Y
CPLNLP: LDA (SRC),Y
; 1107: CMP #$20
CMP #$20
; 1108: BCS :+
BCS :+
; 1109: ADC #$60
ADC #$60
; 1110: : AND #$7F
: AND #$7F
; 1111: STA (DST),Y
STA (DST),Y
; 1112: DEY
DEY
; 1113: BNE CPLNLP
BNE CPLNLP
; 1114: LDA (SRC),Y
LDA (SRC),Y
; 1115: : STA (DST),Y
: STA (DST),Y
; 1116: end
JMP LEAVE
; 1117: ;
; 1118: ; File routines
; 1119: ;
; 1120: def readtxt_10(filename)
C0135: ; readtxt_10()
; filename = 2
; 1121: byte txtbuf[81], refnum, i, j
; txtbuf = 4
; refnum = 85
; i = 86
; j = 87
; 1122:
; 1123: refnum = open_21(filename, iobuffer)
JSR INTERP
DB $58,$58,$01 ; ENTER 88,1
DB $66,$02 ; LLW 2
DB $2C,$00,$08 ; CW 2048
DB $54,<C0029,>C0029 ; CALL C0029
DB $74,$55 ; SLB 85
; 1124: if refnum
DB $64,$55 ; LLB 85
DB $4C,<C0137,>C0137 ; SKPFLS C0137
; 1125: drop newline_31(refnum, $7F, $0D)
DB $64,$55 ; LLB 85
DB $2A,$7F ; CB 127
DB $2A,$0D ; CB 13
DB $54,<C0041,>C0041 ; CALL C0041
DB $30 ; DROP
; 1126: repeat
C0140:
; 1127: txtbuf = read_31(refnum, @txtbuf + 1, maxlnlen)
DB $64,$55 ; LLB 85
DB $28,$04 ; LLA 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $2A,$4F ; CB 79
DB $54,<C0033,>C0033 ; CALL C0033
DB $74,$04 ; SLB 4
; 1128: if txtbuf
DB $64,$04 ; LLB 4
DB $4C,<C0141,>C0141 ; SKPFLS C0141
; 1129: sethibit_10(@txtbuf)
DB $28,$04 ; LLA 4
DB $54,<C0131,>C0131 ; CALL C0131
; 1130: if flags & uppercase
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$08 ; CB 8
DB $14 ; BAND
DB $4C,<C0143,>C0143 ; SKPFLS C0143
; 1131: strupper_10(@txtbuf)
DB $28,$04 ; LLA 4
DB $54,<C0093,>C0093 ; CALL C0093
; 1132: fin
C0143:
C0144:
; 1133: strlinbuf:[numlines] = newstr_11(@txtbuf)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0206,>D0206 ; LAW D0206
DB $1E ; IDXW
DB $28,$04 ; LLA 4
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1134: numlines = numlines + 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0206,>D0206 ; SAW D0206
; 1135: fin
C0141:
C0142:
; 1136: if !(numlines & $0F)
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$0F ; CB 15
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C0145,>C0145 ; SKPFLS C0145
; 1137: cout('.')
DB $2A,$2E ; CB 46
DB $54,<C0015,>C0015 ; CALL C0015
; 1138: fin
C0145:
C0146:
; 1139: until txtbuf == 0 or numlines == maxlines
DB $64,$04 ; LLB 4
DB $00 ; ZERO
DB $40 ; ISEQ
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2C,$72,$02 ; CW 626
DB $40 ; ISEQ
DB $22 ; LOR
DB $4C,<C0140,>C0140 ; SKPFLS C0140
C0139:
; 1140: drop close_11(refnum)
DB $64,$55 ; LLB 85
DB $54,<C0031,>C0031 ; CALL C0031
DB $30 ; DROP
; 1141: fin
C0137:
C0138:
; 1142: if numlines == 0
DB $6A,<D0206,>D0206 ; LAW D0206
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0147,>C0147 ; SKPFLS C0147
; 1143: numlines = 1
DB $2A,$01 ; CB 1
DB $7A,<D0206,>D0206 ; SAW D0206
; 1144: fin
C0147:
C0148:
; 1145: end
DB $5A ; LEAVE
; 1146: def writetxt_10(filename)
C0149: ; writetxt_10()
; filename = 2
; 1147: byte txtbuf[81], refnum
; txtbuf = 4
; refnum = 85
; 1148: byte j, chr
; j = 86
; chr = 87
; 1149: word i, strptr
; i = 88
; strptr = 90
; 1150:
; 1151: drop destroy_11(filename)
JSR INTERP
DB $58,$5C,$01 ; ENTER 92,1
DB $66,$02 ; LLW 2
DB $54,<C0039,>C0039 ; CALL C0039
DB $30 ; DROP
; 1152: drop create_41(filename, $C3, $04, $00) ; full access, TXT file
DB $66,$02 ; LLW 2
DB $2A,$C3 ; CB 195
DB $2A,$04 ; CB 4
DB $00 ; ZERO
DB $54,<C0037,>C0037 ; CALL C0037
DB $30 ; DROP
; 1153: refnum = open_21(filename, iobuffer)
DB $66,$02 ; LLW 2
DB $2C,$00,$08 ; CW 2048
DB $54,<C0029,>C0029 ; CALL C0029
DB $74,$55 ; SLB 85
; 1154: if refnum == 0
DB $64,$55 ; LLB 85
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0151,>C0151 ; SKPFLS C0151
; 1155: return
DB $5A ; LEAVE
; 1156: fin
C0151:
C0152:
; 1157: for i = 0 to numlines - 1
DB $00 ; ZERO
C0154:
DB $6E,$58 ; DLW 88
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $3A,<C0153,>C0153 ; SKPGT C0153
DB $0C ; INCR
; 1158: cpyln_20(strlinbuf:[i], @txtbuf)
DB $2C,$00,$10 ; CW 4096
DB $66,$58 ; LLW 88
DB $1E ; IDXW
DB $62 ; LW
DB $28,$04 ; LLA 4
DB $54,<C0133,>C0133 ; CALL C0133
; 1159: txtbuf = txtbuf + 1
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$04 ; SLB 4
; 1160: txtbuf[txtbuf] = $0D
DB $28,$04 ; LLA 4
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $2A,$0D ; CB 13
DB $70 ; SB
; 1161: drop write_31(refnum, @txtbuf + 1, txtbuf)
DB $64,$55 ; LLB 85
DB $28,$04 ; LLA 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $64,$04 ; LLB 4
DB $54,<C0035,>C0035 ; CALL C0035
DB $30 ; DROP
; 1162: if !(i & $0F)
DB $66,$58 ; LLW 88
DB $2A,$0F ; CB 15
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C0155,>C0155 ; SKPFLS C0155
; 1163: cout('.')
DB $2A,$2E ; CB 46
DB $54,<C0015,>C0015 ; CALL C0015
; 1164: fin
C0155:
C0156:
; 1165: next
DB $50,<C0154,>C0154 ; SKIP C0154
C0153:
DB $30 ; DROP
; 1166: drop close_11(refnum)
DB $64,$55 ; LLB 85
DB $54,<C0031,>C0031 ; CALL C0031
DB $30 ; DROP
; 1167: end
DB $5A ; LEAVE
; 1168: ;
; 1169: ; Screen routines
; 1170: ;
; 1171: def clrscrn
C0157: ; clrscrn()
; 1172: drop romcall(0, 0, 0, 0, $FC58)
JSR INTERP
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $2C,$58,$FC ; CW 64600
DB $54,<C0007,>C0007 ; CALL C0007
DB $30 ; DROP
; 1173: end
DB $5C ; RET
; 1174: def drawrow_30(row, ofst, strptr)
C0159: ; drawrow_30()
; row = 2
; ofst = 4
; strptr = 6
; 1175: byte numchars
; numchars = 8
; 1176: word scrnptr
; scrnptr = 9
; 1177:
; 1178: scrnptr = txtscrn[row]
JSR INTERP
DB $58,$0B,$03 ; ENTER 11,3
DB $26,<D0000,>D0000 ; LA D0000
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $62 ; LW
DB $76,$09 ; SLW 9
; 1179: if ^strptr <= ofst
DB $66,$06 ; LLW 6
DB $60 ; LB
DB $66,$04 ; LLW 4
DB $4A ; ISLE
DB $4C,<C0161,>C0161 ; SKPFLS C0161
; 1180: numchars = 0
DB $00 ; ZERO
DB $74,$08 ; SLB 8
; 1181: else
DB $50,<C0162,>C0162 ; SKIP C0162
C0161:
; 1182: numchars = ^strptr - ofst
DB $66,$06 ; LLW 6
DB $60 ; LB
DB $66,$04 ; LLW 4
DB $04 ; SUB
DB $74,$08 ; SLB 8
; 1183: fin
C0162:
; 1184: if numchars >= 40
DB $64,$08 ; LLB 8
DB $2A,$28 ; CB 40
DB $48 ; ISGE
DB $4C,<C0163,>C0163 ; SKPFLS C0163
; 1185: numchars = 40
DB $2A,$28 ; CB 40
DB $74,$08 ; SLB 8
; 1186: else
DB $50,<C0164,>C0164 ; SKIP C0164
C0163:
; 1187: memset($A0A0, scrnptr + numchars, 40 - numchars)
DB $2C,$A0,$A0 ; CW 41120
DB $66,$09 ; LLW 9
DB $64,$08 ; LLB 8
DB $02 ; ADD
DB $2A,$28 ; CB 40
DB $64,$08 ; LLB 8
DB $04 ; SUB
DB $54,<C0011,>C0011 ; CALL C0011
; 1188: fin
C0164:
; 1189: memcpy(strptr + ofst + 1, scrnptr, numchars)
DB $66,$06 ; LLW 6
DB $66,$04 ; LLW 4
DB $02 ; ADD
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $66,$09 ; LLW 9
DB $64,$08 ; LLB 8
DB $54,<C0013,>C0013 ; CALL C0013
; 1190: end
DB $5A ; LEAVE
; 1191: defopt drawscrn_20(toprow, ofst)
C0165: ; drawscrn_20()
; toprow = 2
; ofst = 4
; 1192: byte row, numchars
; row = 6
; numchars = 7
; 1193: word strptr, scrnptr
; strptr = 8
; scrnptr = 10
; 1194:
; 1195: for row = 0 to 23
LDY #12
LDA #2
JSR ENTER
DEX
STY ESTKL,X
STY ESTKH,X
C0168:
LDY #$06
LDA ESTKL,X
STA (FRMP),Y
DEX
LDA #$17
STA ESTKL,X
LDY #$00
STY ESTKH,X
INX
LDA ESTKL-1,X
CMP ESTKL,X
LDA ESTKH-1,X
SBC ESTKH,X
BPL :+
JMP C0167
:
INC ESTKL,X
BNE :+
INC ESTKH,X
:
; 1196: strptr = strlinbuf:[toprow + row]
DEX
STY ESTKL,X
LDA #$10
STA ESTKH,X
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
JSR ADD
JSR IDXW
JSR LW
LDY #$08
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 1197: scrnptr = txtscrn[row]
LDA #<D0000
STA ESTKL,X
LDA #>D0000
STA ESTKH,X
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR IDXW
JSR LW
LDY #$0A
LDA ESTKL,X
STA (FRMP),Y
INY
LDA ESTKH,X
STA (FRMP),Y
; 1198: if ^strptr <= ofst
LDY #$08
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR LB
DEX
LDY #$04
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR ISLE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0169
:
; 1199: numchars = 0
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
LDY #$07
LDA ESTKL,X
STA (FRMP),Y
; 1200: else
INX
JMP C0170
C0169:
; 1201: numchars = ^strptr - ofst
DEX
LDY #$08
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR LB
DEX
LDY #$04
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JSR SUB
LDY #$07
LDA ESTKL,X
STA (FRMP),Y
; 1202: fin
INX
C0170:
; 1203: if numchars >= 40
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDA #$28
STA ESTKL,X
STY ESTKH,X
JSR ISGE
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0171
:
; 1204: numchars = 40
DEX
LDA #$28
STA ESTKL,X
LDY #$00
STY ESTKH,X
LDY #$07
LDA ESTKL,X
STA (FRMP),Y
; 1205: else
INX
JMP C0172
C0171:
; 1206: memset($A0A0, scrnptr + numchars, 40 - numchars)
DEX
LDA #$A0
STA ESTKL,X
STA ESTKH,X
DEX
LDY #$0A
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
DEX
LDA #$28
STA ESTKL,X
STY ESTKH,X
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SUB
JSR C0011
; 1207: fin
C0172:
; 1208: memcpy(strptr + ofst + 1, scrnptr, numchars)
DEX
LDY #$08
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
JSR ADD
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
DEX
LDY #$0A
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0013
; 1209: next
JMP C0168
C0167:
; 1210: end
INX
JMP LEAVE
; 1211: def cursoff
C0173: ; cursoff()
; 1212: if flags & showcurs
JSR INTERP
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$04 ; CB 4
DB $14 ; BAND
DB $4C,<C0175,>C0175 ; SKPFLS C0175
; 1213: ^cursptr = underchr
DB $6A,<D0204,>D0204 ; LAW D0204
DB $68,<D0198,>D0198 ; LAB D0198
DB $70 ; SB
; 1214: flags = flags & #showcurs
DB $68,<D0192,>D0192 ; LAB D0192
DB $2C,$FB,$FF ; CW -5
DB $14 ; BAND
DB $78,<D0192,>D0192 ; SAB D0192
; 1215: fin
C0175:
C0176:
; 1216: end
DB $5C ; RET
; 1217: def curson
C0177: ; curson()
; 1218: if !(flags & showcurs)
JSR INTERP
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$04 ; CB 4
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C0179,>C0179 ; SKPFLS C0179
; 1219: cursptr = txtscrn[cursy] + cursx
DB $26,<D0000,>D0000 ; LA D0000
DB $68,<D0195,>D0195 ; LAB D0195
DB $1E ; IDXW
DB $62 ; LW
DB $68,<D0194,>D0194 ; LAB D0194
DB $02 ; ADD
DB $7A,<D0204,>D0204 ; SAW D0204
; 1220: underchr = ^cursptr
DB $6A,<D0204,>D0204 ; LAW D0204
DB $60 ; LB
DB $78,<D0198,>D0198 ; SAB D0198
; 1221: ^cursptr = curschr
DB $6A,<D0204,>D0204 ; LAW D0204
DB $68,<D0199,>D0199 ; LAB D0199
DB $70 ; SB
; 1222: flags = flags ? showcurs
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$04 ; CB 4
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1223: fin
C0179:
C0180:
; 1224: end
DB $5C ; RET
; 1225: def cursflash()
C0181: ; cursflash()
; 1226: if flags & showcurs
JSR INTERP
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$04 ; CB 4
DB $14 ; BAND
DB $4C,<C0183,>C0183 ; SKPFLS C0183
; 1227: if flash == 0
DB $68,<D0193,>D0193 ; LAB D0193
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0185,>C0185 ; SKPFLS C0185
; 1228: ^cursptr = curschr
DB $6A,<D0204,>D0204 ; LAW D0204
DB $68,<D0199,>D0199 ; LAB D0199
DB $70 ; SB
; 1229: elsif flash == 128
DB $50,<C0186,>C0186 ; SKIP C0186
C0185:
DB $68,<D0193,>D0193 ; LAB D0193
DB $2A,$80 ; CB 128
DB $40 ; ISEQ
DB $4C,<C0187,>C0187 ; SKPFLS C0187
; 1230: ^cursptr = underchr
DB $6A,<D0204,>D0204 ; LAW D0204
DB $68,<D0198,>D0198 ; LAB D0198
DB $70 ; SB
; 1231: fin
C0187:
C0186:
; 1232: flash = flash + 1
DB $68,<D0193,>D0193 ; LAB D0193
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0193,>D0193 ; SAB D0193
; 1233: fin
C0183:
C0184:
; 1234: end
DB $5C ; RET
; 1235: def redraw
C0188: ; redraw()
; 1236: cursoff()
JSR INTERP
DB $54,<C0173,>C0173 ; CALL C0173
; 1237: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1238: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1239: end
DB $5C ; RET
; 1240: def curshome
C0190: ; curshome()
; 1241: cursoff()
JSR INTERP
DB $54,<C0173,>C0173 ; CALL C0173
; 1242: cursrow = 0
DB $00 ; ZERO
DB $7A,<D0200,>D0200 ; SAW D0200
; 1243: curscol = 0
DB $00 ; ZERO
DB $78,<D0197,>D0197 ; SAB D0197
; 1244: cursx = 0
DB $00 ; ZERO
DB $78,<D0194,>D0194 ; SAB D0194
; 1245: cursy = 0
DB $00 ; ZERO
DB $78,<D0195,>D0195 ; SAB D0195
; 1246: scrnleft = 0
DB $00 ; ZERO
DB $78,<D0196,>D0196 ; SAB D0196
; 1247: scrntop = 0
DB $00 ; ZERO
DB $7A,<D0202,>D0202 ; SAW D0202
; 1248: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1249: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1250: end
DB $5C ; RET
; 1251: def cursend
C0192: ; cursend()
; 1252: cursoff()
JSR INTERP
DB $54,<C0173,>C0173 ; CALL C0173
; 1253: if numlines > 23
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$17 ; CB 23
DB $44 ; ISGT
DB $4C,<C0194,>C0194 ; SKPFLS C0194
; 1254: cursrow = numlines - 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0200,>D0200 ; SAW D0200
; 1255: cursy = 23
DB $2A,$17 ; CB 23
DB $78,<D0195,>D0195 ; SAB D0195
; 1256: scrntop = cursrow - 23
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$17 ; CB 23
DB $04 ; SUB
DB $7A,<D0202,>D0202 ; SAW D0202
; 1257: else
DB $50,<C0195,>C0195 ; SKIP C0195
C0194:
; 1258: cursrow = numlines - 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0200,>D0200 ; SAW D0200
; 1259: cursy = numlines - 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0195,>D0195 ; SAB D0195
; 1260: scrntop = 0
DB $00 ; ZERO
DB $7A,<D0202,>D0202 ; SAW D0202
; 1261: fin
C0195:
; 1262: curscol = 0
DB $00 ; ZERO
DB $78,<D0197,>D0197 ; SAB D0197
; 1263: cursx = 0
DB $00 ; ZERO
DB $78,<D0194,>D0194 ; SAB D0194
; 1264: scrnleft = 0
DB $00 ; ZERO
DB $78,<D0196,>D0196 ; SAB D0196
; 1265: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1266: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1267: end
DB $5C ; RET
; 1268: def cursup
C0196: ; cursup()
; 1269: if cursrow > 0
JSR INTERP
DB $6A,<D0200,>D0200 ; LAW D0200
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0198,>C0198 ; SKPFLS C0198
; 1270: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1271: cursrow = cursrow - 1
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0200,>D0200 ; SAW D0200
; 1272: if cursy > 0
DB $68,<D0195,>D0195 ; LAB D0195
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0200,>C0200 ; SKPFLS C0200
; 1273: cursy = cursy - 1
DB $68,<D0195,>D0195 ; LAB D0195
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0195,>D0195 ; SAB D0195
; 1274: else
DB $50,<C0201,>C0201 ; SKIP C0201
C0200:
; 1275: scrntop = cursrow
DB $6A,<D0200,>D0200 ; LAW D0200
DB $7A,<D0202,>D0202 ; SAW D0202
; 1276: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1277: fin
C0201:
; 1278: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1279: fin
C0198:
C0199:
; 1280: end
DB $5C ; RET
; 1281: def pgup
C0202: ; pgup()
; 1282: byte i
; i = 2
; 1283:
; 1284: for i = pgjmp downto 0
JSR INTERP
DB $58,$03,$00 ; ENTER 3,0
DB $2A,$10 ; CB 16
C0205:
DB $6C,$02 ; DLB 2
DB $00 ; ZERO
DB $38,<C0204,>C0204 ; SKPLT C0204
DB $0E ; DECR
; 1285: cursup()
DB $54,<C0196,>C0196 ; CALL C0196
; 1286: next
DB $50,<C0205,>C0205 ; SKIP C0205
C0204:
DB $30 ; DROP
; 1287: end
DB $5A ; LEAVE
; 1288: def cursdown
C0206: ; cursdown()
; 1289: if cursrow < numlines - 1
JSR INTERP
DB $6A,<D0200,>D0200 ; LAW D0200
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $46 ; ISLT
DB $4C,<C0208,>C0208 ; SKPFLS C0208
; 1290: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1291: cursrow = cursrow + 1
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0200,>D0200 ; SAW D0200
; 1292: if cursy < 23
DB $68,<D0195,>D0195 ; LAB D0195
DB $2A,$17 ; CB 23
DB $46 ; ISLT
DB $4C,<C0210,>C0210 ; SKPFLS C0210
; 1293: cursy = cursy + 1
DB $68,<D0195,>D0195 ; LAB D0195
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0195,>D0195 ; SAB D0195
; 1294: else
DB $50,<C0211,>C0211 ; SKIP C0211
C0210:
; 1295: scrntop = cursrow - 23
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$17 ; CB 23
DB $04 ; SUB
DB $7A,<D0202,>D0202 ; SAW D0202
; 1296: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1297: fin
C0211:
; 1298: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1299: fin
C0208:
C0209:
; 1300: end
DB $5C ; RET
; 1301: def pgdown
C0212: ; pgdown()
; 1302: byte i
; i = 2
; 1303:
; 1304: for i = pgjmp downto 0
JSR INTERP
DB $58,$03,$00 ; ENTER 3,0
DB $2A,$10 ; CB 16
C0215:
DB $6C,$02 ; DLB 2
DB $00 ; ZERO
DB $38,<C0214,>C0214 ; SKPLT C0214
DB $0E ; DECR
; 1305: cursdown()
DB $54,<C0206,>C0206 ; CALL C0206
; 1306: next
DB $50,<C0215,>C0215 ; SKIP C0215
C0214:
DB $30 ; DROP
; 1307: end
DB $5A ; LEAVE
; 1308: def cursleft
C0216: ; cursleft()
; 1309: if curscol > 0
JSR INTERP
DB $68,<D0197,>D0197 ; LAB D0197
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0218,>C0218 ; SKPFLS C0218
; 1310: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1311: curscol = curscol - 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0197,>D0197 ; SAB D0197
; 1312: if cursx > 0
DB $68,<D0194,>D0194 ; LAB D0194
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0220,>C0220 ; SKPFLS C0220
; 1313: cursx = cursx - 1
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0194,>D0194 ; SAB D0194
; 1314: else
DB $50,<C0221,>C0221 ; SKIP C0221
C0220:
; 1315: scrnleft = curscol
DB $68,<D0197,>D0197 ; LAB D0197
DB $78,<D0196,>D0196 ; SAB D0196
; 1316: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1317: fin
C0221:
; 1318: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1319: fin
C0218:
C0219:
; 1320: end
DB $5C ; RET
; 1321: def pgleft
C0222: ; pgleft()
; 1322: byte i
; i = 2
; 1323:
; 1324: for i = 7 downto 0
JSR INTERP
DB $58,$03,$00 ; ENTER 3,0
DB $2A,$07 ; CB 7
C0225:
DB $6C,$02 ; DLB 2
DB $00 ; ZERO
DB $38,<C0224,>C0224 ; SKPLT C0224
DB $0E ; DECR
; 1325: cursleft()
DB $54,<C0216,>C0216 ; CALL C0216
; 1326: next
DB $50,<C0225,>C0225 ; SKIP C0225
C0224:
DB $30 ; DROP
; 1327: end
DB $5A ; LEAVE
; 1328: def cursright
C0226: ; cursright()
; 1329: if curscol < 80
JSR INTERP
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$50 ; CB 80
DB $46 ; ISLT
DB $4C,<C0228,>C0228 ; SKPFLS C0228
; 1330: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1331: curscol = curscol + 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0197,>D0197 ; SAB D0197
; 1332: if cursx < 39
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$27 ; CB 39
DB $46 ; ISLT
DB $4C,<C0230,>C0230 ; SKPFLS C0230
; 1333: cursx = cursx + 1
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0194,>D0194 ; SAB D0194
; 1334: else
DB $50,<C0231,>C0231 ; SKIP C0231
C0230:
; 1335: scrnleft = curscol - 39
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$27 ; CB 39
DB $04 ; SUB
DB $78,<D0196,>D0196 ; SAB D0196
; 1336: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1337: fin
C0231:
; 1338: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1339: fin
C0228:
C0229:
; 1340: end
DB $5C ; RET
; 1341: def pgright
C0232: ; pgright()
; 1342: byte i
; i = 2
; 1343:
; 1344: for i = 7 downto 0
JSR INTERP
DB $58,$03,$00 ; ENTER 3,0
DB $2A,$07 ; CB 7
C0235:
DB $6C,$02 ; DLB 2
DB $00 ; ZERO
DB $38,<C0234,>C0234 ; SKPLT C0234
DB $0E ; DECR
; 1345: cursright()
DB $54,<C0226,>C0226 ; CALL C0226
; 1346: next
DB $50,<C0235,>C0235 ; SKIP C0235
C0234:
DB $30 ; DROP
; 1347: end
DB $5A ; LEAVE
; 1348: ;
; 1349: ; Keyboard routines
; 1350: ;
; 1351: def keyin2e_01
C0236: ; keyin2e_01()
; 1352: repeat
JSR INTERP
C0239:
; 1353: cursflash()
DB $54,<C0181,>C0181 ; CALL C0181
; 1354: until ^keyboard >= 128
DB $2C,$00,$C0 ; CW 49152
DB $60 ; LB
DB $2A,$80 ; CB 128
DB $48 ; ISGE
DB $4C,<C0239,>C0239 ; SKPFLS C0239
C0238:
; 1355: return ^keystrobe
DB $2C,$10,$C0 ; CW 49168
DB $60 ; LB
DB $5C ; RET
; 1356: end
; 1357: def keyin2_01
C0240: ; keyin2_01()
; 1358: byte key
; key = 2
; 1359:
; 1360: repeat
JSR INTERP
DB $58,$03,$00 ; ENTER 3,0
C0243:
; 1361: cursflash()
DB $54,<C0181,>C0181 ; CALL C0181
; 1362: key = ^keyboard
DB $2C,$00,$C0 ; CW 49152
DB $60 ; LB
DB $74,$02 ; SLB 2
; 1363: if key == keyctrll
DB $64,$02 ; LLB 2
DB $2A,$8C ; CB 140
DB $40 ; ISEQ
DB $4C,<C0244,>C0244 ; SKPFLS C0244
; 1364: drop ^keystrobe
DB $2C,$10,$C0 ; CW 49168
DB $60 ; LB
DB $30 ; DROP
; 1365: flags = flags ^ shiftlock
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$80 ; CB 128
DB $18 ; XOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1366: key = 0
DB $00 ; ZERO
DB $74,$02 ; SLB 2
; 1367: fin
C0244:
C0245:
; 1368: until key >= 128
DB $64,$02 ; LLB 2
DB $2A,$80 ; CB 128
DB $48 ; ISGE
DB $4C,<C0243,>C0243 ; SKPFLS C0243
C0242:
; 1369: drop ^keystrobe
DB $2C,$10,$C0 ; CW 49168
DB $60 ; LB
DB $30 ; DROP
; 1370: if key == keyctrln
DB $64,$02 ; LLB 2
DB $2A,$8E ; CB 142
DB $40 ; ISEQ
DB $4C,<C0246,>C0246 ; SKPFLS C0246
; 1371: key = $DB ; [
DB $2A,$DB ; CB 219
DB $74,$02 ; SLB 2
; 1372: elsif key == keyctrlp
DB $50,<C0247,>C0247 ; SKIP C0247
C0246:
DB $64,$02 ; LLB 2
DB $2A,$90 ; CB 144
DB $40 ; ISEQ
DB $4C,<C0248,>C0248 ; SKPFLS C0248
; 1373: key = $DF ; _
DB $2A,$DF ; CB 223
DB $74,$02 ; SLB 2
; 1374: elsif key == keyctrlb
DB $50,<C0247,>C0247 ; SKIP C0247
C0248:
DB $64,$02 ; LLB 2
DB $2A,$82 ; CB 130
DB $40 ; ISEQ
DB $4C,<C0249,>C0249 ; SKPFLS C0249
; 1375: key = $DC ; \
DB $2A,$DC ; CB 220
DB $74,$02 ; SLB 2
; 1376: elsif key == keyarrowleft
DB $50,<C0247,>C0247 ; SKIP C0247
C0249:
DB $64,$02 ; LLB 2
DB $2A,$88 ; CB 136
DB $40 ; ISEQ
DB $4C,<C0250,>C0250 ; SKPFLS C0250
; 1377: if ^pushbttn3 < 128
DB $2C,$63,$C0 ; CW 49251
DB $60 ; LB
DB $2A,$80 ; CB 128
DB $46 ; ISLT
DB $4C,<C0251,>C0251 ; SKPFLS C0251
; 1378: key = $FF
DB $2A,$FF ; CB 255
DB $74,$02 ; SLB 2
; 1379: fin
C0251:
C0252:
; 1380: elsif key >= $C0 and flags < shiftlock
DB $50,<C0247,>C0247 ; SKIP C0247
C0250:
DB $64,$02 ; LLB 2
DB $2A,$C0 ; CB 192
DB $48 ; ISGE
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$80 ; CB 128
DB $46 ; ISLT
DB $24 ; LAND
DB $4C,<C0253,>C0253 ; SKPFLS C0253
; 1381: if ^pushbttn3 < 128
DB $2C,$63,$C0 ; CW 49251
DB $60 ; LB
DB $2A,$80 ; CB 128
DB $46 ; ISLT
DB $4C,<C0254,>C0254 ; SKPFLS C0254
; 1382: if key == $C0
DB $64,$02 ; LLB 2
DB $2A,$C0 ; CB 192
DB $40 ; ISEQ
DB $4C,<C0256,>C0256 ; SKPFLS C0256
; 1383: key = $D0 ; P
DB $2A,$D0 ; CB 208
DB $74,$02 ; SLB 2
; 1384: elsif key == $DD
DB $50,<C0257,>C0257 ; SKIP C0257
C0256:
DB $64,$02 ; LLB 2
DB $2A,$DD ; CB 221
DB $40 ; ISEQ
DB $4C,<C0258,>C0258 ; SKPFLS C0258
; 1385: key = $CD ; M
DB $2A,$CD ; CB 205
DB $74,$02 ; SLB 2
; 1386: elsif key == $DE
DB $50,<C0257,>C0257 ; SKIP C0257
C0258:
DB $64,$02 ; LLB 2
DB $2A,$DE ; CB 222
DB $40 ; ISEQ
DB $4C,<C0259,>C0259 ; SKPFLS C0259
; 1387: key = $CE ; N
DB $2A,$CE ; CB 206
DB $74,$02 ; SLB 2
; 1388: fin
C0259:
C0257:
; 1389: else
DB $50,<C0255,>C0255 ; SKIP C0255
C0254:
; 1390: key = key ? $E0
DB $64,$02 ; LLB 2
DB $2A,$E0 ; CB 224
DB $16 ; IOR
DB $74,$02 ; SLB 2
; 1391: fin
C0255:
; 1392: fin
C0253:
C0247:
; 1393: return key
DB $64,$02 ; LLB 2
DB $5A ; LEAVE
; 1394: end
; 1395: ;
; 1396: ; Printer routines
; 1397: ;
; 1398: def printtxt_10(slot)
C0260: ; printtxt_10()
; slot = 2
; 1399: byte txtbuf[80]
; txtbuf = 4
; 1400: word i, scrncsw
; i = 84
; scrncsw = 86
; 1401:
; 1402: scrncsw = *(csw)
JSR INTERP
DB $58,$58,$01 ; ENTER 88,1
DB $2A,$36 ; CB 54
DB $62 ; LW
DB $76,$56 ; SLW 86
; 1403: *(csw) = $C000 ? (slot << 8)
DB $2A,$36 ; CB 54
DB $2C,$00,$C0 ; CW 49152
DB $66,$02 ; LLW 2
DB $2A,$08 ; CB 8
DB $1A ; SHL
DB $16 ; IOR
DB $72 ; SW
; 1404: for i = 0 to numlines - 1
DB $00 ; ZERO
C0263:
DB $6E,$54 ; DLW 84
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $3A,<C0262,>C0262 ; SKPGT C0262
DB $0C ; INCR
; 1405: cpyln_20(strlinbuf:[i], @txtbuf)
DB $2C,$00,$10 ; CW 4096
DB $66,$54 ; LLW 84
DB $1E ; IDXW
DB $62 ; LW
DB $28,$04 ; LLA 4
DB $54,<C0133,>C0133 ; CALL C0133
; 1406: prstr(@txtbuf)
DB $28,$04 ; LLA 4
DB $54,<C0019,>C0019 ; CALL C0019
; 1407: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1408: next
DB $50,<C0263,>C0263 ; SKIP C0263
C0262:
DB $30 ; DROP
; 1409: *(csw) = scrncsw
DB $2A,$36 ; CB 54
DB $66,$56 ; LLW 86
DB $72 ; SW
; 1410: end
DB $5A ; LEAVE
; 1411: def openline_11(row)
C0264: ; openline_11()
; row = 2
; 1412: if numlines < maxlines
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2C,$72,$02 ; CW 626
DB $46 ; ISLT
DB $4C,<C0266,>C0266 ; SKPFLS C0266
; 1413: memcpy(@strlinbuf:[row], @strlinbuf:[row + 1], (numlines - row) * 2)
DB $2C,$00,$10 ; CW 4096
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $2C,$00,$10 ; CW 4096
DB $66,$02 ; LLW 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $6A,<D0206,>D0206 ; LAW D0206
DB $66,$02 ; LLW 2
DB $04 ; SUB
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $54,<C0013,>C0013 ; CALL C0013
; 1414: strlinbuf:[row] = @nullstr
DB $2C,$00,$10 ; CW 4096
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $26,<D0048,>D0048 ; LA D0048
DB $72 ; SW
; 1415: numlines = numlines + 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0206,>D0206 ; SAW D0206
; 1416: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1417: return 1
DB $2A,$01 ; CB 1
DB $5A ; LEAVE
; 1418: fin
C0266:
C0267:
; 1419: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1420: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 1421: end
; 1422: def cutline
C0268: ; cutline()
; 1423: freestr_10(cutbuf)
JSR INTERP
DB $6A,<D0208,>D0208 ; LAW D0208
DB $54,<C0073,>C0073 ; CALL C0073
; 1424: cutbuf = strlinbuf:[cursrow]
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $7A,<D0208,>D0208 ; SAW D0208
; 1425: memcpy(@strlinbuf:[cursrow + 1], @strlinbuf:[cursrow], (numlines - cursrow) * 2)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $6A,<D0206,>D0206 ; LAW D0206
DB $6A,<D0200,>D0200 ; LAW D0200
DB $04 ; SUB
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $54,<C0013,>C0013 ; CALL C0013
; 1426: if numlines > 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $44 ; ISGT
DB $4C,<C0270,>C0270 ; SKPFLS C0270
; 1427: numlines = numlines - 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0206,>D0206 ; SAW D0206
; 1428: fin
C0270:
C0271:
; 1429: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1430: if cursrow == numlines
DB $6A,<D0200,>D0200 ; LAW D0200
DB $6A,<D0206,>D0206 ; LAW D0206
DB $40 ; ISEQ
DB $4C,<C0272,>C0272 ; SKPFLS C0272
; 1431: cursup()
DB $54,<C0196,>C0196 ; CALL C0196
; 1432: fin
C0272:
C0273:
; 1433: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1434: end
DB $5C ; RET
; 1435: def pasteline
C0274: ; pasteline()
; 1436: if cutbuf and numlines < maxlines
JSR INTERP
DB $6A,<D0208,>D0208 ; LAW D0208
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2C,$72,$02 ; CW 626
DB $46 ; ISLT
DB $24 ; LAND
DB $4C,<C0276,>C0276 ; SKPFLS C0276
; 1437: memcpy(@strlinbuf:[cursrow], @strlinbuf:[cursrow + 1], (numlines - cursrow) * 2)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $6A,<D0206,>D0206 ; LAW D0206
DB $6A,<D0200,>D0200 ; LAW D0200
DB $04 ; SUB
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $54,<C0013,>C0013 ; CALL C0013
; 1438: strlinbuf:[cursrow] = newstr_11(cutbuf)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $6A,<D0208,>D0208 ; LAW D0208
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1439: numlines = numlines + 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0206,>D0206 ; SAW D0206
; 1440: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1441: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1442: else
DB $50,<C0277,>C0277 ; SKIP C0277
C0276:
; 1443: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1444: fin
C0277:
; 1445: end
DB $5C ; RET
; 1446: def joinline
C0278: ; joinline()
; 1447: byte joinstr[80], joinlen
; joinstr = 2
; joinlen = 82
; 1448:
; 1449: if cursrow < numlines - 1
JSR INTERP
DB $58,$53,$00 ; ENTER 83,0
DB $6A,<D0200,>D0200 ; LAW D0200
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $46 ; ISLT
DB $4C,<C0280,>C0280 ; SKPFLS C0280
; 1450: strcpy_20(strlinbuf:[cursrow], @joinstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $28,$02 ; LLA 2
DB $54,<C0047,>C0047 ; CALL C0047
; 1451: joinlen = joinstr + ^(strlinbuf:[cursrow + 1])
DB $64,$02 ; LLB 2
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $62 ; LW
DB $60 ; LB
DB $02 ; ADD
DB $74,$52 ; SLB 82
; 1452: if joinlen < 80
DB $64,$52 ; LLB 82
DB $2A,$50 ; CB 80
DB $46 ; ISLT
DB $4C,<C0282,>C0282 ; SKPFLS C0282
; 1453: memcpy(strlinbuf:[cursrow + 1] + 1, @joinstr + joinstr + 1, ^(strlinbuf:[cursrow + 1]))
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $62 ; LW
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $28,$02 ; LLA 2
DB $64,$02 ; LLB 2
DB $02 ; ADD
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $62 ; LW
DB $60 ; LB
DB $54,<C0013,>C0013 ; CALL C0013
; 1454: joinstr = joinlen
DB $64,$52 ; LLB 82
DB $74,$02 ; SLB 2
; 1455: freestr_10(strlinbuf:[cursrow])
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $54,<C0073,>C0073 ; CALL C0073
; 1456: strlinbuf:[cursrow] = newstr_11(@joinstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $28,$02 ; LLA 2
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1457: freestr_10(strlinbuf:[cursrow + 1])
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $62 ; LW
DB $54,<C0073,>C0073 ; CALL C0073
; 1458: numlines = numlines - 1
DB $6A,<D0206,>D0206 ; LAW D0206
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0206,>D0206 ; SAW D0206
; 1459: memcpy(@strlinbuf:[cursrow + 2], @strlinbuf:[cursrow + 1], (numlines - cursrow) * 2)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $1E ; IDXW
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $6A,<D0206,>D0206 ; LAW D0206
DB $6A,<D0200,>D0200 ; LAW D0200
DB $04 ; SUB
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $54,<C0013,>C0013 ; CALL C0013
; 1460: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1461: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1462: else
DB $50,<C0283,>C0283 ; SKIP C0283
C0282:
; 1463: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1464: fin
C0283:
; 1465: fin
C0280:
C0281:
; 1466: end
DB $5A ; LEAVE
; 1467: def splitline
C0284: ; splitline()
; 1468: byte splitstr[80], splitlen
; splitstr = 2
; splitlen = 82
; 1469:
; 1470: if openline_11(cursrow + 1)
JSR INTERP
DB $58,$53,$00 ; ENTER 83,0
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $54,<C0264,>C0264 ; CALL C0264
DB $4C,<C0286,>C0286 ; SKPFLS C0286
; 1471: if curscol
DB $68,<D0197,>D0197 ; LAB D0197
DB $4C,<C0288,>C0288 ; SKPFLS C0288
; 1472: splitlen = ^(strlinbuf:[cursrow])
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $60 ; LB
DB $74,$52 ; SLB 82
; 1473: if curscol < splitlen - 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $64,$52 ; LLB 82
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $46 ; ISLT
DB $4C,<C0290,>C0290 ; SKPFLS C0290
; 1474: memcpy(strlinbuf:[cursrow] + curscol + 1, @splitstr + 1, splitlen - curscol)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $68,<D0197,>D0197 ; LAB D0197
DB $02 ; ADD
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $28,$02 ; LLA 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $64,$52 ; LLB 82
DB $68,<D0197,>D0197 ; LAB D0197
DB $04 ; SUB
DB $54,<C0013,>C0013 ; CALL C0013
; 1475: splitstr = splitlen - curscol
DB $64,$52 ; LLB 82
DB $68,<D0197,>D0197 ; LAB D0197
DB $04 ; SUB
DB $74,$02 ; SLB 2
; 1476: strlinbuf:[cursrow + 1] = newstr_11(@splitstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $28,$02 ; LLA 2
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1477: memcpy(strlinbuf:[cursrow] + 1, @splitstr + 1, curscol)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $28,$02 ; LLA 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D0197,>D0197 ; LAB D0197
DB $54,<C0013,>C0013 ; CALL C0013
; 1478: splitstr = curscol
DB $68,<D0197,>D0197 ; LAB D0197
DB $74,$02 ; SLB 2
; 1479: freestr_10(strlinbuf:[cursrow])
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $54,<C0073,>C0073 ; CALL C0073
; 1480: strlinbuf:[cursrow] = newstr_11(@splitstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $28,$02 ; LLA 2
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1481: fin
C0290:
C0291:
; 1482: else
DB $50,<C0289,>C0289 ; SKIP C0289
C0288:
; 1483: strlinbuf:[cursrow + 1] = strlinbuf:[cursrow]
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $1E ; IDXW
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $72 ; SW
; 1484: strlinbuf:[cursrow] = @nullstr
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $26,<D0048,>D0048 ; LA D0048
DB $72 ; SW
; 1485: fin
C0289:
; 1486: curscol = 0
DB $00 ; ZERO
DB $78,<D0197,>D0197 ; SAB D0197
; 1487: cursx = 0
DB $00 ; ZERO
DB $78,<D0194,>D0194 ; SAB D0194
; 1488: scrnleft = 0
DB $00 ; ZERO
DB $78,<D0196,>D0196 ; SAB D0196
; 1489: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1490: cursdown()
DB $54,<C0206,>C0206 ; CALL C0206
; 1491: fin
C0286:
C0287:
; 1492: end
DB $5A ; LEAVE
; 1493: def editkey_11(key)
C0292: ; editkey_11()
; key = 2
; 1494: if key >= keyspace
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $66,$02 ; LLW 2
DB $2A,$A0 ; CB 160
DB $48 ; ISGE
DB $4C,<C0294,>C0294 ; SKPFLS C0294
; 1495: return 1
DB $2A,$01 ; CB 1
DB $5A ; LEAVE
; 1496: elsif key == keydelete
DB $50,<C0295,>C0295 ; SKIP C0295
C0294:
DB $66,$02 ; LLW 2
DB $2A,$FF ; CB 255
DB $40 ; ISEQ
DB $4C,<C0296,>C0296 ; SKPFLS C0296
; 1497: return 1
DB $2A,$01 ; CB 1
DB $5A ; LEAVE
; 1498: elsif key == keyctrld
DB $50,<C0295,>C0295 ; SKIP C0295
C0296:
DB $66,$02 ; LLW 2
DB $2A,$84 ; CB 132
DB $40 ; ISEQ
DB $4C,<C0297,>C0297 ; SKPFLS C0297
; 1499: return 1
DB $2A,$01 ; CB 1
DB $5A ; LEAVE
; 1500: elsif key == keyctrlr
DB $50,<C0295,>C0295 ; SKIP C0295
C0297:
DB $66,$02 ; LLW 2
DB $2A,$92 ; CB 146
DB $40 ; ISEQ
DB $4C,<C0298,>C0298 ; SKPFLS C0298
; 1501: return 1
DB $2A,$01 ; CB 1
DB $5A ; LEAVE
; 1502: fin
C0298:
C0295:
; 1503: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 1504: end
; 1505: def editline_11(key)
C0299: ; editline_11()
; key = 2
; 1506: byte editstr[80]
; editstr = 4
; 1507: word undoline
; undoline = 84
; 1508:
; 1509: if (editkey_11(key))
JSR INTERP
DB $58,$56,$01 ; ENTER 86,1
DB $66,$02 ; LLW 2
DB $54,<C0292,>C0292 ; CALL C0292
DB $4C,<C0301,>C0301 ; SKPFLS C0301
; 1510: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1511: memset($A0A0, @editstr, 80)
DB $2C,$A0,$A0 ; CW 41120
DB $28,$04 ; LLA 4
DB $2A,$50 ; CB 80
DB $54,<C0011,>C0011 ; CALL C0011
; 1512: strcpy_20(strlinbuf:[cursrow], @editstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $28,$04 ; LLA 4
DB $54,<C0047,>C0047 ; CALL C0047
; 1513: undoline = strlinbuf:[cursrow]
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $62 ; LW
DB $76,$54 ; SLW 84
; 1514: strlinbuf:[cursrow] = @editstr
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $28,$04 ; LLA 4
DB $72 ; SW
; 1515: repeat
C0304:
; 1516: if key >= keyspace
DB $66,$02 ; LLW 2
DB $2A,$A0 ; CB 160
DB $48 ; ISGE
DB $4C,<C0305,>C0305 ; SKPFLS C0305
; 1517: if key == keydelete
DB $66,$02 ; LLW 2
DB $2A,$FF ; CB 255
DB $40 ; ISEQ
DB $4C,<C0307,>C0307 ; SKPFLS C0307
; 1518: if curscol > 0
DB $68,<D0197,>D0197 ; LAB D0197
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0309,>C0309 ; SKPFLS C0309
; 1519: if curscol <= editstr
DB $68,<D0197,>D0197 ; LAB D0197
DB $64,$04 ; LLB 4
DB $4A ; ISLE
DB $4C,<C0311,>C0311 ; SKPFLS C0311
; 1520: memcpy(@editstr[curscol + 1], @editstr[curscol], editstr - curscol)
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $02 ; IDXB
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $02 ; IDXB
DB $64,$04 ; LLB 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $04 ; SUB
DB $54,<C0013,>C0013 ; CALL C0013
; 1521: editstr = editstr - 1
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$04 ; SLB 4
; 1522: fin
C0311:
C0312:
; 1523: curscol = curscol - 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0197,>D0197 ; SAB D0197
; 1524: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1525: if cursx > 0
DB $68,<D0194,>D0194 ; LAB D0194
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0313,>C0313 ; SKPFLS C0313
; 1526: cursx = cursx - 1
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0194,>D0194 ; SAB D0194
; 1527: drawrow_30(cursy, scrnleft, @editstr)
DB $68,<D0195,>D0195 ; LAB D0195
DB $68,<D0196,>D0196 ; LAB D0196
DB $28,$04 ; LLA 4
DB $54,<C0159,>C0159 ; CALL C0159
; 1528: else
DB $50,<C0314,>C0314 ; SKIP C0314
C0313:
; 1529: scrnleft = scrnleft - 1
DB $68,<D0196,>D0196 ; LAB D0196
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0196,>D0196 ; SAB D0196
; 1530: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1531: fin
C0314:
; 1532: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1533: fin
C0309:
C0310:
; 1534: elsif curscol < maxlnlen
DB $50,<C0308,>C0308 ; SKIP C0308
C0307:
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$4F ; CB 79
DB $46 ; ISLT
DB $4C,<C0315,>C0315 ; SKPFLS C0315
; 1535: curscol = curscol + 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0197,>D0197 ; SAB D0197
; 1536: cursx = cursx + 1
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0194,>D0194 ; SAB D0194
; 1537: if flags & insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0316,>C0316 ; SKPFLS C0316
; 1538: if editstr < maxlnlen or editstr.maxlnlen == $A0
DB $64,$04 ; LLB 4
DB $2A,$4F ; CB 79
DB $46 ; ISLT
DB $28,$53 ; LLA 83
DB $60 ; LB
DB $2A,$A0 ; CB 160
DB $40 ; ISEQ
DB $22 ; LOR
DB $4C,<C0318,>C0318 ; SKPFLS C0318
; 1539: editstr = editstr + 1
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$04 ; SLB 4
; 1540: if curscol >= editstr
DB $68,<D0197,>D0197 ; LAB D0197
DB $64,$04 ; LLB 4
DB $48 ; ISGE
DB $4C,<C0320,>C0320 ; SKPFLS C0320
; 1541: editstr = curscol
DB $68,<D0197,>D0197 ; LAB D0197
DB $74,$04 ; SLB 4
; 1542: else
DB $50,<C0321,>C0321 ; SKIP C0321
C0320:
; 1543: memcpy(@editstr[curscol], @editstr[curscol + 1], editstr - curscol)
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $02 ; IDXB
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $02 ; IDXB
DB $64,$04 ; LLB 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $04 ; SUB
DB $54,<C0013,>C0013 ; CALL C0013
; 1544: fin
C0321:
; 1545: else
DB $50,<C0319,>C0319 ; SKIP C0319
C0318:
; 1546: curscol = curscol - 1
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0197,>D0197 ; SAB D0197
; 1547: cursx = cursx - 1
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D0194,>D0194 ; SAB D0194
; 1548: key = editstr[curscol]
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $02 ; IDXB
DB $60 ; LB
DB $76,$02 ; SLW 2
; 1549: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1550: fin
C0319:
; 1551: else
DB $50,<C0317,>C0317 ; SKIP C0317
C0316:
; 1552: if curscol > editstr
DB $68,<D0197,>D0197 ; LAB D0197
DB $64,$04 ; LLB 4
DB $44 ; ISGT
DB $4C,<C0322,>C0322 ; SKPFLS C0322
; 1553: editstr = curscol
DB $68,<D0197,>D0197 ; LAB D0197
DB $74,$04 ; SLB 4
; 1554: fin
C0322:
C0323:
; 1555: fin
C0317:
; 1556: editstr[curscol] = caseconv_11(key)
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $02 ; IDXB
DB $66,$02 ; LLW 2
DB $54,<C0087,>C0087 ; CALL C0087
DB $70 ; SB
; 1557: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1558: if cursx <= 39
DB $68,<D0194,>D0194 ; LAB D0194
DB $2A,$27 ; CB 39
DB $4A ; ISLE
DB $4C,<C0324,>C0324 ; SKPFLS C0324
; 1559: drawrow_30(cursy, scrnleft, @editstr)
DB $68,<D0195,>D0195 ; LAB D0195
DB $68,<D0196,>D0196 ; LAB D0196
DB $28,$04 ; LLA 4
DB $54,<C0159,>C0159 ; CALL C0159
; 1560: else
DB $50,<C0325,>C0325 ; SKIP C0325
C0324:
; 1561: scrnleft = scrnleft + 1
DB $68,<D0196,>D0196 ; LAB D0196
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0196,>D0196 ; SAB D0196
; 1562: cursx = 39
DB $2A,$27 ; CB 39
DB $78,<D0194,>D0194 ; SAB D0194
; 1563: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 1564: fin
C0325:
; 1565: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1566: else
DB $50,<C0308,>C0308 ; SKIP C0308
C0315:
; 1567: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1568: fin
C0308:
; 1569: elsif key == keyctrld
DB $50,<C0306,>C0306 ; SKIP C0306
C0305:
DB $66,$02 ; LLW 2
DB $2A,$84 ; CB 132
DB $40 ; ISEQ
DB $4C,<C0326,>C0326 ; SKPFLS C0326
; 1570: if curscol < editstr
DB $68,<D0197,>D0197 ; LAB D0197
DB $64,$04 ; LLB 4
DB $46 ; ISLT
DB $4C,<C0327,>C0327 ; SKPFLS C0327
; 1571: memcpy(@editstr[curscol + 2], @editstr[curscol + 1], editstr - curscol)
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $02 ; IDXB
DB $28,$04 ; LLA 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $02 ; IDXB
DB $64,$04 ; LLB 4
DB $68,<D0197,>D0197 ; LAB D0197
DB $04 ; SUB
DB $54,<C0013,>C0013 ; CALL C0013
; 1572: editstr = editstr - 1
DB $64,$04 ; LLB 4
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$04 ; SLB 4
; 1573: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1574: drawrow_30(cursy, scrnleft, @editstr)
DB $68,<D0195,>D0195 ; LAB D0195
DB $68,<D0196,>D0196 ; LAB D0196
DB $28,$04 ; LLA 4
DB $54,<C0159,>C0159 ; CALL C0159
; 1575: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1576: fin
C0327:
C0328:
; 1577: elsif key == keyctrlr
DB $50,<C0306,>C0306 ; SKIP C0306
C0326:
DB $66,$02 ; LLW 2
DB $2A,$92 ; CB 146
DB $40 ; ISEQ
DB $4C,<C0329,>C0329 ; SKPFLS C0329
; 1578: strcpy_20(undoline, @editstr)
DB $66,$54 ; LLW 84
DB $28,$04 ; LLA 4
DB $54,<C0047,>C0047 ; CALL C0047
; 1579: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1580: drawrow_30(cursy, scrnleft, @editstr)
DB $68,<D0195,>D0195 ; LAB D0195
DB $68,<D0196,>D0196 ; LAB D0196
DB $28,$04 ; LLA 4
DB $54,<C0159,>C0159 ; CALL C0159
; 1581: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 1582: fin
C0329:
C0306:
; 1583: key = keyin_01()
DB $26,<D0210,>D0210 ; LA D0210
DB $62 ; LW
DB $34 ; PUSH
DB $36 ; PULL
DB $56 ; ICAL
DB $76,$02 ; SLW 2
; 1584: until !editkey_11(key)
DB $66,$02 ; LLW 2
DB $54,<C0292,>C0292 ; CALL C0292
DB $20 ; NOT
DB $4C,<C0304,>C0304 ; SKPFLS C0304
C0303:
; 1585: if editstr
DB $64,$04 ; LLB 4
DB $4C,<C0330,>C0330 ; SKPFLS C0330
; 1586: strlinbuf:[cursrow] = newstr_11(@editstr)
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $28,$04 ; LLA 4
DB $54,<C0077,>C0077 ; CALL C0077
DB $72 ; SW
; 1587: else
DB $50,<C0331,>C0331 ; SKIP C0331
C0330:
; 1588: strlinbuf:[cursrow] = @nullstr
DB $2C,$00,$10 ; CW 4096
DB $6A,<D0200,>D0200 ; LAW D0200
DB $1E ; IDXW
DB $26,<D0048,>D0048 ; LA D0048
DB $72 ; SW
; 1589: fin
C0331:
; 1590: freestr_10(undoline)
DB $66,$54 ; LLW 84
DB $54,<C0073,>C0073 ; CALL C0073
; 1591: fin
C0301:
C0302:
; 1592: return key
DB $66,$02 ; LLW 2
DB $5A ; LEAVE
; 1593: end
; 1594: def editmode
C0332: ; editmode()
; 1595: repeat
JSR INTERP
C0335:
; 1596: when editline_11(keyin_01())
DB $26,<D0210,>D0210 ; LA D0210
DB $62 ; LW
DB $34 ; PUSH
DB $36 ; PULL
DB $56 ; ICAL
DB $54,<C0299,>C0299 ; CALL C0299
; 1597: is keyarrowup
DB $2A,$8B ; CB 139
DB $3E,<C0337,>C0337 ; SKPNE C0337
; 1598: cursup()
DB $54,<C0196,>C0196 ; CALL C0196
; 1599: is keyarrowdown
DB $50,<C0336,>C0336 ; SKIP C0336
C0337:
DB $2A,$8A ; CB 138
DB $3E,<C0338,>C0338 ; SKPNE C0338
; 1600: cursdown()
DB $54,<C0206,>C0206 ; CALL C0206
; 1601: is keyarrowleft
DB $50,<C0336,>C0336 ; SKIP C0336
C0338:
DB $2A,$88 ; CB 136
DB $3E,<C0339,>C0339 ; SKPNE C0339
; 1602: cursleft()
DB $54,<C0216,>C0216 ; CALL C0216
; 1603: is keyarrowright
DB $50,<C0336,>C0336 ; SKIP C0336
C0339:
DB $2A,$95 ; CB 149
DB $3E,<C0340,>C0340 ; SKPNE C0340
; 1604: cursright()
DB $54,<C0226,>C0226 ; CALL C0226
; 1605: is keyctrlw
DB $50,<C0336,>C0336 ; SKIP C0336
C0340:
DB $2A,$97 ; CB 151
DB $3E,<C0341,>C0341 ; SKPNE C0341
; 1606: pgup()
DB $54,<C0202,>C0202 ; CALL C0202
; 1607: is keyctrlz
DB $50,<C0336,>C0336 ; SKIP C0336
C0341:
DB $2A,$9A ; CB 154
DB $3E,<C0342,>C0342 ; SKPNE C0342
; 1608: pgdown()
DB $54,<C0212,>C0212 ; CALL C0212
; 1609: is keyctrla
DB $50,<C0336,>C0336 ; SKIP C0336
C0342:
DB $2A,$81 ; CB 129
DB $3E,<C0343,>C0343 ; SKPNE C0343
; 1610: pgleft()
DB $54,<C0222,>C0222 ; CALL C0222
; 1611: is keyctrls
DB $50,<C0336,>C0336 ; SKIP C0336
C0343:
DB $2A,$93 ; CB 147
DB $3E,<C0344,>C0344 ; SKPNE C0344
; 1612: pgright()
DB $54,<C0232,>C0232 ; CALL C0232
; 1613: is keyctrlq
DB $50,<C0336,>C0336 ; SKIP C0336
C0344:
DB $2A,$91 ; CB 145
DB $3E,<C0345,>C0345 ; SKPNE C0345
; 1614: curshome()
DB $54,<C0190,>C0190 ; CALL C0190
; 1615: is keyctrle
DB $50,<C0336,>C0336 ; SKIP C0336
C0345:
DB $2A,$85 ; CB 133
DB $3E,<C0346,>C0346 ; SKPNE C0346
; 1616: cursend()
DB $54,<C0192,>C0192 ; CALL C0192
; 1617: is keyctrlx
DB $50,<C0336,>C0336 ; SKIP C0336
C0346:
DB $2A,$98 ; CB 152
DB $3E,<C0347,>C0347 ; SKPNE C0347
; 1618: cutline()
DB $54,<C0268,>C0268 ; CALL C0268
; 1619: is keyctrlv
DB $50,<C0336,>C0336 ; SKIP C0336
C0347:
DB $2A,$96 ; CB 150
DB $3E,<C0348,>C0348 ; SKPNE C0348
; 1620: pasteline()
DB $54,<C0274,>C0274 ; CALL C0274
; 1621: is keyctrlo
DB $50,<C0336,>C0336 ; SKIP C0336
C0348:
DB $2A,$8F ; CB 143
DB $3E,<C0349,>C0349 ; SKPNE C0349
; 1622: drop openline_11(cursrow)
DB $6A,<D0200,>D0200 ; LAW D0200
DB $54,<C0264,>C0264 ; CALL C0264
DB $30 ; DROP
; 1623: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1624: is keyenter
DB $50,<C0336,>C0336 ; SKIP C0336
C0349:
DB $2A,$8D ; CB 141
DB $3E,<C0350,>C0350 ; SKPNE C0350
; 1625: if flags & insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0351,>C0351 ; SKPFLS C0351
; 1626: splitline()
DB $54,<C0284,>C0284 ; CALL C0284
; 1627: else
DB $50,<C0352,>C0352 ; SKIP C0352
C0351:
; 1628: drop openline_11(cursrow + 1)
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $54,<C0264,>C0264 ; CALL C0264
DB $30 ; DROP
; 1629: cursdown()
DB $54,<C0206,>C0206 ; CALL C0206
; 1630: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1631: fin
C0352:
; 1632: is keyctrlt
DB $50,<C0336,>C0336 ; SKIP C0336
C0350:
DB $2A,$94 ; CB 148
DB $3E,<C0353,>C0353 ; SKPNE C0353
; 1633: joinline()
DB $54,<C0278,>C0278 ; CALL C0278
; 1634: is keyctrli
DB $50,<C0336,>C0336 ; SKIP C0336
C0353:
DB $2A,$89 ; CB 137
DB $3E,<C0354,>C0354 ; SKPNE C0354
; 1635: if flags & insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0355,>C0355 ; SKPFLS C0355
; 1636: flags = flags & #insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2C,$FD,$FF ; CW -3
DB $14 ; BAND
DB $78,<D0192,>D0192 ; SAB D0192
; 1637: curschr = ' '
DB $2A,$20 ; CB 32
DB $78,<D0199,>D0199 ; SAB D0199
; 1638: else
DB $50,<C0356,>C0356 ; SKIP C0356
C0355:
; 1639: flags = flags ? insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$02 ; CB 2
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1640: curschr = '+'
DB $2A,$2B ; CB 43
DB $78,<D0199,>D0199 ; SAB D0199
; 1641: fin
C0356:
; 1642: is keyctrlc
DB $50,<C0336,>C0336 ; SKIP C0336
C0354:
DB $2A,$83 ; CB 131
DB $3E,<C0357,>C0357 ; SKPNE C0357
; 1643: if flags & uppercase
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$08 ; CB 8
DB $14 ; BAND
DB $4C,<C0358,>C0358 ; SKPFLS C0358
; 1644: txtlower()
DB $54,<C0109,>C0109 ; CALL C0109
; 1645: else
DB $50,<C0359,>C0359 ; SKIP C0359
C0358:
; 1646: txtupper()
DB $54,<C0105,>C0105 ; CALL C0105
; 1647: fin
C0359:
; 1648: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1649: is keyescape
DB $50,<C0336,>C0336 ; SKIP C0336
C0357:
DB $2A,$9B ; CB 155
DB $3E,<C0360,>C0360 ; SKPNE C0360
; 1650: cursoff()
DB $54,<C0173,>C0173 ; CALL C0173
; 1651: cmdmode()
DB $54,<C0000,>C0000 ; CALL C0000
; 1652: redraw()
DB $54,<C0188,>C0188 ; CALL C0188
; 1653: wend
DB $50,<C0336,>C0336 ; SKIP C0336
C0360:
C0336:
DB $30 ; DROP
; 1654: until 0
DB $00 ; ZERO
DB $4C,<C0335,>C0335 ; SKPFLS C0335
C0334:
; 1655: end
DB $5C ; RET
; 1656: ;
; 1657: ; Command mode
; 1658: ;
; 1659: def prfiles_11(optpath)
C0362: ; prfiles_11()
; optpath = 2
; 1660: byte path[64]
; path = 4
; 1661: byte refnum
; refnum = 68
; 1662: byte firstblk
; firstblk = 69
; 1663: byte entrylen, entriesblk
; entrylen = 70
; entriesblk = 71
; 1664: byte i, type, len
; i = 72
; type = 73
; len = 74
; 1665: word entry, filecnt
; entry = 75
; filecnt = 77
; 1666:
; 1667: if ^optpath
JSR INTERP
DB $58,$4F,$01 ; ENTER 79,1
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $4C,<C0364,>C0364 ; SKPFLS C0364
; 1668: strcpy_20(optpath, @path)
DB $66,$02 ; LLW 2
DB $28,$04 ; LLA 4
DB $54,<C0047,>C0047 ; CALL C0047
; 1669: else
DB $50,<C0365,>C0365 ; SKIP C0365
C0364:
; 1670: drop getpfx_11(@path)
DB $28,$04 ; LLA 4
DB $54,<C0025,>C0025 ; CALL C0025
DB $30 ; DROP
; 1671: prstr(@path)
DB $28,$04 ; LLA 4
DB $54,<C0019,>C0019 ; CALL C0019
; 1672: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1673: fin
C0365:
; 1674: refnum = open_21(@path, iobuffer);
DB $28,$04 ; LLA 4
DB $2C,$00,$08 ; CW 2048
DB $54,<C0029,>C0029 ; CALL C0029
DB $74,$44 ; SLB 68
; 1675: if perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $4C,<C0366,>C0366 ; SKPFLS C0366
; 1676: return perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $5A ; LEAVE
; 1677: fin
C0366:
C0367:
; 1678: firstblk = 1
DB $2A,$01 ; CB 1
DB $74,$45 ; SLB 69
; 1679: repeat
C0369:
; 1680: if read_31(refnum, databuff, 512) == 512
DB $64,$44 ; LLB 68
DB $2C,$00,$0C ; CW 3072
DB $2C,$00,$02 ; CW 512
DB $54,<C0033,>C0033 ; CALL C0033
DB $2C,$00,$02 ; CW 512
DB $40 ; ISEQ
DB $4C,<C0370,>C0370 ; SKPFLS C0370
; 1681: entry = databuff + 4
DB $2C,$00,$0C ; CW 3072
DB $2A,$04 ; CB 4
DB $02 ; ADD
DB $76,$4B ; SLW 75
; 1682: if firstblk
DB $64,$45 ; LLB 69
DB $4C,<C0372,>C0372 ; SKPFLS C0372
; 1683: entrylen = databuff.$23
DB $2C,$23,$0C ; CW 3107
DB $60 ; LB
DB $74,$46 ; SLB 70
; 1684: entriesblk = databuff.$24
DB $2C,$24,$0C ; CW 3108
DB $60 ; LB
DB $74,$47 ; SLB 71
; 1685: filecnt = databuff:$25
DB $2C,$25,$0C ; CW 3109
DB $62 ; LW
DB $76,$4D ; SLW 77
; 1686: entry = entry + entrylen
DB $66,$4B ; LLW 75
DB $64,$46 ; LLB 70
DB $02 ; ADD
DB $76,$4B ; SLW 75
; 1687: fin
C0372:
C0373:
; 1688: for i = firstblk to entriesblk
DB $64,$45 ; LLB 69
C0375:
DB $6C,$48 ; DLB 72
DB $64,$47 ; LLB 71
DB $3A,<C0374,>C0374 ; SKPGT C0374
DB $0C ; INCR
; 1689: type = ^entry
DB $66,$4B ; LLW 75
DB $60 ; LB
DB $74,$49 ; SLB 73
; 1690: if type <> 0
DB $64,$49 ; LLB 73
DB $00 ; ZERO
DB $42 ; ISNE
DB $4C,<C0376,>C0376 ; SKPFLS C0376
; 1691: len = type & $0F
DB $64,$49 ; LLB 73
DB $2A,$0F ; CB 15
DB $14 ; BAND
DB $74,$4A ; SLB 74
; 1692: ^entry = len
DB $66,$4B ; LLW 75
DB $64,$4A ; LLB 74
DB $70 ; SB
; 1693: prstr(entry)
DB $66,$4B ; LLW 75
DB $54,<C0019,>C0019 ; CALL C0019
; 1694: if type & $F0 == $D0 ; Is it a directory?
DB $64,$49 ; LLB 73
DB $2A,$F0 ; CB 240
DB $14 ; BAND
DB $2A,$D0 ; CB 208
DB $40 ; ISEQ
DB $4C,<C0378,>C0378 ; SKPFLS C0378
; 1695: cout('/')
DB $2A,$2F ; CB 47
DB $54,<C0015,>C0015 ; CALL C0015
; 1696: len = len + 1
DB $64,$4A ; LLB 74
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$4A ; SLB 74
; 1697: fin
C0378:
C0379:
; 1698: for len = 20 - len downto 1
DB $2A,$14 ; CB 20
DB $64,$4A ; LLB 74
DB $04 ; SUB
C0381:
DB $6C,$4A ; DLB 74
DB $2A,$01 ; CB 1
DB $38,<C0380,>C0380 ; SKPLT C0380
DB $0E ; DECR
; 1699: cout(' ')
DB $2A,$20 ; CB 32
DB $54,<C0015,>C0015 ; CALL C0015
; 1700: next
DB $50,<C0381,>C0381 ; SKIP C0381
C0380:
DB $30 ; DROP
; 1701: filecnt = filecnt - 1
DB $66,$4D ; LLW 77
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $76,$4D ; SLW 77
; 1702: fin
C0376:
C0377:
; 1703: entry = entry + entrylen
DB $66,$4B ; LLW 75
DB $64,$46 ; LLB 70
DB $02 ; ADD
DB $76,$4B ; SLW 75
; 1704: next
DB $50,<C0375,>C0375 ; SKIP C0375
C0374:
DB $30 ; DROP
; 1705: firstblk = 0
DB $00 ; ZERO
DB $74,$45 ; SLB 69
; 1706: else
DB $50,<C0371,>C0371 ; SKIP C0371
C0370:
; 1707: filecnt = 0
DB $00 ; ZERO
DB $76,$4D ; SLW 77
; 1708: fin
C0371:
; 1709: until filecnt == 0
DB $66,$4D ; LLW 77
DB $00 ; ZERO
DB $40 ; ISEQ
DB $4C,<C0369,>C0369 ; SKPFLS C0369
C0368:
; 1710: drop close_11(refnum)
DB $64,$44 ; LLB 68
DB $54,<C0031,>C0031 ; CALL C0031
DB $30 ; DROP
; 1711: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1712: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 1713: end
; 1714: def striplead_20(strptr, chr)
C0382: ; striplead_20()
; strptr = 2
; chr = 4
; 1715: while ^strptr and ^(strptr + 1) == chr
JSR INTERP
DB $58,$06,$02 ; ENTER 6,2
C0384:
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $66,$02 ; LLW 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $66,$04 ; LLW 4
DB $40 ; ISEQ
DB $24 ; LAND
DB $4C,<C0385,>C0385 ; SKPFLS C0385
; 1716: memcpy(strptr + 2, strptr + 1, ^strptr)
DB $66,$02 ; LLW 2
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $66,$02 ; LLW 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $54,<C0013,>C0013 ; CALL C0013
; 1717: ^strptr = ^strptr - 1
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $70 ; SB
; 1718: loop
DB $50,<C0384,>C0384 ; SKIP C0384
C0385:
; 1719: end
DB $5A ; LEAVE
; 1720: def parsecmd_11(strptr)
C0386: ; parsecmd_11()
; strptr = 2
; 1721: byte cmd
; cmd = 4
; 1722:
; 1723: cmd = 0
JSR INTERP
DB $58,$05,$01 ; ENTER 5,1
DB $00 ; ZERO
DB $74,$04 ; SLB 4
; 1724: striplead_20(strptr, ' ')
DB $66,$02 ; LLW 2
DB $2A,$20 ; CB 32
DB $54,<C0382,>C0382 ; CALL C0382
; 1725: if ^strptr
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $4C,<C0388,>C0388 ; SKPFLS C0388
; 1726: cmd = ^(strptr + 1)
DB $66,$02 ; LLW 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $74,$04 ; SLB 4
; 1727: memcpy(strptr + 2, strptr + 1, ^strptr)
DB $66,$02 ; LLW 2
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $66,$02 ; LLW 2
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $54,<C0013,>C0013 ; CALL C0013
; 1728: ^strptr = ^strptr - 1
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $70 ; SB
; 1729: fin
C0388:
C0389:
; 1730: if ^strptr
DB $66,$02 ; LLW 2
DB $60 ; LB
DB $4C,<C0390,>C0390 ; SKPFLS C0390
; 1731: striplead_20(strptr, ' ')
DB $66,$02 ; LLW 2
DB $2A,$20 ; CB 32
DB $54,<C0382,>C0382 ; CALL C0382
; 1732: fin
C0390:
C0391:
; 1733: return cmd
DB $64,$04 ; LLB 4
DB $5A ; LEAVE
; 1734: end
; 1735: def chkchng_01
C0392: ; chkchng_01()
; 1736: if flags & changed
JSR INTERP
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0394,>C0394 ; SKPFLS C0394
; 1737: prstr(@losechng)
DB $26,<D0104,>D0104 ; LA D0104
DB $54,<C0019,>C0019 ; CALL C0019
; 1738: if toupper_11(keyin_01()) == 'N'
DB $26,<D0210,>D0210 ; LA D0210
DB $62 ; LW
DB $34 ; PUSH
DB $36 ; PULL
DB $56 ; ICAL
DB $54,<C0127,>C0127 ; CALL C0127
DB $2A,$4E ; CB 78
DB $40 ; ISEQ
DB $4C,<C0396,>C0396 ; SKPFLS C0396
; 1739: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1740: return 0
DB $00 ; ZERO
DB $5C ; RET
; 1741: fin
C0396:
C0397:
; 1742: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1743: fin
C0394:
C0395:
; 1744: return 1
DB $2A,$01 ; CB 1
DB $5C ; RET
; 1745: end
; 1746: def exec
C0398: ; exec()
; 1747: when execentry()
JSR INTERP
DB $54,<C0005,>C0005 ; CALL C0005
; 1748: is 1
DB $2A,$01 ; CB 1
DB $3E,<C0401,>C0401 ; SKPNE C0401
; 1749: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1750: prstr(@brkmsg)
DB $26,<D0956,>D0956 ; LA D0956
DB $54,<C0019,>C0019 ; CALL C0019
; 1751: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1752: is 2
DB $50,<C0400,>C0400 ; SKIP C0400
C0401:
DB $2A,$02 ; CB 2
DB $3E,<C0402,>C0402 ; SKPNE C0402
; 1753: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1754: prstr(@stkovflwmsg)
DB $26,<D0969,>D0969 ; LA D0969
DB $54,<C0019,>C0019 ; CALL C0019
; 1755: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1756: wend
DB $50,<C0400,>C0400 ; SKIP C0400
C0402:
C0400:
DB $30 ; DROP
; 1757: ;
; 1758: ; Close all files
; 1759: ;
; 1760: ^$BFD8 = 0
DB $2C,$D8,$BF ; CW 49112
DB $00 ; ZERO
DB $70 ; SB
; 1761: drop close_11(0)
DB $00 ; ZERO
DB $54,<C0031,>C0031 ; CALL C0031
DB $30 ; DROP
; 1762: end
DB $5C ; RET
; 1763: def quit
C0404: ; quit()
; 1764: if chkchng_01()
JSR INTERP
DB $54,<C0392,>C0392 ; CALL C0392
DB $4C,<C0406,>C0406 ; SKPFLS C0406
; 1765: exit
DB $54,<C0023,>C0023 ; CALL C0023
; 1766: fin
C0406:
C0407:
; 1767: end
DB $5C ; RET
; 1768: def cmdmode
C0000: ; cmdmode()
; 1769: byte slot
; slot = 2
; 1770: word cmdptr
; cmdptr = 3
; 1771:
; 1772: clrscrn();
JSR INTERP
DB $58,$05,$00 ; ENTER 5,0
DB $54,<C0157,>C0157 ; CALL C0157
; 1773: prstr(@version)
DB $26,<D0049,>D0049 ; LA D0049
DB $54,<C0019,>C0019 ; CALL C0019
; 1774: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1775: while 1
C0409:
DB $2A,$01 ; CB 1
DB $4C,<C0410,>C0410 ; SKPFLS C0410
; 1776: prstr(@txtfile)
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0019,>C0019 ; CALL C0019
; 1777: cmdptr = rdstr($BA)
DB $2A,$BA ; CB 186
DB $54,<C0021,>C0021 ; CALL C0021
DB $76,$03 ; SLW 3
; 1778: when toupper_11(parsecmd_11(cmdptr))
DB $66,$03 ; LLW 3
DB $54,<C0386,>C0386 ; CALL C0386
DB $54,<C0127,>C0127 ; CALL C0127
; 1779: is 'A'
DB $2A,$41 ; CB 65
DB $3E,<C0412,>C0412 ; SKPNE C0412
; 1780: readtxt_10(cmdptr)
DB $66,$03 ; LLW 3
DB $54,<C0135,>C0135 ; CALL C0135
; 1781: flags = flags ? changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 1782: is 'R'
DB $50,<C0411,>C0411 ; SKIP C0411
C0412:
DB $2A,$52 ; CB 82
DB $3E,<C0413,>C0413 ; SKPNE C0413
; 1783: if chkchng_01()
DB $54,<C0392,>C0392 ; CALL C0392
DB $4C,<C0414,>C0414 ; SKPFLS C0414
; 1784: inittxtbuf()
DB $54,<C0085,>C0085 ; CALL C0085
; 1785: strcpy_20(cmdptr, @txtfile)
DB $66,$03 ; LLW 3
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0047,>C0047 ; CALL C0047
; 1786: readtxt_10(@txtfile)
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0135,>C0135 ; CALL C0135
; 1787: entrypoint = 0
DB $00 ; ZERO
DB $7A,<D0492,>D0492 ; SAW D0492
; 1788: flags = flags & #changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2C,$FE,$FF ; CW -2
DB $14 ; BAND
DB $78,<D0192,>D0192 ; SAB D0192
; 1789: fin
C0414:
C0415:
; 1790: is 'W'
DB $50,<C0411,>C0411 ; SKIP C0411
C0413:
DB $2A,$57 ; CB 87
DB $3E,<C0416,>C0416 ; SKPNE C0416
; 1791: if ^cmdptr
DB $66,$03 ; LLW 3
DB $60 ; LB
DB $4C,<C0417,>C0417 ; SKPFLS C0417
; 1792: strcpy_20(cmdptr, @txtfile)
DB $66,$03 ; LLW 3
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0047,>C0047 ; CALL C0047
; 1793: fin
C0417:
C0418:
; 1794: writetxt_10(@txtfile)
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0149,>C0149 ; CALL C0149
; 1795: if flags & changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0419,>C0419 ; SKPFLS C0419
; 1796: entrypoint = 0
DB $00 ; ZERO
DB $7A,<D0492,>D0492 ; SAW D0492
; 1797: fin
C0419:
C0420:
; 1798: flags = flags & #changed
DB $68,<D0192,>D0192 ; LAB D0192
DB $2C,$FE,$FF ; CW -2
DB $14 ; BAND
DB $78,<D0192,>D0192 ; SAB D0192
; 1799: is 'Q'
DB $50,<C0411,>C0411 ; SKIP C0411
C0416:
DB $2A,$51 ; CB 81
DB $3E,<C0421,>C0421 ; SKPNE C0421
; 1800: quit()
DB $54,<C0404,>C0404 ; CALL C0404
; 1801: is 'C'
DB $50,<C0411,>C0411 ; SKIP C0411
C0421:
DB $2A,$43 ; CB 67
DB $3E,<C0422,>C0422 ; SKPNE C0422
; 1802: drop prfiles_11(cmdptr)
DB $66,$03 ; LLW 3
DB $54,<C0362,>C0362 ; CALL C0362
DB $30 ; DROP
; 1803: is 'P'
DB $50,<C0411,>C0411 ; SKIP C0411
C0422:
DB $2A,$50 ; CB 80
DB $3E,<C0423,>C0423 ; SKPNE C0423
; 1804: drop setpfx_11(cmdptr)
DB $66,$03 ; LLW 3
DB $54,<C0027,>C0027 ; CALL C0027
DB $30 ; DROP
; 1805: is 'H'
DB $50,<C0411,>C0411 ; SKIP C0411
C0423:
DB $2A,$48 ; CB 72
DB $3E,<C0424,>C0424 ; SKPNE C0424
; 1806: if ^cmdptr
DB $66,$03 ; LLW 3
DB $60 ; LB
DB $4C,<C0425,>C0425 ; SKPFLS C0425
; 1807: slot = cmdptr.1 - '0'
DB $28,$04 ; LLA 4
DB $60 ; LB
DB $2A,$30 ; CB 48
DB $04 ; SUB
DB $74,$02 ; SLB 2
; 1808: else
DB $50,<C0426,>C0426 ; SKIP C0426
C0425:
; 1809: slot = 1
DB $2A,$01 ; CB 1
DB $74,$02 ; SLB 2
; 1810: fin
C0426:
; 1811: printtxt_10(slot)
DB $64,$02 ; LLB 2
DB $54,<C0260,>C0260 ; CALL C0260
; 1812: is 'E'
DB $50,<C0411,>C0411 ; SKIP C0411
C0424:
DB $2A,$45 ; CB 69
DB $3E,<C0427,>C0427 ; SKPNE C0427
; 1813: return
DB $30 ; DROP
DB $5A ; LEAVE
; 1814: is 0
DB $50,<C0411,>C0411 ; SKIP C0411
C0427:
DB $00 ; ZERO
DB $3E,<C0428,>C0428 ; SKPNE C0428
; 1815: return
DB $30 ; DROP
DB $5A ; LEAVE
; 1816: is 'N'
DB $50,<C0411,>C0411 ; SKIP C0411
C0428:
DB $2A,$4E ; CB 78
DB $3E,<C0429,>C0429 ; SKPNE C0429
; 1817: if chkchng_01()
DB $54,<C0392,>C0392 ; CALL C0392
DB $4C,<C0430,>C0430 ; SKPFLS C0430
; 1818: inittxtbuf()
DB $54,<C0085,>C0085 ; CALL C0085
; 1819: numlines = 1
DB $2A,$01 ; CB 1
DB $7A,<D0206,>D0206 ; SAW D0206
; 1820: strcpy_20(@untitled, @txtfile)
DB $26,<D0132,>D0132 ; LA D0132
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0047,>C0047 ; CALL C0047
; 1821: fin
C0430:
C0431:
; 1822: is 'X'
DB $50,<C0411,>C0411 ; SKIP C0411
C0429:
DB $2A,$58 ; CB 88
DB $3E,<C0432,>C0432 ; SKPNE C0432
; 1823: if flags & changed or !entrypoint
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $6A,<D0492,>D0492 ; LAW D0492
DB $20 ; NOT
DB $22 ; LOR
DB $4C,<C0433,>C0433 ; SKPFLS C0433
; 1824: drop parse_module_01()
DB $54,<C0002,>C0002 ; CALL C0002
DB $30 ; DROP
; 1825: if parserr
DB $68,<D0498,>D0498 ; LAB D0498
DB $4C,<C0435,>C0435 ; SKPFLS C0435
; 1826: bell()
DB $54,<C0045,>C0045 ; CALL C0045
; 1827: cursrow = parserrln
DB $6A,<D0503,>D0503 ; LAW D0503
DB $7A,<D0200,>D0200 ; SAW D0200
; 1828: scrntop = cursrow & $FFF8
DB $6A,<D0200,>D0200 ; LAW D0200
DB $2C,$F8,$FF ; CW 65528
DB $14 ; BAND
DB $7A,<D0202,>D0202 ; SAW D0202
; 1829: cursy = cursrow - scrntop
DB $6A,<D0200,>D0200 ; LAW D0200
DB $6A,<D0202,>D0202 ; LAW D0202
DB $04 ; SUB
DB $78,<D0195,>D0195 ; SAB D0195
; 1830: curscol = parserrpos
DB $68,<D0497,>D0497 ; LAB D0497
DB $78,<D0197,>D0197 ; SAB D0197
; 1831: scrnleft = curscol & $FFE0
DB $68,<D0197,>D0197 ; LAB D0197
DB $2C,$E0,$FF ; CW 65504
DB $14 ; BAND
DB $78,<D0196,>D0196 ; SAB D0196
; 1832: cursx = curscol - scrnleft
DB $68,<D0197,>D0197 ; LAB D0197
DB $68,<D0196,>D0196 ; LAB D0196
DB $04 ; SUB
DB $78,<D0194,>D0194 ; SAB D0194
; 1833: else
DB $50,<C0436,>C0436 ; SKIP C0436
C0435:
; 1834: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1835: exec(entrypoint)
DB $6A,<D0492,>D0492 ; LAW D0492
DB $54,<C0398,>C0398 ; CALL C0398
; 1836: fin
C0436:
; 1837: else
DB $50,<C0434,>C0434 ; SKIP C0434
C0433:
; 1838: exec(entrypoint)
DB $6A,<D0492,>D0492 ; LAW D0492
DB $54,<C0398,>C0398 ; CALL C0398
; 1839: fin
C0434:
; 1840: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1841: is 'V'
DB $50,<C0411,>C0411 ; SKIP C0411
C0432:
DB $2A,$56 ; CB 86
DB $3E,<C0437,>C0437 ; SKPNE C0437
; 1842: prstr(@version)
DB $26,<D0049,>D0049 ; LA D0049
DB $54,<C0019,>C0019 ; CALL C0019
; 1843: wend
DB $50,<C0411,>C0411 ; SKIP C0411
C0437:
C0411:
DB $30 ; DROP
; 1844: if perr
DB $68,<D0088,>D0088 ; LAB D0088
DB $4C,<C0439,>C0439 ; SKPFLS C0439
; 1845: prstr(@errorstr)
DB $26,<D0076,>D0076 ; LA D0076
DB $54,<C0019,>C0019 ; CALL C0019
; 1846: drop romcall(perr, 0, 0, 0, $FDDA)
DB $68,<D0088,>D0088 ; LAB D0088
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $2C,$DA,$FD ; CW 64986
DB $54,<C0007,>C0007 ; CALL C0007
DB $30 ; DROP
; 1847: else
DB $50,<C0440,>C0440 ; SKIP C0440
C0439:
; 1848: prstr(@okstr)
DB $26,<D0085,>D0085 ; LA D0085
DB $54,<C0019,>C0019 ; CALL C0019
; 1849: fin
C0440:
; 1850: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1851: loop
DB $50,<C0409,>C0409 ; SKIP C0409
C0410:
; 1852: end
DB $5A ; LEAVE
; 1853:
; 1854: ;=====================================
; 1855: ;
; 1856: ; PLASMA Compiler
; 1857: ;
; 1858: ;=====================================
; 1859:
; 1860: ;
; 1861: ; Error handler
; 1862: ;
; 1863: def parse_err_11(err)
C0441: ; parse_err_11()
; err = 2
; 1864: if !parserr
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $68,<D0498,>D0498 ; LAB D0498
DB $20 ; NOT
DB $4C,<C0443,>C0443 ; SKPFLS C0443
; 1865: parserr = TRUE
DB $2C,$FF,$FF ; CW -1
DB $78,<D0498,>D0498 ; SAB D0498
; 1866: parserrln = lineno - 1
DB $6A,<D0507,>D0507 ; LAW D0507
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0503,>D0503 ; SAW D0503
; 1867: parserrpos = tknptr - inbuff
DB $6A,<D0501,>D0501 ; LAW D0501
DB $2C,$00,$02 ; CW 512
DB $04 ; SUB
DB $78,<D0497,>D0497 ; SAB D0497
; 1868: print_10(lineno)
DB $6A,<D0507,>D0507 ; LAW D0507
DB $54,<C0117,>C0117 ; CALL C0117
; 1869: cout(':')
DB $2A,$3A ; CB 58
DB $54,<C0015,>C0015 ; CALL C0015
; 1870: prstr(err)
DB $66,$02 ; LLW 2
DB $54,<C0019,>C0019 ; CALL C0019
; 1871: crout()
DB $54,<C0043,>C0043 ; CALL C0043
; 1872: fin
C0443:
C0444:
; 1873: return ERR_TKN
DB $00 ; ZERO
DB $5A ; LEAVE
; 1874: end
; 1875: ;
; 1876: ; Emit bytecode
; 1877: ;
; 1878: def ctag_new_01
C0445: ; ctag_new_01()
; 1879: if codetag >= ctag_max
JSR INTERP
DB $6A,<D0488,>D0488 ; LAW D0488
DB $2C,$80,$02 ; CW 640
DB $48 ; ISGE
DB $4C,<C0447,>C0447 ; SKPFLS C0447
; 1880: return parse_err_11(@ctag_full)
DB $26,<D0800,>D0800 ; LA D0800
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 1881: fin
C0447:
C0448:
; 1882: codetag = codetag + 1
DB $6A,<D0488,>D0488 ; LAW D0488
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0488,>D0488 ; SAW D0488
; 1883: ctag_value:[codetag] = 0
DB $2C,$00,$08 ; CW 2048
DB $6A,<D0488,>D0488 ; LAW D0488
DB $1E ; IDXW
DB $00 ; ZERO
DB $72 ; SW
; 1884: ctag_flags.[codetag] = 0
DB $2C,$80,$0D ; CW 3456
DB $6A,<D0488,>D0488 ; LAW D0488
DB $02 ; IDXB
DB $00 ; ZERO
DB $70 ; SB
; 1885: return codetag ? is_ctag
DB $6A,<D0488,>D0488 ; LAW D0488
DB $2C,$00,$80 ; CW 32768
DB $16 ; IOR
DB $5C ; RET
; 1886: end
; 1887: defopt ctag_resolve_21(tag, addr)
C0449: ; ctag_resolve_21()
; tag = 2
; addr = 4
; 1888: word updtptr, nextptr
; updtptr = 6
; nextptr = 8
; 1889:
; 1890: 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
; 1891: if ctag_flags.[tag] & resolved
LDA #$80
STA 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 C0451
:
; 1892: return parse_err_11(@dup_id)
DEX
LDA #<D0538
STA ESTKL,X
LDA #>D0538
STA ESTKH,X
JSR C0441
JMP LEAVE
; 1893: fin
C0451:
C0452:
; 1894: updtptr = ctag_value:[tag]
DEX
LDY #$00
STY ESTKL,X
LDA #$08
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
; 1895: while updtptr
INX
C0453:
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 C0454
:
; 1896: ;
; 1897: ; Update list of addresses needing resolution
; 1898: ;
; 1899: 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
; 1900: *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
; 1901: 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
; 1902: loop
INX
JMP C0453
C0454:
; 1903: ctag_value:[tag] = addr
DEX
LDY #$00
STY ESTKL,X
LDA #$08
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
; 1904: ctag_flags.[tag] = ctag_flags.[tag] ? resolved
DEX
LDA #$80
STA 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
LDA #$80
STA 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
; 1905: return 0
DEX
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 1906: end
; 1907: defopt emit_byte_10(bval)
C0455: ; emit_byte_10()
; bval = 2
; 1908: ^codeptr = bval
LDY #4
LDA #1
JSR ENTER
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR SB
; 1909: codeptr = codeptr + 1
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
STY ESTKH,X
JSR ADD
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 1910: end
INX
JMP LEAVE
; 1911: defopt emit_word_10(wval)
C0457: ; emit_word_10()
; wval = 2
; 1912: *codeptr = wval
LDY #4
LDA #1
JSR ENTER
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR SW
; 1913: codeptr = codeptr + 2
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$02
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 1914: end
INX
JMP LEAVE
; 1915: def emit_fill_10(size)
C0459: ; emit_fill_10()
; size = 2
; 1916: memset(0, codeptr, size)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $00 ; ZERO
DB $6A,<D0490,>D0490 ; LAW D0490
DB $66,$02 ; LLW 2
DB $54,<C0011,>C0011 ; CALL C0011
; 1917: codeptr = codeptr + size
DB $6A,<D0490,>D0490 ; LAW D0490
DB $66,$02 ; LLW 2
DB $02 ; ADD
DB $7A,<D0490,>D0490 ; SAW D0490
; 1918: end
DB $5A ; LEAVE
; 1919: def emit_codetag_10(tag)
C0461: ; emit_codetag_10()
; tag = 2
; 1920: drop ctag_resolve_21(tag, codeptr)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $66,$02 ; LLW 2
DB $6A,<D0490,>D0490 ; LAW D0490
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 1921: end
DB $5A ; LEAVE
; 1922: defopt emit_op_10(op)
C0463: ; emit_op_10()
; op = 2
; 1923: 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 D0494
; 1924: ^codeptr = op
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
LDY #$00
JSR SB
; 1925: codeptr = codeptr + 1
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
STY ESTKH,X
JSR ADD
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 1926: end
INX
JMP LEAVE
; 1927: def emit_tag_10(tag)
C0465: ; emit_tag_10()
; tag = 2
; 1928: word updtptr
; updtptr = 4
; 1929:
; 1930: 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,<C0467,>C0467 ; SKPFLS C0467
; 1931: tag = tag & mask_ctag
DB $66,$02 ; LLW 2
DB $2C,$FF,$7F ; CW 32767
DB $14 ; BAND
DB $76,$02 ; SLW 2
; 1932: updtptr = ctag_value:[tag]
DB $2C,$00,$08 ; CW 2048
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $62 ; LW
DB $76,$04 ; SLW 4
; 1933: if !(ctag_flags.[tag] & resolved)
DB $2C,$80,$0D ; CW 3456
DB $66,$02 ; LLW 2
DB $02 ; IDXB
DB $60 ; LB
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C0469,>C0469 ; SKPFLS C0469
; 1934: ;
; 1935: ; Add to list of tags needing resolution
; 1936: ;
; 1937: ctag_value:[tag] = codeptr
DB $2C,$00,$08 ; CW 2048
DB $66,$02 ; LLW 2
DB $1E ; IDXW
DB $6A,<D0490,>D0490 ; LAW D0490
DB $72 ; SW
; 1938: fin
C0469:
C0470:
; 1939: emit_word_10(updtptr)
DB $66,$04 ; LLW 4
DB $54,<C0457,>C0457 ; CALL C0457
; 1940: else
DB $50,<C0468,>C0468 ; SKIP C0468
C0467:
; 1941: emit_word_10(tag + codebuff)
DB $66,$02 ; LLW 2
DB $2C,$00,$A8 ; CW 43008
DB $02 ; ADD
DB $54,<C0457,>C0457 ; CALL C0457
; 1942: fin
C0468:
; 1943: end
DB $5A ; LEAVE
; 1944: def emit_iddata_30(value, size, namestr)
C0471: ; emit_iddata_30()
; value = 2
; size = 4
; namestr = 6
; 1945: emit_fill_10(size)
JSR INTERP
DB $58,$08,$03 ; ENTER 8,3
DB $66,$04 ; LLW 4
DB $54,<C0459,>C0459 ; CALL C0459
; 1946: end
DB $5A ; LEAVE
; 1947: def emit_data_41(vartype, consttype, constval, constsize)
C0473: ; emit_data_41()
; vartype = 2
; consttype = 4
; constval = 6
; constsize = 8
; 1948: byte i
; i = 10
; 1949: word size, chrptr
; size = 11
; chrptr = 13
; 1950:
; 1951: 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,<C0475,>C0475 ; SKPFLS C0475
; 1952: size = constsize
DB $66,$08 ; LLW 8
DB $76,$0B ; SLW 11
; 1953: emit_fill_10(constsize)
DB $66,$08 ; LLW 8
DB $54,<C0459,>C0459 ; CALL C0459
; 1954: elsif consttype == STR_TYPE
DB $50,<C0476,>C0476 ; SKIP C0476
C0475:
DB $66,$04 ; LLW 4
DB $2A,$80 ; CB 128
DB $40 ; ISEQ
DB $4C,<C0477,>C0477 ; SKPFLS C0477
; 1955: size = constsize
DB $66,$08 ; LLW 8
DB $76,$0B ; SLW 11
; 1956: chrptr = constval
DB $66,$06 ; LLW 6
DB $76,$0D ; SLW 13
; 1957: constsize = constsize - 1
DB $66,$08 ; LLW 8
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $76,$08 ; SLW 8
; 1958: emit_byte_10(constsize)
DB $66,$08 ; LLW 8
DB $54,<C0455,>C0455 ; CALL C0455
; 1959: while constsize > 0
C0478:
DB $66,$08 ; LLW 8
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C0479,>C0479 ; SKPFLS C0479
; 1960: emit_byte_10(^chrptr)
DB $66,$0D ; LLW 13
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 1961: chrptr = chrptr + 1
DB $66,$0D ; LLW 13
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $76,$0D ; SLW 13
; 1962: constsize = constsize - 1
DB $66,$08 ; LLW 8
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $76,$08 ; SLW 8
; 1963: loop
DB $50,<C0478,>C0478 ; SKIP C0478
C0479:
; 1964: else
DB $50,<C0476,>C0476 ; SKIP C0476
C0477:
; 1965: if vartype == WORD_TYPE
DB $66,$02 ; LLW 2
DB $2A,$04 ; CB 4
DB $40 ; ISEQ
DB $4C,<C0480,>C0480 ; SKPFLS C0480
; 1966: size = 2
DB $2A,$02 ; CB 2
DB $76,$0B ; SLW 11
; 1967: emit_word_10(constval)
DB $66,$06 ; LLW 6
DB $54,<C0457,>C0457 ; CALL C0457
; 1968: else
DB $50,<C0481,>C0481 ; SKIP C0481
C0480:
; 1969: size = 1
DB $2A,$01 ; CB 1
DB $76,$0B ; SLW 11
; 1970: emit_byte_10(constval)
DB $66,$06 ; LLW 6
DB $54,<C0455,>C0455 ; CALL C0455
; 1971: fin
C0481:
; 1972: fin
C0476:
; 1973: return size
DB $66,$0B ; LLW 11
DB $5A ; LEAVE
; 1974: end
; 1975: def emit_const_10(cval)
C0482: ; emit_const_10()
; cval = 2
; 1976: 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,<C0484,>C0484 ; SKPFLS C0484
; 1977: emit_op_10($00)
DB $00 ; ZERO
DB $54,<C0463,>C0463 ; CALL C0463
; 1978: elsif cval > 0 and cval < 256
DB $50,<C0485,>C0485 ; SKIP C0485
C0484:
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,<C0486,>C0486 ; SKPFLS C0486
; 1979: emit_op_10($2A)
DB $2A,$2A ; CB 42
DB $54,<C0463,>C0463 ; CALL C0463
; 1980: emit_byte_10(cval)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 1981: else
DB $50,<C0485,>C0485 ; SKIP C0485
C0486:
; 1982: emit_op_10($2C)
DB $2A,$2C ; CB 44
DB $54,<C0463,>C0463 ; CALL C0463
; 1983: emit_word_10(cval)
DB $66,$02 ; LLW 2
DB $54,<C0457,>C0457 ; CALL C0457
; 1984: fin
C0485:
; 1985: end
DB $5A ; LEAVE
; 1986: def emit_lb
C0487: ; emit_lb()
; 1987: emit_op_10($60)
JSR INTERP
DB $2A,$60 ; CB 96
DB $54,<C0463,>C0463 ; CALL C0463
; 1988: end
DB $5C ; RET
; 1989: def emit_lw
C0489: ; emit_lw()
; 1990: emit_op_10($62)
JSR INTERP
DB $2A,$62 ; CB 98
DB $54,<C0463,>C0463 ; CALL C0463
; 1991: end
DB $5C ; RET
; 1992: def emit_llb_10(index)
C0491: ; emit_llb_10()
; index = 2
; 1993: emit_op_10($64)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$64 ; CB 100
DB $54,<C0463,>C0463 ; CALL C0463
; 1994: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 1995: end
DB $5A ; LEAVE
; 1996: def emit_llw_10(index)
C0493: ; emit_llw_10()
; index = 2
; 1997: emit_op_10($66)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$66 ; CB 102
DB $54,<C0463,>C0463 ; CALL C0463
; 1998: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 1999: end
DB $5A ; LEAVE
; 2000: def emit_lab_10(tag)
C0495: ; emit_lab_10()
; tag = 2
; 2001: emit_op_10($68)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$68 ; CB 104
DB $54,<C0463,>C0463 ; CALL C0463
; 2002: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2003: end
DB $5A ; LEAVE
; 2004: def emit_law_10(tag)
C0497: ; emit_law_10()
; tag = 2
; 2005: emit_op_10($6A)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$6A ; CB 106
DB $54,<C0463,>C0463 ; CALL C0463
; 2006: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2007: end
DB $5A ; LEAVE
; 2008: def emit_sb
C0499: ; emit_sb()
; 2009: emit_op_10($70)
JSR INTERP
DB $2A,$70 ; CB 112
DB $54,<C0463,>C0463 ; CALL C0463
; 2010: end
DB $5C ; RET
; 2011: def emit_sw
C0501: ; emit_sw()
; 2012: emit_op_10($72)
JSR INTERP
DB $2A,$72 ; CB 114
DB $54,<C0463,>C0463 ; CALL C0463
; 2013: end
DB $5C ; RET
; 2014: def emit_slb_10(index)
C0503: ; emit_slb_10()
; index = 2
; 2015: emit_op_10($74)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$74 ; CB 116
DB $54,<C0463,>C0463 ; CALL C0463
; 2016: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2017: end
DB $5A ; LEAVE
; 2018: def emit_slw_10(index)
C0505: ; emit_slw_10()
; index = 2
; 2019: emit_op_10($76)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$76 ; CB 118
DB $54,<C0463,>C0463 ; CALL C0463
; 2020: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2021: end
DB $5A ; LEAVE
; 2022: def emit_dlb_10(index)
C0507: ; emit_dlb_10()
; index = 2
; 2023: emit_op_10($6C)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$6C ; CB 108
DB $54,<C0463,>C0463 ; CALL C0463
; 2024: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2025: end
DB $5A ; LEAVE
; 2026: def emit_dlw_10(index)
C0509: ; emit_dlw_10()
; index = 2
; 2027: emit_op_10($6E)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$6E ; CB 110
DB $54,<C0463,>C0463 ; CALL C0463
; 2028: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2029: end
DB $5A ; LEAVE
; 2030: def emit_sab_10(tag)
C0511: ; emit_sab_10()
; tag = 2
; 2031: emit_op_10($78)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$78 ; CB 120
DB $54,<C0463,>C0463 ; CALL C0463
; 2032: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2033: end
DB $5A ; LEAVE
; 2034: def emit_saw_10(tag)
C0513: ; emit_saw_10()
; tag = 2
; 2035: emit_op_10($7A)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$7A ; CB 122
DB $54,<C0463,>C0463 ; CALL C0463
; 2036: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2037: end
DB $5A ; LEAVE
; 2038: def emit_dab_10(tag)
C0515: ; emit_dab_10()
; tag = 2
; 2039: emit_op_10($7C)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$7C ; CB 124
DB $54,<C0463,>C0463 ; CALL C0463
; 2040: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2041: end
DB $5A ; LEAVE
; 2042: def emit_daw_10(tag)
C0517: ; emit_daw_10()
; tag = 2
; 2043: emit_op_10($7E)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$7E ; CB 126
DB $54,<C0463,>C0463 ; CALL C0463
; 2044: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2045: end
DB $5A ; LEAVE
; 2046: def emit_call_10(tag)
C0519: ; emit_call_10()
; tag = 2
; 2047: emit_op_10($54)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$54 ; CB 84
DB $54,<C0463,>C0463 ; CALL C0463
; 2048: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2049: end
DB $5A ; LEAVE
; 2050: def emit_ical
C0521: ; emit_ical()
; 2051: emit_op_10($56)
JSR INTERP
DB $2A,$56 ; CB 86
DB $54,<C0463,>C0463 ; CALL C0463
; 2052: end
DB $5C ; RET
; 2053: def emit_push
C0523: ; emit_push()
; 2054: emit_op_10($34)
JSR INTERP
DB $2A,$34 ; CB 52
DB $54,<C0463,>C0463 ; CALL C0463
; 2055: end
DB $5C ; RET
; 2056: def emit_pull
C0525: ; emit_pull()
; 2057: ;
; 2058: ; Skip if last op was push
; 2059: ;
; 2060: if lastop == $34
JSR INTERP
DB $68,<D0494,>D0494 ; LAB D0494
DB $2A,$34 ; CB 52
DB $40 ; ISEQ
DB $4C,<C0527,>C0527 ; SKPFLS C0527
; 2061: codeptr = codeptr - 1
DB $6A,<D0490,>D0490 ; LAW D0490
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0490,>D0490 ; SAW D0490
; 2062: lastop = $FF
DB $2A,$FF ; CB 255
DB $78,<D0494,>D0494 ; SAB D0494
; 2063: else
DB $50,<C0528,>C0528 ; SKIP C0528
C0527:
; 2064: emit_op_10($36)
DB $2A,$36 ; CB 54
DB $54,<C0463,>C0463 ; CALL C0463
; 2065: fin
C0528:
; 2066: end
DB $5C ; RET
; 2067: def emit_localaddr_10(index)
C0529: ; emit_localaddr_10()
; index = 2
; 2068: emit_op_10($28)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$28 ; CB 40
DB $54,<C0463,>C0463 ; CALL C0463
; 2069: emit_byte_10(index)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2070: end
DB $5A ; LEAVE
; 2071: def emit_globaladdr_10(tag)
C0531: ; emit_globaladdr_10()
; tag = 2
; 2072: emit_op_10($26)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$26 ; CB 38
DB $54,<C0463,>C0463 ; CALL C0463
; 2073: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2074: end
DB $5A ; LEAVE
; 2075: def emit_indexbyte
C0533: ; emit_indexbyte()
; 2076: emit_op_10($02)
JSR INTERP
DB $2A,$02 ; CB 2
DB $54,<C0463,>C0463 ; CALL C0463
; 2077: end
DB $5C ; RET
; 2078: def emit_indexword
C0535: ; emit_indexword()
; 2079: emit_op_10($1E)
JSR INTERP
DB $2A,$1E ; CB 30
DB $54,<C0463,>C0463 ; CALL C0463
; 2080: end
DB $5C ; RET
; 2081: defopt emit_unaryop_11(op)
C0537: ; emit_unaryop_11()
; op = 2
; 2082: when op
LDY #4
LDA #1
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
; 2083: 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 C0540
:
; 2084: emit_op_10($10)
DEX
LDA #$10
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2085: is COMP_TKN
JMP C0539
C0540:
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 C0541
:
; 2086: emit_op_10($12)
DEX
LDA #$12
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2087: is LOGIC_NOT_TKN
JMP C0539
C0541:
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 C0542
:
; 2088: emit_op_10($20)
DEX
LDA #$20
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2089: is INC_TKN
JMP C0539
C0542:
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 C0543
:
; 2090: emit_op_10($0C)
DEX
LDA #$0C
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2091: is DEC_TKN
JMP C0539
C0543:
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 C0544
:
; 2092: emit_op_10($0E)
DEX
LDA #$0E
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2093: is BPTR_TKN
JMP C0539
C0544:
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 C0545
:
; 2094: emit_op_10($60)
DEX
LDA #$60
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2095: is WPTR_TKN
JMP C0539
C0545:
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 C0546
:
; 2096: emit_op_10($62)
DEX
LDA #$62
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2097: otherwise
JMP C0539
C0546:
; 2098: return FALSE
LDY #$00
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 2099: wend
C0539:
; 2100: return TRUE
LDA #$FF
STA ESTKL,X
STA ESTKH,X
JMP LEAVE
; 2101: end
; 2102: defopt emit_binaryop_11(op)
C0548: ; emit_binaryop_11()
; op = 2
; 2103: when op
LDY #4
LDA #1
JSR ENTER
DEX
LDY #$02
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
; 2104: 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 C0551
:
; 2105: ;
; 2106: ; Replace MUL 2 with SHL 1
; 2107: ;
; 2108: if lastop == $2A and ^(codeptr - 1) == 2 ; CB 2
DEX
LDA D0494
STA ESTKL,X
STY ESTKH,X
DEX
LDA #$2A
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
DEX
LDA D0490
STA ESTKL,X
LDA D0490+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 C0552
:
; 2109: codeptr = codeptr - 1
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SUB
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 2110: emit_byte_10(1) ; CB 1
LDA #$01
STA ESTKL,X
STY ESTKH,X
JSR C0455
; 2111: emit_op_10($1A) ; SHL
DEX
LDA #$1A
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2112: else
JMP C0553
C0552:
; 2113: emit_op_10($06)
DEX
LDA #$06
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2114: fin
C0553:
; 2115: is DIV_TKN
JMP C0550
C0551:
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 C0554
:
; 2116: ;
; 2117: ; Replace DIV 2 with SHR 1
; 2118: ;
; 2119: if lastop == $2A and ^(codeptr - 1) == 2 ; CB 2
DEX
LDA D0494
STA ESTKL,X
STY ESTKH,X
DEX
LDA #$2A
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
DEX
LDA D0490
STA ESTKL,X
LDA D0490+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 C0555
:
; 2120: codeptr = codeptr - 1
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SUB
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 2121: emit_byte_10(1) ; CB 1
LDA #$01
STA ESTKL,X
STY ESTKH,X
JSR C0455
; 2122: emit_op_10($1C) ; SHR
DEX
LDA #$1C
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2123: else
JMP C0556
C0555:
; 2124: emit_op_10($08)
DEX
LDA #$08
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2125: fin
C0556:
; 2126: is MOD_TKN
JMP C0550
C0554:
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 C0557
:
; 2127: emit_op_10($0A)
DEX
LDA #$0A
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2128: is ADD_TKN
JMP C0550
C0557:
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 C0558
:
; 2129: ;
; 2130: ; Replace ADD 1 with INCR
; 2131: ;
; 2132: if lastop == $2A and ^(codeptr - 1) == 1 ; CB 1
DEX
LDA D0494
STA ESTKL,X
STY ESTKH,X
DEX
LDA #$2A
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
DEX
LDA D0490
STA ESTKL,X
LDA D0490+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 C0559
:
; 2133: codeptr = codeptr - 2
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$02
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SUB
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 2134: emit_op_10($0C) ; INC_OP
LDA #$0C
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2135: else
JMP C0560
C0559:
; 2136: emit_op_10($02)
DEX
LDA #$02
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2137: fin
C0560:
; 2138: is SUB_TKN
JMP C0550
C0558:
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 C0561
:
; 2139: ;
; 2140: ; Replace SUB 1 with DECR
; 2141: ;
; 2142: if lastop == $2A and ^(codeptr - 1) == 1 ; CB 1
DEX
LDA D0494
STA ESTKL,X
STY ESTKH,X
DEX
LDA #$2A
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
DEX
LDA D0490
STA ESTKL,X
LDA D0490+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 C0562
:
; 2143: codeptr = codeptr - 2
DEX
LDA D0490
STA ESTKL,X
LDA D0490+1
STA ESTKH,X
DEX
LDA #$02
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR SUB
LDA ESTKL,X
STA D0490
LDA ESTKH,X
STA D0490+1
; 2144: emit_op_10($0E) ; DEC_OP
LDA #$0E
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2145: else
JMP C0563
C0562:
; 2146: emit_op_10($04)
DEX
LDA #$04
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR C0463
; 2147: fin
C0563:
; 2148: is SHL_TKN
JMP C0550
C0561:
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 C0564
:
; 2149: emit_op_10($1A)
DEX
LDA #$1A
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2150: is SHR_TKN
JMP C0550
C0564:
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 C0565
:
; 2151: emit_op_10($1C)
DEX
LDA #$1C
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2152: is AND_TKN
JMP C0550
C0565:
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 C0566
:
; 2153: emit_op_10($14)
DEX
LDA #$14
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2154: is OR_TKN
JMP C0550
C0566:
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 C0567
:
; 2155: emit_op_10($16)
DEX
LDA #$16
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2156: is EOR_TKN
JMP C0550
C0567:
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 C0568
:
; 2157: emit_op_10($18)
DEX
LDA #$18
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2158: is EQ_TKN
JMP C0550
C0568:
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 C0569
:
; 2159: emit_op_10($40)
DEX
LDA #$40
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2160: is NE_TKN
JMP C0550
C0569:
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 C0570
:
; 2161: emit_op_10($42)
DEX
LDA #$42
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2162: is GE_TKN
JMP C0550
C0570:
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 C0571
:
; 2163: emit_op_10($48)
DEX
LDA #$48
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2164: is LT_TKN
JMP C0550
C0571:
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 C0572
:
; 2165: emit_op_10($46)
DEX
LDA #$46
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2166: is GT_TKN
JMP C0550
C0572:
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 C0573
:
; 2167: emit_op_10($44)
DEX
LDA #$44
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2168: is LE_TKN
JMP C0550
C0573:
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 C0574
:
; 2169: emit_op_10($4A)
DEX
LDA #$4A
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2170: is LOGIC_OR_TKN
JMP C0550
C0574:
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 C0575
:
; 2171: emit_op_10($22)
DEX
LDA #$22
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2172: is LOGIC_AND_TKN
JMP C0550
C0575:
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 C0576
:
; 2173: emit_op_10($24)
DEX
LDA #$24
STA ESTKL,X
STY ESTKH,X
JSR C0463
; 2174: is COMMA_TKN
JMP C0550
C0576:
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 C0577
:
; 2175: ; Do nothing except move to next stanza in expression
; 2176: otherwise
JMP C0550
C0577:
; 2177: return FALSE
LDY #$00
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 2178: wend
C0550:
; 2179: return TRUE
LDA #$FF
STA ESTKL,X
STA ESTKH,X
JMP LEAVE
; 2180: end
; 2181: def emit_brtru_10(tag)
C0579: ; emit_brtru_10()
; tag = 2
; 2182: emit_op_10($4E)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$4E ; CB 78
DB $54,<C0463,>C0463 ; CALL C0463
; 2183: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2184: end
DB $5A ; LEAVE
; 2185: def emit_brfls_10(tag)
C0581: ; emit_brfls_10()
; tag = 2
; 2186: emit_op_10($4C)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$4C ; CB 76
DB $54,<C0463,>C0463 ; CALL C0463
; 2187: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2188: end
DB $5A ; LEAVE
; 2189: def emit_brgt_10(tag)
C0583: ; emit_brgt_10()
; tag = 2
; 2190: emit_op_10($3A)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$3A ; CB 58
DB $54,<C0463,>C0463 ; CALL C0463
; 2191: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2192: end
DB $5A ; LEAVE
; 2193: def emit_brlt_10(tag)
C0585: ; emit_brlt_10()
; tag = 2
; 2194: emit_op_10($38)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$38 ; CB 56
DB $54,<C0463,>C0463 ; CALL C0463
; 2195: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2196: end
DB $5A ; LEAVE
; 2197: def emit_brne_10(tag)
C0587: ; emit_brne_10()
; tag = 2
; 2198: emit_op_10($3E)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$3E ; CB 62
DB $54,<C0463,>C0463 ; CALL C0463
; 2199: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2200: end
DB $5A ; LEAVE
; 2201: def emit_jump_10(tag)
C0589: ; emit_jump_10()
; tag = 2
; 2202: emit_op_10($50)
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $2A,$50 ; CB 80
DB $54,<C0463,>C0463 ; CALL C0463
; 2203: emit_tag_10(tag)
DB $66,$02 ; LLW 2
DB $54,<C0465,>C0465 ; CALL C0465
; 2204: end
DB $5A ; LEAVE
; 2205: def emit_drop
C0591: ; emit_drop()
; 2206: emit_op_10($30)
JSR INTERP
DB $2A,$30 ; CB 48
DB $54,<C0463,>C0463 ; CALL C0463
; 2207: end
DB $5C ; RET
; 2208: def emit_swap
C0593: ; emit_swap()
; 2209: emit_op_10($2E)
JSR INTERP
DB $2A,$2E ; CB 46
DB $54,<C0463,>C0463 ; CALL C0463
; 2210: end
DB $5C ; RET
; 2211: def emit_leave_10(framesize)
C0595: ; emit_leave_10()
; framesize = 2
; 2212: 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,<C0597,>C0597 ; SKPFLS C0597
; 2213: emit_op_10($5A)
DB $2A,$5A ; CB 90
DB $54,<C0463,>C0463 ; CALL C0463
; 2214: else
DB $50,<C0598,>C0598 ; SKIP C0598
C0597:
; 2215: emit_op_10($5C)
DB $2A,$5C ; CB 92
DB $54,<C0463,>C0463 ; CALL C0463
; 2216: fin
C0598:
; 2217: end
DB $5A ; LEAVE
; 2218: def emit_enter_20(framesize, cparams)
C0599: ; emit_enter_20()
; framesize = 2
; cparams = 4
; 2219: emit_byte_10(emit_enter_20.[0])
JSR INTERP
DB $58,$06,$02 ; ENTER 6,2
DB $26,<C0599,>C0599 ; LA C0599
DB $00 ; ZERO
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2220: emit_byte_10(emit_enter_20.[1])
DB $26,<C0599,>C0599 ; LA C0599
DB $2A,$01 ; CB 1
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2221: emit_byte_10(emit_enter_20.[2])
DB $26,<C0599,>C0599 ; LA C0599
DB $2A,$02 ; CB 2
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2222: if framesize > 2
DB $66,$02 ; LLW 2
DB $2A,$02 ; CB 2
DB $44 ; ISGT
DB $4C,<C0601,>C0601 ; SKPFLS C0601
; 2223: emit_op_10($58)
DB $2A,$58 ; CB 88
DB $54,<C0463,>C0463 ; CALL C0463
; 2224: emit_byte_10(framesize)
DB $66,$02 ; LLW 2
DB $54,<C0455,>C0455 ; CALL C0455
; 2225: emit_byte_10(cparams)
DB $66,$04 ; LLW 4
DB $54,<C0455,>C0455 ; CALL C0455
; 2226: fin
C0601:
C0602:
; 2227: end
DB $5A ; LEAVE
; 2228: def emit_start
C0603: ; emit_start()
; 2229: ;
; 2230: ; Save address
; 2231: ;
; 2232: entrypoint = codeptr
JSR INTERP
DB $6A,<D0490,>D0490 ; LAW D0490
DB $7A,<D0492,>D0492 ; SAW D0492
; 2233: emit_byte_10(emit_start.[0])
DB $26,<C0603,>C0603 ; LA C0603
DB $00 ; ZERO
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2234: emit_byte_10(emit_start.[1])
DB $26,<C0603,>C0603 ; LA C0603
DB $2A,$01 ; CB 1
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2235: emit_byte_10(emit_start.[2])
DB $26,<C0603,>C0603 ; LA C0603
DB $2A,$02 ; CB 2
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0455,>C0455 ; CALL C0455
; 2236: end
DB $5C ; RET
; 2237: def emit_exit
C0605: ; emit_exit()
; 2238: emit_op_10($00)
JSR INTERP
DB $00 ; ZERO
DB $54,<C0463,>C0463 ; CALL C0463
; 2239: emit_op_10($5C)
DB $2A,$5C ; CB 92
DB $54,<C0463,>C0463 ; CALL C0463
; 2240: end
DB $5C ; RET
; 2241: ;
; 2242: ; Lexical anaylzer
; 2243: ;
; 2244: ;def isalpha_11(c)
; 2245: ; if c >= 'A' and c <= 'Z'
; 2246: ; return TRUE
; 2247: ; elsif c >= 'a' and c <= 'z'
; 2248: ; return TRUE
; 2249: ; elsif c == '_'
; 2250: ; return TRUE
; 2251: ; fin
; 2252: ; return FALSE
; 2253: ;end
; 2254: asm isalpha_11
C0607: ; isalpha_11()
; 2255: LDY #$00
LDY #$00
; 2256: LDA ESTKL,X
LDA ESTKL,X
; 2257: CMP #'A'
CMP #'A'
; 2258: BCC ISALRET
BCC ISALRET
; 2259: CMP #'Z'+1
CMP #'Z'+1
; 2260: BCS :+
BCS :+
; 2261: DEY
DEY
; 2262: BNE ISALRET
BNE ISALRET
; 2263: : CMP #'a'
: CMP #'a'
; 2264: BCC ISALRET
BCC ISALRET
; 2265: CMP #'z'+1
CMP #'z'+1
; 2266: BCS :+
BCS :+
; 2267: DEY
DEY
; 2268: BNE ISALRET
BNE ISALRET
; 2269: : CMP #'_'
: CMP #'_'
; 2270: BNE ISALRET
BNE ISALRET
; 2271: DEY
DEY
; 2272: ISALRET:
ISALRET:
; 2273: STY ESTKL,X
STY ESTKL,X
; 2274: STY ESTKH,X
STY ESTKH,X
; 2275: RTS
RTS
; 2276: end
RTS
; 2277: ;def isnum_11(c)
; 2278: ; if c >= '0' and c <= '9'
; 2279: ; return TRUE
; 2280: ; fin
; 2281: ; return FALSE
; 2282: ;end
; 2283: asm isnum_11
C0609: ; isnum_11()
; 2284: LDY #$00
LDY #$00
; 2285: LDA ESTKL,X
LDA ESTKL,X
; 2286: CMP #'0'
CMP #'0'
; 2287: BCC :+
BCC :+
; 2288: CMP #'9'+1
CMP #'9'+1
; 2289: BCS :+
BCS :+
; 2290: DEY
DEY
; 2291: : STY ESTKL,X
: STY ESTKL,X
; 2292: STY ESTKH,X
STY ESTKH,X
; 2293: RTS
RTS
; 2294: end
RTS
; 2295: ;def isalphanum_11(c)
; 2296: ; if c >= 'A' and c <= 'Z'
; 2297: ; return TRUE
; 2298: ; elsif c >= '0' and c <= '9'
; 2299: ; return TRUE
; 2300: ; elsif c >= 'a' and c <= 'z'
; 2301: ; return TRUE
; 2302: ; elsif c == '_'
; 2303: ; return TRUE
; 2304: ; fin
; 2305: ; return FALSE
; 2306: ;end
; 2307: asm isalphanum_11
C0611: ; isalphanum_11()
; 2308: LDY #$00
LDY #$00
; 2309: LDA ESTKL,X
LDA ESTKL,X
; 2310: CMP #'0'
CMP #'0'
; 2311: BCC ISANRET
BCC ISANRET
; 2312: CMP #'9'+1
CMP #'9'+1
; 2313: BCS :+
BCS :+
; 2314: DEY
DEY
; 2315: BNE ISANRET
BNE ISANRET
; 2316: : CMP #'A'
: CMP #'A'
; 2317: BCC ISANRET
BCC ISANRET
; 2318: CMP #'Z'+1
CMP #'Z'+1
; 2319: BCS :+
BCS :+
; 2320: DEY
DEY
; 2321: BNE ISANRET
BNE ISANRET
; 2322: : CMP #'a'
: CMP #'a'
; 2323: BCC :+
BCC :+
; 2324: CMP #'z'+1
CMP #'z'+1
; 2325: BCS ISANRET
BCS ISANRET
; 2326: DEY
DEY
; 2327: BNE ISANRET
BNE ISANRET
; 2328: : CMP #'_'
: CMP #'_'
; 2329: BNE ISANRET
BNE ISANRET
; 2330: DEY
DEY
; 2331: ISANRET:
ISANRET:
; 2332: STY ESTKL,X
STY ESTKL,X
; 2333: STY ESTKH,X
STY ESTKH,X
; 2334: RTS
RTS
; 2335: end
RTS
; 2336: defopt keymatch_21(chrptr, len)
C0613: ; keymatch_21()
; chrptr = 2
; len = 4
; 2337: byte i, keypos
; i = 6
; keypos = 7
; 2338:
; 2339: keypos = 0
LDY #8
LDA #2
JSR ENTER
DEX
STY ESTKL,X
STY ESTKH,X
LDY #$07
LDA ESTKL,X
STA (FRMP),Y
; 2340: while keywrds[keypos] < len
INX
C0615:
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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 C0616
:
; 2341: keypos = keypos + keywrds[keypos] + 2
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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
; 2342: loop
INX
JMP C0615
C0616:
; 2343: while keywrds[keypos] == len
C0617:
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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 C0618
:
; 2344: for i = 1 to len
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
C0620:
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 C0619
:
INC ESTKL,X
BNE :+
INC ESTKH,X
:
; 2345: 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 C0127
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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 C0621
:
; 2346: break
JMP C0619
; 2347: fin
C0621:
C0622:
; 2348: next
JMP C0620
C0619:
; 2349: 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 C0623
:
; 2350: return keywrds[keypos + keywrds[keypos] + 1]
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
STA ESTKH,X
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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
; 2351: fin
C0623:
C0624:
; 2352: keypos = keypos + keywrds[keypos] + 2
DEX
LDY #$07
LDA (FRMP),Y
STA ESTKL,X
LDY #$00
STY ESTKH,X
DEX
LDA #<D0212
STA ESTKL,X
LDA #>D0212
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
; 2353: loop
INX
JMP C0617
C0618:
; 2354: return ID_TKN
DEX
LDA #$D6
STA ESTKL,X
LDY #$00
STY ESTKH,X
JMP LEAVE
; 2355: end
; 2356: defopt skipspace_01
C0625: ; skipspace_01()
; 2357: ;
; 2358: ; Skip whitespace
; 2359: ;
; 2360: while ^scanptr and ^scanptr <= ' '
C0627:
DEX
LDA D0499
STA ESTKL,X
LDA D0499+1
STA ESTKH,X
LDY #$00
JSR LB
DEX
LDA D0499
STA ESTKL,X
LDA D0499+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 C0628
:
; 2361: scanptr = scanptr + 1
DEX
LDA D0499
STA ESTKL,X
LDA D0499+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
LDA ESTKL,X
STA D0499
LDA ESTKH,X
STA D0499+1
; 2362: loop
INX
JMP C0627
C0628:
; 2363: tknptr = scanptr
DEX
LDA D0499
STA ESTKL,X
LDA D0499+1
STA ESTKH,X
LDA ESTKL,X
STA D0501
LDA ESTKH,X
STA D0501+1
; 2364: return !^scanptr or ^scanptr == ';'
LDA D0499
STA ESTKL,X
LDA D0499+1
STA ESTKH,X
LDY #$00
JSR LB
JSR NOT
DEX
LDA D0499
STA ESTKL,X
LDA D0499+1
STA ESTKH,X
JSR LB
DEX
LDA #$3B
STA ESTKL,X
STY ESTKH,X
JSR ISEQ
JSR LOR
RTS
; 2365: end
; 2366: def scan_01
C0629: ; scan_01()
; 2367: ;
; 2368: ; Scan for token based on first character
; 2369: ;
; 2370: if skipspace_01()
JSR INTERP
DB $54,<C0625,>C0625 ; CALL C0625
DB $4C,<C0631,>C0631 ; SKPFLS C0631
; 2371: if token <> EOF_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$01 ; CB 1
DB $42 ; ISNE
DB $4C,<C0633,>C0633 ; SKPFLS C0633
; 2372: token = EOL_TKN
DB $2A,$02 ; CB 2
DB $78,<D0495,>D0495 ; SAB D0495
; 2373: fin
C0633:
C0634:
; 2374: elsif isalpha_11(^scanptr)
DB $50,<C0632,>C0632 ; SKIP C0632
C0631:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $54,<C0607,>C0607 ; CALL C0607
DB $4C,<C0635,>C0635 ; SKPFLS C0635
; 2375: ;
; 2376: ; ID, either variable name or reserved word
; 2377: ;
; 2378: repeat
C0637:
; 2379: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2380: until !isalphanum_11(^scanptr)
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $54,<C0611,>C0611 ; CALL C0611
DB $20 ; NOT
DB $4C,<C0637,>C0637 ; SKPFLS C0637
C0636:
; 2381: tknlen = scanptr - tknptr;
DB $6A,<D0499,>D0499 ; LAW D0499
DB $6A,<D0501,>D0501 ; LAW D0501
DB $04 ; SUB
DB $78,<D0496,>D0496 ; SAB D0496
; 2382: token = keymatch_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0613,>C0613 ; CALL C0613
DB $78,<D0495,>D0495 ; SAB D0495
; 2383: elsif isnum_11(^scanptr)
DB $50,<C0632,>C0632 ; SKIP C0632
C0635:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $54,<C0609,>C0609 ; CALL C0609
DB $4C,<C0638,>C0638 ; SKPFLS C0638
; 2384: ;
; 2385: ; Number constant
; 2386: ;
; 2387: token = INT_TKN
DB $2A,$C9 ; CB 201
DB $78,<D0495,>D0495 ; SAB D0495
; 2388: constval = 0
DB $00 ; ZERO
DB $7A,<D0505,>D0505 ; SAW D0505
; 2389: repeat
C0640:
; 2390: constval = constval * 10 + ^scanptr - '0'
DB $6A,<D0505,>D0505 ; LAW D0505
DB $2A,$0A ; CB 10
DB $06 ; MUL
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $02 ; ADD
DB $2A,$30 ; CB 48
DB $04 ; SUB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2391: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2392: until !isnum_11(^scanptr)
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $54,<C0609,>C0609 ; CALL C0609
DB $20 ; NOT
DB $4C,<C0640,>C0640 ; SKPFLS C0640
C0639:
; 2393: elsif ^scanptr == '$'
DB $50,<C0632,>C0632 ; SKIP C0632
C0638:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$24 ; CB 36
DB $40 ; ISEQ
DB $4C,<C0641,>C0641 ; SKPFLS C0641
; 2394: ;
; 2395: ; Hexadecimal constant
; 2396: ;
; 2397: token = INT_TKN;
DB $2A,$C9 ; CB 201
DB $78,<D0495,>D0495 ; SAB D0495
; 2398: constval = 0
DB $00 ; ZERO
DB $7A,<D0505,>D0505 ; SAW D0505
; 2399: repeat
C0643:
; 2400: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2401: if ^scanptr >= '0' and ^scanptr <= '9'
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$30 ; CB 48
DB $48 ; ISGE
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$39 ; CB 57
DB $4A ; ISLE
DB $24 ; LAND
DB $4C,<C0644,>C0644 ; SKPFLS C0644
; 2402: constval = (constval << 4) + ^scanptr - '0'
DB $6A,<D0505,>D0505 ; LAW D0505
DB $2A,$04 ; CB 4
DB $1A ; SHL
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $02 ; ADD
DB $2A,$30 ; CB 48
DB $04 ; SUB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2403: elsif ^scanptr >= 'A' and ^scanptr <= 'F'
DB $50,<C0645,>C0645 ; SKIP C0645
C0644:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$41 ; CB 65
DB $48 ; ISGE
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$46 ; CB 70
DB $4A ; ISLE
DB $24 ; LAND
DB $4C,<C0646,>C0646 ; SKPFLS C0646
; 2404: constval = (constval << 4) + ^scanptr - '7'; 'A'-10
DB $6A,<D0505,>D0505 ; LAW D0505
DB $2A,$04 ; CB 4
DB $1A ; SHL
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $02 ; ADD
DB $2A,$37 ; CB 55
DB $04 ; SUB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2405: elsif ^scanptr >= 'a' and ^scanptr <= 'f'
DB $50,<C0645,>C0645 ; SKIP C0645
C0646:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$61 ; CB 97
DB $48 ; ISGE
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$66 ; CB 102
DB $4A ; ISLE
DB $24 ; LAND
DB $4C,<C0647,>C0647 ; SKPFLS C0647
; 2406: constval = (constval << 4) + ^scanptr - 'W'; 'a'-10
DB $6A,<D0505,>D0505 ; LAW D0505
DB $2A,$04 ; CB 4
DB $1A ; SHL
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $02 ; ADD
DB $2A,$57 ; CB 87
DB $04 ; SUB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2407: else
DB $50,<C0645,>C0645 ; SKIP C0645
C0647:
; 2408: break;
DB $50,<C0642,>C0642 ; SKIP C0642
; 2409: fin
C0645:
; 2410: until !^scanptr
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $20 ; NOT
DB $4C,<C0643,>C0643 ; SKPFLS C0643
C0642:
; 2411: elsif ^scanptr == $27 ; '
DB $50,<C0632,>C0632 ; SKIP C0632
C0641:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$27 ; CB 39
DB $40 ; ISEQ
DB $4C,<C0648,>C0648 ; SKPFLS C0648
; 2412: ;
; 2413: ; Character constant
; 2414: ;
; 2415: token = CHR_TKN
DB $2A,$C3 ; CB 195
DB $78,<D0495,>D0495 ; SAB D0495
; 2416: if ^(scanptr + 1) <> $5C ; \
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$5C ; CB 92
DB $42 ; ISNE
DB $4C,<C0649,>C0649 ; SKPFLS C0649
; 2417: constval = ^(scanptr + 1)
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2418: if ^(scanptr + 2) <> $27 ; '
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $2A,$27 ; CB 39
DB $42 ; ISNE
DB $4C,<C0651,>C0651 ; SKPFLS C0651
; 2419: return parse_err_11(@bad_cnst)
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 2420: fin
C0651:
C0652:
; 2421: scanptr = scanptr + 3
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2422: else
DB $50,<C0650,>C0650 ; SKIP C0650
C0649:
; 2423: when ^(scanptr + 2)
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
; 2424: is 'n'
DB $2A,$6E ; CB 110
DB $3E,<C0654,>C0654 ; SKPNE C0654
; 2425: constval = $0D
DB $2A,$0D ; CB 13
DB $7A,<D0505,>D0505 ; SAW D0505
; 2426: is 'r'
DB $50,<C0653,>C0653 ; SKIP C0653
C0654:
DB $2A,$72 ; CB 114
DB $3E,<C0655,>C0655 ; SKPNE C0655
; 2427: constval = $0A
DB $2A,$0A ; CB 10
DB $7A,<D0505,>D0505 ; SAW D0505
; 2428: is 't'
DB $50,<C0653,>C0653 ; SKIP C0653
C0655:
DB $2A,$74 ; CB 116
DB $3E,<C0656,>C0656 ; SKPNE C0656
; 2429: constval = $09
DB $2A,$09 ; CB 9
DB $7A,<D0505,>D0505 ; SAW D0505
; 2430: otherwise
DB $50,<C0653,>C0653 ; SKIP C0653
C0656:
; 2431: constval = ^(scanptr + 2)
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $7A,<D0505,>D0505 ; SAW D0505
; 2432: wend
C0653:
DB $30 ; DROP
; 2433: if ^(scanptr + 3) <> $27 ; '
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $60 ; LB
DB $2A,$27 ; CB 39
DB $42 ; ISNE
DB $4C,<C0658,>C0658 ; SKPFLS C0658
; 2434: return parse_err_11(@bad_cnst)
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 2435: fin
C0658:
C0659:
; 2436: scanptr = scanptr + 4
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$04 ; CB 4
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2437: fin
C0650:
; 2438: elsif ^scanptr == '"'
DB $50,<C0632,>C0632 ; SKIP C0632
C0648:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$22 ; CB 34
DB $40 ; ISEQ
DB $4C,<C0660,>C0660 ; SKPFLS C0660
; 2439: ;
; 2440: ; String constant
; 2441: ;
; 2442: token = STR_TKN
DB $2A,$D3 ; CB 211
DB $78,<D0495,>D0495 ; SAB D0495
; 2443: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2444: constval = scanptr
DB $6A,<D0499,>D0499 ; LAW D0499
DB $7A,<D0505,>D0505 ; SAW D0505
; 2445: while ^scanptr and ^scanptr <> '"'
C0661:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$22 ; CB 34
DB $42 ; ISNE
DB $24 ; LAND
DB $4C,<C0662,>C0662 ; SKPFLS C0662
; 2446: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2447: loop
DB $50,<C0661,>C0661 ; SKIP C0661
C0662:
; 2448: if !^scanptr
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $20 ; NOT
DB $4C,<C0663,>C0663 ; SKPFLS C0663
; 2449: return parse_err_11(@bad_cnst)
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 2450: fin
C0663:
C0664:
; 2451: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2452: else
DB $50,<C0632,>C0632 ; SKIP C0632
C0660:
; 2453: ;
; 2454: ; Potential two and three character tokens
; 2455: ;
; 2456: when ^scanptr
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
; 2457: is '>'
DB $2A,$3E ; CB 62
DB $3E,<C0666,>C0666 ; SKPNE C0666
; 2458: if ^(scanptr + 1) == '>'
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3E ; CB 62
DB $40 ; ISEQ
DB $4C,<C0667,>C0667 ; SKPFLS C0667
; 2459: token = SHR_TKN
DB $2A,$D2 ; CB 210
DB $78,<D0495,>D0495 ; SAB D0495
; 2460: scanptr = scanptr + 2
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2461: elsif ^(scanptr + 1) == '='
DB $50,<C0668,>C0668 ; SKIP C0668
C0667:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3D ; CB 61
DB $40 ; ISEQ
DB $4C,<C0669,>C0669 ; SKPFLS C0669
; 2462: token = GE_TKN
DB $2A,$C8 ; CB 200
DB $78,<D0495,>D0495 ; SAB D0495
; 2463: scanptr = scanptr + 2
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2464: else
DB $50,<C0668,>C0668 ; SKIP C0668
C0669:
; 2465: token = GT_TKN
DB $2A,$BE ; CB 190
DB $78,<D0495,>D0495 ; SAB D0495
; 2466: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2467: fin
C0668:
; 2468: is '<'
DB $50,<C0665,>C0665 ; SKIP C0665
C0666:
DB $2A,$3C ; CB 60
DB $3E,<C0670,>C0670 ; SKPNE C0670
; 2469: if ^(scanptr + 1) == '<'
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3C ; CB 60
DB $40 ; ISEQ
DB $4C,<C0671,>C0671 ; SKPFLS C0671
; 2470: token = SHL_TKN
DB $2A,$CC ; CB 204
DB $78,<D0495,>D0495 ; SAB D0495
; 2471: scanptr = scanptr + 2
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2472: elsif ^(scanptr + 1) == '='
DB $50,<C0672,>C0672 ; SKIP C0672
C0671:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3D ; CB 61
DB $40 ; ISEQ
DB $4C,<C0673,>C0673 ; SKPFLS C0673
; 2473: token = LE_TKN
DB $2A,$C2 ; CB 194
DB $78,<D0495,>D0495 ; SAB D0495
; 2474: scanptr = scanptr + 2
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2475: elsif ^(scanptr + 1) == '>'
DB $50,<C0672,>C0672 ; SKIP C0672
C0673:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3E ; CB 62
DB $40 ; ISEQ
DB $4C,<C0674,>C0674 ; SKPFLS C0674
; 2476: token = NE_TKN
DB $2A,$D5 ; CB 213
DB $78,<D0495,>D0495 ; SAB D0495
; 2477: scanptr = scanptr + 2
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2478: else
DB $50,<C0672,>C0672 ; SKIP C0672
C0674:
; 2479: token = LT_TKN
DB $2A,$BC ; CB 188
DB $78,<D0495,>D0495 ; SAB D0495
; 2480: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2481: fin
C0672:
; 2482: is '='
DB $50,<C0665,>C0665 ; SKIP C0665
C0670:
DB $2A,$3D ; CB 61
DB $3E,<C0675,>C0675 ; SKPNE C0675
; 2483: if ^(scanptr + 1) == '='
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$3D ; CB 61
DB $40 ; ISEQ
DB $4C,<C0676,>C0676 ; SKPFLS C0676
; 2484: token = EQ_TKN
DB $2A,$C5 ; CB 197
DB $78,<D0495,>D0495 ; SAB D0495
; 2485: scanptr = scanptr + 2;
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2486: elsif ^(scanptr + 1) == ','
DB $50,<C0677,>C0677 ; SKIP C0677
C0676:
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $60 ; LB
DB $2A,$2C ; CB 44
DB $40 ; ISEQ
DB $4C,<C0678,>C0678 ; SKPFLS C0678
; 2487: token = SETLIST_TKN
DB $2A,$B9 ; CB 185
DB $78,<D0495,>D0495 ; SAB D0495
; 2488: scanptr = scanptr + 2;
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2489: else
DB $50,<C0677,>C0677 ; SKIP C0677
C0678:
; 2490: token = SET_TKN;
DB $2A,$BD ; CB 189
DB $78,<D0495,>D0495 ; SAB D0495
; 2491: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2492: fin
C0677:
; 2493: otherwise
DB $50,<C0665,>C0665 ; SKIP C0665
C0675:
; 2494: ;
; 2495: ; Simple single character tokens
; 2496: ;
; 2497: token = ^scanptr ? $80
DB $6A,<D0499,>D0499 ; LAW D0499
DB $60 ; LB
DB $2A,$80 ; CB 128
DB $16 ; IOR
DB $78,<D0495,>D0495 ; SAB D0495
; 2498: scanptr = scanptr + 1
DB $6A,<D0499,>D0499 ; LAW D0499
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0499,>D0499 ; SAW D0499
; 2499: wend
C0665:
DB $30 ; DROP
; 2500: fin
C0632:
; 2501: tknlen = scanptr - tknptr
DB $6A,<D0499,>D0499 ; LAW D0499
DB $6A,<D0501,>D0501 ; LAW D0501
DB $04 ; SUB
DB $78,<D0496,>D0496 ; SAB D0496
; 2502: return token
DB $68,<D0495,>D0495 ; LAB D0495
DB $5C ; RET
; 2503: end
; 2504: def rewind_10(ptr)
C0680: ; rewind_10()
; ptr = 2
; 2505: scanptr = ptr
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $66,$02 ; LLW 2
DB $7A,<D0499,>D0499 ; SAW D0499
; 2506: end
DB $5A ; LEAVE
; 2507: ;
; 2508: ; Get next line of input
; 2509: ;
; 2510: defopt nextln_01
C0682: ; nextln_01()
; 2511: ; if ^keyboard == $A0
; 2512: ; ^keystrobe
; 2513: ; while ^keyboard < 128
; 2514: ; loop
; 2515: ; ^keystrobe
; 2516: ; elsif ^keyboard == $82
; 2517: ; lineno = numlines
; 2518: ; ^keystrobe
; 2519: ; fin
; 2520: scanptr = inbuff
DEX
LDY #$00
STY ESTKL,X
LDA #$02
STA ESTKH,X
LDA ESTKL,X
STA D0499
LDA ESTKH,X
STA D0499+1
; 2521: if lineno < numlines
LDA D0507
STA ESTKL,X
LDA D0507+1
STA ESTKH,X
DEX
LDA D0206
STA ESTKL,X
LDA D0206+1
STA ESTKH,X
JSR ISLT
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0684
:
; 2522: cpyln_20(strlinbuf:[lineno], instr)
DEX
LDY #$00
STY ESTKL,X
LDA #$10
STA ESTKH,X
DEX
LDA D0507
STA ESTKL,X
LDA D0507+1
STA ESTKH,X
JSR IDXW
JSR LW
DEX
LDA #$FF
STA ESTKL,X
LDA #$01
STA ESTKH,X
JSR C0133
; 2523: lineno = lineno + 1
DEX
LDA D0507
STA ESTKL,X
LDA D0507+1
STA ESTKH,X
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
JSR ADD
LDA ESTKL,X
STA D0507
LDA ESTKH,X
STA D0507+1
; 2524: if !(lineno & $0F)
LDA D0507
STA ESTKL,X
LDA D0507+1
STA ESTKH,X
DEX
LDA #$0F
STA ESTKL,X
STY ESTKH,X
JSR BAND
JSR NOT
INX
LDA ESTKL-1,X
ORA ESTKH-1,X
BNE :+
JMP C0686
:
; 2525: cout('.')
DEX
LDA #$2E
STA ESTKL,X
STY ESTKH,X
JSR C0015
; 2526: fin
C0686:
C0687:
; 2527: ; cout('>')
; 2528: ; prstr(instr)
; 2529: ; crout()
; 2530: drop scan_01()
JSR C0629
; 2531: else
INX
JMP C0685
C0684:
; 2532: ^instr = 0
DEX
LDA #$FF
STA ESTKL,X
LDA #$01
STA ESTKH,X
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
JSR SB
; 2533: ^inbuff = $00
DEX
STY ESTKL,X
LDA #$02
STA ESTKH,X
DEX
STY ESTKL,X
STY ESTKH,X
JSR SB
; 2534: token = DONE_TKN
DEX
LDA #$98
STA ESTKL,X
STY ESTKH,X
LDA ESTKL,X
STA D0495
; 2535: fin
INX
C0685:
; 2536: return ^instr
DEX
LDA #$FF
STA ESTKL,X
LDA #$01
STA ESTKH,X
LDY #$00
JSR LB
RTS
; 2537: end
; 2538: ;
; 2539: ; Alebraic op to stack op
; 2540: ;
; 2541: def push_op_21(op, prec)
C0688: ; push_op_21()
; op = 2
; prec = 4
; 2542: opsp = opsp + 1
JSR INTERP
DB $58,$06,$02 ; ENTER 6,2
DB $6A,<D0475,>D0475 ; LAW D0475
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0475,>D0475 ; SAW D0475
; 2543: if opsp == 16
DB $6A,<D0475,>D0475 ; LAW D0475
DB $2A,$10 ; CB 16
DB $40 ; ISEQ
DB $4C,<C0690,>C0690 ; SKPFLS C0690
; 2544: return parse_err_11(@estk_overflw)
DB $26,<D0681,>D0681 ; LA D0681
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2545: fin
C0690:
C0691:
; 2546: opstack[opsp] = op
DB $26,<D0443,>D0443 ; LA D0443
DB $6A,<D0475,>D0475 ; LAW D0475
DB $02 ; IDXB
DB $66,$02 ; LLW 2
DB $70 ; SB
; 2547: precstack[opsp] = prec
DB $26,<D0459,>D0459 ; LA D0459
DB $6A,<D0475,>D0475 ; LAW D0475
DB $02 ; IDXB
DB $66,$04 ; LLW 4
DB $70 ; SB
; 2548: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 2549: end
; 2550: def pop_op_01
C0692: ; pop_op_01()
; 2551: if opsp < 0
JSR INTERP
DB $6A,<D0475,>D0475 ; LAW D0475
DB $00 ; ZERO
DB $46 ; ISLT
DB $4C,<C0694,>C0694 ; SKPFLS C0694
; 2552: return parse_err_11(@estk_underflw)
DB $26,<D0701,>D0701 ; LA D0701
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 2553: fin
C0694:
C0695:
; 2554: opsp = opsp - 1
DB $6A,<D0475,>D0475 ; LAW D0475
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $7A,<D0475,>D0475 ; SAW D0475
; 2555: return opstack[opsp + 1]
DB $26,<D0443,>D0443 ; LA D0443
DB $6A,<D0475,>D0475 ; LAW D0475
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $02 ; IDXB
DB $60 ; LB
DB $5C ; RET
; 2556: end
; 2557: def tos_op_01
C0696: ; tos_op_01()
; 2558: if opsp < 0
JSR INTERP
DB $6A,<D0475,>D0475 ; LAW D0475
DB $00 ; ZERO
DB $46 ; ISLT
DB $4C,<C0698,>C0698 ; SKPFLS C0698
; 2559: return 0
DB $00 ; ZERO
DB $5C ; RET
; 2560: fin
C0698:
C0699:
; 2561: return opstack[opsp]
DB $26,<D0443,>D0443 ; LA D0443
DB $6A,<D0475,>D0475 ; LAW D0475
DB $02 ; IDXB
DB $60 ; LB
DB $5C ; RET
; 2562: end
; 2563: def tos_op_prec_11(tos)
C0700: ; tos_op_prec_11()
; tos = 2
; 2564: if opsp <= tos
JSR INTERP
DB $58,$04,$01 ; ENTER 4,1
DB $6A,<D0475,>D0475 ; LAW D0475
DB $66,$02 ; LLW 2
DB $4A ; ISLE
DB $4C,<C0702,>C0702 ; SKPFLS C0702
; 2565: return 100
DB $2A,$64 ; CB 100
DB $5A ; LEAVE
; 2566: fin
C0702:
C0703:
; 2567: return precstack[opsp]
DB $26,<D0459,>D0459 ; LA D0459
DB $6A,<D0475,>D0475 ; LAW D0475
DB $02 ; IDXB
DB $60 ; LB
DB $5A ; LEAVE
; 2568: end
; 2569: ;
; 2570: ; Symbol table
; 2571: ;
; 2572: defopt idmatch_41(nameptr, len, idptr, idcnt)
C0704: ; idmatch_41()
; nameptr = 2
; len = 4
; idptr = 6
; idcnt = 8
; 2573: byte i
; i = 10
; 2574:
; 2575: while idcnt
LDY #11
LDA #4
JSR ENTER
C0706:
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 C0707
:
; 2576: 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 C0708
:
; 2577: for i = 1 to len
DEX
LDA #$01
STA ESTKL,X
LDY #$00
STY ESTKH,X
C0711:
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 C0710
:
INC ESTKL,X
BNE :+
INC ESTKH,X
:
; 2578: 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 C0712
:
; 2579: break
JMP C0710
; 2580: fin
C0712:
C0713:
; 2581: next
JMP C0711
C0710:
; 2582: 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 C0714
:
; 2583: return idptr
DEX
LDY #$06
LDA (FRMP),Y
STA ESTKL,X
INY
LDA (FRMP),Y
STA ESTKH,X
JMP LEAVE
; 2584: fin
C0714:
C0715:
; 2585: fin
C0708:
C0709:
; 2586: 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
; 2587: 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
; 2588: loop
INX
JMP C0706
C0707:
; 2589: return 0
DEX
LDY #$00
STY ESTKL,X
STY ESTKH,X
JMP LEAVE
; 2590: end
; 2591: ;def dumpsym_20(idptr, idcnt)
; 2592: ; while idcnt
; 2593: ; prword_10((idptr):idval)
; 2594: ; cout(' ')
; 2595: ; prbyte_10((idptr).idtype)
; 2596: ; cout(' ')
; 2597: ; prstr(@(idptr).idname)
; 2598: ; cout('=')
; 2599: ; if (idptr).idtype & ADDR_TYPE
; 2600: ; if (idptr):idval & is_ctag
; 2601: ; prword_10(ctag_value:[(idptr):idval & mask_ctag])
; 2602: ; else
; 2603: ; prword_10((idptr):idval + codebuff)
; 2604: ; fin
; 2605: ; else
; 2606: ; prword_10((idptr):idval)
; 2607: ; fin
; 2608: ; crout()
; 2609: ; idptr = idptr + (idptr).idname + idrecsz
; 2610: ; idcnt = idcnt - 1
; 2611: ; loop
; 2612: ;end
; 2613: def id_lookup_21(nameptr, len)
C0716: ; id_lookup_21()
; nameptr = 2
; len = 4
; 2614: word idptr
; idptr = 6
; 2615:
; 2616: 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,$1E ; CW 7680
DB $68,<D0483,>D0483 ; LAB D0483
DB $54,<C0704,>C0704 ; CALL C0704
DB $76,$06 ; SLW 6
; 2617: if idptr
DB $66,$06 ; LLW 6
DB $4C,<C0718,>C0718 ; SKPFLS C0718
; 2618: return idptr
DB $66,$06 ; LLW 6
DB $5A ; LEAVE
; 2619: fin
C0718:
C0719:
; 2620: idptr = idmatch_41(nameptr, len, idglobal_tbl, globals)
DB $66,$02 ; LLW 2
DB $66,$04 ; LLW 4
DB $2C,$00,$16 ; CW 5632
DB $6A,<D0477,>D0477 ; LAW D0477
DB $54,<C0704,>C0704 ; CALL C0704
DB $76,$06 ; SLW 6
; 2621: if idptr
DB $66,$06 ; LLW 6
DB $4C,<C0720,>C0720 ; SKPFLS C0720
; 2622: return idptr
DB $66,$06 ; LLW 6
DB $5A ; LEAVE
; 2623: fin
C0720:
C0721:
; 2624: return parse_err_11(@undecl_id)
DB $26,<D0559,>D0559 ; LA D0559
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2625: end
; 2626: def idglobal_lookup_21(nameptr, len)
C0722: ; idglobal_lookup_21()
; nameptr = 2
; len = 4
; 2627: 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,$16 ; CW 5632
DB $6A,<D0477,>D0477 ; LAW D0477
DB $54,<C0704,>C0704 ; CALL C0704
DB $5A ; LEAVE
; 2628: end
; 2629: def idlocal_add_41(namestr, len, type, size)
C0724: ; idlocal_add_41()
; namestr = 2
; len = 4
; type = 6
; size = 8
; 2630: 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,$1E ; CW 7680
DB $68,<D0483,>D0483 ; LAB D0483
DB $54,<C0704,>C0704 ; CALL C0704
DB $4C,<C0726,>C0726 ; SKPFLS C0726
; 2631: return parse_err_11(@dup_id)
DB $26,<D0538,>D0538 ; LA D0538
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2632: fin
C0726:
C0727:
; 2633: (lastlocal):idval = framesize
DB $6A,<D0486,>D0486 ; LAW D0486
DB $6A,<D0484,>D0484 ; LAW D0484
DB $72 ; SW
; 2634: (lastlocal).idtype = type ? LOCAL_TYPE
DB $6A,<D0486,>D0486 ; LAW D0486
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $66,$06 ; LLW 6
DB $2A,$10 ; CB 16
DB $16 ; IOR
DB $70 ; SB
; 2635: nametostr_30(namestr, len, lastlocal + idname)
DB $66,$02 ; LLW 2
DB $66,$04 ; LLW 4
DB $6A,<D0486,>D0486 ; LAW D0486
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $54,<C0125,>C0125 ; CALL C0125
; 2636: locals = locals + 1
DB $68,<D0483,>D0483 ; LAB D0483
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D0483,>D0483 ; SAB D0483
; 2637: lastlocal = lastlocal + idrecsz + len
DB $6A,<D0486,>D0486 ; LAW D0486
DB $2A,$04 ; CB 4
DB $02 ; ADD
DB $66,$04 ; LLW 4
DB $02 ; ADD
DB $7A,<D0486,>D0486 ; SAW D0486
; 2638: if lastlocal > idlocal_tbl + idlocal_tblsz
DB $6A,<D0486,>D0486 ; LAW D0486
DB $2C,$00,$1E ; CW 7680
DB $2C,$00,$02 ; CW 512
DB $02 ; ADD
DB $44 ; ISGT
DB $4C,<C0728,>C0728 ; SKPFLS C0728
; 2639: prstr(@local_sym_overflw)
DB $26,<D0772,>D0772 ; LA D0772
DB $54,<C0019,>C0019 ; CALL C0019
; 2640: exit
DB $54,<C0023,>C0023 ; CALL C0023
; 2641: fin
C0728:
C0729:
; 2642: framesize = framesize + size
DB $6A,<D0484,>D0484 ; LAW D0484
DB $66,$08 ; LLW 8
DB $02 ; ADD
DB $7A,<D0484,>D0484 ; SAW D0484
; 2643: if framesize > 255
DB $6A,<D0484,>D0484 ; LAW D0484
DB $2A,$FF ; CB 255
DB $44 ; ISGT
DB $4C,<C0730,>C0730 ; SKPFLS C0730
; 2644: prstr(@local_overflw)
DB $26,<D0722,>D0722 ; LA D0722
DB $54,<C0019,>C0019 ; CALL C0019
; 2645: return FALSE
DB $00 ; ZERO
DB $5A ; LEAVE
; 2646: fin
C0730:
C0731:
; 2647: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 2648: end
; 2649: def iddata_add_41(namestr, len, type, size)
C0732: ; iddata_add_41()
; namestr = 2
; len = 4
; type = 6
; size = 8
; 2650: 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,$16 ; CW 5632
DB $6A,<D0477,>D0477 ; LAW D0477
DB $54,<C0704,>C0704 ; CALL C0704
DB $4C,<C0734,>C0734 ; SKPFLS C0734
; 2651: return parse_err_11(@dup_id)
DB $26,<D0538,>D0538 ; LA D0538
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2652: fin
C0734:
C0735:
; 2653: (lastglobal):idval = datasize
DB $6A,<D0481,>D0481 ; LAW D0481
DB $6A,<D0479,>D0479 ; LAW D0479
DB $72 ; SW
; 2654: (lastglobal).idtype = type
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $66,$06 ; LLW 6
DB $70 ; SB
; 2655: nametostr_30(namestr, len, lastglobal + idname)
DB $66,$02 ; LLW 2
DB $66,$04 ; LLW 4
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $54,<C0125,>C0125 ; CALL C0125
; 2656: emit_iddata_30(datasize, size, lastglobal + idname)
DB $6A,<D0479,>D0479 ; LAW D0479
DB $66,$08 ; LLW 8
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $54,<C0471,>C0471 ; CALL C0471
; 2657: globals = globals + 1
DB $6A,<D0477,>D0477 ; LAW D0477
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0477,>D0477 ; SAW D0477
; 2658: lastglobal = lastglobal + idrecsz + len
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$04 ; CB 4
DB $02 ; ADD
DB $66,$04 ; LLW 4
DB $02 ; ADD
DB $7A,<D0481,>D0481 ; SAW D0481
; 2659: if lastglobal > idglobal_tbl + idglobal_tblsz
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2C,$00,$16 ; CW 5632
DB $2C,$00,$08 ; CW 2048
DB $02 ; ADD
DB $44 ; ISGT
DB $4C,<C0736,>C0736 ; SKPFLS C0736
; 2660: prstr(@global_sym_overflw)
DB $26,<D0743,>D0743 ; LA D0743
DB $54,<C0019,>C0019 ; CALL C0019
; 2661: exit
DB $54,<C0023,>C0023 ; CALL C0023
; 2662: fin
C0736:
C0737:
; 2663: datasize = datasize + size
DB $6A,<D0479,>D0479 ; LAW D0479
DB $66,$08 ; LLW 8
DB $02 ; ADD
DB $7A,<D0479,>D0479 ; SAW D0479
; 2664: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 2665: end
; 2666: def iddata_size_30(type, varsize, initsize)
C0738: ; iddata_size_30()
; type = 2
; varsize = 4
; initsize = 6
; 2667: 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,<C0740,>C0740 ; SKPFLS C0740
; 2668: datasize = datasize + emit_data_41(0, 0, 0, varsize - initsize)
DB $6A,<D0479,>D0479 ; LAW D0479
DB $00 ; ZERO
DB $00 ; ZERO
DB $00 ; ZERO
DB $66,$04 ; LLW 4
DB $66,$06 ; LLW 6
DB $04 ; SUB
DB $54,<C0473,>C0473 ; CALL C0473
DB $02 ; ADD
DB $7A,<D0479,>D0479 ; SAW D0479
; 2669: else
DB $50,<C0741,>C0741 ; SKIP C0741
C0740:
; 2670: datasize = datasize + initsize
DB $6A,<D0479,>D0479 ; LAW D0479
DB $66,$06 ; LLW 6
DB $02 ; ADD
DB $7A,<D0479,>D0479 ; SAW D0479
; 2671: fin
C0741:
; 2672: ; if datasize <> codeptr - codebuff
; 2673: ; prstr(@emiterr)
; 2674: ; keyin_01()
; 2675: ; fin
; 2676: end
DB $5A ; LEAVE
; 2677: def idglobal_add_41(namestr, len, type, value)
C0742: ; idglobal_add_41()
; namestr = 2
; len = 4
; type = 6
; value = 8
; 2678: 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,$16 ; CW 5632
DB $6A,<D0477,>D0477 ; LAW D0477
DB $54,<C0704,>C0704 ; CALL C0704
DB $4C,<C0744,>C0744 ; SKPFLS C0744
; 2679: return parse_err_11(@dup_id)
DB $26,<D0538,>D0538 ; LA D0538
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2680: fin
C0744:
C0745:
; 2681: (lastglobal):idval = value
DB $6A,<D0481,>D0481 ; LAW D0481
DB $66,$08 ; LLW 8
DB $72 ; SW
; 2682: (lastglobal).idtype = type
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $66,$06 ; LLW 6
DB $70 ; SB
; 2683: nametostr_30(namestr, len, lastglobal + idname)
DB $66,$02 ; LLW 2
DB $66,$04 ; LLW 4
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$03 ; CB 3
DB $02 ; ADD
DB $54,<C0125,>C0125 ; CALL C0125
; 2684: globals = globals + 1
DB $6A,<D0477,>D0477 ; LAW D0477
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $7A,<D0477,>D0477 ; SAW D0477
; 2685: lastglobal = lastglobal + idrecsz + len
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2A,$04 ; CB 4
DB $02 ; ADD
DB $66,$04 ; LLW 4
DB $02 ; ADD
DB $7A,<D0481,>D0481 ; SAW D0481
; 2686: if lastglobal > idglobal_tbl + idglobal_tblsz
DB $6A,<D0481,>D0481 ; LAW D0481
DB $2C,$00,$16 ; CW 5632
DB $2C,$00,$08 ; CW 2048
DB $02 ; ADD
DB $44 ; ISGT
DB $4C,<C0746,>C0746 ; SKPFLS C0746
; 2687: prstr(@global_sym_overflw)
DB $26,<D0743,>D0743 ; LA D0743
DB $54,<C0019,>C0019 ; CALL C0019
; 2688: exit
DB $54,<C0023,>C0023 ; CALL C0023
; 2689: fin
C0746:
C0747:
; 2690: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 2691: end
; 2692: def idfunc_add_31(namestr, len, tag)
C0748: ; idfunc_add_31()
; namestr = 2
; len = 4
; tag = 6
; 2693: 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,<C0742,>C0742 ; CALL C0742
DB $5A ; LEAVE
; 2694: end
; 2695: def idconst_add_31(namestr, len, value)
C0750: ; idconst_add_31()
; namestr = 2
; len = 4
; value = 6
; 2696: 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,<C0742,>C0742 ; CALL C0742
DB $5A ; LEAVE
; 2697: end
; 2698: def idglobal_init
C0752: ; idglobal_init()
; 2699: word ctag
; ctag = 2
; 2700:
; 2701: lineno = 0
JSR INTERP
DB $58,$04,$00 ; ENTER 4,0
DB $00 ; ZERO
DB $7A,<D0507,>D0507 ; SAW D0507
; 2702: parserr = 0
DB $00 ; ZERO
DB $78,<D0498,>D0498 ; SAB D0498
; 2703: codeptr = codebuff
DB $2C,$00,$A8 ; CW 43008
DB $7A,<D0490,>D0490 ; SAW D0490
; 2704: lastop = $FF
DB $2A,$FF ; CB 255
DB $78,<D0494,>D0494 ; SAB D0494
; 2705: entrypoint = 0
DB $00 ; ZERO
DB $7A,<D0492,>D0492 ; SAW D0492
; 2706: datasize = 0
DB $00 ; ZERO
DB $7A,<D0479,>D0479 ; SAW D0479
; 2707: globals = 0
DB $00 ; ZERO
DB $7A,<D0477,>D0477 ; SAW D0477
; 2708: lastglobal = idglobal_tbl
DB $2C,$00,$16 ; CW 5632
DB $7A,<D0481,>D0481 ; SAW D0481
; 2709: codetag = -1
DB $2C,$FF,$FF ; CW -1
DB $7A,<D0488,>D0488 ; SAW D0488
; 2710: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2711: drop idfunc_add_31(@runtime0 + 1, runtime0, ctag)
DB $26,<D1000,>D1000 ; LA D1000
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1000,>D1000 ; LAB D1000
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2712: drop idfunc_add_31(@RUNTIME0 + 1, RUNTIME0, ctag)
DB $26,<D1008,>D1008 ; LA D1008
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1008,>D1008 ; LAB D1008
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2713: drop ctag_resolve_21(ctag, @romcall)
DB $66,$02 ; LLW 2
DB $26,<C0007,>C0007 ; LA C0007
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2714: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2715: drop idfunc_add_31(@runtime1 + 1, runtime1, ctag)
DB $26,<D1016,>D1016 ; LA D1016
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1016,>D1016 ; LAB D1016
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2716: drop idfunc_add_31(@RUNTIME1 + 1, RUNTIME1, ctag)
DB $26,<D1024,>D1024 ; LA D1024
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1024,>D1024 ; LAB D1024
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2717: drop ctag_resolve_21(ctag, @syscall)
DB $66,$02 ; LLW 2
DB $26,<C0009,>C0009 ; LA C0009
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2718: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2719: drop idfunc_add_31(@runtime2 + 1, runtime2, ctag)
DB $26,<D1032,>D1032 ; LA D1032
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1032,>D1032 ; LAB D1032
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2720: drop idfunc_add_31(@RUNTIME2 + 1, RUNTIME2, ctag)
DB $26,<D1039,>D1039 ; LA D1039
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1039,>D1039 ; LAB D1039
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2721: drop ctag_resolve_21(ctag, @memset)
DB $66,$02 ; LLW 2
DB $26,<C0011,>C0011 ; LA C0011
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2722: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2723: drop idfunc_add_31(@runtime3 + 1, runtime3, ctag)
DB $26,<D1046,>D1046 ; LA D1046
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1046,>D1046 ; LAB D1046
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2724: drop idfunc_add_31(@RUNTIME3 + 1, RUNTIME3, ctag)
DB $26,<D1053,>D1053 ; LA D1053
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1053,>D1053 ; LAB D1053
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2725: drop ctag_resolve_21(ctag, @memcpy)
DB $66,$02 ; LLW 2
DB $26,<C0013,>C0013 ; LA C0013
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2726: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2727: drop idfunc_add_31(@runtime4 + 1, runtime4, ctag)
DB $26,<D1060,>D1060 ; LA D1060
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1060,>D1060 ; LAB D1060
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2728: drop idfunc_add_31(@RUNTIME4 + 1, RUNTIME4, ctag)
DB $26,<D1065,>D1065 ; LA D1065
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1065,>D1065 ; LAB D1065
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2729: drop ctag_resolve_21(ctag, @cout)
DB $66,$02 ; LLW 2
DB $26,<C0015,>C0015 ; LA C0015
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2730: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2731: drop idfunc_add_31(@runtime5 + 1, runtime5, ctag)
DB $26,<D1070,>D1070 ; LA D1070
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1070,>D1070 ; LAB D1070
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2732: drop idfunc_add_31(@RUNTIME5 + 1, RUNTIME5, ctag)
DB $26,<D1074,>D1074 ; LA D1074
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1074,>D1074 ; LAB D1074
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2733: drop ctag_resolve_21(ctag, @cin)
DB $66,$02 ; LLW 2
DB $26,<C0017,>C0017 ; LA C0017
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2734: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2735: drop idfunc_add_31(@runtime6 + 1, runtime6, ctag)
DB $26,<D1078,>D1078 ; LA D1078
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1078,>D1078 ; LAB D1078
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2736: drop idfunc_add_31(@RUNTIME6 + 1, RUNTIME6, ctag)
DB $26,<D1084,>D1084 ; LA D1084
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1084,>D1084 ; LAB D1084
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2737: drop ctag_resolve_21(ctag, @prstr)
DB $66,$02 ; LLW 2
DB $26,<C0019,>C0019 ; LA C0019
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2738: ctag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$02 ; SLW 2
; 2739: drop idfunc_add_31(@runtime7 + 1, runtime7, ctag)
DB $26,<D1090,>D1090 ; LA D1090
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1090,>D1090 ; LAB D1090
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2740: drop idfunc_add_31(@RUNTIME7 + 1, RUNTIME7, ctag)
DB $26,<D1096,>D1096 ; LA D1096
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $68,<D1096,>D1096 ; LAB D1096
DB $66,$02 ; LLW 2
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 2741: drop ctag_resolve_21(ctag, @rdstr)
DB $66,$02 ; LLW 2
DB $26,<C0021,>C0021 ; LA C0021
DB $54,<C0449,>C0449 ; CALL C0449
DB $30 ; DROP
; 2742: end
DB $5A ; LEAVE
; 2743: def idlocal_init
C0754: ; idlocal_init()
; 2744: locals = 0
JSR INTERP
DB $00 ; ZERO
DB $78,<D0483,>D0483 ; SAB D0483
; 2745: framesize = 2
DB $2A,$02 ; CB 2
DB $7A,<D0484,>D0484 ; SAW D0484
; 2746: lastlocal = idlocal_tbl
DB $2C,$00,$1E ; CW 7680
DB $7A,<D0486,>D0486 ; SAW D0486
; 2747: end
DB $5C ; RET
; 2748: ;
; 2749: ; Parser
; 2750: ;
; 2751: def parse_term_01
C0756: ; parse_term_01()
; 2752: when scan_01()
JSR INTERP
DB $54,<C0629,>C0629 ; CALL C0629
; 2753: is ID_TKN
DB $2A,$D6 ; CB 214
DB $3E,<C0759,>C0759 ; SKPNE C0759
; 2754: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2755: is INT_TKN
DB $50,<C0758,>C0758 ; SKIP C0758
C0759:
DB $2A,$C9 ; CB 201
DB $3E,<C0760,>C0760 ; SKPNE C0760
; 2756: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2757: is CHR_TKN
DB $50,<C0758,>C0758 ; SKIP C0758
C0760:
DB $2A,$C3 ; CB 195
DB $3E,<C0761,>C0761 ; SKPNE C0761
; 2758: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2759: is STR_TKN
DB $50,<C0758,>C0758 ; SKIP C0758
C0761:
DB $2A,$D3 ; CB 211
DB $3E,<C0762,>C0762 ; SKPNE C0762
; 2760: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2761: is OPEN_PAREN_TKN
DB $50,<C0758,>C0758 ; SKIP C0758
C0762:
DB $2A,$A8 ; CB 168
DB $3E,<C0763,>C0763 ; SKPNE C0763
; 2762: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C0764,>C0764 ; SKPFLS C0764
; 2763: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5C ; RET
; 2764: fin
C0764:
C0765:
; 2765: if token <> CLOSE_PAREN_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$A9 ; CB 169
DB $42 ; ISNE
DB $4C,<C0766,>C0766 ; SKPFLS C0766
; 2766: return parse_err_11(@no_close_paren)
DB $30 ; DROP
DB $26,<D0820,>D0820 ; LA D0820
DB $54,<C0441,>C0441 ; CALL C0441
DB $5C ; RET
; 2767: fin
C0766:
C0767:
; 2768: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2769: wend
DB $50,<C0758,>C0758 ; SKIP C0758
C0763:
C0758:
DB $30 ; DROP
; 2770: return FALSE
DB $00 ; ZERO
DB $5C ; RET
; 2771: end
; 2772: def parse_constval_21(valptr, sizeptr)
C0769: ; parse_constval_21()
; valptr = 2
; sizeptr = 4
; 2773: byte mod, type
; mod = 6
; type = 7
; 2774: word idptr
; idptr = 8
; 2775:
; 2776: mod = 0
JSR INTERP
DB $58,$0A,$02 ; ENTER 10,2
DB $00 ; ZERO
DB $74,$06 ; SLB 6
; 2777: type = 0
DB $00 ; ZERO
DB $74,$07 ; SLB 7
; 2778: *valptr = 0
DB $66,$02 ; LLW 2
DB $00 ; ZERO
DB $72 ; SW
; 2779: while !parse_term_01()
C0771:
DB $54,<C0756,>C0756 ; CALL C0756
DB $20 ; NOT
DB $4C,<C0772,>C0772 ; SKPFLS C0772
; 2780: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 2781: is SUB_TKN
DB $2A,$AD ; CB 173
DB $3E,<C0774,>C0774 ; SKPNE C0774
; 2782: mod = mod ? 1
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2783: is COMP_TKN
DB $50,<C0773,>C0773 ; SKIP C0773
C0774:
DB $2A,$A3 ; CB 163
DB $3E,<C0775,>C0775 ; SKPNE C0775
; 2784: mod = mod ? 2
DB $64,$06 ; LLB 6
DB $2A,$02 ; CB 2
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2785: is LOGIC_NOT_TKN
DB $50,<C0773,>C0773 ; SKIP C0773
C0775:
DB $2A,$A1 ; CB 161
DB $3E,<C0776,>C0776 ; SKPNE C0776
; 2786: mod = mod ? 4
DB $64,$06 ; LLB 6
DB $2A,$04 ; CB 4
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2787: is AT_TKN
DB $50,<C0773,>C0773 ; SKIP C0773
C0776:
DB $2A,$C0 ; CB 192
DB $3E,<C0777,>C0777 ; SKPNE C0777
; 2788: mod = mod ? 8
DB $64,$06 ; LLB 6
DB $2A,$08 ; CB 8
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2789: otherwise
DB $50,<C0773,>C0773 ; SKIP C0773
C0777:
; 2790: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 2791: wend
C0773:
DB $30 ; DROP
; 2792: loop
DB $50,<C0771,>C0771 ; SKIP C0771
C0772:
; 2793: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 2794: is STR_TKN
DB $2A,$D3 ; CB 211
DB $3E,<C0780,>C0780 ; SKPNE C0780
; 2795: *valptr = constval
DB $66,$02 ; LLW 2
DB $6A,<D0505,>D0505 ; LAW D0505
DB $72 ; SW
; 2796: ^sizeptr = tknlen - 1
DB $66,$04 ; LLW 4
DB $68,<D0496,>D0496 ; LAB D0496
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $70 ; SB
; 2797: type = STR_TYPE
DB $2A,$80 ; CB 128
DB $74,$07 ; SLB 7
; 2798: if mod
DB $64,$06 ; LLB 6
DB $4C,<C0781,>C0781 ; SKPFLS C0781
; 2799: return parse_err_11(@bad_op)
DB $30 ; DROP
DB $26,<D0628,>D0628 ; LA D0628
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2800: fin
C0781:
C0782:
; 2801: is CHR_TKN
DB $50,<C0779,>C0779 ; SKIP C0779
C0780:
DB $2A,$C3 ; CB 195
DB $3E,<C0783,>C0783 ; SKPNE C0783
; 2802: *valptr = constval
DB $66,$02 ; LLW 2
DB $6A,<D0505,>D0505 ; LAW D0505
DB $72 ; SW
; 2803: ^sizeptr = 1
DB $66,$04 ; LLW 4
DB $2A,$01 ; CB 1
DB $70 ; SB
; 2804: type = BYTE_TYPE
DB $2A,$02 ; CB 2
DB $74,$07 ; SLB 7
; 2805: is INT_TKN
DB $50,<C0779,>C0779 ; SKIP C0779
C0783:
DB $2A,$C9 ; CB 201
DB $3E,<C0784,>C0784 ; SKPNE C0784
; 2806: *valptr = constval
DB $66,$02 ; LLW 2
DB $6A,<D0505,>D0505 ; LAW D0505
DB $72 ; SW
; 2807: ^sizeptr = 2
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $70 ; SB
; 2808: type = WORD_TYPE
DB $2A,$04 ; CB 4
DB $74,$07 ; SLB 7
; 2809: is ID_TKN
DB $50,<C0779,>C0779 ; SKIP C0779
C0784:
DB $2A,$D6 ; CB 214
DB $3E,<C0785,>C0785 ; SKPNE C0785
; 2810: ^sizeptr = 2
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $70 ; SB
; 2811: idptr = id_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0716,>C0716 ; CALL C0716
DB $76,$08 ; SLW 8
; 2812: if !idptr
DB $66,$08 ; LLW 8
DB $20 ; NOT
DB $4C,<C0786,>C0786 ; SKPFLS C0786
; 2813: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2814: fin
C0786:
C0787:
; 2815: type = (idptr).idtype
DB $66,$08 ; LLW 8
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $74,$07 ; SLB 7
; 2816: *valptr = (idptr):idval
DB $66,$02 ; LLW 2
DB $66,$08 ; LLW 8
DB $62 ; LW
DB $72 ; SW
; 2817: 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,<C0788,>C0788 ; SKPFLS C0788
; 2818: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2819: fin
C0788:
C0789:
; 2820: otherwise
DB $50,<C0779,>C0779 ; SKIP C0779
C0785:
; 2821: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2822: wend
C0779:
DB $30 ; DROP
; 2823: if mod & 1
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0791,>C0791 ; SKPFLS C0791
; 2824: *valptr = -*valptr
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $62 ; LW
DB $10 ; NEG
DB $72 ; SW
; 2825: fin
C0791:
C0792:
; 2826: if mod & 2
DB $64,$06 ; LLB 6
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0793,>C0793 ; SKPFLS C0793
; 2827: *valptr = #*valptr
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $62 ; LW
DB $12 ; COMP
DB $72 ; SW
; 2828: fin
C0793:
C0794:
; 2829: if mod & 4
DB $64,$06 ; LLB 6
DB $2A,$04 ; CB 4
DB $14 ; BAND
DB $4C,<C0795,>C0795 ; SKPFLS C0795
; 2830: *valptr = !*valptr
DB $66,$02 ; LLW 2
DB $66,$02 ; LLW 2
DB $62 ; LW
DB $20 ; NOT
DB $72 ; SW
; 2831: fin
C0795:
C0796:
; 2832: return type
DB $64,$07 ; LLB 7
DB $5A ; LEAVE
; 2833: end
; 2834: def ispostop_01
C0797: ; ispostop_01()
; 2835: when token
JSR INTERP
DB $68,<D0495,>D0495 ; LAB D0495
; 2836: is OPEN_PAREN_TKN
DB $2A,$A8 ; CB 168
DB $3E,<C0800,>C0800 ; SKPNE C0800
; 2837: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2838: is OPEN_BRACKET_TKN
DB $50,<C0799,>C0799 ; SKIP C0799
C0800:
DB $2A,$DB ; CB 219
DB $3E,<C0801,>C0801 ; SKPNE C0801
; 2839: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2840: is DOT_TKN
DB $50,<C0799,>C0799 ; SKIP C0799
C0801:
DB $2A,$AE ; CB 174
DB $3E,<C0802,>C0802 ; SKPNE C0802
; 2841: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2842: is COLON_TKN
DB $50,<C0799,>C0799 ; SKIP C0799
C0802:
DB $2A,$BA ; CB 186
DB $3E,<C0803,>C0803 ; SKPNE C0803
; 2843: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 2844: wend
DB $50,<C0799,>C0799 ; SKIP C0799
C0803:
C0799:
DB $30 ; DROP
; 2845: return FALSE
DB $00 ; ZERO
DB $5C ; RET
; 2846: end
; 2847: def parse_value_11(rvalue)
C0805: ; parse_value_11()
; rvalue = 2
; 2848: byte cparams, deref, type, emit_val
; cparams = 4
; deref = 5
; type = 6
; emit_val = 7
; 2849: word optos, idptr, value
; optos = 8
; idptr = 10
; value = 12
; 2850: byte elem_type, elem_size
; elem_type = 14
; elem_size = 15
; 2851: word elem_offset
; elem_offset = 16
; 2852:
; 2853: deref = rvalue
JSR INTERP
DB $58,$12,$01 ; ENTER 18,1
DB $66,$02 ; LLW 2
DB $74,$05 ; SLB 5
; 2854: optos = opsp
DB $6A,<D0475,>D0475 ; LAW D0475
DB $76,$08 ; SLW 8
; 2855: type = 0
DB $00 ; ZERO
DB $74,$06 ; SLB 6
; 2856: emit_val = 0
DB $00 ; ZERO
DB $74,$07 ; SLB 7
; 2857: value = 0
DB $00 ; ZERO
DB $76,$0C ; SLW 12
; 2858:
; 2859: ;
; 2860: ; Parse pre-ops
; 2861: ;
; 2862: while !parse_term_01()
C0807:
DB $54,<C0756,>C0756 ; CALL C0756
DB $20 ; NOT
DB $4C,<C0808,>C0808 ; SKPFLS C0808
; 2863: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 2864: is ADD_TKN
DB $2A,$AB ; CB 171
DB $3E,<C0810,>C0810 ; SKPNE C0810
; 2865: is BPTR_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0810:
DB $2A,$DE ; CB 222
DB $3E,<C0811,>C0811 ; SKPNE C0811
; 2866: if deref
DB $64,$05 ; LLB 5
DB $4C,<C0812,>C0812 ; SKPFLS C0812
; 2867: drop push_op_21(token, 0)
DB $68,<D0495,>D0495 ; LAB D0495
DB $00 ; ZERO
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 2868: else
DB $50,<C0813,>C0813 ; SKIP C0813
C0812:
; 2869: type = type ? BPTR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$20 ; CB 32
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2870: deref = deref + 1
DB $64,$05 ; LLB 5
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$05 ; SLB 5
; 2871: fin
C0813:
; 2872: is WPTR_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0811:
DB $2A,$AA ; CB 170
DB $3E,<C0814,>C0814 ; SKPNE C0814
; 2873: if deref
DB $64,$05 ; LLB 5
DB $4C,<C0815,>C0815 ; SKPFLS C0815
; 2874: drop push_op_21(token, 0)
DB $68,<D0495,>D0495 ; LAB D0495
DB $00 ; ZERO
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 2875: else
DB $50,<C0816,>C0816 ; SKIP C0816
C0815:
; 2876: type = type ? WPTR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$40 ; CB 64
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2877: deref = deref + 1
DB $64,$05 ; LLB 5
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$05 ; SLB 5
; 2878: fin
C0816:
; 2879: is AT_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0814:
DB $2A,$C0 ; CB 192
DB $3E,<C0817,>C0817 ; SKPNE C0817
; 2880: deref = deref - 1
DB $64,$05 ; LLB 5
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $74,$05 ; SLB 5
; 2881: is SUB_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0817:
DB $2A,$AD ; CB 173
DB $3E,<C0818,>C0818 ; SKPNE C0818
; 2882: drop push_op_21(token, 0)
DB $68,<D0495,>D0495 ; LAB D0495
DB $00 ; ZERO
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 2883: is COMP_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0818:
DB $2A,$A3 ; CB 163
DB $3E,<C0819,>C0819 ; SKPNE C0819
; 2884: drop push_op_21(token, 0)
DB $68,<D0495,>D0495 ; LAB D0495
DB $00 ; ZERO
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 2885: is LOGIC_NOT_TKN
DB $50,<C0809,>C0809 ; SKIP C0809
C0819:
DB $2A,$A1 ; CB 161
DB $3E,<C0820,>C0820 ; SKPNE C0820
; 2886: drop push_op_21(token, 0)
DB $68,<D0495,>D0495 ; LAB D0495
DB $00 ; ZERO
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 2887: otherwise
DB $50,<C0809,>C0809 ; SKIP C0809
C0820:
; 2888: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 2889: wend
C0809:
DB $30 ; DROP
; 2890: loop
DB $50,<C0807,>C0807 ; SKIP C0807
C0808:
; 2891: ;
; 2892: ; Determine terminal type
; 2893: ;
; 2894: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 2895: is INT_TKN
DB $2A,$C9 ; CB 201
DB $3E,<C0823,>C0823 ; SKPNE C0823
; 2896: type = type ? CONST_TYPE
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2897: value = constval
DB $6A,<D0505,>D0505 ; LAW D0505
DB $76,$0C ; SLW 12
; 2898: is CHR_TKN
DB $50,<C0822,>C0822 ; SKIP C0822
C0823:
DB $2A,$C3 ; CB 195
DB $3E,<C0824,>C0824 ; SKPNE C0824
; 2899: type = type ? CONST_TYPE
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2900: value = constval
DB $6A,<D0505,>D0505 ; LAW D0505
DB $76,$0C ; SLW 12
; 2901: is ID_TKN
DB $50,<C0822,>C0822 ; SKIP C0822
C0824:
DB $2A,$D6 ; CB 214
DB $3E,<C0825,>C0825 ; SKPNE C0825
; 2902: idptr = id_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0716,>C0716 ; CALL C0716
DB $76,$0A ; SLW 10
; 2903: if !idptr
DB $66,$0A ; LLW 10
DB $20 ; NOT
DB $4C,<C0826,>C0826 ; SKPFLS C0826
; 2904: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 2905: fin
C0826:
C0827:
; 2906: if !(idptr).idtype
DB $66,$0A ; LLW 10
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $20 ; NOT
DB $4C,<C0828,>C0828 ; SKPFLS C0828
; 2907: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 2908: fin
C0828:
C0829:
; 2909: 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
; 2910: value = (idptr):idval
DB $66,$0A ; LLW 10
DB $62 ; LW
DB $76,$0C ; SLW 12
; 2911: is CLOSE_PAREN_TKN
DB $50,<C0822,>C0822 ; SKIP C0822
C0825:
DB $2A,$A9 ; CB 169
DB $3E,<C0830,>C0830 ; SKPNE C0830
; 2912: type = type ? WORD_TYPE
DB $64,$06 ; LLB 6
DB $2A,$04 ; CB 4
DB $16 ; IOR
DB $74,$06 ; SLB 6
; 2913: emit_val = 1
DB $2A,$01 ; CB 1
DB $74,$07 ; SLB 7
; 2914: otherwise
DB $50,<C0822,>C0822 ; SKIP C0822
C0830:
; 2915: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 2916: wend
C0822:
DB $30 ; DROP
; 2917: ;
; 2918: ; Constant optimizations
; 2919: ;
; 2920: if type & CONST_TYPE
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0832,>C0832 ; SKPFLS C0832
; 2921: cparams = TRUE
DB $2C,$FF,$FF ; CW -1
DB $74,$04 ; SLB 4
; 2922: while optos < opsp and cparams
C0834:
DB $66,$08 ; LLW 8
DB $6A,<D0475,>D0475 ; LAW D0475
DB $46 ; ISLT
DB $64,$04 ; LLB 4
DB $24 ; LAND
DB $4C,<C0835,>C0835 ; SKPFLS C0835
; 2923: when tos_op_01()
DB $54,<C0696,>C0696 ; CALL C0696
; 2924: is NEG_TKN
DB $2A,$AD ; CB 173
DB $3E,<C0837,>C0837 ; SKPNE C0837
; 2925: drop pop_op_01()
DB $54,<C0692,>C0692 ; CALL C0692
DB $30 ; DROP
; 2926: value = -value
DB $66,$0C ; LLW 12
DB $10 ; NEG
DB $76,$0C ; SLW 12
; 2927: is COMP_TKN
DB $50,<C0836,>C0836 ; SKIP C0836
C0837:
DB $2A,$A3 ; CB 163
DB $3E,<C0838,>C0838 ; SKPNE C0838
; 2928: drop pop_op_01()
DB $54,<C0692,>C0692 ; CALL C0692
DB $30 ; DROP
; 2929: value = #value
DB $66,$0C ; LLW 12
DB $12 ; COMP
DB $76,$0C ; SLW 12
; 2930: is LOGIC_NOT_TKN
DB $50,<C0836,>C0836 ; SKIP C0836
C0838:
DB $2A,$A1 ; CB 161
DB $3E,<C0839,>C0839 ; SKPNE C0839
; 2931: drop pop_op_01()
DB $54,<C0692,>C0692 ; CALL C0692
DB $30 ; DROP
; 2932: value = !value
DB $66,$0C ; LLW 12
DB $20 ; NOT
DB $76,$0C ; SLW 12
; 2933: otherwise
DB $50,<C0836,>C0836 ; SKIP C0836
C0839:
; 2934: cparams = FALSE
DB $00 ; ZERO
DB $74,$04 ; SLB 4
; 2935: wend
C0836:
DB $30 ; DROP
; 2936: loop
DB $50,<C0834,>C0834 ; SKIP C0834
C0835:
; 2937: fin
C0832:
C0833:
; 2938: ;
; 2939: ; Parse post-ops
; 2940: ;
; 2941: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 2942: while ispostop_01()
C0841:
DB $54,<C0797,>C0797 ; CALL C0797
DB $4C,<C0842,>C0842 ; SKPFLS C0842
; 2943: if token == OPEN_BRACKET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$DB ; CB 219
DB $40 ; ISEQ
DB $4C,<C0843,>C0843 ; SKPFLS C0843
; 2944: ;
; 2945: ; Array
; 2946: ;
; 2947: if !emit_val
DB $64,$07 ; LLB 7
DB $20 ; NOT
DB $4C,<C0845,>C0845 ; SKPFLS C0845
; 2948: if type & ADDR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$0E ; CB 14
DB $14 ; BAND
DB $4C,<C0847,>C0847 ; SKPFLS C0847
; 2949: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0849,>C0849 ; SKPFLS C0849
; 2950: emit_localaddr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0529,>C0529 ; CALL C0529
; 2951: else
DB $50,<C0850,>C0850 ; SKIP C0850
C0849:
; 2952: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 2953: fin
C0850:
; 2954: elsif type & CONST_TYPE
DB $50,<C0848,>C0848 ; SKIP C0848
C0847:
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0851,>C0851 ; SKPFLS C0851
; 2955: emit_const_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0482,>C0482 ; CALL C0482
; 2956: fin
C0851:
C0848:
; 2957: emit_val = 1
DB $2A,$01 ; CB 1
DB $74,$07 ; SLB 7
; 2958: fin ; !emit_val
C0845:
C0846:
; 2959: if type & PTR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$60 ; CB 96
DB $14 ; BAND
DB $4C,<C0852,>C0852 ; SKPFLS C0852
; 2960: emit_lw()
DB $54,<C0489,>C0489 ; CALL C0489
; 2961: fin
C0852:
C0853:
; 2962: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C0854,>C0854 ; SKPFLS C0854
; 2963: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 2964: fin
C0854:
C0855:
; 2965: if token <> CLOSE_BRACKET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$DD ; CB 221
DB $42 ; ISNE
DB $4C,<C0856,>C0856 ; SKPFLS C0856
; 2966: return parse_err_11(@no_close_bracket)
DB $26,<D0842,>D0842 ; LA D0842
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 2967: fin
C0856:
C0857:
; 2968: if type & WORD_TYPE
DB $64,$06 ; LLB 6
DB $2A,$04 ; CB 4
DB $14 ; BAND
DB $4C,<C0858,>C0858 ; SKPFLS C0858
; 2969: type = WPTR_TYPE
DB $2A,$40 ; CB 64
DB $74,$06 ; SLB 6
; 2970: emit_indexword()
DB $54,<C0535,>C0535 ; CALL C0535
; 2971: else
DB $50,<C0859,>C0859 ; SKIP C0859
C0858:
; 2972: type = BPTR_TYPE
DB $2A,$20 ; CB 32
DB $74,$06 ; SLB 6
; 2973: emit_indexbyte()
DB $54,<C0533,>C0533 ; CALL C0533
; 2974: fin
C0859:
; 2975: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 2976: elsif token == DOT_TKN or token == COLON_TKN
DB $50,<C0844,>C0844 ; SKIP C0844
C0843:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AE ; CB 174
DB $40 ; ISEQ
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$BA ; CB 186
DB $40 ; ISEQ
DB $22 ; LOR
DB $4C,<C0860,>C0860 ; SKPFLS C0860
; 2977: ;
; 2978: ; Dot and Colon
; 2979: ;
; 2980: if token == DOT_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AE ; CB 174
DB $40 ; ISEQ
DB $4C,<C0861,>C0861 ; SKPFLS C0861
; 2981: elem_type = BPTR_TYPE
DB $2A,$20 ; CB 32
DB $74,$0E ; SLB 14
; 2982: else
DB $50,<C0862,>C0862 ; SKIP C0862
C0861:
; 2983: elem_type = WPTR_TYPE
DB $2A,$40 ; CB 64
DB $74,$0E ; SLB 14
; 2984: fin
C0862:
; 2985: if parse_constval_21(@elem_offset, @elem_size)
DB $28,$10 ; LLA 16
DB $28,$0F ; LLA 15
DB $54,<C0769,>C0769 ; CALL C0769
DB $4C,<C0863,>C0863 ; SKPFLS C0863
; 2986: ;
; 2987: ; Constant structure offset
; 2988: ;
; 2989: if !emit_val
DB $64,$07 ; LLB 7
DB $20 ; NOT
DB $4C,<C0865,>C0865 ; SKPFLS C0865
; 2990: if type & VAR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $4C,<C0867,>C0867 ; SKPFLS C0867
; 2991: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0869,>C0869 ; SKPFLS C0869
; 2992: emit_localaddr_10(value + elem_offset)
DB $66,$0C ; LLW 12
DB $66,$10 ; LLW 16
DB $02 ; ADD
DB $54,<C0529,>C0529 ; CALL C0529
; 2993: else
DB $50,<C0870,>C0870 ; SKIP C0870
C0869:
; 2994: ; emit_globaladdr_10(value + elem_offset)
; 2995: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 2996: emit_const_10(elem_offset)
DB $66,$10 ; LLW 16
DB $54,<C0482,>C0482 ; CALL C0482
; 2997: drop emit_binaryop_11(ADD_TKN)
DB $2A,$AB ; CB 171
DB $54,<C0548,>C0548 ; CALL C0548
DB $30 ; DROP
; 2998: fin
C0870:
; 2999: elsif type & CONST_TYPE
DB $50,<C0868,>C0868 ; SKIP C0868
C0867:
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0871,>C0871 ; SKPFLS C0871
; 3000: value = value + elem_offset
DB $66,$0C ; LLW 12
DB $66,$10 ; LLW 16
DB $02 ; ADD
DB $76,$0C ; SLW 12
; 3001: emit_const_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0482,>C0482 ; CALL C0482
; 3002: else ; FUNC_TYPE
DB $50,<C0868,>C0868 ; SKIP C0868
C0871:
; 3003: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 3004: emit_const_10(elem_offset)
DB $66,$10 ; LLW 16
DB $54,<C0482,>C0482 ; CALL C0482
; 3005: drop emit_binaryop_11(ADD_TKN)
DB $2A,$AB ; CB 171
DB $54,<C0548,>C0548 ; CALL C0548
DB $30 ; DROP
; 3006: fin
C0868:
; 3007: emit_val = 1
DB $2A,$01 ; CB 1
DB $74,$07 ; SLB 7
; 3008: else
DB $50,<C0866,>C0866 ; SKIP C0866
C0865:
; 3009: if elem_offset <> 0
DB $66,$10 ; LLW 16
DB $00 ; ZERO
DB $42 ; ISNE
DB $4C,<C0872,>C0872 ; SKPFLS C0872
; 3010: emit_const_10(elem_offset)
DB $66,$10 ; LLW 16
DB $54,<C0482,>C0482 ; CALL C0482
; 3011: drop emit_binaryop_11(ADD_TKN)
DB $2A,$AB ; CB 171
DB $54,<C0548,>C0548 ; CALL C0548
DB $30 ; DROP
; 3012: fin
C0872:
C0873:
; 3013: fin ; !emit_val
C0866:
; 3014: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3015: elsif token == OPEN_BRACKET_TKN
DB $50,<C0864,>C0864 ; SKIP C0864
C0863:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$DB ; CB 219
DB $40 ; ISEQ
DB $4C,<C0874,>C0874 ; SKPFLS C0874
; 3016: ;
; 3017: ; Array of arrays
; 3018: ;
; 3019: if !emit_val
DB $64,$07 ; LLB 7
DB $20 ; NOT
DB $4C,<C0875,>C0875 ; SKPFLS C0875
; 3020: if type & ADDR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$0E ; CB 14
DB $14 ; BAND
DB $4C,<C0877,>C0877 ; SKPFLS C0877
; 3021: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0879,>C0879 ; SKPFLS C0879
; 3022: emit_localaddr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0529,>C0529 ; CALL C0529
; 3023: else
DB $50,<C0880,>C0880 ; SKIP C0880
C0879:
; 3024: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 3025: fin
C0880:
; 3026: elsif type & CONST_TYPE
DB $50,<C0878,>C0878 ; SKIP C0878
C0877:
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0881,>C0881 ; SKPFLS C0881
; 3027: emit_const_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0482,>C0482 ; CALL C0482
; 3028: fin
C0881:
C0878:
; 3029: emit_val = 1
DB $2A,$01 ; CB 1
DB $74,$07 ; SLB 7
; 3030: fin ; !emit_val
C0875:
C0876:
; 3031: repeat
C0883:
; 3032: if emit_val > 1
DB $64,$07 ; LLB 7
DB $2A,$01 ; CB 1
DB $44 ; ISGT
DB $4C,<C0884,>C0884 ; SKPFLS C0884
; 3033: emit_indexword()
DB $54,<C0535,>C0535 ; CALL C0535
; 3034: emit_lw()
DB $54,<C0489,>C0489 ; CALL C0489
; 3035: fin
C0884:
C0885:
; 3036: emit_val = emit_val + 1
DB $64,$07 ; LLB 7
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$07 ; SLB 7
; 3037: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C0886,>C0886 ; SKPFLS C0886
; 3038: return parse_err_11(@bad_expr)
DB $26,<D0655,>D0655 ; LA D0655
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3039: fin
C0886:
C0887:
; 3040: if token <> CLOSE_BRACKET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$DD ; CB 221
DB $42 ; ISNE
DB $4C,<C0888,>C0888 ; SKPFLS C0888
; 3041: return parse_err_11(@no_close_bracket)
DB $26,<D0842,>D0842 ; LA D0842
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3042: fin
C0888:
C0889:
; 3043: until scan_01() <> OPEN_BRACKET_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$DB ; CB 219
DB $42 ; ISNE
DB $4C,<C0883,>C0883 ; SKPFLS C0883
C0882:
; 3044: if elem_type & WPTR_TYPE
DB $64,$0E ; LLB 14
DB $2A,$40 ; CB 64
DB $14 ; BAND
DB $4C,<C0890,>C0890 ; SKPFLS C0890
; 3045: emit_indexword()
DB $54,<C0535,>C0535 ; CALL C0535
; 3046: else
DB $50,<C0891,>C0891 ; SKIP C0891
C0890:
; 3047: emit_indexbyte()
DB $54,<C0533,>C0533 ; CALL C0533
; 3048: fin
C0891:
; 3049: else
DB $50,<C0864,>C0864 ; SKIP C0864
C0874:
; 3050: return parse_err_11(@bad_offset)
DB $26,<D0594,>D0594 ; LA D0594
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3051: fin
C0864:
; 3052: type = elem_type
DB $64,$0E ; LLB 14
DB $74,$06 ; SLB 6
; 3053: elsif token == OPEN_PAREN_TKN
DB $50,<C0844,>C0844 ; SKIP C0844
C0860:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$A8 ; CB 168
DB $40 ; ISEQ
DB $4C,<C0892,>C0892 ; SKPFLS C0892
; 3054: ;
; 3055: ; Function call
; 3056: ;
; 3057: 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,<C0893,>C0893 ; SKPFLS C0893
; 3058: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0895,>C0895 ; SKPFLS C0895
; 3059: emit_localaddr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0529,>C0529 ; CALL C0529
; 3060: else
DB $50,<C0896,>C0896 ; SKIP C0896
C0895:
; 3061: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 3062: fin
C0896:
; 3063: fin
C0893:
C0894:
; 3064: if !(type & FUNC_CONST_TYPE)
DB $64,$06 ; LLB 6
DB $2A,$09 ; CB 9
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C0897,>C0897 ; SKPFLS C0897
; 3065: emit_push()
DB $54,<C0523,>C0523 ; CALL C0523
; 3066: fin
C0897:
C0898:
; 3067: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3068: if token <> CLOSE_PAREN_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$A9 ; CB 169
DB $42 ; ISNE
DB $4C,<C0899,>C0899 ; SKPFLS C0899
; 3069: return parse_err_11(@no_close_paren)
DB $26,<D0820,>D0820 ; LA D0820
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3070: fin
C0899:
C0900:
; 3071: if type & FUNC_CONST_TYPE
DB $64,$06 ; LLB 6
DB $2A,$09 ; CB 9
DB $14 ; BAND
DB $4C,<C0901,>C0901 ; SKPFLS C0901
; 3072: emit_call_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0519,>C0519 ; CALL C0519
; 3073: else
DB $50,<C0902,>C0902 ; SKIP C0902
C0901:
; 3074: emit_pull()
DB $54,<C0525,>C0525 ; CALL C0525
; 3075: emit_ical()
DB $54,<C0521,>C0521 ; CALL C0521
; 3076: fin
C0902:
; 3077: emit_val = 1
DB $2A,$01 ; CB 1
DB $74,$07 ; SLB 7
; 3078: type = WORD_TYPE
DB $2A,$04 ; CB 4
DB $74,$06 ; SLB 6
; 3079: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3080: fin
C0892:
C0844:
; 3081: loop
DB $50,<C0841,>C0841 ; SKIP C0841
C0842:
; 3082: if emit_val
DB $64,$07 ; LLB 7
DB $4C,<C0903,>C0903 ; SKPFLS C0903
; 3083: if rvalue
DB $66,$02 ; LLW 2
DB $4C,<C0905,>C0905 ; SKPFLS C0905
; 3084: 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,<C0907,>C0907 ; SKPFLS C0907
; 3085: if type & BPTR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$20 ; CB 32
DB $14 ; BAND
DB $4C,<C0909,>C0909 ; SKPFLS C0909
; 3086: emit_lb()
DB $54,<C0487,>C0487 ; CALL C0487
; 3087: else
DB $50,<C0910,>C0910 ; SKIP C0910
C0909:
; 3088: emit_lw()
DB $54,<C0489,>C0489 ; CALL C0489
; 3089: fin
C0910:
; 3090: fin
C0907:
C0908:
; 3091: fin
C0905:
C0906:
; 3092: else ; emit_val
DB $50,<C0904,>C0904 ; SKIP C0904
C0903:
; 3093: if type & CONST_TYPE
DB $64,$06 ; LLB 6
DB $2A,$01 ; CB 1
DB $14 ; BAND
DB $4C,<C0911,>C0911 ; SKPFLS C0911
; 3094: emit_const_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0482,>C0482 ; CALL C0482
; 3095: elsif deref
DB $50,<C0912,>C0912 ; SKIP C0912
C0911:
DB $64,$05 ; LLB 5
DB $4C,<C0913,>C0913 ; SKPFLS C0913
; 3096: if type & FUNC_TYPE
DB $64,$06 ; LLB 6
DB $2A,$08 ; CB 8
DB $14 ; BAND
DB $4C,<C0914,>C0914 ; SKPFLS C0914
; 3097: emit_call_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0519,>C0519 ; CALL C0519
; 3098: elsif type & VAR_TYPE
DB $50,<C0915,>C0915 ; SKIP C0915
C0914:
DB $64,$06 ; LLB 6
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $4C,<C0916,>C0916 ; SKPFLS C0916
; 3099: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0917,>C0917 ; SKPFLS C0917
; 3100: if type & BYTE_TYPE
DB $64,$06 ; LLB 6
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0919,>C0919 ; SKPFLS C0919
; 3101: emit_llb_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0491,>C0491 ; CALL C0491
; 3102: else
DB $50,<C0920,>C0920 ; SKIP C0920
C0919:
; 3103: emit_llw_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0493,>C0493 ; CALL C0493
; 3104: fin
C0920:
; 3105: else
DB $50,<C0918,>C0918 ; SKIP C0918
C0917:
; 3106: if type & BYTE_TYPE
DB $64,$06 ; LLB 6
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0921,>C0921 ; SKPFLS C0921
; 3107: emit_lab_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0495,>C0495 ; CALL C0495
; 3108: else
DB $50,<C0922,>C0922 ; SKIP C0922
C0921:
; 3109: emit_law_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0497,>C0497 ; CALL C0497
; 3110: fin
C0922:
; 3111: fin
C0918:
; 3112: elsif type & PTR_TYPE
DB $50,<C0915,>C0915 ; SKIP C0915
C0916:
DB $64,$06 ; LLB 6
DB $2A,$60 ; CB 96
DB $14 ; BAND
DB $4C,<C0923,>C0923 ; SKPFLS C0923
; 3113: if type & BPTR_TYPE
DB $64,$06 ; LLB 6
DB $2A,$20 ; CB 32
DB $14 ; BAND
DB $4C,<C0924,>C0924 ; SKPFLS C0924
; 3114: emit_lb()
DB $54,<C0487,>C0487 ; CALL C0487
; 3115: else
DB $50,<C0925,>C0925 ; SKIP C0925
C0924:
; 3116: emit_lw()
DB $54,<C0489,>C0489 ; CALL C0489
; 3117: fin
C0925:
; 3118: fin
C0923:
C0915:
; 3119: else
DB $50,<C0912,>C0912 ; SKIP C0912
C0913:
; 3120: if type & LOCAL_TYPE
DB $64,$06 ; LLB 6
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0926,>C0926 ; SKPFLS C0926
; 3121: emit_localaddr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0529,>C0529 ; CALL C0529
; 3122: else
DB $50,<C0927,>C0927 ; SKIP C0927
C0926:
; 3123: emit_globaladdr_10(value)
DB $66,$0C ; LLW 12
DB $54,<C0531,>C0531 ; CALL C0531
; 3124: fin
C0927:
; 3125: fin
C0912:
; 3126: fin ; emit_val
C0904:
; 3127: while optos < opsp
C0928:
DB $66,$08 ; LLW 8
DB $6A,<D0475,>D0475 ; LAW D0475
DB $46 ; ISLT
DB $4C,<C0929,>C0929 ; SKPFLS C0929
; 3128: if !emit_unaryop_11(pop_op_01())
DB $54,<C0692,>C0692 ; CALL C0692
DB $54,<C0537,>C0537 ; CALL C0537
DB $20 ; NOT
DB $4C,<C0930,>C0930 ; SKPFLS C0930
; 3129: return parse_err_11(@bad_op)
DB $26,<D0628,>D0628 ; LA D0628
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3130: fin
C0930:
C0931:
; 3131: loop
DB $50,<C0928,>C0928 ; SKIP C0928
C0929:
; 3132: return type
DB $64,$06 ; LLB 6
DB $5A ; LEAVE
; 3133: end
; 3134: def parse_constexpr_21(valptr, sizeptr)
C0932: ; parse_constexpr_21()
; valptr = 2
; sizeptr = 4
; 3135: byte type, size1, size2
; type = 6
; size1 = 7
; size2 = 8
; 3136: word val1, val2
; val1 = 9
; val2 = 11
; 3137:
; 3138: 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,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3139: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0934,>C0934 ; SKPFLS C0934
; 3140: return 0
DB $00 ; ZERO
DB $5A ; LEAVE
; 3141: fin
C0934:
C0935:
; 3142: size2 = 0
DB $00 ; ZERO
DB $74,$08 ; SLB 8
; 3143: when scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
; 3144: is ADD_TKN
DB $2A,$AB ; CB 171
DB $3E,<C0937,>C0937 ; SKPNE C0937
; 3145: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3146: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0938,>C0938 ; SKPFLS C0938
; 3147: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3148: fin
C0938:
C0939:
; 3149: *valptr = val1 + val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $02 ; ADD
DB $72 ; SW
; 3150: is SUB_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0937:
DB $2A,$AD ; CB 173
DB $3E,<C0940,>C0940 ; SKPNE C0940
; 3151: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3152: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0941,>C0941 ; SKPFLS C0941
; 3153: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3154: fin
C0941:
C0942:
; 3155: *valptr = val1 - val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $04 ; SUB
DB $72 ; SW
; 3156: is MUL_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0940:
DB $2A,$AA ; CB 170
DB $3E,<C0943,>C0943 ; SKPNE C0943
; 3157: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3158: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0944,>C0944 ; SKPFLS C0944
; 3159: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3160: fin
C0944:
C0945:
; 3161: *valptr = val1 * val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $06 ; MUL
DB $72 ; SW
; 3162: is DIV_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0943:
DB $2A,$AF ; CB 175
DB $3E,<C0946,>C0946 ; SKPNE C0946
; 3163: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3164: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0947,>C0947 ; SKPFLS C0947
; 3165: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3166: fin
C0947:
C0948:
; 3167: *valptr = val1 + val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $02 ; ADD
DB $72 ; SW
; 3168: is MOD_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0946:
DB $2A,$A5 ; CB 165
DB $3E,<C0949,>C0949 ; SKPNE C0949
; 3169: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3170: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0950,>C0950 ; SKPFLS C0950
; 3171: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3172: fin
C0950:
C0951:
; 3173: *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
; 3174: drop
DB $30 ; DROP
; 3175: is AND_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0949:
DB $2A,$A6 ; CB 166
DB $3E,<C0952,>C0952 ; SKPNE C0952
; 3176: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3177: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0953,>C0953 ; SKPFLS C0953
; 3178: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3179: fin
C0953:
C0954:
; 3180: *valptr = val1 & val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $14 ; BAND
DB $72 ; SW
; 3181: is OR_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0952:
DB $2A,$BF ; CB 191
DB $3E,<C0955,>C0955 ; SKPNE C0955
; 3182: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3183: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0956,>C0956 ; SKPFLS C0956
; 3184: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3185: fin
C0956:
C0957:
; 3186: *valptr = val1 ? val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $16 ; IOR
DB $72 ; SW
; 3187: is EOR_TKN
DB $50,<C0936,>C0936 ; SKIP C0936
C0955:
DB $2A,$DE ; CB 222
DB $3E,<C0958,>C0958 ; SKPNE C0958
; 3188: type = parse_constval_21(@val2, @size2)
DB $28,$0B ; LLA 11
DB $28,$08 ; LLA 8
DB $54,<C0769,>C0769 ; CALL C0769
DB $74,$06 ; SLB 6
; 3189: if !type
DB $64,$06 ; LLB 6
DB $20 ; NOT
DB $4C,<C0959,>C0959 ; SKPFLS C0959
; 3190: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3191: fin
C0959:
C0960:
; 3192: *valptr = val1 ^ val2
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $66,$0B ; LLW 11
DB $18 ; XOR
DB $72 ; SW
; 3193: otherwise
DB $50,<C0936,>C0936 ; SKIP C0936
C0958:
; 3194: *valptr = val1
DB $66,$02 ; LLW 2
DB $66,$09 ; LLW 9
DB $72 ; SW
; 3195: wend
C0936:
DB $30 ; DROP
; 3196: if size1 > size2
DB $64,$07 ; LLB 7
DB $64,$08 ; LLB 8
DB $44 ; ISGT
DB $4C,<C0962,>C0962 ; SKPFLS C0962
; 3197: ^sizeptr = size1
DB $66,$04 ; LLW 4
DB $64,$07 ; LLB 7
DB $70 ; SB
; 3198: else
DB $50,<C0963,>C0963 ; SKIP C0963
C0962:
; 3199: ^sizeptr = size2
DB $66,$04 ; LLW 4
DB $64,$08 ; LLB 8
DB $70 ; SB
; 3200: fin
C0963:
; 3201: return type
DB $64,$06 ; LLB 6
DB $5A ; LEAVE
; 3202: end
; 3203: def parse_expr_01
C0001: ; parse_expr_01()
; 3204: byte prevmatch, matchop, i
; prevmatch = 2
; matchop = 3
; i = 4
; 3205: word optos
; optos = 5
; 3206:
; 3207: matchop = 0
JSR INTERP
DB $58,$07,$00 ; ENTER 7,0
DB $00 ; ZERO
DB $74,$03 ; SLB 3
; 3208: optos = opsp
DB $6A,<D0475,>D0475 ; LAW D0475
DB $76,$05 ; SLW 5
; 3209: repeat
C0966:
; 3210: prevmatch = matchop
DB $64,$03 ; LLB 3
DB $74,$02 ; SLB 2
; 3211: matchop = 0
DB $00 ; ZERO
DB $74,$03 ; SLB 3
; 3212: if parse_value_11(1)
DB $2A,$01 ; CB 1
DB $54,<C0805,>C0805 ; CALL C0805
DB $4C,<C0967,>C0967 ; SKPFLS C0967
; 3213: matchop = 1
DB $2A,$01 ; CB 1
DB $74,$03 ; SLB 3
; 3214: for i = 0 to bops_tblsz
DB $00 ; ZERO
C0970:
DB $6C,$04 ; DLB 4
DB $2A,$12 ; CB 18
DB $3A,<C0969,>C0969 ; SKPGT C0969
DB $0C ; INCR
; 3215: if token == bops_tbl[i]
DB $68,<D0495,>D0495 ; LAB D0495
DB $26,<D0405,>D0405 ; LA D0405
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $40 ; ISEQ
DB $4C,<C0971,>C0971 ; SKPFLS C0971
; 3216: matchop = 2
DB $2A,$02 ; CB 2
DB $74,$03 ; SLB 3
; 3217: if bops_prec[i] >= tos_op_prec_11(optos)
DB $26,<D0424,>D0424 ; LA D0424
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $66,$05 ; LLW 5
DB $54,<C0700,>C0700 ; CALL C0700
DB $48 ; ISGE
DB $4C,<C0973,>C0973 ; SKPFLS C0973
; 3218: if !emit_binaryop_11(pop_op_01())
DB $54,<C0692,>C0692 ; CALL C0692
DB $54,<C0548,>C0548 ; CALL C0548
DB $20 ; NOT
DB $4C,<C0975,>C0975 ; SKPFLS C0975
; 3219: return parse_err_11(@bad_op)
DB $30 ; DROP
DB $26,<D0628,>D0628 ; LA D0628
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3220: fin
C0975:
C0976:
; 3221: fin
C0973:
C0974:
; 3222: drop push_op_21(token, bops_prec[i])
DB $68,<D0495,>D0495 ; LAB D0495
DB $26,<D0424,>D0424 ; LA D0424
DB $64,$04 ; LLB 4
DB $02 ; IDXB
DB $60 ; LB
DB $54,<C0688,>C0688 ; CALL C0688
DB $30 ; DROP
; 3223: break
DB $50,<C0969,>C0969 ; SKIP C0969
; 3224: fin
C0971:
C0972:
; 3225: next
DB $50,<C0970,>C0970 ; SKIP C0970
C0969:
DB $30 ; DROP
; 3226: fin
C0967:
C0968:
; 3227: until matchop <> 2
DB $64,$03 ; LLB 3
DB $2A,$02 ; CB 2
DB $42 ; ISNE
DB $4C,<C0966,>C0966 ; SKPFLS C0966
C0965:
; 3228: 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,<C0977,>C0977 ; SKPFLS C0977
; 3229: return parse_err_11(@missing_op)
DB $26,<D0866,>D0866 ; LA D0866
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3230: fin
C0977:
C0978:
; 3231: while optos < opsp
C0979:
DB $66,$05 ; LLW 5
DB $6A,<D0475,>D0475 ; LAW D0475
DB $46 ; ISLT
DB $4C,<C0980,>C0980 ; SKPFLS C0980
; 3232: if !emit_binaryop_11(pop_op_01())
DB $54,<C0692,>C0692 ; CALL C0692
DB $54,<C0548,>C0548 ; CALL C0548
DB $20 ; NOT
DB $4C,<C0981,>C0981 ; SKPFLS C0981
; 3233: return parse_err_11(@bad_op)
DB $26,<D0628,>D0628 ; LA D0628
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3234: fin
C0981:
C0982:
; 3235: loop
DB $50,<C0979,>C0979 ; SKIP C0979
C0980:
; 3236: return matchop or prevmatch
DB $64,$03 ; LLB 3
DB $64,$02 ; LLB 2
DB $22 ; LOR
DB $5A ; LEAVE
; 3237: end
; 3238: def parse_setlist_21(addr, type)
C0983: ; parse_setlist_21()
; addr = 2
; type = 4
; 3239: word nexttype, nextaddr, idptr, saveptr
; nexttype = 6
; nextaddr = 8
; idptr = 10
; saveptr = 12
; 3240:
; 3241: 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,<C0985,>C0985 ; SKPFLS C0985
; 3242: emit_push()
DB $54,<C0523,>C0523 ; CALL C0523
; 3243: fin
C0985:
C0986:
; 3244: nexttype = 0
DB $00 ; ZERO
DB $76,$06 ; SLW 6
; 3245: nextaddr = 0
DB $00 ; ZERO
DB $76,$08 ; SLW 8
; 3246: if scan_01() == ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $40 ; ISEQ
DB $4C,<C0987,>C0987 ; SKPFLS C0987
; 3247: idptr = id_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0716,>C0716 ; CALL C0716
DB $76,$0A ; SLW 10
; 3248: if !idptr
DB $66,$0A ; LLW 10
DB $20 ; NOT
DB $4C,<C0989,>C0989 ; SKPFLS C0989
; 3249: return FALSE
DB $00 ; ZERO
DB $5A ; LEAVE
; 3250: fin
C0989:
C0990:
; 3251: nexttype = (idptr).idtype
DB $66,$0A ; LLW 10
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $76,$06 ; SLW 6
; 3252: if type & VAR_TYPE
DB $66,$04 ; LLW 4
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $4C,<C0991,>C0991 ; SKPFLS C0991
; 3253: nextaddr = (idptr):idval
DB $66,$0A ; LLW 10
DB $62 ; LW
DB $76,$08 ; SLW 8
; 3254: fin
C0991:
C0992:
; 3255: fin
C0987:
C0988:
; 3256: saveptr = tknptr
DB $6A,<D0501,>D0501 ; LAW D0501
DB $76,$0C ; SLW 12
; 3257: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3258: if nexttype & VAR_TYPE and token == SET_TKN
DB $66,$06 ; LLW 6
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$BD ; CB 189
DB $40 ; ISEQ
DB $24 ; LAND
DB $4C,<C0993,>C0993 ; SKPFLS C0993
; 3259: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3260: if type & LOCAL_TYPE
DB $66,$04 ; LLW 4
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C0995,>C0995 ; SKPFLS C0995
; 3261: if type & BYTE_TYPE
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0997,>C0997 ; SKPFLS C0997
; 3262: emit_slb_10(nextaddr)
DB $66,$08 ; LLW 8
DB $54,<C0503,>C0503 ; CALL C0503
; 3263: else
DB $50,<C0998,>C0998 ; SKIP C0998
C0997:
; 3264: emit_slw_10(nextaddr)
DB $66,$08 ; LLW 8
DB $54,<C0505,>C0505 ; CALL C0505
; 3265: fin
C0998:
; 3266: else
DB $50,<C0996,>C0996 ; SKIP C0996
C0995:
; 3267: if type & BYTE_TYPE
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C0999,>C0999 ; SKPFLS C0999
; 3268: emit_sab_10(nextaddr)
DB $66,$08 ; LLW 8
DB $54,<C0511,>C0511 ; CALL C0511
; 3269: else
DB $50,<C1000,>C1000 ; SKIP C1000
C0999:
; 3270: emit_saw_10(nextaddr)
DB $66,$08 ; LLW 8
DB $54,<C0513,>C0513 ; CALL C0513
; 3271: fin
C1000:
; 3272: fin
C0996:
; 3273: elsif nexttype & VAR_TYPE and token == SETLIST_TKN
DB $50,<C0994,>C0994 ; SKIP C0994
C0993:
DB $66,$06 ; LLW 6
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$B9 ; CB 185
DB $40 ; ISEQ
DB $24 ; LAND
DB $4C,<C1001,>C1001 ; SKPFLS C1001
; 3274: if !parse_setlist_21(nextaddr, nexttype)
DB $66,$08 ; LLW 8
DB $66,$06 ; LLW 6
DB $54,<C0983,>C0983 ; CALL C0983
DB $20 ; NOT
DB $4C,<C1002,>C1002 ; SKPFLS C1002
; 3275: return FALSE
DB $00 ; ZERO
DB $5A ; LEAVE
; 3276: fin
C1002:
C1003:
; 3277: else
DB $50,<C0994,>C0994 ; SKIP C0994
C1001:
; 3278: tknptr = saveptr
DB $66,$0C ; LLW 12
DB $7A,<D0501,>D0501 ; SAW D0501
; 3279: rewind_10(tknptr)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $54,<C0680,>C0680 ; CALL C0680
; 3280: nexttype = parse_value_11(0)
DB $00 ; ZERO
DB $54,<C0805,>C0805 ; CALL C0805
DB $76,$06 ; SLW 6
; 3281: if nexttype <> 0
DB $66,$06 ; LLW 6
DB $00 ; ZERO
DB $42 ; ISNE
DB $4C,<C1004,>C1004 ; SKPFLS C1004
; 3282: if token == SET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$BD ; CB 189
DB $40 ; ISEQ
DB $4C,<C1006,>C1006 ; SKPFLS C1006
; 3283: emit_push()
DB $54,<C0523,>C0523 ; CALL C0523
; 3284: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3285: emit_pull()
DB $54,<C0525,>C0525 ; CALL C0525
; 3286: emit_swap()
DB $54,<C0593,>C0593 ; CALL C0593
; 3287: 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,<C1008,>C1008 ; SKPFLS C1008
; 3288: emit_sb()
DB $54,<C0499,>C0499 ; CALL C0499
; 3289: else
DB $50,<C1009,>C1009 ; SKIP C1009
C1008:
; 3290: emit_sw()
DB $54,<C0501,>C0501 ; CALL C0501
; 3291: fin
C1009:
; 3292: fin
C1006:
C1007:
; 3293: elsif token == SETLIST_TKN
DB $50,<C1005,>C1005 ; SKIP C1005
C1004:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$B9 ; CB 185
DB $40 ; ISEQ
DB $4C,<C1010,>C1010 ; SKPFLS C1010
; 3294: if !parse_setlist_21(0, nexttype)
DB $00 ; ZERO
DB $66,$06 ; LLW 6
DB $54,<C0983,>C0983 ; CALL C0983
DB $20 ; NOT
DB $4C,<C1011,>C1011 ; SKPFLS C1011
; 3295: return FALSE
DB $00 ; ZERO
DB $5A ; LEAVE
; 3296: fin
C1011:
C1012:
; 3297: else
DB $50,<C1005,>C1005 ; SKIP C1005
C1010:
; 3298: return parse_err_11(@bad_syntax)
DB $26,<D0670,>D0670 ; LA D0670
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3299: fin
C1005:
; 3300: fin
C0994:
; 3301: if type & VAR_TYPE
DB $66,$04 ; LLW 4
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $4C,<C1013,>C1013 ; SKPFLS C1013
; 3302: if type & LOCAL_TYPE
DB $66,$04 ; LLW 4
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C1015,>C1015 ; SKPFLS C1015
; 3303: if type & BYTE_TYPE
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1017,>C1017 ; SKPFLS C1017
; 3304: emit_slb_10(addr)
DB $66,$02 ; LLW 2
DB $54,<C0503,>C0503 ; CALL C0503
; 3305: else
DB $50,<C1018,>C1018 ; SKIP C1018
C1017:
; 3306: emit_slw_10(addr)
DB $66,$02 ; LLW 2
DB $54,<C0505,>C0505 ; CALL C0505
; 3307: fin
C1018:
; 3308: else
DB $50,<C1016,>C1016 ; SKIP C1016
C1015:
; 3309: if type & BYTE_TYPE
DB $66,$04 ; LLW 4
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1019,>C1019 ; SKPFLS C1019
; 3310: emit_sab_10(addr)
DB $66,$02 ; LLW 2
DB $54,<C0511,>C0511 ; CALL C0511
; 3311: else
DB $50,<C1020,>C1020 ; SKIP C1020
C1019:
; 3312: emit_saw_10(addr)
DB $66,$02 ; LLW 2
DB $54,<C0513,>C0513 ; CALL C0513
; 3313: fin
C1020:
; 3314: fin
C1016:
; 3315: else
DB $50,<C1014,>C1014 ; SKIP C1014
C1013:
; 3316: emit_pull()
DB $54,<C0525,>C0525 ; CALL C0525
; 3317: emit_swap()
DB $54,<C0593,>C0593 ; CALL C0593
; 3318: 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,<C1021,>C1021 ; SKPFLS C1021
; 3319: emit_sb()
DB $54,<C0499,>C0499 ; CALL C0499
; 3320: else
DB $50,<C1022,>C1022 ; SKIP C1022
C1021:
; 3321: emit_sw()
DB $54,<C0501,>C0501 ; CALL C0501
; 3322: fin
C1022:
; 3323: fin
C1014:
; 3324: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3325: end
; 3326: def parse_stmnt_01
C1023: ; parse_stmnt_01()
; 3327: byte type, i
; type = 2
; i = 3
; 3328: 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
; 3329: 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
; 3330:
; 3331: if token <> END_TKN and token <> DONE_TKN
JSR INTERP
DB $58,$1C,$00 ; ENTER 28,0
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$87 ; CB 135
DB $42 ; ISNE
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$98 ; CB 152
DB $42 ; ISNE
DB $24 ; LAND
DB $4C,<C1025,>C1025 ; SKPFLS C1025
; 3332: prevstmnt = token
DB $68,<D0495,>D0495 ; LAB D0495
DB $78,<D1104,>D1104 ; SAB D1104
; 3333: fin
C1025:
C1026:
; 3334: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 3335: is IF_TKN
DB $2A,$83 ; CB 131
DB $3E,<C1028,>C1028 ; SKPNE C1028
; 3336: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3337: tag_else = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$06 ; SLW 6
; 3338: tag_endif = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$08 ; SLW 8
; 3339: emit_brfls_10(tag_else)
DB $66,$06 ; LLW 6
DB $54,<C0581,>C0581 ; CALL C0581
; 3340: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3341: repeat
C1030:
; 3342: while parse_stmnt_01()
C1031:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1032,>C1032 ; SKPFLS C1032
; 3343: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3344: loop
DB $50,<C1031,>C1031 ; SKIP C1031
C1032:
; 3345: if token <> ELSEIF_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$84 ; CB 132
DB $42 ; ISNE
DB $4C,<C1033,>C1033 ; SKPFLS C1033
; 3346: break
DB $50,<C1029,>C1029 ; SKIP C1029
; 3347: fin
C1033:
C1034:
; 3348: emit_jump_10(tag_endif)
DB $66,$08 ; LLW 8
DB $54,<C0589,>C0589 ; CALL C0589
; 3349: emit_codetag_10(tag_else)
DB $66,$06 ; LLW 6
DB $54,<C0461,>C0461 ; CALL C0461
; 3350: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C1035,>C1035 ; SKPFLS C1035
; 3351: return 0
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3352: fin
C1035:
C1036:
; 3353: tag_else = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$06 ; SLW 6
; 3354: emit_brfls_10(tag_else)
DB $66,$06 ; LLW 6
DB $54,<C0581,>C0581 ; CALL C0581
; 3355: until FALSE
DB $00 ; ZERO
DB $4C,<C1030,>C1030 ; SKPFLS C1030
C1029:
; 3356: if token == ELSE_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$85 ; CB 133
DB $40 ; ISEQ
DB $4C,<C1037,>C1037 ; SKPFLS C1037
; 3357: emit_jump_10(tag_endif)
DB $66,$08 ; LLW 8
DB $54,<C0589,>C0589 ; CALL C0589
; 3358: emit_codetag_10(tag_else)
DB $66,$06 ; LLW 6
DB $54,<C0461,>C0461 ; CALL C0461
; 3359: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3360: while parse_stmnt_01()
C1039:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1040,>C1040 ; SKPFLS C1040
; 3361: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3362: loop
DB $50,<C1039,>C1039 ; SKIP C1039
C1040:
; 3363: emit_codetag_10(tag_endif)
DB $66,$08 ; LLW 8
DB $54,<C0461,>C0461 ; CALL C0461
; 3364: else
DB $50,<C1038,>C1038 ; SKIP C1038
C1037:
; 3365: emit_codetag_10(tag_else)
DB $66,$06 ; LLW 6
DB $54,<C0461,>C0461 ; CALL C0461
; 3366: emit_codetag_10(tag_endif)
DB $66,$08 ; LLW 8
DB $54,<C0461,>C0461 ; CALL C0461
; 3367: fin
C1038:
; 3368: if token <> FIN_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$86 ; CB 134
DB $42 ; ISNE
DB $4C,<C1041,>C1041 ; SKPFLS C1041
; 3369: return parse_err_11(@no_fin)
DB $30 ; DROP
DB $26,<D0882,>D0882 ; LA D0882
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3370: fin
C1041:
C1042:
; 3371: is FOR_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1028:
DB $2A,$8E ; CB 142
DB $3E,<C1043,>C1043 ; SKPNE C1043
; 3372: stack_loop = stack_loop + 1
DB $68,<D1103,>D1103 ; LAB D1103
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D1103,>D1103 ; SAB D1103
; 3373: tag_for = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$10 ; SLW 16
; 3374: tag_prevbrk = break_tag
DB $6A,<D1107,>D1107 ; LAW D1107
DB $76,$04 ; SLW 4
; 3375: break_tag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $7A,<D1107,>D1107 ; SAW D1107
; 3376: if scan_01() <> ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $42 ; ISNE
DB $4C,<C1044,>C1044 ; SKPFLS C1044
; 3377: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3378: fin
C1044:
C1045:
; 3379: idptr = id_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0716,>C0716 ; CALL C0716
DB $76,$14 ; SLW 20
; 3380: if idptr
DB $66,$14 ; LLW 20
DB $4C,<C1046,>C1046 ; SKPFLS C1046
; 3381: type = (idptr).idtype
DB $66,$14 ; LLW 20
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $74,$02 ; SLB 2
; 3382: addr = (idptr):idval
DB $66,$14 ; LLW 20
DB $62 ; LW
DB $76,$18 ; SLW 24
; 3383: else
DB $50,<C1047,>C1047 ; SKIP C1047
C1046:
; 3384: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3385: fin
C1047:
; 3386: if scan_01() <> SET_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$BD ; CB 189
DB $42 ; ISNE
DB $4C,<C1048,>C1048 ; SKPFLS C1048
; 3387: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3388: fin
C1048:
C1049:
; 3389: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C1050,>C1050 ; SKPFLS C1050
; 3390: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3391: fin
C1050:
C1051:
; 3392: emit_codetag_10(tag_for)
DB $66,$10 ; LLW 16
DB $54,<C0461,>C0461 ; CALL C0461
; 3393: if type & LOCAL_TYPE
DB $64,$02 ; LLB 2
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C1052,>C1052 ; SKPFLS C1052
; 3394: if type & BYTE_TYPE
DB $64,$02 ; LLB 2
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1054,>C1054 ; SKPFLS C1054
; 3395: emit_dlb_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0507,>C0507 ; CALL C0507
; 3396: else
DB $50,<C1055,>C1055 ; SKIP C1055
C1054:
; 3397: emit_dlw_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0509,>C0509 ; CALL C0509
; 3398: fin
C1055:
; 3399: else
DB $50,<C1053,>C1053 ; SKIP C1053
C1052:
; 3400: if type & BYTE_TYPE
DB $64,$02 ; LLB 2
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1056,>C1056 ; SKPFLS C1056
; 3401: emit_dab_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0515,>C0515 ; CALL C0515
; 3402: else
DB $50,<C1057,>C1057 ; SKIP C1057
C1056:
; 3403: emit_daw_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0517,>C0517 ; CALL C0517
; 3404: fin
C1057:
; 3405: fin
C1053:
; 3406: stepdir = 1
DB $2A,$01 ; CB 1
DB $76,$1A ; SLW 26
; 3407: if token == TO_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$8F ; CB 143
DB $40 ; ISEQ
DB $4C,<C1058,>C1058 ; SKPFLS C1058
; 3408: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3409: elsif token == DOWNTO_TKN
DB $50,<C1059,>C1059 ; SKIP C1059
C1058:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$90 ; CB 144
DB $40 ; ISEQ
DB $4C,<C1060,>C1060 ; SKPFLS C1060
; 3410: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3411: stepdir = -1
DB $2C,$FF,$FF ; CW -1
DB $76,$1A ; SLW 26
; 3412: fin
C1060:
C1059:
; 3413: if stepdir > 0
DB $66,$1A ; LLW 26
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C1061,>C1061 ; SKPFLS C1061
; 3414: emit_brgt_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0583,>C0583 ; CALL C0583
; 3415: else
DB $50,<C1062,>C1062 ; SKIP C1062
C1061:
; 3416: emit_brlt_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0585,>C0585 ; CALL C0585
; 3417: fin
C1062:
; 3418: if token == STEP_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$91 ; CB 145
DB $40 ; ISEQ
DB $4C,<C1063,>C1063 ; SKPFLS C1063
; 3419: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3420: if stepdir > 0
DB $66,$1A ; LLW 26
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C1065,>C1065 ; SKPFLS C1065
; 3421: drop emit_binaryop_11(ADD_TKN)
DB $2A,$AB ; CB 171
DB $54,<C0548,>C0548 ; CALL C0548
DB $30 ; DROP
; 3422: else
DB $50,<C1066,>C1066 ; SKIP C1066
C1065:
; 3423: drop emit_binaryop_11(SUB_TKN)
DB $2A,$AD ; CB 173
DB $54,<C0548,>C0548 ; CALL C0548
DB $30 ; DROP
; 3424: fin
C1066:
; 3425: else
DB $50,<C1064,>C1064 ; SKIP C1064
C1063:
; 3426: if stepdir > 0
DB $66,$1A ; LLW 26
DB $00 ; ZERO
DB $44 ; ISGT
DB $4C,<C1067,>C1067 ; SKPFLS C1067
; 3427: drop emit_unaryop_11(INC_TKN)
DB $2A,$C1 ; CB 193
DB $54,<C0537,>C0537 ; CALL C0537
DB $30 ; DROP
; 3428: else
DB $50,<C1068,>C1068 ; SKIP C1068
C1067:
; 3429: drop emit_unaryop_11(DEC_TKN)
DB $2A,$C4 ; CB 196
DB $54,<C0537,>C0537 ; CALL C0537
DB $30 ; DROP
; 3430: fin
C1068:
; 3431: fin
C1064:
; 3432: while parse_stmnt_01()
C1069:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1070,>C1070 ; SKPFLS C1070
; 3433: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3434: loop
DB $50,<C1069,>C1069 ; SKIP C1069
C1070:
; 3435: if token <> NEXT_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$92 ; CB 146
DB $42 ; ISNE
DB $4C,<C1071,>C1071 ; SKPFLS C1071
; 3436: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3437: fin
C1071:
C1072:
; 3438: emit_jump_10(tag_for)
DB $66,$10 ; LLW 16
DB $54,<C0589,>C0589 ; CALL C0589
; 3439: emit_codetag_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0461,>C0461 ; CALL C0461
; 3440: emit_drop()
DB $54,<C0591,>C0591 ; CALL C0591
; 3441: break_tag = tag_prevbrk
DB $66,$04 ; LLW 4
DB $7A,<D1107,>D1107 ; SAW D1107
; 3442: stack_loop = stack_loop - 1
DB $68,<D1103,>D1103 ; LAB D1103
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D1103,>D1103 ; SAB D1103
; 3443: is WHILE_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1043:
DB $2A,$88 ; CB 136
DB $3E,<C1073,>C1073 ; SKPNE C1073
; 3444: tag_while = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$0A ; SLW 10
; 3445: tag_wend = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$0C ; SLW 12
; 3446: tag_prevbrk = break_tag
DB $6A,<D1107,>D1107 ; LAW D1107
DB $76,$04 ; SLW 4
; 3447: break_tag = tag_wend
DB $66,$0C ; LLW 12
DB $7A,<D1107,>D1107 ; SAW D1107
; 3448: emit_codetag_10(tag_while)
DB $66,$0A ; LLW 10
DB $54,<C0461,>C0461 ; CALL C0461
; 3449: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3450: emit_brfls_10(tag_wend)
DB $66,$0C ; LLW 12
DB $54,<C0581,>C0581 ; CALL C0581
; 3451: while parse_stmnt_01()
C1074:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1075,>C1075 ; SKPFLS C1075
; 3452: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3453: loop
DB $50,<C1074,>C1074 ; SKIP C1074
C1075:
; 3454: if token <> LOOP_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$89 ; CB 137
DB $42 ; ISNE
DB $4C,<C1076,>C1076 ; SKPFLS C1076
; 3455: return parse_err_11(@no_loop)
DB $30 ; DROP
DB $26,<D0894,>D0894 ; LA D0894
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3456: fin
C1076:
C1077:
; 3457: emit_jump_10(tag_while)
DB $66,$0A ; LLW 10
DB $54,<C0589,>C0589 ; CALL C0589
; 3458: emit_codetag_10(tag_wend)
DB $66,$0C ; LLW 12
DB $54,<C0461,>C0461 ; CALL C0461
; 3459: break_tag = tag_prevbrk
DB $66,$04 ; LLW 4
DB $7A,<D1107,>D1107 ; SAW D1107
; 3460: is REPEAT_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1073:
DB $2A,$93 ; CB 147
DB $3E,<C1078,>C1078 ; SKPNE C1078
; 3461: tag_repeat = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$0E ; SLW 14
; 3462: tag_prevbrk = break_tag
DB $6A,<D1107,>D1107 ; LAW D1107
DB $76,$04 ; SLW 4
; 3463: break_tag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $7A,<D1107,>D1107 ; SAW D1107
; 3464: emit_codetag_10(tag_repeat)
DB $66,$0E ; LLW 14
DB $54,<C0461,>C0461 ; CALL C0461
; 3465: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3466: while parse_stmnt_01()
C1079:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1080,>C1080 ; SKPFLS C1080
; 3467: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3468: loop
DB $50,<C1079,>C1079 ; SKIP C1079
C1080:
; 3469: if token <> UNTIL_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$94 ; CB 148
DB $42 ; ISNE
DB $4C,<C1081,>C1081 ; SKPFLS C1081
; 3470: return parse_err_11(@no_until)
DB $30 ; DROP
DB $26,<D0907,>D0907 ; LA D0907
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3471: fin
C1081:
C1082:
; 3472: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3473: emit_brfls_10(tag_repeat)
DB $66,$0E ; LLW 14
DB $54,<C0581,>C0581 ; CALL C0581
; 3474: emit_codetag_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0461,>C0461 ; CALL C0461
; 3475: break_tag = tag_prevbrk
DB $66,$04 ; LLW 4
DB $7A,<D1107,>D1107 ; SAW D1107
; 3476: is CASE_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1078:
DB $2A,$8A ; CB 138
DB $3E,<C1083,>C1083 ; SKPNE C1083
; 3477: stack_loop = stack_loop + 1
DB $68,<D1103,>D1103 ; LAB D1103
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $78,<D1103,>D1103 ; SAB D1103
; 3478: tag_choice = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$12 ; SLW 18
; 3479: tag_prevbrk = break_tag
DB $6A,<D1107,>D1107 ; LAW D1107
DB $76,$04 ; SLW 4
; 3480: break_tag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $7A,<D1107,>D1107 ; SAW D1107
; 3481: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3482: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3483: while token <> ENDCASE_TKN
C1084:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$8D ; CB 141
DB $42 ; ISNE
DB $4C,<C1085,>C1085 ; SKPFLS C1085
; 3484: when token
DB $68,<D0495,>D0495 ; LAB D0495
; 3485: is OF_TKN
DB $2A,$8B ; CB 139
DB $3E,<C1087,>C1087 ; SKPNE C1087
; 3486: if !parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $20 ; NOT
DB $4C,<C1088,>C1088 ; SKPFLS C1088
; 3487: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3488: fin
C1088:
C1089:
; 3489: emit_brne_10(tag_choice)
DB $66,$12 ; LLW 18
DB $54,<C0587,>C0587 ; CALL C0587
; 3490: while parse_stmnt_01()
C1090:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1091,>C1091 ; SKPFLS C1091
; 3491: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3492: loop
DB $50,<C1090,>C1090 ; SKIP C1090
C1091:
; 3493: emit_jump_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0589,>C0589 ; CALL C0589
; 3494: emit_codetag_10(tag_choice)
DB $66,$12 ; LLW 18
DB $54,<C0461,>C0461 ; CALL C0461
; 3495: tag_choice = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$12 ; SLW 18
; 3496: is DEFAULT_TKN
DB $50,<C1086,>C1086 ; SKIP C1086
C1087:
DB $2A,$8C ; CB 140
DB $3E,<C1092,>C1092 ; SKPNE C1092
; 3497: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3498: while parse_stmnt_01()
C1093:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1094,>C1094 ; SKPFLS C1094
; 3499: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3500: loop
DB $50,<C1093,>C1093 ; SKIP C1093
C1094:
; 3501: if token <> ENDCASE_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$8D ; CB 141
DB $42 ; ISNE
DB $4C,<C1095,>C1095 ; SKPFLS C1095
; 3502: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3503: fin
C1095:
C1096:
; 3504: otherwise
DB $50,<C1086,>C1086 ; SKIP C1086
C1092:
; 3505: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3506: wend
C1086:
DB $30 ; DROP
; 3507: loop
DB $50,<C1084,>C1084 ; SKIP C1084
C1085:
; 3508: emit_codetag_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0461,>C0461 ; CALL C0461
; 3509: emit_drop()
DB $54,<C0591,>C0591 ; CALL C0591
; 3510: break_tag = tag_prevbrk
DB $66,$04 ; LLW 4
DB $7A,<D1107,>D1107 ; SAW D1107
; 3511: stack_loop = stack_loop - 1
DB $68,<D1103,>D1103 ; LAB D1103
DB $2A,$01 ; CB 1
DB $04 ; SUB
DB $78,<D1103,>D1103 ; SAB D1103
; 3512: is BREAK_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1083:
DB $2A,$9A ; CB 154
DB $3E,<C1098,>C1098 ; SKPNE C1098
; 3513: if break_tag
DB $6A,<D1107,>D1107 ; LAW D1107
DB $4C,<C1099,>C1099 ; SKPFLS C1099
; 3514: emit_jump_10(break_tag)
DB $6A,<D1107,>D1107 ; LAW D1107
DB $54,<C0589,>C0589 ; CALL C0589
; 3515: else
DB $50,<C1100,>C1100 ; SKIP C1100
C1099:
; 3516: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3517: fin
C1100:
; 3518: is RETURN_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1098:
DB $2A,$99 ; CB 153
DB $3E,<C1101,>C1101 ; SKPNE C1101
; 3519: if infunc
DB $68,<D1102,>D1102 ; LAB D1102
DB $4C,<C1102,>C1102 ; SKPFLS C1102
; 3520: for i = 1 to stack_loop
DB $2A,$01 ; CB 1
C1105:
DB $6C,$03 ; DLB 3
DB $68,<D1103,>D1103 ; LAB D1103
DB $3A,<C1104,>C1104 ; SKPGT C1104
DB $0C ; INCR
; 3521: emit_drop()
DB $54,<C0591,>C0591 ; CALL C0591
; 3522: next
DB $50,<C1105,>C1105 ; SKIP C1105
C1104:
DB $30 ; DROP
; 3523: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3524: emit_leave_10(framesize)
DB $6A,<D0484,>D0484 ; LAW D0484
DB $54,<C0595,>C0595 ; CALL C0595
; 3525: else
DB $50,<C1103,>C1103 ; SKIP C1103
C1102:
; 3526: return parse_err_11(@bad_stmnt)
DB $30 ; DROP
DB $26,<D0642,>D0642 ; LA D0642
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3527: fin
C1103:
; 3528: is EXIT_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1101:
DB $2A,$9C ; CB 156
DB $3E,<C1106,>C1106 ; SKPNE C1106
; 3529: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3530: emit_exit()
DB $54,<C0605,>C0605 ; CALL C0605
; 3531: is DROP_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1106:
DB $2A,$97 ; CB 151
DB $3E,<C1107,>C1107 ; SKPNE C1107
; 3532: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3533: emit_drop()
DB $54,<C0591,>C0591 ; CALL C0591
; 3534: is ELSE_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1107:
DB $2A,$85 ; CB 133
DB $3E,<C1108,>C1108 ; SKPNE C1108
; 3535: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3536: is ELSEIF_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1108:
DB $2A,$84 ; CB 132
DB $3E,<C1109,>C1109 ; SKPNE C1109
; 3537: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3538: is FIN_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1109:
DB $2A,$86 ; CB 134
DB $3E,<C1110,>C1110 ; SKPNE C1110
; 3539: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3540: is LOOP_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1110:
DB $2A,$89 ; CB 137
DB $3E,<C1111,>C1111 ; SKPNE C1111
; 3541: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3542: is UNTIL_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1111:
DB $2A,$94 ; CB 148
DB $3E,<C1112,>C1112 ; SKPNE C1112
; 3543: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3544: is NEXT_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1112:
DB $2A,$92 ; CB 146
DB $3E,<C1113,>C1113 ; SKPNE C1113
; 3545: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3546: is OF_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1113:
DB $2A,$8B ; CB 139
DB $3E,<C1114,>C1114 ; SKPNE C1114
; 3547: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3548: is DEFAULT_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1114:
DB $2A,$8C ; CB 140
DB $3E,<C1115,>C1115 ; SKPNE C1115
; 3549: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3550: is ENDCASE_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1115:
DB $2A,$8D ; CB 141
DB $3E,<C1116,>C1116 ; SKPNE C1116
; 3551: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3552: is END_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1116:
DB $2A,$87 ; CB 135
DB $3E,<C1117,>C1117 ; SKPNE C1117
; 3553: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3554: is DONE_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1117:
DB $2A,$98 ; CB 152
DB $3E,<C1118,>C1118 ; SKPNE C1118
; 3555: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3556: is IFUNC_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1118:
DB $2A,$95 ; CB 149
DB $3E,<C1119,>C1119 ; SKPNE C1119
; 3557: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3558: is NFUNC_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1119:
DB $2A,$96 ; CB 150
DB $3E,<C1120,>C1120 ; SKPNE C1120
; 3559: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3560: is EOF_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1120:
DB $2A,$01 ; CB 1
DB $3E,<C1121,>C1121 ; SKPNE C1121
; 3561: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3562: is EOL_TKN
DB $50,<C1027,>C1027 ; SKIP C1027
C1121:
DB $2A,$02 ; CB 2
DB $3E,<C1122,>C1122 ; SKPNE C1122
; 3563: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3564: otherwise
DB $50,<C1027,>C1027 ; SKIP C1027
C1122:
; 3565: if token == ID_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$D6 ; CB 214
DB $40 ; ISEQ
DB $4C,<C1124,>C1124 ; SKPFLS C1124
; 3566: saveptr = tknptr
DB $6A,<D0501,>D0501 ; LAW D0501
DB $76,$16 ; SLW 22
; 3567: idptr = id_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0716,>C0716 ; CALL C0716
DB $76,$14 ; SLW 20
; 3568: if !idptr
DB $66,$14 ; LLW 20
DB $20 ; NOT
DB $4C,<C1126,>C1126 ; SKPFLS C1126
; 3569: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3570: fin
C1126:
C1127:
; 3571: type = (idptr).idtype
DB $66,$14 ; LLW 20
DB $2A,$02 ; CB 2
DB $02 ; ADD
DB $60 ; LB
DB $74,$02 ; SLB 2
; 3572: if type & ADDR_TYPE
DB $64,$02 ; LLB 2
DB $2A,$0E ; CB 14
DB $14 ; BAND
DB $4C,<C1128,>C1128 ; SKPFLS C1128
; 3573: addr = (idptr):idval
DB $66,$14 ; LLW 20
DB $62 ; LW
DB $76,$18 ; SLW 24
; 3574: if scan_01() == SET_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$BD ; CB 189
DB $40 ; ISEQ
DB $4C,<C1130,>C1130 ; SKPFLS C1130
; 3575: if type & VAR_TYPE
DB $64,$02 ; LLB 2
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $4C,<C1132,>C1132 ; SKPFLS C1132
; 3576: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3577: if type & LOCAL_TYPE
DB $64,$02 ; LLB 2
DB $2A,$10 ; CB 16
DB $14 ; BAND
DB $4C,<C1134,>C1134 ; SKPFLS C1134
; 3578: if type & BYTE_TYPE
DB $64,$02 ; LLB 2
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1136,>C1136 ; SKPFLS C1136
; 3579: emit_slb_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0503,>C0503 ; CALL C0503
; 3580: else
DB $50,<C1137,>C1137 ; SKIP C1137
C1136:
; 3581: emit_slw_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0505,>C0505 ; CALL C0505
; 3582: fin
C1137:
; 3583: else
DB $50,<C1135,>C1135 ; SKIP C1135
C1134:
; 3584: if type & BYTE_TYPE
DB $64,$02 ; LLB 2
DB $2A,$02 ; CB 2
DB $14 ; BAND
DB $4C,<C1138,>C1138 ; SKPFLS C1138
; 3585: emit_sab_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0511,>C0511 ; CALL C0511
; 3586: else
DB $50,<C1139,>C1139 ; SKIP C1139
C1138:
; 3587: emit_saw_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0513,>C0513 ; CALL C0513
; 3588: fin
C1139:
; 3589: fin
C1135:
; 3590: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3591: fin
C1132:
C1133:
; 3592: elsif token == SETLIST_TKN and type & VAR_TYPE
DB $50,<C1131,>C1131 ; SKIP C1131
C1130:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$B9 ; CB 185
DB $40 ; ISEQ
DB $64,$02 ; LLB 2
DB $2A,$06 ; CB 6
DB $14 ; BAND
DB $24 ; LAND
DB $4C,<C1140,>C1140 ; SKPFLS C1140
; 3593: return parse_setlist_21(addr, type);
DB $30 ; DROP
DB $66,$18 ; LLW 24
DB $64,$02 ; LLB 2
DB $54,<C0983,>C0983 ; CALL C0983
DB $5A ; LEAVE
; 3594: elsif token == EOL_TKN and type & FUNC_TYPE
DB $50,<C1131,>C1131 ; SKIP C1131
C1140:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$02 ; CB 2
DB $40 ; ISEQ
DB $64,$02 ; LLB 2
DB $2A,$08 ; CB 8
DB $14 ; BAND
DB $24 ; LAND
DB $4C,<C1141,>C1141 ; SKPFLS C1141
; 3595: emit_call_10(addr)
DB $66,$18 ; LLW 24
DB $54,<C0519,>C0519 ; CALL C0519
; 3596: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3597: fin
C1141:
C1131:
; 3598: fin
C1128:
C1129:
; 3599: tknptr = saveptr
DB $66,$16 ; LLW 22
DB $7A,<D0501,>D0501 ; SAW D0501
; 3600: fin
C1124:
C1125:
; 3601: rewind_10(tknptr)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $54,<C0680,>C0680 ; CALL C0680
; 3602: type = parse_value_11(0)
DB $00 ; ZERO
DB $54,<C0805,>C0805 ; CALL C0805
DB $74,$02 ; SLB 2
; 3603: if type
DB $64,$02 ; LLB 2
DB $4C,<C1142,>C1142 ; SKPFLS C1142
; 3604: if token == SET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$BD ; CB 189
DB $40 ; ISEQ
DB $4C,<C1144,>C1144 ; SKPFLS C1144
; 3605: drop parse_expr_01()
DB $54,<C0001,>C0001 ; CALL C0001
DB $30 ; DROP
; 3606: if type & XBYTE_TYPE
DB $64,$02 ; LLB 2
DB $2A,$22 ; CB 34
DB $14 ; BAND
DB $4C,<C1146,>C1146 ; SKPFLS C1146
; 3607: emit_sb()
DB $54,<C0499,>C0499 ; CALL C0499
; 3608: else
DB $50,<C1147,>C1147 ; SKIP C1147
C1146:
; 3609: emit_sw()
DB $54,<C0501,>C0501 ; CALL C0501
; 3610: fin
C1147:
; 3611: elsif token == SETLIST_TKN
DB $50,<C1145,>C1145 ; SKIP C1145
C1144:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$B9 ; CB 185
DB $40 ; ISEQ
DB $4C,<C1148,>C1148 ; SKPFLS C1148
; 3612: return parse_setlist_21(0, type);
DB $30 ; DROP
DB $00 ; ZERO
DB $64,$02 ; LLB 2
DB $54,<C0983,>C0983 ; CALL C0983
DB $5A ; LEAVE
; 3613: else
DB $50,<C1145,>C1145 ; SKIP C1145
C1148:
; 3614: if type & BPTR_TYPE
DB $64,$02 ; LLB 2
DB $2A,$20 ; CB 32
DB $14 ; BAND
DB $4C,<C1149,>C1149 ; SKPFLS C1149
; 3615: emit_lb()
DB $54,<C0487,>C0487 ; CALL C0487
; 3616: elsif type & WPTR_TYPE
DB $50,<C1150,>C1150 ; SKIP C1150
C1149:
DB $64,$02 ; LLB 2
DB $2A,$40 ; CB 64
DB $14 ; BAND
DB $4C,<C1151,>C1151 ; SKPFLS C1151
; 3617: emit_lw()
DB $54,<C0489,>C0489 ; CALL C0489
; 3618: fin
C1151:
C1150:
; 3619: fin
C1145:
; 3620: else
DB $50,<C1143,>C1143 ; SKIP C1143
C1142:
; 3621: return parse_err_11(@bad_syntax)
DB $30 ; DROP
DB $26,<D0670,>D0670 ; LA D0670
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3622: fin
C1143:
; 3623: wend
C1027:
DB $30 ; DROP
; 3624: if scan_01() <> EOL_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$02 ; CB 2
DB $42 ; ISNE
DB $4C,<C1152,>C1152 ; SKPFLS C1152
; 3625: return parse_err_11(@bad_syntax)
DB $26,<D0670,>D0670 ; LA D0670
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3626: fin
C1152:
C1153:
; 3627: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3628: end
; 3629: def parse_var_11(type)
C1154: ; parse_var_11()
; type = 2
; 3630: byte consttype, constsize, idlen
; consttype = 4
; constsize = 5
; idlen = 6
; 3631: word idptr, constval, arraysize, size
; idptr = 7
; constval = 9
; arraysize = 11
; size = 13
; 3632:
; 3633: idlen = 0
JSR INTERP
DB $58,$0F,$01 ; ENTER 15,1
DB $00 ; ZERO
DB $74,$06 ; SLB 6
; 3634: size = 1
DB $2A,$01 ; CB 1
DB $76,$0D ; SLW 13
; 3635: if scan_01() == ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $40 ; ISEQ
DB $4C,<C1156,>C1156 ; SKPFLS C1156
; 3636: idptr = tknptr
DB $6A,<D0501,>D0501 ; LAW D0501
DB $76,$07 ; SLW 7
; 3637: idlen = tknlen
DB $68,<D0496,>D0496 ; LAB D0496
DB $74,$06 ; SLB 6
; 3638: if scan_01() == OPEN_BRACKET_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$DB ; CB 219
DB $40 ; ISEQ
DB $4C,<C1158,>C1158 ; SKPFLS C1158
; 3639: size = 0
DB $00 ; ZERO
DB $76,$0D ; SLW 13
; 3640: drop parse_constexpr_21(@size, @constsize)
DB $28,$0D ; LLA 13
DB $28,$05 ; LLA 5
DB $54,<C0932,>C0932 ; CALL C0932
DB $30 ; DROP
; 3641: if token <> CLOSE_BRACKET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$DD ; CB 221
DB $42 ; ISNE
DB $4C,<C1160,>C1160 ; SKPFLS C1160
; 3642: return parse_err_11(@no_close_bracket)
DB $26,<D0842,>D0842 ; LA D0842
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3643: fin
C1160:
C1161:
; 3644: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3645: fin
C1158:
C1159:
; 3646: fin
C1156:
C1157:
; 3647: if type == WORD_TYPE
DB $66,$02 ; LLW 2
DB $2A,$04 ; CB 4
DB $40 ; ISEQ
DB $4C,<C1162,>C1162 ; SKPFLS C1162
; 3648: size = size * 2
DB $66,$0D ; LLW 13
DB $2A,$02 ; CB 2
DB $06 ; MUL
DB $76,$0D ; SLW 13
; 3649: fin
C1162:
C1163:
; 3650: if token == SET_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$BD ; CB 189
DB $40 ; ISEQ
DB $4C,<C1164,>C1164 ; SKPFLS C1164
; 3651: if infunc
DB $68,<D1102,>D1102 ; LAB D1102
DB $4C,<C1166,>C1166 ; SKPFLS C1166
; 3652: return parse_err_11(@no_local_init)
DB $26,<D0934,>D0934 ; LA D0934
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3653: fin
C1166:
C1167:
; 3654: if idlen
DB $64,$06 ; LLB 6
DB $4C,<C1168,>C1168 ; SKPFLS C1168
; 3655: drop iddata_add_41(idptr, idlen, type, 0)
DB $66,$07 ; LLW 7
DB $64,$06 ; LLB 6
DB $66,$02 ; LLW 2
DB $00 ; ZERO
DB $54,<C0732,>C0732 ; CALL C0732
DB $30 ; DROP
; 3656: fin
C1168:
C1169:
; 3657: consttype = parse_constexpr_21(@constval, @constsize)
DB $28,$09 ; LLA 9
DB $28,$05 ; LLA 5
DB $54,<C0932,>C0932 ; CALL C0932
DB $74,$04 ; SLB 4
; 3658: if consttype
DB $64,$04 ; LLB 4
DB $4C,<C1170,>C1170 ; SKPFLS C1170
; 3659: arraysize = emit_data_41(type, consttype, constval, constsize)
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $66,$09 ; LLW 9
DB $64,$05 ; LLB 5
DB $54,<C0473,>C0473 ; CALL C0473
DB $76,$0B ; SLW 11
; 3660: while token == COMMA_TKN
C1172:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AC ; CB 172
DB $40 ; ISEQ
DB $4C,<C1173,>C1173 ; SKPFLS C1173
; 3661: consttype = parse_constexpr_21(@constval, @constsize)
DB $28,$09 ; LLA 9
DB $28,$05 ; LLA 5
DB $54,<C0932,>C0932 ; CALL C0932
DB $74,$04 ; SLB 4
; 3662: if consttype
DB $64,$04 ; LLB 4
DB $4C,<C1174,>C1174 ; SKPFLS C1174
; 3663: arraysize = arraysize + emit_data_41(type, consttype, constval, constsize)
DB $66,$0B ; LLW 11
DB $66,$02 ; LLW 2
DB $64,$04 ; LLB 4
DB $66,$09 ; LLW 9
DB $64,$05 ; LLB 5
DB $54,<C0473,>C0473 ; CALL C0473
DB $02 ; ADD
DB $76,$0B ; SLW 11
; 3664: else
DB $50,<C1175,>C1175 ; SKIP C1175
C1174:
; 3665: return parse_err_11(@bad_decl)
DB $26,<D0612,>D0612 ; LA D0612
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3666: fin
C1175:
; 3667: loop
DB $50,<C1172,>C1172 ; SKIP C1172
C1173:
; 3668: if token <> EOL_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$02 ; CB 2
DB $42 ; ISNE
DB $4C,<C1176,>C1176 ; SKPFLS C1176
; 3669: return parse_err_11(@no_close_bracket)
DB $26,<D0842,>D0842 ; LA D0842
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3670: fin
C1176:
C1177:
; 3671: iddata_size_30(PTR_TYPE, size, arraysize);
DB $2A,$60 ; CB 96
DB $66,$0D ; LLW 13
DB $66,$0B ; LLW 11
DB $54,<C0738,>C0738 ; CALL C0738
; 3672: else
DB $50,<C1171,>C1171 ; SKIP C1171
C1170:
; 3673: return parse_err_11(@bad_decl)
DB $26,<D0612,>D0612 ; LA D0612
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3674: fin
C1171:
; 3675: elsif idlen
DB $50,<C1165,>C1165 ; SKIP C1165
C1164:
DB $64,$06 ; LLB 6
DB $4C,<C1178,>C1178 ; SKPFLS C1178
; 3676: if infunc
DB $68,<D1102,>D1102 ; LAB D1102
DB $4C,<C1179,>C1179 ; SKPFLS C1179
; 3677: drop idlocal_add_41(idptr, idlen, type, size)
DB $66,$07 ; LLW 7
DB $64,$06 ; LLB 6
DB $66,$02 ; LLW 2
DB $66,$0D ; LLW 13
DB $54,<C0724,>C0724 ; CALL C0724
DB $30 ; DROP
; 3678: else
DB $50,<C1180,>C1180 ; SKIP C1180
C1179:
; 3679: drop iddata_add_41(idptr, idlen, type, size)
DB $66,$07 ; LLW 7
DB $64,$06 ; LLB 6
DB $66,$02 ; LLW 2
DB $66,$0D ; LLW 13
DB $54,<C0732,>C0732 ; CALL C0732
DB $30 ; DROP
; 3680: fin
C1180:
; 3681: fin
C1178:
C1165:
; 3682: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3683: end
; 3684: def parse_vars_01
C1181: ; parse_vars_01()
; 3685: byte idlen, type, size
; idlen = 2
; type = 3
; size = 4
; 3686: word value, idptr
; value = 5
; idptr = 7
; 3687:
; 3688: when token
JSR INTERP
DB $58,$09,$00 ; ENTER 9,0
DB $68,<D0495,>D0495 ; LAB D0495
; 3689: is CONST_TKN
DB $2A,$80 ; CB 128
DB $3E,<C1184,>C1184 ; SKPNE C1184
; 3690: if scan_01() <> ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $42 ; ISNE
DB $4C,<C1185,>C1185 ; SKPFLS C1185
; 3691: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3692: fin
C1185:
C1186:
; 3693: idptr = tknptr;
DB $6A,<D0501,>D0501 ; LAW D0501
DB $76,$07 ; SLW 7
; 3694: idlen = tknlen
DB $68,<D0496,>D0496 ; LAB D0496
DB $74,$02 ; SLB 2
; 3695: if scan_01() <> SET_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$BD ; CB 189
DB $42 ; ISNE
DB $4C,<C1187,>C1187 ; SKPFLS C1187
; 3696: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3697: fin
C1187:
C1188:
; 3698: if !parse_constexpr_21(@value, @size)
DB $28,$05 ; LLA 5
DB $28,$04 ; LLA 4
DB $54,<C0932,>C0932 ; CALL C0932
DB $20 ; NOT
DB $4C,<C1189,>C1189 ; SKPFLS C1189
; 3699: return parse_err_11(@bad_cnst)
DB $30 ; DROP
DB $26,<D0581,>D0581 ; LA D0581
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3700: fin
C1189:
C1190:
; 3701: drop idconst_add_31(idptr, idlen, value)
DB $66,$07 ; LLW 7
DB $64,$02 ; LLB 2
DB $66,$05 ; LLW 5
DB $54,<C0750,>C0750 ; CALL C0750
DB $30 ; DROP
; 3702: is BYTE_TKN
DB $50,<C1183,>C1183 ; SKIP C1183
C1184:
DB $2A,$81 ; CB 129
DB $3E,<C1191,>C1191 ; SKPNE C1191
; 3703: type = BYTE_TYPE
DB $2A,$02 ; CB 2
DB $74,$03 ; SLB 3
; 3704: repeat
C1193:
; 3705: if !parse_var_11(type)
DB $64,$03 ; LLB 3
DB $54,<C1154,>C1154 ; CALL C1154
DB $20 ; NOT
DB $4C,<C1194,>C1194 ; SKPFLS C1194
; 3706: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3707: fin
C1194:
C1195:
; 3708: until token <> COMMA_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AC ; CB 172
DB $42 ; ISNE
DB $4C,<C1193,>C1193 ; SKPFLS C1193
C1192:
; 3709: is WORD_TKN
DB $50,<C1183,>C1183 ; SKIP C1183
C1191:
DB $2A,$82 ; CB 130
DB $3E,<C1196,>C1196 ; SKPNE C1196
; 3710: type = WORD_TYPE
DB $2A,$04 ; CB 4
DB $74,$03 ; SLB 3
; 3711: repeat
C1198:
; 3712: if !parse_var_11(type)
DB $64,$03 ; LLB 3
DB $54,<C1154,>C1154 ; CALL C1154
DB $20 ; NOT
DB $4C,<C1199,>C1199 ; SKPFLS C1199
; 3713: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3714: fin
C1199:
C1200:
; 3715: until token <> COMMA_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AC ; CB 172
DB $42 ; ISNE
DB $4C,<C1198,>C1198 ; SKPFLS C1198
C1197:
; 3716: is FUNC_TKN
DB $50,<C1183,>C1183 ; SKIP C1183
C1196:
DB $2A,$9E ; CB 158
DB $3E,<C1201,>C1201 ; SKPNE C1201
; 3717: repeat
C1203:
; 3718: if scan_01() == ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $40 ; ISEQ
DB $4C,<C1204,>C1204 ; SKPFLS C1204
; 3719: drop idfunc_add_31(tknptr, tknlen, ctag_new_01())
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0445,>C0445 ; CALL C0445
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 3720: else
DB $50,<C1205,>C1205 ; SKIP C1205
C1204:
; 3721: return parse_err_11(@bad_decl)
DB $30 ; DROP
DB $26,<D0612,>D0612 ; LA D0612
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3722: fin
C1205:
; 3723: until scan_01() <> COMMA_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$AC ; CB 172
DB $42 ; ISNE
DB $4C,<C1203,>C1203 ; SKPFLS C1203
C1202:
; 3724: is EOL_TKN
DB $50,<C1183,>C1183 ; SKIP C1183
C1201:
DB $2A,$02 ; CB 2
DB $3E,<C1206,>C1206 ; SKPNE C1206
; 3725: return TRUE
DB $30 ; DROP
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3726: otherwise
DB $50,<C1183,>C1183 ; SKIP C1183
C1206:
; 3727: return FALSE
DB $30 ; DROP
DB $00 ; ZERO
DB $5A ; LEAVE
; 3728: wend
C1183:
DB $30 ; DROP
; 3729: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3730: end
; 3731: def parse_func_01
C1208: ; parse_func_01()
; 3732: byte opt, cfnparms
; opt = 2
; cfnparms = 3
; 3733: word func_tag, idptr
; func_tag = 4
; idptr = 6
; 3734:
; 3735: if token == IFUNC_TKN or token == NFUNC_TKN
JSR INTERP
DB $58,$08,$00 ; ENTER 8,0
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$95 ; CB 149
DB $40 ; ISEQ
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$96 ; CB 150
DB $40 ; ISEQ
DB $22 ; LOR
DB $4C,<C1210,>C1210 ; SKPFLS C1210
; 3736: opt = token - IFUNC_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$95 ; CB 149
DB $04 ; SUB
DB $74,$02 ; SLB 2
; 3737: if scan_01() <> ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $42 ; ISNE
DB $4C,<C1212,>C1212 ; SKPFLS C1212
; 3738: return parse_err_11(@bad_decl)
DB $26,<D0612,>D0612 ; LA D0612
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3739: fin
C1212:
C1213:
; 3740: cfnparms = 0
DB $00 ; ZERO
DB $74,$03 ; SLB 3
; 3741: infunc = TRUE
DB $2C,$FF,$FF ; CW -1
DB $78,<D1102,>D1102 ; SAB D1102
; 3742: idptr = idglobal_lookup_21(tknptr, tknlen)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $54,<C0722,>C0722 ; CALL C0722
DB $76,$06 ; SLW 6
; 3743: if idptr
DB $66,$06 ; LLW 6
DB $4C,<C1214,>C1214 ; SKPFLS C1214
; 3744: func_tag = (idptr):idval
DB $66,$06 ; LLW 6
DB $62 ; LW
DB $76,$04 ; SLW 4
; 3745: else
DB $50,<C1215,>C1215 ; SKIP C1215
C1214:
; 3746: func_tag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $76,$04 ; SLW 4
; 3747: drop idfunc_add_31(tknptr, tknlen, func_tag)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $66,$04 ; LLW 4
DB $54,<C0748,>C0748 ; CALL C0748
DB $30 ; DROP
; 3748: fin
C1215:
; 3749: emit_codetag_10(func_tag)
DB $66,$04 ; LLW 4
DB $54,<C0461,>C0461 ; CALL C0461
; 3750: retfunc_tag = ctag_new_01()
DB $54,<C0445,>C0445 ; CALL C0445
DB $7A,<D1105,>D1105 ; SAW D1105
; 3751: idlocal_init()
DB $54,<C0754,>C0754 ; CALL C0754
; 3752: if scan_01() == OPEN_PAREN_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$A8 ; CB 168
DB $40 ; ISEQ
DB $4C,<C1216,>C1216 ; SKPFLS C1216
; 3753: repeat
C1219:
; 3754: if scan_01() == ID_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$D6 ; CB 214
DB $40 ; ISEQ
DB $4C,<C1220,>C1220 ; SKPFLS C1220
; 3755: cfnparms = cfnparms + 1
DB $64,$03 ; LLB 3
DB $2A,$01 ; CB 1
DB $02 ; ADD
DB $74,$03 ; SLB 3
; 3756: drop idlocal_add_41(tknptr, tknlen, WORD_TYPE, 2)
DB $6A,<D0501,>D0501 ; LAW D0501
DB $68,<D0496,>D0496 ; LAB D0496
DB $2A,$04 ; CB 4
DB $2A,$02 ; CB 2
DB $54,<C0724,>C0724 ; CALL C0724
DB $30 ; DROP
; 3757: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3758: fin
C1220:
C1221:
; 3759: until token <> COMMA_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$AC ; CB 172
DB $42 ; ISNE
DB $4C,<C1219,>C1219 ; SKPFLS C1219
C1218:
; 3760: if token <> CLOSE_PAREN_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$A9 ; CB 169
DB $42 ; ISNE
DB $4C,<C1222,>C1222 ; SKPFLS C1222
; 3761: return parse_err_11(@bad_decl)
DB $26,<D0612,>D0612 ; LA D0612
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3762: fin
C1222:
C1223:
; 3763: drop scan_01()
DB $54,<C0629,>C0629 ; CALL C0629
DB $30 ; DROP
; 3764: fin
C1216:
C1217:
; 3765: while parse_vars_01()
C1224:
DB $54,<C1181,>C1181 ; CALL C1181
DB $4C,<C1225,>C1225 ; SKPFLS C1225
; 3766: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3767: loop
DB $50,<C1224,>C1224 ; SKIP C1224
C1225:
; 3768: emit_enter_20(framesize, cfnparms)
DB $6A,<D0484,>D0484 ; LAW D0484
DB $64,$03 ; LLB 3
DB $54,<C0599,>C0599 ; CALL C0599
; 3769: prevstmnt = 0
DB $00 ; ZERO
DB $78,<D1104,>D1104 ; SAB D1104
; 3770: while parse_stmnt_01()
C1226:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1227,>C1227 ; SKPFLS C1227
; 3771: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3772: loop
DB $50,<C1226,>C1226 ; SKIP C1226
C1227:
; 3773: infunc = FALSE
DB $00 ; ZERO
DB $78,<D1102,>D1102 ; SAB D1102
; 3774: if token <> END_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$87 ; CB 135
DB $42 ; ISNE
DB $4C,<C1228,>C1228 ; SKPFLS C1228
; 3775: return parse_err_11(@bad_syntax)
DB $26,<D0670,>D0670 ; LA D0670
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3776: fin
C1228:
C1229:
; 3777: if scan_01() <> EOL_TKN
DB $54,<C0629,>C0629 ; CALL C0629
DB $2A,$02 ; CB 2
DB $42 ; ISNE
DB $4C,<C1230,>C1230 ; SKPFLS C1230
; 3778: return parse_err_11(@bad_syntax)
DB $26,<D0670,>D0670 ; LA D0670
DB $54,<C0441,>C0441 ; CALL C0441
DB $5A ; LEAVE
; 3779: fin
C1230:
C1231:
; 3780: if prevstmnt <> RETURN_TKN
DB $68,<D1104,>D1104 ; LAB D1104
DB $2A,$99 ; CB 153
DB $42 ; ISNE
DB $4C,<C1232,>C1232 ; SKPFLS C1232
; 3781: emit_leave_10(framesize)
DB $6A,<D0484,>D0484 ; LAW D0484
DB $54,<C0595,>C0595 ; CALL C0595
; 3782: fin
C1232:
C1233:
; 3783: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3784: elsif token == EOL_TKN
DB $50,<C1211,>C1211 ; SKIP C1211
C1210:
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$02 ; CB 2
DB $40 ; ISEQ
DB $4C,<C1234,>C1234 ; SKPFLS C1234
; 3785: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5A ; LEAVE
; 3786: fin
C1234:
C1211:
; 3787: return FALSE
DB $00 ; ZERO
DB $5A ; LEAVE
; 3788: end
; 3789: def parse_module_01
C0002: ; parse_module_01()
; 3790: entrypoint = 0
JSR INTERP
DB $00 ; ZERO
DB $7A,<D0492,>D0492 ; SAW D0492
; 3791: idglobal_init()
DB $54,<C0752,>C0752 ; CALL C0752
; 3792: idlocal_init()
DB $54,<C0754,>C0754 ; CALL C0754
; 3793: if nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $4C,<C1236,>C1236 ; SKPFLS C1236
; 3794: while parse_vars_01()
C1238:
DB $54,<C1181,>C1181 ; CALL C1181
DB $4C,<C1239,>C1239 ; SKPFLS C1239
; 3795: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3796: loop
DB $50,<C1238,>C1238 ; SKIP C1238
C1239:
; 3797: while parse_func_01()
C1240:
DB $54,<C1208,>C1208 ; CALL C1208
DB $4C,<C1241,>C1241 ; SKPFLS C1241
; 3798: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3799: loop
DB $50,<C1240,>C1240 ; SKIP C1240
C1241:
; 3800: if token <> DONE_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$98 ; CB 152
DB $42 ; ISNE
DB $4C,<C1242,>C1242 ; SKPFLS C1242
; 3801: emit_start()
DB $54,<C0603,>C0603 ; CALL C0603
; 3802: prevstmnt = 0
DB $00 ; ZERO
DB $78,<D1104,>D1104 ; SAB D1104
; 3803: while parse_stmnt_01()
C1244:
DB $54,<C1023,>C1023 ; CALL C1023
DB $4C,<C1245,>C1245 ; SKPFLS C1245
; 3804: drop nextln_01()
DB $54,<C0682,>C0682 ; CALL C0682
DB $30 ; DROP
; 3805: loop
DB $50,<C1244,>C1244 ; SKIP C1244
C1245:
; 3806: if token <> DONE_TKN
DB $68,<D0495,>D0495 ; LAB D0495
DB $2A,$98 ; CB 152
DB $42 ; ISNE
DB $4C,<C1246,>C1246 ; SKPFLS C1246
; 3807: drop parse_err_11(@no_done)
DB $26,<D0921,>D0921 ; LA D0921
DB $54,<C0441,>C0441 ; CALL C0441
DB $30 ; DROP
; 3808: fin
C1246:
C1247:
; 3809: if prevstmnt <> EXIT_TKN
DB $68,<D1104,>D1104 ; LAB D1104
DB $2A,$9C ; CB 156
DB $42 ; ISNE
DB $4C,<C1248,>C1248 ; SKPFLS C1248
; 3810: emit_const_10(0)
DB $00 ; ZERO
DB $54,<C0482,>C0482 ; CALL C0482
; 3811: emit_exit()
DB $54,<C0605,>C0605 ; CALL C0605
; 3812: fin
C1248:
C1249:
; 3813: fin
C1242:
C1243:
; 3814: ; dumpsym(idglobal_tbl, globals)
; 3815: ; prstr(@entrypt_str)
; 3816: ; prword(entrypoint)
; 3817: ; crout()
; 3818: ; keyin_01()
; 3819: return TRUE
DB $2C,$FF,$FF ; CW -1
DB $5C ; RET
; 3820: fin
C1236:
C1237:
; 3821: return FALSE
DB $00 ; ZERO
DB $5C ; RET
; 3822: end
; 3823: ;
; 3824: ; Init editor
; 3825: ;
; 3826: if !(^machid & $80)
START: ; JSR INTERP
DB $2C,$98,$BF ; CW 49048
DB $60 ; LB
DB $2A,$80 ; CB 128
DB $14 ; BAND
DB $20 ; NOT
DB $4C,<C1250,>C1250 ; SKPFLS C1250
; 3827: flags = uppercase ? shiftlock
DB $2A,$08 ; CB 8
DB $2A,$80 ; CB 128
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 3828: keyin_01 = @keyin2_01
DB $26,<C0240,>C0240 ; LA C0240
DB $7A,<D0210,>D0210 ; SAW D0210
; 3829: else
DB $50,<C1251,>C1251 ; SKIP C1251
C1250:
; 3830: keyin_01 = @keyin2e_01
DB $26,<C0236,>C0236 ; LA C0236
DB $7A,<D0210,>D0210 ; SAW D0210
; 3831: fin
C1251:
; 3832: inittxtbuf()
DB $54,<C0085,>C0085 ; CALL C0085
; 3833: if ^argbuff
DB $2C,$06,$20 ; CW 8198
DB $60 ; LB
DB $4C,<C1252,>C1252 ; SKPFLS C1252
; 3834: strcpy_20(argbuff, @txtfile)
DB $2C,$06,$20 ; CW 8198
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0047,>C0047 ; CALL C0047
; 3835: prstr(@txtfile)
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0019,>C0019 ; CALL C0019
; 3836: readtxt_10(@txtfile)
DB $26,<D0141,>D0141 ; LA D0141
DB $54,<C0135,>C0135 ; CALL C0135
; 3837: else
DB $50,<C1253,>C1253 ; SKIP C1253
C1252:
; 3838: numlines = 1
DB $2A,$01 ; CB 1
DB $7A,<D0206,>D0206 ; SAW D0206
; 3839: fin
C1253:
; 3840: curschr = '+'
DB $2A,$2B ; CB 43
DB $78,<D0199,>D0199 ; SAB D0199
; 3841: flags = flags ? insmode
DB $68,<D0192,>D0192 ; LAB D0192
DB $2A,$02 ; CB 2
DB $16 ; IOR
DB $78,<D0192,>D0192 ; SAB D0192
; 3842: drawscrn_20(scrntop, scrnleft)
DB $6A,<D0202,>D0202 ; LAW D0202
DB $68,<D0196,>D0196 ; LAB D0196
DB $54,<C0165,>C0165 ; CALL C0165
; 3843: curson()
DB $54,<C0177,>C0177 ; CALL C0177
; 3844: editmode()
DB $54,<C0332,>C0332 ; CALL C0332
; 3845: done
DB $5C ; RET
Reference in New Issue View Git Blame Copy Permalink