I figured it's about time to make a topic about the eventual 8-bit math mode that will be included in Axe. Post any suggestions, ideas, etc.

Here are mine. About the syntax, I was considering the possibility of enclosing 8-bit expressions with single quotes. But then I found out those are currently in used as 'CHAR' constants. So my other idea is using inverted brackets, like so:
]8-bit stuff goes here[

For example, you could have
]A+5->A[

which would compile to
ld a,(var_A)
add a,5
ld (var_A),a
The compiler should keep track of whether the "last answer" is 8-bit or 16-bit, and do a conversion if operating with a different bit length.

For example:
]A+5[->B

would compile to
ld a,(var_A)
add a,5
ld l,a
ld h,0
ld (var_B),hl
Perhaps it could also be possible to force signed conversion, like so (the value will be interpreted as -128 to 127):
]A+5[r->B

which would compile to the following:
ld a,(var_A)
add a,5
ld l,a
rla
sbc a,a
ld h,a
ld (var_B),hl
Using memory read brackets {} in 8-bit mode should force 16-bit mode within the brackets.
Example:
]A+{P+1->P}->A[

Compiled code:
ld a,(var_A)
push af ;save A in case it will get overwritten (seems to be an Axe standard)
ld hl,(var_P)
inc hl
ld (var_P),hl
pop af
add a,(hl)
ld (var_A),a
That's all for now! Direct comments, questions, concerns to your local Netham45.

I don't think Axioms allow for things like this. This is something that would need to be supported in Axe itself (and Quigibo has said that he plans to add 8-bit math at some point. I'm just getting the ball rolling )

I think it might be a bit faster, although for small stuff it might not be very noticeable

Hmm, interesting to use 'inverted' brackets. That has got to go against all the language theories but that actually would work which is the interesting part

The problem with that though is that I think it would be beneficial to keep the 8-bit mode from line to line so you don't need to keep using the brackets.

]A+1->A[
]B+1->B[

<8bit>
A+1->A
B+1->B
<16bit>

Where <8bit> and <16bit> are some undecided token that indicates a switching of the modes.  They can be used inline as well.

This is something that you won't see soon though, probably not until 2.0 (Axe++) because it basically requires me to rewrite an entirely new copy of the math library including new optimizations, conversions, and other technical issues I would have to deal with.  I was also thinking of allowing the use of some lowercase letters to correspond to their registers for the lowest possible level of optimization.

register access! that would be really cool!
for the 8bit and 16bit tokens: perhaps RADIAN -> 8bit and DEGREE -> 16bit? or wouldn't the words in the mode menu change when the token names are changed?

Yeah register access would be nice. It would extend the language so it can do more stuff that only ASM can do normally, while still having some higher level functions similar to TI-BASIC. This is what makes Axe so great IMHO. We can do some basic-like stuff that runs at ASM speed, but we can store stuff where we want in RAM, like ASM

Yep, register access would be great. How about X₁T for A, Y₁T for F, and so on, so that we have obvious register pairs?

Or we could always use Asm(