from this grammar file. Jison is a bottom-up parser generator, similar in
style to <ahref="http://www.gnu.org/software/bison">Bison</a>, implemented in JavaScript.
It can recognize <ahref="http://en.wikipedia.org/wiki/LR_grammar">LALR(1), LR(0), SLR(1), and LR(1)</a>
type grammars. To create the Jison parser, we list the pattern to match
on the left-hand side, and the action to take (usually the creation of syntax
tree nodes) on the right. As the parser runs, it
shifts tokens from our token stream, from left to right, and
<ahref="http://en.wikipedia.org/wiki/Bottom-up_parsing">attempts to match</a>
the token sequence against the rules below. When a match can be made, it
reduces into the <ahref="http://en.wikipedia.org/wiki/Terminal_and_nonterminal_symbols">nonterminal</a>
(the enclosing name at the top), and we proceed from there.</p>
<p>If you run the <code>cake build:parser</code> command, Jison constructs a parse table
from our rules and saves it into <code>lib/parser.js</code>.</p></td><tdclass="code"><divclass="highlight"><pre></pre></div></td></tr><trid="section-2"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-2">#</a></div><p>The only dependency is on the <strong>Jison.Parser</strong>.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Parser: </span><spanclass="nx">require</span><spanclass="p">(</span><spanclass="s1">'jison'</span><spanclass="p">).</span><spanclass="nx">Parser</span></pre></div></td></tr><trid="section-3"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-3">#</a></div><h2>Jison DSL</h2></td><tdclass="code"><divclass="highlight"><pre></pre></div></td></tr><trid="section-4"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-4">#</a></div><p>Since we're going to be wrapped in a function by Jison in any case, if our
action immediately returns a value, we can optimize by removing the function
wrapper and just returning the value directly.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">unwrap: </span><spanclass="o">/</span><spanclass="nx">function</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="o">*</span><spanclass="err">\</span><spanclass="p">(</span><spanclass="err">\</span><spanclass="p">)</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="o">*</span><spanclass="err">\</span><spanclass="p">{</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="o">*</span><spanclass="k">return</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="o">*</span><spanclass="p">([</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="err">\</span><spanclass="nx">S</span><spanclass="p">]</span><spanclass="o">*</span><spanclass="p">);</span><spanclass="err">\</span><spanclass="nx">s</span><spanclass="o">*</span><spanclass="err">\</span><spanclass="p">}</span><spanclass="o">/</span></pre></div></td></tr><trid="section-5"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-5">#</a></div><p>Our handy DSL for Jison grammar generation, thanks to
<spanclass="p">[</span><spanclass="nx">pattern_string</span><spanclass="p">,</span><spanclass="s2">"$$ = $action;"</span><spanclass="p">,</span><spanclass="nx">options</span><spanclass="p">]</span></pre></div></td></tr><trid="section-6"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-6">#</a></div><h2>Grammatical Rules</h2></td><tdclass="code"><divclass="highlight"><pre></pre></div></td></tr><trid="section-7"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-7">#</a></div><p>In all of the rules that follow, you'll see the name of the nonterminal as
the key to a list of alternative matches. With each match's action, the
dollar-sign variables are provided by Jison as references to the value of
their numeric position, so in this rule:</p>
<pre><code>"Expression UNLESS Expression"
</code></pre>
<p><code>$1</code> would be the value of the first <code>Expression</code>, <code>$2</code> would be the token
for the <code>UNLESS</code> terminal, and <code>$3</code> would be the value of the second
<code>Expression</code>.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">grammar: </span><spanclass="p">{</span></pre></div></td></tr><trid="section-8"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-8">#</a></div><p>The <strong>Root</strong> is the top-level node in the syntax tree. Since we parse bottom-up,
all parsing must end here.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Root: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-9"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-9">#</a></div><p>Any list of expressions or method body, seperated by line breaks or
<spanclass="p">]</span></pre></div></td></tr><trid="section-10"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-10">#</a></div><p>All the different types of expressions in our language. The basic unit of
CoffeeScript is the <strong>Expression</strong> -- you'll notice that there is no
"statement" nonterminal. Expressions serve as the building blocks
of many other rules, making them somewhat circular.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Expression: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-11"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-11">#</a></div><p>A an indented block of expressions. Note that the <ahref="rewriter.html">Rewriter</a>
will convert some postfix forms into blocks for us, by adjusting the
<spanclass="p">]</span></pre></div></td></tr><trid="section-12"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-12">#</a></div><p>A literal identifier, a variable name or property.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Identifier: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-13"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-13">#</a></div><p>Alphanumerics are separated from the other <strong>Literal</strong> matchers because
they can also serve as keys in object literals.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">AlphaNumeric: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-14"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-14">#</a></div><p>All of our immediate values. These can (in general), be passed straight
through and printed to JavaScript.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Literal: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-15"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-15">#</a></div><p>Assignment of a variable, property, or index to a value.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Assign: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-16"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-16">#</a></div><p>Assignment when it happens within an object literal. The difference from
the ordinary <strong>Assign</strong> is that these allow numbers and strings as keys.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">AssignObj: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-17"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-17">#</a></div><p>A return statement from a function body.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Return: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-18"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-18">#</a></div><p>A comment. Because CoffeeScript passes comments through to JavaScript, we
have to parse comments like any other construct, and identify all of the
positions in which they can occur in the grammar.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Comment: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-20"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-20">#</a></div><p>The <strong>Code</strong> node is the function literal. It's defined by an indented block
of <strong>Expressions</strong> preceded by a function arrow, with an optional parameter
<spanclass="p">]</span></pre></div></td></tr><trid="section-21"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-21">#</a></div><p>CoffeeScript has two different symbols for functions. <code>-></code> is for ordinary
functions, and <code>=></code> is for functions bound to the current value of <em>this</em>.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">FuncGlyph: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-22"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-22">#</a></div><p>The list of parameters that a function accepts can be of any length.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">ParamList: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-23"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-23">#</a></div><p>A single parameter in a function definition can be ordinary, or a splat
that hoovers up the remaining arguments.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Param: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-24"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-24">#</a></div><p>A splat that occurs outside of a parameter list.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Splat: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-25"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-25">#</a></div><p>Variables and properties that can be assigned to.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">SimpleAssignable: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-26"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-26">#</a></div><p>Everything that can be assigned to.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Assignable: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-27"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-27">#</a></div><p>The types of things that can be treated as values -- assigned to, invoked
as functions, indexed into, named as a class, etc.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Value: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-28"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-28">#</a></div><p>The general group of accessors into an object, by property, by prototype
<spanclass="p">]</span></pre></div></td></tr><trid="section-29"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-29">#</a></div><p>Indexing into an object or array using bracket notation.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Index: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-30"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-30">#</a></div><p>In CoffeeScript, an object literal is simply a list of assignments.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nb">Object</span><spanclass="o">:</span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-31"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-31">#</a></div><p>Class definitions have optional bodies of prototype property assignments,
<spanclass="nx">o</span><spanclass="s2">"CLASS SimpleAssignable EXTENDS Value IndentedAssignList"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">ClassNode</span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nx">$4</span><spanclass="p">,</span><spanclass="nx">$5</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-32"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-32">#</a></div><p>Assignment of properties within an object literal can be separated by
comma, as in JavaScript, or simply by newline.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">AssignList: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-33"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-33">#</a></div><p>An <strong>AssignList</strong> within a block indentation.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">IndentedAssignList: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-34"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-34">#</a></div><p>The three flavors of function call: normal, object instantiation with <code>new</code>,
<spanclass="p">]</span></pre></div></td></tr><trid="section-35"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-35">#</a></div><p>Binds a function call to a context and/or arguments.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Curry: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-36"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-36">#</a></div><p>Extending an object by setting its prototype chain to reference a parent
<spanclass="p">]</span></pre></div></td></tr><trid="section-37"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-37">#</a></div><p>Ordinary function invocation, or a chained series of calls.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Invocation: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-38"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-38">#</a></div><p>The list of arguments to a function call.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Arguments: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-40"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-40">#</a></div><p>A reference to the <em>this</em> current object.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">This: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-41"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-41">#</a></div><p>A reference to a property on <em>this</em>.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">ThisProperty: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-42"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-42">#</a></div><p>The CoffeeScript range literal.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Range: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-45"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-45">#</a></div><p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
(i.e. comma-separated expressions). Newlines work as well.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">ArgList: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-46"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-46">#</a></div><p>Just simple, comma-separated, required arguments (no fancy syntax). We need
<spanclass="p">]</span></pre></div></td></tr><trid="section-48"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-48">#</a></div><p>A catch clause names its error and runs a block of code.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Catch: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-49"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-49">#</a></div><p>Throw an exception object.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Throw: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-50"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-50">#</a></div><p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
<spanclass="p">]</span></pre></div></td></tr><trid="section-51"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-51">#</a></div><p>A language extension to CoffeeScript from the outside. We simply pass
<spanclass="p">]</span></pre></div></td></tr><trid="section-52"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-52">#</a></div><p>The condition portion of a while loop.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">WhileSource: </span><spanclass="p">[</span>
<spanclass="nx">o</span><spanclass="s2">"WHILE Expression WHEN Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">WhileNode</span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="p">{</span><spanclass="nx">filter</span><spanclass="o">:</span><spanclass="nx">$4</span><spanclass="p">}</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-53"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-53">#</a></div><p>The while loop can either be normal, with a block of expressions to execute,
or postfix, with a single expression. There is no do..while.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">While: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-54"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-54">#</a></div><p>Array, object, and range comprehensions, at the most generic level.
Comprehensions can either be normal, with a block of expressions to execute,
or postfix, with a single expression.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">For: </span><spanclass="p">[</span>
<spanclass="nx">o</span><spanclass="s2">"Expression FOR ForVariables ForSource"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">ForNode</span><spanclass="nx">$1</span><spanclass="p">,</span><spanclass="nx">$4</span><spanclass="p">,</span><spanclass="nx">$3</span><spanclass="p">[</span><spanclass="mi">0</span><spanclass="p">],</span><spanclass="nx">$3</span><spanclass="p">[</span><spanclass="mi">1</span><spanclass="p">]</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-55"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-55">#</a></div><p>An array or range comprehension has variables for the current element and
<spanclass="p">]</span></pre></div></td></tr><trid="section-56"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-56">#</a></div><p>The source of a comprehension is an array or object with an optional filter
clause. If it's an array comprehension, you can also choose to step through
<spanclass="nx">o</span><spanclass="s2">"IN Expression WHEN Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">{</span><spanclass="nv">source: </span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nv">filter: </span><spanclass="nx">$4</span><spanclass="p">}</span>
<spanclass="nx">o</span><spanclass="s2">"OF Expression WHEN Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">{</span><spanclass="nv">source: </span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nv">filter: </span><spanclass="nx">$4</span><spanclass="p">,</span><spanclass="nv">object: </span><spanclass="kc">true</span><spanclass="p">}</span>
<spanclass="nx">o</span><spanclass="s2">"IN Expression BY Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">{</span><spanclass="nv">source: </span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nv">step: </span><spanclass="nx">$4</span><spanclass="p">}</span>
<spanclass="nx">o</span><spanclass="s2">"IN Expression WHEN Expression BY Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">{</span><spanclass="nv">source: </span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nv">filter: </span><spanclass="nx">$4</span><spanclass="p">;</span><spanclass="nv">step: </span><spanclass="nx">$6</span><spanclass="p">}</span>
<spanclass="nx">o</span><spanclass="s2">"IN Expression BY Expression WHEN Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">{</span><spanclass="nv">source: </span><spanclass="nx">$2</span><spanclass="p">,</span><spanclass="nv">step: </span><spanclass="nx">$4</span><spanclass="p">,</span><spanclass="nv">filter: </span><spanclass="nx">$6</span><spanclass="p">}</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-57"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-57">#</a></div><p>The CoffeeScript switch/when/else block replaces the JavaScript
switch/case/default by compiling into an if-else chain.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">Switch: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-58"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-58">#</a></div><p>The inner list of whens is left recursive. At code-generation time, the
<spanclass="p">]</span></pre></div></td></tr><trid="section-60"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-60">#</a></div><p>The most basic form of <em>if</em> is a condition and an action. The following
<spanclass="p">]</span></pre></div></td></tr><trid="section-61"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-61">#</a></div><p>An <strong>IfStart</strong> can optionally be followed by an else block.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">IfBlock: </span><spanclass="p">[</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-62"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-62">#</a></div><p>An <em>else if</em> continuation of the <em>if</em> expression.</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">ElsIf: </span><spanclass="p">[</span>
<spanclass="nx">o</span><spanclass="s2">"ELSE IF Expression Block"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="p">(</span><spanclass="k">new</span><spanclass="nx">IfNode</span><spanclass="p">(</span><spanclass="nx">$3</span><spanclass="p">,</span><spanclass="nx">$4</span><spanclass="p">)).</span><spanclass="nx">force_statement</span><spanclass="p">()</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-63"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-63">#</a></div><p>The full complement of <em>if</em> expressions, including postfix one-liner
<spanclass="nx">o</span><spanclass="s2">"Expression IF Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">IfNode</span><spanclass="nx">$3</span><spanclass="p">,</span><spanclass="nx">Expressions</span><spanclass="p">.</span><spanclass="nx">wrap</span><spanclass="p">([</span><spanclass="nx">$1</span><spanclass="p">]),</span><spanclass="kc">null</span><spanclass="p">,</span><spanclass="p">{</span><spanclass="nv">statement: </span><spanclass="kc">true</span><spanclass="p">}</span>
<spanclass="p">]</span></pre></div></td></tr><trid="section-64"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-64">#</a></div><p>Arithmetic and logical operators, working on one or more operands.
<spanclass="nx">o</span><spanclass="s2">"Expression & Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">OpNode</span><spanclass="s1">'&'</span><spanclass="p">,</span><spanclass="nx">$1</span><spanclass="p">,</span><spanclass="nx">$3</span>
<spanclass="nx">o</span><spanclass="s2">"Expression IN Expression"</span><spanclass="p">,</span><spanclass="o">-></span><spanclass="k">new</span><spanclass="nx">OpNode</span><spanclass="s1">'in'</span><spanclass="p">,</span><spanclass="nx">$1</span><spanclass="p">,</span><spanclass="nx">$3</span>
<spanclass="p">}</span></pre></div></td></tr><trid="section-65"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-65">#</a></div><h2>Precedence</h2></td><tdclass="code"><divclass="highlight"><pre></pre></div></td></tr><trid="section-66"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-66">#</a></div><p>Operators at the top of this list have higher precedence than the ones lower
<spanclass="p">]</span></pre></div></td></tr><trid="section-67"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-67">#</a></div><h2>Wrapping Up</h2></td><tdclass="code"><divclass="highlight"><pre></pre></div></td></tr><trid="section-68"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-68">#</a></div><p>Finally, now what we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
<spanclass="nx">alt</span></pre></div></td></tr><trid="section-69"><tdclass="docs"><divclass="octowrap"><aclass="octothorpe"href="#section-69">#</a></div><p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
rules, and the name of the root. Reverse the operators because Jison orders
precedence from low to high, and we have it high to low
(as in <ahref="http://dinosaur.compilertools.net/yacc/index.html">Yacc</a>).</p></td><tdclass="code"><divclass="highlight"><pre><spanclass="nv">exports.parser: </span><spanclass="k">new</span><spanclass="nx">Parser</span><spanclass="p">{</span>