That's a cleaver trick!  But wouldn't something like this be simpler?

or a
sbc hl,de
add hl,de
jr nc,$+3
ex de,hl

But I'm trying to convert all of my math commands to signed operations anyway, so I would need to tweak it a bit.

I'm going to try your multiplication routine again and see if its smaller.  I think I forgot the ret at the end which might of been what screwed me up.

'CHAR' is new.  So is EHEX.

Sorry about the doc.  You're right, I didn't have time. I added the documentation the last minute because I was on my laptop in the library and I realized my battery was running low so I scrambled to put it together as fast as I could.  Still don't have internet yet, probably won't for a while, but I don't mind since I'm trying not to be too distracted from my school work and I'm at school almost every day anyway so I just use it there.  I'll try to make it more clear in the next version.

Also you mentioned that you didn't see the hex and ascii constants?  Those are just alternative ways to write numbers.  Its in the middle of the doc somewhere.

Instead of 11->A it is sometimes more convenient to write E000B->A as hexadecimal, especially when you want to access certain locations in the RAM since they are defined in hex, not base 10.  Its a pretty low lew command though, you generally won't need it, but it was requested so I figured I might as well since at the same time I was doing ASCII constants.

You might be familiar with ASCII already, but each character is represented by a number.  So if you need to display a single character, than instead of Disp "A" you can do Disp 'A'>Frac which saves some bytes.  But you'll most often use this when reading from a string and comparing the characters to another character.  Also, this makes it easy to store data using strings instead of hex since they are easier to read.  Entire maps can be made with a string since you can make statements now like If {Str1+X}='A'

@Omnimaga

You don't have to use the new commands.  They are just optimizations to what you could have already done with the old ones, but now in less code and faster speed.  Did you see the routine builderboy made for multiplying negative numbers?  If you look at that code, it is almost unreadable and bizarre looking to someone who doesn't know unsigned arithmetic.  Now, if I had made a separate command to do that for you (even if the logic behind the command is hard to understand) it makes the code much easier to read and to program.  Try making your own routines to do the same functions and you will see how convenient these new shortcuts are.

The only real low level command is the int() which is the sign extension command.  You would mostly use this command when you need to store negative numbers into the RAM in an array.  Negative numbers need 2 bytes since they behave like large positive numbers.  But since you can only store one byte then when you go to read it it will turn into a really small number.  Try doing this:

-1->{L1}
Disp {L1}>Dec

This will not display the 65535 that it is supposed to, instead it will be a smaller positive number.  The way around this is sign extension.  So if you do this instead:

Disp int({L1})>Dec

It will return the correct value.  This only works when the stored value is between -128 and 127.

Axe Parser
Alpha 0.1.2

---

New Features:

• Automated data copy, exchange, and fill.
• Absolute value for signed numbers
• Sign extension for single byte signed numbers
• Hexadecimal constants
• ASCII constants

Changed:

• Multiplication should work with signed numbers now.
• Comments now need to start with a period instead of a single quote.

No new examples since I didn't have time to make anything.

Builderboy, you're thinking of a 1's compliment system where the last bit is just a sign bit.  2's compliment is a little bit different.  The advantage of 2's compliment system is that it is arithmetically (and apparently also multiplicitively) compatible with unsigned numbers.

By the way calcmaniac, your code didn't work.  I tried -1 times 1 and it returned a weird number.  But I was able to create my own routine after looking at some other code.  Its a little slower, but its roughly the same size as the original 8bit routine.

Kind of.  I'm going to release all of my templated assembly code that the executable programs use, but I don't think I will release the source of the parser itself.  Right now, I'm not too worried about the optimizations.  Its the actual code of the Parser I am trying to finished first so I can release a beta, but I keep getting distracted by wantting to add more commands since they're relatively easier and more fun