GOLD Grammar, GOLD code generation template, QL test file, parser test project.
Renamed C# Project and moved into a sub-folder.

Added links to the Grammar related files for easy access from within VS.
Added command-line tools to build and test the grammar, as well as create the skeleton file.
Used command-line tools to set up pre-build events. Build fails is any of the tools fails.
Added GOLD binary table files to the gitignore (these are created on build from the grammar file).
Removed EGT.

Created Class Library project for the QL grammar code stuff.
Created Expr and Value classes to reflect the operations within the grammar.
Changes to the parser template.

Renamed some values in the grammar to prevent conflicts.
Updated test file to reflect changes in the grammar.
TestLog.txt is now created on build. Any errors that occurred while verifying the test file are reported here.
Created a more general parser class in between the generated and implemented parser.
Created general base classes for Expressions and Statements (AST folder). Also added a factory class that uses those base classes to create a basic tree.
Moved Eval files to an Eval sub-folder. Current state of these classes is pending replacement/transformation. Where used for testing basic functionality but can be re-used later most likely. Old factory class rewritten to utilize the more general base class.
Created TypeCheck classes to handle some basic type checking and error reporting. Factory included. Pending extension.
Fixed inline if/else expression.

+ more little things I'm not going to write out
Extended type checking.

- Known issues:
-- 'goto' statement not checked properly. This is currently the only statement that can only be evaluated after everything is parsed (only at this point all forms are known). As the checking is now done during parsing, the goto statement will always fail to find forms that are defined later in the code file.

Made object creation functions virtual instead of abstract; they aren't required to be overridden. This allows you to only override those you actually want and not have to override just to leave them empty.
Type checking function now returns a tuple instead of doing shit with out variable.
Single, Double, Triple nodes now extend each other.
Rewrote type checking a little bit; still checking expressions at the moment they are parsed but rewrote statements to be checked when the parsing completes.

Statements check recursively any contained statements. Contained expressions are not checked with this recursion as they are already checked during the parsing.

Solves the 'goto' statement problem that relies on knowledge only known once the parsing has been completed.
Created test project to see how extension works so far. This project adds some math functionality (power and modulo) to the grammar.

While doing so I encountered a few limitations at the area of loading grammars and checking for rules. Rewrote the code to allow for rule lists instead of fixed values. Can most likely be optimized further but this is for later.
Type checking separated from the parsing.

Added unit test project with 3 simple tests.
Overriden Equals in all base node classes otherwise Equals would only be true if the instances are the same. Now checking whether contents are the same instead.
Cleaned up some code and moved some files around.
Made factory usage generic.

Override GetHashCode as per C# rule/guideline when overriding Equals.
TypeChecker now working with separate classes using dynamic dispatch. Make nodes instead later (utilize object algebras as implemented).
Added comments to the dangling else so you know what'll happen to it during parsing.
Reworked code again. Now even more generic/portable/extensible :O

Extensible algebra combinators is being utilized to run multiple algebras together.
Moving type checking is currently a WIP. Skeleton has been set up but it has not yet been moved over. Currently it still works utilizing a central class + dynamic dispatch.
Moved some files around.

Changed error handling of the current type checking. Have to figure out some way to do this using object algebras... Kind of missing anonymous types that can implement functions right now. Fear I'll have to throw around numerous variables to get the needed info everywhere...
Rewrote type checker to utilize object algebras.

TypeCheck function takes a TypeCheckData object to share information between items.
Reading Assignments term frequency stuff
Adapted extended grammar to include a new type: date.

Error messages now event based instead of list aggregated.
Made types extensible; it is working atm but maybe not OK in the way it is done.
Converted ExtensionTest project from console app to library. Moved console app code to ConsoleParser.

Added some tests to QL_Tests that test functionality of ExtensionTest.
Added a test that checks if the 'else' is correctly associated with the inner most 'if'.