Use forced lookahead to move "No" hacks to parser.

[cycript.git] / Cycript.yy.in

diff --git a/Cycript.yy.in b/Cycript.yy.in
index 3f240e40651a809119b939539255d9c3afb573ed..ce895ae1e961ea6980be5f7297efab3071ca6e46 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -1,35 +1,34 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* Cycript - Optimizing JavaScript Compiler/Runtime

- * Copyright (C) 2009-2012  Jay Freeman (saurik)
+ * Copyright (C) 2009-2015  Jay Freeman (saurik)

 */
 
 */
 

-/* GNU Lesser General Public License, Version 3 {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */

 /*
 /*

- * Cycript is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * Cycript is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 **/
 /* }}} */
 
 **/
 /* }}} */
 

-@if Bison23 %{
-
-@if Bison24 %code top {
+%code top {

 #define cyscanner driver.scanner_
 #define YYSTACKEXPANDABLE 1
 #define cyscanner driver.scanner_
 #define YYSTACKEXPANDABLE 1

-@if Bison23 #define yyerrok (yyerrstatus_ = 0)
-@if Bison24 }
+}

 
 

-@if Bison24 %code requires {
+%code requires {
+#include "Driver.hpp"

 #include "Parser.hpp"
 #include "Parser.hpp"

-#define CYNew new($pool)
+#include "Stack.hpp"
+#define CYNew new(driver.pool_)

 
 @begin ObjectiveC
 #include "ObjectiveC/Syntax.hpp"
 
 @begin ObjectiveC
 #include "ObjectiveC/Syntax.hpp"


@@ -40,79 +39,98 @@
 @end
 
 #include "Highlight.hpp"
 @end
 
 #include "Highlight.hpp"

+}
+
+%union { bool bool_; }
+
+%union { CYArgument *argument_; }
+%union { CYAssignment *assignment_; }
+%union { CYBoolean *boolean_; }
+%union { CYClause *clause_; }
+%union { cy::Syntax::Catch *catch_; }
+%union { CYComprehension *comprehension_; }
+%union { CYDeclaration *declaration_; }
+%union { CYDeclarations *declarations_; }
+%union { CYElement *element_; }
+%union { CYExpression *expression_; }
+%union { CYFalse *false_; }
+%union { CYFinally *finally_; }
+%union { CYForInitializer *for_; }
+%union { CYForInInitializer *forin_; }
+%union { CYFunctionParameter *functionParameter_; }
+%union { CYIdentifier *identifier_; }
+%union { CYInfix *infix_; }
+%union { CYLiteral *literal_; }
+%union { CYMember *member_; }
+%union { CYModule *module_; }
+%union { CYNull *null_; }
+%union { CYNumber *number_; }
+%union { CYParenthetical *parenthetical_; }
+%union { CYProperty *property_; }
+%union { CYPropertyName *propertyName_; }
+%union { CYRubyProc *rubyProc_; }
+%union { CYSpan *span_; }
+%union { CYStatement *statement_; }
+%union { CYString *string_; }
+%union { CYThis *this_; }
+%union { CYTrue *true_; }
+%union { CYWord *word_; }

 
 

-typedef struct {
-    bool newline_;
-    hi::Value highlight_;
-
-    union {
-        bool bool_;
-
-        CYDriver::Condition condition_;
-
-        CYArgument *argument_;
-        CYAssignment *assignment_;
-        CYBoolean *boolean_;
-        CYClause *clause_;
-        cy::Syntax::Catch *catch_;
-        CYComment *comment_;
-        CYComprehension *comprehension_;
-        CYCompound *compound_;
-        CYDeclaration *declaration_;
-        CYDeclarations *declarations_;
-        CYElement *element_;
-        CYExpression *expression_;
-        CYFalse *false_;
-        CYFinally *finally_;
-        CYForInitialiser *for_;
-        CYForInInitialiser *forin_;
-        CYFunctionParameter *functionParameter_;
-        CYIdentifier *identifier_;
-        CYInfix *infix_;
-        CYLiteral *literal_;
-        CYMember *member_;
-        CYNull *null_;
-        CYNumber *number_;
-        CYProgram *program_;
-        CYProperty *property_;
-        CYPropertyName *propertyName_;
-        CYRubyProc *rubyProc_;
-        CYStatement *statement_;
-        CYString *string_;
-        CYThis *this_;
-        CYTrue *true_;
-        CYWord *word_;
+@begin C
+%union { CYTypeModifier *modifier_; }
+%union { CYTypeSpecifier *specifier_; }
+%union { CYTypedIdentifier *typedIdentifier_; }
+%union { CYTypedParameter *typedParameter_; }
+@end

 
 @begin ObjectiveC
 
 @begin ObjectiveC

-        CYClassName *className_;
-        CYField *field_;
-        CYMessage *message_;
-        CYMessageParameter *messageParameter_;
-        CYProtocol *protocol_;
-        CYSelectorPart *selector_;
+%union { CYClassName *className_; }
+%union { CYClassField *classField_; }
+%union { CYMessage *message_; }
+%union { CYMessageParameter *messageParameter_; }
+%union { CYProtocol *protocol_; }
+%union { CYSelectorPart *selector_; }

 @end
 
 @begin E4X
 @end
 
 @begin E4X

-        CYAttribute *attribute_;
-        CYPropertyIdentifier *propertyIdentifier_;
-        CYSelector *selector_;
+%union { CYAttribute *attribute_; }
+%union { CYPropertyIdentifier *propertyIdentifier_; }
+%union { CYSelector *selector_; }

 @end
 @end

-    };
-} YYSTYPE;

 
 

-#define YYSTYPE YYSTYPE
-@if Bison24 }
+%code provides {
+
+struct YYSTYPE {
+    cy::parser::semantic_type semantic_;
+    hi::Value highlight_;
+};
+
+int cylex(YYSTYPE *, CYLocation *, void *);

 
 

-@if Bison24 %code provides {
-int cylex(YYSTYPE *, cy::location *, void *);
-@if Bison24 }
+}

 
 

-@if Bison23 %}
+%code {

 
 

-%name-prefix="cy"
+#undef yylex
+_finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, void *scanner) {
+    YYSTYPE data;
+    int token(cylex(&data, location, scanner));
+    *semantic = data.semantic_;
+    return token;
+}

 
 

-@if Bison23 %skeleton "lalr1.cc"
-@if Bison24 %language "C++"
+#define CYMAP(to, from) do { \
+    if (yyla.empty()) \
+        yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, cyscanner)); \
+    if (yyla.type == yytranslate_(token::from)) \
+        yyla.type = yytranslate_(token::to); \
+} while (false)
+
+}
+
+%name-prefix "cy"
+
+%language "C++"

 
 %initial-action {
     @$.begin.filename = @$.end.filename = &driver.filename_;
 
 %initial-action {
     @$.begin.filename = @$.end.filename = &driver.filename_;


@@ -121,6 +139,8 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %locations
 %defines
 
 %locations
 %defines
 

+%define api.location.type { CYLocation }
+

 //%glr-parser
 //%expect 1
 
 //%glr-parser
 //%expect 1
 


@@ -155,6 +175,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 
 @begin E4X ObjectiveC
 %token At "@"
 
 @begin E4X ObjectiveC
 %token At "@"

+%token Pound "#"

 @end
 
 %token Ampersand "&"
 @end
 
 %token Ampersand "&"


@@ -166,6 +187,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %token EqualEqual "=="
 %token EqualEqualEqual "==="
 %token EqualRight "=>"
 %token EqualEqual "=="
 %token EqualEqualEqual "==="
 %token EqualRight "=>"

+%token EqualRight_ "\n=>"

 %token Exclamation "!"
 %token ExclamationEqual "!="
 %token ExclamationEqualEqual "!=="
 %token Exclamation "!"
 %token ExclamationEqual "!="
 %token ExclamationEqualEqual "!=="


@@ -207,7 +229,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %token SemiColon ";"
 %token NewLine "\n"
 
 %token SemiColon ";"
 %token NewLine "\n"
 

-%token <comment_> Comment
+%token Comment

 
 %token OpenParen "("
 %token CloseParen ")"
 
 %token OpenParen "("
 %token CloseParen ")"


@@ -220,105 +242,123 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %token OpenBracket "["
 %token CloseBracket "]"
 
 %token OpenBracket "["
 %token CloseBracket "]"
 

+%token At_error_ "@error"
+

 @begin Java
 @begin Java

-%token AtClass "@class"
+%token At_class_ "@class"
+@end
+
+@begin C
+%token _typedef_ "typedef"
+%token _unsigned_ "unsigned"
+%token _signed_ "signed"
+%token _extern_ "extern"
+@end
+
+@begin C
+%token At_encode_ "@encode"

 @end
 
 @begin ObjectiveC
 @end
 
 @begin ObjectiveC

-%token AtImplementation "@implementation"
-%token AtImplementation_ ";@implementation"
-%token AtImport "@import"
-%token AtEnd "@end"
-%token AtSelector "@selector"
+%token At_implementation_ "@implementation"
+%token At_import_ "@import"
+%token At_end_ "@end"
+%token At_selector_ "@selector"
+%token At_null_ "@null"
+%token At_YES_ "@YES"
+%token At_NO_ "@NO"
+%token At_true_ "@true"
+%token At_false_ "@false"
+%token _YES_ "YES"
+%token _NO_ "NO"

 @end
 
 @end
 

-%token <false_> False "false"
-%token <null_> Null "null"
-%token <true_> True "true"
-
-// ES3/ES5/WIE/JSC Reserved
-%token <word_> Auto "auto"
-%token <word_> Break "break"
-%token <word_> Case "case"
-%token <word_> Catch "catch"
-%token <word_> Continue "continue"
-%token <word_> Default "default"
-%token <word_> Delete "delete"
-%token <word_> Do "do"
-%token <word_> Else "else"
-%token <word_> Finally "finally"
-%token <word_> For "for"
-%token <word_> Function "function"
-%token <word_> Function_ ";function"
-%token <word_> If "if"
-%token <word_> In "in"
-%token <word_> In_ "!in"
-%token <word_> InstanceOf "instanceof"
-%token <word_> New "new"
-%token <word_> Return "return"
-%token <word_> Switch "switch"
-%token <this_> This "this"
-%token <word_> Throw "throw"
-%token <word_> Try "try"
-%token <word_> TypeOf "typeof"
-%token <word_> Var "var"
-%token <word_> Void "void"
-%token <word_> While "while"
-%token <word_> With "with"
-
-// ES3/IE6 Future, ES5/JSC Reserved
-%token <word_> Debugger "debugger"
-
-// ES3/ES5/IE6 Future, JSC Reserved
-%token <word_> Const "const"
-
-// ES3/ES5/IE6/JSC Future
-%token <word_> Class "class"
-%token <word_> Enum "enum"
-%token <word_> Export "export"
-%token <word_> Extends "extends"
-%token <word_> Import "import"
-%token <word_> Super "super"
-
-// ES3 Future, ES5 Strict Future
-%token <identifier_> Implements "implements"
-%token <identifier_> Interface "interface"
-%token <identifier_> Package "package"
-%token <identifier_> Private "private"
-%token <identifier_> Protected "protected"
-%token <identifier_> Public "public"
-%token <identifier_> Static "static"
-
-// ES3 Future
-%token <identifier_> Abstract "abstract"
-%token <identifier_> Boolean "boolean"
-%token <identifier_> Byte "byte"
-%token <identifier_> Char "char"
-%token <identifier_> Double "double"
-%token <identifier_> Final "final"
-%token <identifier_> Float "float"
-%token <identifier_> Goto "goto"
-%token <identifier_> Int "int"
-%token <identifier_> Long "long"
-%token <identifier_> Native "native"
-%token <identifier_> Short "short"
-%token <identifier_> Synchronized "synchronized"
-%token <identifier_> Throws "throws"
-%token <identifier_> Transient "transient"
-%token <identifier_> Volatile "volatile"
-
-// ES5 Strict
-%token <identifier_> Let "let"
-%token <identifier_> Yield "yield"
-
-// Woah?!
-%token <identifier_> Each "each"
-%token <identifier_> Of "of"
+%token _false_ "false"
+%token _null_ "null"
+%token _true_ "true"
+
+%token _break_ "break"
+%token _case_ "case"
+%token _catch_ "catch"
+%token _class_ "class"
+%token _class__ "!class"
+%token _const_ "const"
+%token _continue_ "continue"
+%token _debugger_ "debugger"
+%token _default_ "default"
+%token _delete_ "delete"
+%token _do_ "do"
+%token _else_ "else"
+%token _enum_ "enum"
+%token _export_ "export"
+%token _extends_ "extends"
+%token _finally_ "finally"
+%token _for_ "for"
+%token _function_ "function"
+%token _function__ ";function"
+%token _if_ "if"
+%token _import_ "import"
+%token _in_ "in"
+%token _in__ "!in"
+%token _instanceof_ "instanceof"
+%token _new_ "new"
+%token _return_ "return"
+%token _super_ "super"
+%token _switch_ "switch"
+%token _this_ "this"
+%token _throw_ "throw"
+%token _try_ "try"
+%token _typeof_ "typeof"
+%token _var_ "var"
+%token _void_ "void"
+%token _while_ "while"
+%token _with_ "with"
+
+%token _abstract_ "abstract"
+%token _await_ "await"
+%token _boolean_ "boolean"
+%token _byte_ "byte"
+%token _char_ "char"
+%token _double_ "double"
+%token _final_ "final"
+%token _float_ "float"
+%token _goto_ "goto"
+%token _implements_ "implements"
+%token _int_ "int"
+%token _interface_ "interface"
+%token _let_ "let"
+%token _long_ "long"
+%token _native_ "native"
+%token _package_ "package"
+%token _private_ "private"
+%token _protected_ "protected"
+%token _public_ "public"
+%token _short_ "short"
+%token _static_ "static"
+%token _synchronized_ "synchronized"
+%token _throws_ "throws"
+%token _transient_ "transient"
+%token _volatile_ "volatile"
+%token _yield_ "yield"
+
+%token _undefined_ "undefined"
+
+@begin ObjectiveC
+%token _bool_ "bool"
+%token _BOOL_ "BOOL"
+%token _id_ "id"
+%token _nil_ "nil"
+%token _NULL_ "NULL"
+%token _SEL_ "SEL"
+@end
+
+%token _auto_ "auto"
+%token _each_ "each"
+%token _of_ "of"

 
 @begin E4X
 
 @begin E4X

-// E4X Conditional
-%token <identifier_> Namespace "namespace"
-%token <identifier_> XML "xml"
+%token _namespace_ "namespace"
+%token _xml_ "xml"

 @end
 
 %token AutoComplete
 @end
 
 %token AutoComplete


@@ -328,20 +368,27 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %token <string_> StringLiteral
 %token <literal_> RegularExpressionLiteral
 
 %token <string_> StringLiteral
 %token <literal_> RegularExpressionLiteral
 

+%token <string_> NoSubstitutionTemplate
+%token <string_> TemplateHead
+%token <string_> TemplateMiddle
+%token <string_> TemplateTail
+

 %type <expression_> AdditiveExpression
 %type <argument_> ArgumentList_
 %type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <expression_> AdditiveExpression
 %type <argument_> ArgumentList_
 %type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments

+%type <expression_> ArrayComprehension

 %type <literal_> ArrayLiteral
 %type <expression_> ArrowFunction
 %type <functionParameter_> ArrowParameters
 %type <expression_> AssignmentExpression
 %type <literal_> ArrayLiteral
 %type <expression_> ArrowFunction
 %type <functionParameter_> ArrowParameters
 %type <expression_> AssignmentExpression

+%type <expression_> AssignmentExpressionOpt

 %type <identifier_> Binding
 %type <identifier_> BindingIdentifier
 %type <expression_> BitwiseANDExpression
 %type <identifier_> Binding
 %type <identifier_> BindingIdentifier
 %type <expression_> BitwiseANDExpression

-%type <statement_> Block_

 %type <statement_> Block
 %type <statement_> Block

+%type <statement_> BlockStatement

 %type <boolean_> BooleanLiteral
 %type <declaration_> BindingElement
 %type <expression_> BitwiseORExpression
 %type <boolean_> BooleanLiteral
 %type <declaration_> BindingElement
 %type <expression_> BitwiseORExpression


@@ -353,34 +400,32 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <clause_> CaseBlock
 %type <clause_> CaseClause
 %type <clause_> CaseClausesOpt
 %type <clause_> CaseBlock
 %type <clause_> CaseClause
 %type <clause_> CaseClausesOpt

-%type <catch_> CatchOpt
-%type <comprehension_> ComprehensionForList
-%type <comprehension_> ComprehensionForListOpt
-%type <comprehension_> ComprehensionList
-%type <comprehension_> ComprehensionListOpt
+%type <catch_> Catch
+%type <identifier_> CatchParameter
+%type <expression_> Comprehension
+%type <comprehension_> ComprehensionFor
+%type <comprehension_> ComprehensionIf
+%type <comprehension_> ComprehensionTail

 %type <expression_> ConditionalExpression
 %type <statement_> ContinueStatement
 %type <statement_> ConciseBody
 %type <expression_> ConditionalExpression
 %type <statement_> ContinueStatement
 %type <statement_> ConciseBody

+%type <parenthetical_> CoverParenthesizedExpressionAndArrowParameterList

 %type <statement_> DebuggerStatement
 %type <statement_> Declaration__
 %type <statement_> Declaration_
 %type <statement_> Declaration
 %type <clause_> DefaultClause
 %type <statement_> DebuggerStatement
 %type <statement_> Declaration__
 %type <statement_> Declaration_
 %type <statement_> Declaration
 %type <clause_> DefaultClause

-%type <expression_> Element
-%type <expression_> ElementOpt

 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt
 %type <statement_> EmptyStatement
 %type <expression_> EqualityExpression
 %type <element_> ElementList
 %type <element_> ElementListOpt
 %type <statement_> ElseStatementOpt
 %type <statement_> EmptyStatement
 %type <expression_> EqualityExpression

-%type <compound_> Expression_
-%type <compound_> Expression
+%type <expression_> Expression

 %type <expression_> ExpressionOpt
 %type <statement_> ExpressionStatement
 %type <expression_> ExpressionOpt
 %type <statement_> ExpressionStatement

-%type <finally_> FinallyOpt
-%type <comprehension_> ForComprehension
-%type <for_> ForStatementInitialiser
-%type <forin_> ForInStatementInitialiser
+%type <finally_> Finally
+%type <for_> ForStatementInitializer
+%type <forin_> ForInStatementInitializer

 %type <declaration_> FormalParameter
 %type <functionParameter_> FormalParameterList_
 %type <functionParameter_> FormalParameterList
 %type <declaration_> FormalParameter
 %type <functionParameter_> FormalParameterList_
 %type <functionParameter_> FormalParameterList


@@ -388,36 +433,35 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <expression_> FunctionExpression
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <expression_> FunctionExpression

+%type <statement_> HoistableDeclaration

 %type <identifier_> Identifier
 %type <identifier_> IdentifierOpt
 %type <identifier_> Identifier
 %type <identifier_> IdentifierOpt

+%type <identifier_> IdentifierType

 %type <word_> IdentifierName
 %type <word_> IdentifierName

-%type <comprehension_> IfComprehension
+%type <expression_> IdentifierReference

 %type <statement_> IfStatement
 %type <statement_> IfStatement

-%type <expression_> Initialiser
-%type <expression_> InitialiserOpt
+%type <expression_> Initializer
+%type <expression_> InitializerOpt

 %type <statement_> IterationStatement
 %type <statement_> IterationStatement

+%type <identifier_> LabelIdentifier
+%type <statement_> LabelledItem

 %type <statement_> LabelledStatement
 %type <expression_> LeftHandSideExpression
 %type <statement_> LetStatement
 %type <statement_> LexicalDeclaration
 %type <literal_> Literal
 %type <statement_> LabelledStatement
 %type <expression_> LeftHandSideExpression
 %type <statement_> LetStatement
 %type <statement_> LexicalDeclaration
 %type <literal_> Literal

-%type <literal_> ValueLiteral

 %type <expression_> LogicalANDExpression
 %type <expression_> LogicalORExpression
 %type <member_> MemberAccess
 %type <expression_> MemberExpression_
 %type <expression_> MemberExpression
 %type <expression_> LogicalANDExpression
 %type <expression_> LogicalORExpression
 %type <member_> MemberAccess
 %type <expression_> MemberExpression_
 %type <expression_> MemberExpression

+%type <module_> Module

 %type <expression_> MultiplicativeExpression
 %type <expression_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %type <expression_> MultiplicativeExpression
 %type <expression_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral

-%type <compound_> Parenthetical
-%type <compound_> ParentheticalOpt

 %type <expression_> PostfixExpression
 %type <expression_> PrimaryExpression
 %type <expression_> PostfixExpression
 %type <expression_> PrimaryExpression

-%type <statement_> Program
-%type <statement_> ProgramBody
-%type <statement_> ProgramBodyOpt

 %type <propertyName_> PropertyName_
 %type <propertyName_> PropertyName
 %type <property_> PropertyDefinition
 %type <propertyName_> PropertyName_
 %type <propertyName_> PropertyName
 %type <property_> PropertyDefinition


@@ -431,6 +475,9 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameters
 %type <functionParameter_> RubyProcParametersOpt
 %type <functionParameter_> RubyProcParameterList
 %type <functionParameter_> RubyProcParameters
 %type <functionParameter_> RubyProcParametersOpt

+%type <statement_> Script
+%type <statement_> ScriptBody
+%type <statement_> ScriptBodyOpt

 %type <expression_> ShiftExpression
 %type <declaration_> SingleNameBinding
 %type <statement_> Statement__
 %type <expression_> ShiftExpression
 %type <declaration_> SingleNameBinding
 %type <statement_> Statement__


@@ -440,6 +487,8 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <statement_> StatementListOpt
 %type <statement_> StatementListItem
 %type <statement_> SwitchStatement
 %type <statement_> StatementListOpt
 %type <statement_> StatementListItem
 %type <statement_> SwitchStatement

+%type <expression_> TemplateLiteral
+%type <span_> TemplateSpans

 %type <statement_> ThrowStatement
 %type <statement_> TryStatement
 %type <expression_> UnaryExpression_
 %type <statement_> ThrowStatement
 %type <statement_> TryStatement
 %type <expression_> UnaryExpression_


@@ -450,20 +499,35 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word
 %type <statement_> VariableStatement
 %type <statement_> WithStatement
 %type <word_> Word

+@begin ObjectiveC

 %type <word_> WordOpt
 %type <word_> WordOpt

+@end
+
+@begin C
+%type <specifier_> IntegerType
+%type <specifier_> IntegerTypeOpt
+%type <typedIdentifier_> PrefixedType
+%type <specifier_> PrimitiveType
+%type <typedIdentifier_> SuffixedType
+%type <typedIdentifier_> TypeSignifier
+%type <modifier_> TypeQualifierLeft
+%type <typedIdentifier_> TypeQualifierRight
+%type <typedIdentifier_> TypedIdentifier
+%type <typedParameter_> TypedParameterList_
+%type <typedParameter_> TypedParameterList
+%type <typedParameter_> TypedParameterListOpt
+@end

 
 @begin ObjectiveC
 %type <expression_> BoxableExpression
 %type <statement_> CategoryStatement
 
 @begin ObjectiveC
 %type <expression_> BoxableExpression
 %type <statement_> CategoryStatement

-%type <expression_> ClassExpression
-%type <field_> ClassFieldListOpt
-%type <field_> ClassFields
+%type <classField_> ClassFieldListOpt
+%type <classField_> ClassFields

 %type <statement_> ClassStatement
 %type <expression_> ClassSuperOpt
 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt
 %type <className_> ClassName
 %type <statement_> ClassStatement
 %type <expression_> ClassSuperOpt
 %type <message_> ClassMessageDeclaration
 %type <message_> ClassMessageDeclarationListOpt
 %type <className_> ClassName

-%type <className_> ClassNameOpt

 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt
 %type <protocol_> ClassProtocolListOpt
 %type <protocol_> ClassProtocols
 %type <protocol_> ClassProtocolsOpt


@@ -480,7 +544,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <selector_> SelectorExpressionOpt
 %type <argument_> SelectorList
 %type <word_> SelectorWordOpt
 %type <selector_> SelectorExpressionOpt
 %type <argument_> SelectorList
 %type <word_> SelectorWordOpt

-%type <expression_> TypeOpt
+%type <typedIdentifier_> TypeOpt

 %type <argument_> VariadicCall
 @end
 
 %type <argument_> VariadicCall
 @end
 


@@ -513,7 +577,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %nonassoc "else"
 /* }}} */
 
 %nonassoc "else"
 /* }}} */
 

-%start Program
+%start Script

 
 %%
 
 
 %%
 


@@ -534,20 +598,24 @@ LexSetRegExp
     : { driver.SetCondition(CYDriver::RegExpCondition); }
     ;
 
     : { driver.SetCondition(CYDriver::RegExpCondition); }
     ;
 

+LexNewLine
+    : { if (!yyla.empty() && yyla.type_get() != yyeof_) error(@$, "unexpected lookahead"); driver.next_ = true; }
+    ;
+

 LexNoBrace
 LexNoBrace

-    : { if (yychar == yyempty_) driver.no_.OpenBrace = true; else if (yychar == token::OpenBrace || yychar == token::OpenBrace_) yychar = token::OpenBrace__; }
+    : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); }

     ;
 
     ;
 

-LexNoFunction
-    : { if (yychar == yyempty_) driver.no_.Function = true; else if (yychar == token::Function) yychar = token::Function_; }
+LexNoClass
+    : { CYMAP(_class__, _class_); }

     ;
 
     ;
 

-LexNoAtImplementation
-    : { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; }
+LexNoFunction
+    : { CYMAP(_function__, _function_); }

     ;
 
 LexSetStatement
     ;
 
 LexSetStatement

-    : LexNoBrace LexNoFunction LexNoAtImplementation
+    : LexNoBrace LexNoClass LexNoFunction

     ;
 /* }}} */
 /* Virtual Tokens {{{ */
     ;
 /* }}} */
 /* Virtual Tokens {{{ */


@@ -561,143 +629,89 @@ Var_
     ;
 /* }}} */
 
     ;
 /* }}} */
 

-/* 7.6 Identifier Names and Identifiers {{{ */
+/* 11.6 Names and Keywords {{{ */

 IdentifierName
     : Word { $$ = $1; }
 IdentifierName
     : Word { $$ = $1; }

-    ;
-
-NewLineOpt
-    : "\n"
-    |
+    | "for" { $$ = CYNew CYWord("for"); }
+    | "in" { $$ = CYNew CYWord("in"); }
+    | "instanceof" { $$ = CYNew CYWord("instanceof"); }

     ;
 
 Word
     : Identifier { $$ = $1; }
     ;
 
 Word
     : Identifier { $$ = $1; }

-    | "auto" { $$ = $1; }
-    | "break" NewLineOpt { $$ = $1; }
-    | "case" { $$ = $1; }
-    | "catch" { $$ = $1; }
-    | "class" { $$ = $1; }
-    | "const" { $$ = $1; }
-    | "continue" NewLineOpt { $$ = $1; }
-    | "debugger" { $$ = $1; }
-    | "default" { $$ = $1; }
-    | "delete" { $$ = $1; }
-    | "do" { $$ = $1; }
-    | "else" { $$ = $1; }
-    | "enum" { $$ = $1; }
-    | "export" { $$ = $1; }
-    | "extends" { $$ = $1; }
-    | "false" { $$ = $1; }
-    | "finally" { $$ = $1; }
-    /* XXX: | "for" { $$ = $1; } */
-    | "function" { $$ = $1; }
-    | "if" { $$ = $1; }
-    | "import" { $$ = $1; }
-    /* XXX: | "in" { $$ = $1; } */
-    | "!in" { $$ = $1; }
-    /* XXX: | "instanceof" { $$ = $1; } */
-
-    // XXX: as it currently is not an Identifier
-    | "let" { $$ = $1; }
-
-    | "new" { $$ = $1; }
-    | "null" { $$ = $1; }
-    | "return" NewLineOpt { $$ = $1; }
-    | "super" { $$ = $1; }
-    | "switch" { $$ = $1; }
-    | "this" { $$ = $1; }
-    | "throw" NewLineOpt { $$ = $1; }
-    | "true" { $$ = $1; }
-    | "try" { $$ = $1; }
-    | "typeof" { $$ = $1; }
-    | "var" { $$ = $1; }
-    | "void" { $$ = $1; }
-    | "while" { $$ = $1; }
-    | "with" { $$ = $1; }
+    | "auto" { $$ = CYNew CYWord("auto"); }
+    | "break" { $$ = CYNew CYWord("break"); }
+    | "case" { $$ = CYNew CYWord("case"); }
+    | "catch" { $$ = CYNew CYWord("catch"); }
+    | "class" { $$ = CYNew CYWord("class"); }
+    | "!class" { $$ = CYNew CYWord("class"); }
+    | "const" { $$ = CYNew CYWord("const"); }
+    | "continue" { $$ = CYNew CYWord("continue"); }
+    | "debugger" { $$ = CYNew CYWord("debugger"); }
+    | "default" { $$ = CYNew CYWord("default"); }
+    | "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); }
+    | "do" { $$ = CYNew CYWord("do"); }
+    | "else" { $$ = CYNew CYWord("else"); }
+    | "enum" { $$ = CYNew CYWord("enum"); }
+    | "export" { $$ = CYNew CYWord("export"); }
+    | "extends" { $$ = CYNew CYWord("extends"); }
+    | "false" { $$ = CYNew CYWord("false"); }
+    | "finally" { $$ = CYNew CYWord("finally"); }
+    | "function" { $$ = CYNew CYWord("function"); }
+    | "if" { $$ = CYNew CYWord("if"); }
+    | "import" { $$ = CYNew CYWord("import"); }
+    | "!in" { $$ = CYNew CYWord("in"); }
+    | "new" LexSetRegExp { $$ = CYNew CYWord("new"); }
+    | "null" { $$ = CYNew CYWord("null"); }
+    | "return" { $$ = CYNew CYWord("return"); }
+    | "super" { $$ = CYNew CYWord("super"); }
+    | "switch" { $$ = CYNew CYWord("switch"); }
+    | "this" { $$ = CYNew CYWord("this"); }
+    | "throw" { $$ = CYNew CYWord("throw"); }
+    | "true" { $$ = CYNew CYWord("true"); }
+    | "try" { $$ = CYNew CYWord("try"); }
+    | "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); }
+    | "var" { $$ = CYNew CYWord("var"); }
+    | "void" LexSetRegExp { $$ = CYNew CYWord("void"); }
+    | "while" { $$ = CYNew CYWord("while"); }
+    | "with" { $$ = CYNew CYWord("with"); }
+
+    // XXX: should be Identifier
+    | "let" { $$ = CYNew CYIdentifier("let"); }

     ;
 
     ;
 

+@begin ObjectiveC

 WordOpt
     : Word { $$ = $1; }
     | { $$ = NULL; }
     ;
 WordOpt
     : Word { $$ = $1; }
     | { $$ = NULL; }
     ;

-
-Identifier
-    : Identifier_ { $$ = $1; }
-
-    | "implements" { $$ = $1; }
-    | "interface" { $$ = $1; }
-    | "package" { $$ = $1; }
-    | "private" { $$ = $1; }
-    | "protected" { $$ = $1; }
-    | "public" { $$ = $1; }
-    | "static" { $$ = $1; }
-
-    | "abstract" { $$ = $1; }
-    | "boolean" { $$ = $1; }
-    | "byte" { $$ = $1; }
-    | "char" { $$ = $1; }
-    | "double" { $$ = $1; }
-    | "final" { $$ = $1; }
-    | "float" { $$ = $1; }
-    | "goto" { $$ = $1; }
-    | "int" { $$ = $1; }
-    | "long" { $$ = $1; }
-    | "native" { $$ = $1; }
-    | "short" { $$ = $1; }
-    | "synchronized" { $$ = $1; }
-    | "throws" { $$ = $1; }
-    | "transient" { $$ = $1; }
-    | "volatile" { $$ = $1; }
-
-    // XXX: currently I only have this as Word
-    // | "let" { $$ = $1; }
-
-    | "yield" { $$ = $1; }
-
-    | "each" { $$ = $1; }
-    | "of" { $$ = $1; }
-    ;
-
-IdentifierOpt
-    : Identifier { $$ = $1; }
-    | { $$ = NULL; }
-    ;
-/* }}} */
-
-/* 7.8 Literals {{{ */
-Literal
-    : NullLiteral { $$ = $1; }
-    | ValueLiteral { $$ = $1; }
-    ;
-
-ValueLiteral
-    : BooleanLiteral { $$ = $1; }
-    | NumericLiteral { $$ = $1; }
-    | StringLiteral { $$ = $1; }
-    | RegularExpressionLiteral { $$ = $1; }
-    ;
+@end

 /* }}} */
 /* }}} */

-/* 7.8.1 Null Literals {{{ */
+/* 11.8.1 Null Literals {{{ */

 NullLiteral
 NullLiteral

-    : "null" { $$ = $1; }
+    : "null" { $$ = CYNew CYNull(); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 7.8.2 Boolean Literals {{{ */
+/* 11.8.2 Boolean Literals {{{ */

 BooleanLiteral
 BooleanLiteral

-    : "true" { $$ = $1; }
-    | "false" { $$ = $1; }
+    : "true" { $$ = CYNew CYTrue(); }
+    | "false" { $$ = CYNew CYFalse(); }

     ;
 /* }}} */
 
     ;
 /* }}} */
 

-/* 7.9 Automatic Semicolon Insertion {{{ */
+/* 11.9 Automatic Semicolon Insertion {{{ */

 StrictSemi
 StrictSemi

-    : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); }
+    : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
+    ;
+
+TerminatorSoft
+    : ";"
+    | "\n" StrictSemi

     ;
 
 Terminator
     : ";"
     ;
 
 Terminator
     : ";"

-    | error { if (yychar != yyeof_ && yychar != token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
+    | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) { error(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi

     ;
 
 TerminatorOpt
     ;
 
 TerminatorOpt


@@ -706,44 +720,116 @@ TerminatorOpt
     ;
 /* }}} */
 
     ;
 /* }}} */
 

-/* 11.1 Primary Expressions {{{ */
-Parenthetical
-    : "(" LexPushInOff Expression LexPopIn ")" { $$ = $3; }
+/* 12.1 Identifiers {{{ */
+IdentifierReference
+    : Identifier { $$ = CYNew CYVariable($1); }
+    // XXX: | "yield"

     ;
 
     ;
 

-ParentheticalOpt
-    : Parenthetical { $$ = $1; }
-    | { $$ = NULL; }
+BindingIdentifier
+    : Identifier { $$ = $1; }
+    // XXX: | "yield"
+    ;
+
+LabelIdentifier
+    : Identifier { $$ = $1; }
+    // XXX: | yield
+    ;
+
+IdentifierType
+    : Identifier_ { $$ = $1; }
+    | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
+    | "await" { $$ = CYNew CYIdentifier("await"); }
+    | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
+    | "byte" { $$ = CYNew CYIdentifier("byte"); }
+    | "double" { $$ = CYNew CYIdentifier("double"); }
+    | "each" { $$ = CYNew CYIdentifier("each"); }
+    | "final" { $$ = CYNew CYIdentifier("final"); }
+    | "float" { $$ = CYNew CYIdentifier("float"); }
+    | "goto" { $$ = CYNew CYIdentifier("goto"); }
+    | "implements" { $$ = CYNew CYIdentifier("implements"); }
+    | "interface" { $$ = CYNew CYIdentifier("interface"); }
+    | "native" { $$ = CYNew CYIdentifier("native"); }
+    | "of" { $$ = CYNew CYIdentifier("of"); }
+    | "package" { $$ = CYNew CYIdentifier("package"); }
+    | "private" { $$ = CYNew CYIdentifier("private"); }
+    | "protected" { $$ = CYNew CYIdentifier("protected"); }
+    | "public" { $$ = CYNew CYIdentifier("public"); }
+    | "static" { $$ = CYNew CYIdentifier("static"); }
+    | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); }
+    | "throws" { $$ = CYNew CYIdentifier("throws"); }
+    | "transient" { $$ = CYNew CYIdentifier("transient"); }
+    | "yield" { $$ = CYNew CYIdentifier("yield"); }
+@begin ObjectiveC
+    | "bool" { $$ = CYNew CYIdentifier("bool"); }
+    | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); }
+    | "id" { $$ = CYNew CYIdentifier("id"); }
+    | "SEL" { $$ = CYNew CYIdentifier("SEL"); }
+@end
+    ;
+
+Identifier
+    : IdentifierType
+    | "char" { $$ = CYNew CYIdentifier("char"); }
+    | "int" { $$ = CYNew CYIdentifier("int"); }
+    | "long" { $$ = CYNew CYIdentifier("long"); }
+    | "short" { $$ = CYNew CYIdentifier("short"); }
+    | "undefined" { $$ = CYNew CYIdentifier("undefined"); }
+    | "volatile" { $$ = CYNew CYIdentifier("volatile"); }
+@begin C
+    | "extern" { $$ = CYNew CYIdentifier("extern"); }
+    | "signed" { $$ = CYNew CYIdentifier("signed"); }
+    | "typedef" { $$ = CYNew CYIdentifier("typedef"); }
+    | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); }
+@end
+@begin ObjectiveC
+    | "nil" { $$ = CYNew CYIdentifier("nil"); }
+    | "NO" { $$ = CYNew CYIdentifier("NO"); }
+    | "NULL" { $$ = CYNew CYIdentifier("NULL"); }
+    | "YES" { $$ = CYNew CYIdentifier("YES"); }
+@end

     ;
 
     ;
 

+IdentifierOpt
+    : Identifier { $$ = $1; }
+    | { $$ = NULL; }
+    ;
+/* }}} */
+/* 12.2 Primary Expression {{{ */

 PrimaryExpression
 PrimaryExpression

-    : "this" { $$ = $1; }
-    | Identifier { $$ = CYNew CYVariable($1); }
+    : "this" { $$ = CYNew CYThis(); }
+    | IdentifierReference { $$ = $1; }

     | Literal { $$ = $1; }
     | ArrayLiteral { $$ = $1; }
     | ObjectLiteral { $$ = $1; }
     | Literal { $$ = $1; }
     | ArrayLiteral { $$ = $1; }
     | ObjectLiteral { $$ = $1; }

-    | FunctionExpression { $$ = $1; }
-    | Parenthetical { $$ = $1; }
+    | RegularExpressionLiteral { $$ = $1; }
+    | TemplateLiteral { $$ = $1; }
+    | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) error(@1, "invalid parenthetical"); $$ = $1; }

     | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; }
     ;
     | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; }
     ;

-/* }}} */
-/* 11.1.4.1 Array Initialiser {{{ */
-ArrayLiteral
-    : "[" LexPushInOff ElementListOpt LexPopIn "]" { $$ = CYNew CYArray($3); }
-    ;

 
 

-Element
-    : AssignmentExpression { $$ = $1; }
+CoverParenthesizedExpressionAndArrowParameterList
+    : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }
+    | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }

     ;
     ;

-
-ElementOpt
-    : Element { $$ = $1; }
-    | LexSetRegExp { $$ = NULL; }
+/* }}} */
+/* 12.2.4 Literals {{{ */
+Literal
+    : NullLiteral { $$ = $1; }
+    | BooleanLiteral { $$ = $1; }
+    | NumericLiteral { $$ = $1; }
+    | StringLiteral { $$ = $1; }
+    ;
+/* }}} */
+/* 12.2.5 Array Initializer {{{ */
+ArrayLiteral
+    : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }

     ;
 
 ElementList
     ;
 
 ElementList

-    : ElementOpt "," ElementListOpt { $$ = CYNew CYElement($1, $3); }
-    | Element { $$ = CYNew CYElement($1, NULL); }
+    : AssignmentExpressionOpt "," ElementListOpt { $$ = CYNew CYElementValue($1, $3); }
+    | LexSetRegExp "..." AssignmentExpression { $$ = CYNew CYElementSpread($3); }
+    | AssignmentExpression { $$ = CYNew CYElementValue($1, NULL); }

     ;
 
 ElementListOpt
     ;
 
 ElementListOpt


@@ -751,30 +837,14 @@ ElementListOpt
     | LexSetRegExp { $$ = NULL; }
     ;
 /* }}} */
     | LexSetRegExp { $$ = NULL; }
     ;
 /* }}} */

-/* 11.1.4.2 Array Comprehension {{{ */
-PrimaryExpression
-    : "[" LexPushInOff AssignmentExpression ComprehensionForList LexPopIn "]" { $$ = CYNew CYArrayComprehension($3, $4); }
-    ;
-
-ComprehensionForList
-    : "for" Binding "in" Expression ComprehensionForListOpt { $$ = CYNew CYForInComprehension($2, $4, $5); }
-    | "for" Binding "of" Expression ComprehensionForListOpt { $$ = CYNew CYForOfComprehension($2, $4, $5); }
-    ;
-
-ComprehensionForListOpt
-    : ComprehensionForList { $$ = $1; }
-    | "if" Expression { $$ = CYNew CYIfComprehension($2); }
-    | { $$ = NULL; }
-    ;
-/* }}} */
-/* 11.1.5 Object Initialiser {{{ */
+/* 12.2.6 Object Initializer {{{ */

 ObjectLiteral
 ObjectLiteral

-    : BRACE LexPushInOff PropertyDefinitionListOpt LexPopIn "}" { $$ = CYNew CYObject($3); }
+    : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); }

     ;
 
 PropertyDefinitionList_
     : "," PropertyDefinitionList { $$ = $2; }
     ;
 
 PropertyDefinitionList_
     : "," PropertyDefinitionList { $$ = $2; }

-    | "," { $$ = NULL; }
+    | "," LexSetRegExp { $$ = NULL; }

     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 


@@ -784,7 +854,7 @@ PropertyDefinitionList
 
 PropertyDefinitionListOpt
     : PropertyDefinitionList { $$ = $1; }
 
 PropertyDefinitionListOpt
     : PropertyDefinitionList { $$ = $1; }

-    | { $$ = NULL; }
+    | LexSetRegExp { $$ = NULL; }

     ;
 
 PropertyDefinition
     ;
 
 PropertyDefinition


@@ -803,11 +873,32 @@ PropertyName_
 PropertyName
     : LexSetRegExp PropertyName_ { $$ = $2; }
     ;
 PropertyName
     : LexSetRegExp PropertyName_ { $$ = $2; }
     ;

+
+
+Initializer
+    : "=" AssignmentExpression { $$ = $2; }
+    ;
+
+InitializerOpt
+    : Initializer { $$ = $1; }
+    | { $$ = NULL; }
+    ;

 /* }}} */
 /* }}} */

+/* 12.2.9 Template Literals {{{ */
+TemplateLiteral
+    : NoSubstitutionTemplate { $$ = CYNew CYTemplate($1, NULL); }
+    | TemplateHead TemplateSpans { $$ = CYNew CYTemplate($1, $2); }
+    ;

 
 

-/* 11.2 Left-Hand-Side Expressions {{{ */
+TemplateSpans
+    : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); }
+    | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); }
+    ;
+/* }}} */
+
+/* 12.3+ Left-Hand-Side Expressions {{{ */

 MemberAccess
 MemberAccess

-    : "[" LexPushInOff Expression LexPopIn "]" { $$ = CYNew CYDirectMember(NULL, $3); }
+    : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }

     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
     | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
     ;
     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
     | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
     ;


@@ -819,6 +910,7 @@ MemberExpression_
 
 MemberExpression
     : LexSetRegExp PrimaryExpression { $$ = $2; }
 
 MemberExpression
     : LexSetRegExp PrimaryExpression { $$ = $2; }

+    | LexSetRegExp FunctionExpression { $$ = $2; }

     | MemberExpression_ { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
     | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); }
     ;
     | MemberExpression_ { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
     | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); }
     ;


@@ -839,7 +931,7 @@ CallExpression
     ;
 
 Arguments
     ;
 
 Arguments

-    : "(" LexPushInOff ArgumentListOpt LexPopIn ")" { $$ = $3; }
+    : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; }

     ;
 
 ArgumentList_
     ;
 
 ArgumentList_


@@ -849,6 +941,7 @@ ArgumentList_
 
 ArgumentList
     : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }
 
 ArgumentList
     : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }

+    | LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); }

     ;
 
 ArgumentListOpt
     ;
 
 ArgumentListOpt


@@ -861,14 +954,14 @@ LeftHandSideExpression
     | CallExpression { $$ = $1; }
     ;
 /* }}} */
     | CallExpression { $$ = $1; }
     ;
 /* }}} */

-/* 11.3 Postfix Expressions {{{ */
+/* 12.4 Postfix Expressions {{{ */

 PostfixExpression
     : %prec "" LeftHandSideExpression { $$ = $1; }
     | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); }
     | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); }
     ;
 /* }}} */
 PostfixExpression
     : %prec "" LeftHandSideExpression { $$ = $1; }
     | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); }
     | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); }
     ;
 /* }}} */

-/* 11.4 Unary Operators {{{ */
+/* 12.5 Unary Operators {{{ */

 UnaryExpression_
     : "delete" UnaryExpression { $$ = CYNew CYDelete($2); }
     | "void" UnaryExpression { $$ = CYNew CYVoid($2); }
 UnaryExpression_
     : "delete" UnaryExpression { $$ = CYNew CYDelete($2); }
     | "void" UnaryExpression { $$ = CYNew CYVoid($2); }


@@ -888,7 +981,7 @@ UnaryExpression
     | LexSetRegExp UnaryExpression_ { $$ = $2; }
     ;
 /* }}} */
     | LexSetRegExp UnaryExpression_ { $$ = $2; }
     ;
 /* }}} */

-/* 11.5 Multiplicative Operators {{{ */
+/* 12.6 Multiplicative Operators {{{ */

 MultiplicativeExpression
     : UnaryExpression { $$ = $1; }
     | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); }
 MultiplicativeExpression
     : UnaryExpression { $$ = $1; }
     | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); }


@@ -896,14 +989,14 @@ MultiplicativeExpression
     | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); }
     ;
 /* }}} */
     | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); }
     ;
 /* }}} */

-/* 11.6 Additive Operators {{{ */
+/* 12.7 Additive Operators {{{ */

 AdditiveExpression
     : MultiplicativeExpression { $$ = $1; }
     | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); }
     | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); }
     ;
 /* }}} */
 AdditiveExpression
     : MultiplicativeExpression { $$ = $1; }
     | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); }
     | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); }
     ;
 /* }}} */

-/* 11.7 Bitwise Shift Operators {{{ */
+/* 12.8 Bitwise Shift Operators {{{ */

 ShiftExpression
     : AdditiveExpression { $$ = $1; }
     | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); }
 ShiftExpression
     : AdditiveExpression { $$ = $1; }
     | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); }


@@ -911,7 +1004,7 @@ ShiftExpression
     | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); }
     ;
 /* }}} */
     | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); }
     ;
 /* }}} */

-/* 11.8 Relational Operators {{{ */
+/* 12.9 Relational Operators {{{ */

 RelationalExpression
     : ShiftExpression { $$ = $1; }
     | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); }
 RelationalExpression
     : ShiftExpression { $$ = $1; }
     | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); }


@@ -922,7 +1015,7 @@ RelationalExpression
     | RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); }
     ;
 /* }}} */
     | RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); }
     ;
 /* }}} */

-/* 11.9 Equality Operators {{{ */
+/* 12.10 Equality Operators {{{ */

 EqualityExpression
     : RelationalExpression { $$ = $1; }
     | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); }
 EqualityExpression
     : RelationalExpression { $$ = $1; }
     | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); }


@@ -931,7 +1024,7 @@ EqualityExpression
     | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); }
     ;
 /* }}} */
     | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); }
     ;
 /* }}} */

-/* 11.10 Binary Bitwise Operators {{{ */
+/* 12.11 Binary Bitwise Operators {{{ */

 BitwiseANDExpression
     : EqualityExpression { $$ = $1; }
     | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); }
 BitwiseANDExpression
     : EqualityExpression { $$ = $1; }
     | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); }


@@ -947,7 +1040,7 @@ BitwiseORExpression
     | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); }
     ;
 /* }}} */
     | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); }
     ;
 /* }}} */

-/* 11.11 Binary Logical Operators {{{ */
+/* 12.12 Binary Logical Operators {{{ */

 LogicalANDExpression
     : BitwiseORExpression { $$ = $1; }
     | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); }
 LogicalANDExpression
     : BitwiseORExpression { $$ = $1; }
     | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); }


@@ -958,15 +1051,16 @@ LogicalORExpression
     | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); }
     ;
 /* }}} */
     | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); }
     ;
 /* }}} */

-/* 11.12 Conditional Operator ( ? : ) {{{ */
+/* 12.13 Conditional Operator ( ? : ) {{{ */

 ConditionalExpression
     : LogicalORExpression { $$ = $1; }
 ConditionalExpression
     : LogicalORExpression { $$ = $1; }

-    | LogicalORExpression "?" LexPushInOff AssignmentExpression LexPopIn ":" AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
+    | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 11.13 Assignment Operators {{{ */
+/* 12.14 Assignment Operators {{{ */

 AssignmentExpression
     : ConditionalExpression { $$ = $1; }
 AssignmentExpression
     : ConditionalExpression { $$ = $1; }

+    // XXX: | YieldExpression { $$ = $1; }

     | ArrowFunction { $$ = $1; }
     | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
     | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
     | ArrowFunction { $$ = $1; }
     | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
     | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }


@@ -981,15 +1075,17 @@ AssignmentExpression
     | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
     | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
     ;
     | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
     | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
     ;

-/* }}} */
-/* 11.14 Comma Operator {{{ */
-Expression_
-    : "," Expression { $$ = $2; }
-    | { $$ = CYNew CYCompound(); }
-    ;

 
 

+AssignmentExpressionOpt
+    : AssignmentExpression { $$ = $1; }
+    | LexSetRegExp { $$ = NULL; }
+    ;
+/* }}} */
+/* 12.15 Comma Operator ( , ) {{{ */

 Expression
 Expression

-    : AssignmentExpression Expression_ { $2->AddPrev($1); $$ = $2; }
+    : AssignmentExpression { $$ = $1; }
+    /* XXX: I have this backwards... */
+    | AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); }

     ;
 
 ExpressionOpt
     ;
 
 ExpressionOpt


@@ -998,9 +1094,9 @@ ExpressionOpt
     ;
 /* }}} */
 
     ;
 /* }}} */
 

-/* 12 Statements {{{ */
+/* 13 Statements and Declarations {{{ */

 Statement__
 Statement__

-    : Block { $$ = $1; }
+    : BlockStatement { $$ = $1; }

     | VariableStatement { $$ = $1; }
     | EmptyStatement { $$ = $1; }
     | IfStatement { $$ = $1; }
     | VariableStatement { $$ = $1; }
     | EmptyStatement { $$ = $1; }
     | IfStatement { $$ = $1; }


@@ -1025,7 +1121,8 @@ Statement
     ;
 
 Declaration__
     ;
 
 Declaration__

-    : FunctionDeclaration { $$ = $1; }
+    : HoistableDeclaration { $$ = $1; }
+    // XXX: | ClassDeclaration { $$ = $1; }

     | LexicalDeclaration { $$ = $1; }
     ;
 
     | LexicalDeclaration { $$ = $1; }
     ;
 


@@ -1037,18 +1134,23 @@ Declaration
     : LexSetStatement Declaration_ { $$ = $2; }
     ;
 
     : LexSetStatement Declaration_ { $$ = $2; }
     ;
 

+HoistableDeclaration
+    : FunctionDeclaration
+    // XXX: | GeneratorDeclaration
+    ;
+

 BreakableStatement
     : IterationStatement { $$ = $1; }
     | SwitchStatement { $$ = $1; }
     ;
 /* }}} */
 BreakableStatement
     : IterationStatement { $$ = $1; }
     | SwitchStatement { $$ = $1; }
     ;
 /* }}} */

-/* 12.1 Block {{{ */
-Block_
-    : BRACE StatementListOpt "}" { $$ = $2; }
+/* 13.2 Block {{{ */
+BlockStatement
+    : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }

     ;
 
 Block
     ;
 
 Block

-    : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
+    : BRACE StatementListOpt "}" { $$ = $2; }

     ;
 
 StatementList
     ;
 
 StatementList


@@ -1065,19 +1167,7 @@ StatementListItem
     | Declaration { $$ = $1; }
     ;
 /* }}} */
     | Declaration { $$ = $1; }
     ;
 /* }}} */

-
-/* 12.2 Declarations {{{ */
-BindingIdentifier
-    : Identifier { $$ = $1; }
-    ;
-
-Binding
-    : BindingIdentifier
-    ;
-
-// XXX: BindingPattern
-/* }}} */
-/* 12.2.1 Let and Const Declarations {{{ */
+/* 13.3+ Let and Const Declarations {{{ */

 LexicalDeclaration
     : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
     ;
 LexicalDeclaration
     : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
     ;


@@ -1086,8 +1176,14 @@ LetOrConst
     : "let"
     | "const"
     ;
     : "let"
     | "const"
     ;

+
+Binding
+    : BindingIdentifier
+    ;
+
+// XXX: lots of binding stuff

 /* }}} */
 /* }}} */

-/* 12.2.2 Variable Statement {{{ */
+/* 13.3.2+ Variable Statement {{{ */

 VariableStatement
     : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
     ;
 VariableStatement
     : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
     ;


@@ -1102,20 +1198,11 @@ VariableDeclarationList
     ;
 
 VariableDeclaration
     ;
 
 VariableDeclaration

-    : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
-    // XXX: | BindingPattern Initialiser { $$ = CYNew CYDeclaration($1, $2); }
-    ;
-
-Initialiser
-    : "=" AssignmentExpression { $$ = $2; }
-    ;
-
-InitialiserOpt
-    : Initialiser { $$ = $1; }
-    | { $$ = NULL; }
+    : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); }
+    // XXX: | BindingPattern Initializer { $$ = CYNew CYDeclaration($1, $2); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.2.4 Destructuring Binding Patterns {{{ */
+/* 13.3.3+ Destructuring Binding Patterns {{{ */

 // XXX: *
 
 BindingElement
 // XXX: *
 
 BindingElement


@@ -1123,21 +1210,20 @@ BindingElement
     ;
 
 SingleNameBinding
     ;
 
 SingleNameBinding

-    : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
+    : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); }

     ;
 /* }}} */
     ;
 /* }}} */

-
-/* 12.3 Empty Statement {{{ */
+/* 13.4 Empty Statement {{{ */

 EmptyStatement
     : ";" { $$ = CYNew CYEmpty(); }
     ;
 /* }}} */
 EmptyStatement
     : ";" { $$ = CYNew CYEmpty(); }
     ;
 /* }}} */

-/* 12.4 Expression Statement {{{ */
+/* 13.5 Expression Statement {{{ */

 ExpressionStatement
     : Expression Terminator { $$ = CYNew CYExpress($1); }
     ;
 /* }}} */
 ExpressionStatement
     : Expression Terminator { $$ = CYNew CYExpress($1); }
     ;
 /* }}} */

-/* 12.5 The if Statement {{{ */
+/* 13.6 The if Statement {{{ */

 ElseStatementOpt
     : "else" Statement { $$ = $2; }
     | %prec "if" { $$ = NULL; }
 ElseStatementOpt
     : "else" Statement { $$ = $2; }
     | %prec "if" { $$ = NULL; }


@@ -1147,64 +1233,61 @@ IfStatement
     : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); }
     ;
 /* }}} */
     : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); }
     ;
 /* }}} */

-
-/* 12.6.1 The do-while Statement {{{ */
+/* 13.7+ Iteration Statements {{{ */

 IterationStatement
     : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
 IterationStatement
     : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }

-    ;
-/* }}} */
-/* 12.6.2 The while Statement {{{ */
-IterationStatement
-    : "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
-    ;
-/* }}} */
-/* 12.6.3 The for Statement {{{ */
-IterationStatement
-    : "for" "(" LexPushInOn ForStatementInitialiser LexPopIn ";" ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
+    | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
+    | "for" "(" LexPushInOn ForStatementInitializer ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
+    | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
+    | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }

     ;
 
     ;
 

-ForStatementInitialiser
+ForStatementInitializer

     : ExpressionOpt { $$ = $1; }
     | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
     ;
     : ExpressionOpt { $$ = $1; }
     | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
     ;

-/* }}} */
-/* 12.6.4 The for-in and for-of Statements {{{ */
-IterationStatement
-    : "for" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
-    | "for" "(" LexPushInOn ForInStatementInitialiser LexPopIn "of" Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }
-    ;

 
 

-ForInStatementInitialiser
+ForInStatementInitializer

     : LeftHandSideExpression { $$ = $1; }
     | LexSetRegExp Var_ VariableDeclaration { $$ = $3; }
     ;
 /* }}} */
     : LeftHandSideExpression { $$ = $1; }
     | LexSetRegExp Var_ VariableDeclaration { $$ = $3; }
     ;
 /* }}} */

+/* 13.8 The continue Statement {{{ */
+Continue
+    : "continue" LexNewLine
+    ;

 
 

-/* 12.7 The continue Statement {{{ */

 ContinueStatement
 ContinueStatement

-    : "continue" "\n" StrictSemi { $$ = CYNew CYContinue(NULL); }
-    | "continue" IdentifierOpt Terminator { $$ = CYNew CYContinue($2); }
+    : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); }
+    | Continue Identifier Terminator { $$ = CYNew CYContinue($2); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.8 The break Statement {{{ */
+/* 13.9 The break Statement {{{ */
+Break
+    : "break" LexNewLine
+    ;
+

 BreakStatement
 BreakStatement

-    : "break" "\n" StrictSemi { $$ = CYNew CYBreak(NULL); }
-    | "break" IdentifierOpt Terminator { $$ = CYNew CYBreak($2); }
+    : Break TerminatorSoft { $$ = CYNew CYBreak(NULL); }
+    | Break Identifier Terminator { $$ = CYNew CYBreak($2); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.9 The return Statement {{{ */
+/* 13.10 The return Statement {{{ */
+Return
+    : "return" LexNewLine
+    ;
+

 ReturnStatement
 ReturnStatement

-    : "return" "\n" StrictSemi { $$ = CYNew CYReturn(NULL); }
-    | "return" ExpressionOpt Terminator { $$ = CYNew CYReturn($2); }
+    : Return LexSetRegExp TerminatorSoft { $$ = CYNew CYReturn(NULL); }
+    | Return Expression Terminator { $$ = CYNew CYReturn($2); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.10 The with Statement {{{ */
+/* 13.11 The with Statement {{{ */

 WithStatement
     : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); }
     ;
 /* }}} */
 WithStatement
     : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); }
     ;
 /* }}} */

-
-/* 12.11 The switch Statement {{{ */
+/* 13.12 The switch Statement {{{ */

 SwitchStatement
     : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); }
     ;
 SwitchStatement
     : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); }
     ;


@@ -1223,49 +1306,64 @@ CaseClausesOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

+// XXX: the standard makes certain you can only have one of these

 DefaultClause
     : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
     ;
 /* }}} */
 DefaultClause
     : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
     ;
 /* }}} */

-/* 12.12 Labelled Statements {{{ */
+/* 13.13 Labelled Statements {{{ */

 LabelledStatement
 LabelledStatement

-    : Identifier ":" Statement { $$ = CYNew CYLabel($1, $3); }
+    : LabelIdentifier ":" LabelledItem { $$ = CYNew CYLabel($1, $3); }
+    ;
+
+LabelledItem
+    : Statement { $$ = $1; }
+    | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.13 The throw Statement {{{ */
+/* 13.14 The throw Statement {{{ */
+Throw
+    : "throw" LexNewLine
+    ;
+

 ThrowStatement
 ThrowStatement

-    : "throw" "\n" StrictSemi { YYABORT; }
-    | "throw" Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); }
+    : Throw LexSetRegExp TerminatorSoft { error(@1, "throw without exception"); }
+    | Throw Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.14 The try Statement {{{ */
+/* 13.15 The try Statement {{{ */

 TryStatement
 TryStatement

-    : "try" Block_ CatchOpt FinallyOpt { $$ = CYNew cy::Syntax::Try($2, $3, $4); }
+    : "try" Block Catch { $$ = CYNew cy::Syntax::Try($2, $3, NULL); }
+    | "try" Block Finally { $$ = CYNew cy::Syntax::Try($2, NULL, $3); }
+    | "try" Block Catch Finally { $$ = CYNew cy::Syntax::Try($2, $3, $4); }

     ;
 
     ;
 

-CatchOpt
-    : "catch" "(" Identifier ")" Block_ { $$ = CYNew cy::Syntax::Catch($3, $5); }
-    | { $$ = NULL; }
+Catch
+    : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); }

     ;
 
     ;
 

-FinallyOpt
-    : "finally" Block_ { $$ = CYNew CYFinally($2); }
-    | { $$ = NULL; }
+Finally
+    : "finally" Block { $$ = CYNew CYFinally($2); }
+    ;
+
+CatchParameter
+    : BindingIdentifier { $$ = $1; }
+    // XXX: BindingPattern

     ;
 /* }}} */
     ;
 /* }}} */

-/* 12.14 The debugger Statement {{{ */
+/* 13.16 The debugger Statement {{{ */

 DebuggerStatement
     : "debugger" Terminator { $$ = CYNew CYDebugger(); }
     ;
 /* }}} */
 
 DebuggerStatement
     : "debugger" Terminator { $$ = CYNew CYDebugger(); }
     ;
 /* }}} */
 

-/* 13.1 Function Definitions {{{ */
+/* 14.1+ Function Definitions {{{ */

 FunctionDeclaration
     : ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
     ;
 
 FunctionExpression
 FunctionDeclaration
     : ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
     ;
 
 FunctionExpression

-    : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt LexPopIn ")" BRACE LexPushInOff FunctionBody LexPopIn "}" { $$ = CYNew CYFunctionExpression($2, $5, $10); }
+    : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); }

     ;
 
 FormalParameterList_
     ;
 
 FormalParameterList_


@@ -1295,35 +1393,113 @@ FunctionBody
     : StatementListOpt { $$ = $1; }
     ;
 /* }}} */
     : StatementListOpt { $$ = $1; }
     ;
 /* }}} */

-/* 13.2 Arrow Function Definitions {{{ */
+/* 14.2 Arrow Function Definitions {{{ */

 ArrowFunction
     : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
     ;
 
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
 ArrowFunction
     : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
     ;
 
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }

-    //| ParentheticalOpt { $$ = $1; }
+    | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }

     ;
 
 ConciseBody
     : AssignmentExpression { $$ = CYNew CYReturn($1); }
     ;
 
 ConciseBody
     : AssignmentExpression { $$ = CYNew CYReturn($1); }

-    | ";{" LexPushInOff FunctionBody LexPopIn "}" { $$ = $3; }
+    | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 14 Program {{{ */
-Program
-    : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); }
+/* 14.3+ Method Definitions {{{ */
+/* }}} */
+/* 14.4+ Generator Function Definitions {{{ */
+/* }}} */
+/* 14.5+ Class Definitions {{{ */
+/* }}} */
+
+/* 15.1 Scripts {{{ */
+Script
+    : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); }

     ;
 
     ;
 

-ProgramBody
+ScriptBody

     : StatementList { $$ = $1; }
     ;
 
     : StatementList { $$ = $1; }
     ;
 

-ProgramBodyOpt
-    : ProgramBody { $$ = $1; }
+ScriptBodyOpt
+    : ScriptBody { $$ = $1; }

     | LexSetStatement LexSetRegExp { $$ = NULL; }
     ;
 /* }}} */
     | LexSetStatement LexSetRegExp { $$ = NULL; }
     ;
 /* }}} */

+/* 15.2+ Modules {{{ */
+/* }}} */
+/* 15.2.2+ Imports {{{ */
+/* }}} */
+/* 15.2.3+ Exports {{{ */
+/* }}} */
+
+@begin C
+/* Cycript (C): Type Encoding {{{ */
+TypeSignifier
+    : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); }
+    | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; }
+    ;
+
+SuffixedType
+    : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }
+    | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }
+    | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); }
+    | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); }
+    | TypeSignifier { $$ = $1; }
+    | { $$ = CYNew CYTypedIdentifier(@$); }
+    ;
+
+PrefixedType
+    : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
+    ;
+
+TypeQualifierLeft
+    : { $$ = NULL; }
+    | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); }
+    | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); }
+    ;
+
+TypeQualifierRight
+    : PrefixedType { $$ = $1; }
+    | SuffixedType { $$ = $1; }
+    | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); }
+    | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); }
+    ;
+
+IntegerType
+    : "int" { $$ = CYNew CYTypeVariable("int"); }
+    | "unsigned" IntegerTypeOpt { $$ = CYNew CYTypeUnsigned($2); }
+    | "signed" IntegerTypeOpt { $$ = CYNew CYTypeSigned($2); }
+    | "long" IntegerTypeOpt { $$ = CYNew CYTypeLong($2); }
+    | "short" IntegerTypeOpt { $$ = CYNew CYTypeShort($2); }
+    ;
+
+IntegerTypeOpt
+    : IntegerType { $$ = $1; }
+    | { $$ = CYNew CYTypeVariable("int"); }
+    ;
+
+PrimitiveType
+    : IdentifierType { $$ = CYNew CYTypeVariable($1); }
+    | IntegerType { $$ = $1; }
+    | "void" { $$ = CYNew CYTypeVoid(); }
+    | "char" { $$ = CYNew CYTypeVariable("char"); }
+    | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); }
+    | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); }
+    ;
+
+TypedIdentifier
+    : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
+    ;
+
+PrimaryExpression
+    : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); }
+    ;
+/* }}} */
+@end

 
 @begin ObjectiveC
 /* Cycript (Objective-C): @class Declaration {{{ */
 
 @begin ObjectiveC
 /* Cycript (Objective-C): @class Declaration {{{ */


@@ -1334,8 +1510,8 @@ ClassSuperOpt
     ;
 
 ClassFieldListOpt
     ;
 
 ClassFieldListOpt

-    : Expression Identifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $2, $4); }
-    | { $$ = NULL; }
+    : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); }
+    | LexSetRegExp { $$ = NULL; }

     ;
 
 ClassFields
     ;
 
 ClassFields


@@ -1348,13 +1524,12 @@ MessageScope
     ;
 
 TypeOpt
     ;
 
 TypeOpt

-    : "(" Expression ")" { $$ = $2; }
-    | "(" LexSetRegExp "void" ")" { $$ = CYNew CYString("v"); }
-    | { $$ = NULL; }
+    : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) error($3->location_, "unexpected identifier"); $$ = $3; }
+    | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); }

     ;
 
 MessageParameter
     ;
 
 MessageParameter

-    : Word ":" TypeOpt Identifier { $$ = CYNew CYMessageParameter($1, $3, $4); }
+    : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); }

     ;
 
 MessageParameterList
     ;
 
 MessageParameterList


@@ -1368,7 +1543,7 @@ MessageParameterListOpt
 
 MessageParameters
     : MessageParameterList { $$ = $1; }
 
 MessageParameters
     : MessageParameterList { $$ = $1; }

-    | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); }
+    | Word { $$ = CYNew CYMessageParameter($1, NULL); }

     ;
 
 ClassMessageDeclaration
     ;
 
 ClassMessageDeclaration


@@ -1377,7 +1552,6 @@ ClassMessageDeclaration
 
 ClassMessageDeclarationListOpt
     : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; }
 
 ClassMessageDeclarationListOpt
     : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; }

-    | ClassMessageDeclarationListOpt Comment { $$ = $1; }

     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 


@@ -1386,11 +1560,6 @@ ClassName
     | "(" AssignmentExpression ")" { $$ = $2; }
     ;
 
     | "(" AssignmentExpression ")" { $$ = $2; }
     ;
 

-ClassNameOpt
-    : ClassName { $$ = $1; }
-    | { $$ = NULL; }
-    ;
-

 // XXX: this should be AssignmentExpressionNoRight
 ClassProtocols
     : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }
 // XXX: this should be AssignmentExpressionNoRight
 ClassProtocols
     : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }


@@ -1406,12 +1575,8 @@ ClassProtocolListOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

-ClassExpression
-    : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt LexPopIn "@end" { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); }
-    ;
-

 ClassStatement
 ClassStatement

-    : ";@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }
+    : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }

     ;
 
 CategoryName
     ;
 
 CategoryName


@@ -1419,11 +1584,7 @@ CategoryName
     ;
 
 CategoryStatement
     ;
 
 CategoryStatement

-    : ";@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
-    ;
-
-PrimaryExpression
-    : ClassExpression { $$ = $1; }
+    : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }

     ;
 
 Statement__
     ;
 
 Statement__


@@ -1448,7 +1609,7 @@ SelectorCall_
     ;
 
 SelectorCall
     ;
 
 SelectorCall

-    : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); }
+    : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); }

     ;
 
 SelectorList
     ;
 
 SelectorList


@@ -1457,8 +1618,8 @@ SelectorList
     ;
 
 MessageExpression
     ;
 
 MessageExpression

-    : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList LexPopIn "]" { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
-    | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList LexPopIn "]" { $$ = CYNew CYSendSuper($6); }
+    : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
+    | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); }

     ;
 
 SelectorExpression_
     ;
 
 SelectorExpression_


@@ -1477,26 +1638,23 @@ SelectorExpressionOpt
 
 PrimaryExpression
     : MessageExpression { $$ = $1; }
 
 PrimaryExpression
     : MessageExpression { $$ = $1; }

-    | "@selector" "(" LexPushInOff SelectorExpression LexPopIn ")" { $$ = CYNew CYSelector($4); }
+    | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* Cycript (Objective-C): @import Directive {{{ */
-PathName
-    : "/" PathName
-    | "." PathName
-    | Word PathName
-    |
-    ;
+@end

 
 

-ImportPath
-    : "<" PathName ">"
-    | StringLiteral
+/* Cycript: @import Directive {{{ */
+Module
+    : Module "." Word { $$ = CYNew CYModule($3, $1); }
+    | Word { $$ = CYNew CYModule($1); }

     ;
 
     ;
 

-StatementListItem
-    : LexSetStatement LexSetRegExp "@import" ImportPath { $$ = CYNew CYImport(); }
+Declaration__
+    : "@import" Module { $$ = CYNew CYImport($2); }

     ;
 /* }}} */
     ;
 /* }}} */

+
+@begin ObjectiveC

 /* Cycript (Objective-C): Boxed Expressions {{{ */
 BoxableExpression
     : NullLiteral { $$ = $1; }
 /* Cycript (Objective-C): Boxed Expressions {{{ */
 BoxableExpression
     : NullLiteral { $$ = $1; }


@@ -1505,11 +1663,28 @@ BoxableExpression
     | StringLiteral { $$ = $1; }
     | ArrayLiteral { $$ = $1; }
     | ObjectLiteral { $$ = $1; }
     | StringLiteral { $$ = $1; }
     | ArrayLiteral { $$ = $1; }
     | ObjectLiteral { $$ = $1; }

-    | Parenthetical { $$ = $1; }
+    | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; }
+    | "YES" { $$ = CYNew CYTrue(); }
+    | "NO" { $$ = CYNew CYFalse(); }

     ;
 
 PrimaryExpression
     : "@" BoxableExpression { $$ = CYNew CYBox($2); }
     ;
 
 PrimaryExpression
     : "@" BoxableExpression { $$ = CYNew CYBox($2); }

+    | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); }
+    | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); }
+    | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); }
+    | "@false" { $$ = CYNew CYBox(CYNew CYFalse()); }
+    | "@null" { $$ = CYNew CYBox(CYNew CYNull()); }
+    ;
+/* }}} */
+/* Cycript (Objective-C): Block Expressions {{{ */
+PrimaryExpression
+    : "^" TypedIdentifier { if ($2->identifier_ != NULL) error($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else error($2->location_, "expected parameters"); }
+    ;
+/* }}} */
+/* Cycript (Objective-C): Instance Literals {{{ */
+PrimaryExpression
+    : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); }

     ;
 /* }}} */
 @end
     ;
 /* }}} */
 @end


@@ -1535,14 +1710,38 @@ Var_
     : "auto"
     ;
 /* }}} */
     : "auto"
     ;
 /* }}} */

-@end
+/* Cycript (C): Lambda Expressions {{{ */
+TypedParameterList_
+    : "," TypedParameterList { $$ = $2; }
+    | { $$ = NULL; }
+    ;
+
+TypedParameterList
+    : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); }
+    ;

 
 

-/* YUI: Documentation Comments {{{ */
+TypedParameterListOpt
+    : TypedParameterList { $$ = $1; }
+    | { $$ = NULL; }
+    ;
+
+PrimaryExpression
+    : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); }
+    ;
+/* }}} */
+/* Cycript (C): Type Definitions {{{ */

 Statement__
 Statement__

-    : Comment { $$ = $1; }
+    : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) error($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); }
+    ;
+/* }}} */
+/* Cycript (C): extern "C" {{{ */
+Statement__
+    : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) error(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) error($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); }

     ;
 /* }}} */
 
     ;
 /* }}} */
 

+@end
+

 @begin E4X
 /* Lexer State {{{ */
 LexPushRegExp
 @begin E4X
 /* Lexer State {{{ */
 LexPushRegExp


@@ -1578,11 +1777,11 @@ XMLWhitespaceOpt
 
 /* 8.1 Context Keywords {{{ */
 Identifier
 
 /* 8.1 Context Keywords {{{ */
 Identifier

-    : "namespace" { $$ = $1; }
-    | "xml" { $$ = $1; }
+    : "namespace" { $$ = CYNew CYIdentifier("namespace"); }
+    | "xml" { $$ = CYNew CYIdentifier("xml"); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* 8.3 XML Initialiser Input Elements {{{ */
+/* 8.3 XML Initializer Input Elements {{{ */

 XMLMarkup
     : XMLComment { $$ = $1; }
     | XMLCDATA { $$ = $1; }
 XMLMarkup
     : XMLComment { $$ = $1; }
     | XMLCDATA { $$ = $1; }


@@ -1610,7 +1809,7 @@ AttributeIdentifier
 
 PropertySelector_
     : PropertySelector { $$ = $1; }
 
 PropertySelector_
     : PropertySelector { $$ = $1; }

-    | "[" LexPushInOff Expression LexPopIn "]" { $$ = CYNew CYSelector($3); }
+    | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); }

     ;
 
 PropertySelector
     ;
 
 PropertySelector


@@ -1633,15 +1832,15 @@ WildcardIdentifier
     : "*" { $$ = CYNew CYWildcard(); }
     ;
 /* }}} */
     : "*" { $$ = CYNew CYWildcard(); }
     ;
 /* }}} */

-/* 11.1.4 XML Initialiser {{{ */
+/* 11.1.4 XML Initializer {{{ */

 XMLInitialiser
     : XMLMarkup { $$ = $1; }
     | XMLElement { $$ = $1; }
     ;
 
 XMLElement
 XMLInitialiser
     : XMLMarkup { $$ = $1; }
     | XMLElement { $$ = $1; }
     ;
 
 XMLElement

-    : "<" LexPushInOff XMLTagContent LexPop LexPopIn "/>"
-    | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop LexPopIn ">"
+    : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn
+    | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop ">" LexPopIn

     ;
 
 XMLTagContent
     ;
 
 XMLTagContent


@@ -1688,9 +1887,9 @@ XMLElementContentOpt
     |
     ;
 /* }}} */
     |
     ;
 /* }}} */

-/* 11.1.5 XMLList Initialiser {{{ */
+/* 11.1.5 XMLList Initializer {{{ */

 XMLListInitialiser
 XMLListInitialiser

-    : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop LexPopIn "</>" { $$ = CYNew CYXMLList($4); }
+    : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "</>" LexPopIn { $$ = CYNew CYXMLList($4); }

     ;
 /* }}} */
 
     ;
 /* }}} */
 


@@ -1717,36 +1916,22 @@ Statement__
 /* }}} */
 @end
 
 /* }}} */
 @end
 

-/* JavaScript 1.7: Array Comprehensions {{{ */
-IfComprehension
-    : "if" "(" Expression ")" { $$ = CYNew CYIfComprehension($3); }
-    ;
-
-ForComprehension
-    : "for" "(" Identifier "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); }
-    | "for" "each" "(" Identifier "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
-    ;
-
-ComprehensionList
-    : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; }
-    ;
-
-ComprehensionListOpt
-    : ComprehensionList { $$ = $1; }
-    | IfComprehension { $$ = $1; }
-    | { $$ = NULL; }
+/* JavaScript FTL: Array Comprehensions {{{ */
+Comprehension
+    : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }

     ;
 
     ;
 

-PrimaryExpression
-    : "[" LexPushInOff AssignmentExpression ComprehensionList LexPopIn "]" { $$ = CYNew CYArrayComprehension($3, $4); }
+ComprehensionFor
+    : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); }
+    | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* JavaScript 1.7: for each {{{ */
+/* JavaScript FTL: for each {{{ */

 IterationStatement
 IterationStatement

-    : "for" "each" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
+    : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }

     ;
 /* }}} */
     ;
 /* }}} */

-/* JavaScript 1.7: let Statements {{{ */
+/* JavaScript FTL: let Statements {{{ */

 LetStatement
     : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
     ;
 LetStatement
     : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
     ;


@@ -1756,6 +1941,38 @@ Statement__
     ;
 /* }}} */
 
     ;
 /* }}} */
 

+/* JavaScript FTW: Array Comprehensions {{{ */
+PrimaryExpression
+    : ArrayComprehension
+    ;
+
+ArrayComprehension
+    : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; }
+    ;
+
+Comprehension
+    : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); }
+    ;
+
+ComprehensionTail
+    : { $$ = NULL; }
+    | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); }
+    | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); }
+    ;
+
+ComprehensionFor
+    : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); }
+    ;
+
+ComprehensionIf
+    : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); }
+    ;
+/* }}} */
+/* JavaScript FTW: Coalesce Operator {{{ */
+ConditionalExpression
+    : LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); }
+    ;
+/* }}} */

 /* JavaScript FTW: Ruby Blocks {{{ */
 RubyProcParameterList_
     : "," RubyProcParameterList { $$ = $2; }
 /* JavaScript FTW: Ruby Blocks {{{ */
 RubyProcParameterList_
     : "," RubyProcParameterList { $$ = $2; }


@@ -1782,7 +1999,7 @@ RubyProcExpression
     ;
 
 PrimaryExpression
     ;
 
 PrimaryExpression

-    : "{" LexPushInOff RubyProcParameters StatementListOpt LexPopIn "}" { $$ = CYNew CYRubyProc($3, $4); }
+    : "{" LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); }

     ;
 
 CallExpression
     ;
 
 CallExpression