Looking good Xeda

From a conversation on IRC it's due to searching through the VAT in reverse. I believe @Runer112 had some suggestions on how to speed it up though.

I'm too tired for a full report, but I'll use this as a backup.
I fixed a few bugs introduced in the last version, optimized and cleaned up some more code, and most importantly, I totally overhauled the module system. I renamed the token to just '$'. By storing to it, you can basically register a module to be searched after the default one is searched. At the moment, up to 5 additional modules can be used, which could greatly extend the functionality of Grammer. They can be archived now, and I moved the Menu routine to an external module (appv Grampkg). I still need to do a lot of documentation, but not tonight. Attached is a screenshot of what the code looks like (with the token hook). Good night y'all.

Grammer has a few new commands since the last update.

• G-T returns the address of the default front buffer.
• G-T' returns the address of the AppBackUpScreen, a typical back buffer.
• Else is finally back to being supported.
• →. will write four bytes from one pointer to another. This is intended for single-precision floats
• Text(0,0,.A allows you to print the float pointed to by A.
• A+.B adds two floats pointed to by A and B
• A-.B subtractss two floats pointed to by A and B
• A*.B multiplies two floats pointed to by A and B
• A/.B divides two floats pointed to by A and B
• √(.A calculates the square root of the float pointed to by A.

So an example program using the GFLOAT module to get the pi and e constants:
.0:Return
ClrDraw
ClrHome
"5GFLOAT→$
π8800→X+4→Y
$π→.X
$e→.Y
For(A,0,7
√(.X*.Y→.X
Text(A*6,0,.X
DispGraph
End
Stop


I fixed some bugs including one with the rectangle routine, line clipping, and floating point conversion (to and from strings). There was a serious bug in the str->float routine that caused it to overwrite the source code when the integer part had an even number of digits :|

Grammer now has some basic stack support and easier parameter parsing!

To accomplish the stack routines, Grammer keeps track of three values: The stack base, the stack top, and the stack pointer. Grammer can detect overflows in either direction. I decided to make these actual variables that you can interface with via the Pmt_Bgn and Pmt_End tokens (found at the end of the Finance app). When storing to Pmt_Bgn, the stack pointer is automatically reset. Currently, the stack defaults to saveSScreen+256 and ends at saveSScreen+768, so you have 512 bytes to work with. If you want to relocate the stack, you may. For example, you could create a temp var of 10000 bytes and have a giant stack there !

To push, use Param' followed by an arbitrary number of parameters. To pop, use Param° followed by an arbitrary number of parameters that must be variable names. For example, to swap A and B, you could do:
Param'A,B
Param°A,B


The unmodified Param token also takes variable names as its input. A while back, I added the ability for subroutines to be called with arguments, kinda. In order to parse those arguments, you had to do something like:
]?→A
]?→B
]?→C
But now you can do:
ParamA,B,C


I plan to add the  ▶Nom( token to save variables and then restore them at the end of a subroutine. It is basically just an automated sequence of pushes and pops.

I forgot to upload it here!
With the recent updates to z80float, I updated the existing float routines and added in the rest.

• sin( and cos( now have range reduction!
• division now has proper underflow/overflow detection
• Fixed a bug with the logarithm routines when the input's exponent was 0 (so on [1,2])
• Added in mean( to compute the mean of two numbers.
• I switched e^( to perform exp(), not 2^x (see note below)
• Added in 10^(, tan(, sinh(, cosh(, tanh(, sin^-1(, cos^-1(, tan^-1(, sinh^-1(, cosh^-1(, tanh^-1(.

I also changed the token hook so that e^( was no longer renamed 2^(. The regular routine still performs 2^n, but the float routine will compute exp(x).

Grammer now has proper support for big sprites! With the Pt-Off( command, you can now specify a width argument and it will actually work (with proper clipping, too).

I also totally overhauled the Menu( command. On the surface, it will look largely the same, except that now it allows scrolling if their are too many elements. Internally, it requires a much smaller memory footprint and has a more powerful menu interface. To take advantage of this, I added the Menu(' command. With this one, you can supply two Grammer subroutines to compute the outputs. The syntax looks like:

Menu('"Title",y,x,height,width,GET_ELEMENT_ptr,SELECT_ELEMENT_ptr
The subroutine for GET_ELEMENT will receive the index in Ans. Return 0 if it is out-of-bounds, else return a pointer to the string to display. The subroutine for SELECT_ELEMENT will receive the index in Ans. Modify this as you want, the result will be returned as the result of the menu. 0 is returned if the menu exited due to [CLEAR] or [ON]. An example is:

Lbl "GET→A
Lbl "SEL→B
Menu('"Title",2,33,59,30,A,B→M
Text('0,0,M
Stop


.GET
→X<26
If !
End
"ITEM A→Z
int(Z+5,X+65
Z
End


.SEL
+1
End
That will display items with the name "ITEM A" through "ITEM Z".