I assume this variable would be a bit like Ans, right?

AH ok I see. That could be pretty handy

The ex command is only 1 byte whereas loading a 16 bit register is 2 bytes.  And that statement could still be done like this:

:A->B->pi

The ex command is only 1 byte whereas loading a 16 bit register is 2 bytes.  And that statement could still be done like this:

Code: [Select]

:A->B->pi

Oh, okay. Make sure that's in the docu, though

Definitely not !. That's not(, remember.

Maybe ??

Perhaps. But realize that "!" is only used right before "If ". It could get another use

For a moment there I thought If !(A=2) was allowed as well ... whoops.

But people might still be confused. What about using de for DE, bc for BC, and a for A? Lowercase letters aren't used except in strings, anyway. Except for bBINARY...

Okay, here are my thoughts on using the DE register.

pi and ->pi should be a two-byte load or store. A different method or token should be used for the one-byte swap. This will let it be treated like any other variable, without strange side effects that need to be learned. I know I would miss being able to directly load/store (such as if I want to use DE as a pointer, like {pi+1->pi})

Also, it may be a good idea to change as many operations as possible to trash BC instead of DE to make the pi variable less volatile. If there are any operations that need the ex de,hl to optimize, just ask if you need help optimizing the BC version. For example, the > and <= operations can be done without a swap by setting the carry flag before the sbc instruction.

Finally, a feature request for a /^ operator that returns the quotient and the remainder at the same time.

Edit:
Also, I assume that operators working on pi will be optimized. For example, +pi should compile to one byte of code (add hl,de)

just found something cool. if you *really* don't have any temp variables to exchange two values, the following code should do the trick:

Code: [Select]

. "xor" is the 16 bit plotstyle-box xor, not the actual word xor.
A xor B->A
A xor B->B
A xor B->A


Woah, that's a neat trick! I never thought of that. But you could optimize it a bit

A xor B->A xor B->B xor A->A