<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>2. Chapter 2: Implementing a Parser and AST — llvmpy tag: 0.12.0 documentation</title>
<link rel="stylesheet" href="../../_static/default.css" type="text/css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../../',
VERSION: 'tag: 0.12.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../../_static/jquery.js"></script>
<script type="text/javascript" src="../../_static/underscore.js"></script>
<script type="text/javascript" src="../../_static/doctools.js"></script>
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="top" title="llvmpy tag: 0.12.0 documentation" href="../../index.html" />
<link rel="up" title="Kaleidoscope" href="index.html" />
<link rel="next" title="3. Chapter 3: Code generation to LLVM IR" href="PythonLangImpl3.html" />
<link rel="prev" title="1. Chapter 1: Tutorial Introduction and the Lexer" href="PythonLangImpl1.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="PythonLangImpl3.html" title="3. Chapter 3: Code generation to LLVM IR"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="PythonLangImpl1.html" title="1. Chapter 1: Tutorial Introduction and the Lexer"
accesskey="P">previous</a> |</li>
<li><a href="../../index.html">llvmpy tag: 0.12.0 documentation</a> »</li>
<li><a href="../examples.html" >Examples and LLVM Tutorials</a> »</li>
<li><a href="index.html" accesskey="U">Kaleidoscope</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="chapter-2-implementing-a-parser-and-ast">
<h1>2. Chapter 2: Implementing a Parser and AST<a class="headerlink" href="#chapter-2-implementing-a-parser-and-ast" title="Permalink to this headline">¶</a></h1>
<p>Written by <a class="reference external" href="mailto:sabre%40nondot.org">Chris Lattner</a> and <a class="reference external" href="http://max99x.com">Max
Shawabkeh</a></p>
<div class="section" id="introduction">
<h2>2.1. Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
<p>Welcome to Chapter 2 of the <a class="reference external" href="http://www.llvm.org/docs/tutorial/index.html">Implementing a language with
LLVM</a> tutorial. This
chapter shows you how to use the lexer, built in <a class="reference external" href="PythonLangImpl1.html">Chapter
1</a>, to build a full
<a class="reference external" href="http://en.wikipedia.org/wiki/Parsing">parser</a> for our Kaleidoscope
language. Once we have a parser, we’ll define and build an <a class="reference external" href="http://en.wikipedia.org/wiki/Abstract_syntax_tree">Abstract
Syntax Tree</a> (AST).</p>
<p>The parser we will build uses a combination of <a class="reference external" href="http://en.wikipedia.org/wiki/Recursive_descent_parser">Recursive Descent
Parsing</a> and
<a class="reference external" href="http://en.wikipedia.org/wiki/Operator-precedence_parser">Operator-Precedence
Parsing</a> to
parse the Kaleidoscope language (the latter for binary expressions and
the former for everything else). Before we get to parsing though, lets
talk about the output of the parser: the Abstract Syntax Tree.</p>
</div>
<hr class="docutils" />
<div class="section" id="the-abstract-syntax-tree-ast">
<h2>2.2. The Abstract Syntax Tree (AST)<a class="headerlink" href="#the-abstract-syntax-tree-ast" title="Permalink to this headline">¶</a></h2>
<p>The AST for a program captures its behavior in such a way that it is
easy for later stages of the compiler (e.g. code generation) to
interpret. We basically want one object for each construct in the
language, and the AST should closely model the language. In
Kaleidoscope, we have expressions, a prototype, and a function object.
We’ll start with expressions first:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Base class for all expression nodes.</span>
<span class="k">class</span> <span class="nc">ExpressionNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
<span class="c"># Expression class for numeric literals like "1.0".</span>
<span class="k">class</span> <span class="nc">NumberExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
</pre></div>
</div>
<p>The code above shows the definition of the base ExpressionNode class and
one subclass which we use for numeric literals. The important thing to
note about this code is that the NumberExpressionNode class captures the
numeric value of the literal as an instance variable. This allows later
phases of the compiler to know what the stored numeric value is.</p>
<p>Right now we only create the AST, so there are no useful methods on
them. It would be very easy to add a virtual method to pretty print the
code, for example. Here are the other expression AST node definitions
that we’ll use in the basic form of the Kaleidoscope language:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Expression class for referencing a variable, like "a".</span>
<span class="k">class</span> <span class="nc">VariableExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
<span class="c"># Expression class for a binary operator.</span>
<span class="k">class</span> <span class="nc">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">operator</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">operator</span> <span class="o">=</span> <span class="n">operator</span>
<span class="bp">self</span><span class="o">.</span><span class="n">left</span> <span class="o">=</span> <span class="n">left</span>
<span class="bp">self</span><span class="o">.</span><span class="n">right</span> <span class="o">=</span> <span class="n">right</span>
<span class="c"># Expression class for function calls.</span>
<span class="k">class</span> <span class="nc">CallExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">callee</span><span class="p">,</span> <span class="n">args</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">callee</span> <span class="o">=</span> <span class="n">callee</span>
<span class="bp">self</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>
</pre></div>
</div>
<p>This is all (intentionally) rather straight-forward: variables capture
the variable name, binary operators capture their opcode (e.g. ‘+’), and
calls capture a function name as well as a list of any argument
expressions. One thing that is nice about our AST is that it captures
the language features without talking about the syntax of the language.
Note that there is no discussion about precedence of binary operators,
lexical structure, etc.</p>
<p>For our basic language, these are all of the expression nodes we’ll
define. Because it doesn’t have conditional control flow, it isn’t
Turing-complete; we’ll fix that in a later installment. The two things
we need next are a way to talk about the interface to a function, and a
way to talk about functions themselves:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># This class represents the "prototype" for a function, which captures its name,</span>
<span class="c"># and its argument names (thus implicitly the number of arguments the function</span>
<span class="c"># takes).</span>
<span class="k">class</span> <span class="nc">PrototypeNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">args</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>
<span class="c"># This class represents a function definition itself.</span>
<span class="k">class</span> <span class="nc">FunctionNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">prototype</span><span class="p">,</span> <span class="n">body</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">prototype</span> <span class="o">=</span> <span class="n">prototype</span>
<span class="bp">self</span><span class="o">.</span><span class="n">body</span> <span class="o">=</span> <span class="n">body</span>
</pre></div>
</div>
<p>In Kaleidoscope, functions are typed with just a count of their
arguments. Since all values are double precision floating point, the
type of each argument doesn’t need to be stored anywhere. In a more
aggressive and realistic language, the <tt class="docutils literal"><span class="pre">ExpressionNode</span></tt> class would
probably have a type field.</p>
<p>With this scaffolding, we can now talk about parsing expressions and
function bodies in Kaleidoscope.</p>
</div>
<hr class="docutils" />
<div class="section" id="parser-basics">
<h2>2.3. Parser Basics<a class="headerlink" href="#parser-basics" title="Permalink to this headline">¶</a></h2>
<p>Now that we have an AST to build, we need to define the parser code to
build it. The idea here is that we want to parse something like
<tt class="docutils literal"><span class="pre">x</span> <span class="pre">+</span> <span class="pre">y</span></tt> (which is returned as three tokens by the lexer) into an AST
that could be generated with calls like this:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">x</span> <span class="o">=</span> <span class="n">VariableExpressionNode</span><span class="p">(</span><span class="s">'x'</span><span class="p">)</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">VariableExpressionNode</span><span class="p">(</span><span class="s">'y'</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="s">'+'</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
</pre></div>
</div>
<p>In order to do this, we’ll start by defining a lightweight <tt class="docutils literal"><span class="pre">Parser</span></tt>
class with some basic helper routines:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Parser</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span> <span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">tokens</span><span class="p">,</span> <span class="n">binop_precedence</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">tokens</span> <span class="o">=</span> <span class="n">tokens</span>
<span class="bp">self</span><span class="o">.</span><span class="n">binop_precedence</span> <span class="o">=</span> <span class="n">binop_precedence</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="c"># Provide a simple token buffer. Parser.current is the current token the</span>
<span class="c"># parser is looking at. Parser.Next() reads another token from the lexer and</span>
<span class="c"># updates Parser.current with its results.</span>
<span class="k">def</span> <span class="nf">Next</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="o">.</span><span class="n">next</span><span class="p">()</span>
</pre></div>
</div>
<p>This implements a simple token buffer around the lexer. This allows us
to look one token ahead at what the lexer is returning. Every function
in our parser will assume that <tt class="docutils literal"><span class="pre">self.current</span></tt> is the current token
that needs to be parsed. Note that the first token is read as soon as
the parser is instantiated. Let us ignore the <tt class="docutils literal"><span class="pre">binop_precedence</span></tt>
parameter for now. It will be explained when we start parsing binary
operators.</p>
<p>With these basic helper functions, we can implement the first piece of
our grammar: numeric literals.</p>
</div>
<hr class="docutils" />
<div class="section" id="basic-expression-parsing">
<h2>2.4. Basic Expression Parsing<a class="headerlink" href="#basic-expression-parsing" title="Permalink to this headline">¶</a></h2>
<p>We start with numeric literals, because they are the simplest to
process. For each production in our grammar, we’ll define a function
which parses that production. For numeric literals, we have:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># numberexpr ::= number</span>
<span class="k">def</span> <span class="nf">ParseNumberExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">NumberExpressionNode</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># consume the number.</span>
<span class="k">return</span> <span class="n">result</span>
</pre></div>
</div>
<p>This method is very simple: it expects to be called when the current
token is a <tt class="docutils literal"><span class="pre">NumberToken</span></tt>. It takes the current number value, creates a
<tt class="docutils literal"><span class="pre">NumberExpressionNode</span></tt>, advances to the next token, and finally
returns.</p>
<p>There are some interesting aspects to this. The most important one is
that this routine eats all of the tokens that correspond to the
production and returns the lexer buffer with the next token (which is
not part of the grammar production) ready to go. This is a fairly
standard way to go for recursive descent parsers. For a better example,
the parenthesis operator is defined like this:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># parenexpr ::= '(' expression ')'</span>
<span class="k">def</span> <span class="nf">ParseParenExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">contents</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")".'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">contents</span>
</pre></div>
</div>
<p>This function illustrates an interesting aspect of the parser. The
function uses recursion by calling <tt class="docutils literal"><span class="pre">ParseExpression</span></tt> (we will soon see
that <tt class="docutils literal"><span class="pre">ParseExpression</span></tt> can call <tt class="docutils literal"><span class="pre">ParseParenExpr</span></tt>). This is powerful
because it allows us to handle recursive grammars, and keeps each
production very simple. Note that parentheses do not cause construction
of AST nodes themselves. While we could do it this way, the most
important role of parentheses are to guide the parser and provide
grouping. Once the parser constructs the AST, parentheses are not
needed.</p>
<p>The next simple production is for handling variable references and
function calls:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># identifierexpr ::= identifier | identifier '(' expression* ')'</span>
<span class="k">def</span> <span class="nf">ParseIdentifierExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">identifier_name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat identifier.</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span> <span class="c"># Simple variable reference.</span>
<span class="k">return</span> <span class="n">VariableExpressionNode</span><span class="p">(</span><span class="n">identifier_name</span><span class="p">);</span>
<span class="c"># Call.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="n">args</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">())</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">==</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">break</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">','</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")" or "," in argument list.'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">CallExpressionNode</span><span class="p">(</span><span class="n">identifier_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
</pre></div>
</div>
<p>This routine follows the same style as the other routines. It expects to
be called if the current token is an <tt class="docutils literal"><span class="pre">IdentifierToken</span></tt>. It also has
recursion and error handling. One interesting aspect of this is that it
uses <em>look-ahead</em> to determine if the current identifier is a stand
alone variable reference or if it is a function call expression. It
handles this by checking to see if the token after the identifier is a
‘(‘ token, constructing either a <tt class="docutils literal"><span class="pre">VariableExpressionNode</span></tt> or
<tt class="docutils literal"><span class="pre">CallExpressionNode</span></tt> as appropriate.</p>
<p>Now that we have all of our simple expression-parsing logic in place, we
can define a helper function to wrap it together into one entry point.
We call this class of expressions “primary” expressions, for reasons
that will become more clear <a class="reference external" href="PythonLangImpl6.html#unary">later in the
tutorial</a>. In order to parse an arbitrary
primary expression, we need to determine what sort of expression it is:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># primary ::= identifierexpr | numberexpr | parenexpr</span>
<span class="k">def</span> <span class="nf">ParsePrimary</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseIdentifierExpr</span><span class="p">()</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">NumberToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseNumberExpr</span><span class="p">();</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">==</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseParenExpr</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Unknown token when expecting an expression.'</span><span class="p">)</span>
</pre></div>
</div>
<p>Now that you see the definition of this function, it is more obvious why
we can assume the state of <tt class="docutils literal"><span class="pre">Parser.current</span></tt> in the various functions.
This uses look-ahead to determine which sort of expression is being
inspected, and then parses it with a function call.</p>
<p>Now that basic expressions are handled, we need to handle binary
expressions. They are a bit more complex.</p>
</div>
<hr class="docutils" />
<div class="section" id="binary-expression-parsing">
<h2>2.5. Binary Expression Parsing<a class="headerlink" href="#binary-expression-parsing" title="Permalink to this headline">¶</a></h2>
<p>Binary expressions are significantly harder to parse because they are
often ambiguous. For example, when given the string <tt class="docutils literal"><span class="pre">x+y*z</span></tt>, the
parser can choose to parse it as either <tt class="docutils literal"><span class="pre">(x+y)*z</span></tt> or <tt class="docutils literal"><span class="pre">x+(y*z)</span></tt>. With
common definitions from mathematics, we expect the later parse, because
<tt class="docutils literal"><span class="pre">*</span></tt> (multiplication) has higher <em>precedence</em> than <tt class="docutils literal"><span class="pre">+</span></tt> (addition).</p>
<p>There are many ways to handle this, but an elegant and efficient way is
to use <a class="reference external" href="http://en.wikipedia.org/wiki/Operator-precedence_parser">Operator-Precedence
Parsing</a>.
This parsing technique uses the precedence of binary operators to guide
recursion. To start with, we need a table of precedences. Remember the
<tt class="docutils literal"><span class="pre">binop_precedence</span></tt> parameter we passed to the <tt class="docutils literal"><span class="pre">Parser</span></tt> constructor?
Now is the time to use it:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="c"># Install standard binary operators.</span>
<span class="c"># 1 is lowest possible precedence. 40 is the highest.</span>
<span class="n">operator_precedence</span> <span class="o">=</span> <span class="p">{</span>
<span class="s">'<'</span><span class="p">:</span> <span class="mi">10</span><span class="p">,</span>
<span class="s">'+'</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span>
<span class="s">'-'</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span>
<span class="s">'*'</span><span class="p">:</span> <span class="mi">40</span>
<span class="p">}</span>
<span class="c"># Run the main ``interpreter loop``.</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="o">...</span>
<span class="n">parser</span> <span class="o">=</span> <span class="n">Parser</span><span class="p">(</span><span class="n">Tokenize</span><span class="p">(</span><span class="n">raw</span><span class="p">),</span> <span class="n">operator_precedence</span><span class="p">)</span>
</pre></div>
</div>
<p>For the basic form of Kaleidoscope, we will only support 4 binary
operators (this can obviously be extended by you, our brave and intrepid
reader). Having a dictionary makes it easy to add new operators and
makes it clear that the algorithm doesn’t depend on the specific
operators involved, but it would be easy enough to eliminate the map and
hardcode the comparisons.</p>
<p>We also define a helper function to get the precedence of the current
token, or -1 if the token is not a binary operator:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Gets the precedence of the current token, or -1 if the token is not a binary</span>
<span class="c"># operator.</span>
<span class="k">def</span> <span class="nf">GetCurrentTokenPrecedence</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">CharacterToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">binop_precedence</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">char</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</pre></div>
</div>
<p>With the helper above defined, we can now start parsing binary
expressions. The basic idea of operator precedence parsing is to break
down an expression with potentially ambiguous binary operators into
pieces. Consider, for example, the expression <tt class="docutils literal"><span class="pre">a+b+(c+d)*e*f+g</span></tt>.
Operator precedence parsing considers this as a stream of primary
expressions separated by binary operators. As such, it will first parse
the leading primary expression <tt class="docutils literal"><span class="pre">a</span></tt>, then it will see the pairs
<tt class="docutils literal"><span class="pre">[+,</span> <span class="pre">b]</span> <span class="pre">[+,</span> <span class="pre">(c+d)]</span> <span class="pre">[*,</span> <span class="pre">e]</span> <span class="pre">[*,</span> <span class="pre">f]</span> <span class="pre">and</span> <span class="pre">[+,</span> <span class="pre">g]</span></tt>. Note that because
parentheses are primary expressions, the binary expression parser
doesn’t need to worry about nested subexpressions like (c+d) at all.</p>
<p>To start, an expression is a primary expression potentially followed by
a sequence of <tt class="docutils literal"><span class="pre">[binop,primaryexpr]</span></tt> pairs:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># expression ::= primary binoprhs</span>
<span class="k">def</span> <span class="nf">ParseExpression</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">left</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrimary</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">left</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> is the function that parses the sequence of pairs for
us. It takes a precedence and a pointer to an expression for the part
that has been parsed so far. Note that <tt class="docutils literal"><span class="pre">x</span></tt> is a perfectly valid
expression: As such, <tt class="docutils literal"><span class="pre">binoprhs</span></tt> is allowed to be empty, in which case
it returns the expression that is passed into it. In our example above,
the code passes the expression for <tt class="docutils literal"><span class="pre">a</span></tt> into <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> and the
current token is <tt class="docutils literal"><span class="pre">+</span></tt>.</p>
<p>The precedence value passed into <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt> indicates the *
minimal operator precedence * that the function is allowed to eat. For
example, if the current pair stream is <tt class="docutils literal"><span class="pre">[+,</span> <span class="pre">x]</span></tt> and <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt>
is passed in a precedence of 40, it will not consume any tokens (because
the precedence of ‘+’ is only 20). With this in mind, <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt>
starts with:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># binoprhs ::= (operator primary)*</span>
<span class="k">def</span> <span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">left_precedence</span><span class="p">):</span>
<span class="c"># If this is a binary operator, find its precedence.</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="n">precedence</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">GetCurrentTokenPrecedence</span><span class="p">()</span>
<span class="c"># If this is a binary operator that binds at least as tightly as the</span>
<span class="c"># current one, consume it; otherwise we are done.</span>
<span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">left_precedence</span><span class="p">:</span>
<span class="k">return</span> <span class="n">left</span>
</pre></div>
</div>
<p>This code gets the precedence of the current token and checks to see if
if is too low. Because we defined invalid tokens to have a precedence of
-1, this check implicitly knows that the pair-stream ends when the token
stream runs out of binary operators. If this check succeeds, we know
that the token is a binary operator and that it will be included in this
expression:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">binary_operator</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">char</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat the operator.</span>
<span class="c"># Parse the primary expression after the binary operator.</span>
<span class="n">right</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrimary</span><span class="p">()</span>
</pre></div>
</div>
<p>As such, this code eats (and remembers) the binary operator and then
parses the primary expression that follows. This builds up the whole
pair, the first of which is <tt class="docutils literal"><span class="pre">[+,</span> <span class="pre">b]</span></tt> for the running example.</p>
<p>Now that we parsed the left-hand side of an expression and one pair of
the RHS sequence, we have to decide which way the expression associates.
In particular, we could have <tt class="docutils literal"><span class="pre">(a+b)</span> <span class="pre">binop</span> <span class="pre">unparsed</span></tt> or
<tt class="docutils literal"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">(b</span> <span class="pre">binop</span> <span class="pre">unparsed)</span></tt>. To determine this, we look ahead at
<tt class="docutils literal"><span class="pre">binop</span></tt> to determine its precedence and compare it to BinOp’s
precedence (which is ‘+’ in this case):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># If binary_operator binds less tightly with right than the operator after</span>
<span class="c"># right, let the pending operator take right as its left.</span>
<span class="n">next_precedence</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">GetCurrentTokenPrecedence</span><span class="p">()</span>
<span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">next_precedence</span><span class="p">:</span>
<span class="o">...</span>
</pre></div>
</div>
<p>If the precedence of the binop to the right of <tt class="docutils literal"><span class="pre">RHS</span></tt> is lower or equal
to the precedence of our current operator, then we know that the
parentheses associate as <tt class="docutils literal"><span class="pre">(a+b)</span> <span class="pre">binop</span> <span class="pre">...</span></tt>. In our example, the
current operator is <tt class="docutils literal"><span class="pre">+</span></tt> and the next operator is <tt class="docutils literal"><span class="pre">+</span></tt>, we know that
they have the same precedence. In this case we’ll create the AST node
for <tt class="docutils literal"><span class="pre">a+b</span></tt>, and then continue parsing:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">next_precedence</span><span class="p">:</span>
<span class="o">...</span> <span class="k">if</span> <span class="n">body</span> <span class="n">omitted</span> <span class="o">...</span>
<span class="c"># Merge left/right.</span>
<span class="n">left</span> <span class="o">=</span> <span class="n">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="n">binary_operator</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">);</span>
</pre></div>
</div>
<p>In our example above, this will turn <tt class="docutils literal"><span class="pre">a+b+</span></tt> into <tt class="docutils literal"><span class="pre">(a+b)</span></tt> and execute
the next iteration of the loop, with <tt class="docutils literal"><span class="pre">+</span></tt> as the current token. The
code above will eat, remember, and parse <tt class="docutils literal"><span class="pre">(c+d)</span></tt> as the primary
expression, which makes the current pair equal to <tt class="docutils literal"><span class="pre">[+,</span> <span class="pre">(c+d)]</span></tt>. It
will then evaluate the ‘if’ conditional above with <tt class="docutils literal"><span class="pre">*</span></tt> as the binop to
the right of the primary. In this case, the precedence of <tt class="docutils literal"><span class="pre">*</span></tt> is
higher than the precedence of <tt class="docutils literal"><span class="pre">+</span></tt> so the if condition will be entered.</p>
<p>The critical question left here is
<tt class="docutils literal"><span class="pre">how</span> <span class="pre">can</span> <span class="pre">the</span> <span class="pre">if</span> <span class="pre">condition</span> <span class="pre">parse</span> <span class="pre">the</span> <span class="pre">right</span> <span class="pre">hand</span> <span class="pre">side</span> <span class="pre">in</span> <span class="pre">full</span></tt>? In
particular, to build the AST correctly for our example, it needs to get
all of <tt class="docutils literal"><span class="pre">(</span> <span class="pre">c</span> <span class="pre">+</span> <span class="pre">d</span> <span class="pre">)</span> <span class="pre">*</span> <span class="pre">e</span> <span class="pre">*</span> <span class="pre">f</span></tt> as the RHS expression variable. The code to
do this is surprisingly simple (code from the above two blocks
duplicated for context):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># If binary_operator binds less tightly with right than the operator after</span>
<span class="c"># right, let the pending operator take right as its left.</span>
<span class="n">next_precedence</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">GetCurrentTokenPrecedence</span><span class="p">()</span>
<span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">next_precedence</span><span class="p">:</span>
<span class="n">right</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">right</span><span class="p">,</span> <span class="n">precedence</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
<span class="c"># Merge left/right.</span>
<span class="n">left</span> <span class="o">=</span> <span class="n">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="n">binary_operator</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">)</span>
</pre></div>
</div>
<p>At this point, we know that the binary operator to the RHS of our
primary has higher precedence than the binop we are currently parsing.
As such, we know that any sequence of pairs whose operators are all
higher precedence than <tt class="docutils literal"><span class="pre">+</span></tt> should be parsed together and returned as
<tt class="docutils literal"><span class="pre">RHS</span></tt>. To do this, we recursively invoke the <tt class="docutils literal"><span class="pre">ParseBinOpRHS</span></tt>
function specifying <tt class="docutils literal"><span class="pre">precedence</span> <span class="pre">+</span> <span class="pre">1</span></tt> as the minimum precedence
required for it to continue. In our example above, this will cause it to
return the AST node for <tt class="docutils literal"><span class="pre">(c+d)*e*f</span></tt> as RHS, which is then set as the
RHS of the ‘+’ expression.</p>
<p>Finally, on the next iteration of the while loop, the <tt class="docutils literal"><span class="pre">+g</span></tt> piece is
parsed and added to the AST. With this little bit of code (11
non-trivial lines), we correctly handle fully general binary expression
parsing in a very elegant way. This was a whirlwind tour of this code,
and it is somewhat subtle. I recommend running through it with a few
tough examples to see how it works.</p>
<p>This wraps up handling of expressions. At this point, we can point the
parser at an arbitrary token stream and build an expression from it,
stopping at the first token that is not part of the expression. Next up
we need to handle function definitions, etc.</p>
</div>
<hr class="docutils" />
<div class="section" id="parsing-the-rest">
<h2>2.6. Parsing the Rest<a class="headerlink" href="#parsing-the-rest" title="Permalink to this headline">¶</a></h2>
<p>The next thing missing is handling of function prototypes. In
Kaleidoscope, these are used both for ‘extern’ function declarations as
well as function body definitions. The code to do this is
straight-forward and not very interesting (once you’ve survived
expressions):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># prototype ::= id '(' id* ')'</span>
<span class="k">def</span> <span class="nf">ParsePrototype</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected function name in prototype.'</span><span class="p">)</span>
<span class="n">function_name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat function name.</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected "(" in prototype.'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">arg_names</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">while</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="n">arg_names</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")" in prototype.'</span><span class="p">)</span>
<span class="c"># Success.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">PrototypeNode</span><span class="p">(</span><span class="n">function_name</span><span class="p">,</span> <span class="n">arg_names</span><span class="p">)</span>
</pre></div>
</div>
<p>Given this, a function definition is very simple, just a prototype plus
an expression to implement the body:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># definition ::= 'def' prototype expression</span>
<span class="k">def</span> <span class="nf">ParseDefinition</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat def.</span>
<span class="n">proto</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrototype</span><span class="p">()</span>
<span class="n">body</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">()</span>
<span class="k">return</span> <span class="n">FunctionNode</span><span class="p">(</span><span class="n">proto</span><span class="p">,</span> <span class="n">body</span><span class="p">)</span>
</pre></div>
</div>
<p>In addition, we support ‘extern’ to declare functions like ‘sin’ and
‘cos’ as well as to support forward declaration of user functions. These
‘extern’s are just prototypes with no body:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># external ::= 'extern' prototype</span>
<span class="k">def</span> <span class="nf">ParseExtern</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat extern.</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrototype</span><span class="p">()</span>
</pre></div>
</div>
<p>Finally, we’ll also let the user type in arbitrary top-level expressions
and evaluate them on the fly. We will handle this by defining anonymous
nullary (zero argument) functions for them:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># toplevelexpr ::= expression</span>
<span class="k">def</span> <span class="nf">ParseTopLevelExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">proto</span> <span class="o">=</span> <span class="n">PrototypeNode</span><span class="p">(</span><span class="s">''</span><span class="p">,</span> <span class="p">[])</span>
<span class="k">return</span> <span class="n">FunctionNode</span><span class="p">(</span><span class="n">proto</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">())</span>
</pre></div>
</div>
<p>Now that we have all the pieces, let’s build a little driver that will
let us actually <em>execute</em> this code we’ve built!</p>
</div>
<hr class="docutils" />
<div class="section" id="the-driver">
<h2>2.7. The Driver<a class="headerlink" href="#the-driver" title="Permalink to this headline">¶</a></h2>
<p>The driver for this simply invokes all of the parsing pieces with a
top-level dispatch loop. There isn’t much interesting here, so I’ll just
include the top-level loop. See <a class="reference internal" href="PythonLangImpl7.html#code"><em>below</em></a> for full code.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Run the main "interpreter loop".</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="k">print</span> <span class="s">'ready>'</span><span class="p">,</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">raw</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">()</span>
<span class="k">except</span> <span class="ne">KeyboardInterrupt</span><span class="p">:</span>
<span class="k">return</span>
<span class="n">parser</span> <span class="o">=</span> <span class="n">Parser</span><span class="p">(</span><span class="n">Tokenize</span><span class="p">(</span><span class="n">raw</span><span class="p">),</span> <span class="n">operator_precedence</span><span class="p">)</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="c"># top ::= definition | external | expression | EOF</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">EOFToken</span><span class="p">):</span>
<span class="k">break</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">DefToken</span><span class="p">):</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleDefinition</span><span class="p">()</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">ExternToken</span><span class="p">):</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleExtern</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleTopLevelExpression</span><span class="p">()</span>
</pre></div>
</div>
<p>Here we create a new <tt class="docutils literal"><span class="pre">Parser</span></tt> for each line read, and try to parse out
all the expressions, declarations and definitions in the line. We also
allow the user to quit using Ctrl+C.</p>
</div>
<hr class="docutils" />
<div class="section" id="conclusions">
<h2>2.8. Conclusions<a class="headerlink" href="#conclusions" title="Permalink to this headline">¶</a></h2>
<p>With just under 330 lines of commented code (200 lines of non-comment,
non-blank code), we fully defined our minimal language, including a
lexer, parser, and AST builder. With this done, the executable will
validate Kaleidoscope code and tell us if it is grammatically invalid.
For example, here is a sample interaction:</p>
<div class="highlight-bash"><pre>$ python kaleidoscope.py
ready> def foo(x y) x+foo(y, 4.0)
Parsed a function definition.
ready> def foo(x y) x+y y
Parsed a function definition.
Parsed a top-level expression.
ready> def foo(x y) x+y )
Parsed a function definition.
Error: Unknown token when expecting an expression.
ready> extern sin(a);
Parsed an extern.
ready> ^C
$</pre>
</div>
<p>There is a lot of room for extension here. You can define new AST nodes,
extend the language in many ways, etc. In the <a class="reference external" href="PythonLangImpl3.html">next
installment</a>, we will describe how to generate
LLVM Intermediate Representation (IR) from the AST.</p>
<hr class="docutils" />
</div>
<div class="section" id="full-code-listing">
<span id="code"></span><h2>2.9. Full Code Listing<a class="headerlink" href="#full-code-listing" title="Permalink to this headline">¶</a></h2>
<p>Here is the complete code listing for this and the previous chapter.
Note that it is fully self-contained: you don’t need LLVM or any
external libraries at all for this.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c">#!/usr/bin/env python</span>
<span class="kn">import</span> <span class="nn">re</span>
</pre></div>
</div>
<div class="section" id="lexer">
<h3>2.9.1. Lexer<a class="headerlink" href="#lexer" title="Permalink to this headline">¶</a></h3>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># The lexer yields one of these types for each token.</span>
<span class="k">class</span> <span class="nc">EOFToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">DefToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">ExternToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">class</span> <span class="nc">IdentifierToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
<span class="k">class</span> <span class="nc">NumberToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
<span class="k">class</span> <span class="nc">CharacterToken</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">char</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">char</span> <span class="o">=</span> <span class="n">char</span>
<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">CharacterToken</span><span class="p">)</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">char</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">char</span>
<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="ow">not</span> <span class="bp">self</span> <span class="o">==</span> <span class="n">other</span>
<span class="c"># Regular expressions that tokens and comments of our language.</span>
<span class="n">REGEX_NUMBER</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="s">'[0-9]+(?:\.[0-9]+)?'</span><span class="p">)</span>
<span class="n">REGEX_IDENTIFIER</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="s">'[a-zA-Z][a-zA-Z0-9]*'</span><span class="p">)</span>
<span class="n">REGEX_COMMENT</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="s">'#.*'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">Tokenize</span><span class="p">(</span><span class="n">string</span><span class="p">):</span>
<span class="k">while</span> <span class="n">string</span><span class="p">:</span>
<span class="c"># Skip whitespace.</span>
<span class="k">if</span> <span class="n">string</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">isspace</span><span class="p">():</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">string</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="k">continue</span>
<span class="c"># Run regexes.</span>
<span class="n">comment_match</span> <span class="o">=</span> <span class="n">REGEX_COMMENT</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<span class="n">number_match</span> <span class="o">=</span> <span class="n">REGEX_NUMBER</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<span class="n">identifier_match</span> <span class="o">=</span> <span class="n">REGEX_IDENTIFIER</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
<span class="c"># Check if any of the regexes matched and yield the appropriate result.</span>
<span class="k">if</span> <span class="n">comment_match</span><span class="p">:</span>
<span class="n">comment</span> <span class="o">=</span> <span class="n">comment_match</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">string</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">comment</span><span class="p">):]</span>
<span class="k">elif</span> <span class="n">number_match</span><span class="p">:</span>
<span class="n">number</span> <span class="o">=</span> <span class="n">number_match</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="k">yield</span> <span class="n">NumberToken</span><span class="p">(</span><span class="nb">float</span><span class="p">(</span><span class="n">number</span><span class="p">))</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">string</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">number</span><span class="p">):]</span>
<span class="k">elif</span> <span class="n">identifier_match</span><span class="p">:</span>
<span class="n">identifier</span> <span class="o">=</span> <span class="n">identifier_match</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="c"># Check if we matched a keyword.</span>
<span class="k">if</span> <span class="n">identifier</span> <span class="o">==</span> <span class="s">'def'</span><span class="p">:</span>
<span class="k">yield</span> <span class="n">DefToken</span><span class="p">()</span>
<span class="k">elif</span> <span class="n">identifier</span> <span class="o">==</span> <span class="s">'extern'</span><span class="p">:</span>
<span class="k">yield</span> <span class="n">ExternToken</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">yield</span> <span class="n">IdentifierToken</span><span class="p">(</span><span class="n">identifier</span><span class="p">)</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">string</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">identifier</span><span class="p">):]</span>
<span class="k">else</span><span class="p">:</span>
<span class="c"># Yield the ASCII value of the unknown character.</span>
<span class="k">yield</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="n">string</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="n">string</span> <span class="o">=</span> <span class="n">string</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="k">yield</span> <span class="n">EOFToken</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="abstract-syntax-tree-aka-parse-tree">
<h3>2.9.2. Abstract Syntax Tree (aka Parse Tree)<a class="headerlink" href="#abstract-syntax-tree-aka-parse-tree" title="Permalink to this headline">¶</a></h3>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Base class for all expression nodes.</span>
<span class="k">class</span> <span class="nc">ExpressionNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">pass</span>
<span class="c"># Expression class for numeric literals like "1.0".</span>
<span class="k">class</span> <span class="nc">NumberExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
<span class="c"># Expression class for referencing a variable, like "a".</span>
<span class="k">class</span> <span class="nc">VariableExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
<span class="c"># Expression class for a binary operator.</span>
<span class="k">class</span> <span class="nc">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">operator</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">operator</span> <span class="o">=</span> <span class="n">operator</span>
<span class="bp">self</span><span class="o">.</span><span class="n">left</span> <span class="o">=</span> <span class="n">left</span>
<span class="bp">self</span><span class="o">.</span><span class="n">right</span> <span class="o">=</span> <span class="n">right</span>
<span class="c"># Expression class for function calls.</span>
<span class="k">class</span> <span class="nc">CallExpressionNode</span><span class="p">(</span><span class="n">ExpressionNode</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">callee</span><span class="p">,</span> <span class="n">args</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">callee</span> <span class="o">=</span> <span class="n">callee</span>
<span class="bp">self</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>
<span class="c"># This class represents the "prototype" for a function, which captures its name,</span>
<span class="c"># and its argument names (thus implicitly the number of arguments the function</span>
<span class="c"># takes).</span>
<span class="k">class</span> <span class="nc">PrototypeNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">args</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>
<span class="c"># This class represents a function definition itself.</span>
<span class="k">class</span> <span class="nc">FunctionNode</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">prototype</span><span class="p">,</span> <span class="n">body</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">prototype</span> <span class="o">=</span> <span class="n">prototype</span>
<span class="bp">self</span><span class="o">.</span><span class="n">body</span> <span class="o">=</span> <span class="n">body</span>
</pre></div>
</div>
</div>
<div class="section" id="id2">
<h3>2.9.3. Parser<a class="headerlink" href="#id2" title="Permalink to this headline">¶</a></h3>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Parser</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">tokens</span><span class="p">,</span> <span class="n">binop_precedence</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">tokens</span> <span class="o">=</span> <span class="n">tokens</span>
<span class="bp">self</span><span class="o">.</span><span class="n">binop_precedence</span> <span class="o">=</span> <span class="n">binop_precedence</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="c"># Provide a simple token buffer. Parser.current is the current token the</span>
<span class="c"># parser is looking at. Parser.Next() reads another token from the lexer and</span>
<span class="c"># updates Parser.current with its results.</span>
<span class="k">def</span> <span class="nf">Next</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="o">.</span><span class="n">next</span><span class="p">()</span>
<span class="c"># Gets the precedence of the current token, or -1 if the token is not a binary</span>
<span class="c"># operator.</span>
<span class="k">def</span> <span class="nf">GetCurrentTokenPrecedence</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">CharacterToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">binop_precedence</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">char</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
<span class="c"># identifierexpr ::= identifier | identifier '(' expression* ')'</span>
<span class="k">def</span> <span class="nf">ParseIdentifierExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">identifier_name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat identifier.</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span> <span class="c"># Simple variable reference.</span>
<span class="k">return</span> <span class="n">VariableExpressionNode</span><span class="p">(</span><span class="n">identifier_name</span><span class="p">)</span>
<span class="c"># Call.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="n">args</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">())</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">==</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">break</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">','</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")" or "," in argument list.'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">CallExpressionNode</span><span class="p">(</span><span class="n">identifier_name</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="c"># numberexpr ::= number</span>
<span class="k">def</span> <span class="nf">ParseNumberExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">NumberExpressionNode</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># consume the number.</span>
<span class="k">return</span> <span class="n">result</span>
<span class="c"># parenexpr ::= '(' expression ')'</span>
<span class="k">def</span> <span class="nf">ParseParenExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">contents</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")".'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">contents</span>
<span class="c"># primary ::= identifierexpr | numberexpr | parenexpr</span>
<span class="k">def</span> <span class="nf">ParsePrimary</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseIdentifierExpr</span><span class="p">()</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">NumberToken</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseNumberExpr</span><span class="p">()</span>
<span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">==</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseParenExpr</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Unknown token when expecting an expression.'</span><span class="p">)</span>
<span class="c"># binoprhs ::= (operator primary)*</span>
<span class="k">def</span> <span class="nf">ParseBinOpRHS</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">left_precedence</span><span class="p">):</span>
<span class="c"># If this is a binary operator, find its precedence.</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="n">precedence</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">GetCurrentTokenPrecedence</span><span class="p">()</span>
<span class="c"># If this is a binary operator that binds at least as tightly as the</span>
<span class="c"># current one, consume it; otherwise we are done.</span>
<span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">left_precedence</span><span class="p">:</span>
<span class="k">return</span> <span class="n">left</span>
<span class="n">binary_operator</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">char</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat the operator.</span>
<span class="c"># Parse the primary expression after the binary operator.</span>
<span class="n">right</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrimary</span><span class="p">()</span>
<span class="c"># If binary_operator binds less tightly with right than the operator after</span>
<span class="c"># right, let the pending operator take right as its left.</span>
<span class="n">next_precedence</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">GetCurrentTokenPrecedence</span><span class="p">()</span>
<span class="k">if</span> <span class="n">precedence</span> <span class="o"><</span> <span class="n">next_precedence</span><span class="p">:</span>
<span class="n">right</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">right</span><span class="p">,</span> <span class="n">precedence</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
<span class="c"># Merge left/right.</span>
<span class="n">left</span> <span class="o">=</span> <span class="n">BinaryOperatorExpressionNode</span><span class="p">(</span><span class="n">binary_operator</span><span class="p">,</span> <span class="n">left</span><span class="p">,</span> <span class="n">right</span><span class="p">)</span>
<span class="c"># expression ::= primary binoprhs</span>
<span class="k">def</span> <span class="nf">ParseExpression</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">left</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrimary</span><span class="p">()</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseBinOpRHS</span><span class="p">(</span><span class="n">left</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="c"># prototype ::= id '(' id* ')'</span>
<span class="k">def</span> <span class="nf">ParsePrototype</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected function name in prototype.'</span><span class="p">)</span>
<span class="n">function_name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat function name.</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">'('</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected "(" in prototype.'</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat '('.</span>
<span class="n">arg_names</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">while</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">IdentifierToken</span><span class="p">):</span>
<span class="n">arg_names</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">current</span><span class="o">.</span><span class="n">name</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">current</span> <span class="o">!=</span> <span class="n">CharacterToken</span><span class="p">(</span><span class="s">')'</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">'Expected ")" in prototype.'</span><span class="p">)</span>
<span class="c"># Success.</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat ')'.</span>
<span class="k">return</span> <span class="n">PrototypeNode</span><span class="p">(</span><span class="n">function_name</span><span class="p">,</span> <span class="n">arg_names</span><span class="p">)</span>
<span class="c"># definition ::= 'def' prototype expression</span>
<span class="k">def</span> <span class="nf">ParseDefinition</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat def.</span>
<span class="n">proto</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrototype</span><span class="p">()</span>
<span class="n">body</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">()</span>
<span class="k">return</span> <span class="n">FunctionNode</span><span class="p">(</span><span class="n">proto</span><span class="p">,</span> <span class="n">body</span><span class="p">)</span>
<span class="c"># toplevelexpr ::= expression</span>
<span class="k">def</span> <span class="nf">ParseTopLevelExpr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">proto</span> <span class="o">=</span> <span class="n">PrototypeNode</span><span class="p">(</span><span class="s">''</span><span class="p">,</span> <span class="p">[])</span>
<span class="k">return</span> <span class="n">FunctionNode</span><span class="p">(</span><span class="n">proto</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParseExpression</span><span class="p">())</span>
<span class="c"># external ::= 'extern' prototype</span>
<span class="k">def</span> <span class="nf">ParseExtern</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># eat extern.</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">ParsePrototype</span><span class="p">()</span>
<span class="c"># Top-Level parsing</span>
<span class="k">def</span> <span class="nf">HandleDefinition</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ParseDefinition</span><span class="p">,</span> <span class="s">'Parsed a function definition.'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">HandleExtern</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ParseExtern</span><span class="p">,</span> <span class="s">'Parsed an extern.'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">HandleTopLevelExpression</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ParseTopLevelExpr</span><span class="p">,</span> <span class="s">'Parsed a top-level expression.'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">Handle</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">function</span><span class="p">,</span> <span class="n">message</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">function</span><span class="p">()</span>
<span class="k">print</span> <span class="n">message</span>
<span class="k">except</span> <span class="ne">Exception</span><span class="p">,</span> <span class="n">e</span><span class="p">:</span>
<span class="k">print</span> <span class="s">'Error:'</span><span class="p">,</span> <span class="n">e</span>
<span class="k">try</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">Next</span><span class="p">()</span> <span class="c"># Skip for error recovery.</span>
<span class="k">except</span><span class="p">:</span>
<span class="k">pass</span>
</pre></div>
</div>
</div>
<div class="section" id="main-driver-code">
<h3>2.9.4. Main driver code.<a class="headerlink" href="#main-driver-code" title="Permalink to this headline">¶</a></h3>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="c"># Install standard binary operators.</span>
<span class="c"># 1 is lowest possible precedence. 40 is the highest.</span>
<span class="n">operator_precedence</span> <span class="o">=</span> <span class="p">{</span>
<span class="s">'<'</span><span class="p">:</span> <span class="mi">10</span><span class="p">,</span>
<span class="s">'+'</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span>
<span class="s">'-'</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span>
<span class="s">'*'</span><span class="p">:</span> <span class="mi">40</span>
<span class="p">}</span>
<span class="c"># Run the main "interpreter loop".</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="k">print</span> <span class="s">'ready>'</span><span class="p">,</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">raw</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">()</span>
<span class="k">except</span> <span class="ne">KeyboardInterrupt</span><span class="p">:</span>
<span class="k">return</span>
<span class="n">parser</span> <span class="o">=</span> <span class="n">Parser</span><span class="p">(</span><span class="n">Tokenize</span><span class="p">(</span><span class="n">raw</span><span class="p">),</span> <span class="n">operator_precedence</span><span class="p">)</span>
<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
<span class="c"># top ::= definition | external | expression | EOF</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">EOFToken</span><span class="p">):</span>
<span class="k">break</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">DefToken</span><span class="p">):</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleDefinition</span><span class="p">()</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">parser</span><span class="o">.</span><span class="n">current</span><span class="p">,</span> <span class="n">ExternToken</span><span class="p">):</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleExtern</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">parser</span><span class="o">.</span><span class="n">HandleTopLevelExpression</span><span class="p">()</span>
<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">'__main__'</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">2. Chapter 2: Implementing a Parser and AST</a><ul>
<li><a class="reference internal" href="#introduction">2.1. Introduction</a></li>
<li><a class="reference internal" href="#the-abstract-syntax-tree-ast">2.2. The Abstract Syntax Tree (AST)</a></li>
<li><a class="reference internal" href="#parser-basics">2.3. Parser Basics</a></li>
<li><a class="reference internal" href="#basic-expression-parsing">2.4. Basic Expression Parsing</a></li>
<li><a class="reference internal" href="#binary-expression-parsing">2.5. Binary Expression Parsing</a></li>
<li><a class="reference internal" href="#parsing-the-rest">2.6. Parsing the Rest</a></li>
<li><a class="reference internal" href="#the-driver">2.7. The Driver</a></li>
<li><a class="reference internal" href="#conclusions">2.8. Conclusions</a></li>
<li><a class="reference internal" href="#full-code-listing">2.9. Full Code Listing</a><ul>
<li><a class="reference internal" href="#lexer">2.9.1. Lexer</a></li>
<li><a class="reference internal" href="#abstract-syntax-tree-aka-parse-tree">2.9.2. Abstract Syntax Tree (aka Parse Tree)</a></li>
<li><a class="reference internal" href="#id2">2.9.3. Parser</a></li>
<li><a class="reference internal" href="#main-driver-code">2.9.4. Main driver code.</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="PythonLangImpl1.html"
title="previous chapter">1. Chapter 1: Tutorial Introduction and the Lexer</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="PythonLangImpl3.html"
title="next chapter">3. Chapter 3: Code generation to LLVM IR</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../../_sources/doc/kaleidoscope/PythonLangImpl2.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="PythonLangImpl3.html" title="3. Chapter 3: Code generation to LLVM IR"
>next</a> |</li>
<li class="right" >
<a href="PythonLangImpl1.html" title="1. Chapter 1: Tutorial Introduction and the Lexer"
>previous</a> |</li>
<li><a href="../../index.html">llvmpy tag: 0.12.0 documentation</a> »</li>
<li><a href="../examples.html" >Examples and LLVM Tutorials</a> »</li>
<li><a href="index.html" >Kaleidoscope</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2013, Mahadevan R (2008-2010), Continuum Analytics (2012-2013).
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
</body>
</html>
