1028 lines
30 KiB
HTML
1028 lines
30 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset='UTF-8'>
|
|
<title>CoffeeScript API Documentation</title>
|
|
<script src='../../../../../javascript/application.js'></script>
|
|
<script src='../../../../../javascript/search.js'></script>
|
|
<link rel='stylesheet' href='../../../../../stylesheets/application.css' type='text/css'>
|
|
</head>
|
|
<body>
|
|
<div id='base' data-path='../../../../../'></div>
|
|
<div id='header'>
|
|
<div id='menu'>
|
|
<a href='../../../../../extra/README.md.html' title='Yatta'>
|
|
Yatta
|
|
</a>
|
|
»
|
|
<a href='../../../../../alphabetical_index.html' title='Index'>
|
|
Index
|
|
</a>
|
|
»
|
|
<span class='title'>node_modules</span>
|
|
»
|
|
<span class='title'>gulp-coffee</span>
|
|
»
|
|
<span class='title'>test</span>
|
|
»
|
|
<span class='title'>fixtures</span>
|
|
»
|
|
<span class='title'>grammar.coffee</span>
|
|
</div>
|
|
</div>
|
|
<div id='content'>
|
|
<h1>
|
|
File:
|
|
grammar.coffee
|
|
</h1>
|
|
<table class='box'>
|
|
<tr>
|
|
<td>Defined in:</td>
|
|
<td>node_modules/gulp-coffee/test/fixtures</td>
|
|
</tr>
|
|
</table>
|
|
<h2>Variables Summary</h2>
|
|
<dl class='constants'>
|
|
<dt id='unwrap-variable'>
|
|
unwrap
|
|
=
|
|
</dt>
|
|
<dd>
|
|
<pre><code class='coffeescript'>/^function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/</code></pre>
|
|
<div class='docstring'>
|
|
<p>Since we're going to be wrapped in a function by Jison in any case, if our
|
|
action immediately returns a value, we can optimize by removing the function
|
|
wrapper and just returning the value directly.</p>
|
|
</div>
|
|
<div class='tags'>
|
|
</div>
|
|
</dd>
|
|
<dt id='grammar-variable'>
|
|
grammar
|
|
=
|
|
</dt>
|
|
<dd>
|
|
<pre><code class='coffeescript'>{
|
|
|
|
/*
|
|
The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
|
|
all parsing must end here.
|
|
*/
|
|
Root: [
|
|
o('', function() {
|
|
return new Block;
|
|
}), o('Body')
|
|
],
|
|
|
|
/*
|
|
Any list of statements and expressions, separated by line breaks or semicolons.
|
|
*/
|
|
Body: [
|
|
o('Line', function() {
|
|
return Block.wrap([$1]);
|
|
}), o('Body TERMINATOR Line', function() {
|
|
return $1.push($3);
|
|
}), o('Body TERMINATOR')
|
|
],
|
|
|
|
/*
|
|
Block and statements, which make up a line in a body.
|
|
*/
|
|
Line: [o('Expression'), o('Statement')],
|
|
|
|
/*
|
|
Pure statements which cannot be expressions.
|
|
*/
|
|
Statement: [
|
|
o('Return'), o('Comment'), o('STATEMENT', function() {
|
|
return new Literal($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
All the different types of expressions in our language. The basic unit of
|
|
CoffeeScript is the **Expression** -- everything that can be an expression
|
|
is one. Blocks serve as the building blocks of many other rules, making
|
|
them somewhat circular.
|
|
*/
|
|
Expression: [o('Value'), o('Invocation'), o('Code'), o('Operation'), o('Assign'), o('If'), o('Try'), o('While'), o('For'), o('Switch'), o('Class'), o('Throw')],
|
|
|
|
/*
|
|
An indented block of expressions. Note that the [Rewriter](rewriter.html)
|
|
will convert some postfix forms into blocks for us, by adjusting the
|
|
token stream.
|
|
*/
|
|
Block: [
|
|
o('INDENT OUTDENT', function() {
|
|
return new Block;
|
|
}), o('INDENT Body OUTDENT', function() {
|
|
return $2;
|
|
})
|
|
],
|
|
|
|
/*
|
|
A literal identifier, a variable name or property.
|
|
*/
|
|
Identifier: [
|
|
o('IDENTIFIER', function() {
|
|
return new Literal($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Alphanumerics are separated from the other **Literal** matchers because
|
|
they can also serve as keys in object literals.
|
|
*/
|
|
AlphaNumeric: [
|
|
o('NUMBER', function() {
|
|
return new Literal($1);
|
|
}), o('STRING', function() {
|
|
return new Literal($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
All of our immediate values. Generally these can be passed straight
|
|
through and printed to JavaScript.
|
|
*/
|
|
Literal: [
|
|
o('AlphaNumeric'), o('JS', function() {
|
|
return new Literal($1);
|
|
}), o('REGEX', function() {
|
|
return new Literal($1);
|
|
}), o('DEBUGGER', function() {
|
|
return new Literal($1);
|
|
}), o('UNDEFINED', function() {
|
|
return new Undefined;
|
|
}), o('NULL', function() {
|
|
return new Null;
|
|
}), o('BOOL', function() {
|
|
return new Bool($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Assignment of a variable, property, or index to a value.
|
|
*/
|
|
Assign: [
|
|
o('Assignable = Expression', function() {
|
|
return new Assign($1, $3);
|
|
}), o('Assignable = TERMINATOR Expression', function() {
|
|
return new Assign($1, $4);
|
|
}), o('Assignable = INDENT Expression OUTDENT', function() {
|
|
return new Assign($1, $4);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Assignment when it happens within an object literal. The difference from
|
|
the ordinary **Assign** is that these allow numbers and strings as keys.
|
|
*/
|
|
AssignObj: [
|
|
o('ObjAssignable', function() {
|
|
return new Value($1);
|
|
}), o('ObjAssignable : Expression', function() {
|
|
return new Assign(LOC(1)(new Value($1)), $3, 'object');
|
|
}), o('ObjAssignable : INDENT Expression OUTDENT', function() {
|
|
return new Assign(LOC(1)(new Value($1)), $4, 'object');
|
|
}), o('Comment')
|
|
],
|
|
ObjAssignable: [o('Identifier'), o('AlphaNumeric'), o('ThisProperty')],
|
|
|
|
/*
|
|
A return statement from a function body.
|
|
*/
|
|
Return: [
|
|
o('RETURN Expression', function() {
|
|
return new Return($2);
|
|
}), o('RETURN', function() {
|
|
return new Return;
|
|
})
|
|
],
|
|
|
|
/*
|
|
A block comment.
|
|
*/
|
|
Comment: [
|
|
o('HERECOMMENT', function() {
|
|
return new Comment($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
The **Code** node is the function literal. It's defined by an indented block
|
|
of **Block** preceded by a function arrow, with an optional parameter
|
|
list.
|
|
*/
|
|
Code: [
|
|
o('PARAM_START ParamList PARAM_END FuncGlyph Block', function() {
|
|
return new Code($2, $5, $4);
|
|
}), o('FuncGlyph Block', function() {
|
|
return new Code([], $2, $1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
CoffeeScript has two different symbols for functions. `->` is for ordinary
|
|
functions, and `=>` is for functions bound to the current value of *this*.
|
|
*/
|
|
FuncGlyph: [
|
|
o('->', function() {
|
|
return 'func';
|
|
}), o('=>', function() {
|
|
return 'boundfunc';
|
|
})
|
|
],
|
|
|
|
/*
|
|
An optional, trailing comma.
|
|
*/
|
|
OptComma: [o(''), o(',')],
|
|
|
|
/*
|
|
The list of parameters that a function accepts can be of any length.
|
|
*/
|
|
ParamList: [
|
|
o('', function() {
|
|
return [];
|
|
}), o('Param', function() {
|
|
return [$1];
|
|
}), o('ParamList , Param', function() {
|
|
return $1.concat($3);
|
|
}), o('ParamList OptComma TERMINATOR Param', function() {
|
|
return $1.concat($4);
|
|
}), o('ParamList OptComma INDENT ParamList OptComma OUTDENT', function() {
|
|
return $1.concat($4);
|
|
})
|
|
],
|
|
|
|
/*
|
|
A single parameter in a function definition can be ordinary, or a splat
|
|
that hoovers up the remaining arguments.
|
|
*/
|
|
Param: [
|
|
o('ParamVar', function() {
|
|
return new Param($1);
|
|
}), o('ParamVar ...', function() {
|
|
return new Param($1, null, true);
|
|
}), o('ParamVar = Expression', function() {
|
|
return new Param($1, $3);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Function Parameters
|
|
*/
|
|
ParamVar: [o('Identifier'), o('ThisProperty'), o('Array'), o('Object')],
|
|
|
|
/*
|
|
A splat that occurs outside of a parameter list.
|
|
*/
|
|
Splat: [
|
|
o('Expression ...', function() {
|
|
return new Splat($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Variables and properties that can be assigned to.
|
|
*/
|
|
SimpleAssignable: [
|
|
o('Identifier', function() {
|
|
return new Value($1);
|
|
}), o('Value Accessor', function() {
|
|
return $1.add($2);
|
|
}), o('Invocation Accessor', function() {
|
|
return new Value($1, [].concat($2));
|
|
}), o('ThisProperty')
|
|
],
|
|
|
|
/*
|
|
Everything that can be assigned to.
|
|
*/
|
|
Assignable: [
|
|
o('SimpleAssignable'), o('Array', function() {
|
|
return new Value($1);
|
|
}), o('Object', function() {
|
|
return new Value($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
The types of things that can be treated as values -- assigned to, invoked
|
|
as functions, indexed into, named as a class, etc.
|
|
*/
|
|
Value: [
|
|
o('Assignable'), o('Literal', function() {
|
|
return new Value($1);
|
|
}), o('Parenthetical', function() {
|
|
return new Value($1);
|
|
}), o('Range', function() {
|
|
return new Value($1);
|
|
}), o('This')
|
|
],
|
|
|
|
/*
|
|
The general group of accessors into an object, by property, by prototype
|
|
or by array index or slice.
|
|
*/
|
|
Accessor: [
|
|
o('. Identifier', function() {
|
|
return new Access($2);
|
|
}), o('?. Identifier', function() {
|
|
return new Access($2, 'soak');
|
|
}), o(':: Identifier', function() {
|
|
return [LOC(1)(new Access(new Literal('prototype'))), LOC(2)(new Access($2))];
|
|
}), o('?:: Identifier', function() {
|
|
return [LOC(1)(new Access(new Literal('prototype'), 'soak')), LOC(2)(new Access($2))];
|
|
}), o('::', function() {
|
|
return new Access(new Literal('prototype'));
|
|
}), o('Index')
|
|
],
|
|
|
|
/*
|
|
Indexing into an object or array using bracket notation.
|
|
*/
|
|
Index: [
|
|
o('INDEX_START IndexValue INDEX_END', function() {
|
|
return $2;
|
|
}), o('INDEX_SOAK Index', function() {
|
|
return extend($2, {
|
|
soak: true
|
|
});
|
|
})
|
|
],
|
|
IndexValue: [
|
|
o('Expression', function() {
|
|
return new Index($1);
|
|
}), o('Slice', function() {
|
|
return new Slice($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
In CoffeeScript, an object literal is simply a list of assignments.
|
|
*/
|
|
Object: [
|
|
o('{ AssignList OptComma }', function() {
|
|
return new Obj($2, $1.generated);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Assignment of properties within an object literal can be separated by
|
|
comma, as in JavaScript, or simply by newline.
|
|
*/
|
|
AssignList: [
|
|
o('', function() {
|
|
return [];
|
|
}), o('AssignObj', function() {
|
|
return [$1];
|
|
}), o('AssignList , AssignObj', function() {
|
|
return $1.concat($3);
|
|
}), o('AssignList OptComma TERMINATOR AssignObj', function() {
|
|
return $1.concat($4);
|
|
}), o('AssignList OptComma INDENT AssignList OptComma OUTDENT', function() {
|
|
return $1.concat($4);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Class definitions have optional bodies of prototype property assignments,
|
|
and optional references to the superclass.
|
|
*/
|
|
Class: [
|
|
o('CLASS', function() {
|
|
return new Class;
|
|
}), o('CLASS Block', function() {
|
|
return new Class(null, null, $2);
|
|
}), o('CLASS EXTENDS Expression', function() {
|
|
return new Class(null, $3);
|
|
}), o('CLASS EXTENDS Expression Block', function() {
|
|
return new Class(null, $3, $4);
|
|
}), o('CLASS SimpleAssignable', function() {
|
|
return new Class($2);
|
|
}), o('CLASS SimpleAssignable Block', function() {
|
|
return new Class($2, null, $3);
|
|
}), o('CLASS SimpleAssignable EXTENDS Expression', function() {
|
|
return new Class($2, $4);
|
|
}), o('CLASS SimpleAssignable EXTENDS Expression Block', function() {
|
|
return new Class($2, $4, $5);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Ordinary function invocation, or a chained series of calls.
|
|
*/
|
|
Invocation: [
|
|
o('Value OptFuncExist Arguments', function() {
|
|
return new Call($1, $3, $2);
|
|
}), o('Invocation OptFuncExist Arguments', function() {
|
|
return new Call($1, $3, $2);
|
|
}), o('SUPER', function() {
|
|
return new Call('super', [new Splat(new Literal('arguments'))]);
|
|
}), o('SUPER Arguments', function() {
|
|
return new Call('super', $2);
|
|
})
|
|
],
|
|
|
|
/*
|
|
An optional existence check on a function.
|
|
*/
|
|
OptFuncExist: [
|
|
o('', function() {
|
|
return false;
|
|
}), o('FUNC_EXIST', function() {
|
|
return true;
|
|
})
|
|
],
|
|
|
|
/*
|
|
The list of arguments to a function call.
|
|
*/
|
|
Arguments: [
|
|
o('CALL_START CALL_END', function() {
|
|
return [];
|
|
}), o('CALL_START ArgList OptComma CALL_END', function() {
|
|
return $2;
|
|
})
|
|
],
|
|
|
|
/*
|
|
A reference to the *this* current object.
|
|
*/
|
|
This: [
|
|
o('THIS', function() {
|
|
return new Value(new Literal('this'));
|
|
}), o('@', function() {
|
|
return new Value(new Literal('this'));
|
|
})
|
|
],
|
|
|
|
/*
|
|
A reference to a property on *this*.
|
|
*/
|
|
ThisProperty: [
|
|
o('@ Identifier', function() {
|
|
return new Value(LOC(1)(new Literal('this')), [LOC(2)(new Access($2))], 'this');
|
|
})
|
|
],
|
|
|
|
/*
|
|
The array literal.
|
|
*/
|
|
Array: [
|
|
o('[ ]', function() {
|
|
return new Arr([]);
|
|
}), o('[ ArgList OptComma ]', function() {
|
|
return new Arr($2);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Inclusive and exclusive range dots.
|
|
*/
|
|
RangeDots: [
|
|
o('..', function() {
|
|
return 'inclusive';
|
|
}), o('...', function() {
|
|
return 'exclusive';
|
|
})
|
|
],
|
|
|
|
/*
|
|
The CoffeeScript range literal.
|
|
*/
|
|
Range: [
|
|
o('[ Expression RangeDots Expression ]', function() {
|
|
return new Range($2, $4, $3);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Array slice literals.
|
|
*/
|
|
Slice: [
|
|
o('Expression RangeDots Expression', function() {
|
|
return new Range($1, $3, $2);
|
|
}), o('Expression RangeDots', function() {
|
|
return new Range($1, null, $2);
|
|
}), o('RangeDots Expression', function() {
|
|
return new Range(null, $2, $1);
|
|
}), o('RangeDots', function() {
|
|
return new Range(null, null, $1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
The **ArgList** is both the list of objects passed into a function call,
|
|
as well as the contents of an array literal
|
|
(i.e. comma-separated expressions). Newlines work as well.
|
|
*/
|
|
ArgList: [
|
|
o('Arg', function() {
|
|
return [$1];
|
|
}), o('ArgList , Arg', function() {
|
|
return $1.concat($3);
|
|
}), o('ArgList OptComma TERMINATOR Arg', function() {
|
|
return $1.concat($4);
|
|
}), o('INDENT ArgList OptComma OUTDENT', function() {
|
|
return $2;
|
|
}), o('ArgList OptComma INDENT ArgList OptComma OUTDENT', function() {
|
|
return $1.concat($4);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Valid arguments are Blocks or Splats.
|
|
*/
|
|
Arg: [o('Expression'), o('Splat')],
|
|
|
|
/*
|
|
Just simple, comma-separated, required arguments (no fancy syntax). We need
|
|
this to be separate from the **ArgList** for use in **Switch** blocks, where
|
|
having the newlines wouldn't make sense.
|
|
*/
|
|
SimpleArgs: [
|
|
o('Expression'), o('SimpleArgs , Expression', function() {
|
|
return [].concat($1, $3);
|
|
})
|
|
],
|
|
|
|
/*
|
|
The variants of *try/catch/finally* exception handling blocks.
|
|
*/
|
|
Try: [
|
|
o('TRY Block', function() {
|
|
return new Try($2);
|
|
}), o('TRY Block Catch', function() {
|
|
return new Try($2, $3[0], $3[1]);
|
|
}), o('TRY Block FINALLY Block', function() {
|
|
return new Try($2, null, null, $4);
|
|
}), o('TRY Block Catch FINALLY Block', function() {
|
|
return new Try($2, $3[0], $3[1], $5);
|
|
})
|
|
],
|
|
|
|
/*
|
|
A catch clause names its error and runs a block of code.
|
|
*/
|
|
Catch: [
|
|
o('CATCH Identifier Block', function() {
|
|
return [$2, $3];
|
|
}), o('CATCH Object Block', function() {
|
|
return [LOC(2)(new Value($2)), $3];
|
|
}), o('CATCH Block', function() {
|
|
return [null, $2];
|
|
})
|
|
],
|
|
|
|
/*
|
|
Throw an exception object.
|
|
*/
|
|
Throw: [
|
|
o('THROW Expression', function() {
|
|
return new Throw($2);
|
|
})
|
|
],
|
|
|
|
/*
|
|
Parenthetical expressions. Note that the **Parenthetical** is a **Value**,
|
|
not an **Expression**, so if you need to use an expression in a place
|
|
where only values are accepted, wrapping it in parentheses will always do
|
|
the trick.
|
|
*/
|
|
Parenthetical: [
|
|
o('( Body )', function() {
|
|
return new Parens($2);
|
|
}), o('( INDENT Body OUTDENT )', function() {
|
|
return new Parens($3);
|
|
})
|
|
],
|
|
|
|
/*
|
|
The condition portion of a while loop.
|
|
*/
|
|
WhileSource: [
|
|
o('WHILE Expression', function() {
|
|
return new While($2);
|
|
}), o('WHILE Expression WHEN Expression', function() {
|
|
return new While($2, {
|
|
guard: $4
|
|
});
|
|
}), o('UNTIL Expression', function() {
|
|
return new While($2, {
|
|
invert: true
|
|
});
|
|
}), o('UNTIL Expression WHEN Expression', function() {
|
|
return new While($2, {
|
|
invert: true,
|
|
guard: $4
|
|
});
|
|
})
|
|
],
|
|
|
|
/*
|
|
The while loop can either be normal, with a block of expressions to execute,
|
|
or postfix, with a single expression. There is no do..while.
|
|
*/
|
|
While: [
|
|
o('WhileSource Block', function() {
|
|
return $1.addBody($2);
|
|
}), o('Statement WhileSource', function() {
|
|
return $2.addBody(LOC(1)(Block.wrap([$1])));
|
|
}), o('Expression WhileSource', function() {
|
|
return $2.addBody(LOC(1)(Block.wrap([$1])));
|
|
}), o('Loop', function() {
|
|
return $1;
|
|
})
|
|
],
|
|
Loop: [
|
|
o('LOOP Block', function() {
|
|
return new While(LOC(1)(new Literal('true'))).addBody($2);
|
|
}), o('LOOP Expression', function() {
|
|
return new While(LOC(1)(new Literal('true'))).addBody(LOC(2)(Block.wrap([$2])));
|
|
})
|
|
],
|
|
|
|
/*
|
|
Array, object, and range comprehensions, at the most generic level.
|
|
Comprehensions can either be normal, with a block of expressions to execute,
|
|
or postfix, with a single expression.
|
|
*/
|
|
For: [
|
|
o('Statement ForBody', function() {
|
|
return new For($1, $2);
|
|
}), o('Expression ForBody', function() {
|
|
return new For($1, $2);
|
|
}), o('ForBody Block', function() {
|
|
return new For($2, $1);
|
|
})
|
|
],
|
|
ForBody: [
|
|
o('FOR Range', function() {
|
|
return {
|
|
source: LOC(2)(new Value($2))
|
|
};
|
|
}), o('ForStart ForSource', function() {
|
|
$2.own = $1.own;
|
|
$2.name = $1[0];
|
|
$2.index = $1[1];
|
|
return $2;
|
|
})
|
|
],
|
|
ForStart: [
|
|
o('FOR ForVariables', function() {
|
|
return $2;
|
|
}), o('FOR OWN ForVariables', function() {
|
|
$3.own = true;
|
|
return $3;
|
|
})
|
|
],
|
|
|
|
/*
|
|
An array of all accepted values for a variable inside the loop.
|
|
This enables support for pattern matching.
|
|
*/
|
|
ForValue: [
|
|
o('Identifier'), o('ThisProperty'), o('Array', function() {
|
|
return new Value($1);
|
|
}), o('Object', function() {
|
|
return new Value($1);
|
|
})
|
|
],
|
|
|
|
/*
|
|
An array or range comprehension has variables for the current element
|
|
and (optional) reference to the current index. Or, *key, value*, in the case
|
|
of object comprehensions.
|
|
*/
|
|
ForVariables: [
|
|
o('ForValue', function() {
|
|
return [$1];
|
|
}), o('ForValue , ForValue', function() {
|
|
return [$1, $3];
|
|
})
|
|
],
|
|
|
|
/*
|
|
The source of a comprehension is an array or object with an optional guard
|
|
clause. If it's an array comprehension, you can also choose to step through
|
|
in fixed-size increments.
|
|
*/
|
|
ForSource: [
|
|
o('FORIN Expression', function() {
|
|
return {
|
|
source: $2
|
|
};
|
|
}), o('FOROF Expression', function() {
|
|
return {
|
|
source: $2,
|
|
object: true
|
|
};
|
|
}), o('FORIN Expression WHEN Expression', function() {
|
|
return {
|
|
source: $2,
|
|
guard: $4
|
|
};
|
|
}), o('FOROF Expression WHEN Expression', function() {
|
|
return {
|
|
source: $2,
|
|
guard: $4,
|
|
object: true
|
|
};
|
|
}), o('FORIN Expression BY Expression', function() {
|
|
return {
|
|
source: $2,
|
|
step: $4
|
|
};
|
|
}), o('FORIN Expression WHEN Expression BY Expression', function() {
|
|
return {
|
|
source: $2,
|
|
guard: $4,
|
|
step: $6
|
|
};
|
|
}), o('FORIN Expression BY Expression WHEN Expression', function() {
|
|
return {
|
|
source: $2,
|
|
step: $4,
|
|
guard: $6
|
|
};
|
|
})
|
|
],
|
|
Switch: [
|
|
o('SWITCH Expression INDENT Whens OUTDENT', function() {
|
|
return new Switch($2, $4);
|
|
}), o('SWITCH Expression INDENT Whens ELSE Block OUTDENT', function() {
|
|
return new Switch($2, $4, $6);
|
|
}), o('SWITCH INDENT Whens OUTDENT', function() {
|
|
return new Switch(null, $3);
|
|
}), o('SWITCH INDENT Whens ELSE Block OUTDENT', function() {
|
|
return new Switch(null, $3, $5);
|
|
})
|
|
],
|
|
Whens: [
|
|
o('When'), o('Whens When', function() {
|
|
return $1.concat($2);
|
|
})
|
|
],
|
|
|
|
/*
|
|
An individual **When** clause, with action.
|
|
*/
|
|
When: [
|
|
o('LEADING_WHEN SimpleArgs Block', function() {
|
|
return [[$2, $3]];
|
|
}), o('LEADING_WHEN SimpleArgs Block TERMINATOR', function() {
|
|
return [[$2, $3]];
|
|
})
|
|
],
|
|
|
|
/*
|
|
The most basic form of *if* is a condition and an action. The following
|
|
if-related rules are broken up along these lines in order to avoid
|
|
ambiguity.
|
|
*/
|
|
IfBlock: [
|
|
o('IF Expression Block', function() {
|
|
return new If($2, $3, {
|
|
type: $1
|
|
});
|
|
}), o('IfBlock ELSE IF Expression Block', function() {
|
|
return $1.addElse(LOC(3, 5)(new If($4, $5, {
|
|
type: $3
|
|
})));
|
|
})
|
|
],
|
|
|
|
/*
|
|
The full complement of *if* expressions, including postfix one-liner
|
|
*if* and *unless*.
|
|
*/
|
|
If: [
|
|
o('IfBlock'), o('IfBlock ELSE Block', function() {
|
|
return $1.addElse($3);
|
|
}), o('Statement POST_IF Expression', function() {
|
|
return new If($3, LOC(1)(Block.wrap([$1])), {
|
|
type: $2,
|
|
statement: true
|
|
});
|
|
}), o('Expression POST_IF Expression', function() {
|
|
return new If($3, LOC(1)(Block.wrap([$1])), {
|
|
type: $2,
|
|
statement: true
|
|
});
|
|
})
|
|
],
|
|
|
|
/*
|
|
Arithmetic and logical operators, working on one or more operands.
|
|
Here they are grouped by order of precedence. The actual precedence rules
|
|
are defined at the bottom of the page. It would be shorter if we could
|
|
combine most of these rules into a single generic *Operand OpSymbol Operand*
|
|
-type rule, but in order to make the precedence binding possible, separate
|
|
rules are necessary.
|
|
*/
|
|
Operation: [
|
|
o('UNARY Expression', function() {
|
|
return new Op($1, $2);
|
|
}), o('- Expression', (function() {
|
|
return new Op('-', $2);
|
|
}), {
|
|
prec: 'UNARY'
|
|
}), o('+ Expression', (function() {
|
|
return new Op('+', $2);
|
|
}), {
|
|
prec: 'UNARY'
|
|
}), o('-- SimpleAssignable', function() {
|
|
return new Op('--', $2);
|
|
}), o('++ SimpleAssignable', function() {
|
|
return new Op('++', $2);
|
|
}), o('SimpleAssignable --', function() {
|
|
return new Op('--', $1, null, true);
|
|
}), o('SimpleAssignable ++', function() {
|
|
return new Op('++', $1, null, true);
|
|
}), o('Expression ?', function() {
|
|
return new Existence($1);
|
|
}), o('Expression + Expression', function() {
|
|
return new Op('+', $1, $3);
|
|
}), o('Expression - Expression', function() {
|
|
return new Op('-', $1, $3);
|
|
}), o('Expression MATH Expression', function() {
|
|
return new Op($2, $1, $3);
|
|
}), o('Expression SHIFT Expression', function() {
|
|
return new Op($2, $1, $3);
|
|
}), o('Expression COMPARE Expression', function() {
|
|
return new Op($2, $1, $3);
|
|
}), o('Expression LOGIC Expression', function() {
|
|
return new Op($2, $1, $3);
|
|
}), o('Expression RELATION Expression', function() {
|
|
if ($2.charAt(0) === '!') {
|
|
return new Op($2.slice(1), $1, $3).invert();
|
|
} else {
|
|
return new Op($2, $1, $3);
|
|
}
|
|
}), o('SimpleAssignable COMPOUND_ASSIGN Expression', function() {
|
|
return new Assign($1, $3, $2);
|
|
}), o('SimpleAssignable COMPOUND_ASSIGN INDENT Expression OUTDENT', function() {
|
|
return new Assign($1, $4, $2);
|
|
}), o('SimpleAssignable COMPOUND_ASSIGN TERMINATOR Expression', function() {
|
|
return new Assign($1, $4, $2);
|
|
}), o('SimpleAssignable EXTENDS Expression', function() {
|
|
return new Extends($1, $3);
|
|
})
|
|
]
|
|
}</code></pre>
|
|
<div class='docstring'>
|
|
<p>In all of the rules that follow, you'll see the name of the nonterminal as
|
|
the key to a list of alternative matches. With each match's action, the
|
|
dollar-sign variables are provided by Jison as references to the value of
|
|
their numeric position, so in this rule:</p><pre><code>"Expression UNLESS Expression"
|
|
</code></pre><p><code>$1</code> would be the value of the first <code>Expression</code>, <code>$2</code> would be the token
|
|
for the <code>UNLESS</code> terminal, and <code>$3</code> would be the value of the second
|
|
<code>Expression</code>.</p>
|
|
</div>
|
|
<div class='tags'>
|
|
</div>
|
|
</dd>
|
|
<dt id='operators-variable'>
|
|
operators
|
|
=
|
|
</dt>
|
|
<dd>
|
|
<pre><code class='coffeescript'>[['left', '.', '?.', '::', '?::'], ['left', 'CALL_START', 'CALL_END'], ['nonassoc', '++', '--'], ['left', '?'], ['right', 'UNARY'], ['left', 'MATH'], ['left', '+', '-'], ['left', 'SHIFT'], ['left', 'RELATION'], ['left', 'COMPARE'], ['left', 'LOGIC'], ['nonassoc', 'INDENT', 'OUTDENT'], ['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'], ['right', 'FORIN', 'FOROF', 'BY', 'WHEN'], ['right', 'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS'], ['left', 'POST_IF']]</code></pre>
|
|
<div class='docstring'>
|
|
<p>Operators at the top of this list have higher precedence than the ones lower
|
|
down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p><pre><code>2 + (3 * 4)
|
|
</code></pre><p>And not:</p><pre><code>(2 + 3) * 4
|
|
</code></pre>
|
|
</div>
|
|
<div class='tags'>
|
|
</div>
|
|
</dd>
|
|
<dt id='tokens-variable'>
|
|
tokens
|
|
=
|
|
</dt>
|
|
<dd>
|
|
<pre><code class='coffeescript'>[]</code></pre>
|
|
<div class='docstring'>
|
|
<p>Finally, now that we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
|
|
our <strong>Jison.Parser</strong>. We do this by processing all of our rules, recording all
|
|
terminals (every symbol which does not appear as the name of a rule above)
|
|
as "tokens".</p>
|
|
</div>
|
|
<div class='tags'>
|
|
</div>
|
|
</dd>
|
|
</dl>
|
|
<h2>Method Summary</h2>
|
|
<ul class='summary'>
|
|
<li>
|
|
<span class='signature'>
|
|
<a href='#o-'>
|
|
~
|
|
(void)
|
|
<b>o</b><span>(patternString, action, options)</span>
|
|
</a>
|
|
</span>
|
|
<span class='desc'>
|
|
Our handy DSL for Jison grammar generation, thanks to <a href="http://github.com/creationix">Tim Caswell</a>.
|
|
|
|
</span>
|
|
</li>
|
|
</ul>
|
|
<h2>Method Details</h2>
|
|
<div class='methods'>
|
|
<div class='method_details'>
|
|
<p class='signature' id='o-'>
|
|
~
|
|
(void)
|
|
<b>o</b><span>(patternString, action, options)</span>
|
|
<br>
|
|
</p>
|
|
<div class='docstring'>
|
|
<p>Our handy DSL for Jison grammar generation, thanks to
|
|
<a href="http://github.com/creationix">Tim Caswell</a>. For every rule in the grammar,
|
|
we pass the pattern-defining string, the action to run, and extra options,
|
|
optionally. If no action is specified, we simply pass the value of the
|
|
previous nonterminal.</p>
|
|
</div>
|
|
<div class='tags'>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div id='footer'>
|
|
August 12, 14 06:33:03 by
|
|
<a href='https://github.com/coffeedoc/codo' title='CoffeeScript API documentation generator'>
|
|
Codo
|
|
</a>
|
|
2.0.9
|
|
✲
|
|
Press H to see the keyboard shortcuts
|
|
✲
|
|
<a href='http://twitter.com/netzpirat' target='_parent'>@netzpirat</a>
|
|
✲
|
|
<a href='http://twitter.com/_inossidabile' target='_parent'>@_inossidabile</a>
|
|
</div>
|
|
<iframe id='search_frame'></iframe>
|
|
<div id='fuzzySearch'>
|
|
<input type='text'>
|
|
<ol></ol>
|
|
</div>
|
|
<div id='help'>
|
|
<p>
|
|
Quickly fuzzy find classes, mixins, methods, file:
|
|
</p>
|
|
<ul>
|
|
<li>
|
|
<span>T</span>
|
|
Open fuzzy finder dialog
|
|
</li>
|
|
</ul>
|
|
<p>
|
|
Control the navigation frame:
|
|
</p>
|
|
<ul>
|
|
<li>
|
|
<span>L</span>
|
|
Toggle list view
|
|
</li>
|
|
<li>
|
|
<span>C</span>
|
|
Show class list
|
|
</li>
|
|
<li>
|
|
<span>I</span>
|
|
Show mixin list
|
|
</li>
|
|
<li>
|
|
<span>F</span>
|
|
Show file list
|
|
</li>
|
|
<li>
|
|
<span>M</span>
|
|
Show method list
|
|
</li>
|
|
<li>
|
|
<span>E</span>
|
|
Show extras list
|
|
</li>
|
|
</ul>
|
|
<p>
|
|
You can focus and blur the search input:
|
|
</p>
|
|
<ul>
|
|
<li>
|
|
<span>S</span>
|
|
Focus search input
|
|
</li>
|
|
<li>
|
|
<span>Esc</span>
|
|
Blur search input
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
</body>
|
|
</html> |