mirror of
https://github.com/jashkenas/coffeescript.git
synced 2022-11-09 12:23:24 -05:00
rebuilding docs and compressed version for CoffeeScript 0.7.1
This commit is contained in:
Jeremy Ashkenas
parent
2a7a26482a
commit
e40d25e4bd
16 changed files with 319 additions and 215 deletions
|
|
@ -33,7 +33,7 @@ top-level statement within the function body.</p> </td>
|
|||
<span class="nx">del</span> <span class="nx">@options</span><span class="p">,</span> <span class="s1">'chainRoot'</span> <span class="nx">unless</span> <span class="k">this</span> <span class="k">instanceof</span> <span class="nx">AccessorNode</span> <span class="o">or</span> <span class="k">this</span> <span class="k">instanceof</span> <span class="nx">IndexNode</span>
|
||||
<span class="nv">top: </span> <span class="k">if</span> <span class="nx">@topSensitive</span><span class="p">()</span> <span class="k">then</span> <span class="nx">@options</span><span class="p">.</span><span class="nx">top</span> <span class="k">else</span> <span class="nx">del</span> <span class="nx">@options</span><span class="p">,</span> <span class="s1">'top'</span>
|
||||
<span class="nv">closure: </span> <span class="nx">@isStatement</span><span class="p">()</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@isPureStatement</span><span class="p">()</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">top</span> <span class="o">and</span>
|
||||
<span class="o">not</span> <span class="nx">@options</span><span class="p">.</span><span class="nx">asStatement</span> <span class="o">and</span>
|
||||
<span class="o">not</span> <span class="nx">@options</span><span class="p">.</span><span class="nx">asStatement</span> <span class="o">and</span> <span class="o">not</span> <span class="p">(</span><span class="k">this</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span><span class="p">)</span> <span class="o">and</span>
|
||||
<span class="o">not</span> <span class="nx">@containsPureStatement</span><span class="p">()</span>
|
||||
<span class="k">if</span> <span class="nx">closure</span> <span class="k">then</span> <span class="nx">@compileClosure</span><span class="p">(</span><span class="nx">@options</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@compileNode</span><span class="p">(</span><span class="nx">@options</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-7"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-7">#</a> </div> <p>Statements converted into expressions via closure-wrapping share a scope
|
||||
object with their parent closure, to preserve the expected lexical scope.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileClosure: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -70,9 +70,10 @@ scope boundaries.</p> </td> <td class="code">
|
|||
<span class="k">this</span> <span class="k">instanceof</span> <span class="nx">type</span> <span class="o">or</span> <span class="nx">@contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span> <span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">type</span></pre></div> </td> </tr> <tr id="section-13"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-13">#</a> </div> <p>Convenience for the most common use of contains. Does the node contain
|
||||
a pure statement?</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">containsPureStatement: </span><span class="o">-></span>
|
||||
<span class="nx">@isPureStatement</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span> <span class="nx">n</span><span class="p">.</span><span class="nx">isPureStatement</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-14"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-14">#</a> </div> <p>Perform an in-order traversal of the AST. Crosses scope boundaries.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">traverse: </span><span class="p">(</span><span class="nx">block</span><span class="p">)</span> <span class="o">-></span> <span class="nx">@traverseChildren</span> <span class="kc">true</span><span class="p">,</span> <span class="nx">block</span></pre></div> </td> </tr> <tr id="section-15"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-15">#</a> </div> <p><code>toString</code> representation of the node, for inspecting the parse tree.
|
||||
This is what <code>coffee --nodes</code> prints out.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">toString: </span><span class="p">(</span><span class="nx">idt</span><span class="p">)</span> <span class="o">-></span>
|
||||
This is what <code>coffee --nodes</code> prints out.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">toString: </span><span class="p">(</span><span class="nx">idt</span><span class="p">,</span> <span class="nx">override</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">idt: </span><span class="o">or</span> <span class="s1">''</span>
|
||||
<span class="s1">'\n'</span> <span class="o">+</span> <span class="nx">idt</span> <span class="o">+</span> <span class="nx">@class</span> <span class="o">+</span> <span class="p">(</span><span class="nx">child</span><span class="p">.</span><span class="nx">toString</span><span class="p">(</span><span class="nx">idt</span> <span class="o">+</span> <span class="nx">TAB</span><span class="p">)</span> <span class="k">for</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">@collectChildren</span><span class="p">()).</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
|
||||
<span class="nv">children: </span><span class="p">(</span><span class="nx">child</span><span class="p">.</span><span class="nx">toString</span> <span class="nx">idt</span> <span class="o">+</span> <span class="nx">TAB</span> <span class="k">for</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">@collectChildren</span><span class="p">()).</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
|
||||
<span class="s1">'\n'</span> <span class="o">+</span> <span class="nx">idt</span> <span class="o">+</span> <span class="p">(</span><span class="nx">override</span> <span class="o">or</span> <span class="nx">@class</span><span class="p">)</span> <span class="o">+</span> <span class="nx">children</span>
|
||||
|
||||
<span class="nv">eachChild: </span><span class="p">(</span><span class="nx">func</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">return</span> <span class="nx">unless</span> <span class="nx">@children</span>
|
||||
|
|
@ -92,9 +93,9 @@ This is what <code>coffee --nodes</code> prints out.</p> </td>
|
|||
will override these with custom logic, if needed.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">class: </span> <span class="s1">'BaseNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[]</span>
|
||||
|
||||
<span class="nv">unwrap: </span> <span class="o">-></span> <span class="k">this</span>
|
||||
<span class="nv">unwrap: </span> <span class="o">-></span> <span class="k">this</span>
|
||||
<span class="nv">isStatement: </span> <span class="o">-></span> <span class="kc">no</span>
|
||||
<span class="nv">isPureStatement: </span><span class="o">-></span> <span class="kc">no</span>
|
||||
<span class="nv">isPureStatement: </span> <span class="o">-></span> <span class="kc">no</span>
|
||||
<span class="nv">topSensitive: </span> <span class="o">-></span> <span class="kc">no</span></pre></div> </td> </tr> <tr id="section-17"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-17">#</a> </div> <h3>Expressions</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-18"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-18">#</a> </div> <p>The expressions body is the list of expressions that forms the body of an
|
||||
indented block of code -- the implementation of a function, a clause in an
|
||||
<code>if</code>, <code>switch</code>, or <code>try</code>, and so on...</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Expressions: </span><span class="nx">class</span> <span class="nx">Expressions</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
|
@ -115,6 +116,7 @@ it back out.</p> </td> <td class="code"> <
|
|||
ensures that the final expression is returned.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="nv">idx: </span> <span class="nx">@expressions</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
|
||||
<span class="nv">last: </span><span class="nx">@expressions</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span>
|
||||
<span class="nv">last: </span><span class="nx">@expressions</span><span class="p">[</span><span class="nv">idx: </span><span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="k">if</span> <span class="nx">last</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span>
|
||||
<span class="k">return</span> <span class="k">this</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">last</span> <span class="o">or</span> <span class="nx">last</span> <span class="k">instanceof</span> <span class="nx">ReturnNode</span>
|
||||
<span class="nx">@expressions</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span><span class="o">:</span> <span class="nx">last</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-24"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-24">#</a> </div> <p>An <strong>Expressions</strong> is the only node that can serve as the root.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compile: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -128,14 +130,14 @@ It would be better not to generate them in the first place, but for now,
|
|||
clean up obvious double-parentheses.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileRoot: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.indent: </span><span class="vi">@tab: </span><span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">noWrap</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="nx">TAB</span>
|
||||
<span class="nv">o.scope: </span><span class="k">new</span> <span class="nx">Scope</span><span class="p">(</span><span class="kc">null</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="kc">null</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">globals</span> <span class="k">then</span> <span class="nx">@compileNode</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@compileWithDeclarations</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="nx">@compileWithDeclarations</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="nx">code</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">TRAILING_WHITESPACE</span><span class="p">,</span> <span class="s1">''</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="nx">code</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">DOUBLE_PARENS</span><span class="p">,</span> <span class="s1">'($1)'</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">noWrap</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">"(function(){\n$code\n})();\n"</span></pre></div> </td> </tr> <tr id="section-26"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-26">#</a> </div> <p>Compile the expressions body for the contents of a function, with
|
||||
declarations of all inner variables pushed up to the top.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileWithDeclarations: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">code: </span><span class="nx">@compileNode</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="s2">"${@tab}var ${o.scope.compiledAssignments()};\n$code"</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasAssignments</span><span class="p">(</span><span class="k">this</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="s2">"${@tab}var ${o.scope.compiledDeclarations()};\n$code"</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasDeclarations</span><span class="p">(</span><span class="k">this</span><span class="p">)</span>
|
||||
<span class="nv">code: </span><span class="s2">"${@tab}var ${o.scope.compiledDeclarations()};\n$code"</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">o</span><span class="p">.</span><span class="nx">globals</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasDeclarations</span><span class="p">(</span><span class="k">this</span><span class="p">)</span>
|
||||
<span class="nx">code</span></pre></div> </td> </tr> <tr id="section-27"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-27">#</a> </div> <p>Compiles a single expression within the expressions body. If we need to
|
||||
return the result, and it's an expression, simply return it. If it's a
|
||||
statement, ask the statement to do so.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileExpression: </span><span class="p">(</span><span class="nx">node</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -173,16 +175,15 @@ make sense.</p> </td> <td class="code"> <d
|
|||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">expression</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@expression: </span><span class="nx">expression</span>
|
||||
|
||||
<span class="nv">topSensitive: </span><span class="o">-></span>
|
||||
<span class="kc">true</span>
|
||||
|
||||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="k">this</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">compile: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">expr: </span><span class="nx">@expression</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span>
|
||||
<span class="k">return</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="nx">unless</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">ReturnNode</span>
|
||||
<span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'top'</span>
|
||||
<span class="k">return</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="nx">unless</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">ReturnNode</span>
|
||||
<span class="k">super</span> <span class="nx">o</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.asStatement: </span><span class="kc">true</span> <span class="k">if</span> <span class="nx">@expression</span><span class="p">.</span><span class="nx">isStatement</span><span class="p">()</span>
|
||||
<span class="s2">"${@tab}return ${@expression.compile(o)};"</span></pre></div> </td> </tr> <tr id="section-34"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-34">#</a> </div> <h3>ValueNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-35"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-35">#</a> </div> <p>A value, variable or literal or parenthesized, indexed or dotted into,
|
||||
or vanilla.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ValueNode: </span><span class="nx">class</span> <span class="nx">ValueNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
|
@ -217,14 +218,15 @@ properties.</p> </td> <td class="code"> <d
|
|||
<span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="k">this</span> <span class="o">is</span> <span class="nx">o</span><span class="p">.</span><span class="nx">chainRoot</span> <span class="o">and</span> <span class="nx">@properties</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">instanceof</span> <span class="nx">AccessorNode</span>
|
||||
<span class="nv">node: </span><span class="nx">o</span><span class="p">.</span><span class="nx">chainRoot</span><span class="p">.</span><span class="nx">base</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">chainRoot</span><span class="p">.</span><span class="nx">variable</span>
|
||||
<span class="k">while</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">CallNode</span> <span class="k">then</span> <span class="nv">node: </span><span class="nx">node</span><span class="p">.</span><span class="nx">variable</span>
|
||||
<span class="nx">node</span> <span class="o">is</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-42"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-42">#</a> </div> <p>We compile a value to JavaScript by compiling and joining each property.
|
||||
<span class="nx">node</span> <span class="o">is</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-42"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-42">#</a> </div> <p>Override compile to unwrap the value when possible.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compile: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">if</span> <span class="o">not</span> <span class="nx">o</span><span class="p">.</span><span class="nx">top</span> <span class="o">or</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="k">super</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-43"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-43">#</a> </div> <p>We compile a value to JavaScript by compiling and joining each property.
|
||||
Things get much more insteresting if the chain of properties has <em>soak</em>
|
||||
operators <code>?.</code> interspersed. Then we have to take care not to accidentally
|
||||
evaluate a anything twice when building the soak chain.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">only: </span> <span class="nx">del</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="s1">'onlyFirst'</span><span class="p">)</span>
|
||||
<span class="nv">op: </span> <span class="nx">del</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="s1">'operation'</span><span class="p">)</span>
|
||||
<span class="nv">only: </span> <span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'onlyFirst'</span>
|
||||
<span class="nv">op: </span> <span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'operation'</span>
|
||||
<span class="nv">props: </span> <span class="k">if</span> <span class="nx">only</span> <span class="k">then</span> <span class="nx">@properties</span><span class="p">[</span><span class="mi">0</span><span class="p">...</span><span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="k">else</span> <span class="nx">@properties</span>
|
||||
<span class="nv">o.chainRoot: </span><span class="o">or</span> <span class="k">this</span>
|
||||
<span class="nv">o.chainRoot: </span> <span class="o">or</span> <span class="k">this</span>
|
||||
<span class="nv">baseline: </span> <span class="nx">@base</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
<span class="nv">baseline: </span> <span class="s2">"($baseline)"</span> <span class="k">if</span> <span class="nx">@hasProperties</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@base</span> <span class="k">instanceof</span> <span class="nx">ObjectNode</span> <span class="o">or</span> <span class="nx">@isNumber</span><span class="p">())</span>
|
||||
<span class="nv">complete: </span> <span class="vi">@last: </span><span class="nx">baseline</span>
|
||||
|
|
@ -243,7 +245,21 @@ evaluate a anything twice when building the soak chain.</p> </td>
|
|||
<span class="nv">complete: </span><span class="o">+</span> <span class="nx">part</span>
|
||||
<span class="vi">@last: </span><span class="nx">part</span>
|
||||
|
||||
<span class="k">if</span> <span class="nx">op</span> <span class="o">and</span> <span class="nx">@wrapped</span> <span class="k">then</span> <span class="s2">"($complete)"</span> <span class="k">else</span> <span class="nx">complete</span></pre></div> </td> </tr> <tr id="section-43"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-43">#</a> </div> <h3>CallNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-44"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-44">#</a> </div> <p>Node for a function invocation. Takes care of converting <code>super()</code> calls into
|
||||
<span class="k">if</span> <span class="nx">op</span> <span class="o">and</span> <span class="nx">@wrapped</span> <span class="k">then</span> <span class="s2">"($complete)"</span> <span class="k">else</span> <span class="nx">complete</span></pre></div> </td> </tr> <tr id="section-44"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-44">#</a> </div> <h3>CommentNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-45"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-45">#</a> </div> <p>CoffeeScript passes through block comments as JavaScript block comments
|
||||
at the same position.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.CommentNode: </span><span class="nx">class</span> <span class="nx">CommentNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span><span class="s1">'CommentNode'</span>
|
||||
<span class="nv">isStatement: </span><span class="o">-></span> <span class="kc">yes</span>
|
||||
|
||||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">lines</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@lines: </span><span class="nx">lines</span>
|
||||
|
||||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="k">this</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">sep: </span><span class="s2">"\n$@tab"</span>
|
||||
<span class="s2">"$@tab/*$sep${ @lines.join(sep) }\n$@tab*/"</span></pre></div> </td> </tr> <tr id="section-46"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-46">#</a> </div> <h3>CallNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-47"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-47">#</a> </div> <p>Node for a function invocation. Takes care of converting <code>super()</code> calls into
|
||||
calls against the prototype's function of the same name.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.CallNode: </span><span class="nx">class</span> <span class="nx">CallNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'CallNode'</span>
|
||||
|
|
@ -255,18 +271,18 @@ calls against the prototype's function of the same name.</p> </td>
|
|||
<span class="vi">@variable: </span> <span class="k">if</span> <span class="nx">@isSuper</span> <span class="k">then</span> <span class="kc">null</span> <span class="k">else</span> <span class="nx">variable</span>
|
||||
<span class="vi">@args: </span> <span class="p">(</span><span class="nx">args</span> <span class="o">or</span> <span class="p">[])</span>
|
||||
<span class="vi">@compileSplatArguments: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nx">SplatNode</span><span class="p">.</span><span class="nx">compileMixedArray</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">@args</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-45"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-45">#</a> </div> <p>Tag this invocation as creating a new instance.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">newInstance: </span><span class="o">-></span>
|
||||
<span class="nx">SplatNode</span><span class="p">.</span><span class="nx">compileMixedArray</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">@args</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-48"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-48">#</a> </div> <p>Tag this invocation as creating a new instance.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">newInstance: </span><span class="o">-></span>
|
||||
<span class="vi">@isNew: </span><span class="kc">true</span>
|
||||
<span class="k">this</span>
|
||||
|
||||
<span class="nv">prefix: </span><span class="o">-></span>
|
||||
<span class="k">if</span> <span class="nx">@isNew</span> <span class="k">then</span> <span class="s1">'new '</span> <span class="k">else</span> <span class="s1">''</span></pre></div> </td> </tr> <tr id="section-46"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-46">#</a> </div> <p>Grab the reference to the superclass' implementation of the current method.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">superReference: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">if</span> <span class="nx">@isNew</span> <span class="k">then</span> <span class="s1">'new '</span> <span class="k">else</span> <span class="s1">''</span></pre></div> </td> </tr> <tr id="section-49"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-49">#</a> </div> <p>Grab the reference to the superclass' implementation of the current method.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">superReference: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">methname: </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">method</span><span class="p">.</span><span class="nx">name</span>
|
||||
<span class="nv">meth: </span><span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">method</span><span class="p">.</span><span class="nx">proto</span>
|
||||
<span class="s2">"${o.scope.method.proto}.__superClass__.$methname"</span>
|
||||
<span class="k">else</span> <span class="k">if</span> <span class="nx">methname</span>
|
||||
<span class="s2">"${methname}.__superClass__.constructor"</span>
|
||||
<span class="k">else</span> <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">"cannot call super on an anonymous function."</span></pre></div> </td> </tr> <tr id="section-47"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-47">#</a> </div> <p>Compile a vanilla function call.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">else</span> <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">"cannot call super on an anonymous function."</span></pre></div> </td> </tr> <tr id="section-50"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-50">#</a> </div> <p>Compile a vanilla function call.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.chainRoot: </span><span class="k">this</span> <span class="nx">unless</span> <span class="nx">o</span><span class="p">.</span><span class="nx">chainRoot</span>
|
||||
<span class="k">for</span> <span class="nx">arg</span> <span class="k">in</span> <span class="nx">@args</span> <span class="k">when</span> <span class="nx">arg</span> <span class="k">instanceof</span> <span class="nx">SplatNode</span>
|
||||
<span class="nv">compilation: </span><span class="nx">@compileSplat</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
|
|
@ -274,9 +290,9 @@ calls against the prototype's function of the same name.</p> </td>
|
|||
<span class="nv">args: </span><span class="p">(</span><span class="nx">arg</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">for</span> <span class="nx">arg</span> <span class="k">in</span> <span class="nx">@args</span><span class="p">).</span><span class="nx">join</span><span class="p">(</span><span class="s1">', '</span><span class="p">)</span>
|
||||
<span class="nv">compilation: </span><span class="k">if</span> <span class="nx">@isSuper</span> <span class="k">then</span> <span class="nx">@compileSuper</span><span class="p">(</span><span class="nx">args</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span>
|
||||
<span class="k">else</span> <span class="s2">"${@prefix()}${@variable.compile(o)}($args)"</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">operation</span> <span class="o">and</span> <span class="nx">@wrapped</span> <span class="k">then</span> <span class="s2">"($compilation)"</span> <span class="k">else</span> <span class="nx">compilation</span></pre></div> </td> </tr> <tr id="section-48"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-48">#</a> </div> <p><code>super()</code> is converted into a call against the superclass's implementation
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">operation</span> <span class="o">and</span> <span class="nx">@wrapped</span> <span class="k">then</span> <span class="s2">"($compilation)"</span> <span class="k">else</span> <span class="nx">compilation</span></pre></div> </td> </tr> <tr id="section-51"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-51">#</a> </div> <p><code>super()</code> is converted into a call against the superclass's implementation
|
||||
of the current function.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileSuper: </span><span class="p">(</span><span class="nx">args</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="s2">"${@superReference(o)}.call(this${ if args.length then ', ' else '' }$args)"</span></pre></div> </td> </tr> <tr id="section-49"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-49">#</a> </div> <p>If you call a function with a splat, it's converted into a JavaScript
|
||||
<span class="s2">"${@superReference(o)}.call(this${ if args.length then ', ' else '' }$args)"</span></pre></div> </td> </tr> <tr id="section-52"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-52">#</a> </div> <p>If you call a function with a splat, it's converted into a JavaScript
|
||||
<code>.apply()</code> call to allow an array of arguments to be passed.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileSplat: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">meth: </span><span class="k">if</span> <span class="nx">@variable</span> <span class="k">then</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@superReference</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">obj: </span> <span class="nx">@variable</span> <span class="o">and</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">source</span> <span class="o">or</span> <span class="s1">'this'</span>
|
||||
|
|
@ -284,7 +300,7 @@ of the current function.</p> </td> <td class="code">
|
|||
<span class="nv">temp: </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">()</span>
|
||||
<span class="nv">obj: </span> <span class="nx">temp</span>
|
||||
<span class="nv">meth: </span><span class="s2">"($temp = ${ @variable.source })${ @variable.last }"</span>
|
||||
<span class="s2">"${@prefix()}${meth}.apply($obj, ${ @compileSplatArguments(o) })"</span></pre></div> </td> </tr> <tr id="section-50"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-50">#</a> </div> <h3>ExtendsNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-51"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-51">#</a> </div> <p>Node to extend an object's prototype with an ancestor object.
|
||||
<span class="s2">"${@prefix()}${meth}.apply($obj, ${ @compileSplatArguments(o) })"</span></pre></div> </td> </tr> <tr id="section-53"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-53">#</a> </div> <h3>ExtendsNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-54"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-54">#</a> </div> <p>Node to extend an object's prototype with an ancestor object.
|
||||
After <code>goog.inherits</code> from the
|
||||
<a href="http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.html">Closure Library</a>.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ExtendsNode: </span><span class="nx">class</span> <span class="nx">ExtendsNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -293,9 +309,9 @@ After <code>goog.inherits</code> from the
|
|||
|
||||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">child</span><span class="p">,</span> <span class="nx">parent</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@child: </span><span class="nx">child</span>
|
||||
<span class="vi">@parent: </span><span class="nx">parent</span></pre></div> </td> </tr> <tr id="section-52"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-52">#</a> </div> <p>Hooks one constructor into another's prototype chain.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@parent: </span><span class="nx">parent</span></pre></div> </td> </tr> <tr id="section-55"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-55">#</a> </div> <p>Hooks one constructor into another's prototype chain.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">ref: </span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">literal</span> <span class="nx">utility</span> <span class="s1">'extends'</span>
|
||||
<span class="p">(</span><span class="k">new</span> <span class="nx">CallNode</span> <span class="nx">ref</span><span class="p">,</span> <span class="p">[</span><span class="nx">@child</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-53"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-53">#</a> </div> <h3>AccessorNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-54"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-54">#</a> </div> <p>A <code>.</code> accessor into a property of a value, or the <code>::</code> shorthand for
|
||||
<span class="p">(</span><span class="k">new</span> <span class="nx">CallNode</span> <span class="nx">ref</span><span class="p">,</span> <span class="p">[</span><span class="nx">@child</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-56"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-56">#</a> </div> <h3>AccessorNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-57"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-57">#</a> </div> <p>A <code>.</code> accessor into a property of a value, or the <code>::</code> shorthand for
|
||||
an accessor into the object's prototype.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.AccessorNode: </span><span class="nx">class</span> <span class="nx">AccessorNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'AccessorNode'</span>
|
||||
|
|
@ -310,7 +326,7 @@ an accessor into the object's prototype.</p> </td> <td c
|
|||
<span class="nv">name: </span><span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
<span class="nv">o.chainRoot.wrapped: </span><span class="o">or</span> <span class="nx">@soakNode</span>
|
||||
<span class="nv">namePart: </span><span class="k">if</span> <span class="nx">name</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">IS_STRING</span><span class="p">)</span> <span class="k">then</span> <span class="s2">"[$name]"</span> <span class="k">else</span> <span class="s2">".$name"</span>
|
||||
<span class="nx">@prototype</span> <span class="o">+</span> <span class="nx">namePart</span></pre></div> </td> </tr> <tr id="section-55"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-55">#</a> </div> <h3>IndexNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-56"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-56">#</a> </div> <p>A <code>[ ... ]</code> indexed accessor into an array or object.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.IndexNode: </span><span class="nx">class</span> <span class="nx">IndexNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="nx">@prototype</span> <span class="o">+</span> <span class="nx">namePart</span></pre></div> </td> </tr> <tr id="section-58"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-58">#</a> </div> <h3>IndexNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-59"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-59">#</a> </div> <p>A <code>[ ... ]</code> indexed accessor into an array or object.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.IndexNode: </span><span class="nx">class</span> <span class="nx">IndexNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'IndexNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s1">'index'</span><span class="p">]</span>
|
||||
|
|
@ -322,7 +338,7 @@ an accessor into the object's prototype.</p> </td> <td c
|
|||
<span class="nv">o.chainRoot.wrapped: </span><span class="o">or</span> <span class="nx">@soakNode</span>
|
||||
<span class="nv">idx: </span><span class="nx">@index</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
<span class="nv">prefix: </span><span class="k">if</span> <span class="nx">@proto</span> <span class="k">then</span> <span class="s1">'.prototype'</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="s2">"$prefix[$idx]"</span></pre></div> </td> </tr> <tr id="section-57"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-57">#</a> </div> <h3>RangeNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-58"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-58">#</a> </div> <p>A range literal. Ranges can be used to extract portions (slices) of arrays,
|
||||
<span class="s2">"$prefix[$idx]"</span></pre></div> </td> </tr> <tr id="section-60"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-60">#</a> </div> <h3>RangeNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-61"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-61">#</a> </div> <p>A range literal. Ranges can be used to extract portions (slices) of arrays,
|
||||
to specify a range for comprehensions, or as a value, to be expanded into the
|
||||
corresponding array of integers at runtime.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.RangeNode: </span><span class="nx">class</span> <span class="nx">RangeNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -332,14 +348,14 @@ corresponding array of integers at runtime.</p> </td> <t
|
|||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">from</span><span class="p">,</span> <span class="nx">to</span><span class="p">,</span> <span class="nx">exclusive</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@from: </span><span class="nx">from</span>
|
||||
<span class="vi">@to: </span><span class="nx">to</span>
|
||||
<span class="vi">@exclusive: </span><span class="o">!!</span><span class="nx">exclusive</span></pre></div> </td> </tr> <tr id="section-59"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-59">#</a> </div> <p>Compiles the range's source variables -- where it starts and where it ends.
|
||||
<span class="vi">@exclusive: </span><span class="o">!!</span><span class="nx">exclusive</span></pre></div> </td> </tr> <tr id="section-62"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-62">#</a> </div> <p>Compiles the range's source variables -- where it starts and where it ends.
|
||||
But only if they need to be cached to avoid double evaluation.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileVariables: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">[</span><span class="nx">@from</span><span class="p">,</span> <span class="nx">@fromVar</span><span class="p">]</span><span class="o">:</span> <span class="nx">@from</span><span class="p">.</span><span class="nx">compileReference</span> <span class="nx">o</span>
|
||||
<span class="p">[</span><span class="nx">@to</span><span class="p">,</span> <span class="nx">@toVar</span><span class="p">]</span><span class="o">:</span> <span class="nx">@to</span><span class="p">.</span><span class="nx">compileReference</span> <span class="nx">o</span>
|
||||
<span class="nv">parts: </span><span class="p">[]</span>
|
||||
<span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@from</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="k">if</span> <span class="nx">@from</span> <span class="o">isnt</span> <span class="nx">@fromVar</span>
|
||||
<span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@to</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="k">if</span> <span class="nx">@to</span> <span class="o">isnt</span> <span class="nx">@toVar</span>
|
||||
<span class="k">if</span> <span class="nx">parts</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="s2">"${parts.join('; ')};\n$o.indent"</span> <span class="k">else</span> <span class="s1">''</span></pre></div> </td> </tr> <tr id="section-60"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-60">#</a> </div> <p>When compiled normally, the range returns the contents of the <em>for loop</em>
|
||||
<span class="k">if</span> <span class="nx">parts</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="s2">"${parts.join('; ')};"</span> <span class="k">else</span> <span class="s1">''</span></pre></div> </td> </tr> <tr id="section-63"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-63">#</a> </div> <p>When compiled normally, the range returns the contents of the <em>for loop</em>
|
||||
needed to iterate over the values in the range. Used by comprehensions.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">return</span> <span class="nx">@compileArray</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="nx">unless</span> <span class="nx">o</span><span class="p">.</span><span class="nx">index</span>
|
||||
<span class="nv">idx: </span> <span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'index'</span>
|
||||
|
|
@ -348,17 +364,19 @@ needed to iterate over the values in the range. Used by comprehensions.</p>
|
|||
<span class="nv">step: </span> <span class="k">if</span> <span class="nx">step</span> <span class="k">then</span> <span class="nx">step</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="s1">'1'</span>
|
||||
<span class="nv">equals: </span> <span class="k">if</span> <span class="nx">@exclusive</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="s1">'='</span>
|
||||
<span class="nv">op: </span> <span class="k">if</span> <span class="nx">starts</span><span class="p">(</span><span class="nx">step</span><span class="p">,</span> <span class="s1">'-'</span><span class="p">)</span> <span class="k">then</span> <span class="s2">">$equals"</span> <span class="k">else</span> <span class="s2">"<$equals"</span>
|
||||
<span class="s2">"$vars; ${idx} $op ${@toVar.compile(o)}; $idx += $step"</span></pre></div> </td> </tr> <tr id="section-61"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-61">#</a> </div> <p>When used as a value, expand the range into the equivalent array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileArray: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="s2">"$vars; ${idx} $op ${@toVar.compile(o)}; $idx += $step"</span></pre></div> </td> </tr> <tr id="section-64"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-64">#</a> </div> <p>When used as a value, expand the range into the equivalent array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileArray: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">idt: </span> <span class="nx">@idt</span> <span class="mi">1</span>
|
||||
<span class="nv">vars: </span> <span class="nx">@compileVariables</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">idt</span><span class="p">}))</span>
|
||||
<span class="nv">equals: </span><span class="k">if</span> <span class="nx">@exclusive</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="s1">'='</span>
|
||||
<span class="nv">from: </span> <span class="nx">@fromVar</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
<span class="nv">to: </span> <span class="nx">@toVar</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
<span class="nv">result: </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">()</span>
|
||||
<span class="nv">i: </span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">()</span>
|
||||
<span class="nv">clause: </span><span class="s2">"$from <= $to ?"</span>
|
||||
<span class="nv">pre: </span> <span class="s2">"\n${idt}a = [];${vars}"</span>
|
||||
<span class="nv">body: </span> <span class="s2">"var i = $from; ($clause i <$equals $to : i >$equals $to); ($clause i += 1 : i -= 1)"</span>
|
||||
<span class="nv">post: </span> <span class="s2">"a.push(i);\n${idt}return a;\n$o.indent"</span>
|
||||
<span class="s2">"(function(){${pre}for ($body) $post}).call(this)"</span></pre></div> </td> </tr> <tr id="section-62"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-62">#</a> </div> <h3>SliceNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-63"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-63">#</a> </div> <p>An array slice literal. Unlike JavaScript's <code>Array#slice</code>, the second parameter
|
||||
<span class="nv">pre: </span> <span class="s2">"\n${idt}${result} = []; ${vars}"</span>
|
||||
<span class="nv">body: </span> <span class="s2">"var $i = $from; $clause $i <$equals $to : $i >$equals $to; $clause $i += 1 : $i -= 1"</span>
|
||||
<span class="nv">post: </span> <span class="s2">"{ ${result}.push($i) };\n${idt}return $result;\n$o.indent"</span>
|
||||
<span class="s2">"(function(){${pre}\n${idt}for ($body)$post}).call(this)"</span></pre></div> </td> </tr> <tr id="section-65"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-65">#</a> </div> <h3>SliceNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-66"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-66">#</a> </div> <p>An array slice literal. Unlike JavaScript's <code>Array#slice</code>, the second parameter
|
||||
specifies the index of the end of the slice, just as the first parameter
|
||||
is the index of the beginning.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.SliceNode: </span><span class="nx">class</span> <span class="nx">SliceNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -372,7 +390,7 @@ is the index of the beginning.</p> </td> <td class="code
|
|||
<span class="nv">from: </span> <span class="nx">@range</span><span class="p">.</span><span class="nx">from</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">to: </span> <span class="nx">@range</span><span class="p">.</span><span class="nx">to</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">plusPart: </span> <span class="k">if</span> <span class="nx">@range</span><span class="p">.</span><span class="nx">exclusive</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="s1">' + 1'</span>
|
||||
<span class="s2">".slice($from, $to$plusPart)"</span></pre></div> </td> </tr> <tr id="section-64"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-64">#</a> </div> <h3>ObjectNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-65"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-65">#</a> </div> <p>An object literal, nothing fancy.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ObjectNode: </span><span class="nx">class</span> <span class="nx">ObjectNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="s2">".slice($from, $to$plusPart)"</span></pre></div> </td> </tr> <tr id="section-67"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-67">#</a> </div> <h3>ObjectNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-68"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-68">#</a> </div> <p>An object literal, nothing fancy.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ObjectNode: </span><span class="nx">class</span> <span class="nx">ObjectNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'ObjectNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s1">'properties'</span><span class="p">]</span>
|
||||
|
|
@ -382,14 +400,18 @@ is the index of the beginning.</p> </td> <td class="code
|
|||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.indent: </span><span class="nx">@idt</span> <span class="mi">1</span>
|
||||
<span class="nv">last: </span><span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
|
||||
<span class="nv">nonComments: </span><span class="nx">prop</span> <span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">@properties</span> <span class="k">when</span> <span class="o">not</span> <span class="p">(</span><span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span><span class="p">)</span>
|
||||
<span class="nv">lastNoncom: </span> <span class="nx">nonComments</span><span class="p">[</span><span class="nx">nonComments</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
|
||||
<span class="nv">props: </span><span class="k">for</span> <span class="nx">prop</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">@properties</span>
|
||||
<span class="nv">join: </span> <span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="nx">last</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="s1">',\n'</span>
|
||||
<span class="nv">prop: </span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="nx">prop</span><span class="p">,</span> <span class="nx">prop</span><span class="p">,</span> <span class="s1">'object'</span> <span class="nx">unless</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span>
|
||||
<span class="nx">@idt</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="nx">join</span>
|
||||
<span class="nv">join: </span> <span class="s2">",\n"</span>
|
||||
<span class="nv">join: </span> <span class="s2">"\n"</span> <span class="k">if</span> <span class="p">(</span><span class="nx">prop</span> <span class="o">is</span> <span class="nx">lastNoncom</span><span class="p">)</span> <span class="o">or</span> <span class="p">(</span><span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span><span class="p">)</span>
|
||||
<span class="nv">join: </span> <span class="s1">''</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
|
||||
<span class="nv">indent: </span><span class="k">if</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="nx">@idt</span> <span class="mi">1</span>
|
||||
<span class="nv">prop: </span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="nx">prop</span><span class="p">,</span> <span class="nx">prop</span><span class="p">,</span> <span class="s1">'object'</span> <span class="nx">unless</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span> <span class="o">or</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span>
|
||||
<span class="nx">indent</span> <span class="o">+</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="nx">join</span>
|
||||
<span class="nv">props: </span><span class="nx">props</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
|
||||
<span class="nv">inner: </span><span class="k">if</span> <span class="nx">props</span> <span class="k">then</span> <span class="s1">'\n'</span> <span class="o">+</span> <span class="nx">props</span> <span class="o">+</span> <span class="s1">'\n'</span> <span class="o">+</span> <span class="nx">@idt</span><span class="p">()</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="s2">"{$inner}"</span></pre></div> </td> </tr> <tr id="section-66"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-66">#</a> </div> <h3>ArrayNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-67"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-67">#</a> </div> <p>An array literal.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ArrayNode: </span><span class="nx">class</span> <span class="nx">ArrayNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="s2">"{$inner}"</span></pre></div> </td> </tr> <tr id="section-69"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-69">#</a> </div> <h3>ArrayNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-70"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-70">#</a> </div> <p>An array literal.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ArrayNode: </span><span class="nx">class</span> <span class="nx">ArrayNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'ArrayNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s1">'objects'</span><span class="p">]</span>
|
||||
|
|
@ -406,6 +428,8 @@ is the index of the beginning.</p> </td> <td class="code
|
|||
<span class="nv">code: </span><span class="nx">obj</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">SplatNode</span>
|
||||
<span class="k">return</span> <span class="nx">@compileSplatLiteral</span> <span class="nx">@objects</span><span class="p">,</span> <span class="nx">o</span>
|
||||
<span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">CommentNode</span>
|
||||
<span class="nx">objects</span><span class="p">.</span><span class="nx">push</span> <span class="s2">"\n$code\n$o.indent"</span>
|
||||
<span class="k">else</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="nx">@objects</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
|
||||
<span class="nx">objects</span><span class="p">.</span><span class="nx">push</span> <span class="nx">code</span>
|
||||
<span class="k">else</span>
|
||||
|
|
@ -414,11 +438,11 @@ is the index of the beginning.</p> </td> <td class="code
|
|||
<span class="k">if</span> <span class="nx">indexOf</span><span class="p">(</span><span class="nx">objects</span><span class="p">,</span> <span class="s1">'\n'</span><span class="p">)</span> <span class="o">>=</span> <span class="mi">0</span>
|
||||
<span class="s2">"[\n${@idt(1)}$objects\n$@tab]"</span>
|
||||
<span class="k">else</span>
|
||||
<span class="s2">"[$objects]"</span></pre></div> </td> </tr> <tr id="section-68"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-68">#</a> </div> <h3>ClassNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-69"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-69">#</a> </div> <p>The CoffeeScript class definition.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ClassNode: </span><span class="nx">class</span> <span class="nx">ClassNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="s2">"[$objects]"</span></pre></div> </td> </tr> <tr id="section-71"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-71">#</a> </div> <h3>ClassNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-72"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-72">#</a> </div> <p>The CoffeeScript class definition.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ClassNode: </span><span class="nx">class</span> <span class="nx">ClassNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'ClassNode'</span>
|
||||
<span class="nv">children: </span> <span class="p">[</span><span class="s1">'variable'</span><span class="p">,</span> <span class="s1">'parent'</span><span class="p">,</span> <span class="s1">'properties'</span><span class="p">]</span>
|
||||
<span class="nv">isStatement: </span> <span class="o">-></span> <span class="kc">yes</span></pre></div> </td> </tr> <tr id="section-70"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-70">#</a> </div> <p>Initialize a <strong>ClassNode</strong> with its name, an optional superclass, and a
|
||||
<span class="nv">isStatement: </span> <span class="o">-></span> <span class="kc">yes</span></pre></div> </td> </tr> <tr id="section-73"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-73">#</a> </div> <p>Initialize a <strong>ClassNode</strong> with its name, an optional superclass, and a
|
||||
list of prototype property assignments.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">constructor: </span><span class="p">(</span><span class="nx">variable</span><span class="p">,</span> <span class="nx">parent</span><span class="p">,</span> <span class="nx">props</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@variable: </span><span class="nx">variable</span>
|
||||
<span class="vi">@parent: </span><span class="nx">parent</span>
|
||||
|
|
@ -427,11 +451,11 @@ list of prototype property assignments.</p> </td> <td cl
|
|||
|
||||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="vi">@returns: </span><span class="kc">true</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-71"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-71">#</a> </div> <p>Instead of generating the JavaScript string directly, we build up the
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-74"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-74">#</a> </div> <p>Instead of generating the JavaScript string directly, we build up the
|
||||
equivalent syntax tree and compile that, in pieces. You can see the
|
||||
constructor, property assignments, and inheritance getting built out below.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">extension: </span> <span class="nx">@parent</span> <span class="o">and</span> <span class="k">new</span> <span class="nx">ExtendsNode</span><span class="p">(</span><span class="nx">@variable</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">)</span>
|
||||
<span class="nv">props: </span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
|
||||
<span class="nv">props: </span> <span class="k">new</span> <span class="nx">Expressions</span>
|
||||
<span class="nv">o.top: </span> <span class="kc">true</span>
|
||||
<span class="nv">me: </span> <span class="kc">null</span>
|
||||
<span class="nv">className: </span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
|
|
@ -443,11 +467,12 @@ constructor, property assignments, and inheritance getting built out below.</p>
|
|||
<span class="k">new</span> <span class="nx">CallNode</span><span class="p">(</span><span class="nx">applied</span><span class="p">,</span> <span class="p">[</span><span class="nx">literal</span><span class="p">(</span><span class="s1">'this'</span><span class="p">),</span> <span class="nx">literal</span><span class="p">(</span><span class="s1">'arguments'</span><span class="p">)])</span>
|
||||
<span class="p">]))</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">constructor: </span><span class="k">new</span> <span class="nx">CodeNode</span><span class="p">()</span>
|
||||
<span class="nv">constructor: </span><span class="k">new</span> <span class="nx">CodeNode</span>
|
||||
|
||||
<span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">@properties</span>
|
||||
<span class="p">[</span><span class="nx">pvar</span><span class="p">,</span> <span class="nx">func</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">prop</span><span class="p">.</span><span class="nx">variable</span><span class="p">,</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">value</span><span class="p">]</span>
|
||||
<span class="k">if</span> <span class="nx">pvar</span> <span class="o">and</span> <span class="nx">pvar</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">'constructor'</span> <span class="o">and</span> <span class="nx">func</span> <span class="k">instanceof</span> <span class="nx">CodeNode</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">"cannot define a constructor as a bound function."</span> <span class="k">if</span> <span class="nx">func</span><span class="p">.</span><span class="nx">bound</span>
|
||||
<span class="nv">func.name: </span><span class="nx">className</span>
|
||||
<span class="nx">func</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">ReturnNode</span> <span class="nx">literal</span> <span class="s1">'this'</span>
|
||||
<span class="vi">@variable: </span><span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">@variable</span>
|
||||
|
|
@ -472,8 +497,8 @@ constructor, property assignments, and inheritance getting built out below.</p>
|
|||
<span class="nv">props: </span> <span class="k">if</span> <span class="nx">props</span><span class="p">.</span><span class="nx">empty</span><span class="p">()</span> <span class="k">then</span> <span class="s1">''</span> <span class="k">else</span> <span class="nx">props</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'\n'</span>
|
||||
<span class="nv">extension: </span><span class="k">if</span> <span class="nx">extension</span> <span class="k">then</span> <span class="nx">@idt</span><span class="p">()</span> <span class="o">+</span> <span class="nx">extension</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="s1">';\n'</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="nv">returns: </span> <span class="k">if</span> <span class="nx">@returns</span> <span class="k">then</span> <span class="k">new</span> <span class="nx">ReturnNode</span><span class="p">(</span><span class="nx">@variable</span><span class="p">).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="s2">"$construct$extension$props$returns"</span></pre></div> </td> </tr> <tr id="section-72"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-72">#</a> </div> <h3>AssignNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-73"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-73">#</a> </div> <p>The <strong>AssignNode</strong> is used to assign a local variable to value, or to set the
|
||||
property of an object -- including within object literals.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.AssignNode: </span><span class="nx">class</span> <span class="nx">AssignNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span></pre></div> </td> </tr> <tr id="section-74"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-74">#</a> </div> <p>Matchers for detecting prototype assignments.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">PROTO_ASSIGN: </span><span class="sr">/^(\S+)\.prototype/</span>
|
||||
<span class="s2">"$construct$extension$props$returns"</span></pre></div> </td> </tr> <tr id="section-75"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-75">#</a> </div> <h3>AssignNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-76"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-76">#</a> </div> <p>The <strong>AssignNode</strong> is used to assign a local variable to value, or to set the
|
||||
property of an object -- including within object literals.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.AssignNode: </span><span class="nx">class</span> <span class="nx">AssignNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span></pre></div> </td> </tr> <tr id="section-77"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-77">#</a> </div> <p>Matchers for detecting prototype assignments.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">PROTO_ASSIGN: </span><span class="sr">/^(\S+)\.prototype/</span>
|
||||
<span class="nv">LEADING_DOT: </span> <span class="sr">/^\.(prototype\.)?/</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'AssignNode'</span>
|
||||
|
|
@ -494,7 +519,7 @@ property of an object -- including within object literals.</p> </td>
|
|||
<span class="k">return</span> <span class="k">new</span> <span class="nx">Expressions</span> <span class="p">[</span><span class="k">this</span><span class="p">,</span> <span class="k">new</span> <span class="nx">ReturnNode</span><span class="p">(</span><span class="nx">@variable</span><span class="p">)]</span>
|
||||
|
||||
<span class="nv">isStatement: </span><span class="o">-></span>
|
||||
<span class="nx">@isValue</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@variable</span><span class="p">.</span><span class="nx">isArray</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">isObject</span><span class="p">())</span></pre></div> </td> </tr> <tr id="section-75"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-75">#</a> </div> <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
|
||||
<span class="nx">@isValue</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@variable</span><span class="p">.</span><span class="nx">isArray</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">isObject</span><span class="p">())</span></pre></div> </td> </tr> <tr id="section-78"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-78">#</a> </div> <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
|
||||
<code>compileSplice</code> if appropriate. Keep track of the name of the base object
|
||||
we've been assigned to, for correct internal references. If the variable
|
||||
has not been seen yet within the current scope, declare it.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -514,7 +539,7 @@ has not been seen yet within the current scope, declare it.</p> </td
|
|||
<span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">find</span> <span class="nx">name</span> <span class="nx">unless</span> <span class="nx">@isValue</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@variable</span><span class="p">.</span><span class="nx">hasProperties</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">namespaced</span><span class="p">)</span>
|
||||
<span class="nv">val: </span><span class="s2">"$name = $val"</span>
|
||||
<span class="k">return</span> <span class="s2">"$@tab$val;"</span> <span class="k">if</span> <span class="nx">stmt</span>
|
||||
<span class="k">if</span> <span class="nx">top</span> <span class="k">then</span> <span class="nx">val</span> <span class="k">else</span> <span class="s2">"($val)"</span></pre></div> </td> </tr> <tr id="section-76"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-76">#</a> </div> <p>Brief implementation of recursive pattern matching, when assigning array or
|
||||
<span class="k">if</span> <span class="nx">top</span> <span class="k">then</span> <span class="nx">val</span> <span class="k">else</span> <span class="s2">"($val)"</span></pre></div> </td> </tr> <tr id="section-79"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-79">#</a> </div> <p>Brief implementation of recursive pattern matching, when assigning array or
|
||||
object literals to a value. Peeks at their properties to assign inner names.
|
||||
See the <a href="http://wiki.ecmascript.org/doku.php?id=harmony:destructuring">ECMAScript Harmony Wiki</a>
|
||||
for details.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compilePatternMatch: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -524,10 +549,10 @@ for details.</p> </td> <td class="code"> <
|
|||
<span class="nv">o.top: </span><span class="kc">true</span>
|
||||
<span class="nv">o.asStatement: </span><span class="kc">true</span>
|
||||
<span class="nv">splat: </span><span class="kc">false</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-77"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-77">#</a> </div> <p>A regular array pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx: </span><span class="nx">i</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-80"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-80">#</a> </div> <p>A regular array pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx: </span><span class="nx">i</span>
|
||||
<span class="k">if</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">isObject</span><span class="p">()</span>
|
||||
<span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span></pre></div> </td> </tr> <tr id="section-78"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-78">#</a> </div> <p>A regular object pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="p">[</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">idx</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">obj</span><span class="p">.</span><span class="nx">value</span><span class="p">,</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">base</span><span class="p">]</span>
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-79"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-79">#</a> </div> <p>A shorthand <code>{a, b, c}: val</code> pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx: </span><span class="nx">obj</span>
|
||||
<span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span></pre></div> </td> </tr> <tr id="section-81"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-81">#</a> </div> <p>A regular object pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="p">[</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">idx</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">obj</span><span class="p">.</span><span class="nx">value</span><span class="p">,</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">base</span><span class="p">]</span>
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-82"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-82">#</a> </div> <p>A shorthand <code>{a, b, c}: val</code> pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx: </span><span class="nx">obj</span>
|
||||
<span class="k">if</span> <span class="o">not</span> <span class="p">(</span><span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">ValueNode</span> <span class="o">or</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">SplatNode</span><span class="p">)</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s1">'pattern matching must use only identifiers on the left-hand side.'</span>
|
||||
<span class="nv">isString: </span><span class="nx">idx</span><span class="p">.</span><span class="nx">value</span> <span class="o">and</span> <span class="nx">idx</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">match</span> <span class="nx">IS_STRING</span>
|
||||
|
|
@ -542,7 +567,7 @@ for details.</p> </td> <td class="code"> <
|
|||
<span class="nv">val: </span><span class="k">new</span> <span class="nx">ValueNode</span><span class="p">(</span><span class="nx">literal</span><span class="p">(</span><span class="nx">valVar</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">accessClass</span><span class="p">(</span><span class="nx">idx</span><span class="p">)])</span>
|
||||
<span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="k">new</span> <span class="nx">AssignNode</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">val</span><span class="p">).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">))</span>
|
||||
<span class="nv">code: </span><span class="nx">assigns</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s2">"\n"</span><span class="p">)</span>
|
||||
<span class="nx">code</span></pre></div> </td> </tr> <tr id="section-80"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-80">#</a> </div> <p>Compile the assignment from an array splice literal, using JavaScript's
|
||||
<span class="nx">code</span></pre></div> </td> </tr> <tr id="section-83"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-83">#</a> </div> <p>Compile the assignment from an array splice literal, using JavaScript's
|
||||
<code>Array#splice</code> method.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileSplice: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">name: </span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">onlyFirst: </span><span class="kc">true</span><span class="p">}</span>
|
||||
<span class="nv">l: </span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">length</span>
|
||||
|
|
@ -551,7 +576,7 @@ for details.</p> </td> <td class="code"> <
|
|||
<span class="nv">from: </span> <span class="nx">range</span><span class="p">.</span><span class="nx">from</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">to: </span> <span class="nx">range</span><span class="p">.</span><span class="nx">to</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="s1">' - '</span> <span class="o">+</span> <span class="nx">from</span> <span class="o">+</span> <span class="nx">plus</span>
|
||||
<span class="nv">val: </span> <span class="nx">@value</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="s2">"${name}.splice.apply($name, [$from, $to].concat($val))"</span></pre></div> </td> </tr> <tr id="section-81"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-81">#</a> </div> <h3>CodeNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-82"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-82">#</a> </div> <p>A function definition. This is the only node that creates a new Scope.
|
||||
<span class="s2">"${name}.splice.apply($name, [$from, $to].concat($val))"</span></pre></div> </td> </tr> <tr id="section-84"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-84">#</a> </div> <h3>CodeNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-85"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-85">#</a> </div> <p>A function definition. This is the only node that creates a new Scope.
|
||||
When for the purposes of walking the contents of a function body, the CodeNode
|
||||
has no <em>children</em> -- they're within the inner scope.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.CodeNode: </span><span class="nx">class</span> <span class="nx">CodeNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -560,8 +585,8 @@ has no <em>children</em> -- they're within the inner scope.</p> </td
|
|||
|
||||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">params</span><span class="p">,</span> <span class="nx">body</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@params: </span> <span class="nx">params</span> <span class="o">or</span> <span class="p">[]</span>
|
||||
<span class="vi">@body: </span> <span class="nx">body</span> <span class="o">or</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
|
||||
<span class="vi">@bound: </span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">'boundfunc'</span></pre></div> </td> </tr> <tr id="section-83"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-83">#</a> </div> <p>Compilation creates a new scope unless explicitly asked to share with the
|
||||
<span class="vi">@body: </span> <span class="nx">body</span> <span class="o">or</span> <span class="k">new</span> <span class="nx">Expressions</span>
|
||||
<span class="vi">@bound: </span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">'boundfunc'</span></pre></div> </td> </tr> <tr id="section-86"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-86">#</a> </div> <p>Compilation creates a new scope unless explicitly asked to share with the
|
||||
outer scope. Handles splat parameters in the parameter list by peeking at
|
||||
the JavaScript <code>arguments</code> objects. If the function is bound with the <code>=></code>
|
||||
arrow, generates a wrapper that saves the current value of <code>this</code> through
|
||||
|
|
@ -599,13 +624,13 @@ a closure.</p> </td> <td class="code"> <di
|
|||
<span class="s2">"(function(__this) {\n${@idt(1)}var __func = $func;\n${@idt(1)}return $inner\n$@tab})(this)"</span>
|
||||
|
||||
<span class="nv">topSensitive: </span><span class="o">-></span>
|
||||
<span class="kc">true</span></pre></div> </td> </tr> <tr id="section-84"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-84">#</a> </div> <p>Short-circuit traverseChildren method to prevent it from crossing scope boundaries
|
||||
<span class="kc">true</span></pre></div> </td> </tr> <tr id="section-87"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-87">#</a> </div> <p>Short-circuit traverseChildren method to prevent it from crossing scope boundaries
|
||||
unless crossScope is true</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">traverseChildren: </span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="o">-></span> <span class="k">super</span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="k">if</span> <span class="nx">crossScope</span>
|
||||
|
||||
<span class="nv">toString: </span><span class="p">(</span><span class="nx">idt</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">idt: </span><span class="o">or</span> <span class="s1">''</span>
|
||||
<span class="nv">children: </span><span class="p">(</span><span class="nx">child</span><span class="p">.</span><span class="nx">toString</span><span class="p">(</span><span class="nx">idt</span> <span class="o">+</span> <span class="nx">TAB</span><span class="p">)</span> <span class="k">for</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">@collectChildren</span><span class="p">()).</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
|
||||
<span class="s2">"\n$idt$children"</span></pre></div> </td> </tr> <tr id="section-85"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-85">#</a> </div> <h3>SplatNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-86"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-86">#</a> </div> <p>A splat, either as a parameter to a function, an argument to a call,
|
||||
<span class="s2">"\n$idt$children"</span></pre></div> </td> </tr> <tr id="section-88"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-88">#</a> </div> <h3>SplatNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-89"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-89">#</a> </div> <p>A splat, either as a parameter to a function, an argument to a call,
|
||||
or as part of a destructuring assignment.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.SplatNode: </span><span class="nx">class</span> <span class="nx">SplatNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'SplatNode'</span>
|
||||
|
|
@ -616,7 +641,7 @@ or as part of a destructuring assignment.</p> </td> <td
|
|||
<span class="vi">@name: </span><span class="nx">name</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">if</span> <span class="nx">@index</span><span class="o">?</span> <span class="k">then</span> <span class="nx">@compileParam</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-87"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-87">#</a> </div> <p>Compiling a parameter splat means recovering the parameters that succeed
|
||||
<span class="k">if</span> <span class="nx">@index</span><span class="o">?</span> <span class="k">then</span> <span class="nx">@compileParam</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-90"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-90">#</a> </div> <p>Compiling a parameter splat means recovering the parameters that succeed
|
||||
the splat in the parameter list, by slicing the arguments object.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileParam: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">name: </span><span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">find</span> <span class="nx">name</span>
|
||||
|
|
@ -627,10 +652,10 @@ the splat in the parameter list, by slicing the arguments object.</p>
|
|||
<span class="k">for</span> <span class="nx">trailing</span><span class="p">,</span> <span class="nx">idx</span> <span class="k">in</span> <span class="nx">@trailings</span>
|
||||
<span class="nv">pos: </span><span class="nx">@trailings</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">idx</span>
|
||||
<span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">assign</span><span class="p">(</span><span class="nx">trailing</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="s2">"arguments[$variadic ? $len - $pos : ${@index + idx}]"</span><span class="p">)</span>
|
||||
<span class="s2">"$name = ${utility('slice')}.call(arguments, $@index, $len - ${@trailings.length})"</span></pre></div> </td> </tr> <tr id="section-88"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-88">#</a> </div> <p>A compiling a splat as a destructuring assignment means slicing arguments
|
||||
<span class="s2">"$name = ${utility('slice')}.call(arguments, $@index, $len - ${@trailings.length})"</span></pre></div> </td> </tr> <tr id="section-91"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-91">#</a> </div> <p>A compiling a splat as a destructuring assignment means slicing arguments
|
||||
from the right-hand-side's corresponding array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileValue: </span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">index</span><span class="p">,</span> <span class="nx">trailings</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">trail: </span><span class="k">if</span> <span class="nx">trailings</span> <span class="k">then</span> <span class="s2">", ${name}.length - $trailings"</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="s2">"${utility 'slice'}.call($name, $index$trail)"</span></pre></div> </td> </tr> <tr id="section-89"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-89">#</a> </div> <p>Utility function that converts arbitrary number of elements, mixed with
|
||||
<span class="s2">"${utility 'slice'}.call($name, $index$trail)"</span></pre></div> </td> </tr> <tr id="section-92"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-92">#</a> </div> <p>Utility function that converts arbitrary number of elements, mixed with
|
||||
splats, to a proper array</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@compileMixedArray: </span><span class="p">(</span><span class="nx">list</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">args: </span><span class="p">[]</span>
|
||||
<span class="nv">i: </span><span class="mi">0</span>
|
||||
|
|
@ -648,7 +673,7 @@ splats, to a proper array</p> </td> <td class="code">
|
|||
<span class="nv">code: </span><span class="s2">"[$code]"</span>
|
||||
<span class="nx">args</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="mi">0</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">".concat($code)"</span><span class="p">)</span>
|
||||
<span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
|
||||
<span class="nx">args</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-90"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-90">#</a> </div> <h3>WhileNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-91"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-91">#</a> </div> <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
|
||||
<span class="nx">args</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-93"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-93">#</a> </div> <h3>WhileNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-94"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-94">#</a> </div> <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
|
||||
it, all other loops can be manufactured. Useful in cases where you need more
|
||||
flexibility or more speed than a comprehension can provide.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.WhileNode: </span><span class="nx">class</span> <span class="nx">WhileNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -672,7 +697,7 @@ flexibility or more speed than a comprehension can provide.</p> </td
|
|||
<span class="k">this</span>
|
||||
|
||||
<span class="nv">topSensitive: </span><span class="o">-></span>
|
||||
<span class="kc">true</span></pre></div> </td> </tr> <tr id="section-92"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-92">#</a> </div> <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
|
||||
<span class="kc">true</span></pre></div> </td> </tr> <tr id="section-95"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-95">#</a> </div> <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
|
||||
<em>while</em> can be used as a part of a larger expression -- while loops may
|
||||
return an array containing the computed result of each iteration.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">top: </span> <span class="nx">del</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="s1">'top'</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@returns</span>
|
||||
|
|
@ -690,12 +715,12 @@ return an array containing the computed result of each iteration.</p>
|
|||
<span class="nv">post: </span><span class="s1">'\n'</span> <span class="o">+</span> <span class="k">new</span> <span class="nx">ReturnNode</span><span class="p">(</span><span class="nx">literal</span><span class="p">(</span><span class="nx">rvar</span><span class="p">)).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">@idt</span><span class="p">()}))</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">post: </span><span class="s1">''</span>
|
||||
<span class="s2">"$pre {\n${ @body.compile(o) }\n$@tab}$post"</span></pre></div> </td> </tr> <tr id="section-93"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-93">#</a> </div> <h3>OpNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-94"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-94">#</a> </div> <p>Simple Arithmetic and logical operations. Performs some conversion from
|
||||
CoffeeScript operations into their JavaScript equivalents.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.OpNode: </span><span class="nx">class</span> <span class="nx">OpNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span></pre></div> </td> </tr> <tr id="section-95"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-95">#</a> </div> <p>The map of conversions from CoffeeScript to JavaScript symbols.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CONVERSIONS: </span><span class="p">{</span>
|
||||
<span class="s2">"$pre {\n${ @body.compile(o) }\n$@tab}$post"</span></pre></div> </td> </tr> <tr id="section-96"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-96">#</a> </div> <h3>OpNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-97"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-97">#</a> </div> <p>Simple Arithmetic and logical operations. Performs some conversion from
|
||||
CoffeeScript operations into their JavaScript equivalents.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.OpNode: </span><span class="nx">class</span> <span class="nx">OpNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span></pre></div> </td> </tr> <tr id="section-98"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-98">#</a> </div> <p>The map of conversions from CoffeeScript to JavaScript symbols.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CONVERSIONS: </span><span class="p">{</span>
|
||||
<span class="s1">'=='</span><span class="o">:</span> <span class="s1">'==='</span>
|
||||
<span class="s1">'!='</span><span class="o">:</span> <span class="s1">'!=='</span>
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-96"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-96">#</a> </div> <p>The list of operators for which we perform
|
||||
<a href="http://docs.python.org/reference/expressions.html#notin">Python-style comparison chaining</a>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CHAINABLE: </span> <span class="p">[</span><span class="s1">'<'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="s1">'>='</span><span class="p">,</span> <span class="s1">'<='</span><span class="p">,</span> <span class="s1">'==='</span><span class="p">,</span> <span class="s1">'!=='</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-97"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-97">#</a> </div> <p>Our assignment operators that have no JavaScript equivalent.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">ASSIGNMENT: </span> <span class="p">[</span><span class="s1">'||='</span><span class="p">,</span> <span class="s1">'&&='</span><span class="p">,</span> <span class="s1">'?='</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-98"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-98">#</a> </div> <p>Operators must come before their operands with a space.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">PREFIX_OPERATORS: </span><span class="p">[</span><span class="s1">'typeof'</span><span class="p">,</span> <span class="s1">'delete'</span><span class="p">]</span>
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-99"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-99">#</a> </div> <p>The list of operators for which we perform
|
||||
<a href="http://docs.python.org/reference/expressions.html#notin">Python-style comparison chaining</a>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CHAINABLE: </span> <span class="p">[</span><span class="s1">'<'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="s1">'>='</span><span class="p">,</span> <span class="s1">'<='</span><span class="p">,</span> <span class="s1">'==='</span><span class="p">,</span> <span class="s1">'!=='</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-100"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-100">#</a> </div> <p>Our assignment operators that have no JavaScript equivalent.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">ASSIGNMENT: </span> <span class="p">[</span><span class="s1">'||='</span><span class="p">,</span> <span class="s1">'&&='</span><span class="p">,</span> <span class="s1">'?='</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-101"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-101">#</a> </div> <p>Operators must come before their operands with a space.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">PREFIX_OPERATORS: </span><span class="p">[</span><span class="s1">'typeof'</span><span class="p">,</span> <span class="s1">'delete'</span><span class="p">]</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'OpNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s1">'first'</span><span class="p">,</span> <span class="s1">'second'</span><span class="p">]</span>
|
||||
|
|
@ -712,13 +737,16 @@ CoffeeScript operations into their JavaScript equivalents.</p> </td>
|
|||
<span class="nv">isChainable: </span><span class="o">-></span>
|
||||
<span class="nx">indexOf</span><span class="p">(</span><span class="nx">@CHAINABLE</span><span class="p">,</span> <span class="nx">@operator</span><span class="p">)</span> <span class="o">>=</span> <span class="mi">0</span>
|
||||
|
||||
<span class="nv">toString: </span><span class="p">(</span><span class="nx">idt</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">super</span><span class="p">(</span><span class="nx">idt</span><span class="p">,</span> <span class="nx">@class</span> <span class="o">+</span> <span class="s1">' '</span> <span class="o">+</span> <span class="nx">@operator</span><span class="p">)</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.operation: </span><span class="kc">true</span>
|
||||
<span class="k">return</span> <span class="nx">@compileChain</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@isChainable</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span> <span class="k">instanceof</span> <span class="nx">OpNode</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">isChainable</span><span class="p">()</span>
|
||||
<span class="k">return</span> <span class="nx">@compileAssignment</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">indexOf</span><span class="p">(</span><span class="nx">@ASSIGNMENT</span><span class="p">,</span> <span class="nx">@operator</span><span class="p">)</span> <span class="o">>=</span> <span class="mi">0</span>
|
||||
<span class="k">return</span> <span class="nx">@compileUnary</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@isUnary</span><span class="p">()</span>
|
||||
<span class="k">return</span> <span class="nx">@compileExistence</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s1">'?'</span>
|
||||
<span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">@operator</span><span class="p">,</span> <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)].</span><span class="nx">join</span> <span class="s1">' '</span></pre></div> </td> </tr> <tr id="section-99"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-99">#</a> </div> <p>Mimic Python's chained comparisons when multiple comparison operators are
|
||||
<span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">@operator</span><span class="p">,</span> <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)].</span><span class="nx">join</span> <span class="s1">' '</span></pre></div> </td> </tr> <tr id="section-102"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-102">#</a> </div> <p>Mimic Python's chained comparisons when multiple comparison operators are
|
||||
used sequentially. For example:</p>
|
||||
|
||||
<pre><code>bin/coffee -e "puts 50 < 65 > 10"
|
||||
|
|
@ -727,21 +755,21 @@ true
|
|||
<span class="nv">shared: </span><span class="nx">@first</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">second</span>
|
||||
<span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">second</span><span class="p">,</span> <span class="nx">shared</span><span class="p">]</span><span class="o">:</span> <span class="nx">shared</span><span class="p">.</span><span class="nx">compileReference</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">shared</span><span class="p">.</span><span class="nx">containsType</span> <span class="nx">CallNode</span>
|
||||
<span class="p">[</span><span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">,</span> <span class="nx">shared</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">shared</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)]</span>
|
||||
<span class="s2">"($first) && ($shared $@operator $second)"</span></pre></div> </td> </tr> <tr id="section-100"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-100">#</a> </div> <p>When compiling a conditional assignment, take care to ensure that the
|
||||
<span class="s2">"($first) && ($shared $@operator $second)"</span></pre></div> </td> </tr> <tr id="section-103"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-103">#</a> </div> <p>When compiling a conditional assignment, take care to ensure that the
|
||||
operands are only evaluated once, even though we have to reference them
|
||||
more than once.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileAssignment: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">[</span><span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)]</span>
|
||||
<span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">find</span><span class="p">(</span><span class="nx">first</span><span class="p">)</span> <span class="k">if</span> <span class="nx">first</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">IDENTIFIER</span><span class="p">)</span>
|
||||
<span class="k">return</span> <span class="s2">"$first = ${ ExistenceNode.compileTest(o, @first) } ? $first : $second"</span> <span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s1">'?='</span>
|
||||
<span class="s2">"$first = $first ${ @operator.substr(0, 2) } $second"</span></pre></div> </td> </tr> <tr id="section-101"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-101">#</a> </div> <p>If this is an existence operator, we delegate to <code>ExistenceNode.compileTest</code>
|
||||
<span class="s2">"$first = $first ${ @operator.substr(0, 2) } $second"</span></pre></div> </td> </tr> <tr id="section-104"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-104">#</a> </div> <p>If this is an existence operator, we delegate to <code>ExistenceNode.compileTest</code>
|
||||
to give us the safe references for the variables.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileExistence: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">[</span><span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">),</span> <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)]</span>
|
||||
<span class="nv">test: </span><span class="nx">ExistenceNode</span><span class="p">.</span><span class="nx">compileTest</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">@first</span><span class="p">)</span>
|
||||
<span class="s2">"$test ? $first : $second"</span></pre></div> </td> </tr> <tr id="section-102"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-102">#</a> </div> <p>Compile a unary <strong>OpNode</strong>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileUnary: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="s2">"$test ? $first : $second"</span></pre></div> </td> </tr> <tr id="section-105"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-105">#</a> </div> <p>Compile a unary <strong>OpNode</strong>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileUnary: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">space: </span><span class="k">if</span> <span class="nx">indexOf</span><span class="p">(</span><span class="nx">@PREFIX_OPERATORS</span><span class="p">,</span> <span class="nx">@operator</span><span class="p">)</span> <span class="o">>=</span> <span class="mi">0</span> <span class="k">then</span> <span class="s1">' '</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="nv">parts: </span><span class="p">[</span><span class="nx">@operator</span><span class="p">,</span> <span class="nx">space</span><span class="p">,</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)]</span>
|
||||
<span class="nv">parts: </span><span class="nx">parts</span><span class="p">.</span><span class="nx">reverse</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@flip</span>
|
||||
<span class="nx">parts</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-103"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-103">#</a> </div> <h3>InNode</h3> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.InNode: </span><span class="nx">class</span> <span class="nx">InNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="nx">parts</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-106"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-106">#</a> </div> <h3>InNode</h3> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.InNode: </span><span class="nx">class</span> <span class="nx">InNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'InNode'</span>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s1">'object'</span><span class="p">,</span> <span class="s1">'array'</span><span class="p">]</span>
|
||||
|
|
@ -766,7 +794,7 @@ to give us the safe references for the variables.</p> </td>
|
|||
<span class="p">[</span><span class="nx">@arr1</span><span class="p">,</span> <span class="nx">@arr2</span><span class="p">]</span><span class="o">:</span> <span class="nx">@array</span><span class="p">.</span><span class="nx">compileReference</span> <span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">precompile: </span><span class="kc">yes</span><span class="p">}</span>
|
||||
<span class="p">[</span><span class="nx">i</span><span class="p">,</span> <span class="nx">l</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">(),</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">()]</span>
|
||||
<span class="nv">prefix: </span><span class="k">if</span> <span class="nx">@obj1</span> <span class="o">isnt</span> <span class="nx">@obj2</span> <span class="k">then</span> <span class="nx">@obj1</span> <span class="o">+</span> <span class="s1">'; '</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="s2">"!!(function(){ ${prefix}for (var $i=0, $l=${@arr1}.length; $i<$l; $i++) if (${@arr2}[$i] === $@obj2) return true; })()"</span></pre></div> </td> </tr> <tr id="section-104"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-104">#</a> </div> <h3>TryNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-105"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-105">#</a> </div> <p>A classic <em>try/catch/finally</em> block.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.TryNode: </span><span class="nx">class</span> <span class="nx">TryNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="s2">"!!(function(){ ${prefix}for (var $i=0, $l=${@arr1}.length; $i<$l; $i++) if (${@arr2}[$i] === $@obj2) return true; }).call(this)"</span></pre></div> </td> </tr> <tr id="section-107"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-107">#</a> </div> <h3>TryNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-108"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-108">#</a> </div> <p>A classic <em>try/catch/finally</em> block.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.TryNode: </span><span class="nx">class</span> <span class="nx">TryNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'TryNode'</span>
|
||||
<span class="nv">children: </span> <span class="p">[</span><span class="s1">'attempt'</span><span class="p">,</span> <span class="s1">'recovery'</span><span class="p">,</span> <span class="s1">'ensure'</span><span class="p">]</span>
|
||||
|
|
@ -781,7 +809,7 @@ to give us the safe references for the variables.</p> </td>
|
|||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="vi">@attempt: </span><span class="nx">@attempt</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@attempt</span>
|
||||
<span class="vi">@recovery: </span><span class="nx">@recovery</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@recovery</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-106"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-106">#</a> </div> <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-109"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-109">#</a> </div> <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
|
||||
is optional, the <em>catch</em> is not.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">o.indent: </span> <span class="nx">@idt</span> <span class="mi">1</span>
|
||||
<span class="nv">o.top: </span> <span class="kc">true</span>
|
||||
|
|
@ -789,18 +817,18 @@ is optional, the <em>catch</em> is not.</p> </td> <td cl
|
|||
<span class="nv">errorPart: </span> <span class="k">if</span> <span class="nx">@error</span> <span class="k">then</span> <span class="s2">" (${ @error.compile(o) }) "</span> <span class="k">else</span> <span class="s1">' '</span>
|
||||
<span class="nv">catchPart: </span> <span class="k">if</span> <span class="nx">@recovery</span> <span class="k">then</span> <span class="s2">" catch$errorPart{\n${ @recovery.compile(o) }\n$@tab}"</span> <span class="k">else</span> <span class="s1">''</span>
|
||||
<span class="nv">finallyPart: </span><span class="p">(</span><span class="nx">@ensure</span> <span class="o">or</span> <span class="s1">''</span><span class="p">)</span> <span class="o">and</span> <span class="s1">' finally {\n'</span> <span class="o">+</span> <span class="nx">@ensure</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">))</span> <span class="o">+</span> <span class="s2">"\n$@tab}"</span>
|
||||
<span class="s2">"${@tab}try {\n$attemptPart\n$@tab}$catchPart$finallyPart"</span></pre></div> </td> </tr> <tr id="section-107"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-107">#</a> </div> <h3>ThrowNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-108"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-108">#</a> </div> <p>Simple node to throw an exception.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ThrowNode: </span><span class="nx">class</span> <span class="nx">ThrowNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
<span class="s2">"${@tab}try {\n$attemptPart\n$@tab}$catchPart$finallyPart"</span></pre></div> </td> </tr> <tr id="section-110"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-110">#</a> </div> <h3>ThrowNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-111"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-111">#</a> </div> <p>Simple node to throw an exception.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ThrowNode: </span><span class="nx">class</span> <span class="nx">ThrowNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
<span class="nv">class: </span> <span class="s1">'ThrowNode'</span>
|
||||
<span class="nv">children: </span> <span class="p">[</span><span class="s1">'expression'</span><span class="p">]</span>
|
||||
<span class="nv">isStatement: </span><span class="o">-></span> <span class="kc">yes</span>
|
||||
|
||||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">expression</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@expression: </span><span class="nx">expression</span></pre></div> </td> </tr> <tr id="section-109"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-109">#</a> </div> <p>A <strong>ThrowNode</strong> is already a return, of sorts...</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="vi">@expression: </span><span class="nx">expression</span></pre></div> </td> </tr> <tr id="section-112"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-112">#</a> </div> <p>A <strong>ThrowNode</strong> is already a return, of sorts...</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="k">return</span> <span class="k">this</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="s2">"${@tab}throw ${@expression.compile(o)};"</span></pre></div> </td> </tr> <tr id="section-110"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-110">#</a> </div> <h3>ExistenceNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-111"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-111">#</a> </div> <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
|
||||
<span class="s2">"${@tab}throw ${@expression.compile(o)};"</span></pre></div> </td> </tr> <tr id="section-113"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-113">#</a> </div> <h3>ExistenceNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-114"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-114">#</a> </div> <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
|
||||
similar to <code>.nil?</code> in Ruby, and avoids having to consult a JavaScript truth
|
||||
table.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.ExistenceNode: </span><span class="nx">class</span> <span class="nx">ExistenceNode</span> <span class="k">extends</span> <span class="nx">BaseNode</span>
|
||||
|
||||
|
|
@ -811,11 +839,11 @@ table.</p> </td> <td class="code"> <div cl
|
|||
<span class="vi">@expression: </span><span class="nx">expression</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nx">ExistenceNode</span><span class="p">.</span><span class="nx">compileTest</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">@expression</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-112"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-112">#</a> </div> <p>The meat of the <strong>ExistenceNode</strong> is in this static <code>compileTest</code> method
|
||||
<span class="nx">ExistenceNode</span><span class="p">.</span><span class="nx">compileTest</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">@expression</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-115"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-115">#</a> </div> <p>The meat of the <strong>ExistenceNode</strong> is in this static <code>compileTest</code> method
|
||||
because other nodes like to check the existence of their variables as well.
|
||||
Be careful not to double-evaluate anything.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@compileTest: </span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">variable</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">[</span><span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">]</span><span class="o">:</span> <span class="nx">variable</span><span class="p">.</span><span class="nx">compileReference</span> <span class="nx">o</span>
|
||||
<span class="s2">"(typeof ${first.compile(o)} !== \"undefined\" && ${second.compile(o)} !== null)"</span></pre></div> </td> </tr> <tr id="section-113"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-113">#</a> </div> <h3>ParentheticalNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-114"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-114">#</a> </div> <p>An extra set of parentheses, specified explicitly in the source. At one time
|
||||
<span class="s2">"(typeof ${first.compile(o)} !== \"undefined\" && ${second.compile(o)} !== null)"</span></pre></div> </td> </tr> <tr id="section-116"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-116">#</a> </div> <h3>ParentheticalNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-117"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-117">#</a> </div> <p>An extra set of parentheses, specified explicitly in the source. At one time
|
||||
we tried to clean up the results by detecting and removing redundant
|
||||
parentheses, but no longer -- you can put in as many as you please.</p>
|
||||
|
||||
|
|
@ -833,12 +861,17 @@ parentheses, but no longer -- you can put in as many as you please.</p>
|
|||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="nx">@expression</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span>
|
||||
|
||||
<span class="nv">topSensitive: </span><span class="o">-></span>
|
||||
<span class="kc">yes</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">top: </span> <span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'top'</span>
|
||||
<span class="nv">code: </span><span class="nx">@expression</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="k">return</span> <span class="nx">code</span> <span class="k">if</span> <span class="nx">@isStatement</span><span class="p">()</span>
|
||||
<span class="k">if</span> <span class="nx">@isStatement</span><span class="p">()</span>
|
||||
<span class="k">return</span> <span class="p">(</span><span class="k">if</span> <span class="nx">top</span> <span class="k">then</span> <span class="s2">"$@tab$code;"</span> <span class="k">else</span> <span class="nx">code</span><span class="p">)</span>
|
||||
<span class="nv">l: </span> <span class="nx">code</span><span class="p">.</span><span class="nx">length</span>
|
||||
<span class="nv">code: </span><span class="nx">code</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">l</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="k">if</span> <span class="nx">code</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="nx">l</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span> <span class="o">is</span> <span class="s1">';'</span>
|
||||
<span class="k">if</span> <span class="nx">@expression</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">"($code)"</span></pre></div> </td> </tr> <tr id="section-115"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-115">#</a> </div> <h3>ForNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-116"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-116">#</a> </div> <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
|
||||
<span class="k">if</span> <span class="nx">@expression</span> <span class="k">instanceof</span> <span class="nx">AssignNode</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">"($code)"</span></pre></div> </td> </tr> <tr id="section-118"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-118">#</a> </div> <h3>ForNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-119"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-119">#</a> </div> <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
|
||||
comprehensions, that compile into <em>for</em> loops here. They also act as an
|
||||
expression, able to return the result of each filtered iteration.</p>
|
||||
|
||||
|
|
@ -873,7 +906,7 @@ you can map and filter in a single pass.</p> </td> <td c
|
|||
<span class="nv">compileReturnValue: </span><span class="p">(</span><span class="nx">val</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">return</span> <span class="s1">'\n'</span> <span class="o">+</span> <span class="k">new</span> <span class="nx">ReturnNode</span><span class="p">(</span><span class="nx">literal</span><span class="p">(</span><span class="nx">val</span><span class="p">)).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@returns</span>
|
||||
<span class="k">return</span> <span class="s1">'\n'</span> <span class="o">+</span> <span class="nx">val</span> <span class="k">if</span> <span class="nx">val</span>
|
||||
<span class="s1">''</span></pre></div> </td> </tr> <tr id="section-117"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-117">#</a> </div> <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
|
||||
<span class="s1">''</span></pre></div> </td> </tr> <tr id="section-120"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-120">#</a> </div> <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
|
||||
loop, filtering, stepping, and result saving for array, object, and range
|
||||
comprehensions. Some of the generated code can be shared in common, and
|
||||
some cannot.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
|
|
@ -891,13 +924,14 @@ some cannot.</p> </td> <td class="code"> <
|
|||
<span class="nv">varPart: </span> <span class="s1">''</span>
|
||||
<span class="nv">body: </span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">@body</span><span class="p">])</span>
|
||||
<span class="k">if</span> <span class="nx">range</span>
|
||||
<span class="nv">sourcePart: </span> <span class="nx">source</span><span class="p">.</span><span class="nx">compileVariables</span> <span class="nx">o</span>
|
||||
<span class="nv">sourcePart: </span> <span class="nx">source</span><span class="p">.</span><span class="nx">compileVariables</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">sourcePart: </span> <span class="o">+</span> <span class="s2">"\n$o.indent"</span> <span class="k">if</span> <span class="nx">sourcePart</span>
|
||||
<span class="nv">forPart: </span> <span class="nx">source</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">index: </span><span class="nx">ivar</span><span class="p">,</span> <span class="nv">step: </span><span class="nx">@step</span><span class="p">}</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">svar: </span> <span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span><span class="p">()</span>
|
||||
<span class="nv">sourcePart: </span> <span class="s2">"$svar = ${ @source.compile(o) };"</span>
|
||||
<span class="k">if</span> <span class="nx">@pattern</span>
|
||||
<span class="nv">namePart: </span> <span class="k">new</span> <span class="nx">AssignNode</span><span class="p">(</span><span class="nx">@name</span><span class="p">,</span> <span class="nx">literal</span><span class="p">(</span><span class="s2">"$svar[$ivar]"</span><span class="p">)).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">@idt</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="nv">top: </span><span class="kc">true</span><span class="p">})</span> <span class="o">+</span> <span class="s2">"\n"</span>
|
||||
<span class="nv">namePart: </span> <span class="k">new</span> <span class="nx">AssignNode</span><span class="p">(</span><span class="nx">@name</span><span class="p">,</span> <span class="nx">literal</span><span class="p">(</span><span class="s2">"$svar[$ivar]"</span><span class="p">)).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">@idt</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="nv">top: </span><span class="kc">true</span><span class="p">})</span> <span class="o">+</span> <span class="s1">'\n'</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">namePart: </span> <span class="s2">"$name = $svar[$ivar]"</span> <span class="k">if</span> <span class="nx">name</span>
|
||||
<span class="nx">unless</span> <span class="nx">@object</span>
|
||||
|
|
@ -916,13 +950,13 @@ some cannot.</p> </td> <td class="code"> <
|
|||
<span class="nx">body</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">literal</span> <span class="s2">"var $index = $ivar"</span> <span class="k">if</span> <span class="nx">index</span>
|
||||
<span class="nv">body: </span> <span class="nx">ClosureNode</span><span class="p">.</span><span class="nx">wrap</span><span class="p">(</span><span class="nx">body</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">varPart: </span> <span class="s2">"${@idt(1)}$namePart;\n"</span> <span class="k">if</span> <span class="nx">namePart</span>
|
||||
<span class="nv">varPart: </span> <span class="p">(</span><span class="nx">namePart</span> <span class="o">or</span> <span class="s1">''</span><span class="p">)</span> <span class="o">and</span> <span class="p">(</span><span class="k">if</span> <span class="nx">@pattern</span> <span class="k">then</span> <span class="nx">namePart</span> <span class="k">else</span> <span class="s2">"${@idt(1)}$namePart;\n"</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">@object</span>
|
||||
<span class="nv">forPart: </span> <span class="s2">"$ivar in $svar) { if (${utility('hasProp')}.call($svar, $ivar)"</span>
|
||||
<span class="nv">body: </span> <span class="nx">body</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">@idt</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="nv">top: </span><span class="kc">true</span><span class="p">}))</span>
|
||||
<span class="nv">vars: </span> <span class="k">if</span> <span class="nx">range</span> <span class="k">then</span> <span class="nx">name</span> <span class="k">else</span> <span class="s2">"$name, $ivar"</span>
|
||||
<span class="nv">close: </span> <span class="k">if</span> <span class="nx">@object</span> <span class="k">then</span> <span class="s1">'}}'</span> <span class="k">else</span> <span class="s1">'}'</span>
|
||||
<span class="s2">"${sourcePart}for ($forPart) {\n$varPart$body\n$@tab$close$returnResult"</span></pre></div> </td> </tr> <tr id="section-118"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-118">#</a> </div> <h3>IfNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-119"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-119">#</a> </div> <p><em>If/else</em> statements. Our <em>switch/when</em> will be compiled into this. Acts as an
|
||||
<span class="s2">"${sourcePart}for ($forPart) {\n$varPart$body\n$@tab$close$returnResult"</span></pre></div> </td> </tr> <tr id="section-121"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-121">#</a> </div> <h3>IfNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-122"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-122">#</a> </div> <p><em>If/else</em> statements. Our <em>switch/when</em> will be compiled into this. Acts as an
|
||||
expression by pushing down requested returns to the last line of each clause.</p>
|
||||
|
||||
<p>Single-expression <strong>IfNodes</strong> are compiled into ternary operators if possible,
|
||||
|
|
@ -934,20 +968,20 @@ because ternaries are already proper expressions, and don't need conversion.</p>
|
|||
<span class="nv">constructor: </span><span class="p">(</span><span class="nx">condition</span><span class="p">,</span> <span class="nx">body</span><span class="p">,</span> <span class="nx">tags</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@condition: </span><span class="nx">condition</span>
|
||||
<span class="vi">@body: </span> <span class="nx">body</span>
|
||||
<span class="vi">@elseBody: </span><span class="kc">null</span>
|
||||
<span class="vi">@elseBody: </span> <span class="kc">null</span>
|
||||
<span class="vi">@tags: </span> <span class="nx">tags</span> <span class="o">or</span> <span class="p">{}</span>
|
||||
<span class="vi">@condition: </span><span class="k">new</span> <span class="nx">OpNode</span><span class="p">(</span><span class="s1">'!'</span><span class="p">,</span> <span class="k">new</span> <span class="nx">ParentheticalNode</span><span class="p">(</span><span class="nx">@condition</span><span class="p">))</span> <span class="k">if</span> <span class="nx">@tags</span><span class="p">.</span><span class="nx">invert</span>
|
||||
<span class="vi">@isChain: </span> <span class="kc">false</span>
|
||||
<span class="vi">@isChain: </span> <span class="kc">false</span>
|
||||
|
||||
<span class="nv">bodyNode: </span><span class="o">-></span> <span class="nx">@body</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span>
|
||||
<span class="nv">elseBodyNode: </span><span class="o">-></span> <span class="nx">@elseBody</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span>
|
||||
|
||||
<span class="nv">forceStatement: </span><span class="o">-></span>
|
||||
<span class="vi">@tags.statement: </span><span class="kc">true</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-120"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-120">#</a> </div> <p>Tag a chain of <strong>IfNodes</strong> with their object(s) to switch on for equality
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-123"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-123">#</a> </div> <p>Tag a chain of <strong>IfNodes</strong> with their object(s) to switch on for equality
|
||||
tests. <code>rewriteSwitch</code> will perform the actual change at compile time.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">switchesOver: </span><span class="p">(</span><span class="nx">expression</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@switchSubject: </span><span class="nx">expression</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-121"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-121">#</a> </div> <p>Rewrite a chain of <strong>IfNodes</strong> with their switch condition for equality.
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-124"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-124">#</a> </div> <p>Rewrite a chain of <strong>IfNodes</strong> with their switch condition for equality.
|
||||
Ensure that the switch expression isn't evaluated more than once.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">rewriteSwitch: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="vi">@assigner: </span><span class="nx">@switchSubject</span>
|
||||
<span class="nx">unless</span> <span class="p">(</span><span class="nx">@switchSubject</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span> <span class="k">instanceof</span> <span class="nx">LiteralNode</span><span class="p">)</span>
|
||||
|
|
@ -957,14 +991,14 @@ Ensure that the switch expression isn't evaluated more than once.</p>
|
|||
<span class="vi">@condition: </span><span class="k">for</span> <span class="nx">cond</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">flatten</span> <span class="p">[</span><span class="nx">@condition</span><span class="p">]</span>
|
||||
<span class="nv">cond: </span><span class="k">new</span> <span class="nx">ParentheticalNode</span><span class="p">(</span><span class="nx">cond</span><span class="p">)</span> <span class="k">if</span> <span class="nx">cond</span> <span class="k">instanceof</span> <span class="nx">OpNode</span>
|
||||
<span class="k">new</span> <span class="nx">OpNode</span><span class="p">(</span><span class="s1">'=='</span><span class="p">,</span> <span class="p">(</span><span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="mi">0</span> <span class="k">then</span> <span class="nx">@assigner</span> <span class="k">else</span> <span class="nx">@switchSubject</span><span class="p">),</span> <span class="nx">cond</span><span class="p">)</span>
|
||||
<span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">switchesOver</span><span class="p">(</span><span class="nx">@switchSubject</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@isChain</span></pre></div> </td> </tr> <tr id="section-122"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-122">#</a> </div> <p>prevent this rewrite from happening again</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@switchSubject: </span><span class="kc">undefined</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-123"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-123">#</a> </div> <p>Rewrite a chain of <strong>IfNodes</strong> to add a default case as the final <em>else</em>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">addElse: </span><span class="p">(</span><span class="nx">elseBody</span><span class="p">,</span> <span class="nx">statement</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">switchesOver</span><span class="p">(</span><span class="nx">@switchSubject</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@isChain</span></pre></div> </td> </tr> <tr id="section-125"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-125">#</a> </div> <p>prevent this rewrite from happening again</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@switchSubject: </span><span class="kc">undefined</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-126"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-126">#</a> </div> <p>Rewrite a chain of <strong>IfNodes</strong> to add a default case as the final <em>else</em>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">addElse: </span><span class="p">(</span><span class="nx">elseBody</span><span class="p">,</span> <span class="nx">statement</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">if</span> <span class="nx">@isChain</span>
|
||||
<span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">addElse</span> <span class="nx">elseBody</span><span class="p">,</span> <span class="nx">statement</span>
|
||||
<span class="k">else</span>
|
||||
<span class="vi">@isChain: </span><span class="nx">elseBody</span> <span class="k">instanceof</span> <span class="nx">IfNode</span>
|
||||
<span class="vi">@elseBody: </span><span class="nx">@ensureExpressions</span> <span class="nx">elseBody</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-124"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-124">#</a> </div> <p>The <strong>IfNode</strong> only compiles into a statement if either of its bodies needs
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-127"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-127">#</a> </div> <p>The <strong>IfNode</strong> only compiles into a statement if either of its bodies needs
|
||||
to be a statement. Otherwise a ternary is safe.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">isStatement: </span><span class="o">-></span>
|
||||
<span class="vi">@statement: </span><span class="o">or</span> <span class="o">!!</span><span class="p">(</span><span class="nx">@tags</span><span class="p">.</span><span class="nx">statement</span> <span class="o">or</span> <span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">isStatement</span><span class="p">()</span> <span class="o">or</span> <span class="p">(</span><span class="nx">@elseBody</span> <span class="o">and</span> <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">isStatement</span><span class="p">()))</span>
|
||||
|
||||
|
|
@ -975,12 +1009,15 @@ to be a statement. Otherwise a ternary is safe.</p> </td>
|
|||
<span class="k">if</span> <span class="nx">@isStatement</span><span class="p">()</span> <span class="k">then</span> <span class="nx">@compileStatement</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="nx">@compileTernary</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
|
||||
<span class="nv">makeReturn: </span><span class="o">-></span>
|
||||
<span class="vi">@body: </span> <span class="o">and</span> <span class="nx">@ensureExpressions</span><span class="p">(</span><span class="nx">@body</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">())</span>
|
||||
<span class="vi">@elseBody: </span> <span class="o">and</span> <span class="nx">@ensureExpressions</span><span class="p">(</span><span class="nx">@elseBody</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">())</span>
|
||||
<span class="k">this</span>
|
||||
<span class="k">if</span> <span class="nx">@isStatement</span><span class="p">()</span>
|
||||
<span class="vi">@body: </span> <span class="o">and</span> <span class="nx">@ensureExpressions</span><span class="p">(</span><span class="nx">@body</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">())</span>
|
||||
<span class="vi">@elseBody: </span> <span class="o">and</span> <span class="nx">@ensureExpressions</span><span class="p">(</span><span class="nx">@elseBody</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">())</span>
|
||||
<span class="k">this</span>
|
||||
<span class="k">else</span>
|
||||
<span class="k">new</span> <span class="nx">ReturnNode</span> <span class="k">this</span>
|
||||
|
||||
<span class="nv">ensureExpressions: </span><span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Expressions</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Expressions</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-125"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-125">#</a> </div> <p>Compile the <strong>IfNode</strong> as a regular <em>if-else</em> statement. Flattened chains
|
||||
<span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Expressions</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Expressions</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-128"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-128">#</a> </div> <p>Compile the <strong>IfNode</strong> as a regular <em>if-else</em> statement. Flattened chains
|
||||
force inner <em>else</em> bodies into statement form.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileStatement: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nx">@rewriteSwitch</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@switchSubject</span>
|
||||
<span class="nv">child: </span> <span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">'chainChild'</span>
|
||||
|
|
@ -996,10 +1033,10 @@ force inner <em>else</em> bodies into statement form.</p> </td>
|
|||
<span class="s1">' else '</span> <span class="o">+</span> <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">compile</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nv">indent: </span><span class="nx">@idt</span><span class="p">(),</span> <span class="nv">chainChild: </span><span class="kc">true</span><span class="p">}))</span>
|
||||
<span class="k">else</span>
|
||||
<span class="s2">" else {\n${ @elseBody.compile(o) }\n$@tab}"</span>
|
||||
<span class="s2">"$ifPart$elsePart"</span></pre></div> </td> </tr> <tr id="section-126"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-126">#</a> </div> <p>Compile the IfNode as a ternary operator.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileTernary: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="s2">"$ifPart$elsePart"</span></pre></div> </td> </tr> <tr id="section-129"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-129">#</a> </div> <p>Compile the IfNode as a ternary operator.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileTernary: </span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">ifPart: </span> <span class="nx">@condition</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="s1">' ? '</span> <span class="o">+</span> <span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
<span class="nv">elsePart: </span> <span class="k">if</span> <span class="nx">@elseBody</span> <span class="k">then</span> <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">else</span> <span class="s1">'null'</span>
|
||||
<span class="s2">"$ifPart : $elsePart"</span></pre></div> </td> </tr> <tr id="section-127"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-127">#</a> </div> <h2>Faux-Nodes</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-128"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-128">#</a> </div> <h3>PushNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-129"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-129">#</a> </div> <p>Faux-nodes are never created by the grammar, but are used during code
|
||||
<span class="s2">"$ifPart : $elsePart"</span></pre></div> </td> </tr> <tr id="section-130"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-130">#</a> </div> <h2>Faux-Nodes</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-131"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-131">#</a> </div> <h3>PushNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-132"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-132">#</a> </div> <p>Faux-nodes are never created by the grammar, but are used during code
|
||||
generation to generate other combinations of nodes. The <strong>PushNode</strong> creates
|
||||
the tree for <code>array.push(value)</code>, which is helpful for recording the result
|
||||
arrays from comprehensions.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">PushNode: exports.PushNode: </span><span class="p">{</span>
|
||||
|
|
@ -1011,14 +1048,17 @@ arrays from comprehensions.</p> </td> <td class="code">
|
|||
<span class="k">new</span> <span class="nx">ValueNode</span><span class="p">(</span><span class="nx">literal</span><span class="p">(</span><span class="nx">array</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">AccessorNode</span><span class="p">(</span><span class="nx">literal</span><span class="p">(</span><span class="s1">'push'</span><span class="p">))]),</span> <span class="p">[</span><span class="nx">expr</span><span class="p">]</span>
|
||||
<span class="p">)])</span>
|
||||
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-130"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-130">#</a> </div> <h3>ClosureNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-131"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-131">#</a> </div> <p>A faux-node used to wrap an expressions body in a closure.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">ClosureNode: exports.ClosureNode: </span><span class="p">{</span></pre></div> </td> </tr> <tr id="section-132"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-132">#</a> </div> <p>Wrap the expressions body, unless it contains a pure statement,
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-133"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-133">#</a> </div> <h3>ClosureNode</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-134"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-134">#</a> </div> <p>A faux-node used to wrap an expressions body in a closure.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">ClosureNode: exports.ClosureNode: </span><span class="p">{</span></pre></div> </td> </tr> <tr id="section-135"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-135">#</a> </div> <p>Wrap the expressions body, unless it contains a pure statement,
|
||||
in which case, no dice. If the body mentions <code>this</code> or <code>arguments</code>,
|
||||
then make sure that the closure wrapper preserves the original values.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">wrap: </span><span class="p">(</span><span class="nx">expressions</span><span class="p">,</span> <span class="nx">statement</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">return</span> <span class="nx">expressions</span> <span class="k">if</span> <span class="nx">expressions</span><span class="p">.</span><span class="nx">containsPureStatement</span><span class="p">()</span>
|
||||
<span class="nv">func: </span><span class="k">new</span> <span class="nx">ParentheticalNode</span><span class="p">(</span><span class="k">new</span> <span class="nx">CodeNode</span><span class="p">([],</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">expressions</span><span class="p">])))</span>
|
||||
<span class="nv">args: </span><span class="p">[]</span>
|
||||
<span class="nv">mentionsArgs: </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span> <span class="p">(</span><span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">LiteralNode</span><span class="p">)</span> <span class="o">and</span> <span class="p">(</span><span class="nx">n</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">'arguments'</span><span class="p">)</span>
|
||||
<span class="nv">mentionsThis: </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span> <span class="p">(</span><span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">LiteralNode</span><span class="p">)</span> <span class="o">and</span> <span class="p">(</span><span class="nx">n</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">'this'</span><span class="p">)</span>
|
||||
<span class="nv">mentionsArgs: </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">LiteralNode</span> <span class="o">and</span> <span class="p">(</span><span class="nx">n</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">'arguments'</span><span class="p">)</span>
|
||||
<span class="nv">mentionsThis: </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">(</span><span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">LiteralNode</span> <span class="o">and</span> <span class="p">(</span><span class="nx">n</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">'this'</span><span class="p">))</span> <span class="o">or</span>
|
||||
<span class="p">(</span><span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">CodeNode</span> <span class="o">and</span> <span class="nx">n</span><span class="p">.</span><span class="nx">bound</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">mentionsArgs</span> <span class="o">or</span> <span class="nx">mentionsThis</span>
|
||||
<span class="nv">meth: </span><span class="nx">literal</span><span class="p">(</span><span class="k">if</span> <span class="nx">mentionsArgs</span> <span class="k">then</span> <span class="s1">'apply'</span> <span class="k">else</span> <span class="s1">'call'</span><span class="p">)</span>
|
||||
<span class="nv">args: </span><span class="p">[</span><span class="nx">literal</span><span class="p">(</span><span class="s1">'this'</span><span class="p">)]</span>
|
||||
|
|
@ -1027,7 +1067,7 @@ then make sure that the closure wrapper preserves the original values.</p>
|
|||
<span class="nv">call: </span><span class="k">new</span> <span class="nx">CallNode</span><span class="p">(</span><span class="nx">func</span><span class="p">,</span> <span class="nx">args</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">statement</span> <span class="k">then</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">call</span><span class="p">])</span> <span class="k">else</span> <span class="nx">call</span>
|
||||
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-133"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-133">#</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre><span class="nv">UTILITIES: </span><span class="p">{</span></pre></div> </td> </tr> <tr id="section-134"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-134">#</a> </div> <p>Correctly set up a prototype chain for inheritance, including a reference
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-136"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-136">#</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre><span class="nv">UTILITIES: </span><span class="p">{</span></pre></div> </td> </tr> <tr id="section-137"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-137">#</a> </div> <p>Correctly set up a prototype chain for inheritance, including a reference
|
||||
to the superclass for <code>super()</code> calls. See:
|
||||
<a href="http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.source.html#line1206">goog.inherits</a>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">__extends: </span> <span class="s2">"""</span>
|
||||
<span class="s2"> function(child, parent) {</span>
|
||||
|
|
@ -1037,13 +1077,13 @@ to the superclass for <code>super()</code> calls. See:
|
|||
<span class="s2"> child.prototype = new ctor();</span>
|
||||
<span class="s2"> child.prototype.constructor = child;</span>
|
||||
<span class="s2"> }</span>
|
||||
<span class="s2"> """</span></pre></div> </td> </tr> <tr id="section-135"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-135">#</a> </div> <p>Shortcuts to speed up the lookup time for native functions.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">__hasProp: </span><span class="s1">'Object.prototype.hasOwnProperty'</span>
|
||||
<span class="s2"> """</span></pre></div> </td> </tr> <tr id="section-138"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-138">#</a> </div> <p>Shortcuts to speed up the lookup time for native functions.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">__hasProp: </span><span class="s1">'Object.prototype.hasOwnProperty'</span>
|
||||
<span class="nv">__slice: </span> <span class="s1">'Array.prototype.slice'</span>
|
||||
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-136"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-136">#</a> </div> <h2>Constants</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-137"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-137">#</a> </div> <p>Tabs are two spaces for pretty printing.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TAB: </span><span class="s1">' '</span></pre></div> </td> </tr> <tr id="section-138"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-138">#</a> </div> <p>Trim out all trailing whitespace, so that the generated code plays nice
|
||||
with Git.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TRAILING_WHITESPACE: </span><span class="sr">/[ \t]+$/gm</span></pre></div> </td> </tr> <tr id="section-139"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-139">#</a> </div> <p>Obvious redundant parentheses should be removed.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">DOUBLE_PARENS: </span><span class="sr">/\(\(([^\(\)\n]*)\)\)/g</span></pre></div> </td> </tr> <tr id="section-140"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-140">#</a> </div> <p>Keep these identifier regexes in sync with the Lexer.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IDENTIFIER: </span><span class="sr">/^[a-zA-Z\$_](\w|\$)*$/</span>
|
||||
<span class="nv">NUMBER : </span><span class="sr">/^(((\b0(x|X)[0-9a-fA-F]+)|((\b[0-9]+(\.[0-9]+)?|\.[0-9]+)(e[+\-]?[0-9]+)?)))\b$/i</span></pre></div> </td> </tr> <tr id="section-141"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-141">#</a> </div> <p>Is a literal value a string?</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IS_STRING: </span><span class="sr">/^['"]/</span></pre></div> </td> </tr> <tr id="section-142"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-142">#</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-143"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-143">#</a> </div> <p>Handy helper for a generating LiteralNode.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">literal: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">new</span> <span class="nx">LiteralNode</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-144"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-144">#</a> </div> <p>Helper for ensuring that utility functions are assigned at the top level.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">utility: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="p">}</span></pre></div> </td> </tr> <tr id="section-139"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-139">#</a> </div> <h2>Constants</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-140"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-140">#</a> </div> <p>Tabs are two spaces for pretty printing.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TAB: </span><span class="s1">' '</span></pre></div> </td> </tr> <tr id="section-141"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-141">#</a> </div> <p>Trim out all trailing whitespace, so that the generated code plays nice
|
||||
with Git.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TRAILING_WHITESPACE: </span><span class="sr">/[ \t]+$/gm</span></pre></div> </td> </tr> <tr id="section-142"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-142">#</a> </div> <p>Obvious redundant parentheses should be removed.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">DOUBLE_PARENS: </span><span class="sr">/\(\(([^\(\)\n]*)\)\)/g</span></pre></div> </td> </tr> <tr id="section-143"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-143">#</a> </div> <p>Keep these identifier regexes in sync with the Lexer.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IDENTIFIER: </span><span class="sr">/^[a-zA-Z\$_](\w|\$)*$/</span>
|
||||
<span class="nv">NUMBER : </span><span class="sr">/^(((\b0(x|X)[0-9a-fA-F]+)|((\b[0-9]+(\.[0-9]+)?|\.[0-9]+)(e[+\-]?[0-9]+)?)))\b$/i</span></pre></div> </td> </tr> <tr id="section-144"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-144">#</a> </div> <p>Is a literal value a string?</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IS_STRING: </span><span class="sr">/^['"]/</span></pre></div> </td> </tr> <tr id="section-145"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-145">#</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-146"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-146">#</a> </div> <p>Handy helper for a generating LiteralNode.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">literal: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="k">new</span> <span class="nx">LiteralNode</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-147"> <td class="docs"> <div class="octowrap"> <a class="octothorpe" href="#section-147">#</a> </div> <p>Helper for ensuring that utility functions are assigned at the top level.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">utility: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-></span>
|
||||
<span class="nv">ref: </span><span class="s2">"__$name"</span>
|
||||
<span class="nx">Scope</span><span class="p">.</span><span class="nx">root</span><span class="p">.</span><span class="nx">assign</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">UTILITIES</span><span class="p">[</span><span class="nx">ref</span><span class="p">]</span>
|
||||
<span class="nx">ref</span>
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue