@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_;
- 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_;
- CYParenthetical *parenthetical_;
- 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
- CYTypeModifier *modifier_;
- CYTypeSpecifier *specifier_;
- CYTypedIdentifier *typedIdentifier_;
- CYTypedParameter *typedParameter_;
+%union { CYTypeModifier *modifier_; }
+%union { CYTypeSpecifier *specifier_; }
+%union { CYTypedIdentifier *typedIdentifier_; }
+%union { CYTypedParameter *typedParameter_; }
@end
@begin ObjectiveC
- CYClassName *className_;
- CYClassField *classField_;
- 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
- CYAttribute *attribute_;
- CYPropertyIdentifier *propertyIdentifier_;
- CYSelector *selector_;
+%union { CYAttribute *attribute_; }
+%union { CYPropertyIdentifier *propertyIdentifier_; }
+%union { CYSelector *selector_; }
@end
- };
-} YYSTYPE;
-
-#define YYSTYPE YYSTYPE
-}
%code provides {
+
+struct YYSTYPE {
+ cy::parser::semantic_type semantic_;
+ hi::Value highlight_;
+};
+
int cylex(YYSTYPE *, CYLocation *, void *);
+
+}
+
+%code {
+
+#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;
+}
+
+#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"
%token SemiColon ";"
%token NewLine "\n"
-%token <comment_> Comment
+%token Comment
%token OpenParen "("
%token CloseParen ")"
%token OpenBracket "["
%token CloseBracket "]"
-%token AtError "@error"
+%token At_error_ "@error"
@begin Java
-%token AtClass "@class"
+%token At_class_ "@class"
@end
@begin C
-%token Typedef "typedef"
-%token Unsigned "unsigned"
-%token Signed "signed"
-%token Extern "extern"
+%token _typedef_ "typedef"
+%token _unsigned_ "unsigned"
+%token _signed_ "signed"
+%token _extern_ "extern"
@end
@begin C
-%token AtEncode "@encode"
+%token At_encode_ "@encode"
@end
@begin ObjectiveC
-%token AtImplementation "@implementation"
-%token AtImplementation_ ";@implementation"
-%token AtImport "@import"
-%token AtEnd "@end"
-%token AtSelector "@selector"
-%token AtNull "@null"
-%token AtYes "@YES"
-%token AtNo "@NO"
-%token AtTrue "@true"
-%token AtFalse "@false"
-%token Yes "YES"
-%token No "NO"
+%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
-%token False "false"
-%token Null "null"
-%token True "true"
-
-%token Break "break"
-%token Case "case"
-%token Catch "catch"
-%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 Auto "auto"
-%token Each "each"
-%token 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
-%token Namespace "namespace"
-%token XML "xml"
+%token _namespace_ "namespace"
+%token _xml_ "xml"
@end
%token AutoComplete
%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_> ArrayInitialiser
%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 <statement_> Block_
%type <statement_> Block
+%type <statement_> BlockStatement
%type <boolean_> BooleanLiteral
%type <declaration_> BindingElement
%type <expression_> BitwiseORExpression
%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_> 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 <expression_> Element
-%type <expression_> ElementOpt
%type <element_> ElementList
%type <element_> ElementListOpt
%type <statement_> ElseStatementOpt
%type <expression_> Expression
%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 <statement_> FunctionBody
%type <statement_> FunctionDeclaration
%type <expression_> FunctionExpression
+%type <statement_> HoistableDeclaration
%type <identifier_> Identifier
%type <identifier_> IdentifierOpt
%type <identifier_> IdentifierType
%type <word_> IdentifierName
+%type <expression_> IdentifierReference
%type <statement_> IfStatement
-%type <expression_> Initialiser
-%type <expression_> InitialiserOpt
+%type <expression_> Initializer
+%type <expression_> InitializerOpt
%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 <literal_> ValueLiteral
%type <expression_> LogicalANDExpression
%type <expression_> LogicalORExpression
%type <member_> MemberAccess
%type <expression_> NewExpression
%type <null_> NullLiteral
%type <literal_> ObjectLiteral
-%type <parenthetical_> Parenthetical
%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 <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 <statement_> StatementListOpt
%type <statement_> StatementListItem
%type <statement_> SwitchStatement
+%type <expression_> TemplateLiteral
+%type <span_> TemplateSpans
%type <statement_> ThrowStatement
%type <statement_> TryStatement
%type <expression_> UnaryExpression_
@begin ObjectiveC
%type <word_> WordOpt
@end
-%type <expression_> Variable
@begin C
%type <specifier_> IntegerType
@begin ObjectiveC
%type <expression_> BoxableExpression
%type <statement_> CategoryStatement
-%type <expression_> ClassExpression
%type <classField_> ClassFieldListOpt
%type <classField_> ClassFields
%type <statement_> ClassStatement
%type <message_> ClassMessageDeclaration
%type <message_> ClassMessageDeclarationListOpt
%type <className_> ClassName
-%type <className_> ClassNameOpt
%type <protocol_> ClassProtocolListOpt
%type <protocol_> ClassProtocols
%type <protocol_> ClassProtocolsOpt
%nonassoc "else"
/* }}} */
-%start Program
+%start Script
%%
: { driver.SetCondition(CYDriver::RegExpCondition); }
;
+LexNewLine
+ : { if (!yyla.empty() && yyla.type_get() != yyeof_) error(@$, "unexpected lookahead"); driver.next_ = true; }
+ ;
+
LexNoBrace
- : { if (yyla.empty()) driver.no_.OpenBrace = true; else if (yyla.type == yytranslate_(token::OpenBrace) || yyla.type == yytranslate_(token::OpenBrace_)) yyla.type = yytranslate_(token::OpenBrace__); }
+ : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); }
;
-LexNoFunction
- : { if (yyla.empty()) driver.no_.Function = true; else if (yyla.type == yytranslate_(token::Function)) yyla.type = yytranslate_(token::Function_); }
+LexNoClass
+ : { CYMAP(_class__, _class_); }
;
-LexNoAtImplementation :
-@begin ObjectiveC
- { if (yyla.empty()) driver.no_.AtImplementation = true; else if (yyla.type == yytranslate_(token::AtImplementation)) yyla.type = yytranslate_(token::AtImplementation_); }
-@end
+LexNoFunction
+ : { CYMAP(_function__, _function_); }
;
LexSetStatement
- : LexNoBrace LexNoFunction LexNoAtImplementation
+ : LexNoBrace LexNoClass LexNoFunction
;
/* }}} */
/* Virtual Tokens {{{ */
;
/* }}} */
-/* 7.6 Identifier Names and Identifiers {{{ */
+/* 11.6 Names and Keywords {{{ */
IdentifierName
: Word { $$ = $1; }
- ;
-
-NewLineOpt
- : "\n"
- |
+ | "for" { $$ = CYNew CYWord("for"); }
+ | "in" { $$ = CYNew CYWord("in"); }
+ | "instanceof" { $$ = CYNew CYWord("instanceof"); }
;
Word
: Identifier { $$ = $1; }
-
| "auto" { $$ = CYNew CYWord("auto"); }
- | "break" NewLineOpt { $$ = CYNew CYWord("break"); }
+ | "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" NewLineOpt { $$ = CYNew CYWord("continue"); }
+ | "continue" { $$ = CYNew CYWord("continue"); }
| "debugger" { $$ = CYNew CYWord("debugger"); }
| "default" { $$ = CYNew CYWord("default"); }
| "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); }
| "extends" { $$ = CYNew CYWord("extends"); }
| "false" { $$ = CYNew CYWord("false"); }
| "finally" { $$ = CYNew CYWord("finally"); }
- /* XXX: | "for" { $$ = CYNew CYWord("for"); } */
| "function" { $$ = CYNew CYWord("function"); }
| "if" { $$ = CYNew CYWord("if"); }
| "import" { $$ = CYNew CYWord("import"); }
- /* XXX: | "in" { $$ = CYNew CYWord("in"); } */
| "!in" { $$ = CYNew CYWord("in"); }
- /* XXX: | "instanceof" { $$ = CYNew CYWord("instanceof"); } */
-
- // XXX: as it currently is not an Identifier
- | "let" { $$ = CYNew CYIdentifier("let"); }
-
| "new" LexSetRegExp { $$ = CYNew CYWord("new"); }
| "null" { $$ = CYNew CYWord("null"); }
- | "return" NewLineOpt { $$ = CYNew CYWord("return"); }
+ | "return" { $$ = CYNew CYWord("return"); }
| "super" { $$ = CYNew CYWord("super"); }
| "switch" { $$ = CYNew CYWord("switch"); }
| "this" { $$ = CYNew CYWord("this"); }
- | "throw" NewLineOpt { $$ = CYNew CYWord("throw"); }
+ | "throw" { $$ = CYNew CYWord("throw"); }
| "true" { $$ = CYNew CYWord("true"); }
| "try" { $$ = CYNew CYWord("try"); }
| "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); }
| "void" LexSetRegExp { $$ = CYNew CYWord("void"); }
| "while" { $$ = CYNew CYWord("while"); }
| "with" { $$ = CYNew CYWord("with"); }
+
+ // XXX: should be Identifier
+ | "let" { $$ = CYNew CYIdentifier("let"); }
;
@begin ObjectiveC
| { $$ = NULL; }
;
@end
+/* }}} */
+/* 11.8.1 Null Literals {{{ */
+NullLiteral
+ : "null" { $$ = CYNew CYNull(); }
+ ;
+/* }}} */
+/* 11.8.2 Boolean Literals {{{ */
+BooleanLiteral
+ : "true" { $$ = CYNew CYTrue(); }
+ | "false" { $$ = CYNew CYFalse(); }
+ ;
+/* }}} */
+
+/* 11.9 Automatic Semicolon Insertion {{{ */
+StrictSemi
+ : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
+ ;
+
+TerminatorSoft
+ : ";"
+ | "\n" StrictSemi
+ ;
+
+Terminator
+ : ";"
+ | 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
+ : ";"
+ | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
+ ;
+/* }}} */
+
+/* 12.1 Identifiers {{{ */
+IdentifierReference
+ : Identifier { $$ = CYNew CYVariable($1); }
+ // XXX: | "yield"
+ ;
+
+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"); }
| "synchronized" { $$ = CYNew CYIdentifier("synchronized"); }
| "throws" { $$ = CYNew CYIdentifier("throws"); }
| "transient" { $$ = CYNew CYIdentifier("transient"); }
-
- // XXX: currently I only have this as Word
- // | "let" { $$ = CYNew CYIdentifier("let"); }
-
- | "yield" NewLineOpt { $$ = CYNew CYIdentifier("yield"); }
-
- | "each" { $$ = CYNew CYIdentifier("each"); }
- | "of" { $$ = CYNew CYIdentifier("of"); }
+ | "yield" { $$ = CYNew CYIdentifier("yield"); }
+@begin ObjectiveC
+ | "bool" { $$ = CYNew CYIdentifier("bool"); }
+ | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); }
+ | "id" { $$ = CYNew CYIdentifier("id"); }
+ | "SEL" { $$ = CYNew CYIdentifier("SEL"); }
+@end
;
Identifier
| "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"); }
| "unsigned" { $$ = CYNew CYIdentifier("unsigned"); }
@end
@begin ObjectiveC
+ | "nil" { $$ = CYNew CYIdentifier("nil"); }
| "NO" { $$ = CYNew CYIdentifier("NO"); }
+ | "NULL" { $$ = CYNew CYIdentifier("NULL"); }
| "YES" { $$ = CYNew CYIdentifier("YES"); }
@end
;
| { $$ = NULL; }
;
/* }}} */
-
-/* 7.8 Literals {{{ */
-Literal
- : NullLiteral { $$ = $1; }
- | ValueLiteral { $$ = $1; }
- ;
-
-ValueLiteral
- : BooleanLiteral { $$ = $1; }
- | NumericLiteral { $$ = $1; }
- | StringLiteral { $$ = $1; }
- | RegularExpressionLiteral { $$ = $1; }
- ;
-/* }}} */
-/* 7.8.1 Null Literals {{{ */
-NullLiteral
- : "null" { $$ = CYNew CYNull(); }
- ;
-/* }}} */
-/* 7.8.2 Boolean Literals {{{ */
-BooleanLiteral
- : "true" { $$ = CYNew CYTrue(); }
- | "false" { $$ = CYNew CYFalse(); }
- ;
-/* }}} */
-
-/* 7.9 Automatic Semicolon Insertion {{{ */
-StrictSemi
- : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
- ;
-
-Terminator
- : ";"
- | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !yyla.value.newline_) { error(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
- ;
-
-TerminatorOpt
- : ";"
- | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
- ;
-/* }}} */
-
-/* 11.1 Primary Expressions {{{ */
-Parenthetical
- : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }
- ;
-
-Variable
- : Identifier { $$ = CYNew CYVariable($1); }
- ;
-
+/* 12.2 Primary Expression {{{ */
PrimaryExpression
: "this" { $$ = CYNew CYThis(); }
- | Variable { $$ = $1; }
+ | IdentifierReference { $$ = $1; }
| Literal { $$ = $1; }
- | ArrayInitialiser { $$ = $1; }
+ | ArrayLiteral { $$ = $1; }
| ObjectLiteral { $$ = $1; }
- | Parenthetical { $$ = $1; }
+ | RegularExpressionLiteral { $$ = $1; }
+ | TemplateLiteral { $$ = $1; }
+ | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) error(@1, "invalid parenthetical"); $$ = $1; }
| 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); }
;
-Element
- : AssignmentExpression { $$ = $1; }
- ;
-
-ElementOpt
- : Element { $$ = $1; }
- | LexSetRegExp { $$ = NULL; }
- ;
-
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
| 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); }
;
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); }
+ ;
+
+TemplateSpans
+ : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); }
+ | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); }
+ ;
/* }}} */
-/* 11.2 Left-Hand-Side Expressions {{{ */
+/* 12.3+ Left-Hand-Side Expressions {{{ */
MemberAccess
: "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
| "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
| CallExpression { $$ = $1; }
;
/* }}} */
-/* 11.3 Postfix Expressions {{{ */
+/* 12.4 Postfix Expressions {{{ */
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); }
| LexSetRegExp UnaryExpression_ { $$ = $2; }
;
/* }}} */
-/* 11.5 Multiplicative Operators {{{ */
+/* 12.6 Multiplicative Operators {{{ */
MultiplicativeExpression
: UnaryExpression { $$ = $1; }
| MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($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); }
;
/* }}} */
-/* 11.7 Bitwise Shift Operators {{{ */
+/* 12.8 Bitwise Shift Operators {{{ */
ShiftExpression
: AdditiveExpression { $$ = $1; }
| ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($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 "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 { $$ = CYNew CYNotIdentical($1, $3); }
;
/* }}} */
-/* 11.10 Binary Bitwise Operators {{{ */
+/* 12.11 Binary Bitwise Operators {{{ */
BitwiseANDExpression
: EqualityExpression { $$ = $1; }
| BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($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); }
| 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); }
- | LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); }
;
/* }}} */
-/* 11.13 Assignment Operators {{{ */
+/* 12.14 Assignment Operators {{{ */
AssignmentExpression
: ConditionalExpression { $$ = $1; }
+ // XXX: | YieldExpression { $$ = $1; }
| ArrowFunction { $$ = $1; }
| LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
| LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
| LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
| LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
;
+
+AssignmentExpressionOpt
+ : AssignmentExpression { $$ = $1; }
+ | LexSetRegExp { $$ = NULL; }
+ ;
/* }}} */
-/* 11.14 Comma Operator {{{ */
+/* 12.15 Comma Operator ( , ) {{{ */
Expression
: AssignmentExpression { $$ = $1; }
+ /* XXX: I have this backwards... */
| AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); }
;
;
/* }}} */
-/* 12 Statements {{{ */
+/* 13 Statements and Declarations {{{ */
Statement__
- : Block { $$ = $1; }
+ : BlockStatement { $$ = $1; }
| VariableStatement { $$ = $1; }
| EmptyStatement { $$ = $1; }
| IfStatement { $$ = $1; }
;
Declaration__
- : FunctionDeclaration { $$ = $1; }
+ : HoistableDeclaration { $$ = $1; }
+ // XXX: | ClassDeclaration { $$ = $1; }
| LexicalDeclaration { $$ = $1; }
;
: LexSetStatement Declaration_ { $$ = $2; }
;
+HoistableDeclaration
+ : FunctionDeclaration
+ // XXX: | GeneratorDeclaration
+ ;
+
BreakableStatement
: IterationStatement { $$ = $1; }
| SwitchStatement { $$ = $1; }
;
/* }}} */
-/* 12.1 Block {{{ */
-Block_
- : BRACE StatementListOpt "}" { $$ = $2; }
+/* 13.2 Block {{{ */
+BlockStatement
+ : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
;
Block
- : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
+ : BRACE StatementListOpt "}" { $$ = $2; }
;
StatementList
| 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); }
;
: "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); }
;
;
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
;
SingleNameBinding
- : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
+ : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); }
;
/* }}} */
-
-/* 12.3 Empty Statement {{{ */
+/* 13.4 Empty Statement {{{ */
EmptyStatement
: ";" { $$ = CYNew CYEmpty(); }
;
/* }}} */
-/* 12.4 Expression Statement {{{ */
+/* 13.5 Expression Statement {{{ */
ExpressionStatement
: Expression Terminator { $$ = CYNew CYExpress($1); }
;
/* }}} */
-/* 12.5 The if Statement {{{ */
+/* 13.6 The if Statement {{{ */
ElseStatementOpt
: "else" Statement { $$ = $2; }
| %prec "if" { $$ = NULL; }
: "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); }
- ;
-/* }}} */
-/* 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); }
;
-/* }}} */
-/* 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; }
;
/* }}} */
+/* 13.8 The continue Statement {{{ */
+Continue
+ : "continue" LexNewLine
+ ;
-/* 12.7 The continue Statement {{{ */
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
- : "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
- : "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); }
;
/* }}} */
-
-/* 12.11 The switch Statement {{{ */
+/* 13.12 The switch Statement {{{ */
SwitchStatement
: "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); }
;
| { $$ = NULL; }
;
+// XXX: the standard makes certain you can only have one of these
DefaultClause
: "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
;
/* }}} */
-/* 12.12 Labelled Statements {{{ */
+/* 13.13 Labelled Statements {{{ */
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
- : "throw" LexSetRegExp "\n" StrictSemi { error(@1, "throw without exception"); }
- | "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
- : "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(); }
;
/* }}} */
-/* 13.1 Function Definitions {{{ */
+/* 14.1+ Function Definitions {{{ */
FunctionDeclaration
: ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
;
: 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)); }
- | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }
- | Parenthetical { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }
+ | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }
;
ConciseBody
| 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; }
;
-ProgramBodyOpt
- : ProgramBody { $$ = $1; }
+ScriptBodyOpt
+ : ScriptBody { $$ = $1; }
| LexSetStatement LexSetRegExp { $$ = NULL; }
;
/* }}} */
+/* 15.2+ Modules {{{ */
+/* }}} */
+/* 15.2.2+ Imports {{{ */
+/* }}} */
+/* 15.2.3+ Exports {{{ */
+/* }}} */
@begin C
/* Cycript (C): Type Encoding {{{ */
ClassMessageDeclarationListOpt
: ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; }
- | ClassMessageDeclarationListOpt Comment { $$ = $1; }
| { $$ = NULL; }
;
| "(" AssignmentExpression ")" { $$ = $2; }
;
-ClassNameOpt
- : ClassName { $$ = $1; }
- | { $$ = NULL; }
- ;
-
// XXX: this should be AssignmentExpressionNoRight
ClassProtocols
: ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }
| { $$ = NULL; }
;
-ClassExpression
- : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" LexPopIn { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); }
- ;
-
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
;
CategoryStatement
- : ";@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
- ;
-
-PrimaryExpression
- : ClassExpression { $$ = $1; }
+ : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
;
Statement__
| StringLiteral { $$ = $1; }
| ArrayLiteral { $$ = $1; }
| ObjectLiteral { $$ = $1; }
- | Parenthetical { $$ = $1; }
+ | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; }
| "YES" { $$ = CYNew CYTrue(); }
| "NO" { $$ = CYNew CYFalse(); }
;
@end
-/* YUI: Documentation Comments {{{ */
-Statement__
- : Comment { $$ = $1; }
- ;
-/* }}} */
-
@begin E4X
/* Lexer State {{{ */
LexPushRegExp
| "xml" { $$ = CYNew CYIdentifier("xml"); }
;
/* }}} */
-/* 8.3 XML Initialiser Input Elements {{{ */
+/* 8.3 XML Initializer Input Elements {{{ */
XMLMarkup
: XMLComment { $$ = $1; }
| XMLCDATA { $$ = $1; }
: "*" { $$ = CYNew CYWildcard(); }
;
/* }}} */
-/* 11.1.4 XML Initialiser {{{ */
+/* 11.1.4 XML Initializer {{{ */
XMLInitialiser
: XMLMarkup { $$ = $1; }
| XMLElement { $$ = $1; }
|
;
/* }}} */
-/* 11.1.5 XMLList Initialiser {{{ */
+/* 11.1.5 XMLList Initializer {{{ */
XMLListInitialiser
: "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "</>" LexPopIn { $$ = CYNew CYXMLList($4); }
;
/* }}} */
@end
-/* JavaScript 1.7: Array Comprehensions {{{ */
+/* JavaScript FTL: Array Comprehensions {{{ */
Comprehension
: AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
;
| "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
;
/* }}} */
-/* JavaScript 1.7: for each {{{ */
+/* JavaScript FTL: for each {{{ */
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); }
;
;
/* }}} */
+/* 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; }
projects / cycript.git / blobdiff