********************************************************************************
* Integer BASIC for the Apple II *
* By Steve Wozniak *
* Copyright 1977 by Apple Computer, Inc. *
********************************************************************************
* Disassembly by Paul R. Santa-Maria. *
* *
* "Ported" to SourceGen format by Andy McFadden, using 6502bench SourceGen *
* v1.8. The listing here generally follows the original, except for a few *
* places where SourceGen's limited expressions make it awkward. I added a few *
* additional labels, mostly on loops. *
* *
* Last updated 2021/10/17 *
********************************************************************************
* The binary was extracted from the INTBASIC file on the DOS 3.3 system *
* master, for the region spanning $e000-f7ff. That file also includes PA#1 *
* from $d000-dfff, and the original F8 monitor ROM from $f800-ffff. *
* *
* As noted in Paul R. Santa-Maria's article, there is no original assembly *
* file for Integer BASIC. The entire program was written out by hand. *
********************************************************************************
ETX .eq $03 {const} ;Ctrl+C
CR .eq $0d {const} ;carriage return
BLANK .eq $20 {const} ;space
DQT .eq $22 {const} ;double quote
MON_WNDWDTH .eq $21 ;width of scroll window
MON_CH .eq $24 ;cursor horizontal displacement
MON_CV .eq $25 ;cursor vertical displacement
MON_GBASL .eq $26 ;base address for lo-res drawing (lo)
MON_H2 .eq $2c ;right end of horizontal line drawn by HLINE
MON_V2 .eq $2d ;bottom of vertical line drawn by VLINE
MON_PROMPT .eq $33 ;prompt character
MON_A1L .eq $3c ;general purpose
MON_A1H .eq $3d ;general purpose
MON_A2L .eq $3e ;general purpose
MON_A2H .eq $3f ;general purpose
LOMEM .eq $4a {addr/2} ;pointer to start of variables
HIMEM .eq $4c {addr/2} ;pointer to end of program
MON_RNDL .eq $4e ;low byte of KEYIN "random" value
MON_RNDH .eq $4f ;high byte of KEYIN "random" value
NOUNSTKL .eq $50 {addr/8} ;noun stack low bytes
SYNSTKH .eq $58 ;syntax stack high byte
NOUNSTKH .eq $78 {addr/32} ;noun stack high bytes
SYNSTKL .eq $80 {addr/32} ;syntax stack low bytes
NOUNSTKC .eq $a0 {addr/32} ;noun stack counter
TXTNDXSTK .eq $a8 {addr/32} ;text index stack
TXTNDX .eq $c8 ;text index val (OUTVAL)
LEADBL .eq $c9 ;leading blanks index (YTEMP)
PP .eq $ca {addr/2} ;pointer to start of program
PV .eq $cc {addr/2} ;pointer to end of vars
ACC .eq $ce {addr/2} ;main accumulator
SRCH .eq $d0 {addr/2} ;pointer to search var table
TOKNDXSTK .eq $d1 {addr/32} ;token index stack
SRCH2 .eq $d2 {addr/2} ;second var search pointer
IFFLAG .eq $d4 ;IF/THEN fail flag
CRFLAG .eq $d5 ;carriage return flag
VERBNOW .eq $d6 ;verb currently in use
PRFLAG .eq $d7 ;print it now flag
XSAVE .eq $d8 ;temp X-reg save
RUNFLAG .eq $d9 ;run mode flag
AUX .eq $da {addr/2} ;aux counter
PR .eq $dc {addr/2} ;current line value
PX .eq $e0 {addr/2} ;pointer to current verb
P1 .eq $e2 {addr/2} ;aux pointer 1 (delete line ptr)
P2 .eq $e4 {addr/2} ;aux pointer 2 (line num , next num, ...)
P3 .eq $e6 {addr/2} ;aux pointer 3 (next ptr)
TOKNDX .eq $f1 ;token index val
PCON .eq $f2 {addr/2} ;continue pointer (PRDEC low/hi)
AUTOINC .eq $f4 {addr/2} ;auto line increment
AUTOLN .eq $f6 {addr/2} ;current auto line
AUTOFLAG .eq $f8 ;auto line mode flag ($ff=on)
CHAR .eq $f9 ;current char
LEADZR .eq $fa ;leading zeroes index ($00,$a0,$b0)
FORNDX .eq $fb ;FOR-NEXT loop index
GOSUBNDX .eq $fc ;GOSUB index
SYNSTKDX .eq $fd ;syntax stack index val
SYNPAG .eq $fe {addr/2} ;pointer to syntax page
STK_00 .eq $0100 {addr/15}
STK_10 .eq $0110 {addr/15}
STK_20 .eq $0120 {addr/15}
STK_30 .eq $0130 {addr/15}
STK_40 .eq $0140 {addr/15}
STK_50 .eq $0150 {addr/15}
STK_60 .eq $0160 {addr/15}
STK_70 .eq $0170 {addr/15}
STK_80 .eq $0180 {addr/15}
STK_90 .eq $0190 {addr/15}
STK_A0 .eq $01a0 {addr/15}
STK_B0 .eq $01b0 {addr/15}
STK_C0 .eq $01c0 {addr/15}
STK_D0 .eq $01d0 {addr/15}
IN .eq $0200 {addr/256} ;input buffer
KBD .eq $c000 ;R last key pressed + 128
KBDSTRB .eq $c010 ;RW keyboard strobe
MON_PLOT .eq $f800 ;lo-res plot at X=Y-reg, Y=Acc
MON_HLINE .eq $f819 ;lo-res horiz line at Y=Acc with X from $2c
MON_VLINE .eq $f828 ;lo-res vert line at X=Y-reg and Y from Acc to $2b
MON_GBASCALC .eq $f847 ;compute gfx base addr for line in Acc
MON_SETCOL .eq $f864 ;set lo-res color to Acc
MON_PREAD .eq $fb1e ;read paddle specifed by X-reg, return in Y-reg
MON_SETTXT .eq $fb39 ;set screen to text mode
MON_SETGR .eq $fb40 ;set screen to graphics mode
MON_VTAB .eq $fc22 ;tab to row specified in Acc
MON_NXTCHAR .eq $fd75
MON_CROUT .eq $fd8e ;print a carriage return
MON_COUT .eq $fded ;print Acc to output device via $36-37
MON_INPORT .eq $fe8b
MON_OUTPORT .eq $fe95
MON_WRITE .eq $fecd ;write data to cassette
MON_WRITE0 .eq $fecf
MON_READ .eq $fefd ;read data from cassette
MON_BELL .eq $ff3a ;sound bell
.addrs $e000
e000: 20 00 f0 BASIC jsr COLD
e003: 4c b3 e2 BASIC2 jmp WARM
e006: 85 33 SetPrompt sta MON_PROMPT
e008: 4c ed fd jmp MON_COUT
e00b: 60 .dd1 $60
e00c: 8a LE00C txa ;print a trailing blank?
e00d: 29 20 and #$20
e00f: f0 23 beq :Return
e011: a9 a0 LE011 lda #BLANK+128
e013: 85 e4 sta P2
e015: 4c ed fd jmp MON_COUT
e018: a9 20 LE018 lda #32
e01a: c5 24 LE01A cmp MON_CH ;check line length
e01c: b0 0c bcs NextByte ;line too short
e01e: a9 8d lda #CR+128 ;print CR, then 7 blanks
e020: a0 07 ldy #$07
e022: 20 ed fd :Loop jsr MON_COUT
e025: a9 a0 lda #BLANK+128
e027: 88 dey
e028: d0 f8 bne :Loop
;
e02a: a0 00 NextByte ldy #$00 ;get next byte 16-bit ptr
e02c: b1 e2 lda (P1),y
e02e: e6 e2 inc P1
e030: d0 02 bne :Return
e032: e6 e3 inc P1+1
e034: 60 :Return rts
;
; Token $75 , (with token $74 LIST)
; LIST 5,30
;
e035: 20 15 e7 COMMA_LIST jsr GET16BIT
e038: 20 76 e5 jsr LE576
e03b: a5 e2 LE03B lda P1
e03d: c5 e6 cmp P3
e03f: a5 e3 lda P1+1
e041: e5 e7 sbc P3+1
e043: b0 ef bcs :Return
e045: 20 6d e0 jsr UNPACK
e048: 4c 3b e0 jmp LE03B
;
; Token $76 LIST
; list entire program
;
e04b: a5 ca LIST lda PP ;P1 = PP
e04d: 85 e2 sta P1
e04f: a5 cb lda PP+1
e051: 85 e3 sta P1+1
e053: a5 4c lda HIMEM ;P3 = HIMEM
e055: 85 e6 sta P3
e057: a5 4d lda HIMEM+1
e059: 85 e7 sta P3+1
e05b: d0 de bne LE03B ;(always)
;
; Token $74 LIST
; specific line number or range of numbers
; LIST 10: LIST 5,30
;
e05d: 20 15 e7 LISTNUM jsr GET16BIT
e060: 20 6d e5 jsr LE56D
e063: a5 e4 lda P2 ;P1 = P2
e065: 85 e2 sta P1
e067: a5 e5 lda P2+1
e069: 85 e3 sta P1+1
e06b: b0 c7 bcs :Return
; Unpack tokens to mnemonics.
e06d: 86 d8 UNPACK stx XSAVE
e06f: a9 a0 lda #BLANK+128
e071: 85 fa sta LEADZR
e073: 20 2a e0 jsr NextByte
e076: 98 tya
e077: 85 e4 LE077 sta P2
e079: 20 2a e0 jsr NextByte
e07c: aa tax
e07d: 20 2a e0 jsr NextByte
e080: 20 1b e5 jsr PRDEC
e083: 20 18 e0 :Loop jsr LE018
e086: 84 fa sty LEADZR
e088: aa tax
e089: 10 18 bpl LE0A3
e08b: 0a asl A
e08c: 10 e9 bpl LE077
e08e: a5 e4 lda P2
e090: d0 03 bne :NotEq
e092: 20 11 e0 jsr LE011
e095: 8a :NotEq txa
e096: 20 ed fd :Loop jsr MON_COUT
e099: a9 25 LE099 lda #$25
e09b: 20 1a e0 jsr LE01A
e09e: aa tax
e09f: 30 f5 bmi :Loop
e0a1: 85 e4 sta P2
e0a3: c9 01 LE0A3 cmp #$01
e0a5: d0 05 bne :NotEq
e0a7: a6 d8 ldx XSAVE
e0a9: 4c 8e fd jmp MON_CROUT
e0ac: 48 :NotEq pha
e0ad: 84 ce sty ACC
e0af: a2 ed ldx #>SYNTABL2
e0b1: 86 cf stx ACC+1
e0b3: c9 51 cmp #$51 ;END token
e0b5: 90 04 bcc :Loop1
e0b7: c6 cf dec ACC+1 ;in SYNTABL
e0b9: e9 50 sbc #$50 ;TAB tkn
e0bb: 48 :Loop1 pha
e0bc: b1 ce lda (ACC),y
e0be: aa :Loop2 tax
e0bf: 88 dey
e0c0: b1 ce lda (ACC),y
e0c2: 10 fa bpl :Loop2
e0c4: e0 c0 cpx #$c0
e0c6: b0 04 bcs LE0CC
e0c8: e0 00 cpx #$00
e0ca: 30 f2 bmi :Loop2
e0cc: aa LE0CC tax
e0cd: 68 pla
e0ce: e9 01 sbc #$01 ;carry is set
e0d0: d0 e9 bne :Loop1
e0d2: 24 e4 bit P2
e0d4: 30 03 bmi :Loop
e0d6: 20 f8 ef jsr LEFF8
e0d9: b1 ce :Loop lda (ACC),y
e0db: 10 10 bpl LE0ED
e0dd: aa tax
e0de: 29 3f and #$3f
e0e0: 85 e4 sta P2
e0e2: 18 clc
e0e3: 69 a0 adc #BLANK+128
e0e5: 20 ed fd jsr MON_COUT
e0e8: 88 dey
e0e9: e0 c0 cpx #$c0
e0eb: 90 ec bcc :Loop
e0ed: 20 0c e0 LE0ED jsr LE00C
e0f0: 68 pla
e0f1: c9 5d cmp #‘]’
e0f3: f0 a4 beq LE099
e0f5: c9 28 cmp #‘(’
e0f7: d0 8a bne :Loop
e0f9: f0 9e beq LE099 ;(always)
;
; Token $2a (
; substring
; PRINT A$(12,14)
;
e0fb: 20 18 e1 PAREN_SUBSTR jsr LE118
e0fe: 95 50 sta NOUNSTKL,x
e100: d5 78 cmp NOUNSTKH,x
e102: 90 11 LE102 bcc LE115
e104: a0 2b PrintErr05 ldy #<ErrMsg05 ;"STRING"
e106: 4c e0 e3 LE106 jmp ERRMESS
;
; Token $23 ,
; substring
; PRINT A$(3,3)
;
e109: 20 34 ee COMMA_SUBSTR jsr GETBYTE
e10c: d5 50 cmp NOUNSTKL,x
e10e: 90 f4 bcc PrintErr05 ;"STRING"
e110: 20 e4 ef jsr LEFE4
e113: 95 78 sta NOUNSTKH,x
e115: 4c 23 e8 LE115 jmp TE823
e118: 20 34 ee LE118 jsr GETBYTE
e11b: f0 e7 beq PrintErr05 ;"STRING"
e11d: 38 sec
e11e: e9 01 sbc #$01
e120: 60 rts
;
; Token $42 (
; string array is destination of the data
; A$(1)="HELLO"
;
e121: 20 18 e1 TE121 jsr LE118
e124: 95 50 sta NOUNSTKL,x
e126: 18 clc
e127: f5 78 sbc NOUNSTKH,x
e129: 4c 02 e1 jmp LE102
e12c: a0 14 PrintErr03 ldy #<ErrMsg03 ;"MEM FULL"
e12e: d0 d6 bne LE106 ;(always)
;
; Token $43 ,
; next var in DIM statement is string
; DIM X(5),A$(5)
;
; token $4e DIM
; string var uses token $22 (
; DIM A$(5)
;
e130: 20 18 e1 DIMSTR jsr LE118
e133: e8 inx
e134: b5 50 LE134 lda NOUNSTKL,x
e136: 85 da sta AUX
e138: 65 ce adc ACC
e13a: 48 pha
e13b: a8 tay
e13c: b5 78 lda NOUNSTKH,x
e13e: 85 db sta AUX+1
e140: 65 cf adc ACC+1
e142: 48 pha
e143: c4 ca cpy PP
e145: e5 cb sbc PP+1
e147: b0 e3 bcs PrintErr03 ;"MEM FULL"
e149: a5 da lda AUX ;AUX = AUX - 2
e14b: 69 fe adc #$fe
e14d: 85 da sta AUX
e14f: a9 ff lda #$ff
e151: a8 tay
e152: 65 db adc AUX+1
e154: 85 db sta AUX+1
e156: c8 :Loop1 iny
e157: b1 da lda (AUX),y
e159: d9 cc 00 cmp PV,y
e15c: d0 0f bne DimErr
e15e: 98 tya
e15f: f0 f5 beq :Loop1
e161: 68 :Loop2 pla
e162: 91 da sta (AUX),y
e164: 99 cc 00 sta PV,y
e167: 88 dey
e168: 10 f7 bpl :Loop2
e16a: e8 inx
e16b: 60 rts
e16c: ea .dd1 $ea
e16d: a0 80 DimErr ldy #<ErrMsg17 ;"DIM"
e16f: d0 95 LE16F bne LE106 ;(always)
;
; Input a string.
;
e171: a9 00 INPUTSTR lda #$00
e173: 20 0a e7 jsr LE70A
e176: a0 02 ldy #$02
e178: 94 78 sty NOUNSTKH,x
e17a: 20 0a e7 jsr LE70A
e17d: 86 d8 stx XSAVE
e17f: aa tax
e180: e6 33 inc MON_PROMPT ;change '>' to '?'
e182: 20 51 f3 jsr RDKEY
e185: c6 33 dec MON_PROMPT ;change '?' to '>'
e187: 8a txa
e188: a6 d8 ldx XSAVE
e18a: 95 78 sta NOUNSTKH,x
;
; Token $70 =
; string - non-conditional
; A$ = "HELLO"
;
e18c: b5 51 TE18C lda NOUNSTKL+1,x
e18e: 85 ce sta ACC
e190: b5 79 lda NOUNSTKH+1,x
e192: 85 cf sta ACC+1
e194: e8 inx
e195: e8 inx
e196: 20 bc e1 jsr LE1BC
e199: b5 4e :Loop lda NOUNSTKL-2,x
e19b: d5 76 cmp NOUNSTKH-2,x
e19d: b0 15 bcs LE1B4
e19f: f6 4e inc NOUNSTKL-2,x
e1a1: a8 tay
e1a2: b1 ce lda (ACC),y
e1a4: b4 50 ldy NOUNSTKL,x
e1a6: c4 e4 cpy P2
e1a8: 90 04 bcc LE1AE
e1aa: a0 83 ldy #<ErrMsg18 ;"STR OVFL"
e1ac: d0 c1 bne LE16F ;(always)
e1ae: 91 da LE1AE sta (AUX),y
e1b0: f6 50 inc NOUNSTKL,x
e1b2: 90 e5 bcc :Loop
e1b4: b4 50 LE1B4 ldy NOUNSTKL,x
e1b6: 8a txa
e1b7: 91 da sta (AUX),y
e1b9: 4c 23 f2 jmp LF223
e1bc: b5 51 LE1BC lda NOUNSTKL+1,x
e1be: 85 da sta AUX
e1c0: 38 sec
e1c1: e9 02 sbc #$02
e1c3: 85 e4 sta P2
e1c5: b5 79 lda NOUNSTKH+1,x
e1c7: 85 db sta AUX+1
e1c9: e9 00 sbc #$00
e1cb: 85 e5 sta P2+1
e1cd: a0 00 ldy #$00
e1cf: b1 e4 lda (P2),y
e1d1: 18 clc
e1d2: e5 da sbc AUX
e1d4: 85 e4 sta P2
e1d6: 60 rts
;
; Token $39 =
; string logic op
; IF A$ = "CAT" THEN END
;
e1d7: b5 53 TE1D7 lda NOUNSTKL+3,x
e1d9: 85 ce sta ACC
e1db: b5 7b lda NOUNSTKH+3,x
e1dd: 85 cf sta ACC+1
e1df: b5 51 lda NOUNSTKL+1,x
e1e1: 85 da sta AUX
e1e3: b5 79 lda NOUNSTKH+1,x
e1e5: 85 db sta AUX+1
e1e7: e8 inx
e1e8: e8 inx
e1e9: e8 inx
e1ea: a0 00 ldy #$00
e1ec: 94 78 sty NOUNSTKH,x
e1ee: 94 a0 sty NOUNSTKC,x
e1f0: c8 iny
e1f1: 94 50 sty NOUNSTKL,x
e1f3: b5 4d LE1F3 lda HIMEM+1,x
e1f5: d5 75 cmp NOUNSTKH-3,x
e1f7: 08 php
e1f8: 48 pha
e1f9: b5 4f lda NOUNSTKL-1,x
e1fb: d5 77 cmp NOUNSTKH-1,x
e1fd: 90 07 bcc LE206
e1ff: 68 pla
e200: 28 plp
e201: b0 02 bcs :Return
e203: 56 50 :LoopExit lsr NOUNSTKL,x
e205: 60 :Return rts
e206: a8 LE206 tay
e207: b1 ce lda (ACC),y
e209: 85 e4 sta P2
e20b: 68 pla
e20c: a8 tay
e20d: 28 plp
e20e: b0 f3 bcs :LoopExit
e210: b1 da lda (AUX),y
e212: c5 e4 cmp P2
e214: d0 ed bne :LoopExit
e216: f6 4f inc NOUNSTKL-1,x
e218: f6 4d inc HIMEM+1,x
e21a: b0 d7 bcs LE1F3 ;(always)
;
; Token $3a #
; string logic op
; IF A$ # "CAT" THEN END
;
e21c: 20 d7 e1 TE21C jsr TE1D7
e21f: 4c 36 e7 jmp NOT
;
; Token $14 *
; num math op
; A = 27 * 2
;
e222: 20 54 e2 MULT jsr LE254
e225: 06 ce :Loop asl ACC
e227: 26 cf rol ACC+1 ;add partial product if C flag set
e229: 90 0d bcc LE238
e22b: 18 clc
e22c: a5 e6 lda P3
e22e: 65 da adc AUX
e230: 85 e6 sta P3
e232: a5 e7 lda P3+1
e234: 65 db adc AUX+1
e236: 85 e7 sta P3+1
e238: 88 LE238 dey
e239: f0 09 beq MultEnd ;exit loop
e23b: 06 e6 asl P3
e23d: 26 e7 rol P3+1
e23f: 10 e4 bpl :Loop
e241: 4c 7e e7 jmp Err32767
e244: a5 e6 MultEnd lda P3
e246: 20 08 e7 jsr LE708
e249: a5 e7 lda P3+1
e24b: 95 a0 sta NOUNSTKC,x
e24d: 06 e5 asl P2+1
e24f: 90 28 bcc :Return
e251: 4c 6f e7 jmp NEGATE
e254: a9 55 LE254 lda #$55
e256: 85 e5 sta P2+1
e258: 20 5b e2 jsr LE25B
e25b: a5 ce LE25B lda ACC ;AUX = ACC
e25d: 85 da sta AUX
e25f: a5 cf lda ACC+1
e261: 85 db sta AUX+1
e263: 20 15 e7 jsr GET16BIT
e266: 84 e6 sty P3
e268: 84 e7 sty P3+1
e26a: a5 cf lda ACC+1
e26c: 10 09 bpl LE277
e26e: ca dex
e26f: 06 e5 asl P2+1
e271: 20 6f e7 jsr NEGATE
e274: 20 15 e7 jsr GET16BIT
e277: a0 10 LE277 ldy #$10
e279: 60 :Return rts
;
; Token $1f MOD
; num op
; IF X MOD 13 THEN END
;
e27a: 20 6c ee MOD jsr LEE6C
e27d: f0 c5 beq MultEnd ;(always)
e27f: ff .dd1 $ff
e280: e6 33 LE280 inc MON_PROMPT ;change '>' to '?'
e282: a0 00 ldy #$00
e284: 20 ce e3 jsr GETCMD
e287: c6 33 dec MON_PROMPT ;change '?' to '>'
e289: 60 rts
;
; Token $3d SCRN(
; PRINT SCRN(X,Y)
;
e28a: 20 34 ee SCRN jsr GETBYTE
e28d: 4a lsr A ;A-reg = A-reg / 2
e28e: 08 php ;stash carry (lsb)
e28f: 20 47 f8 jsr MON_GBASCALC
e292: 20 34 ee jsr GETBYTE
e295: a8 tay
e296: b1 26 lda (MON_GBASL),y ;get screen byte
e298: 28 plp ;retrieve carry
e299: 90 04 bcc LE29F
e29b: 4a lsr A ;odd; upper half
e29c: 4a lsr A
e29d: 4a lsr A
e29e: 4a lsr A
e29f: 29 0f LE29F and #$0f ;A-reg = color number
e2a1: a0 00 ldy #$00
e2a3: 20 08 e7 jsr LE708
e2a6: 94 a0 sty NOUNSTKC,x
e2a8: 88 dey
e2a9: 84 d7 sty PRFLAG ;PRFLAG = $ff
;
; Token $3e ,
; PRINT SCRN(X,Y)
;
e2ab: 60 COMMA_SCRN rts
e2ac: ff ff ff ff .bulk $ff,$ff,$ff,$ff
e2b0: 20 d3 ef unref_e2b0 jsr LEFD3 ;old 4K cold start
;
; Warm start. Main compile / execute code.
;
e2b3: 20 8e fd WARM jsr MON_CROUT ;emit blank line
e2b6: 46 d9 LE2B6 lsr RUNFLAG ;not running
e2b8: a9 be lda #“>”
e2ba: 20 06 e0 jsr SetPrompt ;set and print prompt char
e2bd: a0 00 ldy #$00
e2bf: 84 fa sty LEADZR ;no leading zeroes for AUTOLN
e2c1: 24 f8 bit AUTOFLAG ;AUTO?
e2c3: 10 0c bpl LE2D1
e2c5: a6 f6 ldx AUTOLN ;yes, print line number
e2c7: a5 f7 lda AUTOLN+1
e2c9: 20 1b e5 jsr PRDEC
e2cc: a9 a0 lda #BLANK+128
e2ce: 20 ed fd jsr MON_COUT
e2d1: a2 ff LE2D1 ldx #$ff ;init S-reg
e2d3: 9a txs
e2d4: 20 ce e3 jsr GETCMD
e2d7: 84 f1 sty TOKNDX
e2d9: 8a txa
e2da: 85 c8 sta TXTNDX
e2dc: a2 20 ldx #$20
e2de: 20 91 e4 jsr LE491
e2e1: a5 c8 lda TXTNDX ;PX = TXTNDX + $0200 + C-flag
e2e3: 69 00 adc #$00
e2e5: 85 e0 sta PX
e2e7: a9 00 lda #$00
e2e9: aa tax
e2ea: 69 02 adc #$02
e2ec: 85 e1 sta PX+1
e2ee: a1 e0 lda (PX,x)
e2f0: 29 f0 and #$f0
e2f2: c9 b0 cmp #“0”
e2f4: f0 03 beq LE2F9
e2f6: 4c 83 e8 jmp LE883
e2f9: a0 02 LE2F9 ldy #$02 ;move two bytes
e2fb: b1 e0 LE2FB lda (PX),y
e2fd: 99 cd 00 sta ACC-1,y
e300: 88 dey
e301: d0 f8 bne LE2FB
e303: 20 8a e3 jsr LE38A
e306: a5 f1 lda TOKNDX
e308: e5 c8 sbc TXTNDX
e30a: c9 04 cmp #$04
e30c: f0 a8 beq LE2B6
e30e: 91 e0 sta (PX),y
e310: a5 ca lda PP ;P2 = PP - (PX),Y
e312: f1 e0 sbc (PX),y
e314: 85 e4 sta P2
e316: a5 cb lda PP+1
e318: e9 00 sbc #$00
e31a: 85 e5 sta P2+1
e31c: a5 e4 lda P2
e31e: c5 cc cmp PV
e320: a5 e5 lda P2+1
e322: e5 cd sbc PV+1
e324: 90 45 bcc MEMFULL
e326: a5 ca LE326 lda PP ;P3 = PP - (PX),Y
e328: f1 e0 sbc (PX),y
e32a: 85 e6 sta P3
e32c: a5 cb lda PP+1
e32e: e9 00 sbc #$00
e330: 85 e7 sta P3+1
e332: b1 ca lda (PP),y
e334: 91 e6 sta (P3),y
e336: e6 ca inc PP
e338: d0 02 bne LE33C
e33a: e6 cb inc PP+1
e33c: a5 e2 LE33C lda P1
e33e: c5 ca cmp PP
e340: a5 e3 lda P1+1
e342: e5 cb sbc PP+1
e344: b0 e0 bcs LE326
e346: b5 e4 LE346 lda P2,x
e348: 95 ca sta PP,x
e34a: ca dex
e34b: 10 f9 bpl LE346
e34d: b1 e0 lda (PX),y
e34f: a8 tay
e350: 88 LE350 dey
e351: b1 e0 lda (PX),y
e353: 91 e6 sta (P3),y
e355: 98 tya
e356: d0 f8 bne LE350
e358: 24 f8 bit AUTOFLAG ;auto line?
e35a: 10 09 bpl LE365 ;no, branch
e35c: b5 f7 :Loop lda AUTOLN+1,x ;AUTOLN = AUTOLN + AUTOINC
e35e: 75 f5 adc AUTOINC+1,x
e360: 95 f7 sta AUTOLN+1,x
e362: e8 inx
e363: f0 f7 beq :Loop
e365: 10 7e LE365 bpl LE3E5
e367: 00 brk
e368: 00 00 00 .bulk $00,$00,$00
e36b: a0 14 MEMFULL ldy #<ErrMsg03 ;"MEM FULL"
e36d: d0 71 bne ERRMESS ;(always)
;
; Token $0a ,
; DEL 0,10
;
e36f: 20 15 e7 COMMA_DEL jsr GET16BIT
e372: a5 e2 lda P1 ;P3 = P1
e374: 85 e6 sta P3
e376: a5 e3 lda P1+1
e378: 85 e7 sta P3+1
e37a: 20 75 e5 jsr LE575
e37d: a5 e2 lda P1 ;P2 = P1
e37f: 85 e4 sta P2
e381: a5 e3 lda P1+1
e383: 85 e5 sta P2+1
e385: d0 0e bne LE395 ;(always?)
;
; Token $09 DEL
;
e387: 20 15 e7 DEL jsr GET16BIT
e38a: 20 6d e5 LE38A jsr LE56D
e38d: a5 e6 lda P3 ;P1 = P3
e38f: 85 e2 sta P1
e391: a5 e7 lda P3+1
e393: 85 e3 sta P1+1
; Memory move: P3 < PP.P2 backwards.
e395: a0 00 LE395 ldy #$00
e397: a5 ca :Loop lda PP
e399: c5 e4 cmp P2
e39b: a5 cb lda PP+1
e39d: e5 e5 sbc P2+1
e39f: b0 16 bcs LE3B7
e3a1: a5 e4 lda P2
e3a3: d0 02 bne LE3A7
e3a5: c6 e5 dec P2+1
e3a7: c6 e4 LE3A7 dec P2
e3a9: a5 e6 lda P3
e3ab: d0 02 bne LE3AF
e3ad: c6 e7 dec P3+1
e3af: c6 e6 LE3AF dec P3
e3b1: b1 e4 lda (P2),y
e3b3: 91 e6 sta (P3),y
e3b5: 90 e0 bcc :Loop
e3b7: a5 e6 LE3B7 lda P3 ;PP = P3
e3b9: 85 ca sta PP
e3bb: a5 e7 lda P3+1
e3bd: 85 cb sta PP+1
e3bf: 60 rts
e3c0: 20 ed fd :Loop jsr MON_COUT ;print error message
e3c3: c8 iny
;
; Print error message routine entry point.
;
e3c4: b9 00 eb ERRORMESS lda ErrMsg00,y
e3c7: 30 f7 bmi :Loop
e3c9: 09 80 ora #$80
e3cb: 4c ed fd jmp MON_COUT
e3ce: 98 GETCMD tya
e3cf: aa tax
e3d0: 20 75 fd jsr MON_NXTCHAR
e3d3: 8a txa
e3d4: a8 tay
e3d5: a9 df lda #“_” ;underline problem?
e3d7: 99 00 02 sta IN,y
e3da: a2 ff ldx #$ff
e3dc: 60 rts
e3dd: 60 .dd1 $60
e3de: a0 06 ErrTooLong ldy #<ErrMsg01 ;"TOO LONG"
;
; Print error message and goto mainline.
;
e3e0: 20 d3 ee ERRMESS jsr PRINTERR
; DOS 3.3 chains here when processing errors.
e3e3: 24 d9 bit RUNFLAG
e3e5: 30 03 LE3E5 bmi LE3EA
e3e7: 4c b6 e2 jmp LE2B6
e3ea: 4c 9a eb LE3EA jmp LEB9A
e3ed: 2a LE3ED rol A
e3ee: 69 a0 adc #$a0
e3f0: dd 00 02 cmp IN,x
e3f3: d0 53 bne LE448
e3f5: b1 fe lda (SYNPAG),y
e3f7: 0a asl A
e3f8: 30 06 bmi LE400
e3fa: 88 dey
e3fb: b1 fe lda (SYNPAG),y
e3fd: 30 29 bmi LE428
e3ff: c8 iny
e400: 86 c8 LE400 stx TXTNDX
e402: 98 tya
e403: 48 pha
e404: a2 00 ldx #$00
e406: a1 fe lda (SYNPAG,x)
e408: aa tax
e409: 4a :Loop lsr A
e40a: 49 40 eor #$40
e40c: 11 fe ora (SYNPAG),y
e40e: c9 c0 cmp #$c0
e410: 90 01 bcc LE413
e412: e8 inx
e413: c8 LE413 iny
e414: d0 f3 bne :Loop
e416: 68 pla
e417: a8 tay
e418: 8a txa
e419: 4c f8 f2 jmp LF2F8
e41c: e6 f1 LE41C inc TOKNDX
e41e: a6 f1 ldx TOKNDX
e420: f0 bc beq ErrTooLong
e422: 9d 00 02 sta IN,x
e425: 60 :Return rts
e426: a6 c8 LE426 ldx TXTNDX
e428: a9 a0 LE428 lda #BLANK+128
e42a: e8 LE42A inx
e42b: dd 00 02 cmp IN,x
e42e: b0 fa bcs LE42A
e430: b1 fe lda (SYNPAG),y
e432: 29 3f and #$3f
e434: 4a lsr A
e435: d0 b6 bne LE3ED
e437: bd 00 02 lda IN,x
e43a: b0 06 bcs LE442
e43c: 69 3f adc #$3f
e43e: c9 1a cmp #$1a
e440: 90 6f bcc LE4B1
e442: 69 4f LE442 adc #$4f
e444: c9 0a cmp #$0a
e446: 90 69 bcc LE4B1
e448: a6 fd LE448 ldx SYNSTKDX
e44a: c8 :Loop1 iny
e44b: b1 fe lda (SYNPAG),y
e44d: 29 e0 and #$e0
e44f: c9 20 cmp #$20
e451: f0 7a beq LE4CD
e453: b5 a8 lda TXTNDXSTK,x
e455: 85 c8 sta TXTNDX
e457: b5 d1 lda TOKNDXSTK,x
e459: 85 f1 sta TOKNDX
e45b: 88 :Loop2 dey
e45c: b1 fe lda (SYNPAG),y
e45e: 0a asl A ;double
e45f: 10 fa bpl :Loop2
e461: 88 dey
e462: b0 38 bcs LE49C
e464: 0a asl A
e465: 30 35 bmi LE49C
e467: b4 58 ldy SYNSTKH,x
e469: 84 ff sty SYNPAG+1
e46b: b4 80 ldy SYNSTKL,x
e46d: e8 inx
e46e: 10 da bpl :Loop1
e470: f0 b3 LE470 beq :Return
e472: c9 7e cmp #$7e
e474: b0 22 bcs LE498
e476: ca dex
e477: 10 04 bpl LE47D
e479: a0 06 ldy #<ErrMsg01 ;"TOO LONG"
; BUG: above line should be ErrMsg04, "TOO MANY PARENS". See Call-A.P.P.L.E.
; Mar 1983 p.114.
e47b: 10 29 bpl LE4A6 ;(always)
e47d: 94 80 LE47D sty SYNSTKL,x
e47f: a4 ff ldy SYNPAG+1
e481: 94 58 sty SYNSTKH,x
e483: a4 c8 ldy TXTNDX
e485: 94 a8 sty TXTNDXSTK,x
e487: a4 f1 ldy TOKNDX
e489: 94 d1 sty TOKNDXSTK,x
e48b: 29 1f and #$1f
e48d: a8 tay
e48e: b9 97 f1 lda SYNTABLNDX,y
e491: 0a LE491 asl A ;double
e492: a8 tay
e493: a9 76 lda #>SYNTABL-$7600 ;[#>SYNTABL/2]
e495: 2a rol A
e496: 85 ff sta SYNPAG+1
e498: d0 01 LE498 bne LE49B
e49a: c8 iny
e49b: c8 LE49B iny
e49c: 86 fd LE49C stx SYNSTKDX
e49e: b1 fe lda (SYNPAG),y
e4a0: 30 84 bmi LE426
e4a2: d0 05 bne LE4A9
e4a4: a0 0e ldy #<ErrMsg02 ;"SYNTAX"
e4a6: 4c e0 e3 LE4A6 jmp ERRMESS
e4a9: c9 03 LE4A9 cmp #$03
e4ab: b0 c3 bcs LE470
e4ad: 4a lsr A ;halve
e4ae: a6 c8 ldx TXTNDX
e4b0: e8 inx
e4b1: bd 00 02 LE4B1 lda IN,x
e4b4: 90 04 bcc LE4BA
e4b6: c9 a2 cmp #DQT+128
e4b8: f0 0a beq LE4C4
e4ba: c9 df LE4BA cmp #“_” ;underline problem?
e4bc: f0 06 beq LE4C4
e4be: 86 c8 stx TXTNDX
e4c0: 20 1c e4 LE4C0 jsr LE41C
e4c3: c8 iny
e4c4: 88 LE4C4 dey
e4c5: a6 fd ldx SYNSTKDX
e4c7: b1 fe :Loop lda (SYNPAG),y
e4c9: 88 dey
e4ca: 0a asl A
e4cb: 10 cf bpl LE49C
e4cd: b4 58 LE4CD ldy SYNSTKH,x
e4cf: 84 ff sty SYNPAG+1
e4d1: b4 80 ldy SYNSTKL,x
e4d3: e8 inx
e4d4: b1 fe lda (SYNPAG),y
e4d6: 29 9f and #%10011111
e4d8: d0 ed bne :Loop
e4da: 85 f2 sta PCON
e4dc: 85 f3 sta PCON+1
e4de: 98 tya
e4df: 48 pha
e4e0: 86 fd stx SYNSTKDX
e4e2: b4 d0 ldy TOKNDXSTK-1,x
e4e4: 84 c9 sty LEADBL
e4e6: 18 clc
e4e7: a9 0a :Loop1 lda #$0a
e4e9: 85 f9 sta CHAR
e4eb: a2 00 ldx #$00
e4ed: c8 iny
e4ee: b9 00 02 lda IN,y
e4f1: 29 0f and #$0f
e4f3: 65 f2 :Loop2 adc PCON
e4f5: 48 pha
e4f6: 8a txa
e4f7: 65 f3 adc PCON+1
e4f9: 30 1c bmi LE517
e4fb: aa tax
e4fc: 68 pla
e4fd: c6 f9 dec CHAR
e4ff: d0 f2 bne :Loop2
e501: 85 f2 sta PCON
e503: 86 f3 stx PCON+1
e505: c4 f1 cpy TOKNDX
e507: d0 de bne :Loop1
e509: a4 c9 ldy LEADBL
e50b: c8 iny
e50c: 84 f1 sty TOKNDX
e50e: 20 1c e4 jsr LE41C
e511: 68 pla
e512: a8 tay
e513: a5 f3 lda PCON+1
e515: b0 a9 bcs LE4C0
e517: a0 00 LE517 ldy #<ErrMsg00 ;">32767"
e519: 10 8b bpl LE4A6 ;(always)
;
; Prints a 16-bit number in decimal.
;
; On entry:
; A-reg: high byte
; X-reg: low byte
;
e51b: 85 f3 PRDEC sta PCON+1
e51d: 86 f2 stx PCON
e51f: a2 04 ldx #$04
e521: 86 c9 stx LEADBL
e523: a9 b0 :Loop1 lda #“0”
e525: 85 f9 sta CHAR
e527: a5 f2 :Loop2 lda PCON
e529: dd 63 e5 cmp NUMLOW,x
e52c: a5 f3 lda PCON+1
e52e: fd 68 e5 sbc NUMHI,x
e531: 90 0d bcc LE540
e533: 85 f3 sta PCON+1
e535: a5 f2 lda PCON
e537: fd 63 e5 sbc NUMLOW,x
e53a: 85 f2 sta PCON
e53c: e6 f9 inc CHAR
e53e: d0 e7 bne :Loop2
e540: a5 f9 LE540 lda CHAR
e542: e8 inx
e543: ca dex
e544: f0 0e beq PRDEC5
e546: c9 b0 cmp #“0”
e548: f0 02 beq LE54C
e54a: 85 c9 sta LEADBL
e54c: 24 c9 LE54C bit LEADBL
e54e: 30 04 bmi PRDEC5
e550: a5 fa lda LEADZR
e552: f0 0b beq PRDEC6
; PRINT
e554: 20 ed fd PRDEC5 jsr MON_COUT
e557: 24 f8 bit AUTOFLAG ;auto line?
e559: 10 04 bpl PRDEC6
e55b: 99 00 02 sta IN,y
e55e: c8 iny
; NXTX
e55f: ca PRDEC6 dex
e560: 10 c1 bpl :Loop1
e562: 60 rts
e563: 01 NUMLOW .dd1 1 ;1
e564: 0a .dd1 10 ;10
e565: 64 .dd1 100 ;100
e566: e8 .dd1 $e8 ;1000 ($3e8)
e567: 10 .dd1 $10 ;10000 ($2710
e568: 00 NUMHI .dd1 0 ;1
e569: 00 .dd1 0 ;10
e56a: 00 .dd1 0 ;100
e56b: 03 .dd1 $03 ;1000 ($03e8)
e56c: 27 .dd1 $27 ;10000 ($2710)
e56d: a5 ca LE56D lda PP ;P3 = PP
e56f: 85 e6 sta P3
e571: a5 cb lda PP+1
e573: 85 e7 sta P3+1
e575: e8 LE575 inx
e576: a5 e7 LE576 lda P3+1 ;P2 = P3
e578: 85 e5 sta P2+1
e57a: a5 e6 lda P3
e57c: 85 e4 sta P2
e57e: c5 4c cmp HIMEM ;compare P2 and HIMEM
e580: a5 e5 lda P2+1
e582: e5 4d sbc HIMEM+1
e584: b0 26 bcs :Return
;
e586: a0 01 ldy #$01
e588: b1 e4 lda (P2),y
e58a: e5 ce sbc ACC
e58c: c8 iny
e58d: b1 e4 lda (P2),y
e58f: e5 cf sbc ACC+1
e591: b0 19 bcs :Return
e593: a0 00 ldy #$00
e595: a5 e6 lda P3 ;P3 = P3.W + (P2).B
e597: 71 e4 adc (P2),y
e599: 85 e6 sta P3
e59b: 90 03 bcc LE5A0
e59d: e6 e7 inc P3+1
e59f: 18 clc
e5a0: c8 LE5A0 iny
e5a1: a5 ce lda ACC ;is ACC+1 <HS> (P2),Y?
e5a3: f1 e4 sbc (P2),y
e5a5: c8 iny
e5a6: a5 cf lda ACC+1
e5a8: f1 e4 sbc (P2),y
e5aa: b0 ca bcs LE576
e5ac: 60 :Return rts
;
; Token $0b NEW
; turn off AUTO
; remove program
; fall into CLR
;
e5ad: 46 f8 NEW lsr AUTOFLAG ;manual
e5af: a5 4c lda HIMEM ;PP = HIMEM
e5b1: 85 ca sta PP
e5b3: a5 4d lda HIMEM+1
e5b5: 85 cb sta PP+1
;
; Token $0c CLR
; remove variables
; remove FOR loops and GOSUBs
;
e5b7: a5 4a CLR lda LOMEM ;PV = LOMEM
e5b9: 85 cc sta PV
e5bb: a5 4b lda LOMEM+1
e5bd: 85 cd sta PV+1
e5bf: a9 00 lda #$00
e5c1: 85 fb sta FORNDX ;no FORs
e5c3: 85 fc sta GOSUBNDX ;no GOSUBs
e5c5: 85 fe sta SYNPAG
e5c7: a9 00 lda #$00 ;?
e5c9: 85 1d sta $1d ;?
e5cb: 60 rts
e5cc: a5 d0 unref_e5cc lda SRCH
;
e5ce: 4c 6b e3 ErrMemFull jmp MEMFULL
e5d1: a0 ff :Loop1 ldy #$ff
e5d3: 84 d8 :Loop2 sty XSAVE
e5d5: c8 :Loop3 iny
e5d6: b1 e0 lda (PX),y
e5d8: 30 06 bmi LE5E0
e5da: c9 40 cmp #$40
e5dc: d0 68 bne LE646 ;exit loop
e5de: 85 d8 sta XSAVE
e5e0: d1 d0 LE5E0 cmp (SRCH),y
e5e2: f0 f1 beq :Loop3
e5e4: b1 d0 LE5E4 lda (SRCH),y
e5e6: c8 LE5E6 iny
e5e7: 4a lsr A
e5e8: d0 fa bne LE5E4
e5ea: b1 d0 lda (SRCH),y
e5ec: 48 pha
e5ed: c8 iny
e5ee: b1 d0 lda (SRCH),y
e5f0: a8 tay
e5f1: 68 pla
e5f2: 85 d0 LE5F2 sta SRCH
e5f4: 84 d1 sty SRCH+1
e5f6: c5 cc cmp PV
e5f8: d0 d7 bne :Loop1
e5fa: c4 cd cpy PV+1
e5fc: d0 d3 bne :Loop1
e5fe: a0 00 ldy #$00
e600: c8 :Loop iny
e601: b1 e0 lda (PX),y
e603: 30 fb bmi :Loop
e605: 49 40 eor #$40
e607: f0 f7 beq :Loop
e609: 98 tya
e60a: 69 04 adc #$04
e60c: 48 pha
e60d: 65 d0 adc SRCH
e60f: a8 tay
e610: a5 d1 lda SRCH+1
e612: 69 00 adc #$00
e614: 48 pha
e615: c4 ca cpy PP
e617: e5 cb sbc PP+1
e619: b0 b3 bcs ErrMemFull ;"MEM FULL"
e61b: 84 cc sty PV
e61d: 68 pla
e61e: 85 cd sta PV+1
e620: 68 pla
e621: a8 tay
e622: a9 00 lda #$00
e624: 88 dey
e625: 91 d0 sta (SRCH),y
e627: 88 dey
e628: 91 d0 sta (SRCH),y
e62a: 88 dey
e62b: a5 cd lda PV+1
e62d: 91 d0 sta (SRCH),y
e62f: 88 dey
e630: a5 cc lda PV
e632: 91 d0 sta (SRCH),y
e634: 88 dey
e635: a9 00 lda #$00
e637: 91 d0 :Loop sta (SRCH),y
e639: 88 dey
e63a: 30 97 bmi :Loop2
e63c: b1 e0 lda (PX),y
e63e: d0 f7 bne :Loop ;(always)
e640: a5 4a LE640 lda LOMEM
e642: a4 4b ldy LOMEM+1
e644: d0 ac bne LE5F2 ;(always)
e646: b1 d0 LE646 lda (SRCH),y
e648: c9 40 cmp #$40
e64a: b0 9a bcs LE5E6
e64c: 95 9f sta NOUNSTKC-1,x
e64e: 98 tya
e64f: 69 03 adc #$03
e651: 48 pha
e652: 65 d0 adc SRCH
e654: 20 0a e7 jsr LE70A
e657: 20 ff e6 :Loop jsr GETVERB
e65a: 88 dey
e65b: d0 fa bne :Loop
e65d: 98 tya
e65e: 65 d1 adc SRCH+1
e660: 95 78 sta NOUNSTKH,x
e662: 68 pla
e663: 24 d8 bit XSAVE
e665: 30 1d bmi LE684
e667: a8 tay
e668: a9 00 lda #$00
e66a: 20 0a e7 jsr LE70A
e66d: 95 78 sta NOUNSTKH,x
e66f: b1 d0 LE66F lda (SRCH),y
e671: 10 0f bpl LE682 ;exit loop
e673: f6 78 inc NOUNSTKH,x
e675: c8 iny
e676: d0 f7 bne LE66F ;(always)
e678: 09 .dd1 $09
e679: a9 00 LE679 lda #$00
e67b: 85 d4 sta IFFLAG
e67d: 85 d5 sta CRFLAG
e67f: a2 20 ldx #$20
e681: 48 LE681 pha
e682: a0 00 LE682 ldy #$00
e684: b1 e0 LE684 lda (PX),y
e686: 10 18 LE686 bpl LE6A0 ;exit loop
e688: 0a asl A
e689: 30 b5 bmi LE640
e68b: 20 ff e6 jsr GETVERB
e68e: 20 08 e7 jsr LE708
e691: 20 ff e6 jsr GETVERB
e694: 95 a0 sta NOUNSTKC,x
e696: 24 d4 LE696 bit IFFLAG
e698: 10 01 bpl LE69B
e69a: ca dex
e69b: 20 ff e6 LE69B jsr GETVERB
e69e: b0 e6 bcs LE686
e6a0: c9 28 LE6A0 cmp #$28
e6a2: d0 1f bne LE6C3
e6a4: a5 e0 lda PX
e6a6: 20 0a e7 jsr LE70A
e6a9: a5 e1 lda PX+1
e6ab: 95 78 sta NOUNSTKH,x
e6ad: 24 d4 bit IFFLAG
e6af: 30 0b bmi LE6BC
e6b1: a9 01 lda #$01
e6b3: 20 0a e7 jsr LE70A
e6b6: a9 00 lda #$00
e6b8: 95 78 sta NOUNSTKH,x
e6ba: f6 78 :Loop inc NOUNSTKH,x
e6bc: 20 ff e6 LE6BC jsr GETVERB
e6bf: 30 f9 bmi :Loop
e6c1: b0 d3 bcs LE696
e6c3: 24 d4 LE6C3 bit IFFLAG
e6c5: 10 06 bpl LE6CD
e6c7: c9 04 cmp #$04
e6c9: b0 d0 bcs LE69B
e6cb: 46 d4 lsr IFFLAG
e6cd: a8 LE6CD tay
e6ce: 85 d6 sta VERBNOW
e6d0: b9 80 e9 lda TABLE1,y
e6d3: 29 55 and #%01010101 ;even bits only
e6d5: 0a asl A
e6d6: 85 d7 sta PRFLAG ;temp
e6d8: 68 LE6D8 pla
e6d9: a8 tay
e6da: b9 80 e9 lda TABLE1,y
e6dd: 29 aa and #%10101010 ;odd bits only
e6df: c5 d7 cmp PRFLAG
e6e1: b0 09 bcs LE6EC
e6e3: 98 tya
e6e4: 48 pha
e6e5: 20 eb f3 jsr LF3EB
e6e8: a5 d6 lda VERBNOW
e6ea: 90 95 bcc LE681 ;(always)
; BRANCH: get high/low then JSR.
e6ec: b9 00 ea LE6EC lda VERBADRL,y
e6ef: 85 ce sta ACC
e6f1: b9 80 ea lda VERBADRH,y
e6f4: 85 cf sta ACC+1
e6f6: 20 fc e6 jsr LE6FC
e6f9: 4c d8 e6 jmp LE6D8
e6fc: 6c ce 00 LE6FC jmp (ACC)
;
; Get next verb to use.
;
e6ff: e6 e0 GETVERB inc PX
e701: d0 02 bne :NoInc
e703: e6 e1 inc PX+1
e705: b1 e0 :NoInc lda (PX),y
e707: 60 rts
e708: 94 77 LE708 sty NOUNSTKH-1,x
e70a: ca LE70A dex
e70b: 30 03 bmi LE710
e70d: 95 50 sta NOUNSTKL,x
e70f: 60 rts
e710: a0 66 LE710 ldy #<ErrMsg12+3 ;"PPED AT"
e712: 4c e0 e3 LE712 jmp ERRMESS
;
; Get a 16-bit value.
;
e715: a0 00 GET16BIT ldy #$00
e717: b5 50 lda NOUNSTKL,x
e719: 85 ce sta ACC
e71b: b5 a0 lda NOUNSTKC,x
e71d: 85 cf sta ACC+1
e71f: b5 78 lda NOUNSTKH,x
e721: f0 0e beq LE731
e723: 85 cf sta ACC+1
e725: b1 ce lda (ACC),y ;ACC = (ACC),Y
e727: 48 pha ;save low byte
e728: c8 iny ;Y-reg = 1
e729: b1 ce lda (ACC),y
e72b: 85 cf sta ACC+1
e72d: 68 pla ;restore low byte
e72e: 85 ce sta ACC
e730: 88 dey ;Y-reg = 0
e731: e8 LE731 inx
e732: 60 rts
;
; Token $16 =
; num var logic op
; IF X = 13 THEN END
;
e733: 20 4a e7 TE733 jsr TE74A
;
; Token $37 NOT
; numeric
; IF NOT X THEN END
;
e736: 20 15 e7 NOT jsr GET16BIT
e739: 98 tya ;A-reg = 0
e73a: 20 08 e7 jsr LE708
e73d: 95 a0 sta NOUNSTKC,x
e73f: c5 ce cmp ACC
e741: d0 06 bne :Return
e743: c5 cf cmp ACC+1
e745: d0 02 bne :Return
e747: f6 50 inc NOUNSTKL,x
e749: 60 :Return rts
;
; Token $17 #
; num var logic op
; IF X # 13 THEN END
;
; Token $1b <>
; num var logic op
; IF X <> 13 THEN END
;
e74a: 20 82 e7 TE74A jsr SUBTRACT
e74d: 20 59 e7 jsr SGN
;
; Token $31 ABS
;
e750: 20 15 e7 ABS jsr GET16BIT
e753: 24 cf bit ACC+1
e755: 30 1b bmi LE772
e757: ca LE757 dex
e758: 60 :Return rts
;
; Token $30 SGN
;
e759: 20 15 e7 SGN jsr GET16BIT
e75c: a5 cf lda ACC+1 ;is ACC zero?
e75e: d0 04 bne LE764
e760: a5 ce lda ACC
e762: f0 f3 beq LE757 ;yes
e764: a9 ff LE764 lda #$ff
e766: 20 08 e7 jsr LE708
e769: 95 a0 sta NOUNSTKC,x
e76b: 24 cf bit ACC+1
e76d: 30 e9 bmi :Return
;
; Token $36 -
; unary sign of number
; X = -5
;
e76f: 20 15 e7 NEGATE jsr GET16BIT
e772: 98 LE772 tya ;A-reg = 0
e773: 38 sec
e774: e5 ce sbc ACC
e776: 20 08 e7 jsr LE708
e779: 98 tya
e77a: e5 cf sbc ACC+1
e77c: 50 23 bvc LE7A1
e77e: a0 00 Err32767 ldy #<ErrMsg00 ;">32767"
e780: 10 90 bpl LE712 ;(always)
;
; Token $13 -
; num op
; X = 27 - 2
;
e782: 20 6f e7 SUBTRACT jsr NEGATE ;negate, then add
;
; Token $12 +
; num op
; X = 27 + 2
;
e785: 20 15 e7 TE785 jsr GET16BIT
e788: a5 ce lda ACC ;AUX = ACC
e78a: 85 da sta AUX
e78c: a5 cf lda ACC+1
e78e: 85 db sta AUX+1
e790: 20 15 e7 jsr GET16BIT
e793: 18 LE793 clc
e794: a5 ce lda ACC
e796: 65 da adc AUX
e798: 20 08 e7 jsr LE708
e79b: a5 cf lda ACC+1
e79d: 65 db adc AUX+1
e79f: 70 dd bvs Err32767
e7a1: 95 a0 LE7A1 sta NOUNSTKC,x
;
; Token $35 +
; unary sign of number
; X = +5
;
e7a3: 60 POSITIVE rts
;
; Token $50 TAB
;
e7a4: 20 34 ee TAB jsr GETBYTE
e7a7: a8 tay
e7a8: d0 03 bne LE7AD
e7aa: 4c cb ee jmp BcsRANGERR ;range error?
e7ad: 88 LE7AD dey
e7ae: 4c f4 f3 LE7AE jmp LF3F4
;
; Comma tab to next tab posn (every 8 spaces).
;
e7b1: a5 24 LE7B1 lda MON_CH ;get horiz posn
e7b3: 09 07 ora #$07 ;set bits 0-2
e7b5: a8 tay
e7b6: c8 iny ;incr, is it zero? [only if CH=$f8-ff (invalid)]
e7b7: d0 f5 :unref_branch bne LE7AE ;no, adjust CH [always?]
e7b9: c8 iny ;yes, go to next tab posn [sets Y-reg=1]
e7ba: d0 f5 bne LE7B1 ;(always)
e7bc: b0 f9 unref_e7bc bcs :unref_branch
e7be: 60 rts
e7bf: 00 00 .bulk $00,$00
;
; Token $49 ,
; num print follows
; PRINT A$,X
;
e7c1: 20 b1 e7 TE7C1 jsr LE7B1
;
; Token $46 ;
; num print follows
; PRINT A$ ; X
;
; Token $62 PRINT
; num value
; PRINT 123: PRINT X: PRINT ASC(A$)
;
e7c4: 20 15 e7 PRINTNUM jsr GET16BIT
e7c7: a5 cf LE7C7 lda ACC+1 ;is it positive?
e7c9: 10 0a bpl LE7D5
e7cb: a9 ad lda #“-” ;no, print minus sign
e7cd: 20 ed fd jsr MON_COUT
e7d0: 20 72 e7 jsr LE772
e7d3: 50 ef bvc PRINTNUM ;(always)
e7d5: 88 LE7D5 dey ;Y-reg = $ff
e7d6: 84 d5 sty CRFLAG ;CRFLAG = $ff
e7d8: 86 cf stx ACC+1 ;save X-reg
e7da: a6 ce ldx ACC
e7dc: 20 1b e5 jsr PRDEC
e7df: a6 cf ldx ACC+1 ;restore X-reg
e7e1: 60 rts
;
; Token $0d AUTO
;
e7e2: 20 15 e7 AUTO jsr GET16BIT
e7e5: a5 ce lda ACC ;AUTOLN = ACC
e7e7: 85 f6 sta AUTOLN
e7e9: a5 cf lda ACC+1
e7eb: 85 f7 sta AUTOLN+1
e7ed: 88 dey
e7ee: 84 f8 sty AUTOFLAG ;AUTOFLAG = $ff
e7f0: c8 iny
e7f1: a9 0a lda #10 ;default increment
e7f3: 85 f4 LE7F3 sta AUTOINC
e7f5: 84 f5 sty AUTOINC+1
e7f7: 60 rts
;
; Token $0e ,
; AUTO 10,20
;
e7f8: 20 15 e7 COMMA_AUTO jsr GET16BIT
e7fb: a5 ce lda ACC
e7fd: a4 cf ldy ACC+1
e7ff: 10 f2 bpl LE7F3 ;(always)
;
; Token $56 =
; FOR X = 5 TO 10
;
; Token $71 =
; num - non-conditional
; X = 5
;
e801: 20 15 e7 TE801 jsr GET16BIT
e804: b5 50 lda NOUNSTKL,x
e806: 85 da sta AUX
e808: b5 78 lda NOUNSTKH,x
e80a: 85 db sta AUX+1
e80c: a5 ce lda ACC
e80e: 91 da sta (AUX),y
e810: c8 iny
e811: a5 cf lda ACC+1
e813: 4c 07 f2 jmp LF207
;
; Token $25 THEN
; IF X = 3 THEN Y = 5
;
; Token $5e LET
;
e816: 60 LET rts
;
; Token $00
; internal begin-of-line
;
e817: 68 BEGIN_LINE pla
e818: 68 pla
;
; Token $03 :
; statement separation
; X = 5: A$ = "HELLO"
;
e819: 24 d5 COLON bit CRFLAG
e81b: 10 05 bpl :Return
;
; Token $63 PRINT
; dummy print
; PRINT: PRINT
;
e81d: 20 8e fd PRINT_CR jsr MON_CROUT
;
; Token $47 ;
; end of print statement
; PRINT A$;
;
e820: 46 d5 TE820 lsr CRFLAG
e822: 60 :Return rts
;
; Token $22 (
; string DIM
; DIM A$(X)
;
; Token $34 (
; num DIM
; DIM X(5)
;
; Token $38 (
; logic statements and num operations
; IF C and (A=14 OR B=12) THEN X=(27+3)/13
;
; Token $3f (
; used after PEEK, RND, SGN, ABS, and PDL
;
e823: a0 ff TE823 ldy #$ff
e825: 84 d7 sty PRFLAG ;PRFLAG = $ff
;
; Token $72 )
; the only right parenthesis token
;
e827: 60 RIGHT_PAREN rts
;
; Token $60 IF
;
e828: 20 cd ef IF jsr LEFCD
e82b: f0 07 beq LE834
e82d: a9 25 lda #$25 ;THEN token?
e82f: 85 d6 sta VERBNOW
e831: 88 dey
e832: 84 d4 sty IFFLAG
e834: e8 LE834 inx
e835: 60 rts
;
; Run without CLR
; DOS 3.3 chains here to run a program
;
e836: a5 ca RUNWARM lda PP
e838: a4 cb ldy PP+1
e83a: d0 5a bne LE896 ;(always)
;
; Token $5c GOSUB
;
e83c: a0 41 GOSUB ldy #<ErrMsg08 ;"16 GOSUBS"
e83e: a5 fc lda GOSUBNDX
e840: c9 10 cmp #16 ;sixteen GOSUBs?
e842: b0 5e bcs JmpERRMESS1 ;yes, error
e844: a8 tay
e845: e6 fc inc GOSUBNDX
;
e847: a5 e0 lda PX
e849: 99 00 01 sta STK_00,y
e84c: a5 e1 lda PX+1
e84e: 99 10 01 sta STK_10,y
;
e851: a5 dc lda PR
e853: 99 20 01 sta STK_20,y
e856: a5 dd lda PR+1
e858: 99 30 01 sta STK_30,y
;
; Token $24 THEN
; followed by a line number
; IF X=3 THEN 10
;
; Token $5f GOTO
;
e85b: 20 15 e7 GOTO jsr GET16BIT
e85e: 20 6d e5 jsr LE56D
e861: 90 04 bcc LE867
e863: a0 37 ldy #<ErrMsg07 ;"BAD BRANCH"
e865: d0 3b bne JmpERRMESS1
e867: a5 e4 LE867 lda P2
e869: a4 e5 ldy P2+1
; Main loop for running Integer BASIC programs.
e86b: 85 dc LE86B sta PR
e86d: 84 dd sty PR+1
e86f: 18 clc
e870: 69 03 adc #$03
e872: 90 01 bcc GETNEXT
e874: c8 iny
; Fetch next statement from text source.
e875: a2 ff GETNEXT ldx #$ff
e877: 86 d9 stx RUNFLAG
e879: 9a txs
e87a: 85 e0 sta PX
e87c: 84 e1 sty PX+1
e87e: 20 2e f0 jsr LF02E ;test for Ctrl+C and TRACE mode
e881: a0 00 ldy #$00
e883: 20 79 e6 LE883 jsr LE679 ;execute statement
e886: 24 d9 bit RUNFLAG
e888: 10 49 bpl END
e88a: 18 clc
e88b: a0 00 ldy #$00
e88d: a5 dc lda PR
e88f: 71 dc adc (PR),y
e891: a4 dd ldy PR+1
e893: 90 01 bcc LE896
e895: c8 iny
e896: c5 4c LE896 cmp HIMEM
e898: d0 d1 bne LE86B
e89a: c4 4d cpy HIMEM+1
e89c: d0 cd bne LE86B
e89e: a0 31 ldy #<ErrMsg06 ;"NO END"
e8a0: 46 d9 lsr RUNFLAG ;pos
e8a2: 4c e0 e3 JmpERRMESS1 jmp ERRMESS
;
; Token $5b RETURN
;
e8a5: a0 4a RETURN ldy #<ErrMsg09 ;"BAD RETURN"
e8a7: a5 fc lda GOSUBNDX
e8a9: f0 f7 beq JmpERRMESS1
e8ab: c6 fc dec GOSUBNDX
e8ad: a8 tay
e8ae: b9 1f 01 lda STK_20-1,y
e8b1: 85 dc sta PR
e8b3: b9 2f 01 lda STK_30-1,y
e8b6: 85 dd sta PR+1
e8b8: be ff 00 ldx: STK_00-1,y
e8bb: b9 0f 01 lda STK_10-1,y
e8be: a8 LE8BE tay
e8bf: 8a txa
e8c0: 4c 75 e8 jmp GETNEXT
e8c3: a0 63 STOPPED_AT ldy #<ErrMsg12 ;"STOPPED AT"
e8c5: 20 c4 e3 jsr ERRORMESS
e8c8: a0 01 ldy #$01
e8ca: b1 dc lda (PR),y
e8cc: aa tax
e8cd: c8 iny
e8ce: b1 dc lda (PR),y
e8d0: 20 1b e5 jsr PRDEC
;
; Token $51 END
;
e8d3: 4c b3 e2 END jmp WARM
e8d6: c6 fb LE8D6 dec FORNDX
;
; Token $59 NEXT
;
; Token $5a ,
; NEXT X,Y
;
e8d8: a0 5b NEXT ldy #<ErrMsg11 ;"BAD NEXT"
e8da: a5 fb lda FORNDX
e8dc: f0 c4 JmpERRMESS2 beq JmpERRMESS1 ;no more FORs
e8de: a8 tay
e8df: b5 50 lda NOUNSTKL,x
e8e1: d9 3f 01 cmp STK_40-1,y
e8e4: d0 f0 bne LE8D6
e8e6: b5 78 lda NOUNSTKH,x
e8e8: d9 4f 01 cmp STK_50-1,y
e8eb: d0 e9 bne LE8D6
e8ed: b9 5f 01 lda STK_60-1,y
e8f0: 85 da sta AUX
e8f2: b9 6f 01 lda STK_70-1,y
e8f5: 85 db sta AUX+1
;
e8f7: 20 15 e7 jsr GET16BIT
e8fa: ca dex
e8fb: 20 93 e7 jsr LE793
e8fe: 20 01 e8 jsr TE801
e901: ca dex
e902: a4 fb ldy FORNDX
e904: b9 cf 01 lda STK_D0-1,y
e907: 95 9f sta NOUNSTKC-1,x
e909: b9 bf 01 lda STK_C0-1,y
e90c: a0 00 ldy #$00
e90e: 20 08 e7 jsr LE708
e911: 20 82 e7 jsr SUBTRACT
e914: 20 59 e7 jsr SGN
e917: 20 15 e7 jsr GET16BIT
e91a: a4 fb ldy FORNDX
e91c: a5 ce lda ACC
e91e: f0 05 beq LE925
e920: 59 6f 01 eor STK_70-1,y
e923: 10 12 bpl LE937
;
e925: b9 7f 01 LE925 lda STK_80-1,y
e928: 85 dc sta PR
e92a: b9 8f 01 lda STK_90-1,y
e92d: 85 dd sta PR+1
;
e92f: be 9f 01 ldx STK_A0-1,y
e932: b9 af 01 lda STK_B0-1,y
e935: d0 87 bne LE8BE
e937: c6 fb LE937 dec FORNDX
e939: 60 rts
;
; Token $55 FOR
;
e93a: a0 54 FOR ldy #<ErrMsg10 ;"16 FORS"
e93c: a5 fb lda FORNDX
e93e: c9 10 cmp #16 ;sixteen FORs?
e940: f0 9a beq JmpERRMESS2 ;yes, error
e942: e6 fb inc FORNDX
e944: a8 tay
e945: b5 50 lda NOUNSTKL,x
e947: 99 40 01 sta STK_40,y
e94a: b5 78 lda NOUNSTKH,x
e94c: 4c 88 f2 jmp LF288
e94f: 60 .dd1 $60
;
; Token $57 TO
;
e950: 20 15 e7 TO jsr GET16BIT
e953: a4 fb ldy FORNDX
;
e955: a5 ce lda ACC
e957: 99 bf 01 sta STK_C0-1,y
e95a: a5 cf lda ACC+1
e95c: 99 cf 01 sta STK_D0-1,y
;
e95f: a9 01 lda #$01
e961: 99 5f 01 sta STK_60-1,y
e964: a9 00 lda #$00
e966: 99 6f 01 LE966 sta STK_70-1,y
;
e969: a5 dc lda PR
e96b: 99 7f 01 sta STK_80-1,y
e96e: a5 dd lda PR+1
e970: 99 8f 01 sta STK_90-1,y
;
e973: a5 e0 lda PX
e975: 99 9f 01 sta STK_A0-1,y
e978: a5 e1 lda PX+1
e97a: 99 af 01 sta STK_B0-1,y
e97d: 60 rts
e97e: 20 .dd1 $20
e97f: 15 .dd1 $15
;
e980: 00 00 00 ab+ TABLE1 .bulk $00,$00,$00,$ab,$03,$03,$03,$03
e988: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$03,$03,$03
e990: 03 03 3f 3f+ .bulk $03,$03,$3f,$3f,$c0,$c0,$3c,$3c
e998: 3c 3c 3c 3c+ .bulk $3c,$3c,$3c,$3c,$3c,$30,$0f,$c0
e9a0: c3 ff 55 00+ .bulk $c3,$ff,$55,$00,$ab,$ab,$03,$03
e9a8: ff ff 55 ff+ .bulk $ff,$ff,$55,$ff,$ff,$55,$cf,$cf
e9b0: cf cf cf ff+ .bulk $cf,$cf,$cf,$ff,$55,$c6,$c6,$c6
e9b8: 55 f0 f0 cf+ .bulk $55,$f0,$f0,$cf,$cf,$55,$01,$55
e9c0: ff ff 55 03+ .bulk $ff,$ff,$55,$03,$03,$03,$03,$03
e9c8: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$03,$03,$03
e9d0: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$03,$03,$03
e9d8: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$00,$ab,$03
e9e0: 57 03 03 03+ .bulk $57,$03,$03,$03,$03,$07,$03,$03
e9e8: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$03,$03,$03
e9f0: 03 03 aa ff+ .bulk $03,$03,$aa,$ff,$03,$03,$03,$03
e9f8: 03 03 03 03+ .bulk $03,$03,$03,$03,$03,$03,$03,$03
;
; Token address tables (verb dispatch tables).
;
ea00: 17 VERBADRL .dd1 <BEGIN_LINE
ea01: ff .dd1 $ff
ea02: ff .dd1 $ff
ea03: 19 .dd1 <COLON
ea04: df .dd1 <LOAD
ea05: 42 .dd1 <SAVE
ea06: 0a .dd1 <CON
ea07: f2 .dd1 <RUNNUM
ea08: ec .dd1 <RUN
ea09: 87 .dd1 <DEL
ea0a: 6f .dd1 <COMMA_DEL
ea0b: ad .dd1 <NEW
ea0c: b7 .dd1 <CLR
ea0d: e2 .dd1 <AUTO
ea0e: f8 .dd1 <COMMA_AUTO
ea0f: 54 .dd1 <TEE54
ea10: 4d .dd1 <VHIMEM
ea11: c9 .dd1 <VLOMEM
ea12: 85 .dd1 <TE785
ea13: 82 .dd1 <SUBTRACT
ea14: 22 .dd1 <MULT
ea15: 10 .dd1 <DIVIDE
ea16: 33 .dd1 <TE733
ea17: 4a .dd1 <TE74A
ea18: 5b .dd1 <TF25B
ea19: 4e .dd1 <TF24E
ea1a: 53 .dd1 <TF253
ea1b: 4a .dd1 <TE74A
ea1c: 49 .dd1 <TF249
ea1d: 66 .dd1 <VAND
ea1e: 6d .dd1 <VOR
ea1f: 7a .dd1 <MOD
ea20: 71 .dd1 <EXP
ea21: ff .dd1 $ff
ea22: 23 .dd1 <TE823
ea23: 09 .dd1 <COMMA_SUBSTR
ea24: 5b .dd1 <GOTO
ea25: 16 .dd1 <LET
ea26: b6 .dd1 <TEFB6
ea27: cb .dd1 <TEBCB
ea28: ff .dd1 $ff
ea29: ff .dd1 $ff
ea2a: fb .dd1 <PAREN_SUBSTR
ea2b: ff .dd1 $ff
ea2c: ff .dd1 $ff
ea2d: 24 .dd1 <TEF24
ea2e: f6 .dd1 <PEEK
ea2f: 4e .dd1 <RND
ea30: 59 .dd1 <SGN
ea31: 50 .dd1 <ABS
ea32: 3b .dd1 <PDL
ea33: ff .dd1 $ff
ea34: 23 .dd1 <TE823
ea35: a3 .dd1 <POSITIVE
ea36: 6f .dd1 <NEGATE
ea37: 36 .dd1 <NOT
ea38: 23 .dd1 <TE823
ea39: d7 .dd1 <TE1D7
ea3a: 1c .dd1 <TE21C
ea3b: 22 .dd1 <LEN
ea3c: 1d .dd1 <ASC
ea3d: 8a .dd1 <SCRN
ea3e: ab .dd1 <COMMA_SCRN
ea3f: 23 .dd1 <TE823
ea40: ff .dd1 $ff
ea41: ff .dd1 $ff
ea42: 21 .dd1 <TE121
ea43: 30 .dd1 <DIMSTR
ea44: 1e .dd1 <DIMNUM
ea45: 03 .dd1 <PRINTSTR
ea46: c4 .dd1 <PRINTNUM
ea47: 20 .dd1 <TE820
ea48: 00 .dd1 <TEE00
ea49: c1 .dd1 <TE7C1
ea4a: ba .dd1 <TF3BA
ea4b: 39 .dd1 <MON_SETTXT
ea4c: 40 .dd1 <MON_SETGR
ea4d: a0 .dd1 <CALL
ea4e: 30 .dd1 <DIMSTR
ea4f: 1e .dd1 <DIMNUM
ea50: a4 .dd1 <TAB
ea51: d3 .dd1 <END
ea52: b6 .dd1 <TEFB6
ea53: bc .dd1 <INPUT_PROMPT
ea54: aa .dd1 <TEBAA
ea55: 3a .dd1 <FOR
ea56: 01 .dd1 <TE801
ea57: 50 .dd1 <TO
ea58: 79 .dd1 <STEP
ea59: d8 .dd1 <NEXT
ea5a: d8 .dd1 <NEXT
ea5b: a5 .dd1 <RETURN
ea5c: 3c .dd1 <GOSUB
ea5d: ff .dd1 $ff
ea5e: 16 .dd1 <LET
ea5f: 5b .dd1 <GOTO
ea60: 28 .dd1 <IF
ea61: 03 .dd1 <PRINTSTR
ea62: c4 .dd1 <PRINTNUM
ea63: 1d .dd1 <PRINT_CR
ea64: 08 .dd1 <POKE
ea65: 00 .dd1 <GETVAL255
ea66: 4e .dd1 <TEE4E
ea67: 00 .dd1 <GETVAL255
ea68: 3e .dd1 <COMMA_PLOT
ea69: 00 .dd1 <GETVAL255
ea6a: a6 .dd1 <COMMA_HLIN
ea6b: b0 .dd1 <AT_HLIN
ea6c: 00 .dd1 <GETVAL255
ea6d: bc .dd1 <COMMA_VLIN
ea6e: c6 .dd1 <AT_VLIN
ea6f: 57 .dd1 <IVTAB
ea70: 8c .dd1 <TE18C
ea71: 01 .dd1 <TE801
ea72: 27 .dd1 <RIGHT_PAREN
ea73: ff .dd1 $ff
ea74: 5d .dd1 <LISTNUM
ea75: 35 .dd1 <COMMA_LIST
ea76: 4b .dd1 <LIST
ea77: 67 .dd1 <POP
ea78: e0 .dd1 <NODSP_STR
ea79: e1 .dd1 <NODSP_NUM
ea7a: 76 .dd1 <NOTRACE
ea7b: 04 .dd1 <DSP_STR
ea7c: 05 .dd1 <DSP_NUM
ea7d: 71 .dd1 <TRACE
ea7e: c9 .dd1 <PRSLOT
ea7f: 1a .dd1 <INSLOT
ea80: e8 VERBADRH .dd1 >BEGIN_LINE
ea81: ff .dd1 $ff
ea82: ff .dd1 $ff
ea83: e8 .dd1 >COLON
ea84: f0 .dd1 >LOAD
ea85: f1 .dd1 >SAVE
ea86: f3 .dd1 >CON
ea87: ef .dd1 >RUNNUM
ea88: ef .dd1 >RUN
ea89: e3 .dd1 >DEL
ea8a: e3 .dd1 >COMMA_DEL
ea8b: e5 .dd1 >NEW
ea8c: e5 .dd1 >CLR
ea8d: e7 .dd1 >AUTO
ea8e: e7 .dd1 >COMMA_AUTO
ea8f: ee .dd1 >TEE54
ea90: f0 .dd1 >VHIMEM
ea91: f0 .dd1 >VLOMEM
ea92: e7 .dd1 >TE785
ea93: e7 .dd1 >SUBTRACT
ea94: e2 .dd1 >MULT
ea95: ef .dd1 >DIVIDE
ea96: e7 .dd1 >TE733
ea97: e7 .dd1 >TE74A
ea98: f2 .dd1 >TF25B
ea99: f2 .dd1 >TF24E
ea9a: f2 .dd1 >TF253
ea9b: e7 .dd1 >TE74A
ea9c: f2 .dd1 >TF249
ea9d: f2 .dd1 >VAND
ea9e: f2 .dd1 >VOR
ea9f: e2 .dd1 >MOD
eaa0: f3 .dd1 >EXP
eaa1: ff .dd1 $ff
eaa2: e8 .dd1 >TE823
eaa3: e1 .dd1 >COMMA_SUBSTR
eaa4: e8 .dd1 >GOTO
eaa5: e8 .dd1 >LET
eaa6: ef .dd1 >TEFB6
eaa7: eb .dd1 >TEBCB
eaa8: ff .dd1 $ff
eaa9: ff .dd1 $ff
eaaa: e0 .dd1 >PAREN_SUBSTR
eaab: ff .dd1 $ff
eaac: ff .dd1 $ff
eaad: ef .dd1 >TEF24
eaae: ee .dd1 >PEEK
eaaf: ef .dd1 >RND
eab0: e7 .dd1 >SGN
eab1: e7 .dd1 >ABS
eab2: f3 .dd1 >PDL
eab3: ff .dd1 $ff
eab4: e8 .dd1 >TE823
eab5: e7 .dd1 >POSITIVE
eab6: e7 .dd1 >NEGATE
eab7: e7 .dd1 >NOT
eab8: e8 .dd1 >TE823
eab9: e1 .dd1 >TE1D7
eaba: e2 .dd1 >TE21C
eabb: ee .dd1 >LEN
eabc: f3 .dd1 >ASC
eabd: e2 .dd1 >SCRN
eabe: e2 .dd1 >COMMA_SCRN
eabf: e8 .dd1 >TE823
eac0: ff .dd1 $ff
eac1: ff .dd1 $ff
eac2: e1 .dd1 >TE121
eac3: e1 .dd1 >DIMSTR
eac4: ef .dd1 >DIMNUM
eac5: ee .dd1 >PRINTSTR
eac6: e7 .dd1 >PRINTNUM
eac7: e8 .dd1 >TE820
eac8: ee .dd1 >TEE00
eac9: e7 .dd1 >TE7C1
eaca: f3 .dd1 >TF3BA
eacb: fb .dd1 >MON_SETTXT
eacc: fb .dd1 >MON_SETGR
eacd: ee .dd1 >CALL
eace: e1 .dd1 >DIMSTR
eacf: ef .dd1 >DIMNUM
ead0: e7 .dd1 >TAB
ead1: e8 .dd1 >END
ead2: ef .dd1 >TEFB6
ead3: ef .dd1 >INPUT_PROMPT
ead4: eb .dd1 >TEBAA
ead5: e9 .dd1 >FOR
ead6: e8 .dd1 >TE801
ead7: e9 .dd1 >TO
ead8: f2 .dd1 >STEP
ead9: e8 .dd1 >NEXT
eada: e8 .dd1 >NEXT
eadb: e8 .dd1 >RETURN
eadc: e8 .dd1 >GOSUB
eadd: ff .dd1 $ff
eade: e8 .dd1 >LET
eadf: e8 .dd1 >GOTO
eae0: e8 .dd1 >IF
eae1: ee .dd1 >PRINTSTR
eae2: e7 .dd1 >PRINTNUM
eae3: e8 .dd1 >PRINT_CR
eae4: ef .dd1 >POKE
eae5: ef .dd1 >GETVAL255
eae6: ee .dd1 >TEE4E
eae7: ef .dd1 >GETVAL255
eae8: ee .dd1 >COMMA_PLOT
eae9: ef .dd1 >GETVAL255
eaea: ee .dd1 >COMMA_HLIN
eaeb: ee .dd1 >AT_HLIN
eaec: ef .dd1 >GETVAL255
eaed: ee .dd1 >COMMA_VLIN
eaee: ee .dd1 >AT_VLIN
eaef: ee .dd1 >IVTAB
eaf0: e1 .dd1 >TE18C
eaf1: e8 .dd1 >TE801
eaf2: e8 .dd1 >RIGHT_PAREN
eaf3: ff .dd1 $ff
eaf4: e0 .dd1 >LISTNUM
eaf5: e0 .dd1 >COMMA_LIST
eaf6: e0 .dd1 >LIST
eaf7: f1 .dd1 >POP
eaf8: f2 .dd1 >NODSP_STR
eaf9: f2 .dd1 >NODSP_NUM
eafa: f1 .dd1 >NOTRACE
eafb: f3 .dd1 >DSP_STR
eafc: f3 .dd1 >DSP_NUM
eafd: f1 .dd1 >TRACE
eafe: f3 .dd1 >PRSLOT
eaff: f4 .dd1 >INSLOT
;
; Error messages.
;
eb00: be b3 b2 b7+ ErrMsg00 .dstr “>32767”
eb06: d4 cf cf a0+ ErrMsg01 .dstr “TOO LONG”
eb0e: d3 d9 ce d4+ ErrMsg02 .dstr “SYNTAX”
eb14: cd c5 cd a0+ ErrMsg03 .dstr “MEM FULL”
eb1c: d4 cf cf a0+ ErrMsg04 .dstr “TOO MANY PARENS”
eb2b: d3 d4 d2 c9+ ErrMsg05 .dstr “STRING”
eb31: ce cf a0 c5+ ErrMsg06 .dstr “NO END”
eb37: c2 c1 c4 a0+ ErrMsg07 .dstr “BAD BRANCH”
eb41: b1 b6 a0 c7+ ErrMsg08 .dstr “16 GOSUBS”
eb4a: c2 c1 c4 a0+ ErrMsg09 .dstr “BAD RETURN”
eb54: b1 b6 a0 c6+ ErrMsg10 .dstr “16 FORS”
eb5b: c2 c1 c4 a0+ ErrMsg11 .dstr “BAD NEXT”
eb63: d3 d4 cf d0+ ErrMsg12 .dstr “STOPPED AT ”
eb6e: aa aa aa 20 ErrMsg13 .dstr “*** ”
eb72: a0 c5 d2 d2+ ErrMsg14 .dstr “ ERR”,$8d
eb77: be b2 b5 35 ErrMsg15 .dstr “>255”
eb7b: d2 c1 ce c7+ ErrMsg16 .dstr “RANGE”
eb80: c4 c9 4d ErrMsg17 .dstr “DIM”
eb83: d3 d4 d2 a0+ ErrMsg18 .dstr “STR OVFL”
eb8b: dc 0d .dstr “\”,$8d
eb8d: d2 c5 d4 d9+ ErrMsg20 .str “RETYPE LINE”,$8d
eb99: 3f ErrMsg21 .dd1 ‘?’
; Continue run w/o deleting vars?
eb9a: 46 d9 LEB9A lsr RUNFLAG ;pos
eb9c: 90 03 bcc LEBA1
eb9e: 4c c3 e8 jmp STOPPED_AT
eba1: a6 cf LEBA1 ldx ACC+1
eba3: 9a txs
eba4: a6 ce ldx ACC
eba6: a0 8d ldy #<ErrMsg20 ;"RETYPE LINE\r?"
eba8: d0 02 bne LEBAC ;(always)
;
; Token $54 INPUT
; num with no prompt
; INPUT X
;
ebaa: a0 99 TEBAA ldy #<ErrMsg21 ;"?" for INPUT
ebac: 20 c4 e3 LEBAC jsr ERRORMESS
ebaf: 86 ce stx ACC
ebb1: ba tsx
ebb2: 86 cf stx ACC+1
ebb4: 20 66 f3 jsr LF366
ebb7: 84 f1 sty TOKNDX
ebb9: a9 ff lda #$ff
ebbb: 85 c8 sta TXTNDX
ebbd: 0a asl A
ebbe: 85 d9 sta RUNFLAG ;neg
ebc0: a2 20 ldx #$20
ebc2: a9 15 lda #$15
ebc4: 20 91 e4 jsr LE491
ebc7: e6 d9 inc RUNFLAG
ebc9: a6 ce ldx ACC
;
; Token $27 ,
; num inputs
; INPUT "QUANTITY",Q
;
ebcb: a4 c8 TEBCB ldy TXTNDX
ebcd: 0a asl A
ebce: 85 ce LEBCE sta ACC
ebd0: c8 iny
ebd1: b9 00 02 lda IN,y
ebd4: c9 80 cmp #$80
ebd6: f0 d2 beq TEBAA ;end of input?
ebd8: 49 b0 eor #“0”
ebda: c9 0a cmp #10
ebdc: b0 f0 bcs LEBCE
ebde: c8 iny
ebdf: c8 iny
ebe0: 84 c8 sty TXTNDX
ebe2: b9 00 02 lda IN,y
ebe5: 48 pha
ebe6: b9 ff 01 lda IN-1,y
ebe9: a0 00 ldy #$00
ebeb: 20 08 e7 jsr LE708
ebee: 68 pla
ebef: 95 a0 sta NOUNSTKC,x
ebf1: a5 ce lda ACC
ebf3: c9 33 cmp #$33
ebf5: d0 03 bne LEBFA
ebf7: 20 6f e7 jsr NEGATE
ebfa: 4c 01 e8 LEBFA jmp TE801
ebfd: ff ff ff .align $0100 (3 bytes)
;
; Token / syntax table.
;
; Each entry has a token, stored in reverse, with character values adjusted.
; For example, "TRACE" is stored:
; "E"+32, "C"-32, "A"-32, "R"-32", "T"-32
; $e5 $a3 $a1 $b2 $b4
;
ec00: 50 20 4f c0+ SYNTABL .bulk $50,$20,$4f,$c0,$f4,$a1,$e4,$af
ec08: ad f2 af e4+ .bulk $ad,$f2,$af,$e4,$ae,$a1,$f0,$a5
ec10: b4 b3 ef b4+ .bulk $b4,$b3,$ef,$b4,$ee,$a5,$a8,$b4
;
ec18: 5c 80 00 40+ .bulk $5c,$80,$00,$40,$60,$8d,$60,$8b
ec20: 7f 1d 20 7e+ .bulk $7f,$1d,$20,$7e,$8c,$33,$00,$00
ec28: 60 03 bf 12 .bulk $60,$03,$bf,$12
;
ec2c: 47 83 ae a9+ .bulk $47,$83,$ae,$a9,$67,$83,$b2,$b0
ec34: e5 a3 a1 b2+ .bulk $e5,$a3,$a1,$b2,$b4,$79,$b0,$b3
ec3c: a4 69 b0 b3+ .bulk $a4,$69,$b0,$b3,$a4,$e5,$a3,$a1
ec44: b2 b4 af ae+ .bulk $b2,$b4,$af,$ae,$79,$b0,$b3,$a4
ec4c: af ae 69 b0+ .bulk $af,$ae,$69,$b0,$b3,$a4,$af,$ae
ec54: f0 af b0 f4+ .bulk $f0,$af,$b0,$f4,$b3,$a9,$ac,$60
ec5c: 8c 20 b4 b3+ .bulk $8c,$20,$b4,$b3,$a9,$ac
ec62: 00 .dd1 $00
ec63: 40 89 c9 47+ .bulk $40,$89,$c9,$47,$9d,$17,$68,$9d
ec6b: 0a 58 7b 67+ .bulk $0a,$58,$7b,$67,$a2,$a1,$b4,$b6
ec73: 67 b4 a1 07+ .bulk $67,$b4,$a1,$07,$8c,$07,$ae,$a9
ec7b: ac b6 67 b4+ .bulk $ac,$b6,$67,$b4,$a1,$07,$8c,$07
ec83: ae a9 ac a8+ .bulk $ae,$a9,$ac,$a8,$67,$8c,$07,$b4
ec8b: af ac b0 67+ .bulk $af,$ac,$b0,$67,$9d,$b2,$af,$ac
ec93: af a3 67 8c+ .bulk $af,$a3,$67,$8c,$07,$a5,$ab,$af
ec9b: b0 f4 ae a9+ .bulk $b0,$f4,$ae,$a9,$b2,$b0,$7f,$0e
eca3: 27 b4 ae a9+ .bulk $27,$b4,$ae,$a9,$b2,$b0,$7f,$0e
ecab: 28 b4 ae a9+ .bulk $28,$b4,$ae,$a9,$b2,$b0,$64,$07
ecb3: a6 a9 67 af+ .bulk $a6,$a9,$67,$af,$b4,$af,$a7,$78
ecbb: b4 a5 ac 6b+ .bulk $b4,$a5,$ac,$6b,$7f,$02,$ad,$a5
ecc3: b2 67 a2 b5+ .bulk $b2,$67,$a2,$b5,$b3,$af,$a7,$ee
eccb: b2 b5 b4 a5+ .bulk $b2,$b5,$b4,$a5,$b2,$7e,$8c,$39
ecd3: b4 b8 a5 ae+ .bulk $b4,$b8,$a5,$ae,$67,$b0,$a5,$b4
ecdb: b3 27 af b4+ .bulk $b3,$27,$af,$b4,$07,$9d,$19,$b2
ece3: af a6 7f 05+ .bulk $af,$a6,$7f,$05,$37,$b4,$b5,$b0
eceb: ae a9 7f 05+ .bulk $ae,$a9,$7f,$05,$28,$b4,$b5,$b0
ecf3: ae a9 7f 05+ .bulk $ae,$a9,$7f,$05,$2a,$b4,$b5,$b0
ecfb: ae a9 e4 ae+ .bulk $ae,$a9,$e4,$ae,$a5
;
ed00: 00 SYNTABL2 .dd1 $00
ed01: 47 a2 a1 b4+ .bulk $47,$a2,$a1,$b4,$7f,$0d,$30,$ad
ed09: a9 a4 7f 0d+ .bulk $a9,$a4,$7f,$0d,$23,$ad,$a9,$a4
ed11: 67 ac ac a1+ .bulk $67,$ac,$ac,$a1,$a3,$f2,$a7,$f4
ed19: b8 a5 b4 .bulk $b8,$a5,$b4
ed1c: 00 .dd1 $00 ;above are statements
ed1d: 4d cc 67 8c+ .bulk $4d,$cc,$67,$8c,$68,$8c,$db,$67
ed25: 9b 68 9b 50+ .bulk $9b,$68,$9b,$50,$8c,$63,$8c,$7f
ed2d: 01 51 07 88+ .bulk $01,$51,$07,$88,$29,$84,$80,$c4
ed35: 19 57 71 07+ .bulk $19,$57,$71,$07,$88,$14,$71,$07
ed3d: 8c 07 88 ae+ .bulk $8c,$07,$88,$ae,$b2,$a3,$b3,$71
ed45: 08 88 a3 b3+ .bulk $08,$88,$a3,$b3,$a1,$71,$08,$88
ed4d: ae a5 ac 68+ .bulk $ae,$a5,$ac,$68,$83,$08,$68,$9d
ed55: 08 71 07 88+ .bulk $08,$71,$07,$88,$60,$75,$b4,$af
ed5d: ae 75 8d 75+ .bulk $ae,$75,$8d,$75,$8b,$51,$07,$88
ed65: 19 b8 a4 ae+ .bulk $19,$b8,$a4,$ae,$b2,$ec,$a4,$b0
ed6d: f3 a2 a1 ee+ .bulk $f3,$a2,$a1,$ee,$a7,$b3,$e4,$ae
ed75: b2 eb a5 a5+ .bulk $b2,$eb,$a5,$a5,$b0,$51,$07,$88
ed7d: 39 81 c1 4f+ .bulk $39,$81,$c1,$4f,$7f,$0f,$2f,$00
ed85: 51 06 88 29+ .bulk $51,$06,$88,$29,$c2,$0c,$82,$57
ed8d: 8c 6a 8c 42+ .bulk $8c,$6a,$8c,$42,$ae,$a5,$a8,$b4
ed95: 60 ae a5 a8+ .bulk $60,$ae,$a5,$a8,$b4,$4f,$7e,$1e
ed9d: 35 8c 27 51+ .bulk $35,$8c,$27,$51,$07,$88,$09,$8b
eda5: fe e4 af ad+ .bulk $fe,$e4,$af,$ad,$f2,$af,$e4,$ae
edad: a1 dc de 9c+ .bulk $a1,$dc,$de,$9c,$dd,$9c,$de,$dd
edb5: 9e c3 dd cf+ .bulk $9e,$c3,$dd,$cf,$ca,$cd,$cb
edbc: 00 .dd1 $00 ;above 4 are num ops
edbd: 47 9a ad a5+ .bulk $47,$9a,$ad,$a5,$ad,$af,$ac,$67
edc5: 9a ad a5 ad+ .bulk $9a,$ad,$a5,$ad,$a9,$a8,$ee,$a1
edcd: ad 60 8c 20+ .bulk $ad,$60,$8c,$20,$af,$b4,$b5,$a1
edd5: f2 ac a3 f7+ .bulk $f2,$ac,$a3,$f7,$a5,$ae,$60,$8c
eddd: 20 ac a5 a4+ .bulk $20,$ac,$a5,$a4,$ee,$b5,$b2,$60
ede5: ae b5 b2 ee+ .bulk $ae,$b5,$b2,$ee,$af,$a3,$e5,$b6
eded: a1 b3 e4 a1+ .bulk $a1,$b3,$e4,$a1,$af,$ac
; Above are commands.
edf3: 7a 7e 9a 22+ .bulk $7a,$7e,$9a,$22,$20,$00,$60,$03
edfb: bf 60 03 bf+ .bulk $bf,$60,$03,$bf,$1f
;
; Token $48 ,
; string prints
; PRINT T,A$
;
ee00: 20 b1 e7 TEE00 jsr LE7B1
;
; Token $45 ;
; string prints
; PRINT anytype ; string
;
; Token $61 PRINT
; string var or literal
; PRINT A$: PRINT "HELLO"
;
ee03: e8 PRINTSTR inx
ee04: e8 inx
ee05: b5 4f lda NOUNSTKL-1,x
ee07: 85 da sta AUX
ee09: b5 77 lda NOUNSTKH-1,x
ee0b: 85 db sta AUX+1
ee0d: b4 4e ldy NOUNSTKL-2,x
ee0f: 98 :Loop tya
ee10: d5 76 cmp NOUNSTKH-2,x
ee12: b0 09 bcs LEE1D ;exit loop
ee14: b1 da lda (AUX),y
ee16: 20 ed fd jsr MON_COUT
ee19: c8 iny
ee1a: 4c 0f ee jmp :Loop
ee1d: a9 ff LEE1D lda #$ff
ee1f: 85 d5 sta CRFLAG ;CRFLAG = $ff
ee21: 60 rts
;
; Token $3b LEN(
;
ee22: e8 LEN inx
ee23: a9 00 lda #$00
ee25: 95 78 sta NOUNSTKH,x
ee27: 95 a0 sta NOUNSTKC,x
ee29: b5 77 lda NOUNSTKH-1,x
ee2b: 38 sec
ee2c: f5 4f sbc NOUNSTKL-1,x
ee2e: 95 50 sta NOUNSTKL,x
ee30: 4c 23 e8 jmp TE823
ee33: ff .dd1 $ff
ee34: 20 15 e7 GETBYTE jsr GET16BIT
ee37: a5 cf lda ACC+1
ee39: d0 28 bne HI255ERR ;">255"
ee3b: a5 ce lda ACC
ee3d: 60 rts
;
; Token $68 ,
; PLOT 20,15
;
ee3e: 20 34 ee COMMA_PLOT jsr GETBYTE
ee41: a4 c8 ldy TXTNDX
ee43: c9 30 cmp #48
ee45: b0 21 bcs RANGERR
ee47: c0 28 cpy #40
ee49: b0 1d bcs RANGERR
ee4b: 4c 00 f8 jmp MON_PLOT
;
; Token $66 COLOR=
;
ee4e: 20 34 ee TEE4E jsr GETBYTE
ee51: 4c 64 f8 jmp MON_SETCOL
;
; Token $0f MAN
;
ee54: 46 f8 TEE54 lsr AUTOFLAG ;manual
ee56: 60 rts
;
; Token $6f VTAB
;
ee57: 20 b3 f3 IVTAB jsr LF3B3
ee5a: c9 18 cmp #24
ee5c: b0 0a bcs RANGERR
ee5e: 85 25 sta MON_CV
ee60: 4c 22 fc jmp MON_VTAB
ee63: a0 77 HI255ERR ldy #<ErrMsg15 ;">255"
ee65: 4c e0 e3 JmpERRMESS3 jmp ERRMESS
ee68: a0 7b RANGERR ldy #<ErrMsg16 ;"RANGE"
ee6a: d0 f9 bne JmpERRMESS3
;
; Divide routine.
;
ee6c: 20 54 e2 LEE6C jsr LE254
ee6f: a5 da lda AUX ;is AUX zero?
ee71: d0 07 bne LEE7A
ee73: a5 db lda AUX+1
ee75: d0 03 bne LEE7A
ee77: 4c 7e e7 jmp Err32767 ;yes, ">32767" error
ee7a: 06 ce LEE7A asl ACC
ee7c: 26 cf rol ACC+1
ee7e: 26 e6 rol P3
ee80: 26 e7 rol P3+1
ee82: a5 e6 lda P3
ee84: c5 da cmp AUX ;compare P3 to AUX
ee86: a5 e7 lda P3+1
ee88: e5 db sbc AUX+1
ee8a: 90 0a bcc LEE96
ee8c: 85 e7 sta P3+1 ;P3 = P3 - AUX
ee8e: a5 e6 lda P3
ee90: e5 da sbc AUX
ee92: 85 e6 sta P3
ee94: e6 ce inc ACC
ee96: 88 LEE96 dey
ee97: d0 e1 bne LEE7A
ee99: 60 rts
ee9a: ff ff ff ff+ .bulk $ff,$ff,$ff,$ff,$ff,$ff
;
; Token $4d CALL
;
eea0: 20 15 e7 CALL jsr GET16BIT
eea3: 6c ce 00 jmp (ACC)
;
; Token $6a ,
; HLIN 10,20 AT 30
;
eea6: 20 34 ee COMMA_HLIN jsr GETBYTE
eea9: c5 c8 cmp TXTNDX
eeab: 90 bb bcc RANGERR
eead: 85 2c sta MON_H2
eeaf: 60 rts
;
; Token $6b AT
; HLIN 10,20 AT 30
;
eeb0: 20 34 ee AT_HLIN jsr GETBYTE
eeb3: c9 30 cmp #48
eeb5: b0 b1 bcs RANGERR
eeb7: a4 c8 ldy TXTNDX
eeb9: 4c 19 f8 jmp MON_HLINE
;
; Token $6d ,
; VLIN 10,20 AT 30
;
eebc: 20 34 ee COMMA_VLIN jsr GETBYTE
eebf: c5 c8 cmp TXTNDX
eec1: 90 a5 bcc RANGERR
eec3: 85 2d sta MON_V2
eec5: 60 rts
;
; Token $6e AT
; VLIN 10,20 AT 30
;
eec6: 20 34 ee AT_VLIN jsr GETBYTE
eec9: c9 28 cmp #40
eecb: b0 9b BcsRANGERR bcs RANGERR
eecd: a8 tay
eece: a5 c8 lda TXTNDX
eed0: 4c 28 f8 jmp MON_VLINE
eed3: 98 PRINTERR tya
eed4: aa tax
eed5: a0 6e ldy #<ErrMsg13 ;"*** "
eed7: 20 c4 e3 jsr ERRORMESS
eeda: 8a txa
eedb: a8 tay
eedc: 20 c4 e3 jsr ERRORMESS
eedf: a0 72 ldy #<ErrMsg14 ;" ERR"
eee1: 4c 61 f1 jmp PRTERR
eee4: 20 3f f2 LEEE4 jsr LF23F
eee7: 06 ce LEEE7 asl ACC
eee9: 26 cf rol ACC+1
eeeb: 30 fa bmi LEEE7
eeed: b0 dc bcs BcsRANGERR
eeef: d0 04 bne LEEF5
eef1: c5 ce cmp ACC
eef3: b0 d6 bcs BcsRANGERR
eef5: 60 LEEF5 rts
;
; Token $2e PEEK
; uses tken $3f (
;
eef6: 20 15 e7 PEEK jsr GET16BIT
eef9: b1 ce lda (ACC),y
eefb: 94 9f sty NOUNSTKC-1,x
eefd: 4c 08 e7 jmp LE708
;
; Token $65 ,
; POKE 20000,5
;
; Token $67 PLOT
;
; Token $69 HLIN
;
; Token $6c VLIN
;
ef00: 20 34 ee GETVAL255 jsr GETBYTE
ef03: a5 ce lda ACC
ef05: 85 c8 sta TXTNDX
ef07: 60 rts
;
; Token $64 POKE
;
ef08: 20 15 e7 POKE jsr GET16BIT
ef0b: a5 c8 lda TXTNDX
ef0d: 91 ce sta (ACC),y
ef0f: 60 rts
;
; Token $15 /
; num op. uses $38 (
; A = 27 / 2
;
ef10: 20 6c ee DIVIDE jsr LEE6C
ef13: a5 ce lda ACC ;P3 = ACC
ef15: 85 e6 sta P3
ef17: a5 cf lda ACC+1
ef19: 85 e7 sta P3+1
ef1b: 4c 44 e2 jmp MultEnd
;
; Token $44 ,
; next var in DIM is num
; DIM X(5),A(5)
;
; Token $4f DIM
; num var. uses tkn $22 (
; DIM A(5)
;
ef1e: 20 e4 ee DIMNUM jsr LEEE4
ef21: 4c 34 e1 jmp LE134
;
; Token $2d (
; var array
; X(12)
;
ef24: 20 e4 ee TEF24 jsr LEEE4
ef27: b4 78 ldy NOUNSTKH,x
ef29: b5 50 lda NOUNSTKL,x
ef2b: 69 fe adc #$fe
ef2d: b0 01 bcs LEF30
ef2f: 88 dey
ef30: 85 da LEF30 sta AUX
ef32: 84 db sty AUX+1
ef34: 18 clc
ef35: 65 ce adc ACC
ef37: 95 50 sta NOUNSTKL,x
ef39: 98 tya
ef3a: 65 cf adc ACC+1
ef3c: 95 78 sta NOUNSTKH,x
ef3e: a0 00 ldy #$00
ef40: b5 50 lda NOUNSTKL,x
ef42: d1 da cmp (AUX),y
ef44: c8 iny
ef45: b5 78 lda NOUNSTKH,x
ef47: f1 da sbc (AUX),y
ef49: b0 80 bcs BcsRANGERR ;"RANGE"
ef4b: 4c 23 e8 jmp TE823
;
; Token $2f RND
; uses tken $3f (
;
ef4e: 20 15 e7 RND jsr GET16BIT
ef51: a5 4e lda MON_RNDL
ef53: 20 08 e7 jsr LE708
ef56: a5 4f lda MON_RNDH
ef58: d0 04 bne LEF5E
ef5a: c5 4e cmp MON_RNDL
ef5c: 69 00 adc #$00
ef5e: 29 7f LEF5E and #$7f
ef60: 85 4f sta MON_RNDH
ef62: 95 a0 sta NOUNSTKC,x
ef64: a0 11 ldy #$11
ef66: a5 4f LEF66 lda MON_RNDH
ef68: 0a asl A
ef69: 18 clc
ef6a: 69 40 adc #$40
ef6c: 0a asl A
ef6d: 26 4e rol MON_RNDL
ef6f: 26 4f rol MON_RNDH
ef71: 88 dey
ef72: d0 f2 bne LEF66
ef74: a5 ce lda ACC
ef76: 20 08 e7 jsr LE708
ef79: a5 cf lda ACC+1
ef7b: 95 a0 sta NOUNSTKC,x
ef7d: 4c 7a e2 jmp MOD
ef80: 20 15 e7 unref_ef80 jsr GET16BIT
ef83: a4 ce ldy ACC ;compare ACC and LOMEM
ef85: c4 4a cpy LOMEM
ef87: a5 cf lda ACC+1
ef89: e5 4b sbc LOMEM+1
ef8b: 90 1e bcc JmpBcsRANGEERR ;[bad idea]
ef8d: 84 4c sty HIMEM ;HIMEM = ACC
ef8f: a5 cf lda ACC+1
ef91: 85 4d sta HIMEM+1
ef93: 4c ad e5 :unref_branch jmp NEW
ef96: 20 15 e7 unref_ef96 jsr GET16BIT
ef99: a4 ce ldy ACC ;compare ACC and LOMEM
ef9b: c4 4c cpy HIMEM
ef9d: a5 cf lda ACC+1
ef9f: e5 4d sbc HIMEM+1
efa1: b0 08 bcs JmpBcsRANGEERR
efa3: 84 4a sty LOMEM ;LOMEM = ACC
efa5: a5 cf lda ACC+1
efa7: 85 4b sta LOMEM+1
efa9: 90 e8 bcc :unref_branch ;(always)
efab: 4c cb ee JmpBcsRANGEERR jmp BcsRANGERR
efae: ff ff ff ff+ .bulk $ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff
;
; Token $26 ,
; string inputs
; INPUT "WHO",W$
;
; Token $52 INPUT
; string with no prompt
; INPUT S$
;
efb6: 20 71 e1 TEFB6 jsr INPUTSTR
efb9: 4c bf ef jmp LEFBF
;
; Token $53 INPUT
; string or num with prompt
; INPUT "WHO",W$: INPUT "QUANTITY",Q
;
efbc: 20 03 ee INPUT_PROMPT jsr PRINTSTR
efbf: a9 ff LEFBF lda #$ff
efc1: 85 c8 sta TXTNDX
efc3: a9 80 lda #$80
efc5: 8d 00 02 sta IN
efc8: 60 rts
efc9: 20 36 e7 LEFC9 jsr NOT
efcc: e8 inx
efcd: 20 36 e7 LEFCD jsr NOT
efd0: b5 50 lda NOUNSTKL,x
efd2: 60 rts
; Old 4K cold start.
efd3: a9 00 LEFD3 lda #$00
efd5: 85 4a sta LOMEM ;LOMEM = $0800
efd7: 85 4c sta HIMEM ;HIMEM = $1000
efd9: a9 08 lda #$08
efdb: 85 4b sta LOMEM+1
efdd: a9 10 lda #$10
efdf: 85 4d sta HIMEM+1
efe1: 4c ad e5 jmp NEW
efe4: d5 78 LEFE4 cmp NOUNSTKH,x
efe6: d0 01 bne LEFE9
efe8: 18 clc
efe9: 4c 02 e1 LEFE9 jmp LE102
;
; Token $08 RUN
; run from first line of program
;
efec: 20 b7 e5 RUN jsr CLR
efef: 4c 36 e8 jmp RUNWARM
;
; Token $07 RUN
; RUN 100
;
eff2: 20 b7 e5 RUNNUM jsr CLR
eff5: 4c 5b e8 jmp GOTO
eff8: e0 80 LEFF8 cpx #$80
effa: d0 01 bne LEFFD
effc: 88 dey
effd: 4c 0c e0 LEFFD jmp LE00C
;
; Cold start.
; set LOMEM, find HIMEM
; fall into NEW
;
f000: a0 00 COLD ldy #$00
f002: 84 a0 sty NOUNSTKC
f004: 84 4a sty LOMEM ;LOMEM = $0800
f006: 84 4c sty HIMEM ;HIMEM = $0800
f008: a9 08 lda #$08
f00a: 85 4b sta LOMEM+1
f00c: 85 4d sta HIMEM+1
f00e: e6 4d :Loop inc HIMEM+1 ;find top of RAM
f010: b1 4c lda (HIMEM),y
f012: 49 ff eor #$ff
f014: 91 4c sta (HIMEM),y
f016: d1 4c cmp (HIMEM),y
f018: d0 08 bne LF022
f01a: 49 ff eor #$ff
f01c: 91 4c sta (HIMEM),y
f01e: d1 4c cmp (HIMEM),y
f020: f0 ec beq :Loop ;(always, unless RAM is broken)
f022: 4c ad e5 LF022 jmp NEW
f025: 4c 79 f1 LF025 jmp LF179
f028: 20 32 f0 unref_f028 jsr :from_unref
f02b: 4c be e8 jmp LE8BE
f02e: a6 e0 LF02E ldx PX
f030: a5 e1 lda PX+1
f032: ac 00 c0 :from_unref ldy KBD ;get keypress
f035: c0 83 cpy #ETX+128 ;is it Ctrl+C?
f037: d0 ec bne LF025 ;no
f039: 2c 10 c0 bit KBDSTRB ;yes, clear keypress
f03c: 86 50 stx NOUNSTKL
f03e: 85 51 sta NOUNSTKL+1
f040: a5 dc lda PR ;NOUNSTKH = PR
f042: 85 78 sta NOUNSTKH
f044: a5 dd lda PR+1
f046: 85 79 sta NOUNSTKH+1
f048: 4c c3 e8 jmp STOPPED_AT
f04b: ff ff .bulk $ff,$ff
;
; Token $10 HIMEM:
;
f04d: 20 15 e7 VHIMEM jsr GET16BIT
f050: 86 d8 stx XSAVE
f052: a2 fe ldx #$fe
f054: 38 sec
f055: b5 d0 :Loop1 lda ACC+2,x ;P2 = ACC
f057: 95 e6 sta P2+2,x
f059: b5 4e lda HIMEM+2,x ;AUX = HIMEM - ACC
f05b: f5 d0 sbc ACC+2,x
f05d: 95 dc sta AUX+2,x
f05f: e8 inx
f060: d0 f3 bne :Loop1
f062: 90 4b bcc LF0AF
;
f064: ca dex ;X-reg = $ff
f065: b5 cb :Loop2 lda PP+1,x ;P3 = PP
f067: 95 e7 sta P3+1,x
f069: f5 db sbc AUX+1,x ;P2 = PP - AUX
f06b: 95 e5 sta P2+1,x
f06d: e8 inx
f06e: f0 f5 beq :Loop2 ;compare PV to P2
f070: 90 0a bcc JmpMEMFULL
f072: a5 cc lda PV
f074: c5 e4 cmp P2
f076: a5 cd lda PV+1
f078: e5 e5 sbc P2+1
f07a: 90 13 bcc :NoInc3
f07c: 4c 6b e3 JmpMEMFULL jmp MEMFULL
f07f: b1 e6 :Loop lda (P3),y
f081: 91 e4 sta (P2),y
f083: e6 e4 inc P2
f085: d0 02 bne :NoInc2
f087: e6 e5 inc P2+1
f089: e6 e6 :NoInc2 inc P3
f08b: d0 02 bne :NoInc3
f08d: e6 e7 inc P3+1
f08f: a5 e6 :NoInc3 lda P3 ;compare P3 and HIMEM
f091: c5 4c cmp HIMEM
f093: a5 e7 lda P3+1
f095: e5 4d sbc HIMEM+1
f097: 90 e6 bcc :Loop
;
f099: a2 fe LF099 ldx #$fe
f09b: b5 e6 :Loop lda P2+2,x ;P2 = HIMEM
f09d: 95 4e sta HIMEM+2,x
f09f: b5 cc lda PP+2,x ;PP = PP - AUX
f0a1: f5 dc sbc AUX+2,x
f0a3: 95 cc sta PP+2,x
f0a5: e8 inx
f0a6: d0 f3 bne :Loop
f0a8: a6 d8 ldx XSAVE
f0aa: 60 rts
f0ab: b1 4c LF0AB lda (HIMEM),y
f0ad: 91 ce sta (ACC),y
f0af: a5 ce LF0AF lda ACC
f0b1: d0 02 bne :NoInc
f0b3: c6 cf dec ACC+1
f0b5: c6 ce :NoInc dec ACC
f0b7: a5 4c lda HIMEM
f0b9: d0 02 bne :NoInc
f0bb: c6 4d dec HIMEM+1
f0bd: c6 4c :NoInc dec HIMEM
f0bf: c5 ca cmp PP ;compare PP to HIMEM
f0c1: a5 4d lda HIMEM+1
f0c3: e5 cb sbc PP+1
f0c5: 90 e4 bcc LF0AB
f0c7: b0 d0 bcs LF099 ;(always)
;
; Token $11 LOMEM:
;
f0c9: 20 15 e7 VLOMEM jsr GET16BIT
f0cc: a4 ce ldy ACC
f0ce: c0 ca cpy #PP
; BUG: above line should be CPY PP
f0d0: a5 cf lda ACC+1
f0d2: e5 cb sbc PP+1
f0d4: b0 a6 BcsJmpMEMFULL bcs JmpMEMFULL
f0d6: 84 4a sty LOMEM
f0d8: a5 cf lda ACC+1
f0da: 85 4b sta LOMEM+1
f0dc: 4c b7 e5 jmp CLR
;
; Token $04 LOAD
;
f0df: 86 d8 LOAD stx XSAVE
f0e1: 20 1e f1 jsr SETHDR
f0e4: 20 fd fe jsr MON_READ
f0e7: a2 ff ldx #$ff
f0e9: 38 sec
f0ea: b5 4d :Loop lda HIMEM+1,x ;AUX = HIMEM - ACC
f0ec: f5 cf sbc ACC+1,x
f0ee: 95 db sta AUX+1,x
f0f0: e8 inx
f0f1: f0 f7 beq :Loop
f0f3: 90 87 bcc JmpMEMFULL
f0f5: a5 cc lda PV ;compare PV to AUX
f0f7: c5 da cmp AUX
f0f9: a5 cd lda PV+1
f0fb: e5 db sbc AUX+1
f0fd: b0 d5 bcs BcsJmpMEMFULL
f0ff: a5 ce lda ACC ;is ACC zero?
f101: d0 04 bne LF107
f103: a5 cf lda ACC+1
f105: f0 11 beq LF118 ;yes
f107: a5 da LF107 lda AUX ;PP = AUX
f109: 85 ca sta PP
f10b: a5 db lda AUX+1
f10d: 85 cb sta PP+1
f10f: 20 2c f1 jsr SETPRG
f112: 20 fd fe jsr MON_READ
f115: a6 d8 LF115 ldx XSAVE
f117: 60 rts
f118: 20 3a ff LF118 jsr MON_BELL
f11b: 4c 15 f1 jmp LF115
f11e: a0 ce SETHDR ldy #$ce
f120: 84 3c sty MON_A1L ;A1 = $00ce
f122: c8 iny
f123: 84 3e sty MON_A2L ;A2 = $00cd
f125: a0 00 ldy #$00
f127: 84 3d sty MON_A1H
f129: 84 3f sty MON_A2H
f12b: 60 rts
f12c: b5 ca SETPRG lda PP,x
f12e: 95 3c sta MON_A1L,x
f130: b4 4c ldy HIMEM,x
f132: 94 3e sty MON_A2L,x
f134: ca dex
f135: 10 f5 bpl SETPRG
f137: a5 3e lda MON_A2L ;decrement A2
f139: d0 02 bne LF13D
f13b: c6 3f dec MON_A2H
f13d: c6 3e LF13D dec MON_A2L
f13f: 60 rts
f140: 86 d8 unref_f140 stx XSAVE
;
; Token $05 SAVE
;
f142: 38 SAVE sec ;ACC = HIMEM - PP
f143: a2 ff ldx #$ff
f145: b5 4d :Loop lda HIMEM+1,x
f147: f5 cb sbc PP+1,x
f149: 95 cf sta ACC+1,x
f14b: e8 inx
f14c: f0 f7 beq :Loop
;
f14e: 20 1e f1 jsr SETHDR
f151: 20 cd fe jsr MON_WRITE
f154: a2 01 ldx #$01
f156: 20 2c f1 jsr SETPRG
f159: a9 1a lda #$1a
f15b: 20 cf fe jsr MON_WRITE0
f15e: a6 d8 ldx XSAVE
f160: 60 rts
f161: 20 c4 e3 PRTERR jsr ERRORMESS
f164: 4c 3a ff jmp MON_BELL
;
; Token $77 POP
;
f167: a5 fc POP lda GOSUBNDX
f169: d0 03 bne LF16E
f16b: 4c a5 e8 jmp RETURN
f16e: c6 fc LF16E dec GOSUBNDX
f170: 60 rts
;
; Token $7d TRACE
;
f171: a9 ff TRACE lda #$ff
f173: 85 a0 sta NOUNSTKC
f175: 60 rts
;
; Token $7a NOTRACE
;
f176: 46 a0 NOTRACE lsr NOUNSTKC ;clear bit 7
f178: 60 rts
f179: 24 a0 LF179 bit NOUNSTKC ;trace mode?
f17b: 10 19 bpl :Return ;no
f17d: a9 a3 LF17D lda #“#” ;yes, print line number
f17f: 20 ed fd jsr MON_COUT
f182: a0 01 ldy #$01
f184: b1 dc lda (PR),y
f186: aa tax
f187: c8 iny
f188: b1 dc lda (PR),y
f18a: 20 1b e5 jsr PRDEC
f18d: a9 a0 lda #BLANK+128
f18f: 4c ed fd jmp MON_COUT
f192: a5 dc unref_f192 lda PR
f194: a4 dd ldy PR+1
f196: 60 :Return rts
;
; Indices into SYNTABL.
;
f197: c1 00 7f d1+ SYNTABLNDX .bulk $c1,$00,$7f,$d1,$cc,$c7,$cf,$ce
f19f: c5 9a 98 8d+ .bulk $c5,$9a,$98,$8d,$96,$95,$93,$bf
f1a7: b2 32 12 0f+ .bulk $b2,$32,$12,$0f,$bc,$b0,$ac,$be
f1af: 35 0c 61 30+ .bulk $35,$0c,$61,$30,$10,$0b,$dd,$fb
f1b7: a0 00 LF1B7 ldy #$00
f1b9: 20 c7 e7 jsr LE7C7
f1bc: a9 a0 lda #$a0
f1be: 4c ed fd jmp MON_COUT
f1c1: 00 00 00 00+ .bulk $00,$00,$00,$00,$00,$00,$00,$00
f1c9: a4 4a LF1C9 ldy LOMEM
f1cb: a5 4b lda LOMEM+1
f1cd: 48 :Loop1 pha
f1ce: c4 da cpy AUX ;compare LOMEM to AUX
f1d0: e5 db sbc AUX+1
f1d2: b0 1c bcs LF1F0
f1d4: 68 pla
f1d5: 84 d0 sty SRCH ;SRCH = LOMEM
f1d7: 85 d1 sta TOKNDXSTK
f1d9: a0 ff ldy #$ff
f1db: c8 :Loop2 iny
f1dc: b1 d0 lda (SRCH),y
f1de: 30 fb bmi :Loop2
f1e0: c9 40 cmp #$40
f1e2: f0 f7 beq :Loop2
f1e4: c8 iny
f1e5: c8 iny
f1e6: b1 d0 lda (SRCH),y
f1e8: 48 pha
f1e9: 88 dey
f1ea: b1 d0 lda (SRCH),y
f1ec: a8 tay
f1ed: 68 pla
f1ee: d0 dd bne :Loop1
;
f1f0: 68 LF1F0 pla
f1f1: a0 00 ldy #$00
f1f3: b1 d0 LF1F3 lda (SRCH),y
f1f5: 30 05 bmi LF1FC
f1f7: 4a lsr A
f1f8: f0 08 beq LF202
f1fa: a9 a4 lda #“$”
f1fc: 20 ed fd LF1FC jsr MON_COUT
f1ff: c8 iny
f200: d0 f1 bne LF1F3
f202: a9 bd LF202 lda #“=”
f204: 4c ed fd jmp MON_COUT
f207: 91 da LF207 sta (AUX),y
f209: e8 inx
f20a: b5 9f lda NOUNSTKC-1,x
f20c: f0 30 beq :Return
f20e: 4c d5 f3 jmp LF3D5
f211: a0 .dd1 $a0
f212: 30 07 LF212 bmi LF21B
f214: a5 dc lda PR
f216: a4 dd ldy PR+1
f218: 20 7d f1 jsr LF17D
f21b: 20 c9 f1 LF21B jsr LF1C9
f21e: a6 d8 ldx XSAVE
f220: 4c b7 f1 jmp LF1B7
f223: e8 LF223 inx
f224: e8 inx
f225: b5 9f lda NOUNSTKC-1,x
f227: f0 1f beq :Return
f229: 4c e0 f3 jmp LF3E0
f22c: 30 07 LF22C bmi LF235
f22e: a5 dc lda PR
f230: a4 dd ldy PR+1
f232: 20 7d f1 jsr LF17D
f235: 20 c9 f1 LF235 jsr LF1C9
f238: a6 d8 ldx XSAVE
f23a: 4c 09 f4 jmp LF409
f23d: e8 .dd1 $e8
f23e: 60 :Return rts
f23f: 20 15 e7 LF23F jsr GET16BIT
f242: e6 ce inc ACC
f244: d0 02 bne :Return
f246: e6 cf inc ACC+1
f248: 60 :Return rts
;
; Token $1c <
; IF X < 13 THEN END
;
f249: 20 5b f2 TF249 jsr TF25B
f24c: d0 15 bne JmpNOT
;
; Token $19 >
; IF X > 13 THEN END
;
f24e: 20 53 f2 TF24E jsr TF253
f251: d0 10 bne JmpNOT
;
; Token $1a <=
; IF X <= 13 THEN END
;
f253: 20 82 e7 TF253 jsr SUBTRACT
f256: 20 6f e7 jsr NEGATE
f259: 50 03 bvc LF25E
;
; Token $18 >=
; IF X >= 13 THEN END
;
f25b: 20 82 e7 TF25B jsr SUBTRACT
f25e: 20 59 e7 LF25E jsr SGN
f261: 56 50 lsr NOUNSTKL,x
f263: 4c 36 e7 JmpNOT jmp NOT
;
; Token $1d AND
;
f266: 20 c9 ef VAND jsr LEFC9
f269: 15 4f ora NOUNSTKL-1,x
f26b: 10 05 bpl LF272 ;(always?)
;
; Token $1e OR
;
f26d: 20 c9 ef VOR jsr LEFC9
f270: 35 4f and NOUNSTKL-1,x
f272: 95 50 LF272 sta NOUNSTKL,x
f274: 10 ed bpl JmpNOT
f276: 4c c9 ef jmp LEFC9
;
; Token $58 STEP
;
f279: 20 15 e7 STEP jsr GET16BIT
f27c: a4 fb ldy FORNDX
f27e: a5 ce lda ACC
f280: 99 5f 01 sta STK_60-1,y
f283: a5 cf lda ACC+1
f285: 4c 66 e9 jmp LE966
f288: 99 50 01 LF288 sta STK_50,y
f28b: 88 :Loop1 dey
f28c: 30 51 bmi :Return
f28e: b9 40 01 lda STK_40,y
f291: d5 50 cmp NOUNSTKL,x
f293: d0 f6 bne :Loop1
f295: b9 50 01 lda STK_50,y
f298: d5 78 cmp NOUNSTKH,x
f29a: d0 ef bne :Loop1
f29c: c6 fb dec FORNDX
f29e: b9 41 01 :Loop2 lda STK_40+1,y
f2a1: 99 40 01 sta STK_40,y
f2a4: b9 51 01 lda STK_50+1,y
f2a7: 99 50 01 sta STK_50,y
f2aa: b9 c1 01 lda STK_C0+1,y
f2ad: 99 c0 01 sta STK_C0,y
f2b0: b9 d1 01 lda STK_D0+1,y
f2b3: 99 d0 01 sta STK_D0,y
f2b6: b9 61 01 lda STK_60+1,y
f2b9: 99 60 01 sta STK_60,y
f2bc: b9 71 01 lda STK_70+1,y
f2bf: 99 70 01 sta STK_70,y
f2c2: b9 81 01 lda STK_80+1,y
f2c5: 99 80 01 sta STK_80,y
f2c8: b9 91 01 lda STK_90+1,y
f2cb: 99 90 01 sta STK_90,y
f2ce: b9 a1 01 lda STK_A0+1,y
f2d1: 99 a0 01 sta STK_A0,y
f2d4: b9 a1 01 lda STK_A0+1,y
f2d7: 99 a0 01 sta STK_A0,y
; BUG: above two lines should be:
; LDA STK_B0+1,Y
; STA STK_B0,Y
f2da: c8 iny
f2db: c4 fb cpy FORNDX
f2dd: 90 bf bcc :Loop2
f2df: 60 :Return rts
;
; Token $78 NODSP
; string var
;
f2e0: e8 NODSP_STR inx
;
; Token $79 NODSP
; num var
;
f2e1: a9 00 NODSP_NUM lda #$00
f2e3: 48 LF2E3 pha
f2e4: b5 50 lda NOUNSTKL,x
f2e6: 38 sec
f2e7: e9 03 sbc #$03
f2e9: 85 ce sta ACC
f2eb: b5 78 lda NOUNSTKH,x
f2ed: e9 00 sbc #$00
f2ef: 85 cf sta ACC+1
f2f1: 68 pla
f2f2: a0 00 ldy #$00
f2f4: 91 ce sta (ACC),y
f2f6: e8 inx
f2f7: 60 rts
f2f8: c9 85 LF2F8 cmp #$85
f2fa: b0 03 bcs LF2FF
f2fc: 4c c0 e4 jmp LE4C0
f2ff: a0 02 LF2FF ldy #$02
f301: 4c 48 e4 jmp LE448
;
; Token $7b DSP
; string var
;
f304: e8 DSP_STR inx ;[DSP_NUM in paulrsm disasm]
;
; Token $7c DSP
; num var
;
f305: a9 01 DSP_NUM lda #$01 ;[DSP_STR in paulrsm disasm]
f307: d0 da bne LF2E3 ;(always)
f309: e8 .dd1 $e8
;
; Token $06 CON
;
f30a: a5 78 CON lda NOUNSTKH ;PR = NOUNSTKH
f30c: 85 dc sta PR
f30e: a5 79 lda NOUNSTKH+1
f310: 85 dd sta PR+1
f312: a5 50 lda NOUNSTKL
f314: a4 51 ldy NOUNSTKL+1
f316: 4c 75 e8 jmp GETNEXT
f319: a9 01 unref_f319 lda #$01
f31b: d0 c6 bne LF2E3
;
; Token $3c ASC(
;
f31d: b5 50 ASC lda NOUNSTKL,x
f31f: d5 78 cmp NOUNSTKH,x
f321: 90 03 bcc LF326
f323: 4c 68 ee jmp RANGERR
f326: a8 LF326 tay
f327: b5 51 lda NOUNSTKL+1,x
f329: 85 ce sta ACC
f32b: b5 79 lda NOUNSTKH+1,x
f32d: 85 cf sta ACC+1
f32f: b1 ce lda (ACC),y
f331: a0 00 ldy #$00
f333: e8 inx
f334: e8 inx
f335: 20 08 e7 jsr LE708
f338: 4c 04 f4 jmp LF404
;
; Token $32 PDL
;
f33b: 20 34 ee PDL jsr GETBYTE
f33e: 86 d8 stx XSAVE
f340: 29 03 and #$03
f342: aa tax
f343: 20 1e fb jsr MON_PREAD
f346: a6 d8 ldx XSAVE
f348: 98 tya
f349: a0 00 ldy #$00
f34b: 20 08 e7 jsr LE708
f34e: 94 a0 sty NOUNSTKC,x
f350: 60 rts
f351: 20 75 fd RDKEY jsr MON_NXTCHAR
f354: 8a LF354 txa
f355: 48 pha
f356: bd 00 02 :Loop lda IN,x
f359: c9 83 cmp #ETX+128 ;is it Ctrl+C?
f35b: d0 03 bne LF360
f35d: 4c 03 e0 jmp BASIC2
f360: ca LF360 dex
f361: 10 f3 bpl :Loop
f363: 68 pla
f364: aa tax
f365: 60 rts
f366: 20 80 e2 LF366 jsr LE280
f369: 98 tya
f36a: aa tax
f36b: 20 54 f3 jsr LF354
f36e: 8a txa
f36f: a8 tay
f370: 60 rts
;
; Token $20 ^
;
f371: 20 15 e7 EXP jsr GET16BIT
f374: a5 cf lda ACC+1
f376: 10 08 bpl LF380
f378: 98 tya ;A-reg = 0
f379: ca dex
f37a: 20 08 e7 jsr LE708
f37d: 94 a0 sty NOUNSTKC,x
f37f: 60 :Return rts
f380: 85 d1 LF380 sta SRCH+1 ;SRCH = ACC
f382: a5 ce lda ACC
f384: 85 d0 sta SRCH
f386: 20 15 e7 jsr GET16BIT
f389: a5 ce lda ACC ;SRCH2 = ACC
f38b: 85 d2 sta SRCH2
f38d: a5 cf lda ACC+1
f38f: 85 d3 sta SRCH2+1
f391: a9 01 lda #$01
f393: 20 08 e7 jsr LE708
f396: 94 a0 sty NOUNSTKC,x
;
f398: a5 d0 :Loop lda SRCH ;srch = SRCH - 1
f39a: d0 04 bne :NoDec
f39c: c6 d1 dec SRCH+1 ;is SRCH negative?
f39e: 30 df bmi :Return ;yes, return
f3a0: c6 d0 :NoDec dec SRCH
f3a2: a5 d2 lda SRCH2
f3a4: a0 00 ldy #$00
f3a6: 20 08 e7 jsr LE708
f3a9: a5 d3 lda SRCH2+1
f3ab: 95 a0 sta NOUNSTKC,x
f3ad: 20 22 e2 jsr MULT
f3b0: 4c 98 f3 jmp :Loop
f3b3: 20 34 ee LF3B3 jsr GETBYTE
f3b6: 18 clc ;A-reg = A-reg - 1
f3b7: 69 ff adc #$ff
f3b9: 60 :Return rts
;
; Token $4a ,
; end of PRINT statement
; PRINT A$,
;
f3ba: 20 b1 e7 TF3BA jsr LE7B1
f3bd: 46 d5 lsr CRFLAG ;pos
f3bf: 60 rts
f3c0: 86 d9 unref_f3c0 stx RUNFLAG
f3c2: 9a txs
f3c3: 20 2e f0 jsr LF02E
f3c6: 4c 83 e8 jmp LE883
;
; Token $7e PR#
;
f3c9: 20 34 ee PRSLOT jsr GETBYTE
f3cc: 86 d8 stx XSAVE
f3ce: 20 95 fe jsr MON_OUTPORT
f3d1: a6 d8 ldx XSAVE
f3d3: 60 rts
f3d4: fe .dd1 $fe
f3d5: 24 d9 LF3D5 bit RUNFLAG
f3d7: 10 e0 bpl :Return
f3d9: 86 d8 stx XSAVE
f3db: 24 a0 bit NOUNSTKC
f3dd: 4c 12 f2 jmp LF212
f3e0: 24 d9 LF3E0 bit RUNFLAG
f3e2: 10 d5 bpl :Return
f3e4: 86 d8 stx XSAVE
f3e6: 24 a0 bit NOUNSTKC
f3e8: 4c 2c f2 jmp LF22C
f3eb: a0 00 LF3EB ldy #$00
f3ed: 4c ff e6 jmp GETVERB
f3f0: a8 :Loop tay
f3f1: 20 8e fd jsr MON_CROUT
f3f4: 98 LF3F4 tya
f3f5: 38 sec
f3f6: e5 21 sbc MON_WNDWDTH
f3f8: b0 f6 bcs :Loop
f3fa: 84 24 sty MON_CH
f3fc: 60 rts
f3fd: 00 00 00 ff+ .bulk $00,$00,$00,$ff,$ff,$ff,$ff
f404: 94 a0 LF404 sty NOUNSTKC,x
f406: 4c 23 e8 jmp TE823
f409: a0 00 LF409 ldy #$00
f40b: f0 04 beq LF411 ;(always)
f40d: 20 ed fd :Loop jsr MON_COUT
f410: c8 iny
f411: b1 da LF411 lda (AUX),y
f413: 30 f8 bmi :Loop
f415: a9 ff lda #$ff
f417: 85 d5 sta CRFLAG ;CRFLAG = $ff
f419: 60 rts
;
; Token $7f IN#
;
f41a: 20 34 ee INSLOT jsr GETBYTE
f41d: 86 d8 stx XSAVE
f41f: 20 8b fe jsr MON_INPORT
f422: a6 d8 ldx XSAVE
f424: 60 rts
f425: 18 a2 02 b5+ .junk 987 ;binary ends at $f7ff
.adrend ↑ $e000
No exported symbols found.