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.

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


There's actually a slightly more efficient way of doing it. Let's say that you have a series of buttons arranged vertically, as is common in many GUIs. You could arrange the buttons with a simple algorithm like this:

Code: [Select]

:"WTRSNDMTLSPKOILFIRERS"→Str1
:For(A,0,6
:A*8+5→B
:Text(80,B,3*A+Str1)
:RectI(78,B-1,15,9
:RectI(79,B,13,7
:End

This will display three characters from the string for each button and draw a box around the text. When you go to click on a button, you just have to redo the algorithm with with the Y coordinate.

I love optimizing code.

:"WTRSNDMTLSPKOILFIRERS"→Str1
:8→A
:While A-1→A
:Text(*8-3→B*256+80)
:Text A*3-3+Str1
:RectI(78,B-1,15,9)
:RectI(79,B,13,7)
:End


Port has disappeared from the commands.

It looks to me like it's right where it always was, as a token replacement for ClrTable.

getKey(15) will equal 1 if the clear key is being held down and 0 if it isn't. That's all it does: return a value. If you want it to actually do something useful based on whether or not it (or any other key) is held down, you have to put it as the condition in an if statement and then put what you want it to do as the contents of the if statement, just like the other 5 if statements already in the code.

So can you type in the text or you have to do the printing by hand? The latter takes forever and I try to avoid it as much as possible.

Print, as in using the OS text routines to print characters onto the screen.

To quote Sean McLaughlin from Day 26 of his Learn TI-83 Plus Assembly in 28 Days:

The TI-85 and higher-number calculators have a memory mapped screen. That means a section of the calculator's RAM that holds a bit image of the screen is constantly being monitored. Whenever a byte in this area is changed, the display changes immediately. It is also possible to change the RAM area the driver looks at with a single port output. By switching the buffer location back and forth rapidly, you could create Game Boy-style flickerless 4- or 8-level grayscale.
Unfortunately, the "crap series" (everything lower than a TI-85) uses a driver that stores the screen image in its own RAM. In order to change the display, you have to send each byte in the image to the driver. It is also a very slow driver which needs a delay every time it is accessed.

The next line, although not applicable to answering your question, is my favorite line in the whole tutorial.

Hopefully you are sufficiently depressed now, so let's look at how to make the Toshiba T6A04 (that's the name of the driver) our bitch.