Progress so far

[Dan Cook]

I have made several major improvements/changes, some of them "hidden"
or pointless, but others significant. Here is what I have done so far
(recently):

- String and Array literals work, and behave like any other variables
(because technically, they are!). The only glitsh is when putting an
array literal inside a macro.

- I have removed the Basic-like syntax completely ("BEGIN ... END"
and " IF THEN ... ELSE ... END"). If that bothers you, I can explain.

- I have removed the HORRID limitation that function-calls can only
be at the beginning of expressions. The reasoning was that a function
will unpredictably mess up register values (which is ironic in the
case of "blah[some ugly expression] = functionCall();" anyway). The
solution was to push all used registers onto the stack for
safekeeping, which ALSO results in MUY MUY efficient passing of values
because the A and HL registers are guaranteed to be available.

- There is now a positive operator for completeness! I.E. X = A *
+B. Yes, it's lame, but the fun part is that the compiler will make
fun of anyone who uses it. This unlocks an option to tell it to stop
doing that, which causes it to spaz even more. And if you undo it, it
has something else to say.

- There is now a "Forget settings after exiting" option. This resets
preferences, workspace, and directory defaults. Ironically, it will
remember that you checked THAT option, and continue to reset when you
reopen each time until you uncheck it. This is intentional, and makes
testing some things easier anyway. And it's funny.

- I changed the labelling conventions that the compiler uses in it's
output. (Yawn)

- The compiler has routines for * / % built into it now, and has a
cleaner hierarchy of ops. Though I have not actually put the code for
it to handle * / % << >> yet, the routines ARE in place, and it's
mostly a matter of copying other methods and tweaking them. BUT as
messing too much with the pipeline of expression parsing has the
POTENTIAL to screw it up for a bit, I made all these other changes and
I might upload something before I slap that all in. I'm not sure.

- String concatenation now also applies to numeric values &
expressions. I stumbled upon the fact that I made the Parser smart
enough to read expressions that resolve without the need of compiling
as single values, but it's missing a couple things (those new
operations and the use of parentheses).

- You can now throw semicolons where ever you want outside of
functions. I think I for some reason wanted to put them after an
#include or after a macro, and it threw a fit. Well, now you can have
semicolon confetti. They are still required though!!!

- A few other important fixes that I apparently made once but never
uploaded but still have and to which I just added all these other
things.

- Found and fixed a freak NullPointerException bug that occurs if you
delete or remove files that it "remembers" being open last time and
cannot find them. Now it just says makes a note about it.

- I'm pretty sure there is other good stuff I did. Yes, I am not
accounting for at least something else ... but lots lots better
already.