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 d9b9a1da9c8e3e64ae8609b1610f3a03f5bfc569..ce895ae1e961ea6980be5f7297efab3071ca6e46 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -1,5 +1,5 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* Cycript - Optimizing JavaScript Compiler/Runtime

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

 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */


@@ -19,18 +19,16 @@
 **/
 /* }}} */
 
 **/
 /* }}} */
 

-@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 "Driver.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"


@@ -41,92 +39,98 @@
 @end
 
 #include "Highlight.hpp"
 @end
 
 #include "Highlight.hpp"

-
-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_;
-        CYModule *module_;
-        CYNull *null_;
-        CYNumber *number_;
-        CYProgram *program_;
-        CYProperty *property_;
-        CYPropertyName *propertyName_;
-        CYRubyProc *rubyProc_;
-        CYStatement *statement_;
-        CYString *string_;
-        CYThis *this_;
-        CYTrue *true_;
-        CYWord *word_;
+}
+
+%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_; }

 
 @begin C
 
 @begin C

-        CYTypeModifier *modifier_;
-        CYTypeSpecifier *specifier_;
-        CYTypedIdentifier *typedIdentifier_;
-        CYTypedParameter *typedParameter_;
+%union { CYTypeModifier *modifier_; }
+%union { CYTypeSpecifier *specifier_; }
+%union { CYTypedIdentifier *typedIdentifier_; }
+%union { CYTypedParameter *typedParameter_; }

 @end
 
 @begin ObjectiveC
 @end
 
 @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
+%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 }
+%code {

 
 

-@if Bison23 %}
-@if Bison23 %union {
-@if Bison23 }
-@if Bison23 %{
+#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 Bison24 }
-@if Bison23 %}
+#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"
+}

 
 

-@if Bison23 %skeleton "lalr1.cc"
-@if Bison24 %language "C++"
+%name-prefix "cy"
+
+%language "C++"

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


@@ -135,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
 


@@ -181,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 "!=="


@@ -222,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 ")"


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

-%token AtError "@error"
+%token At_error_ "@error"

 
 @begin Java
 
 @begin Java

-%token AtClass "@class"
+%token At_class_ "@class"

 @end
 
 @begin C
 @end
 
 @begin C

-%token <identifier_> Typedef "typedef"
-%token <identifier_> Unsigned "unsigned"
-%token <identifier_> Signed "signed"
+%token _typedef_ "typedef"
+%token _unsigned_ "unsigned"
+%token _signed_ "signed"
+%token _extern_ "extern"

 @end
 
 @begin C
 @end
 
 @begin C

-%token AtEncode "@encode"
+%token At_encode_ "@encode"
+@end
+
+@begin ObjectiveC
+%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"
+%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
 @begin ObjectiveC

-%token AtImplementation "@implementation"
-%token AtImplementation_ ";@implementation"
-%token AtImport "@import"
-%token AtEnd "@end"
-%token AtSelector "@selector"
-%token <identifier_> Yes "YES"
-%token <identifier_> No "NO"
+%token _bool_ "bool"
+%token _BOOL_ "BOOL"
+%token _id_ "id"
+%token _nil_ "nil"
+%token _NULL_ "NULL"
+%token _SEL_ "SEL"

 @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 _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


@@ -357,22 +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_> ArrayComprehension
 %type <expression_> AdditiveExpression
 %type <argument_> ArgumentList_
 %type <argument_> ArgumentList
 %type <argument_> ArgumentListOpt
 %type <argument_> Arguments
 %type <expression_> ArrayComprehension

-%type <expression_> ArrayInitialiser

 %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


@@ -384,7 +400,8 @@ 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 <catch_> Catch
+%type <identifier_> CatchParameter

 %type <expression_> Comprehension
 %type <comprehension_> ComprehensionFor
 %type <comprehension_> ComprehensionIf
 %type <expression_> Comprehension
 %type <comprehension_> ComprehensionFor
 %type <comprehension_> ComprehensionIf


@@ -392,25 +409,23 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %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 <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


@@ -418,20 +433,23 @@ 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_> IdentifierType
 %type <word_> IdentifierName
 %type <identifier_> Identifier
 %type <identifier_> IdentifierOpt
 %type <identifier_> IdentifierType
 %type <word_> IdentifierName

+%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_> LogicalANDExpression
 %type <expression_> LogicalORExpression
 %type <member_> MemberAccess


@@ -442,13 +460,8 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <expression_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %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


@@ -462,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__


@@ -471,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_


@@ -481,20 +499,17 @@ 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

-%type <expression_> Variable
+@end

 
 @begin C
 
 @begin C

-%type <typedIdentifier_> ArrayedType
-%type <expression_> EncodedType
-%type <modifier_> FunctionedType

 %type <specifier_> IntegerType
 %type <specifier_> IntegerTypeOpt
 %type <typedIdentifier_> PrefixedType
 %type <specifier_> PrimitiveType
 %type <specifier_> IntegerType
 %type <specifier_> IntegerTypeOpt
 %type <typedIdentifier_> PrefixedType
 %type <specifier_> PrimitiveType

-%type <typedIdentifier_> TypeParenthetical
-%type <typedIdentifier_> TypeSignifier

 %type <typedIdentifier_> SuffixedType
 %type <typedIdentifier_> SuffixedType

+%type <typedIdentifier_> TypeSignifier

 %type <modifier_> TypeQualifierLeft
 %type <typedIdentifier_> TypeQualifierRight
 %type <typedIdentifier_> TypedIdentifier
 %type <modifier_> TypeQualifierLeft
 %type <typedIdentifier_> TypeQualifierRight
 %type <typedIdentifier_> TypedIdentifier


@@ -506,15 +521,13 @@ int cylex(YYSTYPE *, cy::location *, void *);
 @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


@@ -524,7 +537,6 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <messageParameter_> MessageParameterList
 %type <messageParameter_> MessageParameterListOpt
 %type <bool_> MessageScope
 %type <messageParameter_> MessageParameterList
 %type <messageParameter_> MessageParameterListOpt
 %type <bool_> MessageScope

-%type <typedIdentifier_> ModifiedType

 %type <argument_> SelectorCall_
 %type <argument_> SelectorCall
 %type <selector_> SelectorExpression_
 %type <argument_> SelectorCall_
 %type <argument_> SelectorCall
 %type <selector_> SelectorExpression_


@@ -532,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
 


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

-%start Program
+%start Script

 
 %%
 
 
 %%
 


@@ -586,22 +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 :
-@begin ObjectiveC
-    { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; }
-@end
+LexNoFunction
+    : { CYMAP(_function__, _function_); }

     ;
 
 LexSetStatement
     ;
 
 LexSetStatement

-    : LexNoBrace LexNoFunction LexNoAtImplementation
+    : LexNoBrace LexNoClass LexNoFunction

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


@@ -615,156 +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; }
     ;

-
-IdentifierType
-    : Identifier_ { $$ = $1; }
-
-    | "implements" { $$ = $1; }
-    | "interface" { $$ = $1; }
-    | "package" { $$ = $1; }
-    | "private" { $$ = $1; }
-    | "protected" { $$ = $1; }
-    | "public" { $$ = $1; }
-    | "static" { $$ = $1; }
-
-    | "abstract" { $$ = $1; }
-    | "boolean" { $$ = $1; }
-    | "byte" { $$ = $1; }
-    | "double" { $$ = $1; }
-    | "final" { $$ = $1; }
-    | "float" { $$ = $1; }
-    | "goto" { $$ = $1; }
-    | "native" { $$ = $1; }
-    | "synchronized" { $$ = $1; }
-    | "throws" { $$ = $1; }
-    | "transient" { $$ = $1; }
-
-    // XXX: currently I only have this as Word
-    // | "let" { $$ = $1; }
-
-    | "yield" { $$ = $1; }
-
-    | "each" { $$ = $1; }
-    | "of" { $$ = $1; }
-    ;
-
-Identifier
-    : IdentifierType
-    | "char" { $$ = $1; }
-    | "int" { $$ = $1; }
-    | "long" { $$ = $1; }
-    | "short" { $$ = $1; }
-    | "volatile" { $$ = $1; }
-@begin C
-    | "typedef" { $$ = $1; }
-    | "unsigned" { $$ = $1; }
-    | "signed" { $$ = $1; }
-@end
-@begin ObjectiveC
-    | "YES" { $$ = $1; }
-    | "NO" { $$ = $1; }

 @end
 @end

-    ;
-
-IdentifierOpt
-    : Identifier { $$ = $1; }
-    | { $$ = NULL; }
-    ;
-/* }}} */
-
-/* 7.8 Literals {{{ */
-Literal
-    : NullLiteral { $$ = $1; }
-    | ValueLiteral { $$ = $1; }
-    ;
-
-ValueLiteral
-    : BooleanLiteral { $$ = $1; }
-    | NumericLiteral { $$ = $1; }
-    | StringLiteral { $$ = $1; }
-    | RegularExpressionLiteral { $$ = $1; }
-    ;

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

-/* 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


@@ -773,53 +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"

     ;
 
     ;
 

-Variable
-    : Identifier { $$ = CYNew CYVariable($1); }
+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; }
-    | Variable { $$ = $1; }
+    : "this" { $$ = CYNew CYThis(); }
+    | IdentifierReference { $$ = $1; }

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

-    | ArrayInitialiser { $$ = $1; }
+    | ArrayLiteral { $$ = $1; }

     | ObjectLiteral { $$ = $1; }
     | ObjectLiteral { $$ = $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; }
     ;

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

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

-/* 11.1.4 Array Initializer {{{ */
-ArrayInitialiser
-    : ArrayLiteral { $$ = $1; }
-    | ArrayComprehension { $$ = $1; }
+/* 12.2.4 Literals {{{ */
+Literal
+    : NullLiteral { $$ = $1; }
+    | BooleanLiteral { $$ = $1; }
+    | NumericLiteral { $$ = $1; }
+    | StringLiteral { $$ = $1; }

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

-/* 11.1.4.1 Array Literal {{{ */
+/* 12.2.5 Array Initializer {{{ */

 ArrayLiteral
     : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
     ;
 
 ArrayLiteral
     : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
     ;
 

-Element
-    : AssignmentExpression { $$ = $1; }
-    ;
-
-ElementOpt
-    : Element { $$ = $1; }
-    | LexSetRegExp { $$ = NULL; }
-    ;
-

 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


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

-/* 11.1.4.2 Array Comprehension {{{ */
-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); }
-    ;
-/* }}} */
-/* 11.1.5 Object Initialiser {{{ */
+/* 12.2.6 Object Initializer {{{ */

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


@@ -886,9 +873,30 @@ 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
     : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
 MemberAccess
     : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
     | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }


@@ -933,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


@@ -945,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); }


@@ -972,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); }


@@ -980,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); }


@@ -995,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); }


@@ -1006,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); }


@@ -1015,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); }


@@ -1031,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); }


@@ -1042,16 +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; }
     | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
 ConditionalExpression
     : LogicalORExpression { $$ = $1; }
     | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }

-    | LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $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); }


@@ -1066,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; }
-    | { $$ = NULL; }
-    ;

 
 

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

 Expression
 Expression

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

     ;
 
 ExpressionOpt
     ;
 
 ExpressionOpt


@@ -1083,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; }


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

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

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


@@ -1122,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


@@ -1150,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); }
     ;


@@ -1171,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); }
     ;


@@ -1187,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


@@ -1208,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; }


@@ -1232,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 "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
-    | "for" "(" LexPushInOn ForInStatementInitialiser "of" LexPopIn 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" LexSetRegExp "\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); }
     ;


@@ -1308,43 +1306,58 @@ 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" LexSetRegExp "\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); }
     ;
 FunctionDeclaration
     : ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
     ;


@@ -1380,14 +1393,14 @@ 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
     ;
 
 ConciseBody


@@ -1395,47 +1408,48 @@ ConciseBody
     | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }
     ;
 /* }}} */
     | 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 {{{ */
 
 @begin C
 /* Cycript (C): Type Encoding {{{ */

-TypeParenthetical
-    : "(" LexPushInOff PrefixedType ")" LexPopIn { $$ = $3; }
-    ;
-

 TypeSignifier
 TypeSignifier

-    : IdentifierType { $$ = CYNew CYTypedIdentifier($1); }
-    | TypeParenthetical { $$ = $1; }
-    ;
-
-ArrayedType
-    : ArrayedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }
-    | TypeSignifier { $$ = $1; }
-    | { $$ = CYNew CYTypedIdentifier(); }
-    ;
-
-FunctionedType
-    : "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypeFunctionWith($3); }
+    : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); }
+    | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; }

     ;
 
 SuffixedType
     ;
 
 SuffixedType

-    : ArrayedType { $$ = $1; }
+    : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }

     | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }
     | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }

-    | TypeParenthetical FunctionedType { $$ = $1; CYSetLast($2) = $$->modifier_; $$->modifier_ = $2; }
-    | FunctionedType { $$ = CYNew CYTypedIdentifier(); CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
+    | 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
     ;
 
 PrefixedType


@@ -1481,12 +1495,8 @@ TypedIdentifier
     : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
     ;
 
     : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
     ;
 

-EncodedType
-    : TypedIdentifier { $$ = CYNew CYEncodedType($1); }
-    ;
-

 PrimaryExpression
 PrimaryExpression

-    : "@encode" "(" EncodedType ")" { $$ = $3; }
+    : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); }

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


@@ -1500,7 +1510,7 @@ ClassSuperOpt
     ;
 
 ClassFieldListOpt
     ;
 
 ClassFieldListOpt

-    : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $3); }
+    : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); }

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


@@ -1514,12 +1524,12 @@ MessageScope
     ;
 
 TypeOpt
     ;
 
 TypeOpt

-    : "(" LexSetRegExp EncodedType ")" { $$ = $3; }
-    | { $$ = 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


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

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

     ;
 
 ClassMessageDeclaration
     ;
 
 ClassMessageDeclaration


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

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

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


@@ -1551,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); }


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

-ClassExpression
-    : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" LexPopIn { $$ = 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


@@ -1584,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__


@@ -1613,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


@@ -1667,23 +1663,23 @@ 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); }
     | "YES" { $$ = CYNew CYTrue(); }
     | "NO" { $$ = CYNew CYFalse(); }
     ;
 
 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 {{{ */
     ;
 /* }}} */
 /* Cycript (Objective-C): Block Expressions {{{ */

-ModifiedType
-    : TypeQualifierLeft PrimitiveType { $$ = CYNew CYTypedIdentifier(); $$->specifier_ = $2; $$->modifier_ = $1; }
-    | ModifiedType "*" { $$ = $1; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
-    ;
-

 PrimaryExpression
 PrimaryExpression

-    : "^" ModifiedType "(" LexPushInOff TypedParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYObjCBlock($2, $5, $10); }
+    : "^" 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 {{{ */
     ;
 /* }}} */
 /* Cycript (Objective-C): Instance Literals {{{ */


@@ -1735,17 +1731,17 @@ PrimaryExpression
 /* }}} */
 /* Cycript (C): Type Definitions {{{ */
 Statement__
 /* }}} */
 /* Cycript (C): Type Definitions {{{ */
 Statement__

-    : "typedef" TypedIdentifier Terminator { $$ = CYNew CYTypeDefinition($2); }
+    : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) error($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); }

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

-@end
-
-/* YUI: Documentation Comments {{{ */
+/* Cycript (C): extern "C" {{{ */

 Statement__
 Statement__

-    : Comment { $$ = $1; }
+    : "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


@@ -1781,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; }


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

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

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


@@ -1891,7 +1887,7 @@ XMLElementContentOpt
     |
     ;
 /* }}} */
     |
     ;
 /* }}} */

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

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


@@ -1920,7 +1916,7 @@ Statement__
 /* }}} */
 @end
 
 /* }}} */
 @end
 

-/* JavaScript 1.7: Array Comprehensions {{{ */
+/* JavaScript FTL: Array Comprehensions {{{ */

 Comprehension
     : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
     ;
 Comprehension
     : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
     ;


@@ -1930,12 +1926,12 @@ ComprehensionFor
     | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
     ;
 /* }}} */
     | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
     ;
 /* }}} */

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

 IterationStatement
 IterationStatement

-    : "for" "each" "(" LexPushInOn ForInStatementInitialiser "!in" LexPopIn 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); }
     ;


@@ -1945,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; }