Currently, I'm putting cached Axiom token replacements in appBackUpScreen, because I know that the OS will not touch this. Except for when you run an app, as the name suggests, but at that point you've exited the program editor. I still need to ask thepenguin77 if zStart wants this area of RAM when editing programs, in which case I should probably find another spot.

Oh sorry, I misread your post.

Basically, your standard Axiom looks like this:


.dw $C0DE
;Axiom commands go here
.dw 0


If you don't want any token replacements, you don't have to change a thing. This keeps backwards compatibility, which is always nice.
If you want token replacements, the layout extends to something like this:


.dw $C0DE
;Axiom commands go here
.dw 0
.dw $C0DE
.dw Tokens_End-Tokens
Tokens:
;For as many token replacements as you want:
.db HookLowByte, HookHighByte, StringLength, "String"
.db HookLowByte, HookHighByte, StringLength, "String"
Tokens_End:


HookLowByte and HookHighByte are different from the usual token values. To figure them out, I use a mix of this in combination with this. And StringLength is the length of the replacement ASCII string, which should not include a null terminator.

---

EDIT: Here's an example, taken from the Axiom I showed in the screenshot. It replaces GridOn with GrayOn, X₃ᴛ with Buf1, and Y₃ᴛ with Buf2.


.dw $C0DE
;Axiom commands go here
.dw 0
.dw $C0DE
.dw Tokens_End-Tokens
Tokens:
.dw 10*2+$0384
.db 6,"GrayOn"
.dw 14*2+$0220
.db 4,"Buf1"
.dw 15*2+$0220
.db 4,"Buf2"
Tokens_End:

Axe doesn't have this functionality yet, which is why I spent the time to make a prototype version that does. I haven't released it anywhere, since I think Quigibo would rather I give it to him and let him possibly tinker with it a bit and then release it officially. And existing Axioms don't have any token replacement data, so even with this new system, they will act just like they do currently. Only Axioms designed with this new system in mind will have token replacements. However, it is possible to tack on token replacement data to old Axioms if you properly resize the appvar and add in token replacement data.

Very cool!  I'd like to see that code, how you accomplished it.  And I don't mind if you show off the code here, I'm always willing to share code.  The only reason I haven't open-sourced Axe is simply because of standardization.  If other people were to modify and release the parser you could start seeing programs that each need a special version to compile and it can get annoying, these versions wouldn't get official updates either without a very active developer.  By keeping it closed, I can ensure reverse and forward-compatibility in a simple single version.  If you want to know how any chuck of the code looks though, I can always share.

Some things I'm particularly curious about:
- How do you know if the program has just been opened using only the token hook?  Would this process work during an instant scroll as well?  Even in DCS?
- What do you do (or prefer me to do) when there are more replacements than can fit in the buffer?  Especially with long names, it could only hold 80 or so max.
- Are you sure this doesn't slow down the scrolling too much with all these replacements?
- The token numbers are difficult for developers to type in manually, any ideas of how I could generate a list of equates?

Unrelated, but the other thing I realized a while ago is that its too difficult for Applications to use the framework.  All the absolute labels are in the $4000 range, and since an app is running here, I would have to generate an entirely new copy of the pseudo-lookup-table in order to change these addresses to the $8000 range.  And since space is a problem, I doubt I will be able to do that.

Sorry for the double post, but technically, this is a project update!


I fixed everything that I knew was bad about the previous version of the token hook that I posted. The updated hook is now:

• DoorsCS compatible!
• zStart compatible!
• Compatible with any Axiom name length!
• Faster!
• Smaller!
• And stronger, too!

.nolist
#include "ti83plus.inc"
.list

#define cxPrevApp cxPrev+cxCurApp-cxMain

#define p_GetArc $55E7
#define p_ReadArcApp $5658
#define p_CopyArc $568D

#define TokenHook_Temp appRawKeyHandle
#define AxiomTokens statVars
#define AxiomTokens_End curGStyle

.org $71E0


TokenHook:
.db $83
ld a,(cxCurApp)
cp kPrgmEd
ret nz
ld bc,(EditTop)
ld a,(bc)
cp tDecPt
ret nz
inc bc
ld a,(bc)
cp tDecPt
jr z,TokenHook_IsAxe
sub tA
cp tTheta-tA+1
ret nc
TokenHook_IsAxe:
push hl
ld hl,cxPrevApp
ld a,kPrgmEd
cp (hl)
jr z,TokenHook_SkipAxiomSearch
TokenHook_AxiomSearch:
ld (hl),a
push de
ld hl,AxiomTokens
ld (iy+statFlags),h
B_CALL(_BufClr)
ld hl,AxiomTokens-AxiomTokens_End
ld (TokenHook_Temp),hl
B_CALL(_IsAtTop)
push de
push hl
B_CALL(_BufToBtm)
B_CALL(_IsAtTop)
sbc hl,de
ld b,h
ld c,l
ex de,hl
call TokenHook_AxiomSearch_Loop
pop hl
ld (editTop),hl
B_CALL(_BufToTop)
pop hl
ld (editTop),hl
pop de
TokenHook_SkipAxiomSearch:
ld hl,AxeTokens
ld b,0
jr TokenHook_CompareLoop_Start
TokenHook_CompareLoop:
cp e
inc hl
jr z,TokenHook_LowByteMatch
TokenHook_NoMatch:
inc hl
ld c,(hl)
inc c
add hl,bc
TokenHook_CompareLoop_Start:
ld a,(hl)
or a
jr nz,TokenHook_CompareLoop
TokenHook_DoneNoMatch:
add hl,hl
ld hl,AxiomTokens
jr nc,TokenHook_CompareLoop_Start
pop hl
ret
TokenHook_LowByteMatch:
ld a,(hl)
cp d
jr nz,TokenHook_NoMatch
TokenHook_Match:
ld de,localTokStr
push de
ld c,17
ldir
pop hl
pop bc
ret


TokenHook_AxiomSearch_CheckHeader:
call ReadArc
inc de
add a,c
ld bc,$C0DE
sbc hl,bc
ld c,a
ret z
pop bc
TokenHook_AxiomSearch_Loop__:
pop bc
TokenHook_AxiomSearch_Loop_:
pop hl
TokenHook_AxiomSearch_Loop:
ld a,tAsmComp
cpir
ret po
push hl
dec hl
dec hl
ld a,(hl)
cp t2ByteTok
jr nz,TokenHook_AxiomSearch_Loop_
TokenHook_AxiomSearch_Backtrack:
dec hl
ld a,(hl)
cp tSpace
jr z,TokenHook_AxiomSearch_Backtrack
sub tColon
cp tEnter-tColon+1
jr nc,TokenHook_AxiomSearch_Loop_
TokenHook_AxiomSearch_FindAxiom:
pop hl
push hl
push bc
dec hl
rst 20h
ld hl,OP1
ld (hl),AppVarObj
ld a,tRParen
ld bc,10
cpir
dec hl
ld (hl),b
ld l,OP1&$FF
call p_GetArc+1
jr c,TokenHook_AxiomSearch_Loop__
TokenHook_AxiomSearch_FoundAxiom:
ex de,hl
ld c,b
call TokenHook_AxiomSearch_CheckHeader
ld b,32+1
TokenHook_AxiomSearch_ScanAxiom:
call ReadArc
inc de
ld a,h
or l
jr z,TokenHook_AxiomSearch_EndOfAxiom
add hl,de
ld de,5
add hl,de
ex de,hl
djnz TokenHook_AxiomSearch_ScanAxiom
TokenHook_AxiomSearch_EndOfAxiom:
call TokenHook_AxiomSearch_CheckHeader
call ReadArc
inc de
ld a,c
ld b,h
ld c,l
ld hl,(TokenHook_Temp)
add hl,bc
jr c,TokenHook_AxiomSearch_Loop__
ld (TokenHook_Temp),hl
sbc hl,bc
push bc
ld bc,curGStyle
add hl,bc
pop bc
ex de,hl
call p_CopyArc+5
jr TokenHook_AxiomSearch_Loop__


ReadArc:
ex de,hl
xor a
cp c
jr z,ReadArc_RAM
push bc
push hl
call p_ReadArcApp+11
pop de
inc de
pop bc
ret
ReadArc_RAM:
ld e,(hl)
inc hl
ld d,(hl)
ex de,hl
ret


AxeTokens:
.db $F4,$03,5,"Copy("
.db $FE,$03,5,"Exch("
.db $0E,$04,5,"Freq("
.db $66,$01,5,"Buff("
.db $62,$01,5,"sign{"
.db $06,$00,5,Lconvert,"Char"
.db $08,$04,4,Lconvert,"Hex"
.db $02,$04,5,"Data("
.db $4E,$01,7,"Bitmap("
.db $02,$00,4,Lconvert,"Tok"
.db $80,$04,7,"#Axiom("
.db $04,$04,5,"Rect("
.db $06,$04,6,"RectI("
.db $58,$02,3,LrecurV,"ar"
.db $5A,$02,4,"app",LrecurV
.db $5C,$02,3,"grp"
.db $F6,$01,4,"port"
.db $52,$01,5,"Text "
.db $D8,$01,8,"Pt-Mask("
.db $DA,$01,7,"pt-Get("
.db $D0,$01,3,"Get"
.db $14,$04,5,"rotC("
.db $16,$04,6,"rotCC("
.db $18,$04,6,"flipV("
.db $1A,$04,6,"flipH("
.db $C8,$03,7,"inData("
.db $B8,$01,5,"input"
.db $74,$01,6,"float{"
.db $72,$01,4,"nib{"
.db $F6,$03,9,"#Realloc("
.db $68,$01,6,"#Icon("
.db $80,$01,2,Llambda,"("
.db $38,$03,5,"Load("
.db $3A,$03,5,"Next("
.db $14,$03,7,"Render("
.db $3C,$03,6,"DrawL("
.db $3E,$03,6,"DrawR("
.db $16,$03,6,"DrawS("
.db $82,$03,6,"Print("
.db $44,$03,3,"Up("
.db $46,$03,5,"Down("
.db $5C,$03,5,"Left("
.db $40,$03,6,"Right("
.db $42,$03,4,"New("
.db $5E,$03,7,"Delete("
.db 0


Once again, great work Runer!