Share on Mastodon
Posts in this series: Lexer, Parser, Evaluator
Subs has reached version 1.3.4, which means that it can successfully run all the tests from chapter 1 of SICP. This is very exciting.
Last time I explained a bit about the Lexer, which takes in a stream of characters and emits a stream of tokens: individual elements of code such as a bracket, a keyword or a symbol.
Generally, parsers emit some kind of tree structure – they understand the raw tokens as a hierarchical structure which (conceptually, at least) will be executed from the bottom up, with each branch-point in the tree being an operation of some kind.
Our parser takes in a stream of tokens, and emits a stream of parsed trees.
Parsing Scheme is very easy, because (except for a couple of exceptions I haven’t implemented yet) there is essentially one rule: start with an open bracket, see a list of things, and then find a close bracket. Of course, one of the “things” you see may itself be another bracketted list, so after parsing you get a tree structure of nested lists.
The parser in Subs looks like this:
class Parser
{
public:
Parser( ILexer& lexer );
std::auto_ptr<Value> NextValue();
private:
ILexer& lexer_;
};
We supply a Lexer in the constructor, which we know will provide us with tokens when we need them via its NextToken() method. The Parser’s NextValue() method returns a pointer to a Value, which is the base class for all the “things” in the Subs interpreter.
There are lots of types of things that inherit from the Value class, but the “parse tree” (the output of the parser) will only consist of a very small subset of them:
- CombinationValue
- DecimalValue
- IntegerValue
- StringValue
- SymbolValue
The CombinationValue class forms the tree structure. Its declaration looks like this:
class CombinationValue : public Value, public std::vector<Value*>
{
// ...
};
It is simply a list of other Values.
Note that it “owns” those Values in the sense that it deletes them when it is deleted. I have recently made the jump to make Subs depend on BOOST, so it’s on my TODO list to make containers like this use the BOOST smart containers to manage this job for me.
DecimalValue, IntegerValue and StringValue are relatively self-explanatory: they contain numbers and strings that were found as literals in the source code.
SymbolValue is essentially everything else – if the code that recognises the type of a token can’t recognise it as a bracket, a number or a string, we assume it is a symbol, and tuck it away in a SymbolValue to be understood later.
The core of the Parser looks like this (with some error-checking removed):
std::auto_ptr<Value> next_value( ILexer& lexer, Token token )
{
if( token.Name() == "(" )
{
auto_ptr<CombinationValue> ret( new CombinationValue );
while( true )
{
token = lexer.NextToken();
if( token.Name() == ")" )
{
break;
}
// Recursive call
ret->push_back( next_value( lexer, token ).release() );
}
return auto_ptr<Value>( ret.release() );
}
else
{
return ValueFactory::CreateValue( token );
}
}
(Full code here: Parser.cpp) It’s a simple recursive function that creates a CombinationValue whenever it finds a bracket, and otherwise uses a ValueFactory to create an individual value.
Side note: the wisdom of using recursion could certainly be questioned, since it limits the depth of bracketting we can handle to the size of the C++ stack, but the only other way to get the same result would be to keep our own manual stack of unfinished combinations, and it just seems perverse to re-implement language features like that. What might well be more interesting would be to consider whether we can actually evaluate parts of the tree as we go, without parsing it all at once. This might make the whole setup scale rather better, but would most likely be quite complex. The implementation presented here will work fine for almost any imaginable program – remember we would need not just code whose execution is deeply nested, but whose expression in code had thousands of levels of nesting before the parser would fail.
The ValueFactory uses some basic rules such as “starts and ends with a quote” or “consists of only numbers and a decimal point” to recognise what type of Value to create, and if no rules match it defaults to a SymbolValue.
When we have completed a bracketted expression, we return a complete tree of numbers, strings and symbols, and it is ready to be evaluated, which you can think of as simply expanding the tree we already have into the full expression of itself, and then reducing it back down again to an answer.
Next time, the Evaluator and the famous eval-apply loop.