X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/005a09393a9d0d1cdd93ccab565f28ff7c078dcc..442609f78b9211e29761d7fe877097ab3cd95bb0:/Cycript.yy.in diff --git a/Cycript.yy.in b/Cycript.yy.in index d5e3e6a..ce895ae 100644 --- a/Cycript.yy.in +++ b/Cycript.yy.in @@ -1,35 +1,34 @@ /* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2010 Jay Freeman (saurik) + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* GNU Lesser General Public License, Version 3 {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Cycript is free software: you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Cycript is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with Cycript. If not, see . + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . **/ /* }}} */ -@if Bison23 %{ - -@if Bison24 %code top { +%code top { #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" -#define CYNew new($pool) +#include "Stack.hpp" +#define CYNew new(driver.pool_) @begin ObjectiveC #include "ObjectiveC/Syntax.hpp" @@ -39,77 +38,99 @@ #include "E4X/Syntax.hpp" @end -typedef struct { - bool newline_; - - union { - bool bool_; - - CYDriver::Condition condition_; - - CYArgument *argument_; - CYAssignment *assignment_; - CYBoolean *boolean_; - CYClause *clause_; - cy::Syntax::Catch *catch_; - CYComment *comment_; - CYComprehension *comprehension_; - CYCompound *compound_; - CYDeclaration *declaration_; - CYDeclarations *declarations_; - CYElement *element_; - CYExpression *expression_; - CYFalse *false_; - CYFinally *finally_; - CYForInitialiser *for_; - CYForInInitialiser *forin_; - CYFunctionParameter *functionParameter_; - CYIdentifier *identifier_; - CYInfix *infix_; - CYLiteral *literal_; - CYMember *member_; - CYNull *null_; - CYNumber *number_; - CYProgram *program_; - CYProperty *property_; - CYPropertyName *propertyName_; - CYRubyProc *rubyProc_; - CYStatement *statement_; - CYString *string_; - CYThis *this_; - CYTrue *true_; - CYWord *word_; +#include "Highlight.hpp" +} + +%union { bool bool_; } + +%union { CYArgument *argument_; } +%union { CYAssignment *assignment_; } +%union { CYBoolean *boolean_; } +%union { CYClause *clause_; } +%union { cy::Syntax::Catch *catch_; } +%union { CYComprehension *comprehension_; } +%union { CYDeclaration *declaration_; } +%union { CYDeclarations *declarations_; } +%union { CYElement *element_; } +%union { CYExpression *expression_; } +%union { CYFalse *false_; } +%union { CYFinally *finally_; } +%union { CYForInitializer *for_; } +%union { CYForInInitializer *forin_; } +%union { CYFunctionParameter *functionParameter_; } +%union { CYIdentifier *identifier_; } +%union { CYInfix *infix_; } +%union { CYLiteral *literal_; } +%union { CYMember *member_; } +%union { CYModule *module_; } +%union { CYNull *null_; } +%union { CYNumber *number_; } +%union { CYParenthetical *parenthetical_; } +%union { CYProperty *property_; } +%union { CYPropertyName *propertyName_; } +%union { CYRubyProc *rubyProc_; } +%union { CYSpan *span_; } +%union { CYStatement *statement_; } +%union { CYString *string_; } +%union { CYThis *this_; } +%union { CYTrue *true_; } +%union { CYWord *word_; } + +@begin C +%union { CYTypeModifier *modifier_; } +%union { CYTypeSpecifier *specifier_; } +%union { CYTypedIdentifier *typedIdentifier_; } +%union { CYTypedParameter *typedParameter_; } +@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 - CYAttribute *attribute_; - CYPropertyIdentifier *propertyIdentifier_; - CYSelector *selector_; +%union { CYAttribute *attribute_; } +%union { CYPropertyIdentifier *propertyIdentifier_; } +%union { CYSelector *selector_; } @end - }; -} YYSTYPE; -#define YYSTYPE YYSTYPE -@if Bison24 } +%code provides { + +struct YYSTYPE { + cy::parser::semantic_type semantic_; + hi::Value highlight_; +}; -@if Bison24 %code provides { -int cylex(YYSTYPE *, cy::location *, void *); -@if Bison24 } +int cylex(YYSTYPE *, CYLocation *, void *); -@if Bison23 %} +} -%name-prefix="cy" +%code { -@if Bison23 %skeleton "lalr1.cc" -@if Bison24 %language "C++" +#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" + +%language "C++" %initial-action { @$.begin.filename = @$.end.filename = &driver.filename_; @@ -118,6 +139,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %locations %defines +%define api.location.type { CYLocation } + //%glr-parser //%expect 1 @@ -126,6 +149,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %parse-param { CYDriver &driver } %lex-param { void *cyscanner } +/* Token Declarations {{{ */ @begin E4X %token XMLCDATA %token XMLComment @@ -151,6 +175,7 @@ int cylex(YYSTYPE *, cy::location *, void *); @begin E4X ObjectiveC %token At "@" +%token Pound "#" @end %token Ampersand "&" @@ -161,6 +186,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %token Equal "=" %token EqualEqual "==" %token EqualEqualEqual "===" +%token EqualRight "=>" +%token EqualRight_ "\n=>" %token Exclamation "!" %token ExclamationEqual "!=" %token ExclamationEqualEqual "!==" @@ -202,7 +229,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %token SemiColon ";" %token NewLine "\n" -%token Comment +%token Comment %token OpenParen "(" %token CloseParen ")" @@ -215,103 +242,123 @@ int cylex(YYSTYPE *, cy::location *, void *); %token OpenBracket "[" %token CloseBracket "]" +%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" +@end + +@begin C +%token At_encode_ "@encode" @end @begin ObjectiveC -%token AtImplementation "@implementation" -%token AtImplementation_ ";@implementation" -%token AtImport "@import" -%token AtEnd "@end" -%token AtSelector "@selector" +%token At_implementation_ "@implementation" +%token At_import_ "@import" +%token At_end_ "@end" +%token At_selector_ "@selector" +%token At_null_ "@null" +%token At_YES_ "@YES" +%token At_NO_ "@NO" +%token At_true_ "@true" +%token At_false_ "@false" +%token _YES_ "YES" +%token _NO_ "NO" @end -%token False "false" -%token Null "null" -%token True "true" - -// ES3/ES5/WIE/JSC Reserved -%token Break "break" -%token Case "case" -%token Catch "catch" -%token Continue "continue" -%token Default "default" -%token Delete "delete" -%token Do "do" -%token Else "else" -%token Finally "finally" -%token For "for" -%token Function "function" -%token Function_ ";function" -%token If "if" -%token In "in" -%token In_ "!in" -%token InstanceOf "instanceof" -%token New "new" -%token Return "return" -%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" - -// ES3/IE6 Future, ES5/JSC Reserved -%token Debugger "debugger" - -// ES3/ES5/IE6 Future, JSC Reserved -%token Const "const" - -// ES3/ES5/IE6/JSC Future -%token Class "class" -%token Enum "enum" -%token Export "export" -%token Extends "extends" -%token Import "import" -%token Super "super" - -// ES3 Future, ES5 Strict Future -%token Implements "implements" -%token Interface "interface" -%token Package "package" -%token Private "private" -%token Protected "protected" -%token Public "public" -%token Static "static" - -// ES3 Future -%token Abstract "abstract" -%token Boolean "boolean" -%token Byte "byte" -%token Char "char" -%token Double "double" -%token Final "final" -%token Float "float" -%token Goto "goto" -%token Int "int" -%token Long "long" -%token Native "native" -%token Short "short" -%token Synchronized "synchronized" -%token Throws "throws" -%token Transient "transient" -%token Volatile "volatile" - -// ES5 Strict -%token Let "let" -%token Yield "yield" - -// Woah?! -%token Each "each" +%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 -// E4X Conditional -%token Namespace "namespace" -%token XML "xml" +%token _namespace_ "namespace" +%token _xml_ "xml" @end %token AutoComplete @@ -321,17 +368,27 @@ int cylex(YYSTYPE *, cy::location *, void *); %token StringLiteral %token RegularExpressionLiteral +%token NoSubstitutionTemplate +%token TemplateHead +%token TemplateMiddle +%token TemplateTail + %type AdditiveExpression %type ArgumentList_ %type ArgumentList %type ArgumentListOpt %type Arguments +%type ArrayComprehension %type ArrayLiteral +%type ArrowFunction +%type ArrowParameters %type AssignmentExpression +%type AssignmentExpressionOpt +%type Binding %type BindingIdentifier %type BitwiseANDExpression -%type Block_ %type Block +%type BlockStatement %type BooleanLiteral %type BindingElement %type BitwiseORExpression @@ -343,34 +400,32 @@ int cylex(YYSTYPE *, cy::location *, void *); %type CaseBlock %type CaseClause %type CaseClausesOpt -%type CatchOpt -%type ComprehensionList -%type ComprehensionListOpt +%type Catch +%type CatchParameter +%type Comprehension +%type ComprehensionFor +%type ComprehensionIf +%type ComprehensionTail %type ConditionalExpression %type ContinueStatement +%type ConciseBody +%type CoverParenthesizedExpressionAndArrowParameterList %type DebuggerStatement %type Declaration__ %type Declaration_ %type Declaration %type DefaultClause -%type DoWhileStatement -%type Element -%type ElementOpt %type ElementList %type ElementListOpt %type ElseStatementOpt %type EmptyStatement %type EqualityExpression -%type Expression_ %type Expression %type ExpressionOpt %type ExpressionStatement -%type FinallyOpt -%type ForComprehension -%type ForStatement -%type ForStatementInitialiser -%type ForInStatement -%type ForInStatementInitialiser +%type Finally +%type ForStatementInitializer +%type ForInStatementInitializer %type FormalParameter %type FormalParameterList_ %type FormalParameterList @@ -378,40 +433,41 @@ int cylex(YYSTYPE *, cy::location *, void *); %type FunctionBody %type FunctionDeclaration %type FunctionExpression +%type HoistableDeclaration %type Identifier %type IdentifierOpt -%type IfComprehension +%type IdentifierType +%type IdentifierName +%type IdentifierReference %type IfStatement -%type Initialiser -%type InitialiserOpt +%type Initializer +%type InitializerOpt %type IterationStatement +%type LabelIdentifier +%type LabelledItem %type LabelledStatement %type LeftHandSideExpression %type LetStatement %type LexicalDeclaration %type Literal -%type LiteralNoRE %type LogicalANDExpression %type LogicalORExpression %type MemberAccess %type MemberExpression_ %type MemberExpression +%type Module %type MultiplicativeExpression %type NewExpression %type NullLiteral %type ObjectLiteral -%type Parenthetical %type PostfixExpression %type PrimaryExpression -%type Program -%type ProgramBody -%type ProgramBodyOpt %type PropertyName_ %type PropertyName -%type PropertyNameAndValueList_ -%type PropertyNameAndValueList -%type PropertyNameAndValueListOpt -%type RelationalExpression_ +%type PropertyDefinition +%type PropertyDefinitionList_ +%type PropertyDefinitionList +%type PropertyDefinitionListOpt %type RelationalExpression %type ReturnStatement %type RubyProcExpression @@ -419,6 +475,9 @@ int cylex(YYSTYPE *, cy::location *, void *); %type RubyProcParameterList %type RubyProcParameters %type RubyProcParametersOpt +%type Script +%type ScriptBody +%type ScriptBodyOpt %type ShiftExpression %type SingleNameBinding %type Statement__ @@ -428,6 +487,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %type StatementListOpt %type StatementListItem %type SwitchStatement +%type TemplateLiteral +%type TemplateSpans %type ThrowStatement %type TryStatement %type UnaryExpression_ @@ -436,19 +497,37 @@ int cylex(YYSTYPE *, cy::location *, void *); %type VariableDeclarationList_ %type VariableDeclarationList %type VariableStatement -%type WhileStatement %type WithStatement +%type Word +@begin ObjectiveC +%type WordOpt +@end + +@begin C +%type IntegerType +%type IntegerTypeOpt +%type PrefixedType +%type PrimitiveType +%type SuffixedType +%type TypeSignifier +%type TypeQualifierLeft +%type TypeQualifierRight +%type TypedIdentifier +%type TypedParameterList_ +%type TypedParameterList +%type TypedParameterListOpt +@end @begin ObjectiveC +%type BoxableExpression %type CategoryStatement -%type ClassExpression +%type ClassFieldListOpt +%type ClassFields %type ClassStatement %type ClassSuperOpt -%type ClassFieldList %type ClassMessageDeclaration %type ClassMessageDeclarationListOpt %type ClassName -%type ClassNameOpt %type ClassProtocolListOpt %type ClassProtocols %type ClassProtocolsOpt @@ -465,10 +544,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %type SelectorExpressionOpt %type SelectorList %type SelectorWordOpt -%type TypeOpt +%type TypeOpt %type VariadicCall -%type Word -%type WordOpt @end @begin E4X @@ -491,14 +568,16 @@ int cylex(YYSTYPE *, cy::location *, void *); %type XMLListInitialiser %type XMLInitialiser @end - +/* }}} */ +/* Token Priorities {{{ */ %nonassoc "" %left "++" "--" %nonassoc "if" %nonassoc "else" +/* }}} */ -%start Program +%start Script %% @@ -519,201 +598,238 @@ LexSetRegExp : { driver.SetCondition(CYDriver::RegExpCondition); } ; -LexSetStatement - : { switch (yychar) { - case token::Function: - yychar = token::Function_; - break; - - case token::OpenBrace: - case token::OpenBrace_: - yychar = token::OpenBrace__; - break; - } } +LexNewLine + : { if (!yyla.empty() && yyla.type_get() != yyeof_) error(@$, "unexpected lookahead"); driver.next_ = true; } ; -/* }}} */ -BRACE - : "{" - | "\n{" +LexNoBrace + : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); } ; -StrictSemi - : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); } +LexNoClass + : { CYMAP(_class__, _class_); } ; -Terminator_ - : ";" - | "\n" StrictSemi +LexNoFunction + : { CYMAP(_function__, _function_); } ; -Terminator - : Terminator_ - | error { if (yychar != 0 && yychar != token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi +LexSetStatement + : LexNoBrace LexNoClass LexNoFunction ; - -TerminatorOpt - : Terminator_ - | error { yyerrok; driver.errors_.pop_back(); } StrictSemi +/* }}} */ +/* Virtual Tokens {{{ */ +BRACE + : "{" + | "\n{" ; -/*CommaOpt - : "," - | - ;*/ +Var_ + : "var" + ; +/* }}} */ -@begin ObjectiveC -NewLineOpt - : "\n" - | +/* 11.6 Names and Keywords {{{ */ +IdentifierName + : Word { $$ = $1; } + | "for" { $$ = CYNew CYWord("for"); } + | "in" { $$ = CYNew CYWord("in"); } + | "instanceof" { $$ = CYNew CYWord("instanceof"); } ; Word : Identifier { $$ = $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; } */ - /* XXX: | "instanceof" { $$ = $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; } ; +@end +/* }}} */ +/* 11.8.1 Null Literals {{{ */ +NullLiteral + : "null" { $$ = CYNew CYNull(); } + ; +/* }}} */ +/* 11.8.2 Boolean Literals {{{ */ +BooleanLiteral + : "true" { $$ = CYNew CYTrue(); } + | "false" { $$ = CYNew CYFalse(); } + ; +/* }}} */ -PrimaryExpression - : "@" LiteralNoRE { $$ = CYNew CYBox($2); } - | "@" ArrayLiteral { $$ = CYNew CYBox($2); } - | "@" ObjectLiteral { $$ = CYNew CYBox($2); } - | "@" Parenthetical { $$ = CYNew CYBox($2); } +/* 11.9 Automatic Semicolon Insertion {{{ */ +StrictSemi + : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } ; -@end -Identifier - : Identifier_ { $$ = $1; } +TerminatorSoft + : ";" + | "\n" StrictSemi + ; - | "implements" { $$ = $1; } - | "interface" { $$ = $1; } - | "package" { $$ = $1; } - | "private" { $$ = $1; } - | "protected" { $$ = $1; } - | "public" { $$ = $1; } - | "static" { $$ = $1; } - - | "abstract" { $$ = $1; } - | "boolean" { $$ = $1; } - | "byte" { $$ = $1; } - | "char" { $$ = $1; } - | "double" { $$ = $1; } - | "final" { $$ = $1; } - | "float" { $$ = $1; } - | "goto" { $$ = $1; } - | "int" { $$ = $1; } - | "long" { $$ = $1; } - | "native" { $$ = $1; } - | "short" { $$ = $1; } - | "synchronized" { $$ = $1; } - | "throws" { $$ = $1; } - | "transient" { $$ = $1; } - | "volatile" { $$ = $1; } - - // XXX: is this allowed?! | "let" { $$ = $1; } - | "yield" { $$ = $1; } - - | "each" { $$ = $1; } +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 ; -IdentifierOpt - : Identifier { $$ = $1; } - | { $$ = NULL; } +TerminatorOpt + : ";" + | error { yyerrok; driver.errors_.pop_back(); } StrictSemi ; +/* }}} */ -LiteralNoRE - : NullLiteral { $$ = $1; } - | BooleanLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - | StringLiteral { $$ = $1; } +/* 12.1 Identifiers {{{ */ +IdentifierReference + : Identifier { $$ = CYNew CYVariable($1); } + // XXX: | "yield" ; -Literal - : LiteralNoRE { $$ = $1; } - | RegularExpressionLiteral { $$ = $1; } +BindingIdentifier + : Identifier { $$ = $1; } + // XXX: | "yield" ; -NullLiteral - : "null" { $$ = $1; } +LabelIdentifier + : Identifier { $$ = $1; } + // XXX: | yield ; -BooleanLiteral - : "true" { $$ = $1; } - | "false" { $$ = $1; } +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 ; -/* 11.1 Primary Expressions {{{ */ -Parenthetical - : "(" LexPushInOff Expression LexPopIn ")" { $$ = $3; } +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 - : "this" { $$ = $1; } - | Identifier { $$ = CYNew CYVariable($1); } + : "this" { $$ = CYNew CYThis(); } + | IdentifierReference { $$ = $1; } | Literal { $$ = $1; } | ArrayLiteral { $$ = $1; } | ObjectLiteral { $$ = $1; } - | FunctionExpression { $$ = $1; } - | Parenthetical { $$ = $1; } + | RegularExpressionLiteral { $$ = $1; } + | TemplateLiteral { $$ = $1; } + | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) error(@1, "invalid parenthetical"); $$ = $1; } | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; } ; -/* }}} */ -/* 11.1.4.1 Array Initialiser {{{ */ -ArrayLiteral - : "[" LexPushInOff ElementListOpt LexPopIn "]" { $$ = CYNew CYArray($3); } - ; -Element - : AssignmentExpression { $$ = $1; } +CoverParenthesizedExpressionAndArrowParameterList + : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); } + | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; } ; - -ElementOpt - : Element { $$ = $1; } - | LexSetRegExp { $$ = NULL; } +/* }}} */ +/* 12.2.4 Literals {{{ */ +Literal + : NullLiteral { $$ = $1; } + | BooleanLiteral { $$ = $1; } + | NumericLiteral { $$ = $1; } + | StringLiteral { $$ = $1; } + ; +/* }}} */ +/* 12.2.5 Array Initializer {{{ */ +ArrayLiteral + : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); } ; ElementList - : 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 @@ -721,27 +837,35 @@ ElementListOpt | LexSetRegExp { $$ = NULL; } ; /* }}} */ -/* 11.1.5 Object Initialiser {{{ */ +/* 12.2.6 Object Initializer {{{ */ ObjectLiteral - : BRACE LexPushInOff PropertyNameAndValueListOpt LexPopIn "}" { $$ = CYNew CYObject($3); } + : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); } ; -PropertyNameAndValueList_ - : "," PropertyNameAndValueList { $$ = $2; } +PropertyDefinitionList_ + : "," PropertyDefinitionList { $$ = $2; } + | "," LexSetRegExp { $$ = NULL; } | { $$ = NULL; } ; -PropertyNameAndValueList - : PropertyName ":" AssignmentExpression PropertyNameAndValueList_ { $$ = CYNew CYProperty($1, $3, $4); } +PropertyDefinitionList + : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; } ; -PropertyNameAndValueListOpt - : PropertyNameAndValueList { $$ = $1; } - | { $$ = NULL; } +PropertyDefinitionListOpt + : PropertyDefinitionList { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; + +PropertyDefinition + // XXX: this should be IdentifierName + : LexSetRegExp Identifier { $$ = CYNew CYProperty($2, CYNew CYVariable($2)); } + | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); } + //| MethodDefinition ; PropertyName_ - : Identifier { $$ = $1; } + : IdentifierName { $$ = $1; } | StringLiteral { $$ = $1; } | NumericLiteral { $$ = $1; } ; @@ -749,12 +873,33 @@ PropertyName_ 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); } - | "." Identifier { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); } + : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); } + | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); } | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; } ; @@ -765,6 +910,7 @@ MemberExpression_ MemberExpression : LexSetRegExp PrimaryExpression { $$ = $2; } + | LexSetRegExp FunctionExpression { $$ = $2; } | MemberExpression_ { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); } ; @@ -785,7 +931,7 @@ CallExpression ; Arguments - : "(" LexPushInOff ArgumentListOpt LexPopIn ")" { $$ = $3; } + : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; } ; ArgumentList_ @@ -795,6 +941,7 @@ ArgumentList_ ArgumentList : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); } + | LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); } ; ArgumentListOpt @@ -807,14 +954,14 @@ LeftHandSideExpression | 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); } @@ -834,7 +981,7 @@ UnaryExpression | LexSetRegExp UnaryExpression_ { $$ = $2; } ; /* }}} */ -/* 11.5 Multiplicative Operators {{{ */ +/* 12.6 Multiplicative Operators {{{ */ MultiplicativeExpression : UnaryExpression { $$ = $1; } | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); } @@ -842,14 +989,14 @@ MultiplicativeExpression | 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); } @@ -857,22 +1004,18 @@ ShiftExpression | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); } ; /* }}} */ -/* 11.8 Relational Operators {{{ */ -RelationalExpression_ - : ShiftExpression { $$ = $1; } - ; - +/* 12.9 Relational Operators {{{ */ RelationalExpression - : RelationalExpression_ { $$ = $1; } - | RelationalExpression "<" RelationalExpression_ { $$ = CYNew CYLess($1, $3); } - | RelationalExpression ">" RelationalExpression_ { $$ = CYNew CYGreater($1, $3); } - | RelationalExpression "<=" RelationalExpression_ { $$ = CYNew CYLessOrEqual($1, $3); } - | RelationalExpression ">=" RelationalExpression_ { $$ = CYNew CYGreaterOrEqual($1, $3); } - | RelationalExpression "instanceof" RelationalExpression_ { $$ = CYNew CYInstanceOf($1, $3); } - | RelationalExpression "in" RelationalExpression_ { $$ = CYNew CYIn($1, $3); } + : ShiftExpression { $$ = $1; } + | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); } + | RelationalExpression ">" ShiftExpression { $$ = CYNew CYGreater($1, $3); } + | RelationalExpression "<=" ShiftExpression { $$ = CYNew CYLessOrEqual($1, $3); } + | RelationalExpression ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual($1, $3); } + | RelationalExpression "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf($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); } @@ -881,7 +1024,7 @@ EqualityExpression | 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); } @@ -897,7 +1040,7 @@ BitwiseORExpression | 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); } @@ -908,15 +1051,17 @@ LogicalORExpression | 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 AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $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 CYDivideAssign($1, $3); } @@ -930,15 +1075,17 @@ AssignmentExpression | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); } | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); } ; -/* }}} */ -/* 11.14 Comma Operator {{{ */ -Expression_ - : "," Expression { $$ = CYNew CYCompound($2); } - | { $$ = NULL; } - ; +AssignmentExpressionOpt + : AssignmentExpression { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; +/* }}} */ +/* 12.15 Comma Operator ( , ) {{{ */ Expression - : AssignmentExpression Expression_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; } + : AssignmentExpression { $$ = $1; } + /* XXX: I have this backwards... */ + | AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); } ; ExpressionOpt @@ -947,9 +1094,9 @@ ExpressionOpt ; /* }}} */ -/* 12 Statements {{{ */ +/* 13 Statements and Declarations {{{ */ Statement__ - : Block { $$ = $1; } + : BlockStatement { $$ = $1; } | VariableStatement { $$ = $1; } | EmptyStatement { $$ = $1; } | IfStatement { $$ = $1; } @@ -974,7 +1121,8 @@ Statement ; Declaration__ - : FunctionDeclaration { $$ = $1; } + : HoistableDeclaration { $$ = $1; } + // XXX: | ClassDeclaration { $$ = $1; } | LexicalDeclaration { $$ = $1; } ; @@ -986,18 +1134,23 @@ Declaration : 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 @@ -1006,7 +1159,7 @@ StatementList StatementListOpt : StatementList { $$ = $1; } - | LexSetRegExp { $$ = NULL; } + | LexSetStatement LexSetRegExp { $$ = NULL; } ; StatementListItem @@ -1014,14 +1167,7 @@ StatementListItem | Declaration { $$ = $1; } ; /* }}} */ -/* 12.2 Declarations {{{ */ -BindingIdentifier - : Identifier { $$ = $1; } - ; - -// XXX: BindingPattern -/* }}} */ -/* 12.2.1 Let and Const Declarations {{{ */ +/* 13.3+ Let and Const Declarations {{{ */ LexicalDeclaration : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } ; @@ -1030,10 +1176,16 @@ LetOrConst : "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); } + : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } ; VariableDeclarationList_ @@ -1046,20 +1198,11 @@ VariableDeclarationList ; 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 @@ -1067,20 +1210,20 @@ 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; } @@ -1090,68 +1233,61 @@ IfStatement : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); } ; /* }}} */ - -/* 12.6 Iteration Statements {{{ */ +/* 13.7+ Iteration Statements {{{ */ IterationStatement - : DoWhileStatement { $$ = $1; } - | WhileStatement { $$ = $1; } - | ForStatement { $$ = $1; } - | ForInStatement { $$ = $1; } - ; -/* }}} */ -/* 12.6.1 The do-while Statement {{{ */ -DoWhileStatement : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); } - ; -/* }}} */ -/* 12.6.2 The while Statement {{{ */ -WhileStatement - : "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); } - ; -/* }}} */ -/* 12.6.3 The for Statement {{{ */ -ForStatement - : "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 Statement {{{ */ -ForInStatement - : "for" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); } + | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); } ; -ForInStatementInitialiser +ForInStatementInitializer : LeftHandSideExpression { $$ = $1; } - | LexSetRegExp "var" VariableDeclaration { $$ = $3; } + | LexSetRegExp Var_ VariableDeclaration { $$ = $3; } ; /* }}} */ +/* 13.8 The continue Statement {{{ */ +Continue + : "continue" LexNewLine + ; -/* 12.7 The continue Statement {{{ */ ContinueStatement - : "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" 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" 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); } ; @@ -1170,48 +1306,64 @@ CaseClausesOpt | { $$ = 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" 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 Function Definition {{{ */ +/* 14.1+ Function Definitions {{{ */ FunctionDeclaration : ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); } ; FunctionExpression - : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt LexPopIn ")" BRACE LexPushInOff FunctionBody LexPopIn "}" { $$ = CYNew CYFunctionExpression($2, $5, $10); } + : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); } ; FormalParameterList_ @@ -1241,20 +1393,113 @@ FunctionBody : StatementListOpt { $$ = $1; } ; /* }}} */ -/* 14 Program {{{ */ -Program - : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); } +/* 14.2 Arrow Function Definitions {{{ */ +ArrowFunction + : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); } + ; + +ArrowParameters + : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); } + | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); } ; -ProgramBody +ConciseBody + : AssignmentExpression { $$ = CYNew CYReturn($1); } + | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; } + ; +/* }}} */ +/* 14.3+ Method Definitions {{{ */ +/* }}} */ +/* 14.4+ Generator Function Definitions {{{ */ +/* }}} */ +/* 14.5+ Class Definitions {{{ */ +/* }}} */ + +/* 15.1 Scripts {{{ */ +Script + : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); } + ; + +ScriptBody : StatementList { $$ = $1; } ; -ProgramBodyOpt - : ProgramBody { $$ = $1; } - | { $$ = NULL; } +ScriptBodyOpt + : ScriptBody { $$ = $1; } + | LexSetStatement LexSetRegExp { $$ = NULL; } + ; +/* }}} */ +/* 15.2+ Modules {{{ */ +/* }}} */ +/* 15.2.2+ Imports {{{ */ +/* }}} */ +/* 15.2.3+ Exports {{{ */ +/* }}} */ + +@begin C +/* Cycript (C): Type Encoding {{{ */ +TypeSignifier + : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } + | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } + ; + +SuffixedType + : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } + | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); } + | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); } + | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); } + | TypeSignifier { $$ = $1; } + | { $$ = CYNew CYTypedIdentifier(@$); } + ; + +PrefixedType + : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + ; + +TypeQualifierLeft + : { $$ = NULL; } + | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); } + | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } + ; + +TypeQualifierRight + : PrefixedType { $$ = $1; } + | SuffixedType { $$ = $1; } + | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } + | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } + ; + +IntegerType + : "int" { $$ = CYNew CYTypeVariable("int"); } + | "unsigned" IntegerTypeOpt { $$ = CYNew CYTypeUnsigned($2); } + | "signed" IntegerTypeOpt { $$ = CYNew CYTypeSigned($2); } + | "long" IntegerTypeOpt { $$ = CYNew CYTypeLong($2); } + | "short" IntegerTypeOpt { $$ = CYNew CYTypeShort($2); } + ; + +IntegerTypeOpt + : IntegerType { $$ = $1; } + | { $$ = CYNew CYTypeVariable("int"); } + ; + +PrimitiveType + : IdentifierType { $$ = CYNew CYTypeVariable($1); } + | IntegerType { $$ = $1; } + | "void" { $$ = CYNew CYTypeVoid(); } + | "char" { $$ = CYNew CYTypeVariable("char"); } + | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); } + | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); } + ; + +TypedIdentifier + : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } + ; + +PrimaryExpression + : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } ; /* }}} */ +@end @begin ObjectiveC /* Cycript (Objective-C): @class Declaration {{{ */ @@ -1264,17 +1509,13 @@ ClassSuperOpt | { $$ = NULL; } ; -ClassField - : Expression Identifier ";" - ; - -ClassFieldList - : BRACE ClassFieldListOpt "}" { $$ = NULL; } +ClassFieldListOpt + : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); } + | LexSetRegExp { $$ = NULL; } ; -ClassFieldListOpt - : ClassFieldListOpt ClassField - | +ClassFields + : BRACE ClassFieldListOpt "}" { $$ = $2; } ; MessageScope @@ -1283,13 +1524,12 @@ MessageScope ; TypeOpt - : "(" Expression ")" { $$ = $2; } - | "(" LexSetRegExp "void" ")" { $$ = NULL; } - | { $$ = NULL; } + : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) error($3->location_, "unexpected identifier"); $$ = $3; } + | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } ; MessageParameter - : Word ":" TypeOpt Identifier { $$ = CYNew CYMessageParameter($1, $3, $4); } + : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); } ; MessageParameterList @@ -1303,7 +1543,7 @@ MessageParameterListOpt MessageParameters : MessageParameterList { $$ = $1; } - | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); } + | Word { $$ = CYNew CYMessageParameter($1, NULL); } ; ClassMessageDeclaration @@ -1312,7 +1552,6 @@ ClassMessageDeclaration ClassMessageDeclarationListOpt : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; } - | ClassMessageDeclarationListOpt Comment { $$ = $1; } | { $$ = NULL; } ; @@ -1321,11 +1560,6 @@ ClassName | "(" AssignmentExpression ")" { $$ = $2; } ; -ClassNameOpt - : ClassName { $$ = $1; } - | { $$ = NULL; } - ; - // XXX: this should be AssignmentExpressionNoRight ClassProtocols : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); } @@ -1341,12 +1575,8 @@ ClassProtocolListOpt | { $$ = NULL; } ; -ClassExpression - : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFieldList ClassMessageDeclarationListOpt LexPopIn "@end" { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); } - ; - ClassStatement - : ";@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFieldList ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); } + : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); } ; CategoryName @@ -1354,11 +1584,7 @@ CategoryName ; CategoryStatement - : ";@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); } - ; - -PrimaryExpression - : ClassExpression { $$ = $1; } + : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); } ; Statement__ @@ -1383,7 +1609,7 @@ SelectorCall_ ; SelectorCall - : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); } + : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); } ; SelectorList @@ -1392,8 +1618,8 @@ SelectorList ; MessageExpression - : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList LexPopIn "]" { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); } - | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList LexPopIn "]" { $$ = CYNew CYSendSuper($6); } + : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); } + | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); } ; SelectorExpression_ @@ -1412,24 +1638,53 @@ SelectorExpressionOpt PrimaryExpression : MessageExpression { $$ = $1; } - | "@selector" "(" LexPushInOff SelectorExpression LexPopIn ")" { $$ = CYNew CYSelector($4); } + | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } ; /* }}} */ -/* Cycript (Objective-C): @import Directive {{{ */ -PathName - : "/" PathName - | "." PathName - | Word PathName - | +@end + +/* Cycript: @import Directive {{{ */ +Module + : Module "." Word { $$ = CYNew CYModule($3, $1); } + | Word { $$ = CYNew CYModule($1); } ; -ImportPath - : "<" PathName ">" - | StringLiteral +Declaration__ + : "@import" Module { $$ = CYNew CYImport($2); } ; +/* }}} */ -StatementListItem - : "@import" ImportPath { $$ = CYNew CYImport(); } +@begin ObjectiveC +/* Cycript (Objective-C): Boxed Expressions {{{ */ +BoxableExpression + : NullLiteral { $$ = $1; } + | BooleanLiteral { $$ = $1; } + | NumericLiteral { $$ = $1; } + | StringLiteral { $$ = $1; } + | ArrayLiteral { $$ = $1; } + | ObjectLiteral { $$ = $1; } + | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; } + | "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 {{{ */ +PrimaryExpression + : "^" TypedIdentifier { if ($2->identifier_ != NULL) error($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else error($2->location_, "expected parameters"); } + ; +/* }}} */ +/* Cycript (Objective-C): Instance Literals {{{ */ +PrimaryExpression + : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); } ; /* }}} */ @end @@ -1446,17 +1701,46 @@ UnaryExpression_ MemberAccess : "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); } - | "->" Identifier { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); } + | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); } | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; } ; /* }}} */ -@end +/* Cycript (C): auto Compatibility {{{ */ +Var_ + : "auto" + ; +/* }}} */ +/* Cycript (C): Lambda Expressions {{{ */ +TypedParameterList_ + : "," TypedParameterList { $$ = $2; } + | { $$ = NULL; } + ; -/* YUI: Documentation Comments {{{ */ +TypedParameterList + : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } + ; + +TypedParameterListOpt + : TypedParameterList { $$ = $1; } + | { $$ = NULL; } + ; + +PrimaryExpression + : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); } + ; +/* }}} */ +/* Cycript (C): Type Definitions {{{ */ Statement__ - : Comment { $$ = $1; } + : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) error($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } ; /* }}} */ +/* Cycript (C): extern "C" {{{ */ +Statement__ + : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) error(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) error($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } + ; +/* }}} */ + +@end @begin E4X /* Lexer State {{{ */ @@ -1484,25 +1768,27 @@ LexSetXMLTag : { driver.SetCondition(CYDriver::XMLTagCondition); } ; /* }}} */ - +/* Virtual Tokens {{{ */ XMLWhitespaceOpt : XMLWhitespace | ; +/* }}} */ /* 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; } | XMLPI { $$ = $1; } ; /* }}} */ + /* 11.1 Primary Expressions {{{ */ PrimaryExpression : PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); } @@ -1523,7 +1809,7 @@ AttributeIdentifier PropertySelector_ : PropertySelector { $$ = $1; } - | "[" LexPushInOff Expression LexPopIn "]" { $$ = CYNew CYSelector($3); } + | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); } ; PropertySelector @@ -1546,15 +1832,15 @@ WildcardIdentifier : "*" { $$ = CYNew CYWildcard(); } ; /* }}} */ -/* 11.1.4 XML Initialiser {{{ */ +/* 11.1.4 XML Initializer {{{ */ XMLInitialiser : XMLMarkup { $$ = $1; } | XMLElement { $$ = $1; } ; XMLElement - : "<" LexPushInOff XMLTagContent LexPop LexPopIn "/>" - | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "" + : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn + | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "" LexPopIn ; XMLTagContent @@ -1601,11 +1887,12 @@ XMLElementContentOpt | ; /* }}} */ -/* 11.1.5 XMLList Initialiser {{{ */ +/* 11.1.5 XMLList Initializer {{{ */ XMLListInitialiser - : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop LexPopIn "" { $$ = CYNew CYXMLList($4); } + : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "" LexPopIn { $$ = CYNew CYXMLList($4); } ; /* }}} */ + /* 11.2 Left-Hand-Side Expressions {{{ */ PropertyIdentifier_ : Identifier { $$ = $1; } @@ -1629,51 +1916,63 @@ Statement__ /* }}} */ @end -/* ECMAScript5: Object Literal Trailing Comma {{{ */ -PropertyNameAndValueList_ - : "," { $$ = NULL; } +/* JavaScript FTL: Array Comprehensions {{{ */ +Comprehension + : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); } ; -/* }}} */ -/* JavaScript 1.7: Array Comprehensions {{{ */ -IfComprehension - : "if" "(" Expression ")" { $$ = CYNew CYIfComprehension($3); } +ComprehensionFor + : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); } + | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); } + ; +/* }}} */ +/* JavaScript FTL: for each {{{ */ +IterationStatement + : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); } + ; +/* }}} */ +/* JavaScript FTL: let Statements {{{ */ +LetStatement + : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); } ; -ForComprehension - : "for" "(" LexPushInOn Identifier LexPopIn "!in" Expression ")" { $$ = CYNew CYForInComprehension($4, $7); } - | "for" "each" "(" LexPushInOn Identifier LexPopIn "!in" Expression ")" { $$ = CYNew CYForEachInComprehension($5, $8); } +Statement__ + : LetStatement ; +/* }}} */ -ComprehensionList - : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; } +/* JavaScript FTW: Array Comprehensions {{{ */ +PrimaryExpression + : ArrayComprehension ; -ComprehensionListOpt - : ComprehensionList { $$ = $1; } - | IfComprehension { $$ = $1; } - | { $$ = NULL; } +ArrayComprehension + : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; } ; -PrimaryExpression - : "[" LexPushInOff AssignmentExpression ComprehensionList LexPopIn "]" { $$ = CYNew CYArrayComprehension($3, $4); } +Comprehension + : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); } ; -/* }}} */ -/* JavaScript 1.7: for each {{{ */ -ForInStatement - : "for" "each" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForEachIn($5, $8, $10); } + +ComprehensionTail + : { $$ = NULL; } + | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); } + | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); } ; -/* }}} */ -/* JavaScript 1.7: let Statements {{{ */ -LetStatement - : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); } + +ComprehensionFor + : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); } ; -Statement__ - : LetStatement +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; } @@ -1700,7 +1999,7 @@ RubyProcExpression ; PrimaryExpression - : "{" LexPushInOff RubyProcParameters StatementListOpt LexPopIn "}" { $$ = CYNew CYRubyProc($3, $4); } + : "{" LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); } ; CallExpression