;Replacement BASIC parser

 include "settings.inc"
 include "ti83plus.inc"
 include "equates.inc" 
 SEGMENT Main
 GLOBALS ON

 EXTERN EvaluateOPSToken,MaybePushMultiplyOperator,OP2Set60,PUSHNUM,PUSHNUMFINISH,ExecClass2Token,DoCommand

 Var basic_start_page,1
 Var nextParseBytePage,1
 Var backupNextParseByte,2
 Var backupNextParseBytePage,1
 Var basic_end_page,1
 Var Atemp,1
 Var nextParseBytePageTemp,1
 Var tempWord,2

InitPFlagsParseInpGraph:
       B_CALL InitPFlgs
ParseInpGraph:
       call SetupBasicProg
       pop bc
       call PushWordOPS
       ld bc,parseInpGraphReturnPoint
       jr $F
ParseInp:
       set 1,(iy+8)
       B_CALL ChkFindSym
       ld a,b
       or a
       jr z,_ParseInpSub
       ld hl,ParseInpError
       call APP_PUSH_ERRORH
       call _ParseInpSub
       call APP_POP_ERRORH ;Yes, you really have to do call \ ret here
       ret
ParseInpError:
       res 7,a
       B_JUMP JError
_ParseInpSub:
       xor a
       ld (EST),a
       B_CALL InitPFlgs
       res splitOverride,(iy+graphFlags2)
       call SetupBasicProg
       pop bc
       call PushWordOPS
       pop bc
       call PushWordOPS
       pop bc
       call PushWordOPS
       ld bc,parseInpReturnPoint
$$:    call PushWordOPS
       ;Parser hook with A=0 would be called here
MasterParseLoop:
       res 3,(iy+1Ah)
       res 0,(iy+7)
       xor a
       call PushByteOPS
       ld hl,1
       ld (numArguments),hl
parseLoopGetByte:
       call GetCurrentParseByte
parseLoop:
       in a,(2)
       and 80h
       jr z,$F
       ld a,1
       out (20h),a
$$:    B_CALL CHKERRBREAK
       call IsEndOfLine
       jr z,endOfLineReached
       bit 7,(iy+9)
       jr z,$F
       B_CALL RESETWINTOP
$$:    res 7,(iy+9)

;Do token parsing here
       cp 04h
       jr z,encounteredSto
       jr c,conversionTokensEncountered
       cp 07h
       jr z,rightBracketEncountered
       jr c,leftBracketEncountered
       cp 09h
       jr c,leftCurlyBraceEncountered
       jr z,rightCurlyBraceEncountered
       cp 10h
       jr c,encounteredSpecialCommand
       cp 11h
       jr z,EvaluateOPSTokenResumeParse
       jr c,LParenEncountered
       cp 29h
       jr z,errSyntax
       jr c,mathCommandEncountered
       cp 2Ch
       jr z,noArgumentFunctionEncountered
       cp 2Bh
       jr z,EvaluateOPSTokenResumeParse
       jr c,encounteredQuote
       cp 2Dh
       jr z,encounteredSpecialCommand
       cp 30h
       jr c,encounteredtCubicROrtQuartR
       cp 3Ch
       jr c,encounteredHardCodedNumber
       cp 3Eh
       jr z,encounteredColonChar
       jr c,EvaluateOPSTokenResumeParse
       cp 40h
       jr z,EvaluateOPSTokenResumeParse
       cp 64h
       jr c,letterOrVarTokenEncountered
       cp 72h
       jr z,letterOrVarTokenEncountered
       cp 6Ah
       jr c,modeSettingCommandEncountered
       cp 70h
       jr c,EvaluateOPSTokenResumeParse
       cp 73h
       jr z,encounteredFix
       jr c,EvaluateOPSTokenResumeParse
       cp 7Eh
       jr c,graphModeCommandEncountered
       jr z,twoByteGraphModeCommandEncountered
       cp 82h
       jr c,errSyntax
       cp 84h
       jr c,EvaluateOPSTokenResumeParse
       cp 94h
       jr c,isSomeGraphCommandsToken
       cp 96h
       jr c,EvaluateOPSTokenResumeParse
       cp 0AAh
       jr c,moreGraphCommands
       jr z,letterOrVarTokenEncountered
       cp 0AEh
       jr c,noArgumentFunctionEncountered
       cp 0B0h
       jr z,changeSignEncountered
       cp 0BBh
       jr z,isBBhToken
       cp 0EFh
       jr z,isEFhToken
       cp 0CEh
       jr c,newMathTokens
       cp 0E6h
       jr z,menuEncountered
       cp 0EBh
       jr c,programmingTokenEncountered
       jr z,letterOrVarTokenEncountered
       cp 0EFh
       jr c,listOrPlotNameEncountered
       cp 0F2h
       jr c,EvaluateOPSTokenResumeParse
       cp 0FCh
       jr c,statPlotCommandEncountered
       cp 0FFh
       jr z,linraxPlusBEncountered
errSyntax:
       B_JUMP ErrSyntax

mathCommandEncountered:
       push af
       call PushMathOPS
       pop af
       cp 22h
       jr c,ResumeParse
       cp 29h
       jr nc,ResumeParse
       call ParseExpressionToTempEqu
       call BRKInc
       ld d,a
       call PUSHNUM
       call ParseOutObjectName
       push af
       call FindSymRAMErrDataTypeMaybe
       call ValidateGraphModeName
       ld a,(OP1+1)
       cp 62h
       jr z,$F
       cp 41h
       jr c,errSyntax
       cp 5Ch
       jr nc,errSyntax
$$:    pop af
       jr z,ResumeParseResult
       cp 2Bh
       jr z,ResumeParseResult
       cp 11h
       jr z,ResumeParseResult
       cp 0F4h
       jr nc,$F
       cp 0F2h
       jr nc,ResumeParseResult
$$:    cp 5
       jr nc,errSyntax
ResumeParseResult:
       set 0,(iy+7)
ResumeParse:
       call BRKInc
       jr parseLoop
encounteredSpecialCommand:
       bit numOP1,(iy+ParsFlag2)
       jr z,errSyntax
       ld hl,1
       call DoCommand
       set 0,(iy+7)
       call BRKInc
       jr parseLoop
conversionTokensEncountered:
       push af
       call GetByteMaybeDelimiter
       jr nz,errSyntax
       pop af
       call EvaluateOPSToken
       ei
       cp 0F2h
       jr c,$F
       add a,12h
$$:    ld c,3
       call ExecClass2Token
leftBracketEncountered:
       bit 5,(iy+6)
       jr nz,errSyntax
       push af
       bit 7,(iy+6)
       jr nz,leftBracketBranch
       bit 6,(iy+6)
       jr z,startingBracket
       set 7,(iy+6)
leftBracketContinue:
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       call PeekOPSByte
       cp 6
       jr nz,errSyntax
       ld hl,9664h
       inc (hl)
       jr nz,$F
       B_JUMP ErrDimension
$$:    pop af
       call PushByteOPS
       res 0,(iy+7)
       call BRKInc
       jr parseLoop
startingBracket:
       ld hl,0
       ld (9663h),hl
       ld (iy+6),h
       set 6,(iy+6)
       pop af
       push af
       call MaybePushMultiplyOperator
       pop af
       call PushByteOPS
       res 0,(iy+7)
       call BRKInc
       jr parseLoop
leftBracketBranch:
       bit 6,(iy+6)
       jr nz,errSyntax
       set 6,(iy+6)
       jr leftBracketContinue
rightBracketEncountered:
       bit 7,(iy+6)
       jr $F
rightCurlyBraceEncountered:
       bit 5,(iy+6)
$$:    jr z,errSyntax
       jr EvaluateOPSTokenResumeParse
leftCurlyBraceEncountered:
       ld a,(iy+6)
       and 0E0h
       jr nz,errSyntax
       ld (iy+6),0
       set 5,(iy+6)
       ld a,8
       push af
       call MaybePushMultiplyOperator
       pop af
       call PushByteOPS
       res 0,(iy+7)
       call BRKInc
       jr parseLoop
encounteredFix:
       call ZIfParseVarIsProgram
       jr nz,errSyntax
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       call GetOPSByte
       or a
       jr nz,errSyntax
       ld bc,1
       call PushWordOPS
       call BRKInc
       jr parseLoop
LParenEncountered:
       ld a,10h
       push af
       call MaybePushMultiplyOperator
       pop af
       call PushByteOPS
       res 0,(iy+7)
       call BRKInc
       jr parseLoop
moreGraphCommands:
       sub 2
isSomeGraphCommandsToken:
       cp 85h
       jr z,$F
       cp 93h
       call c,ErrInvalidIfProgrammingToken
$$:    push af
       call ZIfParseVarIsProgram
       jr nz,errSyntax
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       call PeekOPSByte
       or a
       jr nz,errSyntax
       pop af
       cp 93h
       jr nc,graphContinue
       push af
       call GetByteMaybeDelimiter
       jr z,$F
       call GetNextParseByte
       jr errSyntax
$$:    pop af
graphContinue:
       ld c,2
       jr ExecClass2Token
linraxPlusBEncountered:
       ld a,0EFh
       jr $F
listOrPlotNameEncountered:
       call ErrInvalidIfProgrammingToken
$$:    sub 0BCh
encounteredtCubicROrtQuartR:
       add a,0CEh
statPlotCommandEncountered;
       sub 7
programmingTokenEncountered:
       sub 0CEh
       cp 14h
       call c,ErrInvalidIfProgrammingToken
execClass2Category1Token:
       push af
       call ZIfParseVarIsProgram
       jr nz,errSyntax
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       call PeekOPSByte
       or a
       jr nz,errSyntax
       pop af
       ld c,1
       jr ExecClass2Token
menuEncountered:
       ;TODO: FIX THIS
       jr parseLoop
newMathTokens:
       cp 0B5h
       call z,0 ;TODO: FIX THIS, it's for ->dim(
       call PushMathOPS
       call BRKInc
       jr parseLoop
isBBhToken:
       ;TODO: FIX THIS
       ;requires class 2
isEFhToken:
       ;TODO: FIX THIS
       ;requires class 2
       call GetNextParseByte
       jr parseLoop
changeSignEncountered:
       call PushMathOPS
       call BRKInc
       jr parseLoop
twoByteGraphModeCommandEncountered:
       call GetNextParseByte
       add a,7Eh
graphModeCommandEncountered:
       sub 9
modeSettingCommandEncountered:
       push af
       call ZIfParseVarIsProgram
       jr nz,errSyntax
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       call PeekOPSByte
       or a
       jr nz,errSyntax
       call GetByteMaybeDelimiter
       jr z,$F
       call GetNextParseByte
       B_JUMP ErrSyntax
$$:    pop af
       ld c,0
       ld b,a
       ld a,2
       bit 1,(iy+36h)
       jr z,$F
       ;call parser hook
$$:    ld hl,modeSettingTable-(64h*2)
       ld e,b
       ld d,0
       add hl,de
       add hl,de
       B_CALL ldHLind
       call JpHL
       call BRKInc
       jr parseLoop
modeSettingTable:
       DW SetRadianMode
       DW SetDegreeMode
       DW SetNormal
       DW SetSci
       DW SetEng
       DW SetFloat
SetDegreeMode:
       bit 2,(iy+0)
       ret nz
       set 2,(iy+0)
       jr $F
SetNormal:
       res 0,(iy+0Ah)
$$:    res 1,(iy+0Ah)
       ret
SetSci:
       set 0,(iy+0Ah)
       jr $B
SetEng:
       set 0,(iy+0Ah)
       set 1,(iy+0Ah)
SetFloat:
       ld a,0FFh
       ld (97B0h),a
       ret
SetRadianMode:
       bit 2,(iy+0)
       ret z
       res 2,(iy+0)
$$:    bit 1,(iy+3)
       jr nz,$F
       set 1,(iy+17h)
       bit 1,(iy+3)
       jr nz,$F
       set 6,(iy+13h)
$$:    set 0,(iy+3)
       ret
noArgumentFunctionEncountered:
       push af
       cp 0ABh
       jr nz,$F
       call GetByteMaybeDelimiter
       cp 10h
       jr nz,$F
       call GetNextParseByte
       pop af
       call PushMathOPS
       call BRKInc
       jr parseLoop
$$:    call MaybePushMultiplyOperator
       pop af
       cp 2Ch
       jr z,isI
       cp 0ACh
       jr z,isPi
       jr c,isRand
       call ErrInvalidIfProgrammingToken
       B_CALL NZIf83Plus
       jr nz,$F
       B_CALL HandleLinkKeyActivity
$$:    B_CALL EVALF3A
       B_CALL OP2ToOP1
noArgumentReturn:
       set 0,(iy+7)
       call BRKInc
       jr parseLoop
isI:   B_CALL COP1Set0
       ld a,10h
       ld (OP2+2),a
       jr noArgumentReturn
isPi:  ld a,4
       B_CALL GETCONOP1
       jr noArgumentReturn
isRand:
       call PeekOPSByte
       cp 4
       jr z,$F
       B_CALL Random
       jr noArgumentReturn
$$:    call GetByteMaybeDelimiter
       jr z,$F
       call GetNextParseByte
       B_JUMP ErrSyntax
$$:    call GetOPSByte
       B_CALL PopRealO1
       B_CALL StoRand
       jr noArgumentReturn
ErrInvalidIfProgrammingToken:
       bit 1,(iy+8)
       ret nz
       B_JUMP ErrInvalid
encounteredQuote:
;TODO: finish this
       bit numOP1,(iy+ParsFlag2)
       jr nz,errSyntax
       ld bc,(nextParseByte)
       ld a,(nextParseBytePage)
       push af
       push bc
$$:    call parseQuotedStringLimit
       pop de
       pop bc
       push af
       ld (nextParseByte),de
       ld a,b
       ld (nextParseBytePage),a
       ld a,(nextParseBytePageTemp)
       ;BDE contains start of string
       ;AHL contains end of string
;       ld c,a
;       ld a,b
;       ld b,c
;       ex de,hl
       call AHL_minus_BDE
       push bc
       push bc
       pop hl
       B_CALL CreateTempString
       inc de
       inc de
       pop bc
       ld a,b
       or c
       jr z,$F
copyStringLoop:
       push bc
       push de
;       call GetCurrentParseByte ;this gets the current byte
;       push af
       call GetNextParseByte ;this is just for incrementing the pointer
;       pop af
       pop de
       ld (de),a
       inc de
       pop bc
       dec bc
       ld a,b
       or c
       jr nz,copyStringLoop
$$:    B_CALL OP4ToOP1
       pop af
       cp 2Ah
       set 0,(iy+7)
       jr z,$F
       call GetNextParseByte
       jr parseLoopGetByte
$$:    call BRKInc
       jr parseLoop
parseQuotedStringLimit:
       ld b,1
       jr $F
parseQuotedStringNoLimit:
       ld b,0
;This routine needs to return the end of the string in (nextParseByteTemp):HL and ending char in A
;nextParseByte/nextParseBytePage can be used as scratch space since they are backed up before calling this
$$:    ld de,0
       push bc
quoteStringParseLoop:
       call PeekNextParseByte
       cp 3Eh
       jr nz,$F
       pop hl
       push hl
       rl h
       jr c,scfRet0
       jr z,scfOrAret
       jr quoteStringContinue
$$:    call IsEndOfLine
       jr z,scfRet0
       cp 4
       jr z,scfRet
       cp 2Ah
       jr nz,quoteStringContinue
       pop hl
       push hl
       rl h
       jr c,$F
       jr nz,scfOrAret
$$:    call GetNextParseByte ;this is for incrementing nextParseByte/nextParseBytePage
       call SkipPastQuoteString
       B_CALL CKENDEXP
       jr nz,quoteStringParseLoop
       jr scfRet0
quoteStringContinue:
       push af
       call GetNextParseByte ;this is for incrementing nextParseByte/nextParseBytePage
       pop af
       cp 0BBh
       jr nz,notBBhToken
       call GetNextParseByte
       cp 20h
       jr c,incD
       cp 25h
       jr c,quoteStringParseLoop
       cp 2Fh
       jr c,incD
       cp 35h
       jr c,quoteStringParseLoop
       cp 3Ch
       jr c,incD
       cp 42h
       jr c,$F
       cp 48h
       jr c,incD
$$:    ld hl,stringEnderTable
       push bc
       ld bc,10
       cpir
       pop bc
       jr nz,quoteStringParseLoop
       jr incD
notBBhToken:
       cp 0EFh
       jr nz,notEFhToken
       call GetNextParseByte
       cp 13h
       jr z,incD
       cp 9
       jr c,incD
       jr quoteStringParseLoop
notEFhToken:
       cp 0B1h
       jr c,$F
       cp 0CEh
       jr z,incD
$$:    cp 12h
       jr c,$F
       cp 29h
       jr c,incD
       cp 9Eh
       jr c,$F
       cp 0A6h
       jr c,$F
$$:    ld hl,stringEnderTable2
       push bc
       ld bc,18
       cpir
       pop bc
       jr nz,parseContinue2
incD:  ld a,e
       or a
       jr nz,$F
       inc d
$$:    jr quoteStringParseLoop
parseContinue2:
       B_CALL isA2ByteTok
       jr nz,$F
       call GetNextParseByte
       call GetNextParseByte
       jr $B
$$:    pop hl
       push hl
       or a
       rl h
       jr c,$F
       jr nz,quoteStringParseLoop
$$:    cp 11h
       jr nz,$F
       ld a,e
       or a
       jr nz,quoteStringParseLoop
       dec d
       jp m,scfRet
$$:    cp 6
       jr z,$F
       cp 8
       jr nz,parseContinue3
$$:    inc e
       jr quoteStringParseLoop
parseContinue3:
       cp 7
       jr z,$F
       cp 9
       jr nz,parseContinue4
$$:    ld a,e
       or a
       jr z,quoteStringParseLoop
       dec e
       jr quoteStringParseLoop
parseContinue4:
       pop hl
       push hl
       rl h
       jr c,quoteStringParseLoop
       cp 2Bh
       jr nz,quoteStringParseLoop
       ld a,d
       or e
       jr nz,quoteStringParseLoop
parseReturn:
       pop hl
       push af
       ld a,(nextParseBytePage)
       ld (nextParseBytePageTemp),a
       ld hl,(nextParseByte)
       pop af
       ret
scfRet0:
       xor a
scfOrAret:
       or a
scfRet:
       scf
       jr parseReturn
SkipPastQuoteString:
       call GetNextParseByte
       ret c
       B_CALL isA2ByteTok
       jr nz,$F
       call GetNextParseByte
       jr SkipPastQuoteString
$$:    cp 2Ah
       ret z
       cp 3Fh
       ret z
       jr SkipPastQuoteString
stringEnderTable2:
       DB 10h,0DAh,0DBh,9Ch,93h,0A7h,0D2h,0D3h,0E0h,0E2h,0E3h,0E4h,0E6h,0E7h,0E8h,0ECh,0EDh,0EEh
stringEnderTable:
       DB 3Dh,3Eh,3Fh,40h,49h,53h,55h,56h,58h,59h
letterOrVarTokenEncountered:
       push af
       call MaybePushMultiplyOperator
       pop af
       push af
       cp 5Fh
       jr z,isPrgmToken
       cp 0EBh
       jr z,isListNameToken
       call isAValidChar
       jr c,invalidChar
       call PeekOPSByte
       cp 4
       jr nz,notList
       B_CALL CpyTo2FPST
       ld a,(OP2)
       and 1Fh
       cp 4
       jr z,$F
       B_CALL IS_A_LSTorCLST
       jr nz,notList
$$:    call DecNextParseByte
       jr isListNameToken
notList:
       pop af
       push af
invalidChar:
       call TryRealName
       pop af
       push af
       cp 62h
       jr c,normalVarName
       jr z,istVarOut
       cp 0AAh
       jr z,normalVarName
       cp 72h
       jr nz,isSpecialName
       bit 1,(iy+graphFlags)
       jr z,normalVarName
errInvalid:
       B_JUMP ErrInvalid
isSpecialName:
       ld a,(OP1+2)
       cp 6
       jr z,errInvalid
       cp 7
       jr z,errInvalid
       cp 41h
       jr z,doNameCopy
       cp 40h
       jr z,pushFPSTSto
       bit 1,(iy+graphFlags)
       call nz,ValidateGraphName
       B_CALL VARSYSADR
       ld (OP1),a
       ld (chkDelPtr3),de
       ld (chkDelPtr1),hl
       jr letterOrVarTokenContinue
istVarOut:
       ld a,(OP1+2)
       cp 21h
       jr z,normalVarName
       pop hl
       call CMP_STATPTR_Err
       bit 1,(iy+graphFlags)
       jr z,$F
       set 6,(hl)
$$:    rst 20h
       B_CALL CkOP1Real
       cp 0Eh
       jr z,errUndefined
       set 0,(iy+7)
       call BRKInc
       jr parseLoop
CMP_STATPTR_Err:
       bit 6,(iy+9)
       jr z,errUndefined
       cp 5Ch
       jr nz,$F
       ld hl,8D0Dh
$$:    ld l,a
       ld h,0
       B_CALL HLTimes9
       ld de,8A28h
       add hl,de
       ret
errUndefined:
       B_JUMP ErrUndefined
isListNameToken:
       pop af
       ld a,5Dh
       push af
       call parseListNameToOP1
normalVarName:
       pop af
       push af
       ld a,0FFh
       ld (OP1),a
$$:    call FindSymNoArc
       jr nc,varExists
       ld a,(OP1+1)
       call isAValidChar
       jr c,varExists
       call CreateOP1Real0
       jr $B
varExists:
       push af
       ld a,b
       ld (9CCEh),a
       pop af
       ld (chkDelPtr3),hl
       ld (chkDelPtr1),de
       B_CALL OP1ToOP4
       bit 3,(iy+3)
       jr z,letterOrVarTokenContinue
       cp 59h
       jr nz,letterOrVarTokenContinue
       B_JUMP ErrInvalid
isPrgmToken:
       call getCharZeroOP1
       ld (hl),5
       ld b,9
       call parseName
letterOrVarTokenContinue:
       call ValidateGraphModeName
       call PeekOPSByte
       cp 4
       jr z,letterNextByteIsSto ;storing to variables actually happens here
       or a
       jr nz,letterStillGood
       call ZIfParseVarIsProgram
       jr nz,letterStillGood
       B_CALL CkOP1Real
       cp 5
       jr z,nameIsProgram
       cp 6
       jr z,nameIsProgram
letterStillGood:
       ld a,(OP1)
       cp 0FFh
       jr z,errUndefined
       call ZIfOP1NamedType
       jr z,errDataType
       bit 1,(iy+graphFlags)
       jr z,$F
       ld hl,(chkDelPtr3)
       set 6,(hl)
$$:    B_CALL equ_or_newequ
       pop hl
       jr nz,notEquation
       bit 2,(iy+17h)
       jr z,$F
       bit grfRecurM,(iy+grfModeFlags)
       jr z,$F
       call IsEquName
       jr nc,$F
       ld a,(OP1+2)
       bit 7,a
       jr nz,errInvalid
$$:    call PeekNextParseByte
       cp 10h
       jr nz,$F
       call GetNextParseByte
       ld a,26h
       call PushMathOPS
       rst rFINDSYM
       call BRKInc
       jr parseLoop
       call GetNextParseByte
       B_CALL ZeroOP1
       jr parseLoop
notEquation:
       set 0,(iy+7)
       B_CALL CkOP1Real
       jr z,letterIsNum
       cp 4
       jr nz,$F
       call BRKInc
       jr parseLoop
$$:    cp 0Ch
       jr z,letterIsNum
       B_CALL ISO1NONTEMPLST
       jr nz,$F
       ld hl,(chkDelPtr3)
       call 0 ;TODO: FIX THIS
$$:    B_CALL CkOP1Real
       cp 3
       jr c,equOrCplxList
       cp 0Dh
       jr z,equOrCplxList
       B_JUMP ErrDataType
letterIsNum:
       ld a,(9CCEh)
       ld b,a
       ld hl,(chkDelPtr3)
       ld de,(chkDelPtr1)
       B_CALL RclVarSym ;what's the problem with using this directly?
       call BRKInc
       jr parseLoop
equOrCplxList:
       call PeekNextParseByte
       cp 10h
       jr nz,0 ;TODO: FIX THIS
       call GetNextParseByte
PUSHSPACE:
       ld d,29h
       call PUSHNUM
       call BRKInc
       jr parseLoop
nameIsProgram:
       pop hl
       call GetByteMaybeDelimiter
       jr nz,errSyntax
       bit 1,(iy+8)
       jr nz,$F
       xor a
       ld (9B80h),a
       ld (9B81h),a
       ld (9B82h),a
       set 1,(iy+8)
       call InitPFlagsParseInpGraph
       res 1,(iy+8)
       call BRKInc
       jr parseLoop
$$:    call InitPFlagsParseInpGraph
checkBreakParseNext:
       call BRKInc
       jr parseLoop
letterNextByteIsSto:
       call GetByteMaybeDelimiter
       jr z,stoIsDelimiter
       call GetNextParseByte
       cp 10h
       jr nz,errSyntax
       ld a,(OP1)
       call ErrDataTypeIfANotTypicalValue
       pop af
       ld (OP1),a
       cp 5Dh
       jr z,PUSHSPACE
       cp 5Ch
       jr z,PUSHSPACE
       cp 63h
       jr nz,$F
       ld a,(OP1+2)
       cp 1Ah
       jr z,PUSHSPACE
$$:    B_JUMP ErrDataType
stoIsDelimiter:
       call GetOPSByte
       pop bc
       ld a,(OP1+1)
       cp 62h
       ld a,b
       jr nz,nottVarOut
       B_CALL CpyTo1FPST
       B_CALL ErrD_OP1NotPosInt
       B_CALL EOP1NotReal
       B_CALL RECURNNAME
       B_CALL StoOther
       bit 5,(iy+7)
       jr nz,$F
       bit 2,(iy+2)
       jr nz,$F
       bit 1,(iy+3)
       jr nz,$F
       bit 0,(iy+2)
       jr nz,$F
       bit 7,(iy+2)
       jr z,$F
       B_CALL SetTblGraphDraw
       jr $F
nottVarOut:
       B_CALL StoOther ;what's the problem with using this directly?
$$:    B_CALL CkOP1Real
       B_CALL equ_or_newequ
       jr z,checkBreakParseNext
       set 0,(iy+7)
       jr checkBreakParseNext
ErrDataTypeIfANotTypicalValue:
       cp 0FFh
       ret z
       and 0Fh
       cp 5
       ret c
       cp 0Eh
       jr nc,$F
       cp 0Bh
       ret nc
$$:    B_JUMP ErrDataType
PushMathOPS:
       push af
       call MaybePushMultiplyOperator
       pop af
       push af
       call MaybeInc9665h
       jr PUSHNUMFINISH
MaybeInc9665h:
       ld hl,incTable
       ld bc,15
       cpir
       ret nz
Inc9665h:
       ld hl,(9665h)
       inc hl
       ld (9665h),hl
       ret
incTable:
       DB 19h,1Ah,0B6h,0B7h,0E3h,0E4h,0B5h,21h,1Fh,0CEh,0CFh,0DBh,0DCh,8Dh,90h
IsEquName:
       ld a,(OP1+1)
       cp 5Eh
       scf
       ret z
       xor a
       ret
errDataType:
       B_JUMP ErrDataType
ZIfOP1NamedType:
       ld a,(OP1)
       and 1Fh
       cp 15h
       ret z
       cp 17h
       ret z
       cp 5
       ret z
       cp 16h
       ret z
       cp 6
       ret
ValidateGraphModeName:
       bit 1,(iy+graphFlags)
       ret z
       ld a,(OP1+1)
       cp 63h
       jr nz,$F
       ld a,(OP1+2)
       cp 2Ah
       jr z,errInvalid
       ret
$$:    bit grfFuncM,(iy+grfModeFlags)
       jr nz,$F
       cp 58h
       jr z,errInvalid
       bit 5,(iy+2)
       jr z,$F
       cp 52h
       jr z,errInvalid
$$:    cp 59h
       ret nz
       jr errInvalid
parseListNameToOP1:
       call getCharZeroOP1
       ld (hl),1
       inc hl
       ld (hl),5Dh
       ld b,6
parseName:
       push hl
       push bc
       call GetByteMaybeDelimiter
       jr z,parseNameDone
       call isAValidChar
       jr nc,parseNameNumber
       cp 30h
       jr nc,parseNameAtLeastNumber
isADelimiter:
       jr parseNameDone
parseNameAtLeastNumber:
       cp 3Ah
       jr nc,isADelimiter
parseNameNumber:
       call GetNextParseByte
       pop bc
       pop hl
       inc hl
       ld (hl),a
       djnz parseName
       B_JUMP ErrSyntax
parseNameDone:
       pop bc
       pop hl
       ret
getCharZeroOP1:
       call PeekNextParseByte
       call isAValidChar
       jr c,errSyntax
       B_CALL ZeroOP1
       ld hl,OP1
       ret
ValidateGraphName:
       ld a,(OP1+2)
       cp 0Ah
       jr z,$F
       cp 0Bh
       jr z,$F
       cp 1Ah
       ret nz
$$:    B_JUMP ErrInvalid
FindSymNoArc;
       B_CALL FindSym
       ret c
       ;HACK: don't choke if we're a program
       ;Not sure what I was thinking here...
       ld a,(OP1)
       and 1Fh
       cp 05h
       ret z
       cp 06h
       ret z
       cp 16h
       ret z
       ld a,b
       or a
       ret z
errArchived:
       ld a,0AFh
       B_JUMP JError
TryRealName:
       push af
       B_CALL ZeroOP1
       pop af
       ld (OP1+1),a
       cp 72h
       jr z,GetByteMaybeDelimiter
       cp 41h
       jr c,errSyntax
       cp 5Ch
       jr c,GetByteMaybeDelimiter
       cp 0AAh
       jr z,$F
       cp 64h
       jr nc,errSyntax
$$:    call GetNextParseByte
       ld (OP1+2),a
GetByteMaybeDelimiter:
       call PeekNextParseByte
       B_CALL CKENDEXP
       ret
isAValidChar:
       cp 41h
       ret c
       cp 5Ch
       ccf
       ret
CreateOP1Real0:
       B_CALL CreateReal
       B_CALL OP1Set0
       B_CALL MovFrOP1
       B_CALL OP4ToOP1
       ret
doNameCopy:
       pop af
       ld b,5
       ld de,OP1
$$:    push bc
       push de
       call GetNextParseByte
       pop de
       pop bc
       ld (de),a
       inc de
       djnz $B
       call DecNextParseByte
       ld hl,(OP1+1)
       ld (9810h),hl
       ld hl,(OP1+3)
       ld (980Eh),hl
       call BRKInc
       jr parseLoop
pushFPSTSto:
       pop af
       B_CALL PopRealO3
       B_CALL popOP1
       B_CALL PushRealO3
       ld d,4
       call PUSHNUM
       call BRKInc
       jr parseLoop
encounteredHardCodedNumber:
       B_CALL ZeroOP1
       call MaybePushMultiplyOperator
       call ParseNumberStringToOP1Value
       call GetCurrentParseByte
       cp 0Bh
       jr nz,numberReturn
       ld hl,(nextParseByte)
       ld a,(nextParseBytePage)
       push af
       push hl
       call IsNextParseByteNumberToken
       pop hl
       pop bc
       jr nc,isNumberToken
       ld a,b
       ld (nextParseBytePage),a
       ld (nextParseByte),hl
numberReturn:
       set 0,(iy+7)
       jr parseLoopGetByte
isNumberToken:
       B_CALL OP1ToOP6
       call ParseNumberStringToOP1Value
       call GetCurrentParseByte
       cp 0AEh
       jr z,$F
       B_JUMP ErrSyntax
$$:    call OP2Set60
       B_CALL fpdiv
       B_CALL OP6ToOP2
       rst rFPADD
       call IsNextParseByteNumberToken
       jr c,numberReturn
       B_CALL OP1ToOP6
       call ParseNumberStringToOP1Value
       call OP2Set60
       inc (hl)
       inc (hl)
       ld a,36h
       ld (OP2+2),a
       B_CALL fpdiv
       B_CALL OP6ToOP2
       rst rFPADD
       call GetCurrentParseByte
       cp 2Ah
       jr z,$F
       B_JUMP ErrSyntax
$$:    set 0,(iy+7)
       call BRKInc
       jr parseLoop
ParseNumberStringToOP1Value:
       B_CALL OP1Set0
       B_CALL DecO1Exp
       ld c,0
       ld b,3
       push bc
       call GetCurrentParseByte
       cp 3Bh
       jr z,isEEToken
numberParseLoop:
       pop bc
       cp 0B0h
       jr z,negativeSign
       cp 3Ah
       jr z,decimalPoint
       cp 3Bh
       jr z,isEETokenAgain
       jr nc,notNumberToken
       cp 30h
       jr c,notNumberToken
       bit 5,c
       jr nz,significantDigitsStuff
       set 3,c
       cp 30h
       jr z,numberIsZero
       set 7,c
$$:    push bc
       call GetDigit
doNumberParseLoop:
       call BRKInc
       jr numberParseLoop
numberIsZero:
       bit 7,c
       jr nz,$B
       bit 6,c
       jr z,restartNumberParseLoop
       B_CALL DecO1Exp
       jp p,restartNumberParseLoop
       B_JUMP ErrSyntax
decimalPoint:
       bit 6,c
       jr z,$F
numberParseErrSyntax:
       B_JUMP ErrSyntax
$$:    bit 5,c
       jr nz,numberParseErrSyntax
       set 6,c
       jr restartNumberParseLoop
negativeSign:
       bit 5,c
       jr z,numberParseErrSyntax
       ld a,b
       cp 3
       jr nz,numberParseErrSyntax
       ld a,c
       xor 10h
       ld c,a
restartNumberParseLoop:
       push bc
       jr doNumberParseLoop
isEEToken:
       pop bc
       push bc
       call GetDigit1
       pop bc
       set 7,c
       set 3,c
isEETokenAgain:
       ld hl,0
       ld (OP2),hl
       bit 5,c
       jr nz,numberParseErrSyntax
       bit 3,c
       jr z,numberParseErrSyntax
       set 5,c
       jr restartNumberParseLoop
significantDigitsStuff:
       ld hl,OP2+1
       rld
       djnz restartNumberParseLoop
$$:    B_JUMP ErrSyntax
notNumberToken:
       bit 5,c
       jr z,doneMakeReal
       ld a,b
       cp 3
       jr z,$B
       bit 7,c
       jr z,doneMakeReal
       push bc
       ld hl,OP2+1
       call AlterSigDigits
       pop bc
       ld a,(OP1+1)
       bit 4,c
       jr nz,zeroToOP1
       add a,e
       jr nc,$F
       B_JUMP ErrOverflow
$$:    ld (OP1+1),a
doneMakeReal:
       bit 3,c
       jr z,numberParseErrSyntax
       ld hl,OP1
       ld a,(hl)
       and 0E0h
       ld (hl),a
       B_CALL CkValidNum
       ret
zeroToOP1:
       sub e
       jr nc,$B
       B_CALL OP1Set0
       ret
GetDigit1:
       ld a,31h
GetDigit:
       push bc
       and 0Fh
       ld b,a
       ld hl,OP1
       ld a,(hl)
       bit 4,a
       jr nz,$F
       and 0Fh
       inc (hl)
       ld c,a
       ld a,b
       ld b,0
       ld hl,OP1+2
       srl c
       jr c,GetDigitNoShift
       B_CALL ShLAcc
GetDigitNoShift:
       add hl,bc
       add a,(hl)
       ld (hl),a
$$:    pop bc
       bit 6,c
       ret nz
       B_CALL INCO1EXP
       ret
AlterSigDigits:
       ex de,hl
       ld a,(de)
       and 0Fh
       ld l,a
       ld h,0
       ld c,10
       ld b,h
       call CalculateCount
       dec de
       ld a,(de)
       ld c,100
       and 0Fh
       call BCtimesAplusHL
       ld bc,1000
       call CalculateCount
       ex de,hl
       ld (hl),d
       inc hl
       ld (hl),e
       ld a,e
       ret
CalculateCount:
       ld a,(de)
       B_CALL ShRAcc
BCtimesAplusHL:
       dec a
       ret m
       add hl,bc
       jr BCtimesAplusHL
IsNextParseByteNumberToken:
       call GetNextParseByte
       cp 30h
       ret c
       cp 3Ch
       ccf
       ret
encounteredSto:
       call ZIfParseVarIsProgram
       jr z,$F
       B_JUMP ErrSyntax
$$:    call PeekNextParseByte
       cp 0B5h
       jr z,$F
       cp 0ABh
       jr z,$F
       cp 0EBh
       jr z,$F
       cp 41h
       ld bc,1
       jr c,invalidStoToken
       cp 62h
       jr nz,possiblyValidStoToken
       call PeekSecondParseByte
       cp 21h
       jr z,$F
       ld bc,2
invalidStoToken:
       ld hl,(nextParseByte)
       ld a,(nextParseBytePage)
       add hl,bc
       ld b,a
       ld a,(9CCDh)
       or a
       ld a,b
       jr z,noStoOverflow
       bit 7,h
       jr z,noStoOverflow
       inc a
       res 7,h
       set 6,h
noStoOverflow:
       ld (nextParseByte),hl
       ld (nextParseBytePage),a
       B_JUMP ErrSyntax
possiblyValidStoToken:
       cp 0AAh
       jr z,$F
       cp 64h
       jr c,$F
       jr invalidStoToken
$$:    ld a,4
EvaluateOPSTokenResumeParse:
       call EvaluateOPSToken
       ei
       call BRKInc
       jr parseLoop
encounteredColonChar:
       call ZIfParseVarIsProgram
       jr z,endOfLineReached
       B_JUMP ErrSyntax
endOfLineReached:
       xor a
       call EvaluateOPSToken
       ei
       call GetOPSByte
       call ZIfParseVarIsProgram
       jr nz,$F
       bit numOP1,(iy+ParsFlag2)
       jr z,$F
       B_CALL StoAns
$$:    call BRKInc
       or a
       jr nz,continueParse
stopParsingVariable:
       call GetOPSWord
       push bc
       call ZIfAtExitPoint
       ret z
       call GetOPSWord
       pop hl
       xor a
       call JpHL
       call GetOPSByte
       jr stopParsingVariable
JpHL:  jp (hl)
continueParse:
       call CopyFmtFlags
       ld de,(cleanTmp)
       B_CALL FixTempCnt
       jr MasterParseLoop
CopyFmtFlags:
       ld a,(iy+numMode)
       ld (iy+fmtOverride),a
ZIfAtExitPoint:
       ld hl,parseInpReturnPoint
       or a
       sbc hl,bc
       ret z
       add hl,bc
       ld hl,parseInpGraphReturnPoint
       or a
       sbc hl,bc
       ret
IsEndOfLine:
       or a
       ret z
       cp 3Fh
       ret
parseInpReturnPoint:
       call GetOPSWord
       push bc
       call GetOPSWord
       push bc
parseInpGraphReturnPoint:
       call GetOPSWord
       push bc
       B_CALL PopRealO3
       B_CALL PushOP1
       B_CALL OP3ToOP1
       ;Restore prog data
       call GetOPSWord ;this is the address
       call GetOPSByte
       ld (9CCDh),a
       ld a,(OP1+1)
       or a
       jr z,OP1toParseVar
       push bc
       B_CALL ChkFindSym
       ld a,b
       or a
       jr z,$F
       ;Archived variable, get BDE to the real variable data instead
       ex de,hl
       ld de,3
       call BHL_plus_DE
       push bc
       push hl
       call GetSymEntryLength
       pop hl
       pop bc
       call BHL_plus_DE
       or a
$$:    ex de,hl
       pop de
       jr nc,$F
       xor a
       ld (OP1+1),a
       jr OP1toParseVar
$$:    push de
       call GetVariableStartSize
       ld a,e
       pop de
       ;At this point, AHL is the start of the variable data
       ;DE is the offset from there to start picking up parsing
       ;BC is the size of the variable
       ld (basic_start),hl
       ld (basic_start_page),a
       push af
       push hl
       add hl,de
       ld d,a
       ld a,(9CCDh)
       or a
       ld a,d
       jr z,$F
       bit 7,h
       jr z,$F
       inc a
       res 7,h
       set 6,h
$$:    ld (nextParseByte),hl
       ld (nextParseBytePage),a
       pop hl
       pop af
       add hl,bc
       ld d,a
       ld a,(9CCDh)
       or a
       ld a,d
       jr z,$F
       bit 7,h
       jr z,$F
       inc a
       res 7,h
       set 6,h
$$:    ld (basic_end),hl
       ld (basic_end_page),a
OP1toParseVar:
       ld de,basic_prog
       B_CALL MovFrOP1
       B_CALL popOP1
       ret

PeekSecondParseByte:
       ld de,(nextParseByte)
       ld a,(nextParseBytePage)
       ld b,a
       inc de
       inc de
       jr $F
PeekNextParseByte:
       ld a,(9CCDh)
       or a
       ld de,(nextParseByte)
       ld a,(nextParseBytePage)
       ld b,a
       inc de
       jr z,GetParseByte
$$:    bit 7,d
       jr z,GetParseByte
       inc b
       res 7,d
       set 6,d
       jr GetParseByte
BRKInc:
       B_CALL CHKERRBREAK
GetNextParseByte:
       ld (tempWord),de
       ld a,(9CCDh)
       or a
       ld hl,(nextParseByte)
       ld a,(nextParseBytePage)
       ld (backupNextParseByte),hl
       ld (backupNextParseBytePage),a
       inc hl
       jr z,$F
       bit 7,h
       jr z,$F
       res 7,h
       set 6,h
       inc a
$$:    ld (nextParseByte),hl
       ld (nextParseBytePage),a
GetCurrentParseByte:
       ld (tempWord),de
       ld de,(nextParseByte)
       ld a,(nextParseBytePage)
       ld b,a
GetParseByte:
       ld hl,(basic_end)
       ld a,(basic_end_page)
       call compareAHL_BDE
       ld a,0 ;ew
       ret c
GetDataByte:
       ex de,hl
       ld a,b
       ld b,(hl)
       bit 7,h
       jr nz,$F
       B_CALL GetBytePaged
$$:    ld a,b
       ld de,(tempWord)
       ret
DecNextParseByte:
       ld hl,(backupNextParseByte)
       ld a,(backupNextParseBytePage)
       ld (nextParseByte),hl
       ld (nextParseBytePage),a
       ret

SetupBasicProg:
       B_CALL ChkFindSym
       jr nc,$F
       B_JUMP ErrUndefined
$$:    ld a,b
       or a
       jr z,$F
       ;Archived variable, get BDE to the real variable data instead
       ex de,hl
       ld de,3
       call BHL_plus_DE
       push bc
       push hl
       call GetSymEntryLength
       pop hl
       pop bc
       call BHL_plus_DE
       ex de,hl
$$:    push bc
       ld (chkDelPtr1),de
       push af
       call PushPrevProgData
       pop af
       ld hl,(chkDelPtr1)
       pop bc
       call GetVariableStartSize
       ld a,e
       ld (basic_start),hl
       ld (basic_start_page),a
       ld (nextParseByte),hl
       ld (nextParseBytePage),a
       add hl,bc
       inc bc
       ld d,a
       ld a,b
       or c
       ld a,d
       jr nz,$F
       ld hl,(nextParseByte)
       dec hl
$$:    or a
       jr z,$F
       ld d,a
       ld a,(9CCDh)
       or a
       ld a,d
       jr z,$F
       bit 7,h
       jr z,$F
       inc a
       res 7,h
       set 6,h
$$:    ld (basic_end),hl
       ld (basic_end_page),a
       ld de,basic_prog
       B_CALL MovFrOP1
       ret

PushPrevProgData:
       ld a,(9CCDh)
       call PushByteOPS
       ld hl,(nextParseByte)
       ld de,(basic_start)
       ld a,(basic_start_page)
       ld b,a
       ld a,(nextParseBytePage)
       call AHL_minus_BDE
       call PushWordOPS
       ld hl,basic_prog
       B_CALL PushReal
       ret

AHL_minus_BDE:
       call compareAHL_BDE
       jr nz,$F
       ld bc,0
       ret
$$:    ret c ;if BDE > AHL, something ain't right
       ld ix,0
       ;Swap AHL/BDE
       ld c,a
       ld a,b
       ld b,c
       ex de,hl
       ;Keep increasing AHL (really BDE) until they're equal
$$:    call AHL_plus_1
       call compareAHL_BDE
       ccf
       inc ix
       jr z,$F
       jr nc,$B
       dec ix
$$:    push ix
       pop bc
       ret
AHL_plus_1:
       inc hl
       bit inRAM,(iy+proggerFlags)
       ret nz
       bit 7,h
       ret z
       inc a
       res 7,h
       set 6,h
       ret
BHL_plus_DE:
       add hl,de
       bit inRAM,(iy+proggerFlags)
       ret nz
       bit 7,h
       ret z
       inc b
       res 7,h
       set 6,h
       ret
compareAHL_BDE:
;Returns carry if BDE > AHL
       cp b
       ret c
       ret nz
       or a
       push hl
       sbc hl,de
       pop hl
       ret

GetSymEntryLength:
       B_CALL CMPPRGNAMLEN
       add a,7
       ld d,0
       ld e,a
       call isOP1NamedType
       ret z
       ld a,(OP1+1)
       cp 5Dh
       ret z
       ld e,9
       ret
isOP1NamedType:
       ld a,(OP1)
       and 1Fh
       cp 15h
       ret z
       cp 17h
       ret z
       cp 5
       ret z
       cp 16h
       ret z
       cp 6
       ret
       
GetVariableStartSize:
       push af
       ld a,b
       ld (9CCDh),a
       or a
       set inRAM,(iy+proggerFlags)
       jr z,$F
       res inRAM,(iy+proggerFlags)
$$:    ld e,a
       ld b,(hl)
       bit 7,h
       jr nz,$F
       B_CALL GetBytePaged
$$:    ld d,b
       inc hl
       ld a,e
       or a
       jr z,$F
       bit 7,h
       jr z,$F
       inc e
       res 7,h
       set 6,h
$$:    ld a,(9CCDh)
       ld b,(hl)
       bit 7,h
       jr nz,$F
       B_CALL GetBytePaged
$$:    ld c,d
       dec bc
       inc hl
       ld a,e
       or a
       jr z,$F
       bit 7,h
       jr z,$F
       inc e
       res 7,h
       set 6,h
$$:    pop af
       and 0Fh
       call ZIfProgram
       ret z
       ld a,(OP1+1)
       cp 24h
       ret nz
       inc hl
       ld a,e
       or a
       jr z,$F
       bit 7,h
       jr z,$F
       inc e
       res 7,h
       set 6,h
$$:    dec bc
       push bc
       ld a,(9CCDh)
       ld b,(hl)
       bit 7,h
       jr nz,$F
       B_CALL GetBytePaged
$$:    ld a,b
       pop bc
       or a
       jr z,equByteZero
       add a,3
$$:    inc hl
       ld a,e
       or a
       jr z,incPage
       bit 7,h
       jr z,incPage
       res 7,h
       set 6,h
incPage:
       dec bc
       dec a
       jr nz,$B
       ret
equByteZero:
       inc hl
       ld a,e
       or a
       jr z,$F
       bit 7,h
       jr z,$F
       res 7,h
       set 6,h
       inc e
$$:    dec bc
       ret

ZIfParseVarIsProgram:
       ld a,(basic_prog)
       and 0Fh
ZIfProgram:
       cp 05h
       ret z
       cp 16h
       ret z
       cp 6
       ret

PushByteOPS:
       push af
       ld hl,1
       B_CALL EnoughMem
       jr nc,$F
       B_CALL ErrMemory
$$:    pop af
       ld hl,(OPS)
       ld (hl),a
pushOPSret:
       dec hl
saveOPS:
       ld (OPS),hl
       ret
PeekOPSByte:
       ld hl,(OPS)
       inc hl
       ld a,(hl)
       ret
PeekOPSByteFromWord:
       ld hl,(OPS)
       inc hl
       inc hl
       ld a,(hl)
       ret
GetOPSByte:
       ld hl,(OPS)
       inc hl
       ld a,(hl)
       jr saveOPS
GetOPSWord:
       ld hl,(OPS)
       inc hl
       ld c,(hl)
       inc hl
       ld b,(hl)
       jr saveOPS
PushWordOPS:
       push bc
       ld hl,2
       B_CALL EnoughMem
       jr nc,$F
       B_CALL ErrMemory
$$:    pop bc
       ld hl,(OPS)
       ld (hl),b
       dec hl
       ld (hl),c
       jr pushOPSret