You can already compile Axe programs as applications by selecting "Application" as the shell from the options menu.

Note that on certain calcs, it may fail, though. It is very rare, but on my 83+ it doesn't work, even if it works fine on everyone else's calc. Someone else had this problem with his 84+, too. Also writing to Flash is dangerous, so always backup both your ARCHIVE and RAM on a flash drive before compiling apps when you have major updates.

Also you need to sign the app on the computer afterward.

Here's a sort of odd request: reverse modulus. Instead of returning the remainder of a division, it would return the original number minus the remainder. Perhaps it could use ^^ as its operator? For instance, 16^^7 would return 14 and 9001^^3 would return 9000. I've been trying to wrap my head around how to get a reverse modulus routine to work, but complex math routines aren't my specialty. But I figure the least I could do if you want to implement this feature is save you a few minutes and write the reverse modulus auto-optimizations (really just adjustments to the normal modulus auto-optimizations), which are what I would want the most anyways. I could actually do without a reverse modulus routine.

p_RMod2:
.db 2
res 0,l
p_RMod4:
.db 4
ld a,%11111100
and l
ld l,a
p_RMod8:
.db 4
ld a,%11111000
and l
ld l,a
p_RMod16:
.db 4
ld a,%11110000
and l
ld l,a
p_RMod32:
.db 4
ld a,%11100000
and l
ld l,a
p_RMod64:
.db 4
ld a,%11000000
and l
ld l,a
p_RMod128:
.db 4
ld a,%10000000
and l
ld l,a
p_RMod256:
.db 2
ld l,0
p_RMod512:
.db 4
ld l,0
res 0,h
p_RMod1024:
.db 6
ld l,0
ld a,%11111100
and h
ld h,a
p_RMod2048:
.db 6
ld l,0
ld a,%11111000
and h
ld h,a
p_RMod4096:
.db 6
ld l,0
ld a,%11110000
and h
ld h,a
p_RMod8192:
.db 6
ld l,0
ld a,%11100000
and h
ld h,a
p_RMod16384:
.db 6
ld l,0
ld a,%11000000
and h
ld h,a
p_RMod32768:
.db 6
ld l,0
ld a,%10000000
and h
ld h,a


Indeed it could be. But, especially for the cases where the modulus is a multiple of 2, it would be both faster and smaller to actually have a reverse modulus function. For instance, whereas -(^16) would be 12 bytes, ^^16 would be 6 bytes. As an even more extreme example, whereas -(^2) would be 11 bytes, ^^2 would be 2 bytes.



EDIT: On a completely unrelated note, I like the new filetype that can be attached to posts.

That would work too. It would be smaller than the -(^16) solution; every call with a modulo of 2-256 could use the 8-bit and operator and would be 6 bytes, and a modluo of 512-32768 would be 9 bytes. Reverse modulus optimizations would be, on average, about 60% the size of their and -CONST counterparts. Which I guess isn't too much, but if adding it wouldn't be too hard, why not add it and let people save a few bytes. And I think it would be especially useful for the 2-byte ^^256, which could come in handy in some situations.

For reverse modulus 2, wouldn't #+1^2 be smaller and faster?

Oh wait never mind, lol i was reading the explanation of reverse modulus wrong.

Yeah, I'm going to have to add some auto optimizations for "and" "or" and "xor" and their 16-bit counter parts. I totally forgot about those.