RUNTIME

The library as 6502 source in the style of Apple's DOS Toolkit assembler. Address and bytes on the left; labels in operands link to their definitions; point at a name from the equates for its meaning. The source assembles to the library byte for byte. Equates

Routines (66)

INIT INIT: START A COMPILED PROGRAM. EVERY OBJECT FILE BEGINS WITH JSR INIT FOLLOWED BY A 17-BYTE HEADER: THE FIRST
CLRCOM CLRCOM: CLEAR COMMON (REM! CLEAR COMMON). CLEAR: THE CLEAR STATEMENT. BOTH, AND THE END OF INIT, SHARE ONE ROU
HIMEM HIMEM: (THE STATEMENT): THE NEW HIMEM ADDRESS IS IN FAC. STRING SPACE IS EMPTIED BELOW IT; VARIABLES ARE NOT C
RESETSTK RESETSTK: EMPTY THE STACK, DROPPING EVERY PENDING GOSUB AND FOR, AND RESET THE DATA POINTER. THE BOTTOM OF THE
RESTORE RESTORE: POINT THE DATA POINTER AT THE FIRST DATA ITEM.
CHRPATCH CHRPATCH: 15 BYTES THAT INIT COPIES OVER CHRGET AT $BA-$C8. THEY RUN THERE, SO THEY ARE SHOWN AS THEY RUN AT $
POP POP (THE STATEMENT): DROP THE MOST RECENT GOSUB RETURN ADDRESS, PASSING OVER ANY FOR FRAMES ABOVE IT. ERROR RE
FORUNWND FORUNWND: EVERY FOR FRAME STARTS WITH THE ADDRESS IN FORPOP ($09B0), WHICH IS ALSO A RETURN ADDRESS. WHEN A SU
NORET NORET: RETURN WITHOUT GOSUB. RESETSTK LEAVES A RETURN ADDRESS TO HERE AT THE BOTTOM OF THE STACK.
FINDFOR FINDFOR: IS THERE A FOR FRAME ON THE STACK AT X? CARRY SET IF THE 16 BYTES ABOVE X START WITH THE FOR MARKER.
IFORINR FOR, THE START OF A LOOP. FOUR ENTRIES BY THE LOOP VARIABLE'S TYPE AND THE INITIAL VALUE'S: IFORINR INTEGER VA
NEXT NEXT: THE CALL IS FOLLOWED BY THE VARIABLE'S ADDRESS, 0 FOR A BARE NEXT. FRAMES OF INNER LOOPS ARE DROPPED UNT
ARRREAL ARRAY ELEMENTS. EVERY ARRAY HAS A ROUTINE IN THE PROGRAM: SEC (LOAD) OR CLC (ADDRESS) THEN JSR ARRREAL, ARRSTR
IMULT IMULT: INTEGER OPERATION 4: IACC = IACC * THE INTEGER AT (Y,A). SIGNS ARE TAKEN OUT (COUNTED IN $AB), THE MAGN
ARRLOAD ARRLOAD: LOAD THE ELEMENT AT (Y,A) BY ITS TYPE (X: 0 REAL, 1 INTEGER, 2 STRING).
ARRSTORE ARRSTORE: STORE THE VALUE INTO THE ARRAY ELEMENT WHOSE ADDRESS AND TYPE THE ARRAY ROUTINE LEFT IN $DC/$DD AND
DISPSTR DISPSTR: THE STRING VARIABLE DISPATCHER. A STRING VARIABLE'S ROUTINE IS SEC (OR CLC), LDA #, LDY #HIGH, LDA #L
ILOAD INTEGER OPERATIONS 0 AND 1, ENTERED FROM DISPINT WITH (Y,A) = THE VARIABLE'S ADDRESS. INTEGERS ARE STORED HIGH
INEG INEG: IACC = -IACC. IRSUB (INTEGER OPERATION 3): IACC = VARIABLE - IACC. ISUBT: IACC = IARG - IACC. IADD (OPER
DISPINT DISPINT: THE INTEGER VARIABLE DISPATCHER. A NUMERIC VARIABLE'S ROUTINE LOADS X WITH THE OPERATION AND (Y,A) WI
ICOMP ICOMP: INTEGER OPERATION 5: COMPARE IACC WITH THE VARIABLE. A = -1, 0 OR 1 AS FCOMP GIVES IT, FOR THE RELATION
ISTOREF ISTOREF: INTEGER OPERATION 7: STORE FAC IN THE INTEGER VARIABLE THROUGH APPLESOFT'S OWN LET, WHICH ROUNDS AND
IREAL IREAL: THE REAL OPERATIONS ON AN INTEGER VARIABLE. X: 0 LOAD, 1 ADD, 2 MULTIPLY, 3 COMPARE, 4 LOAD ARG OR (WIT
DRAWAT HI-RES: DRAW AND XDRAW AT X,Y, HPLOT TO AND HPLOT. EACH HAS A REAL ENTRY (JSR AYINT) AND AN INTEGER ENTRY 3 BY
DRAW DRAW AND XDRAW: THE SHAPE NUMBER IS CHECKED AGAINST THE COUNT AT THE START OF THE SHAPE TABLE, THE SHAPE'S ADD
COLOR COLOR=. LIKE MOST STATEMENTS WITH ONE NUMBER, A REAL ENTRY (JSR AYINT) FALLS INTO THE INTEGER ENTRY, WHICH TAK
VALFN VALFN: VAL OF THE STRING ACCUMULATOR. THE BYTE AFTER THE STRING IS REPLACED BY 0 WHILE THE ROM'S FIN READS THE
ASCFN ASCFN: ASC OF THE STRING ACCUMULATOR INTO IACC (ERROR $35 FOR AN EMPTY STRING). LENFN: ITS LENGTH INTO IACC.
STRLITP STRLITP AND STRLIT: A STRING LITERAL IN THE CODE: THE CALL IS FOLLOWED BY THE LITERAL'S ADDRESS. THE STRING AC
PRSTR PRSTR: PRINT THE STRING ACCUMULATOR.
CLRCHAIN CLRCHAIN (REM! CLEAR CHAIN) AND FREFN (FRE): BOTH COLLECT GARBAGE. CLEAR CHAIN LEAVES THE LOCAL STRINGS OUT, S
GARBAG GARBAG: THE GARBAGE COLLECTOR. EACH ROUND FINDS THE HIGHEST STRING STILL IN USE THAT IS BELOW THE STRINGS ALRE
OLDTEXT OLDTEXT: 45 BYTES OF TEXT LEFT IN MEMORY BY THE ASSEMBLER: NEVER EXECUTED. THE BRANCH BEFORE THEM IS ALWAYS TA
GETSTR GETSTR: GET A$: A NEW ONE-CHARACTER STRING FROM THE KEYBOARD.
CONCATT CONCAT: THE PUSHED STRING FOLLOWED BY THE LOADED STRING, AS A NEW STRING (ERROR $B0, STRING TOO LONG, PAST 255
PUSHSTR PUSHSTR: COPY THE LOADED STRING TO THE PUSHED STRING.
NEWSTR NEWSTR: MAKE ROOM FOR A NEW STRING OF ($0D) BYTES BELOW THE BOTTOM OF STRING SPACE, COLLECTING GARBAGE IF IT D
CHRFN CHR$: A ONE-CHARACTER STRING.
STRFN STR$: FOUT CONVERTS FAC TO TEXT AT $0100; THE TEXT BECOMES A NEW STRING.
LEFT LEFT$, RIGHT$ AND MID$. THE STRING IS IN THE STRING ACCUMULATOR; THE COUNT (AND FOR MID$ THE START, PUSHED BY
INPSTRQ INPUT. INPSTR AND INPNUM READ THE FIRST ITEM (PRINTING "?"), THE P ENTRIES THE FIRST ITEM AFTER A PROMPT, THE
STOP STOP: PRINT BREAK IN AND THE OBJECT ADDRESS OF THE STOP, THEN END.
PGMEND PGMEND (END, AND NEW): PUT CHRGET BACK FROM THE ROM, MAKE THE PROGRAM SPACE AN EMPTY PROGRAM AND GO BACK TO TH
INPEND INPEND: THE END OF AN INPUT STATEMENT: ?EXTRA IGNORED IF THE LINE HAS MORE.
GETNUM GETNUM: GET X: A DIGIT KEY GIVES ITS VALUE, ANY OTHER KEY 0.
READSTR READ. THE DATA POINTER WALKS THE DATA ITEMS IN THE CODE: EACH IS A LENGTH BYTE AND ITS TEXT; $FF IS FOLLOWED B
ERREXIT ERREXIT: EVERY LIBRARY ERROR ENDS HERE WITH THE ERROR NUMBER IN X. WITHOUT ONERR THE OBJECT ADDRESS OF THE CAL
DEBUG DEBUG: CALLED BEFORE EACH STATEMENT WITH THE RESUME/DEBUG OPTION. IT KEEPS THE STACK POINTER AND THE STATEMENT
PRNUM STATEMENTS WITH ONE BYTE ARGUMENT: PR#, IN#, POKE (THE VALUE), WAIT (THE MASKS), TAB(, SPC(. THE REAL ENTRY CO
COMMA COMMA: A COMMA IN PRINT: TO THE NEXT 16-COLUMN FIELD, OR A NEW LINE PAST COLUMN 24.
ONGOTO ON ... GOTO AND ON ... GOSUB: THE CALL IS FOLLOWED BY THE NUMBER OF LINES AND THEIR ADDRESSES. AN INDEX OF 0 O
LOGORI AND, OR AND THE RELATIONS. THE CODE BEFORE THE CALL HAS SET THE FLAGS: FOR AND/OR BY LOADING ONE OPERAND, FOR
STRGE STRING RELATIONS ON THE PUSHED STRING (LEFT) AND THE LOADED STRING (RIGHT). STRLT AND STRGE SWAP THEM AND USE
ROT STATEMENTS AND ARGUMENTS THAT KEEP A BYTE FOR LATER: ROT=, SCALE=, THE SHAPE NUMBER, THE THIRD WAIT ARGUMENT,
INPBEG INPBEG: THE START OF AN INPUT STATEMENT: KEEP ITS OBJECT ADDRESS FOR ?REENTER.
ONERR ONERR: THE CALL IS FOLLOWED BY THE HANDLER'S ADDRESS, WHICH GOES INTO THE ONERR VECTOR AT $5B.
RESUME RESUME: BACK TO THE STATEMENT THAT FAILED (ITS DEBUG CALL) WITH THE STACK AS IT WAS.
PUSHSUB PUSHSUB: PUSH A SUBSCRIPT UNDER THE RETURN ADDRESS FOR THE ARRAY ROUTINE.
FLOATI FLOATI: FAC = IACC. THE JMP AT $58 COMES HERE. IMOVE: IARG = IACC.
IFORST1 LOOP LIMIT AND STEP, CALLED AFTER THE LOOP START. THEY PUT THE VALUES INTO THE FRAME UNDER THE CALLER'S RETURN
SCRN SCRN(: THE FIRST ARGUMENT WAS PUSHED WITH PUSHBYTE. POS: THE CURSOR COLUMN. THE RESULT GOES TO IACC.
PLOT PLOT, HLIN, VLIN, PDL: THE LAST ARGUMENT; THE OTHERS WERE SAVED BEFORE. PDL GIVES ITS RESULT IN IACC.
CALLI STATEMENTS AND FUNCTIONS WITH AN ADDRESS: CALL, POKE AND WAIT (THE ADDRESS, SVADDR), PEEK. GETADR TAKES ANY VA
PRINTI PRINT A NUMBER: PRINTI FLOATS IACC FIRST.
DISPREAL DISPREAL: THE REAL VARIABLE DISPATCHER: X = OPERATION, (Y,A) = THE VARIABLE. 0 LOAD FAC (AND SET THE FLAGS), 1
COPYRT COPYRT: THE COPYRIGHT NOTICE.

ORG

$0803

THE LIBRARY'S USUAL ADDRESS

INIT

INIT: START A COMPILED PROGRAM. EVERY OBJECT FILE BEGINS WITH JSR INIT FOLLOWED BY A 17-BYTE HEADER: THE FIRST DATA ITEM, THE HIGHEST ADDRESS, THE COMMON BOUNDS (START-1, NUMERIC END, STRING END), THE LOCAL BOUNDS (THE SAME THREE), TWO BYTES EACH, AND THE COMMON FLAG (0 NONE OR DEFINE, $FF USE).

INIT POINTS THE & VECTOR AT THE PROGRAM (& RUNS IT AGAIN), SETS UP THE JMP VECTORS AT $58 (FLOAT THE INTEGER ACCUMULATOR) AND $5B (ONERR), FINDS THE LIBRARY'S OWN ADDRESS FROM THE OPERAND OF THE CALLER'S JSR, SO THE LIBRARY RUNS WHEREVER IT IS LOADED, PATCHES CHRGET FOR ONERR, COPIES THE HEADER TO PAGE ZERO AND CLEARS THE VARIABLES. IT RETURNS PAST THE HEADER.

0803	20 8B FD	INIT	JSR	CROUT1	CLEAR TO THE END OF THE LINE, NEW LINE
0806	A9 4C		LDA	#$4C	$4C, JMP, FOR THE THREE VECTORS
0808	8D F5 03		STA	AMPER	& VECTOR
080B	85 5B		STA	ERRVEC	ONERR VECTOR AT $5B
080D	85 58		STA	FLTVEC	FLOAT VECTOR AT $58
080F	68		PLA		THE CALLER'S RETURN ADDRESS: THE LAST BYTE OF ITS JSR
0810	AA		TAX
0811	18		CLC
0812	69 11		ADC	#$11	+$11: PAST THE 17-BYTE HEADER
0814	A8		TAY
0815	68		PLA		HIGH BYTE
0816	8D F7 03		STA	AMPER+2
0819	85 63		STA	RESULT+1	RESULT WILL POINT AT THE CALLER'S JSR
081B	69 00		ADC	#$00	PUSH THE ADDRESS AFTER THE HEADER FOR THE FINAL RTS
081D	48		PHA
081E	98		TYA
081F	48		PHA
0820	E0 02		CPX	#$02	THE JSR BEGINS 2 BYTES BEFORE: BORROW IF THE LOW BYTE IS BELOW 2
0822	B0 05		BCS	INIT1
0824	CE F7 03		DEC	AMPER+2
0827	C6 63		DEC	RESULT+1
0829	CA	INIT1	DEX		LOW BYTE - 2
082A	CA		DEX
082B	8E F6 03		STX	AMPER+1	THE & VECTOR JUMPS TO THE PROGRAM'S START: & RUNS IT AGAIN
082E	86 62		STX	RESULT	RESULT = ADDRESS OF THE CALLER'S JSR INIT
0830	A0 BB		LDY	#$BB	ONERR TEXT POINTER = $00BB, INSIDE THE CHRGET PATCH
0832	84 F4		STY	TXTPSV
0834	A0 00		LDY	#$00
0836	84 F5		STY	TXTPSV+1
0838	84 76		STY	CURLIN+1	NO STATEMENT ADDRESS YET
083A	84 75		STY	CURLIN
083C	84 D8		STY	ERRFLG	ONERR OFF
083E	C8		INY		THE JSR'S OPERAND IS THIS LIBRARY'S ADDRESS, L
083F	B1 62		LDA	(RESULT),Y
0841	18		CLC
0842	69 69		ADC	#$69	L+$169 = CHRPATCH
0844	85 83		STA	RETADR
0846	AA		TAX
0847	C8		INY
0848	B1 62		LDA	(RESULT),Y
084A	69 01		ADC	#$01
084C	85 84		STA	RETADR+1
084E	A8		TAY
084F	8A		TXA
0850	69 44		ADC	#$44	L+$1AD = $09B0, THE FOR MARKER (SEE FORUNWND)
0852	85 AF		STA	FORPOP
0854	98		TYA
0855	69 00		ADC	#$00
0857	85 B0		STA	FORPOP+1
0859	8A		TXA		L+$0E6B = FLOATI: $58 IS NOW JMP FLOATI
085A	69 02		ADC	#$02
085C	85 59		STA	FLTVEC+1
085E	98		TYA
085F	69 0D		ADC	#$0D
0861	85 5A		STA	FLTVEC+2
0863	A0 0E		LDY	#$0E	COPY THE 15 BYTES OF THE PATCH TO $BA-$C8
0865	B1 83	INIT2	LDA	(RETADR),Y
0867	99 BA 00		STA	CHRPAT,Y
086A	88		DEY
086B	10 F8		BPL	INIT2
086D	A9 55		LDA	#$55	APPLESOFT'S TEMPORARY STRING STACK, EMPTY
086F	85 52		STA	TEMPPT
0871	A9 06		LDA	#$06	$33 = 6
0873	85 33		STA	PROMPT
0875	A0 13		LDY	#$13	OFFSET 19 FROM THE JSR: THE COMMON FLAG
0877	B1 62		LDA	(RESULT),Y
0879	85 16		STA	HDRFLAG
087B	88	INIT3	DEY		THE HEADER, LAST WORD FIRST
087C	B1 62		LDA	(RESULT),Y
087E	C0 0D		CPY	#$0D	OFFSETS 13-18: THE LOCAL BOUNDS TO $7B-$80
0880	90 05		BCC	INIT4
0882	99 6E 00		STA	STRCEND+1,Y
0885	B0 F4		BCS	INIT3
0887	C0 07	INIT4	CPY	#$07	OFFSETS 7-12: THE COMMON BOUNDS TO $69-$6E ...
0889	90 12		BCC	INIT6
088B	24 16		BIT	HDRFLAG	... A PROGRAM THAT USES COMMON MUST FIND THEM AS THE PROGRAM BEFORE LEFT THEM
088D	10 09		BPL	INIT5
088F	D9 62 00		CMP	RESULT,Y
0892	F0 E7		BEQ	INIT3
0894	A2 A3		LDX	#$A3	A DIFFERENT COMMON BLOCK: ERROR $A3 (163, TYPE MISMATCH)
0896	D0 3E		BNE	CLEAR5
0898	99 62 00	INIT5	STA	RESULT,Y	NO COMMON OR DEFCOMMON: SET THEM
089B	10 DE		BPL	INIT3
089D	99 0F 00	INIT6	STA	NUMDIM,Y	OFFSETS 3-6: THE FIRST DATA ITEM AND THE HIGHEST ADDRESS TO $12-$15
08A0	C0 03		CPY	#$03
08A2	D0 D7		BNE	INIT3
08A4	A5 16		LDA	HDRFLAG	MODE = THE COMMON FLAG: 0 CLEARS COMMON AND LOCALS, $FF ONLY THE LOCALS
08A6	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES

CLRCOM

CLRCOM: CLEAR COMMON (REM! CLEAR COMMON). CLEAR: THE CLEAR STATEMENT. BOTH, AND THE END OF INIT, SHARE ONE ROUTINE WITH A IN THE ROLE OF A MODE: 1 CLEARS THE COMMON BLOCK, $FF THE LOCAL VARIABLES, 0 BOTH (INIT, NO COMMON OR DEFCOMMON).

NUMERIC VARIABLES BECOME ZERO; STRING VARIABLES POINT AT AN EMPTY STRING KEPT AT HIMEM-1. MODE 0 ALSO EMPTIES STRING SPACE. THE ROUTINE ENDS BY RESETTING THE STACK (RESETSTK).

08A7	A9 01	CLRCOM	LDA	#$01	MODE 1: THE COMMON BLOCK
08A9	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
08AA	A9 FF	CLEAR	LDA	#$FF	MODE $FF: THE LOCAL VARIABLES
08AC	A4 73		LDY	MEMSIZ	HIMEM
08AE	A6 74		LDX	MEMSIZ+1
08B0	86 16		STX	HDRFLAG	NOT ZERO: CLEAR VARIABLES AFTERWARDS
08B2	48	CLEAR1	PHA		KEEP THE MODE
08B3	98		TYA
08B4	D0 01		BNE	CLEAR2
08B6	CA		DEX
08B7	88	CLEAR2	DEY
08B8	86 7A		STX	STRPSH+1	STRPSH = HIMEM-1, AN EMPTY STRING (ITS LENGTH BYTE IS SET BELOW)
08BA	84 79		STY	STRPSH
08BC	68		PLA		MODE 0: ALSO EMPTY STRING SPACE ...
08BD	48		PHA
08BE	D0 09		BNE	CLEAR4
08C0	98		TYA
08C1	D0 01		BNE	CLEAR3
08C3	CA		DEX
08C4	88	CLEAR3	DEY
08C5	86 70		STX	FRETOP+1	... FRETOP = HIMEM-2
08C7	84 6F		STY	FRETOP
08C9	A4 6F	CLEAR4	LDY	FRETOP	STRING SPACE MUST STAY ABOVE THE PROGRAM AND ITS VARIABLES
08CB	C4 14		CPY	HIGHEST
08CD	A5 70		LDA	FRETOP+1
08CF	E5 15		SBC	HIGHEST+1
08D1	B0 1B		BCS	HIMEM2
08D3	68		PLA
08D4	A2 4D		LDX	#$4D	ELSE OUT OF MEMORY, ERROR $4D
08D6	D0 6D	CLEAR5	BNE	HIMEM10	ON TO THE ERROR EXIT (X = ERROR NUMBER)
08D8	20 58 00		JSR	FLTVEC	INTEGER ENTRY: FLOAT THE INTEGER ACCUMULATOR FIRST

HIMEM

HIMEM: (THE STATEMENT): THE NEW HIMEM ADDRESS IS IN FAC. STRING SPACE IS EMPTIED BELOW IT; VARIABLES ARE NOT CLEARED.

08DB	20 52 E7	HIMEM	JSR	GETADR	THE ADDRESS IN FAC TO LINNUM
08DE	A6 51		LDX	LINNUM+1	HIMEM = THE ADDRESS
08E0	86 74		STX	MEMSIZ+1
08E2	A4 50		LDY	LINNUM
08E4	84 73		STY	MEMSIZ
08E6	A9 00		LDA	#$00	MODE 0 AND NO VARIABLE CLEARING
08E8	85 16		STA	HDRFLAG
08EA	F0 C6		BEQ	CLEAR1
08EC	68	HIMEM1	PLA
08ED	60		RTS
08EE	A0 00	HIMEM2	LDY	#$00	THE EMPTY STRING: LENGTH 0
08F0	98		TYA
08F1	91 79		STA	(STRPSH),Y
08F3	A5 16		LDA	HDRFLAG	HIMEM: DONE
08F5	F0 F5		BEQ	HIMEM1
08F7	A2 00		LDX	#$00
08F9	68		PLA
08FA	48	HIMEM3	PHA		CLEAR ONE BLOCK: X = 0 THE COMMON BOUNDS ...
08FB	10 02		BPL	HIMEM4
08FD	A2 12		LDX	#$12	... X = $12 THE LOCAL BOUNDS ($7B-$80)
08FF	B5 6A	HIMEM4	LDA	COMBEG+1,X	A1 = THE BLOCK'S START-1
0901	85 3D		STA	A1L+1
0903	B5 69		LDA	COMBEG,X
0905	85 3C		STA	A1L
0907	A0 00		LDY	#$00
0909	E6 3C	HIMEM5	INC	A1L	NUMBERS: ZERO EVERY BYTE UP TO THE NUMERIC END
090B	D0 02		BNE	HIMEM6
090D	E6 3D		INC	A1L+1
090F	B5 6B	HIMEM6	LDA	NUMCEND,X
0911	C5 3C		CMP	A1L
0913	B5 6C		LDA	NUMCEND+1,X
0915	E5 3D		SBC	A1L+1
0917	90 05		BCC	HIMEM7
0919	98		TYA
091A	91 3C		STA	(A1L),Y
091C	F0 EB		BEQ	HIMEM5
091E	A5 3C	HIMEM7	LDA	A1L	STRINGS: EVERY POINTER UP TO THE STRING END ...
0920	D5 6D		CMP	STRCEND,X
0922	A5 3D		LDA	A1L+1
0924	F5 6E		SBC	STRCEND+1,X
0926	B0 16		BCS	HIMEM9
0928	A5 79		LDA	STRPSH	... POINTS AT THE EMPTY STRING
092A	91 3C		STA	(A1L),Y
092C	E6 3C		INC	A1L
092E	D0 02		BNE	HIMEM8
0930	E6 3D		INC	A1L+1
0932	A5 7A	HIMEM8	LDA	STRPSH+1
0934	91 3C		STA	(A1L),Y
0936	E6 3C		INC	A1L
0938	D0 E4		BNE	HIMEM7
093A	E6 3D		INC	A1L+1
093C	D0 E0		BNE	HIMEM7
093E	68	HIMEM9	PLA		MODE 0: NOW THE LOCALS TOO
093F	D0 06		BNE	RESETSTK
0941	A9 FF		LDA	#$FF
0943	30 B5		BMI	HIMEM3
0945	D0 68	HIMEM10	BNE	POP7	ON TO THE ERROR EXIT

RESETSTK

RESETSTK: EMPTY THE STACK, DROPPING EVERY PENDING GOSUB AND FOR, AND RESET THE DATA POINTER. THE BOTTOM OF THE NEW STACK IS A RETURN ADDRESS INTO NORET, SO A RETURN WITH NO GOSUB REPORTS RETURN WITHOUT GOSUB. PASS 0, 1 AND 2 OF THE COMPILER CALL THIS ROUTINE AFTER AN ERROR.

0947	68	RESETSTK	PLA		THE CALLER'S RETURN ADDRESS
0948	85 62		STA	RESULT
094A	68		PLA
094B	85 63		STA	RESULT+1
094D	A2 FF		LDX	#$FF	AN EMPTY STACK
094F	9A		TXS
0950	A5 AF		LDA	FORPOP	PUSH FORPOP+8 = $09B8, THE RTS BEFORE NORET: A RETURN WITHOUT GOSUB RETURNS TO NORET
0952	18		CLC
0953	69 08		ADC	#$08
0955	AA		TAX
0956	A5 B0		LDA	FORPOP+1
0958	69 00		ADC	#$00
095A	48		PHA
095B	8A		TXA
095C	48		PHA
095D	A5 63		LDA	RESULT+1	AND THE CALLER'S RETURN ADDRESS
095F	48		PHA
0960	A5 62		LDA	RESULT
0962	48		PHA

RESTORE

RESTORE: POINT THE DATA POINTER AT THE FIRST DATA ITEM.

0963	A5 12	RESTORE	LDA	DATFIRST	DATA POINTER = FIRST DATA ITEM
0965	85 F6		STA	DATPTR
0967	A5 13		LDA	DATFIRST+1
0969	85 F7		STA	DATPTR+1
096B	60		RTS

CHRPATCH

CHRPATCH: 15 BYTES THAT INIT COPIES OVER CHRGET AT $BA-$C8. THEY RUN THERE, SO THEY ARE SHOWN AS THEY RUN AT $BA.

FOR THE INTERPRETER NOTHING CHANGES: SPACES ARE SKIPPED AND THE ROM'S CHRGET GOES ON AT $F114. BUT WHEN THE ROM'S ERROR HANDLER, WITH ONERR ACTIVE, SETS THE TEXT POINTER TO $00BB (TXTPSV, SET BY INIT) AND CALLS CHRGOT, THE BYTE READ IS THE $20 OF THE PATCH'S OWN CMP, THE TEXT POINTER IS ON PAGE ZERO, AND THE PATCH JUMPS THROUGH THE ONERR VECTOR AT $5B INTO THE COMPILED HANDLER.

096C	C9 20	CHRPATCH	DFB	$C9,$20	$BA: CMP #$20
096E	D0 08		DFB	$D0,$08	$BC: BNE $00C6
0970	A5 B9		DFB	$A5,$B9	$BE: LDA $B9
0972	D0 EF		DFB	$D0,$EF	$C0: BNE $00B1
0974	E6 B9		DFB	$E6,$B9	$C2: INC $B9
0976	D0 95		DFB	$D0,$95	$C4: BNE $005B
0978	4C 14 F1		DFB	$4C,$14,$F1	$C6: JMP $F114

POP

POP (THE STATEMENT): DROP THE MOST RECENT GOSUB RETURN ADDRESS, PASSING OVER ANY FOR FRAMES ABOVE IT. ERROR RETURN WITHOUT GOSUB IF THERE IS NONE.

097B	68	POP	PLA		THE CALLER'S RETURN ADDRESS
097C	85 62		STA	RESULT
097E	68		PLA
097F	85 63		STA	RESULT+1
0981	BA		TSX
0982	A0 03	POP1	LDY	#$03	Y = 3: FINDFOR GOES ON AT POP2
0984	D0 38		BNE	FINDFOR
0986	90 03	POP2	BCC	POP3	A FOR FRAME: DROP IT AND LOOK AGAIN
0988	9A		TXS
0989	B0 F7		BCS	POP1
098B	A5 AF	POP3	LDA	FORPOP	IS THE TOP THE STACK'S BOTTOM ENTRY (THE RETURN TO NORET)?
098D	69 08		ADC	#$08
098F	A8		TAY
0990	A5 B0		LDA	FORPOP+1
0992	69 00		ADC	#$00
0994	BA		TSX
0995	DD 02 01		CMP	STACK+2,X	COMPARE HIGH BYTE ...
0998	D0 07		BNE	POP4
099A	98		TYA
099B	DD 01 01		CMP	STACK+1,X	... AND LOW BYTE
099E	38		SEC
099F	F0 03		BEQ	POP5
09A1	18	POP4	CLC		NO: DROP THE GOSUB RETURN ADDRESS
09A2	68		PLA
09A3	68		PLA
09A4	A5 63	POP5	LDA	RESULT+1	RETURN TO THE CALLER
09A6	48		PHA
09A7	A5 62		LDA	RESULT
09A9	48		PHA
09AA	B0 01		BCS	POP6
09AC	60		RTS
09AD	A2 16	POP6	LDX	#$16	RETURN WITHOUT GOSUB: ERROR $16
09AF	D0 2B	POP7	BNE	FINDF3	ON TO THE ERROR EXIT

FORUNWND

FORUNWND: EVERY FOR FRAME STARTS WITH THE ADDRESS IN FORPOP ($09B0), WHICH IS ALSO A RETURN ADDRESS. WHEN A SUBROUTINE RETURNS WITH UNFINISHED LOOPS ON THE STACK, ITS RTS PULLS THAT ADDRESS AND COMES HERE, ONE PAST IT: THE REST OF THE FRAME IS DROPPED AND RTS IS TRIED AGAIN, SO RETURN UNWINDS THE LOOPS.

09B1	BA	FORUNWND	TSX		THE MARKER'S 2 BYTES ARE GONE; DROP THE OTHER 14 ...
09B2	8A		TXA
09B3	18		CLC
09B4	69 0E		ADC	#$0E
09B6	AA		TAX
09B7	9A		TXS
09B8	60		RTS		... AND RETURN AGAIN

NORET

NORET: RETURN WITHOUT GOSUB. RESETSTK LEAVES A RETURN ADDRESS TO HERE AT THE BOTTOM OF THE STACK.

09B9	A2 16	NORET	LDX	#$16	ERROR $16: RETURN WITHOUT GOSUB
09BB	4C 12 D4		JMP	ERROR

FINDFOR

FINDFOR: IS THERE A FOR FRAME ON THE STACK AT X? CARRY SET IF THE 16 BYTES ABOVE X START WITH THE FOR MARKER. SHARED BY NEXT (Y = 1), FOR (Y = 2) AND POP (Y = 3); Y SAYS WHERE TO GO ON.

09BE	8A	FINDFOR	TXA		X+16: THE STACK ABOVE THE FRAME
09BF	18		CLC
09C0	69 10		ADC	#$10
09C2	B0 0F		BCS	FINDF1	NOT 16 BYTES LEFT: NO FRAME
09C4	AA		TAX
09C5	BD F1 00		DFB	$BD,$F1,$00	LDA $00F1,X (ABSOLUTE ON PURPOSE); THE FRAME'S FIRST TWO BYTES ...
09C8	C5 AF		CMP	FORPOP	... ARE THEY THE MARKER?
09CA	D0 07		BNE	FINDF1
09CC	BD F2 00		DFB	$BD,$F2,$00	LDA $00F2,X (ABSOLUTE ON PURPOSE)
09CF	C5 B0		CMP	FORPOP+1
09D1	F0 01		BEQ	FINDF2
09D3	18	FINDF1	CLC		CARRY CLEAR: NO FRAME
09D4	88	FINDF2	DEY		Y = 1: NEXT, 2: FOR, 3: POP
09D5	F0 66		BEQ	NEXT2
09D7	88		DEY
09D8	F0 3D		BEQ	FORIN5
09DA	D0 AA		BNE	POP2
09DC	D0 6C	FINDF3	BNE	NEXT3	ON TO THE ERROR EXIT

IFORINR

FOR, THE START OF A LOOP. FOUR ENTRIES BY THE LOOP VARIABLE'S TYPE AND THE INITIAL VALUE'S: IFORINR INTEGER VARIABLE, REAL VALUE; IFORINIT BOTH INTEGER; FORINITI REAL VARIABLE, INTEGER VALUE; FORINIT BOTH REAL. THE CALL IS FOLLOWED BY THE VARIABLE'S ADDRESS.

THE VALUE IS STORED IN THE VARIABLE; A FRAME FOR THE SAME VARIABLE STILL ON THE STACK IS REMOVED (AS IN APPLESOFT); THE VARIABLE'S ADDRESS IS PUSHED AS THE FIRST PART OF THE NEW FRAME. THE LIMIT AND STEP ROUTINES PUSH THE REST.

09DE	20 0C E1	IFORINR	JSR	AYINT	REAL VALUE TO AN INTEGER IN IACC
09E1	A2 01	IFORINIT	LDX	#$01	X = 1: STORE IACC
09E3	D0 05		BNE	FORIN1
09E5	20 58 00	FORINITI	JSR	FLTVEC	INTEGER VALUE TO A REAL IN FAC
09E8	A2 00	FORINIT	LDX	#$00	X = 0: STORE FAC
09EA	68	FORIN1	PLA		THE RETURN ADDRESS POINTS BEFORE THE INLINE WORD
09EB	85 83		STA	RETADR
09ED	68		PLA
09EE	85 84		STA	RETADR+1
09F0	A0 01		LDY	#$01	TPTR = THE LOOP VARIABLE'S ADDRESS
09F2	B1 83		LDA	(RETADR),Y
09F4	85 55		STA	TPTR
09F6	C8		INY
09F7	B1 83		LDA	(RETADR),Y
09F9	85 56		STA	TPTR+1
09FB	CA		DEX		INTEGER: STORE IACC, HIGH BYTE FIRST
09FC	30 0E		BMI	FORIN2
09FE	A0 00		LDY	#$00
0A00	A5 A0		LDA	IACC
0A02	91 55		STA	(TPTR),Y
0A04	C8		INY
0A05	A5 A1		LDA	IACC+1
0A07	91 55		STA	(TPTR),Y
0A09	98		TYA
0A0A	D0 06		BNE	FORIN3
0A0C	A8	FORIN2	TAY		REAL: STORE FAC ROUNDED AT (Y,X)
0A0D	A6 55		LDX	TPTR
0A0F	20 2B EB		JSR	MOVMF
0A12	BA	FORIN3	TSX		LOOK FOR A FRAME FOR THE SAME VARIABLE
0A13	A0 02	FORIN4	LDY	#$02
0A15	D0 A7		BNE	FINDFOR
0A17	90 0F	FORIN5	BCC	FORIN6	A FRAME: IS IT FOR THIS VARIABLE?
0A19	BD FF 00		DFB	$BD,$FF,$00	LDA $00FF,X (ABSOLUTE ON PURPOSE)
0A1C	C5 55		CMP	TPTR
0A1E	D0 F3		BNE	FORIN4
0A20	BD 00 01		LDA	STACK,X
0A23	C5 56		CMP	TPTR+1
0A25	D0 EC		BNE	FORIN4
0A27	9A		TXS		YES: DROP IT
0A28	A5 56	FORIN6	LDA	TPTR+1	START THE NEW FRAME: THE VARIABLE'S ADDRESS
0A2A	48		PHA
0A2B	A5 55		LDA	TPTR
0A2D	48		PHA
0A2E	18		CLC
0A2F	90 74		BCC	NEXT7	AND RETURN PAST THE INLINE WORD

NEXT: THE CALL IS FOLLOWED BY THE VARIABLE'S ADDRESS, 0 FOR A BARE NEXT. FRAMES OF INNER LOOPS ARE DROPPED UNTIL THE VARIABLE'S FRAME IS FOUND (ERROR NEXT WITHOUT FOR IF NONE). THE STEP IS ADDED TO THE VARIABLE AND THE RESULT COMPARED WITH THE LIMIT IN THE DIRECTION OF THE STEP: THE LOOP GOES ON BY RETURNING TO THE LOOP ADDRESS KEPT IN THE FRAME, OR ENDS BY DROPPING THE FRAME AND RETURNING PAST THE CALL.

FOR FRAME, 16 BYTES FROM THE TOP: MARKER (FORPOP), LOOP ADDRESS-1, STEP (5 BYTES PACKED), LIMIT (5), VARIABLE ADDRESS. AN INTEGER LOOP HAS 0 IN THE 4TH BYTE, THE STEP IN BYTES 5-6, THE LOOP ADDRESS IN 8-9 AND THE LIMIT IN 10-11.

0A31	68	NEXT	PLA		THE RETURN ADDRESS POINTS BEFORE THE INLINE WORD
0A32	85 83		STA	RETADR
0A34	68		PLA
0A35	85 84		STA	RETADR+1
0A37	BA		TSX
0A38	9A	NEXT1	TXS		DROP THE FRAME AT X (AN INNER LOOP) AND LOOK FURTHER
0A39	A0 01		LDY	#$01
0A3B	D0 81		BNE	FINDFOR
0A3D	A0 02	NEXT2	LDY	#$02	Y = 2: THE HIGH BYTE OF THE INLINE ADDRESS
0A3F	B0 0B		BCS	NEXT4	A FRAME
0A41	A5 84		LDA	RETADR+1	NONE: NEXT WITHOUT FOR (ERROR 0)
0A43	48		PHA
0A44	A5 83		LDA	RETADR
0A46	48		PHA
0A47	A2 00		LDX	#$00
0A49	98		TYA
0A4A	D0 66	NEXT3	BNE	NEXT8
0A4C	B1 83	NEXT4	LDA	(RETADR),Y	0: A BARE NEXT TAKES THE INNERMOST LOOP
0A4E	F0 0D		BEQ	NEXT5
0A50	DD 00 01		CMP	STACK,X	THE FRAME'S VARIABLE?
0A53	D0 E3		BNE	NEXT1
0A55	88		DEY
0A56	B1 83		LDA	(RETADR),Y
0A58	DD FF 00		DFB	$DD,$FF,$00	CMP $00FF,X (ABSOLUTE ON PURPOSE)
0A5B	D0 DB		BNE	NEXT1
0A5D	BA	NEXT5	TSX		THE FRAME IS AT X+1
0A5E	BD 04 01		LDA	STACK+4,X	A ZERO 4TH BYTE: AN INTEGER LOOP
0A61	F0 51		BEQ	NEXT9
0A63	8A		TXA		REAL: FAC = STEP
0A64	18		CLC
0A65	69 05		ADC	#$05
0A67	A0 01		LDY	#$01
0A69	20 F9 EA		JSR	MOVFM
0A6C	20 82 EB		JSR	SIGN	THE SIGN OF THE STEP
0A6F	85 65		STA	RESULT+3
0A71	BA		TSX		FAC = STEP + VARIABLE
0A72	BC 10 01		LDY	$0110,X
0A75	BD 0F 01		LDA	$010F,X
0A78	20 BE E7		JSR	FADD
0A7B	BA		TSX		STORE IT IN THE VARIABLE
0A7C	BC 10 01		LDY	$0110,X
0A7F	BD 0F 01		LDA	$010F,X
0A82	AA		TAX
0A83	20 2B EB		JSR	MOVMF
0A86	BA		TSX		COMPARE WITH THE LIMIT
0A87	8A		TXA
0A88	18		CLC
0A89	69 0A		ADC	#$0A
0A8B	A0 01		LDY	#$01
0A8D	20 B2 EB		JSR	FCOMP
0A90	C5 65		CMP	RESULT+3	PAST THE LIMIT IN THE STEP'S DIRECTION: THE LOOP IS DONE
0A92	F0 0A		BEQ	NEXT6
0A94	BA		TSX		AGAIN: RETURN TO THE LOOP ADDRESS KEPT IN THE FRAME
0A95	BD 04 01		LDA	STACK+4,X
0A98	48		PHA
0A99	BD 03 01		LDA	STACK+3,X
0A9C	48		PHA
0A9D	60		RTS
0A9E	BA	NEXT6	TSX		DONE: DROP THE 16-BYTE FRAME
0A9F	8A		TXA
0AA0	18		CLC
0AA1	69 10		ADC	#$10
0AA3	AA		TAX
0AA4	9A		TXS
0AA5	A5 83	NEXT7	LDA	RETADR	RETURN PAST THE INLINE WORD
0AA7	69 02		ADC	#$02
0AA9	AA		TAX
0AAA	A5 84		LDA	RETADR+1
0AAC	69 00		ADC	#$00
0AAE	48		PHA
0AAF	8A		TXA
0AB0	48		PHA
0AB1	60		RTS
0AB2	D0 28	NEXT8	BNE	NEXT10
0AB4	BD 05 01	NEXT9	LDA	STACK+5,X	INTEGER LOOP: IACC = STEP
0AB7	85 A0		STA	IACC
0AB9	BD 06 01		LDA	$0106,X
0ABC	85 A1		STA	IACC+1
0ABE	BD 0F 01		LDA	$010F,X	RESULT = THE VARIABLE'S ADDRESS
0AC1	85 62		STA	RESULT
0AC3	BD 10 01		LDA	$0110,X
0AC6	85 63		STA	RESULT+1
0AC8	A0 01		LDY	#$01	VARIABLE += STEP, LOW BYTE ...
0ACA	B1 62		LDA	(RESULT),Y
0ACC	18		CLC
0ACD	65 A1		ADC	IACC+1
0ACF	91 62		STA	(RESULT),Y
0AD1	85 A1		STA	IACC+1
0AD3	88		DEY		... HIGH BYTE
0AD4	B1 62		LDA	(RESULT),Y
0AD6	65 A0		ADC	IACC
0AD8	50 04		BVC	NEXT11	OVERFLOW: ERROR $45
0ADA	A2 45		LDX	#$45
0ADC	D0 31	NEXT10	BNE	NEXT17
0ADE	91 62	NEXT11	STA	(RESULT),Y
0AE0	A8		TAY
0AE1	5D 0A 01		EOR	$010A,X	SAME SIGN AS THE LIMIT?
0AE4	10 0A		BPL	NEXT13
0AE6	98		TYA
0AE7	10 1F		BPL	NEXT16
0AE9	BD 05 01	NEXT12	LDA	STACK+5,X
0AEC	10 11		BPL	NEXT15
0AEE	30 AE		BMI	NEXT6
0AF0	98	NEXT13	TYA
0AF1	DD 0A 01		CMP	$010A,X
0AF4	90 F3	NEXT14	BCC	NEXT12
0AF6	D0 10		BNE	NEXT16
0AF8	A5 A1		LDA	IACC+1
0AFA	DD 0B 01		CMP	$010B,X
0AFD	D0 F5		BNE	NEXT14
0AFF	BD 09 01	NEXT15	LDA	$0109,X	NOT PAST THE LIMIT: BACK TO THE LOOP
0B02	48		PHA
0B03	BD 08 01		LDA	$0108,X
0B06	48		PHA
0B07	60		RTS
0B08	BD 05 01	NEXT16	LDA	STACK+5,X
0B0B	30 F2		BMI	NEXT15
0B0D	10 8F		BPL	NEXT6
0B0F	D0 53	NEXT17	BNE	ARRDIM2

ARRREAL

ARRAY ELEMENTS. EVERY ARRAY HAS A ROUTINE IN THE PROGRAM: SEC (LOAD) OR CLC (ADDRESS) THEN JSR ARRREAL, ARRSTR OR ARRINT, FOLLOWED BY THE ARRAY'S DESCRIPTOR: ITS ADDRESS, THE NUMBER OF DIMENSIONS AND THE HIGHEST INDEX OF EACH, LAST DIMENSION FIRST.

THE FIRST SUBSCRIPT IS IN IACC; THE OTHERS WERE PUSHED BY PUSHSUB. EACH IS CHECKED AGAINST ITS HIGHEST INDEX (ERROR $6B, BAD SUBSCRIPT) AND THE OFFSET IS BUILT AS OFFSET*(HIGHEST+1)+SUBSCRIPT, THEN SCALED BY THE ELEMENT SIZE (5 REAL, 2 INTEGER OR STRING).

LOAD: THE ELEMENT GOES TO FAC, IACC OR THE STRING ACCUMULATOR. ADDRESS: THE ELEMENT'S ADDRESS GOES TO $DC/$DD AND ITS TYPE TO $D9 FOR ARRSTORE, WHICH STORES THE VALUE COMPUTED IN BETWEEN.

0B11	A2 00	ARRREAL	LDX	#$00	X = ELEMENT TYPE: 0 REAL ...
0B13	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0B14	A2 02	ARRSTR	LDX	#$02	... 2 STRING ...
0B16	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0B17	A2 01	ARRINT	LDX	#$01	... 1 INTEGER
0B19	08		PHP		KEEP THE CARRY: 1 LOAD, 0 ADDRESS
0B1A	68		PLA
0B1B	85 64		STA	RESULT+2
0B1D	86 65		STX	RESULT+3	AND THE TYPE
0B1F	68		PLA		TPTR = THE DESCRIPTOR - 1 (THE ROUTINE'S RETURN ADDRESS)
0B20	85 55		STA	TPTR
0B22	68		PLA
0B23	85 56		STA	TPTR+1
0B25	68		PLA		RETADR = THE COMPILED CODE'S RETURN ADDRESS
0B26	85 83		STA	RETADR
0B28	68		PLA
0B29	85 84		STA	RETADR+1
0B2B	A5 A0		LDA	IACC	THE FIRST SUBSCRIPT JOINS THE OTHERS ON THE STACK
0B2D	48		PHA
0B2E	A5 A1		LDA	IACC+1
0B30	48		PHA
0B31	A0 00		LDY	#$00	OFFSET = 0
0B33	84 A1		STY	IACC+1
0B35	84 A0		STY	IACC
0B37	A0 03		LDY	#$03	Y = 2 * DIMENSIONS + 3: THE LAST HIGHEST INDEX
0B39	B1 55		LDA	(TPTR),Y
0B3B	0A		ASL	A
0B3C	A8		TAY
0B3D	C8		INY
0B3E	C8		INY
0B3F	C8	ARRDIM	INY		EACH DIMENSION: ADD THE NEXT SUBSCRIPT TO THE OFFSET
0B40	68		PLA
0B41	AA		TAX
0B42	18		CLC
0B43	65 A1		ADC	IACC+1
0B45	85 A1		STA	IACC+1
0B47	68		PLA
0B48	48		PHA
0B49	65 A0		ADC	IACC
0B4B	85 A0		STA	IACC
0B4D	68		PLA		CHECK IT AGAINST THE HIGHEST INDEX
0B4E	D1 55		CMP	(TPTR),Y
0B50	90 14		BCC	ARRSUB
0B52	D0 08		BNE	ARRDIM1
0B54	88		DEY
0B55	8A		TXA
0B56	D1 55		CMP	(TPTR),Y
0B58	90 0D		BCC	ARRSUB1
0B5A	F0 0B		BEQ	ARRSUB1
0B5C	A5 84	ARRDIM1	LDA	RETADR+1	TOO LARGE (OR NEGATIVE): BAD SUBSCRIPT, ERROR $6B
0B5E	48		PHA
0B5F	A5 83		LDA	RETADR
0B61	48		PHA
0B62	A2 6B		LDX	#$6B
0B64	D0 60	ARRDIM2	BNE	ARRAD1
0B66	88	ARRSUB	DEY		NEXT DIMENSION
0B67	88	ARRSUB1	DEY
0B68	88		DEY
0B69	C0 02		CPY	#$02	ALL DONE
0B6B	F0 18		BEQ	ARRSIZE
0B6D	84 8E		STY	TEMP3+4	OFFSET *= HIGHEST+1 OF THE NEXT DIMENSION
0B6F	B1 55		LDA	(TPTR),Y
0B71	18		CLC
0B72	69 01		ADC	#$01
0B74	85 9F		STA	IARG+1
0B76	C8		INY
0B77	B1 55		LDA	(TPTR),Y
0B79	69 00		ADC	#$00
0B7B	85 9E		STA	IARG
0B7D	A2 00		LDX	#$00	X = 0 (KEPT IN $16): MULSHARE COMES BACK TO $0B81
0B7F	F0 75		BEQ	MULSHARE
0B81	A4 8E	ARRSUB2	LDY	TEMP3+4
0B83	D0 BA		BNE	ARRDIM
0B85	A6 65	ARRSIZE	LDX	RESULT+3	TIMES THE ELEMENT SIZE: 2 ...
0B87	F0 06		BEQ	ARRSI1
0B89	06 A1		ASL	IACC+1
0B8B	26 A0		ROL	IACC
0B8D	90 15		BCC	ARRADDR
0B8F	A4 A0	ARRSI1	LDY	IACC	... OR 5 (4+1) FOR A REAL
0B91	A5 A1		LDA	IACC+1
0B93	85 16		STA	HDRFLAG
0B95	0A		ASL	A
0B96	26 A0		ROL	IACC
0B98	0A		ASL	A
0B99	26 A0		ROL	IACC
0B9B	65 16		ADC	HDRFLAG
0B9D	85 A1		STA	IACC+1
0B9F	98		TYA
0BA0	65 A0		ADC	IACC
0BA2	85 A0		STA	IACC
0BA4	A5 84	ARRADDR	LDA	RETADR+1	RETURN ADDRESS BACK FOR THE COMPILED CODE
0BA6	48		PHA
0BA7	A5 83		LDA	RETADR
0BA9	48		PHA
0BAA	A0 01		LDY	#$01	ELEMENT ADDRESS = ARRAY ADDRESS + OFFSET
0BAC	18		CLC
0BAD	A5 A1		LDA	IACC+1
0BAF	71 55		ADC	(TPTR),Y
0BB1	AA		TAX
0BB2	C8		INY
0BB3	A5 A0		LDA	IACC
0BB5	71 55		ADC	(TPTR),Y
0BB7	A8		TAY
0BB8	8A		TXA
0BB9	A6 65		LDX	RESULT+3
0BBB	46 64		LSR	RESULT+2	LOAD?
0BBD	B0 4F		BCS	MULSH1
0BBF	84 DD		STY	ERRPOS+1	NO: KEEP THE ADDRESS AND TYPE FOR ARRSTORE
0BC1	85 DC		STA	ERRPOS
0BC3	86 D9		STX	ELTYPE
0BC5	60		RTS
0BC6	D0 79	ARRAD1	BNE	MULLO3

IMULT

IMULT: INTEGER OPERATION 4: IACC = IACC * THE INTEGER AT (Y,A). SIGNS ARE TAKEN OUT (COUNTED IN $AB), THE MAGNITUDES MULTIPLIED BY SHIFT AND ADD, AND THE SIGN PUT BACK. ERROR $45 (OVERFLOW) IF THE PRODUCT DOES NOT FIT. MULSHARE IS THE SAME MULTIPLY WITHOUT SIGNS, USED BY THE ARRAY CODE.

0BC8	84 63	IMULT	STY	RESULT+1	THE VARIABLE INTO IARG
0BCA	85 62		STA	RESULT
0BCC	A0 00		LDY	#$00
0BCE	B1 62		LDA	(RESULT),Y
0BD0	85 9E		STA	IARG
0BD2	C8		INY
0BD3	B1 62		LDA	(RESULT),Y
0BD5	85 9F		STA	IARG+1
0BD7	A2 02		LDX	#$02	MAKE IARG AND IACC POSITIVE, COUNTING NEGATIVES
0BD9	86 AB		STX	SGNCPR
0BDB	B5 9E	IMULT1	LDA	IARG,X
0BDD	10 13		BPL	IMULT3
0BDF	10 A0	IMULT2	BPL	ARRSUB2
0BE1	C6 AB		DEC	SGNCPR	ONE MORE NEGATIVE
0BE3	A9 00		LDA	#$00
0BE5	38		SEC
0BE6	F5 9F		SBC	IARG+1,X
0BE8	95 9F		STA	IARG+1,X
0BEA	A9 00		LDA	#$00
0BEC	F5 9E		SBC	IARG,X
0BEE	95 9E		STA	IARG,X
0BF0	70 4D		BVS	MULLO2	-32768 HAS NO POSITIVE: OVERFLOW
0BF2	CA	IMULT3	DEX
0BF3	CA		DEX
0BF4	F0 E5		BEQ	IMULT1
0BF6	86 16	MULSHARE	STX	HDRFLAG	THE SMALLER FACTOR GOES IN THE SHIFT REGISTER
0BF8	A6 9F		LDX	IARG+1
0BFA	E4 A1		CPX	IACC+1
0BFC	A5 9E		LDA	IARG
0BFE	E5 A0		SBC	IACC
0C00	B0 0E		BCS	MULSH2
0C02	A4 9E		LDY	IARG
0C04	A5 A0		LDA	IACC
0C06	85 9E		STA	IARG
0C08	A5 A1		LDA	IACC+1
0C0A	85 9F		STA	IARG+1
0C0C	90 06		BCC	MULSH3
0C0E	B0 3E	MULSH1	BCS	ARRLOAD
0C10	A4 A0	MULSH2	LDY	IACC
0C12	A6 A1		LDX	IACC+1
0C14	84 A2	MULSH3	STY	FACSIGN	Y,X: THE MULTIPLIER, SHIFTED OUT BIT BY BIT
0C16	86 A3		STX	SERLEN
0C18	A9 00		LDA	#$00	PRODUCT = 0
0C1A	85 A0		STA	IACC
0C1C	85 A1		STA	IACC+1
0C1E	46 A2	MULLOOP	LSR	FACSIGN	NEXT BIT OF THE MULTIPLIER
0C20	66 A3		ROR	SERLEN
0C22	90 0F		BCC	MULLO1
0C24	A5 9F		LDA	IARG+1	SET: ADD THE MULTIPLICAND
0C26	18		CLC
0C27	65 A1		ADC	IACC+1
0C29	85 A1		STA	IACC+1
0C2B	A5 9E		LDA	IARG
0C2D	65 A0		ADC	IACC
0C2F	85 A0		STA	IACC
0C31	30 0C		BMI	MULLO2	PAST 32767: OVERFLOW
0C33	A5 A2	MULLO1	LDA	FACSIGN	NO BITS LEFT: DONE
0C35	05 A3		ORA	SERLEN
0C37	F0 0C		BEQ	MULLO5
0C39	06 9F		ASL	IARG+1	MULTIPLICAND * 2
0C3B	26 9E		ROL	IARG
0C3D	10 DF		BPL	MULLOOP
0C3F	A2 45	MULLO2	LDX	#$45	OVERFLOW: ERROR $45
0C41	D0 58	MULLO3	BNE	DISPS2
0C43	F0 83	MULLO4	BEQ	IMULT
0C45	24 16	MULLO5	BIT	HDRFLAG	FROM THE ARRAY CODE: BACK TO IT
0C47	10 96		BPL	IMULT2
0C49	C6 AB		DEC	SGNCPR	ONE NEGATIVE FACTOR: NEGATE THE PRODUCT
0C4B	F0 76		BEQ	INEG
0C4D	60		RTS

ARRLOAD

ARRLOAD: LOAD THE ELEMENT AT (Y,A) BY ITS TYPE (X: 0 REAL, 1 INTEGER, 2 STRING).

0C4E	CA	ARRLOAD	DEX		REAL ...
0C4F	10 08		BPL	ARRLO1
0C51	20 F9 EA		JSR	MOVFM	FAC = THE ELEMENT, FLAGS SET
0C54	A5 AA		LDA	ARGSIGN
0C56	4C 59 DE		JMP	SGNEXIT
0C59	F0 44	ARRLO1	BEQ	ILOAD	INTEGER: ILOAD ...
0C5B	84 63		STY	RESULT+1	... STRING: BOTH STRING ACCUMULATORS
0C5D	85 62		STA	RESULT
0C5F	A0 00		LDY	#$00
0C61	B1 62		LDA	(RESULT),Y
0C63	85 77		STA	STRACC
0C65	85 79		STA	STRPSH
0C67	C8		INY
0C68	B1 62		LDA	(RESULT),Y
0C6A	85 78		STA	STRACC+1
0C6C	85 7A		STA	STRPSH+1
0C6E	60		RTS

ARRSTORE

ARRSTORE: STORE THE VALUE INTO THE ARRAY ELEMENT WHOSE ADDRESS AND TYPE THE ARRAY ROUTINE LEFT IN $DC/$DD AND $D9.

0C6F	A4 DD	ARRSTORE	LDY	ERRPOS+1	THE ELEMENT'S ADDRESS ...
0C71	A5 DC		LDA	ERRPOS
0C73	A6 D9		LDX	ELTYPE	... AND TYPE
0C75	D0 04		BNE	ARRST1
0C77	AA		TAX		REAL: STORE FAC ROUNDED
0C78	4C 2B EB		JMP	MOVMF
0C7B	CA	ARRST1	DEX		INTEGER: STORE IACC; STRING: FALL INTO THE STRING STORE WITH CARRY CLEAR
0C7C	F0 33		BEQ	ISTORE
0C7E	18		CLC

DISPSTR

DISPSTR: THE STRING VARIABLE DISPATCHER. A STRING VARIABLE'S ROUTINE IS SEC (OR CLC), LDA #, LDY #HIGH, LDA #LOW, JMP DISPSTR: CARRY SET LOADS THE VARIABLE'S POINTER INTO THE STRING ACCUMULATOR $77/$78, CARRY CLEAR STORES IT.

0C7F	85 55	DISPSTR	STA	TPTR
0C81	84 56		STY	TPTR+1
0C83	A0 00		LDY	#$00
0C85	90 0A		BCC	DISPS1	CARRY CLEAR: STORE
0C87	B1 55		LDA	(TPTR),Y	LOAD: THE VARIABLE'S POINTER INTO $77/$78
0C89	85 77		STA	STRACC
0C8B	C8		INY
0C8C	B1 55		LDA	(TPTR),Y
0C8E	85 78		STA	STRACC+1
0C90	60		RTS
0C91	A5 77	DISPS1	LDA	STRACC	STORE: $77/$78 INTO THE VARIABLE
0C93	91 55		STA	(TPTR),Y
0C95	C8		INY
0C96	A5 78		LDA	STRACC+1
0C98	91 55		STA	(TPTR),Y
0C9A	60		RTS
0C9B	D0 4E	DISPS2	BNE	ISUBT2
0C9D	F0 A4	DISPS3	BEQ	MULLO4

ILOAD

INTEGER OPERATIONS 0 AND 1, ENTERED FROM DISPINT WITH (Y,A) = THE VARIABLE'S ADDRESS. INTEGERS ARE STORED HIGH BYTE FIRST. BOTH LEAVE THE FLAGS SET BY THE VALUE.

0C9F	84 63	ILOAD	STY	RESULT+1	LOAD IACC FROM THE VARIABLE
0CA1	85 62		STA	RESULT
0CA3	A0 00		LDY	#$00
0CA5	B1 62		LDA	(RESULT),Y
0CA7	85 A0		STA	IACC
0CA9	C8		INY
0CAA	B1 62		LDA	(RESULT),Y
0CAC	85 A1		STA	IACC+1
0CAE	05 A0		ORA	IACC
0CB0	60		RTS
0CB1	84 63	ISTORE	STY	RESULT+1	STORE IACC IN THE VARIABLE
0CB3	85 62		STA	RESULT
0CB5	A0 00		LDY	#$00
0CB7	A5 A0		LDA	IACC
0CB9	91 62		STA	(RESULT),Y
0CBB	C8		INY
0CBC	A5 A1		LDA	IACC+1
0CBE	91 62		STA	(RESULT),Y
0CC0	05 A0		ORA	IACC
0CC2	60		RTS

INEG

INEG: IACC = -IACC. IRSUB (INTEGER OPERATION 3): IACC = VARIABLE - IACC. ISUBT: IACC = IARG - IACC. IADD (OPERATION 2): IACC = IACC + VARIABLE. ERROR $45 ON OVERFLOW.

0CC3	A9 00	INEG	LDA	#$00	IARG = 0, THEN 0 - IACC
0CC5	85 9E		STA	IARG
0CC7	85 9F		STA	IARG+1
0CC9	F0 0F		BEQ	ISUBT
0CCB	84 63	IRSUB	STY	RESULT+1	IARG = THE VARIABLE
0CCD	85 62		STA	RESULT
0CCF	A0 00		LDY	#$00
0CD1	B1 62		LDA	(RESULT),Y
0CD3	85 9E		STA	IARG
0CD5	C8		INY
0CD6	B1 62		LDA	(RESULT),Y
0CD8	85 9F		STA	IARG+1
0CDA	A5 9F	ISUBT	LDA	IARG+1	IACC = IARG - IACC
0CDC	38		SEC
0CDD	E5 A1		SBC	IACC+1
0CDF	85 A1		STA	IACC+1
0CE1	A5 9E		LDA	IARG
0CE3	E5 A0		SBC	IACC
0CE5	85 A0		STA	IACC
0CE7	50 1C		BVC	IADD1
0CE9	A2 45	ISUBT1	LDX	#$45	OVERFLOW: ERROR $45
0CEB	D0 6E	ISUBT2	BNE	ICOMP5
0CED	84 63	IADD	STY	RESULT+1	IACC = IACC + THE VARIABLE
0CEF	85 62		STA	RESULT
0CF1	A0 00		LDY	#$00
0CF3	B1 62		LDA	(RESULT),Y
0CF5	AA		TAX
0CF6	C8		INY
0CF7	B1 62		LDA	(RESULT),Y
0CF9	18		CLC
0CFA	65 A1		ADC	IACC+1
0CFC	85 A1		STA	IACC+1
0CFE	8A		TXA
0CFF	65 A0		ADC	IACC
0D01	85 A0		STA	IACC
0D03	70 E4		BVS	ISUBT1
0D05	60	IADD1	RTS

DISPINT

DISPINT: THE INTEGER VARIABLE DISPATCHER. A NUMERIC VARIABLE'S ROUTINE LOADS X WITH THE OPERATION AND (Y,A) WITH THE VARIABLE'S ADDRESS AND JUMPS HERE.

0 LOAD IACC, 1 STORE IACC, 2 ADD, 3 VARIABLE MINUS IACC, 4 MULTIPLY, 5 COMPARE; 6-13 ARE THE REAL OPERATIONS 0-7 WITH THE VARIABLE USED AS A REAL: 6 LOAD FAC, 7 STORE FAC (ROUNDED, RANGE CHECKED), 8 ADD, 9 SUBTRACT, 10 MULTIPLY, 11 COMPARE, 12 LOAD ARG, 13 DIVIDE.

0D06	CA	DISPINT	DEX		OPERATION 0
0D07	30 96		BMI	ILOAD
0D09	F0 A6		BEQ	ISTORE	1
0D0B	CA		DEX		2
0D0C	F0 DF		BEQ	IADD
0D0E	CA		DEX		3
0D0F	F0 BA		BEQ	IRSUB
0D11	CA		DEX		4
0D12	F0 89		BEQ	DISPS3
0D14	CA		DEX		5
0D15	F0 1E		BEQ	ICOMP
0D17	CA		DEX		6: LOAD AS A REAL
0D18	F0 43		BEQ	ICOMP6
0D1A	CA		DEX		7: STORE FAC
0D1B	F0 42		BEQ	ISTOREF
0D1D	CA		DEX		8: ADD AS A REAL
0D1E	F0 65		BEQ	ISTOR6
0D20	CA		DEX		9: SUBTRACT: FAC = -FAC, THEN ADD
0D21	F0 5D		BEQ	ISTOR5
0D23	CA		DEX		10: MULTIPLY
0D24	F0 51		BEQ	ISTOR3
0D26	CA		DEX		11: COMPARE
0D27	F0 3D		BEQ	ISTOR1
0D29	CA		DEX		12: LOAD ARG
0D2A	F0 62		BEQ	ISTOR8
0D2C	A2 01		LDX	#$01	13: DIVIDE
0D2E	D0 60		BNE	ISTOR9
0D30	A5 9D	DISPI1	LDA	FAC	FAC = ARG / FAC
0D32	4C 69 EA		JMP	FDIVT

ICOMP

ICOMP: INTEGER OPERATION 5: COMPARE IACC WITH THE VARIABLE. A = -1, 0 OR 1 AS FCOMP GIVES IT, FOR THE RELATIONS.

0D35	84 63	ICOMP	STY	RESULT+1	Y = HIGH BYTE, X = LOW BYTE OF THE VARIABLE
0D37	85 62		STA	RESULT
0D39	A0 01		LDY	#$01
0D3B	B1 62		LDA	(RESULT),Y
0D3D	AA		TAX
0D3E	88		DEY
0D3F	B1 62		LDA	(RESULT),Y
0D41	A8		TAY
0D42	45 A0		EOR	IACC	DIFFERENT SIGNS: THE NEGATIVE ONE IS SMALLER
0D44	10 06		BPL	ICOMP2
0D46	98		TYA
0D47	30 0F		BMI	ICOMP4
0D49	A9 FF	ICOMP1	LDA	#$FF
0D4B	60		RTS
0D4C	C4 A0	ICOMP2	CPY	IACC	SAME SIGN: COMPARE HIGH, THEN LOW
0D4E	90 08	ICOMP3	BCC	ICOMP4
0D50	D0 F7		BNE	ICOMP1
0D52	8A		TXA
0D53	E5 A1		SBC	IACC+1
0D55	D0 F7		BNE	ICOMP3
0D57	60		RTS
0D58	A9 01	ICOMP4	LDA	#$01
0D5A	60		RTS
0D5B	D0 4D	ICOMP5	BNE	ISTOR12
0D5D	F0 4D	ICOMP6	BEQ	ISTOR13

ISTOREF

ISTOREF: INTEGER OPERATION 7: STORE FAC IN THE INTEGER VARIABLE THROUGH APPLESOFT'S OWN LET, WHICH ROUNDS AND CHECKS THE RANGE.

0D5F	84 86	ISTOREF	STY	FORPNT+1	THE VARIABLE'S ADDRESS FOR LET
0D61	85 85		STA	FORPNT
0D63	4C 65 DA		JMP	LET2
0D66	A2 03	ISTOR1	LDX	#$03
0D68	D0 44		BNE	IREAL
0D6A	20 21 EB	ISTOR2	JSR	MOV1F	COMPARE: THE OLD FAC (IN ARG) WITH THE VARIABLE
0D6D	20 53 EB		JSR	MOVFA
0D70	A0 00		LDY	#$00
0D72	A9 93		LDA	#$93
0D74	4C B2 EB		JMP	FCOMP
0D77	A2 02	ISTOR3	LDX	#$02
0D79	D0 33		BNE	IREAL
0D7B	A5 9D	ISTOR4	LDA	FAC	FAC = ARG * FAC
0D7D	4C 82 E9		JMP	FMULTT
0D80	48	ISTOR5	PHA
0D81	20 D0 EE		JSR	NEGOP
0D84	68		PLA
0D85	A2 01	ISTOR6	LDX	#$01
0D87	D0 25		BNE	IREAL
0D89	A5 9D	ISTOR7	LDA	FAC	FAC = ARG + FAC
0D8B	4C C1 E7		JMP	FADDT
0D8E	A2 00	ISTOR8	LDX	#$00
0D90	86 64	ISTOR9	STX	RESULT+2
0D92	A2 04		LDX	#$04
0D94	D0 18		BNE	IREAL
0D96	A2 05	ISTOR10	LDX	#$05	LOAD ARG / DIVIDE: SWAP FAC AND ARG
0D98	B4 9D	ISTOR11	LDY	FAC,X
0D9A	B5 A5		LDA	ARG,X
0D9C	94 A5		STY	ARG,X
0D9E	95 9D		STA	FAC,X
0DA0	CA		DEX
0DA1	10 F5		BPL	ISTOR11
0DA3	A6 64		LDX	RESULT+2
0DA5	D0 89		BNE	DISPI1
0DA7	A5 9D		LDA	FAC
0DA9	60		RTS
0DAA	D0 3F	ISTOR12	BNE	XDRAW3
0DAC	A2 00	ISTOR13	LDX	#$00

IREAL

IREAL: THE REAL OPERATIONS ON AN INTEGER VARIABLE. X: 0 LOAD, 1 ADD, 2 MULTIPLY, 3 COMPARE, 4 LOAD ARG OR (WITH $64 SET) DIVIDE. FOR ALL BUT A LOAD THE CURRENT FAC IS MOVED TO ARG; THE VARIABLE IS LOADED INTO FAC AS A REAL AND THE OPERATION APPLIED.

0DAE	86 16	IREAL	STX	HDRFLAG	X: WHICH REAL OPERATION
0DB0	CA		DEX
0DB1	30 09		BMI	IREAL1
0DB3	48		PHA		THE CURRENT FAC TO ARG
0DB4	98		TYA
0DB5	48		PHA
0DB6	20 63 EB		JSR	MOVAF
0DB9	68		PLA
0DBA	A8		TAY
0DBB	68		PLA
0DBC	84 A1	IREAL1	STY	IACC+1	VPNT = THE VARIABLE'S ADDRESS
0DBE	85 A0		STA	IACC
0DC0	20 E9 DE		JSR	INTVAR	FAC = THE INTEGER AS A REAL
0DC3	A5 AA		LDA	ARGSIGN
0DC5	20 59 DE		JSR	SGNEXIT	SIGNS COMPARED; A = THE EXPONENT
0DC8	A6 16		LDX	HDRFLAG
0DCA	D0 02		BNE	IREAL2	A LOAD: DONE
0DCC	AA		TAX
0DCD	60		RTS
0DCE	CA	IREAL2	DEX
0DCF	F0 B8		BEQ	ISTOR7
0DD1	CA		DEX
0DD2	F0 A7		BEQ	ISTOR4
0DD4	CA		DEX
0DD5	F0 93		BEQ	ISTOR2
0DD7	D0 BD		BNE	ISTOR10

DRAWAT

HI-RES: DRAW AND XDRAW AT X,Y, HPLOT TO AND HPLOT. EACH HAS A REAL ENTRY (JSR AYINT) AND AN INTEGER ENTRY 3 BYTES LATER. X WAS SAVED IN $50/$51 BY SAVEHX AND THE SHAPE NUMBER IN $F0; Y IS THE ARGUMENT NOW. X MUST BE BELOW 280 AND Y BELOW 192 (ERROR $35, ILLEGAL QUANTITY).

0DD9	20 0C E1	DRAWAT	JSR	AYINT
0DDC	A9 01	DRAWATI	LDA	#$01
0DDE	D0 05		BNE	XDRAW2
0DE0	20 0C E1	XDRAWAT	JSR	AYINT
0DE3	A9 02	XDRAWATI	LDA	#$02
0DE5	85 65	XDRAW2	STA	RESULT+3
0DE7	A9 02		LDA	#$02
0DE9	D0 0E		BNE	HGRPOINT
0DEB	D0 45	XDRAW3	BNE	HGRPO5
0DED	20 0C E1	HPLOTTO	JSR	AYINT
0DF0	A9 00	HPLOTTOI	LDA	#$00
0DF2	F0 05		BEQ	HGRPOINT
0DF4	20 0C E1	HPLOT	JSR	AYINT
0DF7	A9 01	HPLOTI	LDA	#$01
0DF9	85 16	HGRPOINT	STA	HDRFLAG	$64: 0 HPLOT TO, 1 HPLOT, 2 DRAW/XDRAW AT
0DFB	20 FE E6		JSR	CONINT2	Y COORDINATE
0DFE	E0 C0		CPX	#$C0	BELOW 192
0E00	B0 2E		BCS	HGRPO4
0E02	A4 51		LDY	LINNUM+1	X (SAVED IN $50/$51) BELOW 280
0E04	A6 50		LDX	LINNUM
0E06	C0 01		CPY	#$01
0E08	90 06		BCC	HGRPO1
0E0A	D0 24		BNE	HGRPO4
0E0C	E0 18		CPX	#$18
0E0E	B0 20		BCS	HGRPO4
0E10	A5 16	HGRPO1	LDA	HDRFLAG
0E12	F0 12		BEQ	HGRPO3
0E14	A5 A1		LDA	IACC+1	HPLOT: POSITION AND PLOT
0E16	C6 16		DEC	HDRFLAG
0E18	F0 09		BEQ	HGRPO2
0E1A	20 11 F4		JSR	HPOSN	DRAW AT: POSITION, THEN DRAW SHAPE $F0
0E1D	A6 F0		LDX	FIRST
0E1F	A9 01		LDA	#$01
0E21	D0 22		BNE	SHAPE1
0E23	4C 57 F4	HGRPO2	JMP	HPLOT0
0E26	8A	HGRPO3	TXA		HPLOT TO: A LINE TO X,Y
0E27	48		PHA
0E28	98		TYA
0E29	AA		TAX
0E2A	68		PLA
0E2B	A4 A1		LDY	IACC+1
0E2D	4C 3A F5		JMP	HGLIN
0E30	A2 35	HGRPO4	LDX	#$35	ILLEGAL QUANTITY: ERROR $35
0E32	D0 7E	HGRPO5	BNE	ASCFN1

DRAW

DRAW AND XDRAW: THE SHAPE NUMBER IS CHECKED AGAINST THE COUNT AT THE START OF THE SHAPE TABLE, THE SHAPE'S ADDRESS LOOKED UP, AND THE ROM DRAWS IT WITH THE CURRENT ROTATION.

0E34	20 0C E1	DRAW	JSR	AYINT
0E37	A9 01	DRAWI	LDA	#$01
0E39	D0 05		BNE	SHAPEARG
0E3B	20 0C E1	XDRAW	JSR	AYINT
0E3E	A9 02	XDRAWI	LDA	#$02
0E40	85 65	SHAPEARG	STA	RESULT+3	1 DRAW, 2 XDRAW
0E42	20 FE E6		JSR	CONINT2
0E45	A5 E8	SHAPE1	LDA	SHAPETBL	THE SHAPE TABLE
0E47	85 1A		STA	HGRSHAPE
0E49	A5 E9		LDA	SHAPETBL+1
0E4B	85 1B		STA	HGRSHAPE+1
0E4D	8A		TXA		SHAPE NUMBER, NOT ABOVE THE COUNT IN THE TABLE'S FIRST BYTE
0E4E	A2 00		LDX	#$00
0E50	C1 1A		CMP	(HGRSHAPE,X)
0E52	F0 02		BEQ	SHAPE2
0E54	B0 DA		BCS	HGRPO4
0E56	0A	SHAPE2	ASL	A	THE SHAPE'S OFFSET, 2 BYTES PER NUMBER ...
0E57	90 03		BCC	SHAPE3
0E59	E6 1B		INC	HGRSHAPE+1
0E5B	18		CLC
0E5C	A8	SHAPE3	TAY
0E5D	B1 1A		LDA	(HGRSHAPE),Y	... GIVES ITS ADDRESS
0E5F	65 1A		ADC	HGRSHAPE
0E61	AA		TAX
0E62	C8		INY
0E63	B1 1A		LDA	(HGRSHAPE),Y
0E65	65 E9		ADC	SHAPETBL+1
0E67	85 1B		STA	HGRSHAPE+1
0E69	86 1A		STX	HGRSHAPE
0E6B	A5 F9		LDA	HGRROT	WITH THE CURRENT ROTATION
0E6D	C6 65		DEC	RESULT+3
0E6F	F0 03		BEQ	SHAPE4
0E71	4C 61 F6		JMP	XDRAW1
0E74	4C 05 F6	SHAPE4	JMP	DRAW1

COLOR

COLOR=. LIKE MOST STATEMENTS WITH ONE NUMBER, A REAL ENTRY (JSR AYINT) FALLS INTO THE INTEGER ENTRY, WHICH TAKES THE BYTE WITH CONINT AND GOES ON INTO THE ROM'S OWN CODE FOR THE STATEMENT.

0E77	20 0C E1	COLOR	JSR	AYINT
0E7A	20 FE E6	COLORI	JSR	CONINT2
0E7D	4C 52 F2		JMP	COLOR2

VALFN

VALFN: VAL OF THE STRING ACCUMULATOR. THE BYTE AFTER THE STRING IS REPLACED BY 0 WHILE THE ROM'S FIN READS THE NUMBER, THEN PUT BACK.

0E80	A0 00	VALFN	LDY	#$00	THE STRING'S LENGTH
0E82	B1 77		LDA	(STRACC),Y
0E84	A6 77		LDX	STRACC	TXTPTR = THE STRING
0E86	A4 78		LDY	STRACC+1
0E88	86 B8		STX	TXTPTR
0E8A	84 B9		STY	TXTPTR+1
0E8C	E8		INX
0E8D	D0 01		BNE	VALFN1
0E8F	C8		INY
0E90	86 83	VALFN1	STX	RETADR	RETADR = ITS TEXT
0E92	84 84		STY	RETADR+1
0E94	A8		TAY		THE BYTE AFTER THE TEXT ...
0E95	85 16		STA	HDRFLAG
0E97	B1 83		LDA	(RETADR),Y
0E99	48		PHA
0E9A	A9 00		LDA	#$00	... BECOMES 0 FOR NOW
0E9C	91 83		STA	(RETADR),Y
0E9E	20 B1 00		JSR	CHRGET	FIN READS THE NUMBER
0EA1	20 4A EC		JSR	FIN
0EA4	68		PLA		PUT THE BYTE BACK
0EA5	A4 16		LDY	HDRFLAG
0EA7	91 83		STA	(RETADR),Y
0EA9	60		RTS

ASCFN

ASCFN: ASC OF THE STRING ACCUMULATOR INTO IACC (ERROR $35 FOR AN EMPTY STRING). LENFN: ITS LENGTH INTO IACC.

0EAA	A0 00	ASCFN	LDY	#$00	THE LENGTH
0EAC	B1 77		LDA	(STRACC),Y
0EAE	D0 04		BNE	ASCFN2
0EB0	A2 35		LDX	#$35	EMPTY: ERROR $35
0EB2	D0 55	ASCFN1	BNE	PRSTR3
0EB4	C8	ASCFN2	INY		Y = 1: THE FIRST CHARACTER (THE BIT SKIPS LENFN'S LDY #0)
0EB5	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0EB6	A0 00	LENFN	LDY	#$00
0EB8	B1 77		LDA	(STRACC),Y	IACC = THE BYTE
0EBA	85 A1		STA	IACC+1
0EBC	A0 00		LDY	#$00
0EBE	84 A0		STY	IACC
0EC0	A8		TAY
0EC1	60		RTS

STRLITP

STRLITP AND STRLIT: A STRING LITERAL IN THE CODE: THE CALL IS FOLLOWED BY THE LITERAL'S ADDRESS. THE STRING ACCUMULATOR POINTS AT IT (IT IS NOT COPIED) AND THE CALL RETURNS PAST THE WORD; STRLITP ALSO PRINTS IT (AN INPUT PROMPT).

0EC2	A2 01	STRLITP	LDX	#$01	X = 1: ALSO PRINT
0EC4	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0EC5	A2 00	STRLIT	LDX	#$00	X = 0
0EC7	86 16		STX	HDRFLAG
0EC9	68		PLA		THE RETURN ADDRESS POINTS BEFORE THE INLINE WORD
0ECA	85 62		STA	RESULT
0ECC	AA		TAX
0ECD	68		PLA
0ECE	85 63		STA	RESULT+1
0ED0	A0 01		LDY	#$01	$77/$78 = THE LITERAL'S ADDRESS
0ED2	B1 62		LDA	(RESULT),Y
0ED4	85 77		STA	STRACC
0ED6	C8		INY
0ED7	B1 62		LDA	(RESULT),Y
0ED9	85 78		STA	STRACC+1
0EDB	A4 63		LDY	RESULT+1	RETURN PAST THE WORD
0EDD	E8		INX
0EDE	D0 01		BNE	STRLIT1
0EE0	C8		INY
0EE1	E8	STRLIT1	INX
0EE2	D0 01		BNE	STRLIT2
0EE4	C8		INY
0EE5	98	STRLIT2	TYA
0EE6	48		PHA
0EE7	8A		TXA
0EE8	48		PHA
0EE9	A5 16		LDA	HDRFLAG
0EEB	D0 01		BNE	PRSTR
0EED	60		RTS

PRSTR

PRSTR: PRINT THE STRING ACCUMULATOR.

0EEE	A0 00	PRSTR	LDY	#$00	THE LENGTH
0EF0	B1 77		LDA	(STRACC),Y
0EF2	85 0E		STA	ENDCHR
0EF4	C8		INY
0EF5	84 16		STY	HDRFLAG
0EF7	A5 0E		LDA	ENDCHR
0EF9	F0 0D		BEQ	PRSTR2
0EFB	A4 16	PRSTR1	LDY	HDRFLAG	EACH CHARACTER
0EFD	B1 77		LDA	(STRACC),Y
0EFF	20 5C DB		JSR	OUTDO
0F02	E6 16		INC	HDRFLAG
0F04	C6 0E		DEC	ENDCHR
0F06	D0 F3		BNE	PRSTR1
0F08	60	PRSTR2	RTS
0F09	D0 68	PRSTR3	BNE	GARBAG6

CLRCHAIN

CLRCHAIN (REM! CLEAR CHAIN) AND FREFN (FRE): BOTH COLLECT GARBAGE. CLEAR CHAIN LEAVES THE LOCAL STRINGS OUT, SO ONLY THE COMMON STRINGS SURVIVE, PACKED AT THE TOP OF STRING SPACE, FOR THE NEXT PROGRAM; IT THEN GOES ON INTO CLEAR, WHICH CLEARS THE LOCAL VARIABLES.

0F0B	A5 80	CLRCHAIN	LDA	LOCSEND+1	KEEP THE LOCAL STRING END'S HIGH BYTE ...
0F0D	48		PHA
0F0E	A9 00		LDA	#$00	... AND MAKE IT 0: NO LOCAL STRINGS ARE KEPT
0F10	85 80		STA	LOCSEND+1
0F12	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0F13	A9 01	FREFN	LDA	#$01	FRE: COLLECT, THEN RETURN THE FREE SPACE

GARBAG

GARBAG: THE GARBAGE COLLECTOR. EACH ROUND FINDS THE HIGHEST STRING STILL IN USE THAT IS BELOW THE STRINGS ALREADY MOVED, COPIES IT TO THE TOP OF STRING SPACE AND REWRITES EVERY POINTER TO IT. THE POINTERS ARE THE COMMON STRINGS, THE LOCAL STRINGS AND THE TWO STRING ACCUMULATORS. LITERALS IN THE PROGRAM LIE BELOW STRING SPACE AND ARE LEFT ALONE.

FRE RETURNS THE FREE SPACE, FROM THE BOTTOM OF STRINGS DOWN TO THE HIGHEST ADDRESS USED BY THE PROGRAM. ERROR $4D, OUT OF MEMORY, WHEN A STRING DOES NOT FIT.

0F15	48	GARBAG	PHA		THE MODE: 0 CLEAR CHAIN, 1 FRE, $FF A NEW STRING THAT DID NOT FIT
0F16	A5 6F		LDA	FRETOP	TEMP1 = THE OLD BOTTOM OF STRINGS
0F18	85 93		STA	TEMP1
0F1A	A5 70		LDA	FRETOP+1
0F1C	85 94		STA	TEMP1+1
0F1E	A5 73		LDA	MEMSIZ	THE MOVED STRINGS WILL GROW DOWN FROM HIMEM-2
0F20	38		SEC
0F21	E9 02		SBC	#$02
0F23	85 6F		STA	FRETOP
0F25	85 95		STA	TEMP1+2
0F27	A5 74		LDA	MEMSIZ+1
0F29	E9 00		SBC	#$00
0F2B	85 70		STA	FRETOP+1
0F2D	85 96		STA	TEMP1+3
0F2F	A2 00	GARBAG1	LDX	#$00	START A ROUND: THE HIGHEST STRING FOUND SO FAR = NONE
0F31	86 66		STX	RESULT+4
0F33	86 82		STX	VARNAM+1
0F35	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
0F36	A2 12	GARBAG2	LDX	#$12	THE POINTERS: FIRST THE COMMON STRINGS (X = 0), THEN THE LOCAL ONES (X = $12)
0F38	B5 6B		LDA	NUMCEND,X
0F3A	38		SEC
0F3B	E9 01		SBC	#$01
0F3D	85 55		STA	TPTR
0F3F	B5 6C		LDA	NUMCEND+1,X
0F41	E9 00		SBC	#$00
0F43	85 56		STA	TPTR+1
0F45	D0 2A		BNE	GARBAG5
0F47	A0 01	GARBAG3	LDY	#$01	ONE POINTER
0F49	B1 55		LDA	(TPTR),Y
0F4B	24 66		BIT	RESULT+4	REWRITING THE POINTERS TO THE STRING JUST MOVED?
0F4D	10 26		BPL	GARBAG7
0F4F	C5 82		CMP	VARNAM+1
0F51	D0 6B		BNE	GARBAG15
0F53	88		DEY
0F54	B1 55		LDA	(TPTR),Y
0F56	C5 81		CMP	VARNAM
0F58	D0 64		BNE	GARBAG15
0F5A	A0 00	GARBAG4	LDY	#$00	YES: POINT AT ITS NEW PLACE
0F5C	A5 62		LDA	RESULT
0F5E	91 55		STA	(TPTR),Y
0F60	C8		INY
0F61	A5 63		LDA	RESULT+1
0F63	91 55		STA	(TPTR),Y
0F65	A5 55		LDA	TPTR
0F67	C5 AD		CMP	SERPNT
0F69	D0 53		BNE	GARBAG15
0F6B	A5 56		LDA	TPTR+1
0F6D	C5 AE		CMP	SERPNT+1
0F6F	F0 BE		BEQ	GARBAG1
0F71	D0 4B	GARBAG5	BNE	GARBAG15
0F73	D0 73	GARBAG6	BNE	GARBAG20
0F75	C5 82	GARBAG7	CMP	VARNAM+1	SEARCHING: IS THIS STRING HIGHER THAN THE BEST SO FAR?
0F77	90 45		BCC	GARBAG15
0F79	D0 15		BNE	GARBAG9
0F7B	88		DEY
0F7C	B1 55		LDA	(TPTR),Y
0F7E	C5 81		CMP	VARNAM
0F80	90 3C		BCC	GARBAG15
0F82	D0 0C		BNE	GARBAG9
0F84	A5 55		LDA	TPTR
0F86	85 AD		STA	SERPNT
0F88	A5 56		LDA	TPTR+1
0F8A	85 AE		STA	SERPNT+1
0F8C	B0 30		BCS	GARBAG15
0F8E	D0 85	GARBAG8	BNE	GARBAG
0F90	A0 00	GARBAG9	LDY	#$00	AND BELOW THE STRINGS ALREADY MOVED?
0F92	B1 55		LDA	(TPTR),Y
0F94	C5 95		CMP	TEMP1+2
0F96	C8		INY
0F97	B1 55		LDA	(TPTR),Y
0F99	E5 96		SBC	TEMP1+3
0F9B	B0 21		BCS	GARBAG15
0F9D	90 08		BCC	GARBAG14
0F9F	30 B9	GARBAG10	BMI	GARBAG4
0FA1	90 A4	GARBAG11	BCC	GARBAG3
0FA3	F0 91	GARBAG12	BEQ	GARBAG2
0FA5	F0 88	GARBAG13	BEQ	GARBAG1
0FA7	B1 55	GARBAG14	LDA	(TPTR),Y	THE NEW BEST
0FA9	85 82		STA	VARNAM+1
0FAB	88		DEY
0FAC	B1 55		LDA	(TPTR),Y
0FAE	85 81		STA	VARNAM
0FB0	86 64		STX	RESULT+2
0FB2	A5 55		LDA	TPTR
0FB4	85 8A		STA	TEMP3
0FB6	85 AD		STA	SERPNT
0FB8	A5 56		LDA	TPTR+1
0FBA	85 8B		STA	TEMP3+1
0FBC	85 AE		STA	SERPNT+1
0FBE	8A	GARBAG15	TXA		NEXT POINTER
0FBF	30 2B		BMI	GARBAG22
0FC1	A5 55		LDA	TPTR
0FC3	18		CLC
0FC4	69 02		ADC	#$02
0FC6	85 55		STA	TPTR
0FC8	90 02		BCC	GARBAG16
0FCA	E6 56		INC	TPTR+1
0FCC	D5 6D	GARBAG16	CMP	STRCEND,X
0FCE	A5 56		LDA	TPTR+1
0FD0	F5 6E		SBC	STRCEND+1,X
0FD2	90 CD	GARBAG17	BCC	GARBAG11
0FD4	8A		TXA
0FD5	F0 CC		BEQ	GARBAG12
0FD7	A2 80		LDX	#$80	THEN THE TWO STRING ACCUMULATORS ($77, $79)
0FD9	A9 77		LDA	#$77
0FDB	85 55		STA	TPTR
0FDD	A9 00		LDA	#$00
0FDF	85 56		STA	TPTR+1
0FE1	18		CLC
0FE2	90 BD		BCC	GARBAG11
0FE4	30 B9	GARBAG18	BMI	GARBAG10
0FE6	D0 A6	GARBAG19	BNE	GARBAG8
0FE8	D0 79	GARBAG20	BNE	GARBAG31
0FEA	F0 B9	GARBAG21	BEQ	GARBAG13
0FEC	A9 79	GARBAG22	LDA	#$79
0FEE	C5 55		CMP	TPTR
0FF0	85 55		STA	TPTR
0FF2	18		CLC
0FF3	D0 DD		BNE	GARBAG17
0FF5	A4 81		LDY	VARNAM	THE ROUND IS OVER
0FF7	84 95		STY	TEMP1+2
0FF9	A5 82		LDA	VARNAM+1
0FFB	F0 68		BEQ	GARBAG32	NONE FOUND: DONE
0FFD	85 96		STA	TEMP1+3
0FFF	A6 80		LDX	LOCSEND+1	CLEAR CHAIN: A STRING BELOW THE OLD BOTTOM IS NOT A COMMON STRING TO KEEP
1001	F0 06		BEQ	GARBAG23
1003	C4 93		CPY	TEMP1
1005	E5 94		SBC	TEMP1+1
1007	90 5C		BCC	GARBAG32
1009	A0 00	GARBAG23	LDY	#$00	AN EMPTY STRING: POINT AT THE EMPTY STRING AT HIMEM-1
100B	B1 81		LDA	(VARNAM),Y
100D	D0 0F		BNE	GARBAG25
100F	A4 74		LDY	MEMSIZ+1
1011	A6 73		LDX	MEMSIZ
1013	D0 01		BNE	GARBAG24
1015	88		DEY
1016	CA	GARBAG24	DEX
1017	86 62		STX	RESULT
1019	84 63		STY	RESULT+1
101B	38		SEC
101C	B0 33		BCS	GARBAG29
101E	18	GARBAG25	CLC		MOVE IT: ROOM BELOW THE BOTTOM OF STRINGS?
101F	A5 6F		LDA	FRETOP
1021	F1 81		SBC	(VARNAM),Y
1023	AA		TAX
1024	A5 70		LDA	FRETOP+1
1026	E9 00		SBC	#$00
1028	A8		TAY
1029	E4 14		CPX	HIGHEST	NOT ABOVE THE PROGRAM: OUT OF MEMORY
102B	E5 15		SBC	HIGHEST+1
102D	90 54		BCC	GARBAG34
102F	86 6F		STX	FRETOP
1031	84 70		STY	FRETOP+1
1033	E8		INX
1034	D0 01		BNE	GARBAG26
1036	C8		INY
1037	86 62	GARBAG26	STX	RESULT
1039	84 63		STY	RESULT+1
103B	E4 81		CPX	VARNAM	ALREADY THERE: NOTHING TO COPY
103D	D0 04		BNE	GARBAG27
103F	C4 82		CPY	VARNAM+1
1041	F0 A7		BEQ	GARBAG21
1043	A0 00	GARBAG27	LDY	#$00	COPY THE LENGTH AND THE TEXT
1045	B1 81		LDA	(VARNAM),Y
1047	A8		TAY
1048	B1 81	GARBAG28	LDA	(VARNAM),Y
104A	91 62		STA	(RESULT),Y
104C	88		DEY
104D	C0 FF		CPY	#$FF
104F	D0 F7		BNE	GARBAG28
1051	A5 8A	GARBAG29	LDA	TEMP3	NOW REWRITE EVERY POINTER TO IT
1053	85 55		STA	TPTR
1055	A5 8B		LDA	TEMP3+1
1057	85 56		STA	TPTR+1
1059	A6 64		LDX	RESULT+2
105B	A9 80		LDA	#$80
105D	85 66		STA	RESULT+4
105F	30 83		BMI	GARBAG18
1061	D0 83	GARBAG30	BNE	GARBAG19
1063	D0 65	GARBAG31	BNE	OLDTE2
1065	38	GARBAG32	SEC		FREE SPACE = BOTTOM OF STRINGS - HIGHEST ADDRESS
1066	A5 6F		LDA	FRETOP
1068	E5 14		SBC	HIGHEST
106A	A8		TAY
106B	A5 70		LDA	FRETOP+1
106D	E5 15		SBC	HIGHEST+1
106F	AA		TAX
1070	68		PLA		MODE 1, FRE: RETURN IT IN FAC
1071	F0 15		BEQ	GARBAG35
1073	30 04		BMI	GARBAG33
1075	8A		TXA
1076	4C F2 E2		JMP	GIVAYF
1079	38	GARBAG33	SEC		A NEW STRING: DOES IT FIT NOW?
107A	8A		TXA
107B	D0 1C		BNE	GARBAG36
107D	C4 0D		CPY	CHARAC
107F	F0 02		BEQ	GARBAG34
1081	B0 16		BCS	GARBAG36
1083	A2 4D	GARBAG34	LDX	#$4D	OUT OF MEMORY: ERROR $4D
1085	4C 12 D4		JMP	ERROR
1088	68	GARBAG35	PLA		CLEAR CHAIN: PUT THE LOCAL STRING END BACK ...
1089	85 80		STA	LOCSEND+1
108B	A5 AF		LDA	FORPOP	... AND RETURN INTO CLEAR: FORPOP-$107 = $08A9, ONE BEFORE CLEAR, SO THE LOCAL VARIABLES ARE CLEARED AND THE STACK RESET
108D	38		SEC
108E	E9 07		SBC	#$07
1090	AA		TAX
1091	A5 B0		LDA	FORPOP+1
1093	E9 01		SBC	#$01
1095	48		PHA
1096	8A		TXA
1097	48		PHA
1098	60		RTS
1099	B0 42	GARBAG36	BCS	GETSTR2

OLDTEXT

OLDTEXT: 45 BYTES OF TEXT LEFT IN MEMORY BY THE ASSEMBLER: NEVER EXECUTED. THE BRANCH BEFORE THEM IS ALWAYS TAKEN.

109B	4C 45 3F 20 22 3B 3A B0	OLDTEXT	DFB	$4C,$45,$3F,$20,$22,$3B,$3A,$B0	"LE? ";:0"
10A3	31 31 32 30 3A 52 46 D0		DFB	$31,$31,$32,$30,$3A,$52,$46,$D0	"1120:RFP"
10AB	32 3A AB 31 33 36 30 3A		DFB	$32,$3A,$AB,$31,$33,$36,$30,$3A	"2:+1360:"
10B3	B2 20 20 20 20 49 46 20		DFB	$B2,$20,$20,$20,$20,$49,$46,$20	"2 IF "
10BB	41 20 44 49 53 4B 20 43		DFB	$41,$20,$44,$49,$53,$4B,$20,$43	"A DISK C"
10C3	4F 4D 4D 41 4E		DFB	$4F,$4D,$4D,$41,$4E	"OMMAN"
10C8	D0 97	OLDTE1	BNE	GARBAG30
10CA	D0 7B	OLDTE2	BNE	PUSHS2

GETSTR

GETSTR: GET A$: A NEW ONE-CHARACTER STRING FROM THE KEYBOARD.

10CC	A2 01	GETSTR	LDX	#$01	A ONE-BYTE STRING, KIND 5
10CE	A9 05		LDA	#$05
10D0	D0 79		BNE	NEWSTR
10D2	20 53 D5	GETSTR1	JSR	INCHR	THE KEY
10D5	A0 01		LDY	#$01
10D7	91 55		STA	(TPTR),Y
10D9	A9 00		LDA	#$00
10DB	F0 45		BEQ	CONCAT4
10DD	B0 6F	GETSTR2	BCS	NEWSTR1

CONCATT

CONCAT: THE PUSHED STRING FOLLOWED BY THE LOADED STRING, AS A NEW STRING (ERROR $B0, STRING TOO LONG, PAST 255). CONCATT SWAPS THE TWO FIRST.

10DF	A5 77	CONCATT	LDA	STRACC	SWAP THE TWO STRINGS
10E1	A6 79		LDX	STRPSH
10E3	85 79		STA	STRPSH
10E5	86 77		STX	STRACC
10E7	A5 78		LDA	STRACC+1
10E9	A6 7A		LDX	STRPSH+1
10EB	85 7A		STA	STRPSH+1
10ED	86 78		STX	STRACC+1
10EF	A0 00	CONCAT	LDY	#$00	THE LOADED STRING EMPTY: THE RESULT IS THE PUSHED ONE
10F1	B1 77		LDA	(STRACC),Y
10F3	F0 49		BEQ	PUSHS1
10F5	85 0E		STA	ENDCHR
10F7	B1 79		LDA	(STRPSH),Y	THE PUSHED STRING EMPTY: THE RESULT IS THE LOADED ONE
10F9	F0 3A		BEQ	PUSHSTR
10FB	18		CLC		THE TOTAL LENGTH
10FC	65 0E		ADC	ENDCHR
10FE	90 04		BCC	CONCAT1
1100	A2 B0		LDX	#$B0	PAST 255: STRING TOO LONG, ERROR $B0
1102	D0 43		BNE	PUSHS2
1104	AA	CONCAT1	TAX		A NEW STRING, KIND 0
1105	98		TYA
1106	C8		INY
1107	D0 42		BNE	NEWSTR
1109	EA		NOP
110A	EA		NOP
110B	A4 0E	CONCAT2	LDY	ENDCHR	COPY THE LOADED STRING TO THE END ...
110D	B1 77		LDA	(STRACC),Y
110F	A4 0D		LDY	CHARAC
1111	91 55		STA	(TPTR),Y
1113	C6 0D		DEC	CHARAC
1115	C6 0E		DEC	ENDCHR
1117	D0 F2		BNE	CONCAT2
1119	A4 0D		LDY	CHARAC
111B	B1 79	CONCAT3	LDA	(STRPSH),Y	... AND THE PUSHED STRING BEFORE IT
111D	91 55		STA	(TPTR),Y
111F	88		DEY
1120	D0 F9		BNE	CONCAT3
1122	A5 55	CONCAT4	LDA	TPTR	BOTH STRING ACCUMULATORS = THE NEW STRING
1124	85 77		STA	STRACC
1126	85 79		STA	STRPSH
1128	A5 56		LDA	TPTR+1
112A	85 78		STA	STRACC+1
112C	85 7A		STA	STRPSH+1
112E	60		RTS
112F	D0 97	CONCAT5	BNE	OLDTE1
1131	D0 9F	CONCAT6	BNE	GETSTR1
1133	EA		NOP
1134	EA		NOP

PUSHSTR

PUSHSTR: COPY THE LOADED STRING TO THE PUSHED STRING.

1135	A5 77	PUSHSTR	LDA	STRACC
1137	85 79		STA	STRPSH
1139	A5 78		LDA	STRACC+1
113B	85 7A		STA	STRPSH+1
113D	60		RTS
113E	A5 79	PUSHS1	LDA	STRPSH
1140	85 77		STA	STRACC
1142	A5 7A		LDA	STRPSH+1
1144	85 78		STA	STRACC+1
1146	60		RTS
1147	D0 47	PUSHS2	BNE	NEWSTR4
1149	F0 D7	PUSHS3	BEQ	CONCAT4

NEWSTR

NEWSTR: MAKE ROOM FOR A NEW STRING OF ($0D) BYTES BELOW THE BOTTOM OF STRING SPACE, COLLECTING GARBAGE IF IT DOES NOT FIT, AND FILL IT FOR THE CALLER: A SAYS WHICH (0 CONCAT, 1 CHR$, 2 STR$, 3 LEFT$/MID$, 4 RIGHT$, 5 GET).

114B	48	NEWSTR	PHA		KEEP THE KIND; $0D = THE LENGTH
114C	86 0D		STX	CHARAC
114E	A5 6F	NEWSTR1	LDA	FRETOP	ITS PLACE: BELOW THE BOTTOM OF STRINGS
1150	38		SEC
1151	E5 0D		SBC	CHARAC
1153	85 55		STA	TPTR
1155	A5 70		LDA	FRETOP+1
1157	E9 00		SBC	#$00
1159	85 56		STA	TPTR+1
115B	A5 14		LDA	HIGHEST	ABOVE THE PROGRAM?
115D	C5 55		CMP	TPTR
115F	A5 15		LDA	HIGHEST+1
1161	E5 56		SBC	TPTR+1
1163	90 04		BCC	NEWSTR2
1165	A9 FF		LDA	#$FF	NO: COLLECT GARBAGE AND TRY AGAIN
1167	D0 C6		BNE	CONCAT5
1169	A0 00	NEWSTR2	LDY	#$00	THE LENGTH BYTE
116B	A5 0D		LDA	CHARAC
116D	91 55		STA	(TPTR),Y
116F	A4 56		LDY	TPTR+1	THE NEW BOTTOM OF STRINGS
1171	A6 55		LDX	TPTR
1173	D0 01		BNE	NEWSTR3
1175	88		DEY
1176	CA	NEWSTR3	DEX
1177	86 6F		STX	FRETOP
1179	84 70		STY	FRETOP+1
117B	68		PLA		FILL IT BY KIND
117C	A8		TAY
117D	F0 8C		BEQ	CONCAT2
117F	88		DEY
1180	F0 1B		BEQ	CHRFNI1
1182	88		DEY
1183	F0 33		BEQ	STRFN3
1185	88		DEY
1186	F0 5D		BEQ	LEFTI4
1188	88		DEY
1189	F0 65		BEQ	LEFTI6
118B	D0 A4		BNE	CONCAT6
118D	EA		NOP
118E	EA		NOP
118F	EA		NOP
1190	D0 6B	NEWSTR4	BNE	RIGHTI1

CHRFN

CHR$: A ONE-CHARACTER STRING.

1192	20 0C E1	CHRFN	JSR	AYINT
1195	20 FE E6	CHRFNI	JSR	CONINT2	THE CHARACTER, A ONE-BYTE STRING, KIND 1
1198	A2 01		LDX	#$01
119A	8A		TXA
119B	D0 AE		BNE	NEWSTR
119D	A6 A1	CHRFNI1	LDX	IACC+1
119F	A0 01		LDY	#$01
11A1	8A		TXA
11A2	91 55		STA	(TPTR),Y
11A4	88		DEY
11A5	F0 A2	CHRFNI2	BEQ	PUSHS3
11A7	F0 8C	CHRFNI3	BEQ	PUSHSTR

STRFN

STR$: FOUT CONVERTS FAC TO TEXT AT $0100; THE TEXT BECOMES A NEW STRING.

11A9	20 34 ED	STRFN	JSR	FOUT	THE NUMBER AS TEXT AT $0100
11AC	A2 00		LDX	#$00	ITS LENGTH
11AE	E8	STRFN1	INX
11AF	BD 00 01		LDA	STACK,X
11B2	D0 FA		BNE	STRFN1
11B4	A9 02		LDA	#$02	KIND 2
11B6	D0 93	STRFN2	BNE	NEWSTR
11B8	A4 0D	STRFN3	LDY	CHARAC	COPY THE TEXT
11BA	B9 FF 00	STRFN4	LDA	ZPFF,Y
11BD	91 55		STA	(TPTR),Y
11BF	88		DEY
11C0	D0 F8		BNE	STRFN4
11C2	F0 E1		BEQ	CHRFNI2

LEFT

LEFT$, RIGHT$ AND MID$. THE STRING IS IN THE STRING ACCUMULATOR; THE COUNT (AND FOR MID$ THE START, PUSHED BY PUSHBYTE) ARE BYTES. A ZERO COUNT IS ERROR $35. WHEN THE RESULT IS THE WHOLE STRING NO NEW STRING IS MADE; AN EMPTY RESULT POINTS AT THE EMPTY STRING.

11C4	20 0C E1	LEFT	JSR	AYINT
11C7	20 FE E6	LEFTI	JSR	CONINT2	THE COUNT
11CA	8A		TXA
11CB	D0 04		BNE	LEFTI1
11CD	A2 35		LDX	#$35	0: ERROR $35
11CF	D0 2C		BNE	RIGHTI1
11D1	A0 00	LEFTI1	LDY	#$00	THE STRING'S LENGTH
11D3	B1 77		LDA	(STRACC),Y
11D5	F0 D0		BEQ	CHRFNI3
11D7	85 0E		STA	ENDCHR
11D9	E4 0E	LEFTI2	CPX	ENDCHR	THE COUNT COVERS THE WHOLE STRING: KEEP IT
11DB	90 04		BCC	LEFTI3
11DD	A9 00		LDA	#$00
11DF	F0 C6		BEQ	CHRFNI3
11E1	A9 03	LEFTI3	LDA	#$03	OTHERWISE A NEW STRING OF THAT LENGTH, KIND 3
11E3	D0 D1		BNE	STRFN2
11E5	A4 0D	LEFTI4	LDY	CHARAC	COPY THE FIRST CHARACTERS
11E7	B1 77	LEFTI5	LDA	(STRACC),Y
11E9	91 55		STA	(TPTR),Y
11EB	88		DEY
11EC	D0 F9		BNE	LEFTI5
11EE	F0 B5		BEQ	CHRFNI2
11F0	F0 21	LEFTI6	BEQ	RIGHTI5
11F2	20 0C E1	RIGHT	JSR	AYINT
11F5	20 FE E6	RIGHTI	JSR	CONINT2
11F8	8A		TXA
11F9	D0 04		BNE	RIGHTI2
11FB	A2 35		LDX	#$35
11FD	D0 42	RIGHTI1	BNE	MID3I2
11FF	A0 00	RIGHTI2	LDY	#$00
1201	B1 77		LDA	(STRACC),Y
1203	F0 A2	RIGHTI3	BEQ	CHRFNI3
1205	85 0E		STA	ENDCHR
1207	E4 0E		CPX	ENDCHR
1209	90 04		BCC	RIGHTI4
120B	A9 00		LDA	#$00
120D	F0 F4		BEQ	RIGHTI3
120F	A9 04	RIGHTI4	LDA	#$04	A NEW STRING, KIND 4
1211	D0 A3		BNE	STRFN2
1213	38	RIGHTI5	SEC		RIGHT$: START AT LENGTH-COUNT
1214	A5 0E		LDA	ENDCHR
1216	E5 0D		SBC	CHARAC
1218	18		CLC
1219	65 77		ADC	STRACC
121B	85 77		STA	STRACC
121D	90 02		BCC	RIGHTI6
121F	E6 78		INC	STRACC+1
1221	D0 C2	RIGHTI6	BNE	LEFTI4
1223	F0 B4	RIGHTI7	BEQ	LEFTI2
1225	B0 BA	RIGHTI8	BCS	LEFTI3
1227	20 0C E1	MID2	JSR	AYINT
122A	20 FE E6	MID2I	JSR	CONINT2
122D	A9 FF		LDA	#$FF	MID$ WITHOUT A COUNT: 255
122F	D0 09		BNE	MID3I1
1231	20 0C E1	MID3	JSR	AYINT
1234	20 FE E6	MID3I	JSR	CONINT2
1237	8A		TXA		MID$ WITH A COUNT: THE START WAS PUSHED IN $10
1238	A6 10		LDX	DIMFLG
123A	85 16	MID3I1	STA	HDRFLAG
123C	8A		TXA
123D	D0 04		BNE	MID3I3
123F	A2 35		LDX	#$35
1241	D0 3F	MID3I2	BNE	MID3I11
1243	A0 00	MID3I3	LDY	#$00
1245	B1 77		LDA	(STRACC),Y
1247	F0 BA		BEQ	RIGHTI3
1249	85 0E		STA	ENDCHR
124B	8A		TXA
124C	A6 16		LDX	HDRFLAG
124E	D0 10		BNE	MID3I6
1250	A4 74	MID3I4	LDY	MEMSIZ+1	THE START IS PAST THE END: THE EMPTY STRING
1252	A6 73		LDX	MEMSIZ
1254	D0 01		BNE	MID3I5
1256	88		DEY
1257	CA	MID3I5	DEX
1258	86 77		STX	STRACC
125A	84 78		STY	STRACC+1
125C	A9 00		LDA	#$00
125E	F0 A3		BEQ	RIGHTI3
1260	38	MID3I6	SEC		START-1
1261	E9 01		SBC	#$01
1263	F0 BE		BEQ	RIGHTI7
1265	85 64		STA	RESULT+2
1267	C5 0E		CMP	ENDCHR
1269	B0 E5		BCS	MID3I4
126B	65 16		ADC	HDRFLAG	START+COUNT PAST THE END?
126D	B0 04		BCS	MID3I7
126F	C5 0E		CMP	ENDCHR
1271	90 07		BCC	MID3I8
1273	A5 0E	MID3I7	LDA	ENDCHR	THEN TO THE END
1275	E5 64		SBC	RESULT+2
1277	AA		TAX
1278	D0 95		BNE	RIGHTI4
127A	85 0E	MID3I8	STA	ENDCHR
127C	D0 91		BNE	RIGHTI4
127E	B0 A5	MID3I9	BCS	RIGHTI8
1280	F0 CE	MID3I10	BEQ	MID3I4
1282	D0 74	MID3I11	BNE	INPST9

INPSTRQ

INPUT. INPSTR AND INPNUM READ THE FIRST ITEM (PRINTING "?"), THE P ENTRIES THE FIRST ITEM AFTER A PROMPT, THE N ENTRIES THE NEXT ITEMS. A NEW LINE IS READ WITH INLIN INTO $0200 WHEN NEEDED; $71 IS THE POSITION IN IT ($FF A NEW LINE, $FE USED UP).

STRINGS MAY BE QUOTED; ITEMS ARE SEPARATED BY COMMAS. A NUMBER IS CONVERTED BY FIN; A BAD ONE PRINTS ?REENTER AND THE WHOLE STATEMENT STARTS AGAIN AT THE ADDRESS INPBEG SAVED. CONTROL-C AS THE LINE'S FIRST CHARACTER STOPS THE PROGRAM.

1284	20 5A DB	INPSTRQ	JSR	OUTQUES	ENTRY AFTER ?REENTER FOR A STRING
1287	20 5A DB	INPSTR	JSR	OUTQUES	PRINT ?
128A	20 2C D5	INPSTRP	JSR	INLIN	READ A LINE
128D	AD 00 02		LDA	INBUF	CONTROL-C FIRST: STOP
1290	C9 03		CMP	#$03
1292	F0 76		BEQ	INPNU1
1294	A9 FF		LDA	#$FF	A NEW LINE: POSITION $FF
1296	85 71		STA	INPOS
1298	A5 71	INPSTRN	LDA	INPOS	THE LINE IS USED UP: ASK FOR MORE
129A	C9 FE		CMP	#$FE
129C	F0 E6		BEQ	INPSTRQ
129E	AA		TAX
129F	E8	INPST1	INX		SKIP SPACES
12A0	BD 00 02		LDA	INBUF,X
12A3	C9 20		CMP	#$20
12A5	F0 F8		BEQ	INPST1
12A7	C9 22		CMP	#$22	A QUOTED STRING ENDS AT THE QUOTE ...
12A9	F0 06		BEQ	INPST2
12AB	A0 2C		LDY	#$2C	... ANOTHER AT A COMMA
12AD	84 16		STY	HDRFLAG
12AF	D0 06		BNE	INPST3
12B1	85 16	INPST2	STA	HDRFLAG
12B3	E8		INX
12B4	BD 00 02		LDA	INBUF,X
12B7	86 0E	INPST3	STX	ENDCHR
12B9	A4 0E		LDY	ENDCHR
12BB	A2 00		LDX	#$00
12BD	C9 00	INPST4	CMP	#$00	FIND THE END OF THE ITEM
12BF	F0 20		BEQ	INPST7
12C1	C5 16		CMP	HDRFLAG
12C3	F0 07		BEQ	INPST5
12C5	C8		INY
12C6	B9 00 02		LDA	INBUF,Y
12C9	E8		INX
12CA	D0 F1		BNE	INPST4
12CC	C9 2C	INPST5	CMP	#$2C	AFTER A QUOTE: SKIP SPACES TO THE COMMA OR THE END
12CE	F0 13		BEQ	INPST8
12D0	C8	INPST6	INY
12D1	B9 00 02		LDA	INBUF,Y
12D4	C9 20		CMP	#$20
12D6	F0 F8		BEQ	INPST6
12D8	C9 00		CMP	#$00
12DA	F0 05		BEQ	INPST7
12DC	C9 2C		CMP	#$2C
12DE	D0 57		BNE	INPNU4	ANYTHING ELSE: ?REENTER
12E0	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
12E1	A0 FE	INPST7	LDY	#$FE	THE LINE IS USED UP
12E3	84 71	INPST8	STY	INPOS	THE NEXT POSITION
12E5	8A		TXA
12E6	F0 98		BEQ	MID3I10
12E8	18		CLC		THE ITEM IS IN THE INPUT BUFFER: $77/$78 POINTS AT THE BYTE BEFORE IT, THE LENGTH
12E9	A9 FF		LDA	#$FF
12EB	65 0E		ADC	ENDCHR
12ED	85 77		STA	STRACC
12EF	A9 01		LDA	#$01
12F1	69 00		ADC	#$00
12F3	85 78		STA	STRACC+1
12F5	38		SEC
12F6	B0 86		BCS	MID3I9
12F8	D0 12	INPST9	BNE	INPNU2
12FA	20 5A DB	INPNUMQ	JSR	OUTQUES	ENTRY AFTER ?REENTER FOR A NUMBER
12FD	20 5A DB	INPNUM	JSR	OUTQUES
1300	20 2C D5	INPNUMP	JSR	INLIN
1303	AD 00 02		LDA	INBUF
1306	C9 03		CMP	#$03
1308	D0 04		BNE	INPNU3
130A	A2 FF	INPNU1	LDX	#$FF	CONTROL-C: X = $FF, A BREAK
130C	D0 77	INPNU2	BNE	PGMEND3
130E	A9 FF	INPNU3	LDA	#$FF
1310	85 71		STA	INPOS
1312	A6 71	INPNUMN	LDX	INPOS	THE LINE IS USED UP: ASK FOR MORE
1314	E0 FE		CPX	#$FE
1316	F0 E2		BEQ	INPNUMQ
1318	E8		INX		TXTPTR = THE ITEM IN THE BUFFER AT $0200
1319	86 B8		STX	TXTPTR
131B	86 16		STX	HDRFLAG
131D	A9 02		LDA	#$02
131F	85 B9		STA	TXTPTR+1
1321	20 B7 00		JSR	CHRGOT
1324	20 4A EC		JSR	FIN	FIN CONVERTS IT
1327	A6 B8		LDX	TXTPTR	NOTHING READ: ?REENTER
1329	E4 16		CPX	HDRFLAG
132B	F0 0A		BEQ	INPNU4
132D	20 B7 00		JSR	CHRGOT
1330	A8		TAY
1331	F0 10		BEQ	INPNU5	THE END OF THE LINE ...
1333	C9 2C		CMP	#$2C	... OR A COMMA
1335	F0 0F		BEQ	INPNU6
1337	20 87 DB	INPNU4	JSR	REENTER	?REENTER, OR THE ONERR ERROR $FE
133A	EA		NOP		FOUR BYTES THAT DO NOTHING
133B	EA		NOP
133C	EA		NOP
133D	EA		NOP
133E	68		PLA		DROP THE RETURN ADDRESS AND START THE INPUT STATEMENT AGAIN AT THE ADDRESS INPBEG SAVED
133F	68		PLA
1340	6C 50 00		JMP	(LINNUM)
1343	A9 FE	INPNU5	LDA	#$FE	THE LINE IS USED UP
1345	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
1346	A5 B8	INPNU6	LDA	TXTPTR
1348	85 71		STA	INPOS
134A	60		RTS

STOP

STOP: PRINT BREAK IN AND THE OBJECT ADDRESS OF THE STOP, THEN END.

134B	68	STOP	PLA		THE STATEMENT'S OBJECT ADDRESS = RETURN ADDRESS - 2
134C	38		SEC
134D	E9 02		SBC	#$02
134F	85 75		STA	CURLIN
1351	68		PLA
1352	E9 00		SBC	#$00
1354	85 76		STA	CURLIN+1
1356	A9 5D		LDA	#$5D	"BREAK" FROM THE ROM ($D35D)
1358	A0 D3		LDY	#$D3
135A	20 3A DB		JSR	STROUT
135D	20 19 ED		JSR	INPRT	" IN " AND THE ADDRESS
1360	20 FB DA		JSR	CRDO

PGMEND

PGMEND (END, AND NEW): PUT CHRGET BACK FROM THE ROM, MAKE THE PROGRAM SPACE AN EMPTY PROGRAM AND GO BACK TO THE INTERPRETER.

1363	A2 17	PGMEND	LDX	#$17	PUT THE ROM'S CHRGET BACK AT $B1-$C8
1365	BD 0B F1	PGMEND1	LDA	CHRGIMG,X
1368	95 B1		STA	CHRGET,X
136A	CA		DEX
136B	10 F8		BPL	PGMEND1
136D	A4 68		LDY	TXTTAB+1	AN EMPTY PROGRAM: A ZERO BEFORE TXTTAB ...
136F	A6 67		LDX	TXTTAB
1371	D0 01		BNE	PGMEND2
1373	88		DEY
1374	CA	PGMEND2	DEX
1375	86 62		STX	RESULT
1377	84 63		STY	RESULT+1
1379	A0 00		LDY	#$00
137B	98		TYA
137C	91 62		STA	(RESULT),Y
137E	18		CLC
137F	20 4B D6		JSR	SCRTCH	... NEW, THEN BACK TO THE INTERPRETER
1382	4C 66 D5		JMP	RUNCLR
1385	D0 2F	PGMEND3	BNE	READN2

INPEND

INPEND: THE END OF AN INPUT STATEMENT: ?EXTRA IGNORED IF THE LINE HAS MORE.

1387	A5 71	INPEND	LDA	INPOS	THE LINE USED UP?
1389	C9 FE		CMP	#$FE
138B	F0 0B		BEQ	INPEND1
138D	A9 DF		LDA	#$DF	NO: ?EXTRA IGNORED ($DCDF)
138F	A0 DC		LDY	#$DC
1391	20 3A DB		JSR	STROUT
1394	A9 FE		LDA	#$FE
1396	85 71		STA	INPOS
1398	60	INPEND1	RTS

GETNUM

GETNUM: GET X: A DIGIT KEY GIVES ITS VALUE, ANY OTHER KEY 0.

1399	20 53 D5	GETNUM	JSR	INCHR	THE KEY
139C	E9 30		SBC	#$30	A DIGIT GIVES ITS VALUE ...
139E	90 04		BCC	GETNUM1
13A0	C9 0A		CMP	#$0A
13A2	90 02		BCC	GETNUM2
13A4	A9 00	GETNUM1	LDA	#$00	... ANYTHING ELSE 0
13A6	4C 93 EB	GETNUM2	JMP	FLOAT

READSTR

READ. THE DATA POINTER WALKS THE DATA ITEMS IN THE CODE: EACH IS A LENGTH BYTE AND ITS TEXT; $FF IS FOLLOWED BY THE ADDRESS OF THE NEXT DATA BLOCK (0 AFTER THE LAST: ERROR $2A, OUT OF DATA). A STRING ITEM IS USED IN PLACE; A NUMBER IS CONVERTED BY FIN (ERROR $10, SYNTAX, IF ANYTHING IS LEFT).

13A9	A9 01	READSTR	LDA	#$01	A STRING ITEM ...
13AB	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
13AC	A9 00	READNUM	LDA	#$00	... OR A NUMBER
13AE	48		PHA
13AF	A5 F7	READN1	LDA	DATPTR+1	NO DATA LEFT: OUT OF DATA, ERROR $2A
13B1	D0 05		BNE	READN3
13B3	68		PLA
13B4	A2 2A		LDX	#$2A
13B6	D0 4D	READN2	BNE	READN7
13B8	A0 00	READN3	LDY	#$00	THE ITEM'S LENGTH, OR $FF
13BA	B1 F6		LDA	(DATPTR),Y
13BC	85 16		STA	HDRFLAG
13BE	C9 FF		CMP	#$FF
13C0	D0 13		BNE	READN5
13C2	E6 F6		INC	DATPTR	$FF: GO TO THE NEXT DATA BLOCK
13C4	D0 02		BNE	READN4
13C6	E6 F7		INC	DATPTR+1
13C8	B1 F6	READN4	LDA	(DATPTR),Y
13CA	AA		TAX
13CB	C8		INY
13CC	B1 F6		LDA	(DATPTR),Y
13CE	86 F6		STX	DATPTR
13D0	85 F7		STA	DATPTR+1
13D2	88		DEY
13D3	F0 DA		BEQ	READN1
13D5	A6 F6	READN5	LDX	DATPTR	THE ITEM
13D7	A4 F7		LDY	DATPTR+1
13D9	68		PLA
13DA	F0 06		BEQ	READN6
13DC	86 77		STX	STRACC	A STRING: USED WHERE IT IS
13DE	84 78		STY	STRACC+1
13E0	D0 25		BNE	READN8
13E2	86 B8	READN6	STX	TXTPTR	A NUMBER: TXTPTR = THE ITEM ...
13E4	84 B9		STY	TXTPTR+1
13E6	A4 16		LDY	HDRFLAG	... WITH A ZERO AFTER IT FOR NOW
13E8	C8		INY
13E9	B1 F6		LDA	(DATPTR),Y
13EB	48		PHA
13EC	A9 00		LDA	#$00
13EE	91 F6		STA	(DATPTR),Y
13F0	20 B1 00		JSR	CHRGET	FIN CONVERTS IT
13F3	20 4A EC		JSR	FIN
13F6	20 B7 00		JSR	CHRGOT	ANYTHING LEFT?
13F9	AA		TAX
13FA	A4 16		LDY	HDRFLAG
13FC	C8		INY
13FD	68		PLA
13FE	91 F6		STA	(DATPTR),Y
1400	8A		TXA
1401	F0 04		BEQ	READN8
1403	A2 10		LDX	#$10	SYNTAX ERROR, $10
1405	D0 0C	READN7	BNE	ERREXIT
1407	38	READN8	SEC		THE DATA POINTER PASSES THE ITEM
1408	A5 F6		LDA	DATPTR
140A	65 16		ADC	HDRFLAG
140C	85 F6		STA	DATPTR
140E	90 02		BCC	READN9
1410	E6 F7		INC	DATPTR+1
1412	60	READN9	RTS

ERREXIT

ERREXIT: EVERY LIBRARY ERROR ENDS HERE WITH THE ERROR NUMBER IN X. WITHOUT ONERR THE OBJECT ADDRESS OF THE CALL THAT FAILED BECOMES THE LINE NUMBER OF THE MESSAGE. X = $FF IS A CONTROL-C BREAK.

1413	A5 D8	ERREXIT	LDA	ERRFLG	ONERR ACTIVE?
1415	F0 12		BEQ	DEBUG1
1417	E0 FF	ERREX1	CPX	#$FF	X = $FF: A CONTROL-C BREAK
1419	F0 03		BEQ	ERREX2
141B	4C 12 D4		JMP	ERROR	ERROR X
141E	A9 03	ERREX2	LDA	#$03
1420	4C 63 D8		JMP	STOPCC

DEBUG

DEBUG: CALLED BEFORE EACH STATEMENT WITH THE RESUME/DEBUG OPTION. IT KEEPS THE STACK POINTER AND THE STATEMENT'S OBJECT ADDRESS, SO THAT AFTER AN ERROR RESUME CAN START THE STATEMENT AGAIN.

1423	BA	DEBUG	TSX		THE STACK POINTER BEFORE THE CALL
1424	E8		INX
1425	E8		INX
1426	86 F8		STX	REMSTK
1428	8A		TXA
1429	85 16	DEBUG1	STA	HDRFLAG	A = 0 FROM ERREXIT
142B	68		PLA		CURLIN = RETURN ADDRESS - 2, THE OBJECT ADDRESS OF THE STATEMENT (OR OF THE CALL THAT FAILED)
142C	A8		TAY
142D	38		SEC
142E	E9 02		SBC	#$02
1430	85 75		STA	CURLIN
1432	68		PLA
1433	48		PHA
1434	E9 00		SBC	#$00
1436	85 76		STA	CURLIN+1
1438	98		TYA
1439	48		PHA
143A	A5 16		LDA	HDRFLAG	FROM ERREXIT: ON TO THE ERROR
143C	F0 D9		BEQ	ERREX1
143E	60		RTS

PRNUM

STATEMENTS WITH ONE BYTE ARGUMENT: PR#, IN#, POKE (THE VALUE), WAIT (THE MASKS), TAB(, SPC(. THE REAL ENTRY CONVERTS FAC WITH AYINT; THE INTEGER ENTRY, 3 BYTES LATER, TAKES THE BYTE WITH CONINT (ERROR $35 PAST 255).

143F	20 0C E1	PRNUM	JSR	AYINT
1442	20 FE E6	PRNUMI	JSR	CONINT2
1445	4C E8 F1		JMP	PRSLOT	THE ROM'S PR#
1448	20 0C E1	INNUM	JSR	AYINT
144B	20 FE E6	INNUMI	JSR	CONINT2
144E	4C E1 F1		JMP	INSLOT
1451	20 0C E1	POKE	JSR	AYINT
1454	20 FE E6	POKEI	JSR	CONINT2
1457	4C 7E E7		JMP	POKE2
145A	20 0C E1	WAIT	JSR	AYINT
145D	20 FE E6	WAITI	JSR	CONINT2
1460	86 85		STX	FORPNT	WAIT WITH TWO ARGUMENTS: THE MASK, NO XOR VALUE
1462	A2 00		LDX	#$00
1464	F0 06		BEQ	WAIT3I1
1466	20 0C E1	WAIT3	JSR	AYINT
1469	20 FE E6	WAIT3I	JSR	CONINT2
146C	4C 93 E7	WAIT3I1	JMP	WAIT2	THE ROM'S WAIT
146F	20 0C E1	TAB	JSR	AYINT
1472	20 FE E6	TABI	JSR	CONINT2
1475	CA		DEX		TAB(N): N-1 - CURSOR COLUMN SPACES
1476	8A		TXA
1477	38		SEC
1478	E5 24		SBC	CH
147A	90 21		BCC	COMMA2
147C	AA		TAX
147D	B0 08		BCS	SPCI2
147F	20 0C E1	SPC	JSR	AYINT
1482	20 FE E6	SPCI	JSR	CONINT2
1485	E8		INX		SPC(N): N SPACES
1486	CA	SPCI1	DEX
1487	F0 14	SPCI2	BEQ	COMMA2
1489	20 57 DB		JSR	OUTSP
148C	D0 F8		BNE	SPCI1

COMMA

COMMA: A COMMA IN PRINT: TO THE NEXT 16-COLUMN FIELD, OR A NEW LINE PAST COLUMN 24.

148E	A5 24	COMMA	LDA	CH	PAST COLUMN 24: A NEW LINE
1490	C9 18		CMP	#$18
1492	90 03		BCC	COMMA1
1494	4C FB DA		JMP	CRDO
1497	69 10	COMMA1	ADC	#$10	TO THE NEXT MULTIPLE OF 16
1499	29 F0		AND	#$F0
149B	85 24		STA	CH
149D	60	COMMA2	RTS
149E	20 0C E1	VTAB	JSR	AYINT
14A1	20 FE E6	VTABI	JSR	CONINT2
14A4	4C 59 F2		JMP	VTAB2
14A7	20 0C E1	HTAB	JSR	AYINT
14AA	20 FE E6	HTABI	JSR	CONINT2
14AD	4C EA F7		JMP	HTAB2

ONGOTO

ON ... GOTO AND ON ... GOSUB: THE CALL IS FOLLOWED BY THE NUMBER OF LINES AND THEIR ADDRESSES. AN INDEX OF 0 OR PAST THE LIST GOES ON AFTER THE LIST; OTHERWISE CONTROL GOES TO THE LINE, FOR GOSUB WITH A RETURN ADDRESS PAST THE LIST.

14B0	20 0C E1	ONGOTO	JSR	AYINT
14B3	A2 00	ONGOTOI	LDX	#$00	X = 0: GOTO
14B5	F0 05		BEQ	ONGOS1
14B7	20 0C E1	ONGOSUB	JSR	AYINT
14BA	A2 01	ONGOSUBI	LDX	#$01	X = 1: GOSUB
14BC	86 16	ONGOS1	STX	HDRFLAG
14BE	20 FE E6		JSR	CONINT2	THE INDEX
14C1	68		PLA		THE RETURN ADDRESS POINTS AT THE COUNT - 1
14C2	85 50		STA	LINNUM
14C4	68		PLA
14C5	85 51		STA	LINNUM+1
14C7	A0 01		LDY	#$01	THE COUNT
14C9	B1 50		LDA	(LINNUM),Y
14CB	A8		TAY
14CC	0A		ASL	A	RETURN ADDRESS PAST THE LIST: COUNT*2+1
14CD	38		SEC
14CE	65 50		ADC	LINNUM
14D0	AA		TAX
14D1	A5 51		LDA	LINNUM+1
14D3	69 00		ADC	#$00
14D5	48		PHA
14D6	8A		TXA
14D7	48		PHA
14D8	98		TYA		INDEX 0 OR ABOVE THE COUNT: CONTINUE AFTER THE LIST
14D9	C5 A1		CMP	IACC+1
14DB	90 04		BCC	ONGOS2
14DD	A5 A1		LDA	IACC+1
14DF	D0 01		BNE	ONGOS3
14E1	60	ONGOS2	RTS
14E2	A6 16	ONGOS3	LDX	HDRFLAG	GOTO: DROP THE RETURN ADDRESS; GOSUB KEEPS IT
14E4	D0 02		BNE	ONGOS4
14E6	68		PLA
14E7	68		PLA
14E8	A5 A1	ONGOS4	LDA	IACC+1	THE LINE'S ADDRESS - 1 ...
14EA	0A		ASL	A
14EB	A8		TAY
14EC	B1 50		LDA	(LINNUM),Y
14EE	AA		TAX
14EF	C8		INY
14F0	B1 50		LDA	(LINNUM),Y
14F2	A8		TAY
14F3	8A		TXA
14F4	D0 01		BNE	ONGOS5
14F6	88		DEY
14F7	CA	ONGOS5	DEX
14F8	98		TYA		... PUSHED, AND RTS GOES THERE
14F9	48		PHA
14FA	8A		TXA
14FB	48		PHA
14FC	60		RTS

LOGORI

AND, OR AND THE RELATIONS. THE CODE BEFORE THE CALL HAS SET THE FLAGS: FOR AND/OR BY LOADING ONE OPERAND, FOR A RELATION BY COMPARING (A = -1, 0, 1). THE RESULT IN FAC IS 1 (TRUE) OR 0 (FALSE). THE ENTRIES SHARE CODE BY FALLING THROUGH ONE ANOTHER.

14FD	05 A1	LOGORI	ORA	IACC+1	INTEGER OR: EITHER OPERAND NOT ZERO
14FF	05 A0		ORA	IACC
1501	D0 1A		BNE	RELTRUE
1503	F0 25	LOGANDI	BEQ	RELFALSE	INTEGER AND: BOTH NOT ZERO
1505	A5 A1		LDA	IACC+1
1507	05 A0		ORA	IACC
1509	F0 1F		BEQ	RELFALSE
150B	D0 10	LOGOR	BNE	RELTRUE	REAL OR
150D	A5 9D		LDA	FAC
150F	D0 0C		BNE	RELTRUE
1511	F0 17	LOGAND	BEQ	RELFALSE	REAL AND
1513	A5 9D		LDA	FAC
1515	F0 13		BEQ	RELFALSE
1517	D0 04	RELNE	BNE	RELTRUE
1519	F0 0F	RELGT	BEQ	RELFALSE
151B	30 0D	RELGE	BMI	RELFALSE
151D	A9 13	RELTRUE	LDA	#$13	TRUE: FAC = 1.0 (THE ROM'S CONSTANT AT $E913)
151F	A0 E9		LDY	#$E9
1521	4C F9 EA		JMP	MOVFM
1524	D0 04	RELEQ	BNE	RELFALSE
1526	F0 F5	RELLE	BEQ	RELTRUE
1528	30 F3	RELLT	BMI	RELTRUE
152A	A9 00	RELFALSE	LDA	#$00	FALSE: FAC = 0
152C	85 9D		STA	FAC
152E	60		RTS

STRGE

STRING RELATIONS ON THE PUSHED STRING (LEFT) AND THE LOADED STRING (RIGHT). STRLT AND STRGE SWAP THEM AND USE THE CODE OF STRGT AND STRLE. EQUAL OR NOT EQUAL COMPARE LENGTHS FIRST.

152F	A9 01	STRGE	LDA	#$01	STRGE: STRLE WITH THE STRINGS SWAPPED
1531	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
1532	A9 00	STRLT	LDA	#$00	STRLT: STRGT WITH THE STRINGS SWAPPED
1534	A4 77		LDY	STRACC
1536	A6 79		LDX	STRPSH
1538	84 79		STY	STRPSH
153A	86 77		STX	STRACC
153C	A4 78		LDY	STRACC+1
153E	A6 7A		LDX	STRPSH+1
1540	84 7A		STY	STRPSH+1
1542	86 78		STX	STRACC+1
1544	D0 05		BNE	STRGT1
1546	A9 01	STRLE	LDA	#$01	STRLE: NOT GREATER
1548	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
1549	A9 00	STRGT	LDA	#$00	STRGT
154B	48	STRGT1	PHA
154C	A0 00		LDY	#$00	COMPARE UP TO THE SHORTER LENGTH
154E	B1 79		LDA	(STRPSH),Y
1550	D1 77		CMP	(STRACC),Y
1552	F0 0A		BEQ	STRGT2
1554	90 08		BCC	STRGT2
1556	B1 77		LDA	(STRACC),Y
1558	AA		TAX
1559	C8		INY
155A	84 66		STY	RESULT+4
155C	D0 04		BNE	STRGT3
155E	84 66	STRGT2	STY	RESULT+4
1560	C8		INY
1561	AA		TAX
1562	8A	STRGT3	TXA
1563	F0 0C		BEQ	STRGT5
1565	B1 79	STRGT4	LDA	(STRPSH),Y
1567	D1 77		CMP	(STRACC),Y
1569	90 0A		BCC	STRGT6
156B	D0 10		BNE	STRGT8
156D	C8		INY
156E	CA		DEX
156F	D0 F4		BNE	STRGT4
1571	A5 66	STRGT5	LDA	RESULT+4	ALL EQUAL: THE LONGER STRING IS GREATER
1573	D0 08		BNE	STRGT8
1575	68	STRGT6	PLA
1576	D0 30		BNE	STREQ5
1578	A9 00	STRGT7	LDA	#$00
157A	85 9D		STA	FAC
157C	60		RTS
157D	68	STRGT8	PLA
157E	D0 F8		BNE	STRGT7
1580	F0 26		BEQ	STREQ5
1582	A9 00	STREQ	LDA	#$00	STREQ
1584	48	STREQ1	PHA
1585	A5 77		LDA	STRACC	THE SAME STRING: EQUAL
1587	C5 79		CMP	STRPSH
1589	D0 06		BNE	STREQ2
158B	A5 78		LDA	STRACC+1
158D	C5 7A		CMP	STRPSH+1
158F	F0 14		BEQ	STREQ4
1591	A0 00	STREQ2	LDY	#$00	THE SAME LENGTH ...
1593	B1 77		LDA	(STRACC),Y
1595	D1 79		CMP	(STRPSH),Y
1597	D0 16		BNE	STREQ6
1599	A8		TAY
159A	F0 09		BEQ	STREQ4
159C	B1 77	STREQ3	LDA	(STRACC),Y	... AND THE SAME CHARACTERS
159E	D1 79		CMP	(STRPSH),Y
15A0	D0 0D		BNE	STREQ6
15A2	88		DEY
15A3	D0 F7		BNE	STREQ3
15A5	68	STREQ4	PLA
15A6	D0 0A		BNE	STREQ7
15A8	A9 13	STREQ5	LDA	#$13
15AA	A0 E9		LDY	#$E9
15AC	4C F9 EA		JMP	MOVFM
15AF	68	STREQ6	PLA
15B0	D0 F6		BNE	STREQ5
15B2	A9 00	STREQ7	LDA	#$00
15B4	85 9D		STA	FAC
15B6	60		RTS
15B7	A9 01	STRNE	LDA	#$01	STRNE
15B9	D0 C9		BNE	STREQ1

ROT

STATEMENTS AND ARGUMENTS THAT KEEP A BYTE FOR LATER: ROT=, SCALE=, THE SHAPE NUMBER, THE THIRD WAIT ARGUMENT, A BYTE FOR SCRN( OR MID$, THE HI-RES X (16 BITS, SAVEHX), HCOLOR=, THE LO-RES X (SAVEX) AND THE OTHER END OF HLIN/VLIN (SAVEY), SPEED=.

15BB	20 0C E1	ROT	JSR	AYINT
15BE	20 FE E6	ROTI	JSR	CONINT2
15C1	86 F9		STX	HGRROT	ROTATION
15C3	60		RTS
15C4	20 0C E1	SCALE	JSR	AYINT
15C7	20 FE E6	SCALEI	JSR	CONINT2
15CA	86 E7		STX	HGRSCALE	SCALE
15CC	60		RTS
15CD	20 0C E1	SVSHAPE	JSR	AYINT
15D0	20 FE E6	SVSHAPEI	JSR	CONINT2
15D3	86 F0		STX	FIRST	SHAPE NUMBER
15D5	60		RTS
15D6	20 0C E1	SVARG3	JSR	AYINT
15D9	20 FE E6	SVARG3I	JSR	CONINT2
15DC	86 85		STX	FORPNT	THIRD ARGUMENT OF WAIT
15DE	60		RTS
15DF	20 0C E1	PUSHBYTE	JSR	AYINT
15E2	20 FE E6	PUSHBYTI	JSR	CONINT2
15E5	86 10		STX	DIMFLG	FIRST ARGUMENT OF SCRN( OR THE START OF MID$
15E7	60		RTS
15E8	20 0C E1	SAVEHX	JSR	AYINT
15EB	A5 A0	SAVEHXI	LDA	IACC	HI-RES X, 16 BITS, TO $50/$51
15ED	85 51		STA	LINNUM+1
15EF	A5 A1		LDA	IACC+1
15F1	85 50		STA	LINNUM
15F3	60		RTS
15F4	20 0C E1	HCOLOR	JSR	AYINT
15F7	20 FE E6	HCOLORI	JSR	CONINT2
15FA	4C EC F6		JMP	HCOLOR2	THE ROM'S HCOLOR=
15FD	20 0C E1	SAVEX	JSR	AYINT
1600	20 FE E6	SAVEXI	JSR	CONINT2
1603	86 F0		STX	FIRST	LO-RES X
1605	4C 20 F2		JMP	PLOTCHK
1608	20 0C E1	SAVEY	JSR	AYINT
160B	20 FE E6	SAVEYI	JSR	CONINT2
160E	20 FD F1		JSR	LINCHK	HLIN/VLIN: ORDER THE TWO ENDS
1611	E4 F0		CPX	FIRST
1613	B0 08		BCS	SAVEYI1
1615	A5 F0		LDA	FIRST
1617	85 2C		STA	H2
1619	85 2D		STA	V2
161B	86 F0		STX	FIRST
161D	60	SAVEYI1	RTS
161E	20 0C E1	SPEED	JSR	AYINT
1621	20 FE E6	SPEEDI	JSR	CONINT2
1624	4C 65 F2		JMP	SPEED2

INPBEG

INPBEG: THE START OF AN INPUT STATEMENT: KEEP ITS OBJECT ADDRESS FOR ?REENTER.

1627	68	INPBEG	PLA		RETURN ADDRESS - 2: THE INPUT STATEMENT'S ADDRESS, FOR ?REENTER
1628	AA		TAX
1629	38		SEC
162A	E9 02		SBC	#$02
162C	85 50		STA	LINNUM
162E	68		PLA
162F	48		PHA
1630	E9 00		SBC	#$00
1632	85 51		STA	LINNUM+1
1634	8A		TXA
1635	48		PHA
1636	60		RTS

ONERR

ONERR: THE CALL IS FOLLOWED BY THE HANDLER'S ADDRESS, WHICH GOES INTO THE ONERR VECTOR AT $5B.

1637	A2 80	ONERR	LDX	#$80	ONERR ON
1639	86 D8		STX	ERRFLG
163B	68		PLA		RETURN PAST THE INLINE WORD
163C	85 62		STA	RESULT
163E	18		CLC
163F	69 02		ADC	#$02
1641	AA		TAX
1642	68		PLA
1643	85 63		STA	RESULT+1
1645	69 00		ADC	#$00
1647	48		PHA
1648	8A		TXA
1649	48		PHA
164A	A0 01		LDY	#$01	THE HANDLER'S ADDRESS INTO THE ONERR VECTOR
164C	B1 62		LDA	(RESULT),Y
164E	85 5C		STA	ERRVEC+1
1650	C8		INY
1651	B1 62		LDA	(RESULT),Y
1653	85 5D		STA	ERRVEC+2
1655	60		RTS

RESUME

RESUME: BACK TO THE STATEMENT THAT FAILED (ITS DEBUG CALL) WITH THE STACK AS IT WAS.

1656	A6 DF	RESUME	LDX	ERRSTK	THE STACK AS IT WAS BEFORE THE STATEMENT
1658	9A		TXS
1659	6C DA 00		JMP	(ERRLIN)	AND BACK TO THE STATEMENT'S DEBUG CALL

PUSHSUB

PUSHSUB: PUSH A SUBSCRIPT UNDER THE RETURN ADDRESS FOR THE ARRAY ROUTINE.

165C	20 0C E1	PUSHSUB	JSR	AYINT
165F	68	PUSHSUBI	PLA		PUSH IACC UNDER THE RETURN ADDRESS
1660	AA		TAX
1661	68		PLA
1662	A8		TAY
1663	A5 A0		LDA	IACC
1665	48		PHA
1666	A5 A1		LDA	IACC+1
1668	48		PHA
1669	98		TYA
166A	48		PHA
166B	8A		TXA
166C	48		PHA
166D	60		RTS

FLOATI

FLOATI: FAC = IACC. THE JMP AT $58 COMES HERE. IMOVE: IARG = IACC.

166E	A5 A0	FLOATI	LDA	IACC
1670	A4 A1		LDY	IACC+1
1672	4C F2 E2		JMP	GIVAYF
1675	A5 A0	IMOVE	LDA	IACC
1677	85 9E		STA	IARG
1679	A5 A1		LDA	IACC+1
167B	85 9F		STA	IARG+1
167D	60		RTS

IFORST1

LOOP LIMIT AND STEP, CALLED AFTER THE LOOP START. THEY PUT THE VALUES INTO THE FRAME UNDER THE CALLER'S RETURN ADDRESS; THE LIMIT ALSO PUSHES THE LOOP ADDRESS (THE RETURN ADDRESS OF THE STEP CALL) AND THE MARKER. INTEGER LOOPS: IFORLIM, IFORSTEP (IFORST1 = STEP 1); REAL LOOPS: FORLIM, FORSTEP (FORSTEP1 = STEP 1). THE R AND I ENTRIES CONVERT THE VALUE FIRST.

167E	A2 01	IFORST1	LDX	#$01	IACC = 1
1680	86 A1		STX	IACC+1
1682	CA		DEX
1683	86 A0		STX	IACC
1685	F0 03		BEQ	IFORSTEP
1687	20 0C E1	IFORSTR	JSR	AYINT
168A	A9 00	IFORSTEP	LDA	#$00	STEP: A = 0
168C	F0 05		BEQ	IFORL1
168E	20 0C E1	IFORLIMR	JSR	AYINT
1691	A9 01	IFORLIM	LDA	#$01	LIMIT: A = 1
1693	85 16	IFORL1	STA	HDRFLAG
1695	68		PLA		THE RETURN ADDRESS
1696	85 64		STA	RESULT+2
1698	68		PLA
1699	85 65		STA	RESULT+3
169B	48		PHA		PUT IT BACK TWICE
169C	A5 64		LDA	RESULT+2
169E	48		PHA
169F	48		PHA
16A0	A5 A1		LDA	IACC+1	AND THE INTEGER VALUE
16A2	48		PHA
16A3	A5 A0		LDA	IACC
16A5	48		PHA
16A6	A5 16		LDA	HDRFLAG	THE LIMIT ALSO PUSHES THE MARKER
16A8	F0 30		BEQ	FORPU1
16AA	D0 38		BNE	FORPU2
16AC	A0 E9	FORSTEP1	LDY	#$E9	STEP 1.0 (THE ROM'S CONSTANT AT $E913)
16AE	A9 13		LDA	#$13
16B0	20 F9 EA		JSR	MOVFM
16B3	D0 03		BNE	FORSTEP
16B5	20 58 00	FORSTEPI	JSR	FLTVEC
16B8	A9 00	FORSTEP	LDA	#$00	STEP: A = 0
16BA	F0 05		BEQ	FORPUSH
16BC	20 58 00	FORLIMI	JSR	FLTVEC
16BF	A9 01	FORLIM	LDA	#$01	LIMIT: A = 1
16C1	85 16	FORPUSH	STA	HDRFLAG
16C3	BA		TSX		MAKE ROOM FOR 5 BYTES UNDER THE RETURN ADDRESS ...
16C4	CA		DEX
16C5	CA		DEX
16C6	CA		DEX
16C7	68		PLA
16C8	85 64		STA	RESULT+2
16CA	68		PLA
16CB	85 65		STA	RESULT+3
16CD	9A		TXS
16CE	E8		INX
16CF	A0 01		LDY	#$01	... AND STORE FAC THERE
16D1	20 2B EB		JSR	MOVMF
16D4	A5 16		LDA	HDRFLAG
16D6	D0 0C		BNE	FORPU2
16D8	A5 65		LDA	RESULT+3	THE LOOP ADDRESS AND THE MARKER
16DA	48	FORPU1	PHA
16DB	A5 64		LDA	RESULT+2
16DD	48		PHA
16DE	A5 B0		LDA	FORPOP+1
16E0	48		PHA
16E1	A5 AF		LDA	FORPOP
16E3	48		PHA
16E4	A5 65	FORPU2	LDA	RESULT+3	RETURN
16E6	48		PHA
16E7	A5 64		LDA	RESULT+2
16E9	48		PHA
16EA	60		RTS

SCRN

SCRN(: THE FIRST ARGUMENT WAS PUSHED WITH PUSHBYTE. POS: THE CURSOR COLUMN. THE RESULT GOES TO IACC.

16EB	20 0C E1	SCRN	JSR	AYINT
16EE	20 FE E6	SCRNI	JSR	CONINT2
16F1	20 20 F2		JSR	PLOTCHK	X: 0-47
16F4	8A		TXA
16F5	A6 10		LDX	DIMFLG
16F7	20 20 F2		JSR	PLOTCHK	Y: 0-47
16FA	A4 10		LDY	DIMFLG
16FC	20 71 F8		JSR	MONSCRN	THE ROM'S SCRN
16FF	2C		DFB	$2C	BIT ABSOLUTE: SKIPS THE NEXT 2 BYTES
1700	A5 24	POS	LDA	CH	POS: THE CURSOR COLUMN
1702	85 A1	POS1	STA	IACC+1	IACC = A
1704	A0 00		LDY	#$00
1706	84 A0		STY	IACC
1708	A8		TAY
1709	60		RTS

PLOT

PLOT, HLIN, VLIN, PDL: THE LAST ARGUMENT; THE OTHERS WERE SAVED BEFORE. PDL GIVES ITS RESULT IN IACC.

170A	20 0C E1	PLOT	JSR	AYINT
170D	20 FE E6	PLOTI	JSR	CONINT2
1710	20 20 F2		JSR	PLOTCHK
1713	4C 28 F2		JMP	PLOT2
1716	20 0C E1	HLIN	JSR	AYINT
1719	20 FE E6	HLINI	JSR	CONINT2
171C	20 20 F2		JSR	PLOTCHK
171F	4C 35 F2		JMP	HLIN2
1722	20 0C E1	VLIN	JSR	AYINT
1725	20 FE E6	VLINI	JSR	CONINT2
1728	4C 44 F2		JMP	VLIN2
172B	20 0C E1	PDL	JSR	AYINT
172E	20 FE E6	PDLI	JSR	CONINT2
1731	20 1E FB		JSR	PREAD	READ THE PADDLE
1734	98	PDLI1	TYA
1735	38		SEC
1736	B0 CA		BCS	POS1

CALLI

STATEMENTS AND FUNCTIONS WITH AN ADDRESS: CALL, POKE AND WAIT (THE ADDRESS, SVADDR), PEEK. GETADR TAKES ANY VALUE FROM -65535 TO 65535. THE INTEGER ENTRY, 3 BYTES EARLIER, FLOATS IACC FIRST, SO -16384 IS A GOOD ADDRESS.

1738	20 58 00	CALLI	JSR	FLTVEC
173B	4C D8 F1	CALL	JMP	CALLROM	THE ROM'S CALL
173E	20 58 00	SVADDRI	JSR	FLTVEC
1741	4C 52 E7	SVADDR	JMP	GETADR	THE ADDRESS TO $50/$51
1744	20 58 00	PEEKI	JSR	FLTVEC
1747	A5 51	PEEK	LDA	LINNUM+1	PEEK KEEPS $50/$51 (THE POKE ADDRESS)
1749	48		PHA
174A	A5 50		LDA	LINNUM
174C	48		PHA
174D	20 52 E7		JSR	GETADR
1750	A0 00		LDY	#$00	THE BYTE
1752	B1 50		LDA	(LINNUM),Y
1754	A8		TAY
1755	68		PLA
1756	85 50		STA	LINNUM
1758	68		PLA
1759	85 51		STA	LINNUM+1
175B	38		SEC
175C	B0 D6		BCS	PDLI1

PRINTI

PRINT A NUMBER: PRINTI FLOATS IACC FIRST.

175E	20 58 00	PRINTI	JSR	FLTVEC
1761	4C 2E ED	PRINTN	JMP	PRNTFAC	THE ROM PRINTS FAC

DISPREAL

DISPREAL: THE REAL VARIABLE DISPATCHER: X = OPERATION, (Y,A) = THE VARIABLE. 0 LOAD FAC (AND SET THE FLAGS), 1 STORE FAC, 2 ADD, 3 VARIABLE MINUS FAC, 4 MULTIPLY, 5 COMPARE, 6 LOAD ARG, 7 VARIABLE DIVIDED BY FAC.

1764	CA	DISPREAL	DEX		OPERATION 0
1765	30 27		BMI	DISPR7
1767	D0 04		BNE	DISPR1	1: STORE FAC ROUNDED AT (Y,X)
1769	AA		TAX
176A	4C 2B EB		JMP	MOVMF
176D	CA	DISPR1	DEX		2 ADD
176E	F0 18		BEQ	DISPR5
1770	CA		DEX		3 SUBTRACT
1771	F0 12		BEQ	DISPR4
1773	CA		DEX		4 MULTIPLY
1774	F0 0C		BEQ	DISPR3
1776	CA		DEX		5 COMPARE
1777	F0 06		BEQ	DISPR2
1779	CA		DEX		6 LOAD ARG
177A	F0 0F		BEQ	DISPR6
177C	4C 66 EA		JMP	FDIV	7 DIVIDE
177F	4C B2 EB	DISPR2	JMP	FCOMP
1782	4C 7F E9	DISPR3	JMP	FMULT
1785	4C A7 E7	DISPR4	JMP	FSUB
1788	4C BE E7	DISPR5	JMP	FADD
178B	4C E3 E9	DISPR6	JMP	CONUPK
178E	20 F9 EA	DISPR7	JSR	MOVFM	LOAD FAC; SIGNS COMPARED; A = THE EXPONENT (FLAGS SET)
1791	A5 AA		LDA	ARGSIGN
1793	4C 59 DE		JMP	SGNEXIT

COPYRT

COPYRT: THE COPYRIGHT NOTICE.

1796	C3 CF D0 D9 D2 C9 C7 C8	COPYRT	DFB	$C3,$CF,$D0,$D9,$D2,$C9,$C7,$C8	"COPYRIGH"
179E	D4 A8 C3 A9 B1 B9 B8 B1		DFB	$D4,$A8,$C3,$A9,$B1,$B9,$B8,$B1	"T(C)1981"
17A6	AC CD C9 C3 D2 CF D3 CF		DFB	$AC,$CD,$C9,$C3,$D2,$CF,$D3,$CF	",MICROSO"
17AE	C6 D4		DFB	$C6,$D4	"FT"

Equates

Name	Value	Meaning
CHARAC	$0D	TEMPORARY
ENDCHR	$0E	TEMPORARY
NUMDIM	$0F	TEMPORARY: DIMENSION COUNT
DIMFLG	$10	TEMPORARY
DATFIRST	$12	HEADER: ADDRESS OF THE FIRST DATA ITEM (2 BYTES)
HIGHEST	$14	HEADER: HIGHEST ADDRESS USED BY LIBRARY, PROGRAM OR VARIABLES (2)
HDRFLAG	$16	HEADER: COMMON FLAG; ALSO A TEMPORARY
HGRSHAPE	$1A	HI-RES SHAPE POINTER (2)
CH	$24	MONITOR: CURSOR COLUMN
H2	$2C	MONITOR: RIGHT END OF A LO-RES LINE
V2	$2D	MONITOR: BOTTOM END OF A LO-RES LINE
PROMPT	$33	MONITOR: PROMPT CHARACTER
A1L	$3C	MONITOR: A1 (2)
LINNUM	$50	ADDRESS TEMPORARY (2)
TEMPPT	$52	TEMPORARY
TPTR	$55	TEMPORARY POINTER (2)
FLTVEC	$58	JMP TO THE ROUTINE THAT FLOATS THE INTEGER ACCUMULATOR (3)
ERRVEC	$5B	JMP TO THE CODE HANDLING ONERR (3)
RESULT	$62	TEMPORARIES (5)
TXTTAB	$67	APPLESOFT START OF PROGRAM (2)
COMBEG	$69	START OF THE COMMON BLOCK - 1 (2)
NUMCEND	$6B	END OF NUMERIC COMMON (2)
STRCEND	$6D	END OF STRING COMMON (2)
FRETOP	$6F	BOTTOM OF STRINGS - 1 (2)
INPOS	$71	INPUT BUFFER POSITION ($FF NEW LINE, $FE USED UP)
MEMSIZ	$73	HIMEM (2)
CURLIN	$75	ADDRESS OF THE OBJECT CODE BEING EXECUTED (2)
STRACC	$77	STRING ACCUMULATOR: THE LOADED STRING (2)
STRPSH	$79	THE PUSHED STRING (2)
LOCBEG	$7B	START OF LOCAL VARIABLES - 1 (2)
LOCNEND	$7D	END OF LOCAL NUMERIC VARIABLES (2)
LOCSEND	$7F	END OF LOCAL STRING VARIABLES (2)
VARNAM	$81	TEMPORARY (2)
RETADR	$83	TEMPORARY: A SAVED RETURN ADDRESS (2)
FORPNT	$85	TEMPORARY POINTER (2)
TEMP3	$8A	TEMPORARIES (5)
TEMP1	$93	TEMPORARIES; ALSO THE COLLECTOR'S POINTERS (5)
FAC	$9D	FLOATING POINT ACCUMULATOR (EXPONENT, 4 MANTISSA BYTES, SIGN AT $A2)
IARG	$9E	INTEGER ARGUMENT (HIGH, LOW)
IACC	$A0	INTEGER ACCUMULATOR (HIGH, LOW)
FACSIGN	$A2	SIGN OF FAC
SERLEN	$A3	TEMPORARY
ARG	$A5	SECOND FLOATING POINT ACCUMULATOR (5, SIGN AT $AA)
ARGSIGN	$AA	SIGN OF ARG
SGNCPR	$AB	TEMPORARY: SIGN COMPARISON, NEGATION COUNT
SERPNT	$AD	TEMPORARY (2)
FORPOP	$AF	ADDRESS OF THE ROUTINE THAT POPS FOR ENTRIES (2)
CHRGET	$B1	APPLESOFT CHRGET (MODIFIED)
CHRGOT	$B7	CHRGOT, INSIDE CHRGET
TXTPTR	$B8	TEXT POINTER, INSIDE CHRGET (2)
CHRPAT	$BA	WHERE THE CHRGET PATCH GOES
ERRFLG	$D8	$80 WHEN ONERR IS ACTIVE
ELTYPE	$D9	TEMPORARY: ARRAY ELEMENT TYPE
ERRLIN	$DA	OBJECT ADDRESS OF THE STATEMENT THAT FAILED (2)
ERRPOS	$DC	TEMPORARY: ARRAY ELEMENT ADDRESS (2)
ERRSTK	$DF	STACK POINTER BEFORE THE FAILED STATEMENT
HGRSCALE	$E7	HI-RES SCALE
SHAPETBL	$E8	ADDRESS OF THE SHAPE TABLE (2)
FIRST	$F0	TEMPORARY: LO-RES / SHAPE ARGUMENT
SPEEDZ	$F1	OUTPUT SPEED
TRCFLG	$F2	TRACE FLAG
TXTPSV	$F4	ONERR TEXT POINTER (2)
DATPTR	$F6	POINTER INTO THE DATA ITEMS (2)
REMSTK	$F8	STACK POINTER BEFORE THE STATEMENT
HGRROT	$F9	HI-RES ROTATION
ZPFF	$FF	LAST BYTE OF PAGE ZERO
STACK	$0100	THE 6502 STACK
INBUF	$0200	INPUT BUFFER
AMPER	$03F5	AMPERSAND VECTOR (3)
ERROR	$D412	ROM: REPORT ERROR X
INLIN	$D52C	ROM: READ A LINE INTO THE INPUT BUFFER
INCHR	$D553	ROM: READ A KEY
RUNCLR	$D566	ROM: RUN, AFTER CLEARING VARIABLES
SCRTCH	$D64B	ROM: NEW
STOPCC	$D863	ROM: CONTROL-C BREAK
LET2	$DA65	ROM: STORE FAC IN AN INTEGER VARIABLE (ROUND, RANGE CHECK)
CRDO	$DAFB	ROM: PRINT A CARRIAGE RETURN
STROUT	$DB3A	ROM: PRINT A STRING AT (Y,A)
OUTSP	$DB57	ROM: PRINT A SPACE
OUTQUES	$DB5A	ROM: PRINT A QUESTION MARK
OUTDO	$DB5C	ROM: PRINT THE CHARACTER IN A
REENTER	$DB87	ROM: ?REENTER (INSIDE INPERR)
SGNEXIT	$DE59	ROM: SAVE THE SIGN COMPARISON, RETURN THE FAC EXPONENT (SETS THE FLAGS)
INTVAR	$DEE9	ROM: LOAD THE INTEGER AT (VPNT) INTO FAC
AYINT	$E10C	ROM: FAC TO A 16-BIT INTEGER IN FAC+3/FAC+4 ($A0/$A1)
GIVAYF	$E2F2	ROM: FLOAT THE INTEGER (A HIGH, Y LOW) INTO FAC
CONINT2	$E6FE	ROM: INSIDE CONINT: FAC+3/4 TO A BYTE IN X (0-255)
GETADR	$E752	ROM: FAC TO A 16-BIT ADDRESS IN LINNUM
POKE2	$E77E	ROM: INSIDE POKE: STORE X AT (LINNUM)
WAIT2	$E793	ROM: INSIDE WAIT
FSUB	$E7A7	ROM: FAC = (Y,A) - FAC
FADD	$E7BE	ROM: FAC = (Y,A) + FAC
FADDT	$E7C1	ROM: FAC = ARG + FAC
FMULT	$E97F	ROM: FAC = (Y,A) * FAC
FMULTT	$E982	ROM: FAC = ARG * FAC
CONUPK	$E9E3	ROM: LOAD ARG FROM (Y,A)
FDIV	$EA66	ROM: FAC = (Y,A) / FAC
FDIVT	$EA69	ROM: FAC = ARG / FAC
MOVFM	$EAF9	ROM: LOAD FAC FROM (Y,A)
MOV1F	$EB21	ROM: PACK FAC INTO TEMP1
MOVMF	$EB2B	ROM: STORE FAC, ROUNDED, AT (Y,X)
MOVFA	$EB53	ROM: COPY ARG TO FAC
MOVAF	$EB63	ROM: COPY FAC, ROUNDED, TO ARG
SIGN	$EB82	ROM: SIGN OF FAC IN A
FLOAT	$EB93	ROM: FLOAT THE SIGNED BYTE IN A
FCOMP	$EBB2	ROM: COMPARE FAC WITH (Y,A): A = -1, 0 OR 1
FIN	$EC4A	ROM: CONVERT THE NUMBER AT TXTPTR INTO FAC
INPRT	$ED19	ROM: PRINT " IN " AND THE LINE NUMBER
PRNTFAC	$ED2E	ROM: PRINT FAC
FOUT	$ED34	ROM: CONVERT FAC TO A STRING AT $0100
NEGOP	$EED0	ROM: FAC = -FAC
CHRGIMG	$F10B	ROM: THE COPY OF CHRGET THAT INITIALIZES $B1-$C8
CHRCONT	$F114	ROM: THE REST OF CHRGET AFTER THE SPACE CHECK
CALLROM	$F1D8	ROM: INSIDE CALL: JSR (LINNUM)
INSLOT	$F1E1	ROM: INSIDE IN#
PRSLOT	$F1E8	ROM: INSIDE PR#
LINCHK	$F1FD	ROM: LO-RES COORDINATE CHECK
PLOTCHK	$F220	ROM: LO-RES COORDINATE CHECK (BELOW 48)
PLOT2	$F228	ROM: INSIDE PLOT
HLIN2	$F235	ROM: INSIDE HLIN
VLIN2	$F244	ROM: INSIDE VLIN
COLOR2	$F252	ROM: INSIDE COLOR=
VTAB2	$F259	ROM: INSIDE VTAB
SPEED2	$F265	ROM: INSIDE SPEED=
HPOSN	$F411	ROM: POSITION THE HI-RES CURSOR
HPLOT0	$F457	ROM: PLOT A HI-RES POINT
HGLIN	$F53A	ROM: DRAW A HI-RES LINE
DRAW1	$F605	ROM: DRAW A SHAPE
XDRAW1	$F661	ROM: XDRAW A SHAPE
HCOLOR2	$F6EC	ROM: INSIDE HCOLOR=
HTAB2	$F7EA	ROM: INSIDE HTAB
MONSCRN	$F871	ROM: MONITOR SCRN
PREAD	$FB1E	ROM: READ A PADDLE
CROUT1	$FD8B	ROM: CLEAR TO END OF LINE, CARRIAGE RETURN