Axe Parser v0.4.6


Command List Index

System
Screen and Buffer
Control Blocks
Labels and Subroutines
Basic Math
Advanced Math
Drawing
Sprites
Text
Data and Storage
External Variables
Interrupts
Link Port

System
Command Description
_ Spaces are ignored in most situations. They mainly just help for code organization and readability.
: The colon and enter key end a line of code.
. The period is a single line comment. Whatever follows will be ignored until the next newline. Must be the first character on the line.
DiagnosticOn Turns on the run indicator (marching ants). Program will display "done" after finishing.
DiagnosticOff Turns off the run indicator. Program will not display "done" after finishing.
Full Full speed mode is activated if supported, making it 3 times faster on newer calculators. Returns 0 if not supported.
Normal Full speed mode is deactivated.
Pause EXP Pause for the given amount of time. A one second pause is a value of roughly 1900 at normal speed or 4700 in full speed mode.
getKey Returns the last key pressed or zero if no keys are pressed. Its just like the BASIC getkey, but with different codes.
getKey(KEY) Returns 1 if the key is held down this instant and 0 otherwise. The key code must be a single constant.
getKey(0) Returns a non-zero number if any key is held down and 0 otherwise.
Asm(HEX) Native assembly code written in hexadecimal is inserted at the current position.
Axiom(NAME)
Key: AsmComp()
The Axiom assembly library becomes useable in the program. No quotes needed, just type the name of the appvar case sensitive.
prgmNAME The code from the external program is parsed as if it completely replaced this command in the main program. (Similar to the C++ "include")

Screen and Buffer
Command Description
ClrHome Erases the screen and text shadow and moves the cursor to the upper left corner.
ClrDraw Erases the buffer.
ClrDrawr Erases the back buffer.
DispGraph Draws the buffer on the screen.
DispGraphr Draws the 2 buffers on the screen to create 3 color grayscale. Will not work in full speed mode.
DispGraphrr Draws the 2 buffers on the screen to create 4 color grayscale. Will not work in full speed mode. Cannot be used in a custom interrupt routine!
EXP→DispGraph Draws the 768 bytes of an arbitrary buffer at the pointed location onto the screen.
StoreGDB Copies the screen to the buffer.
StorePic Copies the buffer to the back-buffer.
RecallPic Copies the back-buffer to the buffer.
DrawInv The colors on the buffer are inverted.
DrawInv r The colors on the back buffer are inverted.
Horizontal +
Horizontal -
The buffer is shifted right (+) or left (-) by 1 pixel. White pixels are shifted in.
Vertical +
Vertical -
The buffer is shifted down (+) or up (-) by 1 pixel. New pixels are not shifted in, that row remains the same.
Horizontal +r
Horizontal -r
The back buffer is shifted right (+) or left (-) by 1 pixel. White pixels are shifted in.
Vertical +r
Vertical -r
The back buffer is shifted down (+) or up (-) by 1 pixel. New pixels are not shifted in, that row remains the same.
Shade(EXP) Sets the contrast. 0 is lightest, 63 is darkest.

Control Blocks
Command Description
If EXP
 code1
End
If the expression is true, code1 will be executed.
If EXP
 code1
Else
 code2
End
If the expression is true, then only code1 is executed. Otherwise, only code 2 is executed.
ElseIf EXP Can be used inside If blocks. If the condition is true, the block's code is executed and then goes to the end of the If block.
!If EXP
 code1
End
If the expression is false, code1 will be executed.
!If EXP
 code1
Else
 code2
End
If the expression is false, then only code1 is executed. Otherwise, only code 2 is executed.
Else!If EXP Can be used inside If blocks. If the condition is false, the block's code is executed and then goes to the end of the If block.
While EXP
 code1
End
The expression is checked first. If its true, code1 will be executed over and over until its false.
Repeat EXP
 code1
End
The expression is checked first. If its false, code1 will be executed over and over until its true.
For(VAR,EXP1,EXP2)
 code1
End
The variable is initialized with expression1. Until the variable is greater than expression2, code1 is executed and the variable is incremented by 1.
DS<(VAR,MAX)
 code1
End
The variable is decreased by 1. If its 0, code1 is executed and the variable resets back to Max. If its not 0 yet, code1 is skipped.

Labels and Subroutines
Command Description
Lbl LBL Creates a label at the current position.
Goto LBL Jumps to the label.
sub(LBL) Calls the subroutine. All subroutines should end with a Return.
sub(LBL,...) Loads up to 6 arguments to the r1 through r6 variables respectively. Then the subroutine is called.
sub(LBLr,...) Same as above except the argument variables it uses are saved before the subroutine is called and restored when it returns.
Return Returns from a subroutine. If not in a subroutine, the program will end.
ReturnIf EXP Returns only if the expression is true.
Return!If EXP Returns only if the expression is false.

Basic Math
Command Description
VAR Returns the variable. Uppercase A through Z, Theta, and r1 through r6 are variables.
°VAR Returns the pointer to the variable.
EXPVAR Stores the expression into the variable.
'CHAR' Converts an ASCII constant into an integer.
-EXP Returns the negative of the expression. That's a negative sign, not a minus sign!
EXP1+EXP2
EXP1-EXP2
Expression2 is added to or subtracted from expression1.
EXP1*EXP2
EXP1/EXP2
EXP1^EXP2
Expression1 is multiplied, divided, or the modulus of expression2.
EXP2 The expression is multiplied by itself.
EXP1=EXP2
EXP1EXP2
EXP1<EXP2
EXP1EXP2
EXP1>EXP2
EXP1EXP2
Returns 1 if the statement is true or 0 if its false. This is an unsigned comparison.
EXP1 or EXP2
EXP1 and EXP2
EXP1 xor EXP2
Returns the bitwise operation of the lower 8 bits of the expressions. You often need parenthesis on the second argument when used.
abs(EXP) Returns the absolute value of the expression.
√(EXP) Returns the square root of the expression.
sin(EXP) Returns the sine of the expression. One Period is [0,256] and the value returned ranges from -127 to 127.
cos(EXP) Returns the cosine of the expression. One Period is [0,256] and the value returned ranges from -127 to 127.
e^(EXP1) Returns 2 to the power of the expression (modular).
ln(EXP1) Returns the log base 2 of the expression, or 255 if undefined.
min(EXP1,EXP2) Returns the minimum of the 2 expressions.
max(EXP1,EXP2) Returns the maximum of the 2 expressions.
rand Returns a random 16 bit number.

Advanced Math
Command Description
EHEX Converts a hexadecimal number into an integer. That prefix is the scientific notation "E".
bBIN Converts a binary number into an integer. That prefix is the lowercase "b".
TTOKEN Converts the 1 or 2 byte token into an integer. That prefix is the transpose symbol "T".
EXP1<<EXP2
EXP1≤≤EXP2
EXP1>>EXP2
EXP1≥≥EXP2
Signed comparisons for numbers that aren't always positive. Returns 1 if the statement is true or 0 if its false.
EXP1**EXP2 The signed multiplication is performed using the high byte as the integer part and the low byte as the decimal part returning a number in the same format.
EXP1*^EXP2 Computes the high order 16 bits of an unsigned multiplication.
EXP1//EXP2 Performs a division, but it works for negative numbers too.
EXP1·EXP2
EXP1+EXP2
EXP1EXP2
Returns respectively the full 16 bit "and", "or", and "xor" of the two expressions. These are the plot style tokens.
EXP1eEXP2 Gets the expression2-th bit of the 8-bit number in expression1. Unlike assembly, the leftmost bit (high order) is bit 0 and the rightmost bit (low order) is bit 7. The bit checking is modular. That's the Euler's constant "e".
EXP1eeEXP2 Gets the expression2-th bit of the 16-bit number in expression1. Unlike assembly, the leftmost bit (high order) is bit 0 and the rightmost bit (low order) is bit 15. The bit checking is modular. That's the Euler's constant "e".

Drawing
Command Description
Pxl-On(X,Y) A pixel becomes black on the buffer at (X,Y).
Pxl-Off(X,Y) A pixel becomes white on the buffer at (X,Y).
Pxl-Change(X,Y) A pixel will change color on the buffer at (X,Y).
pxl-Test(X,Y) Returns 1 if pixel is black and 0 if pixel is white on the buffer at (X,Y).
Pxl-On(X,Y)r A pixel becomes black on the back buffer at (X,Y).
Pxl-Off(X,Y)r A pixel becomes white on the back buffer at (X,Y).
Pxl-Change(X,Y)r A pixel will change color on the back buffer at (X,Y).
pxl-Test(X,Y)r Returns 1 if pixel is black and 0 if pixel is white on the back buffer at (X,Y).
Line(X1,Y1,X2,Y2) Draws a black line from point (X1,Y1) to (X2,Y2) on the buffer.
Rect(X,Y,W,H)
Key: ref()
Draws a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the buffer.
RectI(X,Y,W,H)
Key: rref()
Inverts a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the buffer.
Rect(X,Y,W,H)r
Key: ref()
Draws a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the back buffer.
RectI(X,Y,W,H)r
Key: rref()
Inverts a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the back buffer.
Circle(X,Y,R) Draws a circle with center (X,Y) and radius R on the buffer.

Drawing
Command Description
Pt-On(X,Y,PIC) The 8x8 sprite that is pointed to is drawn to the buffer at (X,Y). Does not clear the area behind it.
Pt-Off(X,Y,PIC) The 8x8 sprite that is pointed to is drawn to the buffer at (X,Y) but clears the area behind it first.
Pt-Change(X,Y,PIC) The 8x8 sprite that is pointed to inverts its pixels on the buffer at (X,Y).
Pt-On(X,Y,PIC)r The 8x8 sprite that is pointed to is drawn to the back buffer at (X,Y). Does not clear the area behind it.
Pt-Off(X,Y,PIC)r The 8x8 sprite that is pointed to is drawn to the back buffer at (X,Y) but clears the area behind it first.
Pt-Change(X,Y,PIC)r The 8x8 sprite that is pointed to inverts its pixels on the back buffer at (X,Y).
Pt-Mask(X,Y,PIC)
Key: Plot1()
The 8x8 grayscale sprite (2 layers) that is pointed to is drawn to both buffers at (X,Y). Areas clear on both layers are transparent and the other combinations are 3-level grayscale. Can also be used for monochrome masking, but the back buffer still gets written to.
Pt-Command()BUFF Performs any of the Pt-On(), Pt-Off(), or Pt-change() routines to an arbitrary buffer of your choice.
Bitmap(X,Y,BITMAP)
Key: Tangent()
Draws a bitmap to the screen or buffer at (X,Y). The structure pointed to should be height (1 byte), then width (1 byte), then the rows of the image padded to the nearest byte.
rotC(PIC)
Key: ShadeNorm()
A copy of the 8x8 sprite pointed to is rotated clockwise 90 degrees. Returns a pointer to that new rotated sprite. Cannot be used recursively.
rotCC(PIC)
Key: Shade_t()
A copy of the 8x8 sprite pointed to is rotated counter-clockwise 90 degrees. Returns a pointer to that new rotated sprite. Cannot be used recursively.
flipV(PIC)
Key: ShadeX2()
A copy of the 8x8 sprite pointed to is flipped vertically. Returns a pointer to that new flipped sprite. Cannot be used recursively.
flipH(PIC)
Key: ShadeF()
A copy of the 8x8 sprite pointed to is flipped horizontally. Returns a pointer to that new flipped sprite.

Text
Command Description
Disp PTR The string that is pointed to is displayed at the cursor position. The cursor moves with the string. If it reaches the end of the screen, it will loop around to the next line.
Disp EXP▶Dec The number is displayed as a decimal at the cursor position. The cursor is then advanced 5 spaces.
Disp EXP▶Char
Key: ▶Frac
The ASCII character is displayed at the cursor position. The cursor is advanced 1 space. A new line is added if it hits the edge.
Disp EXP▶Tok
Key: ▶DMS
The 1 or 2 byte token is displayed at the cursor position. The cursor is advanced. A new line is added if it hits the edge.
Disp i The cursor moves to the next line down. This is the imaginary, not lowercase 'i'.
Output(X) The cursor moves to the cursor position (X/256,X%256).
Output(X,Y) The cursor moves to the cursor position (X,Y).
Output(X,Y,... The cursor moves to the cursor position (X,Y) and whatever follows is displayed at that position.
Text EXP The text pointed to is drawn at the current pen location. See "Fix" command for drawing details.
Text EXP▶Dec The number is drawn as a decimal at the current pen location. See "Fix" command for drawing details.
Text EXP▶Char
Key: ▶Frac
The ASCII character is drawn at the current pen location. See "Fix" command for drawing details.
Text PTR▶Tok
Key: ▶DMS
The 1 or 2 byte token POINTED TO is drawn at the current pen location. Notice how this is different than Disp. See "Fix" command for drawing details.
Text(X) The text pen moves to the position (X%256,X/256).
Text(X,Y) The text pen moves to the position (X,Y).
Text(X,Y,...) The text pen moves to the position (X,Y). Whatever comes next becomes the "Text" command.
Fix 0Small size font. Calculator should exit in this mode if changed!
Fix 1Large size font.
Fix 2Normal colored font. Calculator should exit in this mode if changed!
Fix 3Inverted font.
Fix 4Text is drawn directly to the screen. Calculator should exit in this mode if changed!
Fix 5Text is drawn to the buffer.
Fix 6Automatic scrolling on last line of display. Calculator should exit in this mode if changed!
Fix 7No scrolling on last line of display
Fix 8Bitmaps are drawn directly to the screen. Calculator should exit in this mode if changed!
Fix 9Bitmaps are drawn to the buffer.

Data and Storage
Command Description
"" Adds the string to program memory, but without the ending character.
[HEX] Adds the hex to the program memory.
[PICVAR] Absorbs the picture from RAM into the program (usually 96x63 and 756 bytes). Only the source needs the pic, not the executable.
[PICVARr] Absorbs the tile map picture from RAM into the program. 12 tiles across, 7 tiles down (672 bytes). Only the source needs the pic, not the executable.
Data(NUM,...)
Key: ΔList()
Adds the bytes to program memory. Numbers ending with r are added as 2 byte numbers.
Zeros(SIZE)
Key: det()
Adds Size bytes of zeros to program memory.
DATANAME Saves the data's pointer to a static variable. Also terminates current string if applicable.
NAME Returns a pointer to the start of the data.
L1
L2
L3
L4
L5
L6
Returns a pointer to some free memory.
L1 = 712 bytes (saveSScreen+56) Volatility: LOW
L2 = 531 bytes (statVars) Volatility: LOW (Do not use this area when custom interrupts are enabled, including Mirage OS)
L3 = 768 bytes (appBackUpScreen) Volatility: MED (Saving to back-buffer will corrupt)
L4 = 323 bytes (tempSwapArea) Volatility: MED (Corrupt when archiving/unarchiving in program)
L5 = 128 bytes (textShadow) Volatility: MED ("Disp","Output", and "ClrHome" will corrupt)
L6 = 768 bytes (plotSScreen) Volatility: HIGH (Any buffer drawing will corrupt)
{EXP} Returns the single byte the expression points to. It will be in the range 0 to 255.
{EXP}r Returns the 2 byte data the expression points to.
{EXP}rr Returns the 2 byte data the expression points to but in reverse order.
sign{EXP}
Key: int()
Returns the single byte the expression points to. It will be in the range -128 to 127.
EXP1→{EXP2}r The full 2 bytes of Expression1 is stored to where Expression2 points.
EXP1→{EXP2} The single byte of Expression1 is stored to where Expression2 points.
nib{PTR}
Key: fPart()
Returns the Nth nibble in RAM. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2.
nib{PTR}r
Key: fPart()
Returns the Nth nibble in an Application. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2.
EXP→nib{PTR}
Key: fPart()
Writes to the Nth nibble in RAM. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2.
Fill(PTR1,SIZE) The byte already at Ptr1 is copied to all the bytes after it until Size bytes have been filled with that value. Zero is not a valid Size.
Copy(PTR1,PTR2,SIZE)
Key: conj()
Size bytes starting from Ptr1 are copied to Ptr2 onwards. Zero is not a valid Size.
Copy(PTR1,PTR2,SIZE)r
Key: conj()
Size bytes ending at Ptr1 are copied to Ptr2 moving backwards. Zero is not a valid Size.
Exch(PTR1,PTR2,SIZE)
Key: expr()
Size bytes starting from Ptr1 are exchanged with Size bytes starting at Ptr2. Zero is not a valid Size.
length(PTR) Returns the number of bytes from the pointer to the next zero data element.
inData(BYTE,PTR)
Key: inString()
Searches for the byte in the zero-terminated data. If found, it returns the position it was found in (starting at 1). If not found, 0 is returned.
SortD(PTR,SIZE) Sorts up to 256 bytes of data from largest to smallest starting at the pointed address.

External Variables
Command Description
Ans The expression becomes the "Ans" variable as an integer. Throws an error if out of range.
EXP→Ans The expression stores into the "Ans" variable as an integer.
GetCalc(PTR) Finds the object who's name is pointed to and returns a pointer to the start of its data, or zero if it was archived or not found.
GetCalc(PTR,FILE) Attempts to create a file of the OS variable who's name is pointed to so it can be read from archive. Returns 0 if the variable was not found or unarchived, and non-zero otherwise.
GetCalc(PTR,SIZE) Creates an OS variable who's name is pointed to in RAM and makes it Size bytes large. Returns a pointer to the start of data, or zero if there was not enough RAM. Overwrites existing variable, even if it was in archive.
UnArchive PTR Tries to unarchive the object who's name is pointed to. Returns 1 if it could unarchive and 0 otherwise. Gives a memory error if not enough RAM.
Archive PTR Tries to archive the object who's name is pointed to. Returns 1 if it could archive and 0 otherwise. Gives a memory error if not enough Flash Memory.
DelVar PTR Deletes the OS variable who's name is pointed to even if in archive. Nothing happens if the variable does not exist.
input Prompts for an input string just like BASIC then returns a pointer to the string structure. Don't forget, its a string of tokens, not characters.
float{PTR}
Key: iPart()
Converts the float at the pointed address to an integer. Floats are 9 bytes large.
EXP→float{PTR}
Key: iPart()
Converts the expression into a float and then stores it at the pointed address. Floats are 9 bytes large.

Interrupts
Command Description
FnInt(LBL,FREQ) Turns the subroutine into an interrupt and then turns interrupts on. The frequency can be (fastest) 0, 2, 4, or 6 (slowest). L2 is used for interrupt data so do not use L2 for storage when using interrupts.
FnOn Turns on interrupts.
FnOff Turns off interrupts.
Stop Stops execution until the next interrupt occurs. Interrupts must be enabled or else the calculator will freeze.
LnReg Returns the calculator to regular interrupt mode. MUST be called before exiting the program if using interrupts.

Link Port
Command Description
Port
Key: ClrTable
Returns the status of the link port as a number 0-3.
EXP→Port
Key: ClrTable
Sets the link port to a given status with a number 0-3. Must exit program with status 0 if changed!
Freq(WAVE,TIME)
Key: SinReg
Sound is played out of the link port. Wave is inversely proportional to frequency and Time must be greater than Wave to hear anything.
Send(BYTE,TIME) Tries to send the byte across the linkport. It will keep trying until the other calculator receives the byte or time runs out. Returns 1 if the byte was sent successfully or 0 if it timed-out. Time is in the order of microseconds.
Get Checks if the sender is trying to send anything. Returns the byte if it was received or -1 if nothing was sent. No waiting is done.
New In This Version
Changed From Last Version
Existing Command



Documentation for Axe Parser
Copyright (c) 2010 Kevin Horowitz