So i was inspired by SourceCoders' Basic Optimizer function, and i thought about making one on the calculator, so you could optimize your Basic Programs without having to transfer them to the computer for any utility. I quickly wrote up some code in Axe, and the optimizations have started! Currently it has support for:

Ending Parenthasis
Ending Brackets
Ending Braces
Ending Quotes
Devlar
Powers of 10
Squared or cubed
Negative cancelations

And there is plans and psedocode for

Implied multiplication
=0 into Not(
Expression rearranging to maximize parenthesis deletion

any other ideas of simple find and replace optimizations that i could put into the optimizer? Obviously i cant do some of the complicated stuff, but there are some good simple replacements that can make a big difference. And note that it ignores Strings completely Strings Should not be changed ^^. And there also might be an option on whether to erase empty lines or not. Some people like to keep them for readability during development, and then maybe want to take them out later.

This certainly sounds like a cool idea; how does it work? Does it use a state machine of sorts in order to omit optimizing the contents of strings? Let me show you how the SourceCoder optimizations work via Regex, and I'd also appreciate your (and others') help in coming up with a better optimizer for SourceCoder:


Code:


Edit: I should also mention that the optimization tools aren't actually my original code, but instead created by Brazucs of UnitedTI and integrated into SourceCoder about 5 years ago.

Well it loops through the entire program token by token, if it encounters a quote, it flips a flag that says its inside a string. If it encounters another quote, a newline, or a store token, it flips the flag back. And for every token *not* found when not in a string has its address passed into the optimization sub.

That sub has hand written code (not a table replace) to search for and around tokens and do optimizations directly. For instance when it encounters a closing parentheses it does this:


Code:


And for more complicated optimizations, such as the powers of 10, it does things like this:


Code:


And each optimization has a statement coded for it specifically. There are cases where optimization leads to more possible optimization though, so the optimizer loops through the program multiple times until no more are found.

OK, that's known as a state machine, so I thought so. That's how I'd like SourceCoder's to work as well, which obviously is a bit easier and hence can be made more powerful in PHP on my server than on Axe on a calculator. Let me explain each of my optimizations.


Code:
Remove a closing ) or }, but only if it's followed by a :, a newline, the end of the program, or some character I don't recognize with Unicode ID 8594.

Code:
Remove a single-quote followed by a newline, provided that it's not delimiting a blank line

Code:
Replace a number by itself in a string with just the number, to save the quote byte.

Code:
Remove the Then and End around a single statement after an If, including constructions like If \ Then \ Goto \ End.

Code:
Remove the construction Output(1,1,". I'm unsure what this is for.

Code:
Convert Disp "string" \ Pause to Pause "string"

Code:
Turn Stops into Returns. Because, come on.

Code:
Remove any Return that's the last command in a program

Code:
Replace 0->var with Delvar var

Code:
Remove the newline or colon after a Delvar.

Code:
I'd have to look closer at this to understand fully the logic it applies, but the high-level interpretation is that it changes If BLAH!=0 to If BLAH. and If BLAH=0 to If not(BLAH.

Code:
Remove the final ,1 increment in For( loops with it.

Code:
Replace ^2 with the exponent 2.

Code:
Same with ^3 -> exponent 3.

Code:
Implicit multiplication creation.

Code:
No point having 1 as a coefficient.

Code:
Replace series of Disp A \ Disp B or Prompt A \ Prompt B with Disp A,B or Prompt A,B

Code:
combine boolean expressions

Code:
more of same.

Code:
This massively complex thing does some kind of If \ Store statement compression to value(conditional)->variable expression

Code:
Remove blank lines

Code:
I have no idea. I'd have to work this one out more carefully.

Code:
No point storing to Ans.

Code:
remove extraneous parenthesis around division

Code:
same thing, but for the first half of the division

Code:
Remove extraneous addition and subtraction parentheses, but I think this one might be functionally incorrect (same with the division)

Code:
Combine Disp / Input or Disp / Prompt into a single Input or Prompt.

Those are some really great optimizations! I hadn't thought of some of those, and the logical ones involving If and logical things are quite complex o.O I will definetaly see if i can try to implement those!

Also i need to do some research on regex's to see if i can get my expression recognition working and so i can move them around to maximize parentheses loss ^^

Oooh, can you tell me about this expression recognition? I'm sure you're not trying to write a full regex parser, but you're trying to make a rudimentary regex-like parser? Fire away with any regex questions; I've been using them for years.

Haha its not been fully conceptualized even, but i think that i have an idea of how to get it working. I just need to figure out which groups of parenthesis are movable relative to each other. Like if i have a bunch of expressions added together, they are free to move around. Same if they are all multiplied together

Ah, that's very ambitious; I didn't even consider something that intense for SourceCoder! It seems to me that you'd first need to go to the most innermost sets of parenthesis, rearrange those as possible, then work your way out. Although, what if someone did something like (A+B+(C+D+(E)))? You'd need to remove between multiple levels.

Yeah i know its pretty crazy but i have an idea that it may possibly be able to work. I remember i had a parenthesis expression parser written when i wrote my PEMDAS math parser, so i might build off that, but yeah, it would have to work from outside in.

Was that Axe or BASIC? If BASIC, do you have some source code to throw out here, or is it unwieldily large?

basic, and actually its fairly smallish, only a tad bit over 1K

SourceCoder it and post it up, then, if you don't mind! I'm curious to see it and help you explore how it could be adapted.

Main program
http://sc.cemetech.net/?xpi=0b66e2b79e9cbb85d4822eaf409c7873
This is the expressions parser if i remember correctly
http://sc.cemetech.net/?xpi=5ca6f07cdd3345746dc2d0dbda0f76ca
String to number converter
http://sc.cemetech.net/?xpi=1fc6e6b4ab578ded49e8ba7daec81557

The last program is a number to string converter i believe, i was trying to make one that was faster than the LinReg(Ax+b) way. And it uses Expr() at one point, but its only to go from number to string, not to do any math evaluation.

AMATH
KermMartian has just edited this program. The source code now reads:
This is an automatic post from SourceCoder 2. Report abuse to admin@cemetech.net . You can disable these posts by unchecking the "Post on Update" box in the file's permissions.

A
KermMartian has just edited this program. The source code now reads:
This is an automatic post from SourceCoder 2. Report abuse to admin@cemetech.net . You can disable these posts by unchecking the "Post on Update" box in the file's permissions.

AN2S
KermMartian has just edited this program. The source code now reads:
This is an automatic post from SourceCoder 2. Report abuse to admin@cemetech.net . You can disable these posts by unchecking the "Post on Update" box in the file's permissions.

BuilderBoy, very impressive! That looks like it could definitely be a good place to start, and looking at that and understanding how it works, it does indeed seem that a recursive parser would be necessary to properly optimize TI-BASIC programs effectively and correctly, both for the sake of your program and for SourceCoder. Do you agree? Do you have any particular thoughts or lessons that you learned or re-learned from your code?

I think a recursive parser would definetaly needed for things like the advanced expression parsing for sure, although not necessarily for the ending quotes

As for the code, it gave me ideas of how to handle and detect individual expressions. We really only care about the expressions inside of parentheses (because that is what we are optimizing) and so that makes detection of the expressions very easy. then its just a matter of rules for optimizing. Expressions that are added together can be freely moved about each other, providing that they are kept with any expressions that they are multiplied to. And likewise, expressions that are multiplied together can be moved around freely within the multiplication.

BuilderBoy, exactly, which will be challenging but not impossible to implement, I think. I'm wondering how we'd be able to figure out how to optimize some of the more complex things, like moving addition of a number that's not a list element with a list element around to save a parenthesis, or -A+B -> A-B to save a byte. Perhaps some of those are outside the scope of the projects? We could always try all the possible permutations, but even that would require some more complexity. Hmm.

Yeah this sounds like a whole project just on its own rather than a section of a larger program. For now i think i am going to focus more on the simpler optimizations, and gradually work my way up towards the more complicated ones. Like optimizing =0 into Not() is a medium challenging one, since you still need to count for order of operations, but it is a ton simpler. Also things like If+Store optimizations and If:then optimizations exc...