simple-interpreter

I have a very similar project (not a compiler but an interpreter for a small, integer-only imperative language): https://github.com/bbu/simple-interpreter Unlike this recursive-descent parser, my minimalistic language uses a table-driven shift-reduce parser which is entirely contained in the C code. Both the lexer and the parser can be extended very easily in order to accommodate new tokens and new syntactic forms.

I recently created a toy interpreter for a minimalistic C-like language that is easily extensible: https://github.com/bbu/simple-interpreter I am also currently developing a "real" language that is based on the same lexing and parsing machinery: https://github.com/bbu/quaint-lang

> IMHO seeing an entire programming language's AST parsed almost entirely using a single recursive function with very little code and a table concisely describing its grammar can be quite exhilarating. I recently implemented a toy interpreter for a small language which uses a hand-written, table-driven shift-reduce parser. The parser simply maintains a stack of terminals and non-terminals and applies the corresponding reduction if a suffix of the stack matches a rule in the table. Precedence rules are resolved through an additional "should_shift" function, keeping the grammar very understandable. I think it's a very elegant algorithm: https://github.com/bbu/simple-interpreter

I wrote a shift-reduce parser for a minimalistic C-like language where the grammar is entirely specified as a static table. The precedence rules are resolved through a "should_shift" function where the parser asks whether it should perform the reduction for a matched rule, or shift one token more: https://github.com/bbu/simple-interpreter

Shameless plug: I wrote a very compact and generic lexer, parser and interpreter for a small C-like language. I believe it can be of a great educational value for anyone who tries to understand the basic mechanics of parsing an imperative curly-brace language: https://github.com/bbu/simple-interpreter

I just added array support: https://github.com/bbu/simple-interpreter/commit/392c38e7899... The arrays themselves are dynamically realloc'ed and checked for out of bounds access. I've also added some runtime warnings for access to undefined variables and negative or out of bounds array access. Also, there is an equivalence between variables and arrays: `var[0]` is the same as `var`. All in 1466 lines :-)

Quite impressive. One improvement that I don't think would increase your lines of code might be to use a `realloc' for your variable storage, so you wouldn't run out of space or have a hard limit. https://github.com/bbu/simple-interpreter/blob/master/src/ru... And of course I want to test this myself with a few interesting programs. In terms of computing power, I think this language is just shy of being Turing complete. It's probably in the same class as regular expressions. I'm working on a similar project, with a minimal compiler for an integer-only language, and I expect it to have the same limitation at first. I think the easiest way to remedy that is to implement dynamic arrays or some form of recursion, although I'm not sure if the latter is sufficient.