Serious reworking of preprocessor macro replacement code. Appears to handles the various oddities on might encounter in macro salsa, now.

Updated .hgignore for Lemon header output.

Added a --version command line to mojoshader-compiler.

Added another unit test.

Forgot to add this test before.

List subsection in the condensed error output.

Make failed tests more clear in the output.

Added more unit tests.

Finished preprocessor/errors/too-many-macro-args test.

Implemented error output unit test harness.

Merged some lemon diffs from sqlite's fossil repo: Visual Studio compile fixes.

Fixed C++ compiler error.

Did some Ryanification of Aras's Windows #include handling code.

When processing identifiers in macro "calls", check both args and #defines.

Added another failing test.

Added indirect stringify test.

Added another failing test.

Added basic tests for __FILE__ and __LINE__.

Changed where we spawn mojoshader-compiler from, for __FILE__ testing.

Added support for __FILE__ and __LINE__ to the preprocessor.

Added unit test for better coverage of bug I just fixed.

Macro args in macro args need to be replaced inline. So... #define x THIS_IS_THE_DEFINE #define b(x) x #define z(x) b(x) z(THIS_IS_THE_MACRO_ARG) ...should produce THIS_IS_THE_MACRO_ARG and not THIS_IS_THE_DEFINE. Fixes unit-tests/preprocessor/output/nested-macro-args

Added some unit tests for the preprocessor #line directive.

filename in #line is optional

make compile on MSVC, and fix stringmap_insert

Added concat operator ("##") to the preprocessor. There are still some failing corner cases, but it's probably good enough.

Catch these tokens in the compiler, for badly-formed preprocessor source code.

Don't reference built-in include functions if we preprocessed them out.

Regenerated lexer with stringify operator.

Added stringify operator ("#") to preprocessor.

Check for "##" at the start and end of macro definitions.

Added unit tests for preprocessor's macro concat operator. These fail at the moment.

Removed unused struct member.

preprocessor open impl on MSVC

Patched to compile.

Implemented StringMap, for future use.

Formalized the compiler's string cache into a real API. Moved the compiler and preprocessor to use it, and dumped their separate implementations of the same thing.

Removed the vector/matrix datatype parser tokens. MSDN docs suggest that there aren't formal grammar tokens for these, but rather the compiler treats these as implicit typedefs that appear before the first line of source code. We now treat them as such, which makes everything a little less bulky.

Moved print_ast() elsewhere.

Reverse all the linked lists that we generate backwards in the parser.

Filled in the rest of the missing print_ast() cases.

Bunch More Work on print_ast().

Temporary (and incomplete!) debug code to print the AST.

Cleaned up compiler framework a little.

Fixed pop_scope().

Removed some debug code.

Make the error code blocks into fail() calls. I think I want this to be more robust, still, though.

Added a FIXME.

Added better (?) USERTYPE management. Now handles scoping of typedefs, etc.

Removed incorrect assertion.

Make AST nodes a little more generic, add source position info to them.

Keep track of token location when parsing.

A little work on error handling in the compiler.

Added a FIXME.

Report bad characters in the assembler.

Clean up context at the end.

Removed SEMANTIC token...we can do this with IDENTIFIER. The less the parser has to do, the better!

Uncommented some grammar bits that got masked out in the calculator experiment.

Bunch More Work on HLSL parser. This is not nearly ready for primetime. I doubt it does much more than compile (and maybe only on my machine). This reworks/improves/cleans up the grammar quite a bit, and fills in much of the C code required to generate an Abstract Syntax Tree. Nothing is done with this tree yet, including freeing it.

Added boilerplate comment to start of file.

Updated lempar.c to match updated lemon.c

Lemon fix: don't let grammar define the same nonterminal %type more than once.

Lemon fix: incorrect printf format strings.

Updated lemon to the latest in my fossil repo. My assumption is that many of my __MOJOSHADER__ blocks will be formal parts of upstream Lemon, so I've merged over for now, removing the #ifdefs where appropriate. I'm keeping %expect support for now, even though drh didn't like the idea, since I can't wrap my stupid head around the parser conflict resolution process yet.

Lemon now writes errors to stderr instead of stdout, and uses full output. The previous way truncated the filename, so my editor couldn't jump to the problem line in the source code.

Lemon now deletes its output on failure. This is to fix the build system. Previously, a Makefile would abort when lemon fails, but on the next run it would see a newer (incorrect/incomplete) output file, and assume it succeeded previously, with disastrous effects for later steps in the build process.

Merged calculator-experiment back into default branch.

Moved the calculator experiment work back into the compiler. At least we know the expression parser works! :) Lots of other bits of new infrastructure in there, too.

Don't pass the TokenData back out of the lemon code.

Removed some Context fields we don't really need.

"identifier" shouldn't be a non-terminal.

Cleaned up TokenData FIXMEs, and added string cache.

Free the parse tree once we're done with it.

Actually run the calculator, walking the parse tree.

Stop parsing if the parser panics.

Closing the "trunk" branch. (it's a relic of the conversion from Subversion to Mercurial).

Ignore blank lines.

Removed debug output.

Fixed literal data getting through the parser in one piece.

Initial dumping of parse tree once parsing finishes. Other minor tweaks and cleanups, too.

Allow "q" to quit calculator, too.

Make #include callbacks optional. Now fails at runtime if we hit an #include without callbacks defined. If we never need the callbacks, it's silly to assert they must exist.

Cleaned up operator enumeration, put it into ranges, fixed data ops.

Start of experiment with a basic calculator. This is a throwaway so I can debug some of the HLSL parsing code, and get a better idea of what I want to do there. This will eventually merge back into the default branch with the right bits going into the compiler code.

Don't suppress #line directives in lemon output.

Forgot to wrap this in a #if __MOJOSHADER__.

Allow compiler to strip disabled glsl120 and nvX profiles as dead code.

Fixed compiler warnings on 64-bit Mac OS X.

Added a FIXME.

Minor Ryanification.

Emit vs_1_1 properly (thanks, Aras!).

vs_1_1 also has decls on D3D9

when profile is compiled out, dont crash later

asm needs bytecode profile

fix passthrough/bytecode define

Regenerated mojoshader_lexer.c from mojoshader_lexer.re.

Bunch of small tweaks to make this compile as C++ code without errors/warnings.

GLSL Uniform locations are signed ints.

Keep it simple.

Pacify compiler warning.

Fixed compiler warning about Lemon allocator function signature. ...probably fixed 64-bit builds, too...

Fixed a compiler warning, for now.

Forgot to add DEPTH to the list of valid semantics.

Fixed compiler warning.

Initializer blocks can nest, like "float4 x[] = { {a,b,c,d}, {a,b,c,d} };"

Variable declarations can have empty array bounds, like "float x[] = {a,b,c};"

Allow vector initializers, like "float4 x = {a,b,c,d};"

Added statement block attributes to the HLSL grammar. These are supposedly only available to Shader Model 4 and Xbox 360 targets.

Modified Lemon to accept a specific amount of conflicts. This works like bison's %expect declaration.

Added totally unhelpful syntax error output.

Removed some debug code.

HLSL for loops can have variable declarations: "for (int x=0; x<10; x++) {}"

HLSL array declarations can be expressions, like "float4 x[(1 + 1) / 2];" ...

HLSL struct fields can have semantics.

Apparently "inout" and "in out" are both legal for HLSL function parameters.

Fixed parsing of HLSL functions that return void.

Added some structure for user types (struct at the moment).

Fixed HLSL parsing of structs with array fields.

Move glsl "#version" pragma to the preflight section, so it's always first.

Only enable/disable vertex arrays when forced to.