X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/a2909cb767bc931614365686a15cb619191076b1..4b645e23d2abde4de1ced347750b070f89b685c3:/Parser.ypp.in?ds=sidebyside diff --git a/Parser.ypp.in b/Parser.ypp.in index 6acefbc..0d48316 100644 --- a/Parser.ypp.in +++ b/Parser.ypp.in @@ -45,13 +45,14 @@ %union { CYMember *access_; } %union { CYArgument *argument_; } %union { CYAssignment *assignment_; } +%union { CYBinding *binding_; } +%union { CYBindings *bindings_; } %union { CYBoolean *boolean_; } +%union { CYBraced *braced_; } %union { CYClause *clause_; } %union { cy::Syntax::Catch *catch_; } %union { CYClassTail *classTail_; } %union { CYComprehension *comprehension_; } -%union { CYDeclaration *declaration_; } -%union { CYDeclarations *declarations_; } %union { CYElement *element_; } %union { CYExpression *expression_; } %union { CYFalse *false_; } @@ -61,6 +62,7 @@ %union { CYForInInitializer *forin_; } %union { CYFunctionParameter *functionParameter_; } %union { CYIdentifier *identifier_; } +%union { CYImportSpecifier *import_; } %union { CYInfix *infix_; } %union { CYLiteral *literal_; } %union { CYMethod *method_; } @@ -70,7 +72,6 @@ %union { CYParenthetical *parenthetical_; } %union { CYProperty *property_; } %union { CYPropertyName *propertyName_; } -%union { CYRubyProc *rubyProc_; } %union { CYSpan *span_; } %union { CYStatement *statement_; } %union { CYString *string_; } @@ -80,16 +81,20 @@ %union { CYWord *word_; } @begin C +%union { CYTypeIntegral *integral_; } +%union { CYTypeStructField *structField_; } %union { CYTypeModifier *modifier_; } %union { CYTypeSpecifier *specifier_; } +%union { CYTypedFormal *typedFormal_; } %union { CYTypedIdentifier *typedIdentifier_; } %union { CYTypedParameter *typedParameter_; } @end @begin ObjectiveC +%union { CYObjCKeyValue *keyValue_; } +%union { CYImplementationField *implementationField_; } %union { CYMessage *message_; } %union { CYMessageParameter *messageParameter_; } -%union { CYImplementationField *implementationField_; } %union { CYProtocol *protocol_; } %union { CYSelectorPart *selector_; } @end @@ -114,25 +119,62 @@ int cylex(YYSTYPE *, CYLocation *, void *); %code { #undef yylex -_finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) { - if (driver.mark_ == CYMarkIgnore); - else if (driver.mark_ == CYMarkScript) { - driver.mark_ = CYMarkIgnore; - return cy::parser::token::MarkScript; - } else if (driver.mark_ == CYMarkModule) { - driver.mark_ = CYMarkIgnore; - return cy::parser::token::MarkModule; - } +typedef cy::parser::token tk; + +_finline int cylex_(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) { + driver.newline_ = false; + lex: YYSTYPE data; int token(cylex(&data, location, driver.scanner_)); *semantic = data.semantic_; + + switch (token) { + case tk::OpenBrace: + case tk::OpenBracket: + case tk::OpenParen: + driver.in_.push(false); + break; + + case tk::_in_: + if (driver.in_.top()) + token = tk::_in__; + break; + + case tk::CloseBrace: + case tk::CloseBracket: + case tk::CloseParen: + driver.in_.pop(); + break; + + + case tk::_yield_: + if (driver.yield_.top()) + token = tk::_yield__; + break; + + case tk::NewLine: + driver.newline_ = true; + goto lex; + break; + } + return token; } +#define yylex_(semantic, location, driver) ({ \ + int type; \ + if (driver.hold_ == cy::parser::empty_symbol) \ + type = yytranslate_(cylex_(semantic, location, driver)); \ + else { \ + type = driver.hold_; \ + driver.hold_ = cy::parser::empty_symbol; \ + } \ +type; }) + #define CYLEX() do if (yyla.empty()) { \ YYCDEBUG << "Mapping a token: "; \ - yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, driver)); \ + yyla.type = yylex_(&yyla.value, &yyla.location, driver); \ YY_SYMBOL_PRINT("Next token is", yyla); \ } while (false) @@ -142,14 +184,31 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY yyla.type = yytranslate_(token::to); \ } while (false) +#define CYHLD(location, token) do { \ + if (driver.hold_ != empty_symbol) \ + CYERR(location, "unexpected hold"); \ + driver.hold_ = yyla.type; \ + yyla.type = yytranslate_(token); \ +} while (false) + #define CYERR(location, message) do { \ error(location, message); \ YYABORT; \ } while (false) +#define CYEOK() do { \ + yyerrok; \ + driver.errors_.pop_back(); \ +} while (false) + #define CYNOT(location) \ CYERR(location, "unimplemented feature") +#define CYMPT(location) do { \ + if (!yyla.empty() && yyla.type_get() != yyeof_) \ + CYERR(location, "unexpected lookahead"); \ +} while (false) + } %name-prefix "cy" @@ -158,6 +217,15 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %initial-action { @$.begin.filename = @$.end.filename = &driver.filename_; + + switch (driver.mark_) { + case CYMarkScript: + driver.hold_ = yytranslate_(token::MarkScript); + break; + case CYMarkModule: + driver.hold_ = yytranslate_(token::MarkModule); + break; + } }; %locations @@ -192,7 +260,6 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token SlashRight "/>" %token LeftSlash "" -%token EqualRight_ "\n=>" %token Exclamation "!" %token ExclamationEqual "!=" %token ExclamationEqualEqual "!==" %token Hyphen "-" %token HyphenEqual "-=" %token HyphenHyphen "--" -%token HyphenHyphen_ "\n--" %token HyphenRight "->" %token Left "<" %token LeftEqual "<=" @@ -233,7 +298,6 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token Plus "+" %token PlusEqual "+=" %token PlusPlus "++" -%token PlusPlus_ "\n++" %token Right ">" %token RightEqual ">=" %token RightRight ">>" @@ -247,10 +311,12 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token Tilde "~" %token Colon ":" +%token ColonColon "::" %token Comma "," %token Question "?" %token SemiColon ";" %token NewLine "\n" +%token __ "" %token Comment @@ -258,11 +324,12 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token CloseParen ")" %token OpenBrace "{" -%token OpenBrace_ "\n{" -%token OpenBrace__ ";{" +%token OpenBrace_ ";{" +%token OpenBrace_let "let {" %token CloseBrace "}" %token OpenBracket "[" +%token OpenBracket_let "let [" %token CloseBracket "]" %token At_error_ "@error" @@ -275,6 +342,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _typedef_ "typedef" %token _unsigned_ "unsigned" %token _signed_ "signed" +%token _struct_ "struct" %token _extern_ "extern" @end @@ -300,6 +368,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _null_ "null" %token _true_ "true" +%token _as_ "as" %token _break_ "break" %token _case_ "case" %token _catch_ "catch" @@ -327,7 +396,6 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _instanceof_ "instanceof" %token _new_ "new" %token _return_ "return" -%token _return__ "!return" %token _super_ "super" %token _switch_ "switch" %token _target_ "target" @@ -357,19 +425,24 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _int_ "int" %token _interface_ "interface" %token _let_ "let" +%token _let__ "!let" %token _long_ "long" %token _native_ "native" %token _package_ "package" %token _private_ "private" %token _protected_ "protected" +%token ___proto___ "__proto__" %token _prototype_ "prototype" %token _public_ "public" +%token ___restrict_ "__restrict" +%token _restrict_ "restrict" %token _set_ "set" %token _short_ "short" %token _static_ "static" %token _synchronized_ "synchronized" %token _throws_ "throws" %token _transient_ "transient" +%token _typeid_ "typeid" %token _volatile_ "volatile" %token _yield_ "yield" %token _yield__ "!yield" @@ -385,9 +458,9 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _SEL_ "SEL" @end -%token _auto_ "auto" %token _each_ "each" %token _of_ "of" +%token _of__ "!of" @begin E4X %token _namespace_ "namespace" @@ -395,40 +468,43 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY @end %token AutoComplete -%token YieldStar +%token YieldStar "yield *" %token Identifier_ %token NumericLiteral %token StringLiteral -%token RegularExpressionLiteral +%token RegularExpressionLiteral_ %token NoSubstitutionTemplate %token TemplateHead %token TemplateMiddle %token TemplateTail +%type AccessExpression %type AdditiveExpression %type ArgumentList_ %type ArgumentList %type ArgumentListOpt %type Arguments %type ArrayComprehension +%type ArrayElement %type ArrayLiteral %type ArrowFunction %type ArrowParameters %type AssignmentExpression -%type AssignmentExpressionOpt %type BindingIdentifier %type BindingIdentifierOpt -%type BindingList_ -%type BindingList +%type BindingList_ +%type BindingList %type BitwiseANDExpression %type Block %type BlockStatement %type BooleanLiteral -%type BindingElement +%type BindingElement %type BitwiseORExpression %type BitwiseXORExpression +%type BracedExpression_ +%type BracedExpression %type BreakStatement %type BreakableStatement %type CallExpression_ @@ -453,10 +529,10 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type ConciseBody %type CoverParenthesizedExpressionAndArrowParameterList %type DebuggerStatement -%type Declaration__ %type Declaration_ %type Declaration %type DefaultClause +%type ElementList_ %type ElementList %type ElementListOpt %type ElseStatementOpt @@ -466,15 +542,19 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type ExpressionOpt %type ExpressionStatement_ %type ExpressionStatement +%type ExternC +%type ExternCStatement +%type ExternCStatementListOpt %type Finally -%type ForBinding +%type ForBinding %type ForDeclaration %type ForInStatementInitializer %type ForStatementInitializer -%type FormalParameter +%type FormalParameter %type FormalParameterList_ %type FormalParameterList %type FormalParameters +%type FromClause %type FunctionBody %type FunctionDeclaration %type FunctionExpression @@ -485,10 +565,22 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type GeneratorMethod %type HoistableDeclaration %type Identifier +%type IdentifierNoOf %type IdentifierType +%type IdentifierTypeNoOf +%type IdentifierTypeOpt %type IdentifierName %type IdentifierReference %type IfStatement +%type ImportClause +%type ImportDeclaration +%type ImportSpecifier +%type ImportedBinding +%type ImportedDefaultBinding +%type ImportsList_ +%type ImportsList +%type ImportsListOpt +%type IndirectExpression %type Initializer %type InitializerOpt %type IterationStatement @@ -498,7 +590,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type LeftHandSideAssignment %type LeftHandSideExpression %type LetOrConst -%type LexicalBinding +%type LexicalBinding %type LexicalDeclaration_ %type LexicalDeclaration %type Literal @@ -508,8 +600,16 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type MemberAccess %type MemberExpression %type MethodDefinition +%type ModuleBody +%type ModuleBodyOpt +%type ModuleItem +%type ModuleItemList +%type ModuleItemListOpt %type ModulePath +%type ModuleSpecifier %type MultiplicativeExpression +%type NameSpaceImport +%type NamedImports %type NewExpression %type NullLiteral %type ObjectLiteral @@ -520,10 +620,12 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type PropertyDefinitionList_ %type PropertyDefinitionList %type PropertyDefinitionListOpt -%type PropertySetParameterList +%type PropertySetParameterList +%type RegularExpressionLiteral +%type RegularExpressionSlash %type RelationalExpression %type ReturnStatement -%type RubyProcExpression +%type BracedParameter %type RubyProcParameterList_ %type RubyProcParameterList %type RubyProcParameters @@ -532,7 +634,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type ScriptBody %type ScriptBodyOpt %type ShiftExpression -%type SingleNameBinding +%type SingleNameBinding %type Statement__ %type Statement_ %type Statement @@ -547,33 +649,48 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type TemplateSpans %type ThrowStatement %type TryStatement +%type TypeDefinition %type UnaryExpression_ %type UnaryExpression -%type VariableDeclaration -%type VariableDeclarationList_ -%type VariableDeclarationList +%type VariableDeclaration +%type VariableDeclarationList_ +%type VariableDeclarationList %type VariableStatement_ %type VariableStatement %type WithStatement %type Word +%type WordNoUnary @begin ObjectiveC %type WordOpt @end %type YieldExpression @begin C -%type IntegerType -%type IntegerTypeOpt +%type IntegerType +%type IntegerTypeOpt %type PrefixedType %type PrimitiveType +%type StructFieldListOpt %type SuffixedType +%type SuffixedTypeOpt %type TypeSignifier +%type TypeSignifierNone +%type TypeSignifierOpt +%type ParameterTail %type TypeQualifierLeft +%type TypeQualifierLeftOpt %type TypeQualifierRight -%type TypedIdentifier -%type TypedParameterList_ -%type TypedParameterList -%type TypedParameterListOpt +%type TypeQualifierRightOpt +%type TypedIdentifierDefinition +%type TypedIdentifierEncoding +%type TypedIdentifierField +%type TypedIdentifierMaybe +%type TypedIdentifierNo +%type TypedIdentifierYes +%type TypedParameterList_ +%type TypedParameterList +%type TypedParameterListOpt +%type TypedParameters @end @begin ObjectiveC @@ -582,14 +699,16 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type CategoryStatement %type ClassSuperOpt %type ConditionalExpressionClassic -%type ImplementationFieldListOpt -%type ImplementationFields %type ClassMessageDeclaration %type ClassMessageDeclarationListOpt %type ClassProtocolListOpt %type ClassProtocols %type ClassProtocolsOpt +%type ImplementationFieldListOpt %type ImplementationStatement +%type KeyValuePairList_ +%type KeyValuePairList +%type KeyValuePairListOpt %type MessageExpression %type MessageParameter %type MessageParameters @@ -624,16 +743,16 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type AttributeIdentifier /* XXX: %type DefaultXMLNamespaceStatement */ %type PropertyIdentifier -%type XMLListInitialiser -%type XMLInitialiser +%type XMLListInitilizer +%type XMLInitilizer @end /* }}} */ /* Token Priorities {{{ */ -%nonassoc "" -%left "++" "--" "{" - %nonassoc "if" %nonassoc "else" + +%nonassoc ":" +%nonassoc "!yield" /* }}} */ %start Program @@ -654,21 +773,23 @@ LexPopIn: { driver.in_.pop(); }; LexPushReturnOn: { driver.return_.push(true); }; LexPopReturn: { driver.return_.pop(); }; +Return: "return"[return] { if (!driver.return_.top()) CYERR(@return, "invalid return"); }; LexPushSuperOn: { driver.super_.push(true); }; LexPushSuperOff: { driver.super_.push(false); }; LexPopSuper: { driver.super_.pop(); }; +Super: "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); }; LexPushYieldOn: { driver.yield_.push(true); }; LexPushYieldOff: { driver.yield_.push(false); }; LexPopYield: { driver.yield_.pop(); }; -LexSetRegExp - : { CYLEX(); if (yyla.type == yytranslate_(token::Slash)) { yyla.clear(); driver.SetRegEx(false); } else if (yyla.type == yytranslate_(token::SlashEqual)) { yyla.clear(); driver.SetRegEx(true); } } +LexNewLineOrOpt + : { CYLEX(); if (driver.newline_) { CYHLD(@$, tk::NewLine); } } ; -LexNewLine - : { if (!yyla.empty() && yyla.type_get() != yyeof_) CYERR(@$, "unexpected lookahead"); driver.next_ = true; } +LexNewLineOrNot + : { CYLEX(); CYHLD(@$, driver.newline_ ? tk::NewLine : tk::__); } ; LexNoStar @@ -676,7 +797,7 @@ LexNoStar ; LexNoBrace - : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); } + : { CYMAP(OpenBrace_, OpenBrace); } ; LexNoClass @@ -692,11 +813,6 @@ LexSetStatement ; /* }}} */ /* Virtual Tokens {{{ */ -BRACE - : "{" - | "\n{" - ; - Var_ : "var" ; @@ -704,30 +820,23 @@ Var_ /* 11.6 Names and Keywords {{{ */ IdentifierName - : Word { $$ = $1; } + : Word[pass] { $$ = $pass; } | "for" { $$ = CYNew CYWord("for"); } | "in" { $$ = CYNew CYWord("in"); } | "instanceof" { $$ = CYNew CYWord("instanceof"); } ; -NewLineOpt - : "\n" - | - ; - -Word - : Identifier { $$ = $1; } - | "auto" { $$ = CYNew CYWord("auto"); } +WordNoUnary + : IdentifierNoOf[pass] { $$ = $pass; } | "break" { $$ = CYNew CYWord("break"); } | "case" { $$ = CYNew CYWord("case"); } | "catch" { $$ = CYNew CYWord("catch"); } - | "class" { $$ = CYNew CYWord("class"); } + | "class" LexOf { $$ = 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"); } @@ -735,36 +844,35 @@ Word | "extends" { $$ = CYNew CYWord("extends"); } | "false" { $$ = CYNew CYWord("false"); } | "finally" { $$ = CYNew CYWord("finally"); } - | "function" { $$ = CYNew CYWord("function"); } + | "function" LexOf { $$ = CYNew CYWord("function"); } | "if" { $$ = CYNew CYWord("if"); } | "import" { $$ = CYNew CYWord("import"); } | "!in" { $$ = CYNew CYWord("in"); } - | "new" LexSetRegExp { $$ = CYNew CYWord("new"); } + | "!of" { $$ = CYNew CYWord("of"); } | "null" { $$ = CYNew CYWord("null"); } | "return" { $$ = CYNew CYWord("return"); } - | "!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"); } - | "yield" { $$ = CYNew CYIdentifier("yield"); } - - | Yield LexSetRegExp NewLineOpt { $$ = CYNew CYIdentifier("yield"); } + ; - // XXX: should be Identifier - | "let" { $$ = CYNew CYIdentifier("let"); } +Word + : WordNoUnary[pass] { $$ = $pass; } + | "delete" { $$ = CYNew CYWord("delete"); } + | "typeof" { $$ = CYNew CYWord("typeof"); } + | "void" { $$ = CYNew CYWord("void"); } + | "yield" { $$ = CYNew CYIdentifier("yield"); } ; @begin ObjectiveC WordOpt - : Word { $$ = $1; } + : Word[pass] { $$ = $pass; } | { $$ = NULL; } ; @end @@ -780,20 +888,44 @@ BooleanLiteral | "false" { $$ = CYNew CYFalse(); } ; /* }}} */ +/* 11.8.5 Regular Expression Literals {{{ */ +RegularExpressionSlash + : "/" { $$ = false; } + | "/=" { $$ = true; } + ; + +RegularExpressionLiteral + : RegularExpressionSlash[equals] { CYMPT(@$); driver.SetRegEx($equals); } RegularExpressionLiteral_[pass] { $$ = $pass; } + ; +/* }}} */ /* 11.9 Automatic Semicolon Insertion {{{ */ StrictSemi : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } ; +NewLineNot + : LexNewLineOrNot "" + ; + +NewLineOpt + : LexNewLineOrNot "\n" + | NewLineNot + ; + TerminatorSoft + : LexNewLineOrNot "\n" StrictSemi + | NewLineNot LexOf Terminator + ; + +TerminatorHard : ";" - | "\n" StrictSemi + | error { if (yyla.type_get() != yyeof_) CYERR(@error, "required semi-colon"); else CYEOK(); } StrictSemi ; Terminator : ";" - | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) { CYERR(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi + | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) CYERR(@error, "required semi-colon"); else CYEOK(); } StrictSemi ; TerminatorOpt @@ -804,28 +936,30 @@ TerminatorOpt /* 12.1 Identifiers {{{ */ IdentifierReference - : Identifier { $$ = CYNew CYVariable($1); } + : Identifier[pass] { $$ = CYNew CYVariable($pass); } | "yield" { $$ = CYNew CYVariable(CYNew CYIdentifier("yield")); } ; BindingIdentifier - : Identifier { $$ = $1; } - | "yield" { $$ = CYNew CYIdentifier("yield"); } + : LexOf IdentifierNoOf[pass] { $$ = $pass; } + | LexOf "!of" { $$ = CYNew CYIdentifier("of"); } + | LexOf "yield" { $$ = CYNew CYIdentifier("yield"); } ; BindingIdentifierOpt - : BindingIdentifier { $$ = $1; } - | { $$ = NULL; } + : BindingIdentifier[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } ; LabelIdentifier - : Identifier { $$ = $1; } + : Identifier[pass] { $$ = $pass; } | "yield" { $$ = CYNew CYIdentifier("yield"); } ; -IdentifierType - : Identifier_ { $$ = $1; } +IdentifierTypeNoOf + : Identifier_[pass] { $$ = $pass; } | "abstract" { $$ = CYNew CYIdentifier("abstract"); } + | "as" { $$ = CYNew CYIdentifier("as"); } | "await" { $$ = CYNew CYIdentifier("await"); } | "boolean" { $$ = CYNew CYIdentifier("boolean"); } | "byte" { $$ = CYNew CYIdentifier("byte"); } @@ -841,11 +975,13 @@ IdentifierType | "implements" { $$ = CYNew CYIdentifier("implements"); } | "Infinity" { $$ = CYNew CYIdentifier("Infinity"); } | "interface" { $$ = CYNew CYIdentifier("interface"); } + | "let" { $$ = CYNew CYIdentifier("let"); } + | "!let" LexBind LexOf { $$ = CYNew CYIdentifier("let"); } | "native" { $$ = CYNew CYIdentifier("native"); } - | "of" { $$ = CYNew CYIdentifier("of"); } | "package" { $$ = CYNew CYIdentifier("package"); } | "private" { $$ = CYNew CYIdentifier("private"); } | "protected" { $$ = CYNew CYIdentifier("protected"); } + | "__proto__" { $$ = CYNew CYIdentifier("__proto__"); } | "prototype" { $$ = CYNew CYIdentifier("prototype"); } | "public" { $$ = CYNew CYIdentifier("public"); } | "set" { $$ = CYNew CYIdentifier("set"); } @@ -853,6 +989,7 @@ IdentifierType | "target" { $$ = CYNew CYIdentifier("target"); } | "throws" { $$ = CYNew CYIdentifier("throws"); } | "transient" { $$ = CYNew CYIdentifier("transient"); } + | "typeid" { $$ = CYNew CYIdentifier("typeid"); } | "undefined" { $$ = CYNew CYIdentifier("undefined"); } @begin ObjectiveC | "bool" { $$ = CYNew CYIdentifier("bool"); } @@ -862,18 +999,28 @@ IdentifierType @end ; -Identifier - : IdentifierType +IdentifierType + : IdentifierTypeNoOf[pass] { $$ = $pass; } + | "of" { $$ = CYNew CYIdentifier("of"); } + ; + +IdentifierTypeOpt + : IdentifierType[pass] { $$ = $pass; } + | { $$ = NULL; } + ; + +IdentifierNoOf + : IdentifierTypeNoOf | "char" { $$ = CYNew CYIdentifier("char"); } | "int" { $$ = CYNew CYIdentifier("int"); } | "long" { $$ = CYNew CYIdentifier("long"); } + | "__restrict" { $$ = CYNew CYIdentifier("__restrict"); } + | "restrict" { $$ = CYNew CYIdentifier("restrict"); } | "short" { $$ = CYNew CYIdentifier("short"); } | "static" { $$ = CYNew CYIdentifier("static"); } | "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 @@ -883,93 +1030,108 @@ Identifier | "YES" { $$ = CYNew CYIdentifier("YES"); } @end ; + +Identifier + : IdentifierNoOf[pass] { $$ = $pass; } + | "of" { $$ = CYNew CYIdentifier("of"); } + | "!of" { $$ = CYNew CYIdentifier("of"); } + ; /* }}} */ /* 12.2 Primary Expression {{{ */ PrimaryExpression : "this" { $$ = CYNew CYThis(); } - | IdentifierReference { $$ = $1; } - | Literal { $$ = $1; } - | ArrayLiteral { $$ = $1; } - | ObjectLiteral { $$ = $1; } - | FunctionExpression { $$ = $1; } - | ClassExpression { $$ = $1; } - | GeneratorExpression { $$ = $1; } - | RegularExpressionLiteral { $$ = $1; } - | TemplateLiteral { $$ = $1; } - | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) CYERR(@1, "invalid parenthetical"); $$ = $1; } + | IdentifierReference[pass] { $$ = $pass; } + | Literal[pass] { $$ = $pass; } + | ArrayLiteral[pass] { $$ = $pass; } + | ObjectLiteral[pass] { $$ = $pass; } + | FunctionExpression[pass] { $$ = $pass; } + | ClassExpression[pass] { $$ = $pass; } + | GeneratorExpression[pass] { $$ = $pass; } + | RegularExpressionLiteral[pass] { $$ = $pass; } + | TemplateLiteral[pass] { $$ = $pass; } + | CoverParenthesizedExpressionAndArrowParameterList[cover] { if ($cover == NULL) CYERR(@cover, "invalid parenthetical"); $$ = $cover; } | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; } ; CoverParenthesizedExpressionAndArrowParameterList - : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); } - | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; } - | "(" LexPushInOff LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } - | "(" LexPushInOff Expression "," LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } + : "(" Expression[expression] ")" { $$ = CYNew CYParenthetical($expression); } + | "(" LexOf ")" { $$ = NULL; } + | "(" LexOf "..." BindingIdentifier ")" { CYNOT(@$); } + | "(" Expression "," LexOf "..." BindingIdentifier ")" { CYNOT(@$); } ; /* }}} */ /* 12.2.4 Literals {{{ */ Literal - : NullLiteral { $$ = $1; } - | BooleanLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - | StringLiteral { $$ = $1; } + : NullLiteral[pass] { $$ = $pass; } + | BooleanLiteral[pass] { $$ = $pass; } + | NumericLiteral[pass] { $$ = $pass; } + | StringLiteral[pass] { $$ = $pass; } ; /* }}} */ /* 12.2.5 Array Initializer {{{ */ ArrayLiteral - : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); } + : "[" ElementListOpt[elements] "]" { $$ = CYNew CYArray($elements); } + ; + +ArrayElement + : AssignmentExpression[value] { $$ = CYNew CYElementValue($value); } + | LexOf "..." AssignmentExpression[values] { $$ = CYNew CYElementSpread($values); } + ; + +ElementList_ + : "," ElementListOpt[elements] { $$ = $elements; } + | { $$ = NULL; } ; ElementList - : AssignmentExpressionOpt "," ElementListOpt { $$ = CYNew CYElementValue($1, $3); } - | LexSetRegExp "..." AssignmentExpression { $$ = CYNew CYElementSpread($3); } - | AssignmentExpression { $$ = CYNew CYElementValue($1, NULL); } + : ArrayElement[element] ElementList_[next] { $$ = $element; $$->SetNext($next); } + | LexOf "," ElementListOpt[next] { $$ = CYNew CYElementValue(NULL, $next); } ; ElementListOpt - : ElementList { $$ = $1; } - | LexSetRegExp { $$ = NULL; } + : ElementList[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } ; /* }}} */ /* 12.2.6 Object Initializer {{{ */ ObjectLiteral - : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); } + : "{" PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYObject($properties); } ; PropertyDefinitionList_ - : "," PropertyDefinitionListOpt { $$ = $2; } + : "," PropertyDefinitionListOpt[properties] { $$ = $properties; } | { $$ = NULL; } ; PropertyDefinitionList - : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; } + : PropertyDefinition[property] PropertyDefinitionList_[next] { $property->SetNext($next); $$ = $property; } ; PropertyDefinitionListOpt - : LexSetRegExp PropertyDefinitionList { $$ = $2; } - | LexSetRegExp { $$ = NULL; } + : PropertyDefinitionList[properties] { $$ = $properties; } + | { $$ = NULL; } ; PropertyDefinition - : IdentifierReference { $$ = CYNew CYPropertyValue($1->name_, $1); } - | CoverInitializedName { CYNOT(@$); } - | PropertyName ":" AssignmentExpression { $$ = CYNew CYPropertyValue($1, $3); } - | MethodDefinition { $$ = $1; } + : IdentifierReference[value] { $$ = CYNew CYPropertyValue($value->name_, $value); } + | CoverInitializedName[name] { CYNOT(@$); } + | PropertyName[name] ":" AssignmentExpression[value] { $$ = CYNew CYPropertyValue($name, $value); } + | MethodDefinition[pass] { $$ = $pass; } ; PropertyName - : LiteralPropertyName { $$ = $1; } - | ComputedPropertyName { $$ = $1; } + : LiteralPropertyName[pass] { $$ = $pass; } + | ComputedPropertyName[pass] { $$ = $pass; } ; LiteralPropertyName - : IdentifierName { $$ = $1; } - | StringLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } + : IdentifierName[pass] { $$ = $pass; } + | StringLiteral[pass] { $$ = $pass; } + | NumericLiteral[pass] { $$ = $pass; } ; ComputedPropertyName - : "[" AssignmentExpression "]" { $$ = CYNew CYComputed($2); } + : "[" AssignmentExpression[expression] "]" { $$ = CYNew CYComputed($expression); } ; CoverInitializedName @@ -977,45 +1139,45 @@ CoverInitializedName ; Initializer - : "=" AssignmentExpression { $$ = $2; } + : "=" AssignmentExpression[initializer] { $$ = $initializer; } ; InitializerOpt - : Initializer { $$ = $1; } + : Initializer[pass] { $$ = $pass; } | { $$ = NULL; } ; /* }}} */ /* 12.2.9 Template Literals {{{ */ TemplateLiteral - : NoSubstitutionTemplate { $$ = CYNew CYTemplate($1, NULL); } - | TemplateHead TemplateSpans { $$ = CYNew CYTemplate($1, $2); } + : NoSubstitutionTemplate[string] { $$ = CYNew CYTemplate($string, NULL); } + | TemplateHead[string] LexPushInOff TemplateSpans[spans] { $$ = CYNew CYTemplate($string, $spans); } ; TemplateSpans - : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); } - | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); } + : Expression[value] TemplateMiddle[string] TemplateSpans[spans] { $$ = CYNew CYSpan($value, $string, $spans); } + | Expression[value] TemplateTail[string] LexPopIn { $$ = CYNew CYSpan($value, $string, NULL); } ; /* }}} */ /* 12.3 Left-Hand-Side Expressions {{{ */ MemberAccess - : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); } - | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); } + : "[" Expression[property] "]" { $$ = CYNew CYDirectMember(NULL, $property); } + | "." IdentifierName[property] { $$ = CYNew CYDirectMember(NULL, CYNew CYString($property)); } | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; } | TemplateLiteral { CYNOT(@$); } ; MemberExpression - : LexSetRegExp PrimaryExpression { $$ = $2; } - | MemberExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } - | SuperProperty { $$ = $1; } + : PrimaryExpression[pass] { $$ = $pass; } + | MemberExpression[object] { driver.context_ = $object; } MemberAccess[member] { $member->SetLeft($object); $$ = $member; } + | SuperProperty[pass] { $$ = $pass; } | MetaProperty { CYNOT(@$); } - | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); } + | "new" MemberExpression[constructor] Arguments[arguments] { $$ = CYNew cy::Syntax::New($constructor, $arguments); } ; SuperProperty - : LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } "[" Expression "]" { $$ = CYNew CYSuperAccess($5); } - | LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } "." IdentifierName { $$ = CYNew CYSuperAccess(CYNew CYString($5)); } + : Super "[" Expression[property] "]" { $$ = CYNew CYSuperAccess($property); } + | Super "." IdentifierName[property] { $$ = CYNew CYSuperAccess(CYNew CYString($property)); } ; MetaProperty @@ -1023,332 +1185,338 @@ MetaProperty ; NewTarget - : LexSetRegExp "new" LexSetRegExp "." "target" + : "new" "." "target" ; NewExpression - : MemberExpression { $$ = $1; } - | LexSetRegExp "new" NewExpression { $$ = CYNew cy::Syntax::New($3, NULL); } + : MemberExpression[pass] { $$ = $pass; } + | "new" NewExpression[expression] { $$ = CYNew cy::Syntax::New($expression, NULL); } ; CallExpression_ - : MemberExpression { $$ = $1; } - | CallExpression { $$ = $1; } + : MemberExpression[pass] { $$ = $pass; } + | CallExpression[pass] { $$ = $pass; } ; CallExpression - : CallExpression_ Arguments { if (!$1->Eval()) $$ = CYNew CYCall($1, $2); else $$ = CYNew CYEval($2); } - | SuperCall { $$ = $1; } - | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } + : CallExpression_[function] Arguments[arguments] { if (!$function->Eval()) $$ = CYNew CYCall($function, $arguments); else $$ = CYNew CYEval($arguments); } + | SuperCall[pass] { $$ = $pass; } + | CallExpression[object] { driver.context_ = $object; } MemberAccess[member] { $member->SetLeft($object); $$ = $member; } ; SuperCall - : LexSetRegExp "super" { if (!driver.super_.top()) CYERR(@2, "invalid super"); } Arguments { $$ = CYNew CYSuperCall($4); } + : Super Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); } ; Arguments - : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; } + : "(" ArgumentListOpt[arguments] ")" { $$ = $arguments; } ; ArgumentList_ - : "," ArgumentList { $$ = $2; } + : "," ArgumentList[arguments] { $$ = $arguments; } | { $$ = NULL; } ; ArgumentList - : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); } - | LexSetRegExp "..." AssignmentExpression { CYNOT(@$); } + : AssignmentExpression[value] ArgumentList_[next] { $$ = CYNew CYArgument(NULL, $value, $next); } + | LexOf "..." AssignmentExpression { CYNOT(@$); } ; ArgumentListOpt - : ArgumentList { $$ = $1; } - | LexSetRegExp { $$ = NULL; } + : ArgumentList[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } + ; + +AccessExpression + : NewExpression[pass] { $$ = $pass; } + | CallExpression[pass] { $$ = $pass; } ; LeftHandSideExpression - : NewExpression { $$ = $1; } - | CallExpression { $$ = $1; } + : BracedExpression[pass] { $$ = $pass; } + | IndirectExpression[pass] { $$ = $pass; } ; /* }}} */ /* 12.4 Postfix Expressions {{{ */ PostfixExpression - : %prec "" LeftHandSideExpression { $$ = $1; } - | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); } - | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); } + : BracedExpression[pass] { $$ = $pass; } + | AccessExpression[lhs] LexNewLineOrOpt "++" { $$ = CYNew CYPostIncrement($lhs); } + | AccessExpression[lhs] LexNewLineOrOpt "--" { $$ = CYNew CYPostDecrement($lhs); } ; /* }}} */ /* 12.5 Unary Operators {{{ */ UnaryExpression_ - : "delete" UnaryExpression { $$ = CYNew CYDelete($2); } - | "void" UnaryExpression { $$ = CYNew CYVoid($2); } - | "typeof" UnaryExpression { $$ = CYNew CYTypeOf($2); } - | "++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } - | "\n++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } - | "--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } - | "\n--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } - | "+" UnaryExpression { $$ = CYNew CYAffirm($2); } - | "-" UnaryExpression { $$ = CYNew CYNegate($2); } - | "~" UnaryExpression { $$ = CYNew CYBitwiseNot($2); } - | "!" UnaryExpression { $$ = CYNew CYLogicalNot($2); } + : "delete" UnaryExpression[rhs] { $$ = CYNew CYDelete($rhs); } + | "void" UnaryExpression[rhs] { $$ = CYNew CYVoid($rhs); } + | "typeof" UnaryExpression[rhs] { $$ = CYNew CYTypeOf($rhs); } + | "++" UnaryExpression[rhs] { $$ = CYNew CYPreIncrement($rhs); } + | "--" UnaryExpression[rhs] { $$ = CYNew CYPreDecrement($rhs); } + | "+" UnaryExpression[rhs] { $$ = CYNew CYAffirm($rhs); } + | "-" UnaryExpression[rhs] { $$ = CYNew CYNegate($rhs); } + | "~" UnaryExpression[rhs] { $$ = CYNew CYBitwiseNot($rhs); } + | "!" UnaryExpression[rhs] { $$ = CYNew CYLogicalNot($rhs); } ; UnaryExpression - : %prec "" PostfixExpression { $$ = $1; } - | LexSetRegExp UnaryExpression_ { $$ = $2; } + : PostfixExpression[expression] { $$ = $expression; } + | UnaryExpression_[pass] { $$ = $pass; } ; /* }}} */ /* 12.6 Multiplicative Operators {{{ */ MultiplicativeExpression - : UnaryExpression { $$ = $1; } - | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); } - | MultiplicativeExpression "/" UnaryExpression { $$ = CYNew CYDivide($1, $3); } - | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); } + : UnaryExpression[pass] { $$ = $pass; } + | MultiplicativeExpression[lhs] "*" UnaryExpression[rhs] { $$ = CYNew CYMultiply($lhs, $rhs); } + | MultiplicativeExpression[lhs] "/" UnaryExpression[rhs] { $$ = CYNew CYDivide($lhs, $rhs); } + | MultiplicativeExpression[lhs] "%" UnaryExpression[rhs] { $$ = CYNew CYModulus($lhs, $rhs); } ; /* }}} */ /* 12.7 Additive Operators {{{ */ AdditiveExpression - : MultiplicativeExpression { $$ = $1; } - | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); } - | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); } + : MultiplicativeExpression[pass] { $$ = $pass; } + | AdditiveExpression[lhs] "+" MultiplicativeExpression[rhs] { $$ = CYNew CYAdd($lhs, $rhs); } + | AdditiveExpression[lhs] "-" MultiplicativeExpression[rhs] { $$ = CYNew CYSubtract($lhs, $rhs); } ; /* }}} */ /* 12.8 Bitwise Shift Operators {{{ */ ShiftExpression - : AdditiveExpression { $$ = $1; } - | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); } - | ShiftExpression ">>" AdditiveExpression { $$ = CYNew CYShiftRightSigned($1, $3); } - | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); } + : AdditiveExpression[pass] { $$ = $pass; } + | ShiftExpression[lhs] "<<" AdditiveExpression[rhs] { $$ = CYNew CYShiftLeft($lhs, $rhs); } + | ShiftExpression[lhs] ">>" AdditiveExpression[rhs] { $$ = CYNew CYShiftRightSigned($lhs, $rhs); } + | ShiftExpression[lhs] ">>>" AdditiveExpression[rhs] { $$ = CYNew CYShiftRightUnsigned($lhs, $rhs); } ; /* }}} */ /* 12.9 Relational Operators {{{ */ RelationalExpression - : 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); } + : ShiftExpression[pass] { $$ = $pass; } + | RelationalExpression[lhs] "<" ShiftExpression[rhs] { $$ = CYNew CYLess($lhs, $rhs); } + | RelationalExpression[lhs] ">" ShiftExpression[rhs] { $$ = CYNew CYGreater($lhs, $rhs); } + | RelationalExpression[lhs] "<=" ShiftExpression[rhs] { $$ = CYNew CYLessOrEqual($lhs, $rhs); } + | RelationalExpression[lhs] ">=" ShiftExpression[rhs] { $$ = CYNew CYGreaterOrEqual($lhs, $rhs); } + | RelationalExpression[lhs] "instanceof" ShiftExpression[rhs] { $$ = CYNew CYInstanceOf($lhs, $rhs); } + | RelationalExpression[lhs] "in" ShiftExpression[rhs] { $$ = CYNew CYIn($lhs, $rhs); } ; /* }}} */ /* 12.10 Equality Operators {{{ */ EqualityExpression - : RelationalExpression { $$ = $1; } - | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); } - | EqualityExpression "!=" RelationalExpression { $$ = CYNew CYNotEqual($1, $3); } - | EqualityExpression "===" RelationalExpression { $$ = CYNew CYIdentical($1, $3); } - | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); } + : RelationalExpression[pass] { $$ = $pass; } + | EqualityExpression[lhs] "==" RelationalExpression[rhs] { $$ = CYNew CYEqual($lhs, $rhs); } + | EqualityExpression[lhs] "!=" RelationalExpression[rhs] { $$ = CYNew CYNotEqual($lhs, $rhs); } + | EqualityExpression[lhs] "===" RelationalExpression[rhs] { $$ = CYNew CYIdentical($lhs, $rhs); } + | EqualityExpression[lhs] "!==" RelationalExpression[rhs] { $$ = CYNew CYNotIdentical($lhs, $rhs); } ; /* }}} */ /* 12.11 Binary Bitwise Operators {{{ */ BitwiseANDExpression - : EqualityExpression { $$ = $1; } - | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); } + : EqualityExpression[pass] { $$ = $pass; } + | BitwiseANDExpression[lhs] "&" EqualityExpression[rhs] { $$ = CYNew CYBitwiseAnd($lhs, $rhs); } ; BitwiseXORExpression - : BitwiseANDExpression { $$ = $1; } - | BitwiseXORExpression "^" BitwiseANDExpression { $$ = CYNew CYBitwiseXOr($1, $3); } + : BitwiseANDExpression[pass] { $$ = $pass; } + | BitwiseXORExpression[lhs] "^" BitwiseANDExpression[rhs] { $$ = CYNew CYBitwiseXOr($lhs, $rhs); } ; BitwiseORExpression - : BitwiseXORExpression { $$ = $1; } - | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); } + : BitwiseXORExpression[pass] { $$ = $pass; } + | BitwiseORExpression[lhs] "|" BitwiseXORExpression[rhs] { $$ = CYNew CYBitwiseOr($lhs, $rhs); } ; /* }}} */ /* 12.12 Binary Logical Operators {{{ */ LogicalANDExpression - : BitwiseORExpression { $$ = $1; } - | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); } + : BitwiseORExpression[pass] { $$ = $pass; } + | LogicalANDExpression[lhs] "&&" BitwiseORExpression[rhs] { $$ = CYNew CYLogicalAnd($lhs, $rhs); } ; LogicalORExpression - : LogicalANDExpression { $$ = $1; } - | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); } + : LogicalANDExpression[pass] { $$ = $pass; } + | LogicalORExpression[lhs] "||" LogicalANDExpression[rhs] { $$ = CYNew CYLogicalOr($lhs, $rhs); } ; /* }}} */ /* 12.13 Conditional Operator ( ? : ) {{{ */ @begin ObjectiveC ConditionalExpressionClassic - : LogicalORExpression { $$ = $1; } - | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpressionClassic { $$ = CYNew CYCondition($1, $4, $7); } + : LogicalORExpression[pass] { $$ = $pass; } + | LogicalORExpression[test] "?" LexPushInOff AssignmentExpression[true] ":" LexPopIn AssignmentExpressionClassic[false] { $$ = CYNew CYCondition($test, $true, $false); } ; @end ConditionalExpression - : LogicalORExpression { $$ = $1; } - | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); } + : LogicalORExpression[pass] { $$ = $pass; } + | LogicalORExpression[test] "?" LexPushInOff AssignmentExpression[true] ":" LexPopIn AssignmentExpression[false] { $$ = CYNew CYCondition($test, $true, $false); } ; /* }}} */ /* 12.14 Assignment Operators {{{ */ LeftHandSideAssignment - : LeftHandSideExpression "=" { $$ = CYNew CYAssign($1, NULL); } - | LeftHandSideExpression "*=" { $$ = CYNew CYMultiplyAssign($1, NULL); } - | LeftHandSideExpression "/=" { $$ = CYNew CYDivideAssign($1, NULL); } - | LeftHandSideExpression "%=" { $$ = CYNew CYModulusAssign($1, NULL); } - | LeftHandSideExpression "+=" { $$ = CYNew CYAddAssign($1, NULL); } - | LeftHandSideExpression "-=" { $$ = CYNew CYSubtractAssign($1, NULL); } - | LeftHandSideExpression "<<=" { $$ = CYNew CYShiftLeftAssign($1, NULL); } - | LeftHandSideExpression ">>=" { $$ = CYNew CYShiftRightSignedAssign($1, NULL); } - | LeftHandSideExpression ">>>=" { $$ = CYNew CYShiftRightUnsignedAssign($1, NULL); } - | LeftHandSideExpression "&=" { $$ = CYNew CYBitwiseAndAssign($1, NULL); } - | LeftHandSideExpression "^=" { $$ = CYNew CYBitwiseXOrAssign($1, NULL); } - | LeftHandSideExpression "|=" { $$ = CYNew CYBitwiseOrAssign($1, NULL); } + : LeftHandSideExpression[lhs] "=" { $$ = CYNew CYAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "*=" { $$ = CYNew CYMultiplyAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "/=" { $$ = CYNew CYDivideAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "%=" { $$ = CYNew CYModulusAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "+=" { $$ = CYNew CYAddAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "-=" { $$ = CYNew CYSubtractAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "<<=" { $$ = CYNew CYShiftLeftAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] ">>=" { $$ = CYNew CYShiftRightSignedAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] ">>>=" { $$ = CYNew CYShiftRightUnsignedAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "&=" { $$ = CYNew CYBitwiseAndAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "^=" { $$ = CYNew CYBitwiseXOrAssign($lhs, NULL); } + | LeftHandSideExpression[lhs] "|=" { $$ = CYNew CYBitwiseOrAssign($lhs, NULL); } ; @begin ObjectiveC AssignmentExpressionClassic - : ConditionalExpressionClassic { $$ = $1; } - | LeftHandSideAssignment AssignmentExpressionClassic { $1->SetRight($2); $$ = $1; } + : LexOf ConditionalExpressionClassic[pass] { $$ = $pass; } + | LexOf LeftHandSideAssignment[assignment] AssignmentExpressionClassic[rhs] { $assignment->SetRight($rhs); $$ = $assignment; } ; @end AssignmentExpression - : ConditionalExpression { $$ = $1; } - | LexSetRegExp YieldExpression { $$ = $2; } - | ArrowFunction { $$ = $1; } - | LeftHandSideAssignment AssignmentExpression { $1->SetRight($2); $$ = $1; } - ; - -AssignmentExpressionOpt - : AssignmentExpression { $$ = $1; } - | LexSetRegExp { $$ = NULL; } + : LexOf ConditionalExpression[pass] { $$ = $pass; } + | LexOf YieldExpression[pass] { $$ = $pass; } + | ArrowFunction[pass] { $$ = $pass; } + | LexOf LeftHandSideAssignment[assignment] AssignmentExpression[rhs] { $assignment->SetRight($rhs); $$ = $assignment; } ; /* }}} */ /* 12.15 Comma Operator ( , ) {{{ */ Expression - : AssignmentExpression { $$ = $1; } - | Expression "," AssignmentExpression { $$ = CYNew CYCompound($1, $3); } + : AssignmentExpression[pass] { $$ = $pass; } + | Expression[expression] "," AssignmentExpression[next] { $$ = CYNew CYCompound($expression, $next); } ; ExpressionOpt - : Expression { $$ = $1; } - | LexSetRegExp { $$ = NULL; } + : Expression[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } ; /* }}} */ /* 13 Statements and Declarations {{{ */ Statement__ - : BlockStatement { $$ = $1; } - | VariableStatement { $$ = $1; } - | EmptyStatement { $$ = $1; } - | IfStatement { $$ = $1; } - | BreakableStatement { $$ = $1; } - | ContinueStatement { $$ = $1; } - | BreakStatement { $$ = $1; } - | ReturnStatement { $$ = $1; } - | WithStatement { $$ = $1; } - | LabelledStatement { $$ = $1; } - | ThrowStatement { $$ = $1; } - | TryStatement { $$ = $1; } - | DebuggerStatement { $$ = $1; } + : BlockStatement[pass] { $$ = $pass; } + | VariableStatement[pass] { $$ = $pass; } + | EmptyStatement[pass] { $$ = $pass; } + | IfStatement[pass] { $$ = $pass; } + | BreakableStatement[pass] { $$ = $pass; } + | ContinueStatement[pass] { $$ = $pass; } + | BreakStatement[pass] { $$ = $pass; } + | ReturnStatement[pass] { $$ = $pass; } + | WithStatement[pass] { $$ = $pass; } + | LabelledStatement[pass] { $$ = $pass; } + | ThrowStatement[pass] { $$ = $pass; } + | TryStatement[pass] { $$ = $pass; } + | DebuggerStatement[pass] { $$ = $pass; } ; Statement_ - : LexSetRegExp Statement__ { $$ = $2; } - | ExpressionStatement { $$ = $1; } + : LexOf Statement__[pass] { $$ = $pass; } + | ExpressionStatement[pass] { $$ = $pass; } ; Statement - : LexSetStatement Statement_ { $$ = $2; } - ; - -Declaration__ - : HoistableDeclaration { $$ = $1; } - | ClassDeclaration { $$ = $1; } - | LexicalDeclaration { $$ = $1; } + : LexSetStatement LexLet Statement_[pass] { $$ = $pass; } ; Declaration_ - : LexSetRegExp Declaration__ { $$ = $2; } + : HoistableDeclaration[pass] { $$ = $pass; } + | ClassDeclaration[pass] { $$ = $pass; } ; Declaration - : LexSetStatement Declaration_ { $$ = $2; } + : LexSetStatement LexLet LexOf Declaration_[pass] { $$ = $pass; } + | LexSetStatement LexicalDeclaration[pass] { $$ = $pass; } ; HoistableDeclaration - : FunctionDeclaration { $$ = $1; } - | GeneratorDeclaration { $$ = $1; } + : FunctionDeclaration[pass] { $$ = $pass; } + | GeneratorDeclaration[pass] { $$ = $pass; } ; BreakableStatement - : IterationStatement { $$ = $1; } - | SwitchStatement { $$ = $1; } + : IterationStatement[pass] { $$ = $pass; } + | SwitchStatement[pass] { $$ = $pass; } ; /* }}} */ /* 13.2 Block {{{ */ BlockStatement - : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); } + : ";{" StatementListOpt[code] "}" { $$ = CYNew CYBlock($code); } ; Block - : BRACE StatementListOpt "}" { $$ = $2; } + : "{" StatementListOpt[code] "}" { $$ = $code; } ; StatementList - : StatementListItem StatementListOpt { $1->SetNext($2); $$ = $1; } + : StatementListItem[statement] StatementListOpt[next] { $$ = $statement; CYSetLast($$) = $next; } ; StatementListOpt - : StatementList { $$ = $1; } - | LexSetStatement LexSetRegExp { $$ = NULL; } + : StatementList[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf { $$ = NULL; } ; StatementListItem - : Statement { $$ = $1; } - | Declaration { $$ = $1; } + : Statement[pass] { $$ = $pass; } + | Declaration[pass] { $$ = $pass; } ; /* }}} */ /* 13.3 Let and Const Declarations {{{ */ LexicalDeclaration_ - : LetOrConst BindingList { $$ = CYNew CYLet($1, $2); } + : LetOrConst[constant] BindingList[bindings] { $$ = CYNew CYLexical($constant, $bindings); } ; LexicalDeclaration - : LexicalDeclaration_ Terminator { $$ = $1; } + : LexicalDeclaration_[statement] Terminator { $$ = $statement; } + ; + +LexLet + : { CYMAP(_let__, _let_); } + ; + +LexOf + : { CYMAP(_of__, _of_); } + ; + +LexBind + : { CYMAP(OpenBrace_let, OpenBrace); CYMAP(OpenBracket_let, OpenBracket); } ; LetOrConst - : "let" { $$ = false; } - | "const" { $$ = true; } + : LexLet LexOf "!let" LexBind LexOf { $$ = false; } + | LexLet LexOf "const" { $$ = true; } ; BindingList_ - : "," BindingList { $$ = $2; } + : "," LexBind BindingList[bindings] { $$ = $bindings; } | { $$ = NULL; } ; BindingList - : LexicalBinding BindingList_ { $$ = CYNew CYDeclarations($1, $2); } + : LexicalBinding[binding] BindingList_[next] { $$ = CYNew CYBindings($binding, $next); } ; LexicalBinding - : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } - | BindingPattern Initializer { CYNOT(@1); } + : BindingIdentifier[identifier] InitializerOpt[initializer] { $$ = CYNew CYBinding($identifier, $initializer); } + | LexOf BindingPattern Initializer { CYNOT(@$); } ; /* }}} */ /* 13.3.2 Variable Statement {{{ */ VariableStatement_ - : Var_ VariableDeclarationList { $$ = CYNew CYVar($2); } + : Var_ VariableDeclarationList[bindings] { $$ = CYNew CYVar($bindings); } ; VariableStatement - : VariableStatement_ Terminator { $$ = $1; } + : VariableStatement_[statement] Terminator { $$ = $statement; } ; VariableDeclarationList_ - : "," VariableDeclarationList { $$ = $2; } + : "," VariableDeclarationList[bindings] { $$ = $bindings; } | { $$ = NULL; } ; VariableDeclarationList - : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); } + : LexBind VariableDeclaration[binding] VariableDeclarationList_[next] { $$ = CYNew CYBindings($binding, $next); } ; VariableDeclaration - : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } - | BindingPattern Initializer { CYNOT(@1); } + : BindingIdentifier[identifier] InitializerOpt[initializer] { $$ = CYNew CYBinding($identifier, $initializer); } + | LexOf BindingPattern Initializer { CYNOT(@$); } ; /* }}} */ /* 13.3.3 Destructuring Binding Patterns {{{ */ @@ -1358,11 +1526,11 @@ BindingPattern ; ObjectBindingPattern - : BRACE BindingPropertyListOpt "}" + : "let {" BindingPropertyListOpt "}" ; ArrayBindingPattern - : "[" { CYNOT(@$); } + : "let [" BindingElementListOpt "]" ; BindingPropertyList_ @@ -1376,25 +1544,41 @@ BindingPropertyList BindingPropertyListOpt : BindingPropertyList - | + | LexOf + ; + +BindingElementList + : BindingElementOpt[element] "," BindingElementListOpt[next] + | BindingRestElement[element] + | BindingElement[element] + ; + +BindingElementListOpt + : BindingElementList[pass] + | LexBind LexOf ; BindingProperty : SingleNameBinding - | PropertyName ":" BindingElement + | LexOf PropertyName ":" BindingElement ; BindingElement - : SingleNameBinding { $$ = $1; } - | BindingPattern InitializerOpt { CYNOT(@$); } + : LexBind SingleNameBinding[pass] { $$ = $pass; } + | LexBind LexOf BindingPattern InitializerOpt[initializer] { CYNOT(@$); } + ; + +BindingElementOpt + : BindingElement[pass] + | LexBind LexOf ; SingleNameBinding - : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } + : BindingIdentifier[identifier] InitializerOpt[initializer] { $$ = CYNew CYBinding($identifier, $initializer); } ; BindingRestElement - : "..." BindingIdentifier + : LexBind LexOf "..." BindingIdentifier ; /* }}} */ /* 13.4 Empty Statement {{{ */ @@ -1404,151 +1588,136 @@ EmptyStatement /* }}} */ /* 13.5 Expression Statement {{{ */ ExpressionStatement_ - : Expression { $$ = CYNew CYExpress($1); } + : Expression[expression] { $$ = CYNew CYExpress($[expression]); } ExpressionStatement - : ExpressionStatement_ Terminator { $$ = $1; } + : ExpressionStatement_[statement] Terminator { $$ = $statement; } ; /* }}} */ /* 13.6 The if Statement {{{ */ ElseStatementOpt - : "else" Statement { $$ = $2; } + : "else" Statement[false] { $$ = $false; } | %prec "if" { $$ = NULL; } ; IfStatement - : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); } + : "if" "(" Expression[test] ")" Statement[true] ElseStatementOpt[false] { $$ = CYNew CYIf($test, $true, $false); } ; /* }}} */ /* 13.7 Iteration Statements {{{ */ IterationStatement - : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); } - | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); } - | "for" "(" LexPushInOn ForStatementInitializer LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $6, $8, $10); } - | "for" "(" LexPushInOn LexSetRegExp Var_ BindingIdentifier Initializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForInitialized(CYNew CYDeclaration($6, $7), $10, $12); } - | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); } - | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn AssignmentExpression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); } + : "do" Statement[code] "while" "(" Expression[test] ")" TerminatorOpt { $$ = CYNew CYDoWhile($test, $code); } + | "while" "(" Expression[test] ")" Statement[code] { $$ = CYNew CYWhile($test, $code); } + | "for" "(" LexPushInOn ForStatementInitializer[initializer] LexPopIn ExpressionOpt[test] ";" ExpressionOpt[increment] ")" Statement[code] { $$ = CYNew CYFor($initializer, $test, $increment, $code); } + | "for" "(" LexPushInOn LexLet LexOf Var_ LexBind BindingIdentifier[identifier] Initializer[initializer] "!in" LexPopIn Expression[iterable] ")" Statement[code] { $$ = CYNew CYForInitialized(CYNew CYBinding($identifier, $initializer), $iterable, $code); } + | "for" "(" LexPushInOn ForInStatementInitializer[initializer] "!in" LexPopIn Expression[iterable] ")" Statement[code] { $$ = CYNew CYForIn($initializer, $iterable, $code); } + | "for" "(" LexPushInOn ForInStatementInitializer[initializer] "of" LexPopIn AssignmentExpression[iterable] ")" Statement[code] { $$ = CYNew CYForOf($initializer, $iterable, $code); } ; ForStatementInitializer - : LexSetRegExp EmptyStatement { $$ = $2; } - | ExpressionStatement_ ";" { $$ = $1; } - | LexSetRegExp VariableStatement_ ";" { $$ = $2; } - | LexSetRegExp LexicalDeclaration_ ";" { $$ = $2; } + : LexLet LexOf EmptyStatement[pass] { $$ = $pass; } + | LexLet ExpressionStatement_[initializer] ";" { $$ = $initializer; } + | LexLet LexOf VariableStatement_[initializer] ";" { $$ = $initializer; } + | LexicalDeclaration_[initializer] ";" { $$ = $initializer; } ; ForInStatementInitializer - : LeftHandSideExpression { $$ = $1; } - | LexSetRegExp Var_ ForBinding { $$ = CYNew CYForVariable($3); } - | LexSetRegExp ForDeclaration { $$ = $2; } + : LexLet LexOf BracedExpression[pass] { $$ = $pass; } + | LexLet LexOf IndirectExpression[pass] { $$ = $pass; } + | LexLet LexOf Var_ LexBind ForBinding[binding] { $$ = CYNew CYForVariable($binding); } + | ForDeclaration[pass] { $$ = $pass; } ; ForDeclaration - : LetOrConst ForBinding { $$ = CYNew CYForLexical($1, $2); } + : LetOrConst[constant] ForBinding[binding] { $$ = CYNew CYForLexical($constant, $binding); } ; ForBinding - : BindingIdentifier { $$ = CYNew CYDeclaration($1, NULL); } - | BindingPattern { CYNOT(@1); } + : BindingIdentifier[identifier] { $$ = CYNew CYBinding($identifier, NULL); } + | LexOf BindingPattern { CYNOT(@$); } ; /* }}} */ /* 13.8 The continue Statement {{{ */ -Continue - : "continue" LexNewLine - ; - ContinueStatement - : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); } - | Continue Identifier Terminator { $$ = CYNew CYContinue($2); } + : "continue" TerminatorSoft { $$ = CYNew CYContinue(NULL); } + | "continue" NewLineNot LexOf Identifier[label] Terminator { $$ = CYNew CYContinue($label); } ; /* }}} */ /* 13.9 The break Statement {{{ */ -Break - : "break" LexNewLine - ; - BreakStatement - : Break TerminatorSoft { $$ = CYNew CYBreak(NULL); } - | Break Identifier Terminator { $$ = CYNew CYBreak($2); } + : "break" TerminatorSoft { $$ = CYNew CYBreak(NULL); } + | "break" NewLineNot LexOf Identifier[label] Terminator { $$ = CYNew CYBreak($label); } ; /* }}} */ /* 13.10 The return Statement {{{ */ -Return - : "!return" LexNewLine - ; - ReturnStatement - : Return LexSetRegExp TerminatorSoft { $$ = CYNew CYReturn(NULL); } - | Return Expression Terminator { $$ = CYNew CYReturn($2); } + : Return TerminatorSoft { $$ = CYNew CYReturn(NULL); } + | Return NewLineNot Expression[value] Terminator { $$ = CYNew CYReturn($value); } ; /* }}} */ /* 13.11 The with Statement {{{ */ WithStatement - : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); } + : "with" "(" Expression[scope] ")" Statement[code] { $$ = CYNew CYWith($scope, $code); } ; /* }}} */ /* 13.12 The switch Statement {{{ */ SwitchStatement - : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); } + : "switch" "(" Expression[value] ")" CaseBlock[clauses] { $$ = CYNew CYSwitch($value, $clauses); } ; CaseBlock - : BRACE CaseClausesOpt "}" { $$ = $2; } + : "{" CaseClausesOpt[clauses] "}" { $$ = $clauses; } ; CaseClause - : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); } + : "case" Expression[value] ":" StatementListOpt[code] { $$ = CYNew CYClause($value, $code); } ; CaseClausesOpt - : CaseClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } - | DefaultClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } + : CaseClause[clause] CaseClausesOpt[next] { $clause->SetNext($next); $$ = $clause; } + | DefaultClause[clause] CaseClausesOpt[next] { $clause->SetNext($next); $$ = $clause; } | { $$ = NULL; } ; // XXX: the standard makes certain you can only have one of these DefaultClause - : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); } + : "default" ":" StatementListOpt[code] { $$ = CYNew CYClause(NULL, $code); } ; /* }}} */ /* 13.13 Labelled Statements {{{ */ LabelledStatement - : LabelIdentifier ":" LabelledItem { $$ = CYNew CYLabel($1, $3); } + : LabelIdentifier[name] ":" LabelledItem[statement] { $$ = CYNew CYLabel($name, $statement); } ; LabelledItem - : Statement { $$ = $1; } - | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; } + : Statement[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf FunctionDeclaration[pass] { $$ = $pass; } ; /* }}} */ /* 13.14 The throw Statement {{{ */ -Throw - : "throw" LexNewLine - ; - ThrowStatement - : Throw LexSetRegExp TerminatorSoft { CYERR(@1, "throw without exception"); } - | Throw Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); } + : "throw"[throw] TerminatorSoft { CYERR(@throw, "throw without exception"); } + | "throw" NewLineNot Expression[value] Terminator { $$ = CYNew cy::Syntax::Throw($value); } ; /* }}} */ /* 13.15 The try Statement {{{ */ TryStatement - : "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); } + : "try" Block[code] Catch[catch] { $$ = CYNew cy::Syntax::Try($code, $catch, NULL); } + | "try" Block[code] Finally[finally] { $$ = CYNew cy::Syntax::Try($code, NULL, $finally); } + | "try" Block[code] Catch[catch] Finally[finally] { $$ = CYNew cy::Syntax::Try($code, $catch, $finally); } ; Catch - : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); } + : "catch" "(" LexBind CatchParameter[name] ")" Block[code] { $$ = CYNew cy::Syntax::Catch($name, $code); } ; Finally - : "finally" Block { $$ = CYNew CYFinally($2); } + : "finally" Block[code] { $$ = CYNew CYFinally($code); } ; CatchParameter - : BindingIdentifier { $$ = $1; } - | BindingPattern { CYNOT(@$); } + : BindingIdentifier[pass] { $$ = $pass; } + | LexOf BindingPattern { CYNOT(@$); } ; /* }}} */ /* 13.16 The debugger Statement {{{ */ @@ -1559,30 +1728,30 @@ DebuggerStatement /* 14.1 Function Definitions {{{ */ FunctionDeclaration - : ";function" BindingIdentifier "(" FormalParameters ")" BRACE LexPushSuperOff FunctionBody "}" LexPopSuper { $$ = CYNew CYFunctionStatement($2, $4, $8); } + : ";function" BindingIdentifier[name] "(" FormalParameters[parameters] ")" "{" LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionStatement($name, $parameters, $code); } ; FunctionExpression - : "function" BindingIdentifierOpt "(" LexPushInOff FormalParameters ")" LexPopIn BRACE LexPushSuperOff LexPushInOff FunctionBody "}" LexPopIn LexPopSuper { $$ = CYNew CYFunctionExpression($2, $5, $11); } + : "function" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" "{" LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionExpression($name, $parameters, $code); } ; StrictFormalParameters - : FormalParameters { $$ = $1; } + : FormalParameters[pass] { $$ = $pass; } ; FormalParameters - : { $$ = NULL; } + : LexBind LexOf { $$ = NULL; } | FormalParameterList ; FormalParameterList_ - : "," FormalParameterList { $$ = $2; } + : "," FormalParameterList[parameters] { $$ = $parameters; } | { $$ = NULL; } ; FormalParameterList : FunctionRestParameter { CYNOT(@$); } - | FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); } + | FormalParameter[binding] FormalParameterList_[next] { $$ = CYNew CYFunctionParameter($binding, $next); } ; FunctionRestParameter @@ -1590,90 +1759,87 @@ FunctionRestParameter ; FormalParameter - : BindingElement { $$ = $1; } + : BindingElement[pass] { $$ = $pass; } ; FunctionBody - : LexPushYieldOff FunctionStatementList LexPopYield { $$ = $2; } + : LexPushYieldOff FunctionStatementList[code] LexPopYield { $$ = $code; } ; FunctionStatementList - : LexPushReturnOn StatementListOpt LexPopReturn { $$ = $2; } + : LexPushReturnOn StatementListOpt[code] LexPopReturn { $$ = $code; } ; /* }}} */ /* 14.2 Arrow Function Definitions {{{ */ ArrowFunction - : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); } + : ArrowParameters[parameters] LexNewLineOrOpt "=>" LexNoBrace ConciseBody[code] { $$ = CYNew CYFatArrow($parameters, $code); } ; ArrowParameters - : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); } - | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) $$ = NULL; else { $$ = $1->expression_->Parameter(); if ($$ == NULL) CYERR(@1, "invalid parameter list"); } } + : BindingIdentifier[identifier] { $$ = CYNew CYFunctionParameter(CYNew CYBinding($identifier)); } + | LexOf CoverParenthesizedExpressionAndArrowParameterList[cover] { if ($cover == NULL) $$ = NULL; else { $$ = $cover->expression_->Parameter(); if ($$ == NULL) CYERR(@cover, "invalid parameter list"); } } ; ConciseBody - : AssignmentExpression { $$ = CYNew CYReturn($1); } - | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; } + : AssignmentExpression[expression] { $$ = CYNew CYReturn($expression); } + | LexOf ";{" FunctionBody[code] "}" { $$ = $code; } ; /* }}} */ /* 14.3 Method Definitions {{{ */ MethodDefinition - : PropertyName "(" StrictFormalParameters ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertyMethod($1, $3, $6); } - | GeneratorMethod { $$ = $1; } - | "get" PropertyName "(" ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertyGetter($2, $6); } - | "set" PropertyName "(" PropertySetParameterList ")" BRACE FunctionBody "}" { $$ = CYNew CYPropertySetter($2, CYNew CYFunctionParameter($4), $7); } + : PropertyName[name] "(" StrictFormalParameters[parameters] ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertyMethod($name, $parameters, $code); } + | GeneratorMethod[pass] { $$ = $pass; } + | "get" PropertyName[name] "(" ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertyGetter($name, $code); } + | "set" PropertyName[name] "(" PropertySetParameterList[parameter] ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertySetter($name, $parameter, $code); } ; PropertySetParameterList - : FormalParameter { $$ = $1; } + : FormalParameter[binding] { $$ = CYNew CYFunctionParameter($binding); } ; /* }}} */ /* 14.4 Generator Function Definitions {{{ */ GeneratorMethod - : "*" PropertyName "(" StrictFormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($2, $4, $7); */ } + : "*" PropertyName[name] "(" StrictFormalParameters[parameters] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($name, $parameters, $code); */ } ; GeneratorDeclaration - : ";function" "*" BindingIdentifier "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($3, $5, $8); */ } + : ";function" LexOf "*" BindingIdentifier[name] "(" FormalParameters[code] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($name, $parameters, $code); */ } ; GeneratorExpression - : "function" "*" BindingIdentifierOpt "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($3, $5, $8); */ } + : "function" LexOf "*" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($name, $parameters, $code); */ } ; GeneratorBody - : LexPushYieldOn FunctionStatementList LexPopYield { $$ = $2; } - ; - -Yield - : "!yield" LexNewLine LexNoStar + : LexPushYieldOn FunctionStatementList[code] LexPopYield { $$ = $code; } ; YieldExpression - : Yield LexSetRegExp NewLineOpt { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } - | Yield AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldValue($2); */ } - | Yield LexSetRegExp YieldStar AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($4); */ } + : "!yield" LexNewLineOrNot "\n" LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } + | "!yield" LexNewLineOrNot "" LexNoStar LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } %prec "!yield" + | "!yield" LexNewLineOrNot "" LexNoStar AssignmentExpression[value] { CYNOT(@$); /* $$ = CYNew CYYieldValue($value); */ } + | "!yield" LexNewLineOrNot "" LexNoStar LexOf "yield *" AssignmentExpression[generator] { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($generator); */ } ; /* }}} */ /* 14.5 Class Definitions {{{ */ ClassDeclaration - : ";class" BindingIdentifier ClassTail { $$ = CYNew CYClassStatement($2, $3); } + : ";class" BindingIdentifier[name] ClassTail[tail] { $$ = CYNew CYClassStatement($name, $tail); } ; ClassExpression - : "class" BindingIdentifierOpt ClassTail { $$ = CYNew CYClassExpression($2, $3); } + : "class" BindingIdentifierOpt[name] ClassTail[tail] { $$ = CYNew CYClassExpression($name, $tail); } ; ClassTail - : ClassHeritageOpt { driver.class_.push($1); } BRACE LexPushSuperOn ClassBodyOpt "}" LexPopSuper { driver.class_.pop(); $$ = $1; } + : ClassHeritageOpt[tail] { driver.class_.push($tail); } "{" LexPushSuperOn ClassBodyOpt "}" LexPopSuper { driver.class_.pop(); $$ = $tail; } ; ClassHeritage - : "extends" LeftHandSideExpression { $$ = CYNew CYClassTail($2); } + : "extends" AccessExpression[extends] { $$ = CYNew CYClassTail($extends); } ; ClassHeritageOpt - : ClassHeritage { $$ = $1; } + : ClassHeritage[pass] { $$ = $pass; } | { $$ = CYNew CYClassTail(NULL); } ; @@ -1696,110 +1862,110 @@ ClassElementListOpt ; ClassElement - : MethodDefinition { if (CYFunctionExpression *constructor = $1->Constructor()) driver.class_.top()->constructor_ = constructor; else driver.class_.top()->instance_->*$1; } - | "static" MethodDefinition { driver.class_.top()->static_->*$2; } + : MethodDefinition[method] { if (CYFunctionExpression *constructor = $method->Constructor()) driver.class_.top()->constructor_ = constructor; else driver.class_.top()->instance_->*$method; } + | "static" MethodDefinition[method] { driver.class_.top()->static_->*$method; } | ";" ; /* }}} */ /* 15.1 Scripts {{{ */ Script - : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); } + : ScriptBodyOpt[code] { driver.script_ = CYNew CYScript($code); } ; ScriptBody - : StatementList { $$ = $1; } + : StatementList[pass] { $$ = $pass; } ; ScriptBodyOpt - : ScriptBody { $$ = $1; } - | LexSetStatement LexSetRegExp { $$ = NULL; } + : ScriptBody[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf { $$ = NULL; } ; /* }}} */ /* 15.2 Modules {{{ */ Module - : ModuleBodyOpt + : ModuleBodyOpt[code] { driver.script_ = CYNew CYScript($code); } ; ModuleBody - : ModuleItemList + : ModuleItemList[pass] { $$ = $pass; } ; ModuleBodyOpt - : ModuleBody - | + : ModuleBody[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf { $$ = NULL; } ; ModuleItemList - : ModuleItemListOpt ModuleItem + : ModuleItem[statement] ModuleItemListOpt[next] { $$ = $statement; CYSetLast($$) = $next; } ; ModuleItemListOpt - : ModuleItemList - | + : ModuleItemList[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf { $$ = NULL; } ; ModuleItem - : LexSetStatement LexSetRegExp ImportDeclaration - | LexSetStatement LexSetRegExp ExportDeclaration - | StatementListItem + : LexSetStatement LexLet LexOf ImportDeclaration[pass] { $$ = $pass; } + | LexSetStatement LexLet LexOf ExportDeclaration { CYNOT(@$); } + | StatementListItem[pass] { $$ = $pass; } ; /* }}} */ /* 15.2.2 Imports {{{ */ ImportDeclaration - : "import" ImportClause FromClause Terminator - | "import" ModuleSpecifier Terminator + : "import" ImportClause[specifiers] FromClause[module] Terminator { $$ = CYNew CYImportDeclaration($specifiers, $module); } + | "import" LexOf ModuleSpecifier[module] Terminator { $$ = CYNew CYImportDeclaration(NULL, $module); } ; ImportClause - : ImportedDefaultBinding - | NameSpaceImport - | NamedImports - | ImportedDefaultBinding "," NameSpaceImport - | ImportedDefaultBinding "," NamedImports + : ImportedDefaultBinding[default] { $$ = $default; } + | LexOf NameSpaceImport[pass] { $$ = $pass; } + | LexOf NamedImports[pass] { $$ = $pass; } + | ImportedDefaultBinding[default] "," NameSpaceImport[next] { $$ = $default; CYSetLast($$) = $next; } + | ImportedDefaultBinding[default] "," NamedImports[next] { $$ = $default; CYSetLast($$) = $next; } ; ImportedDefaultBinding - : ImportedBinding + : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(CYNew CYIdentifier("default"), $binding); } ; NameSpaceImport - : "*" "as" ImportedBinding + : "*" "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(NULL, $binding); } ; NamedImports - : BRACE ImportsListOpt "}" + : "{" ImportsListOpt[pass] "}" { $$ = $pass; } ; FromClause - : "from" ModuleSpecifier + : "from" ModuleSpecifier[pass] { $$ = $pass; } ; ImportsList_ - : "," ImportsListOpt - | + : "," ImportsListOpt[pass] { $$ = $pass; } + | { $$ = NULL; } ; ImportsList - : ImportSpecifier ImportsList_ + : ImportSpecifier[import] ImportsList_[next] { $$ = $import; CYSetLast($$) = $next; } ; ImportsListOpt - : ImportsList - | + : ImportsList[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } ; ImportSpecifier - : ImportedBinding - | IdentifierName "as" ImportedBinding + : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($binding, $binding); } + | LexOf IdentifierName[name] "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($name, $binding); } ; ModuleSpecifier - : StringLiteral + : StringLiteral[pass] { $$ = $pass; } ; ImportedBinding - : BindingIdentifier + : BindingIdentifier[pass] { $$ = $pass; } ; /* }}} */ /* 15.2.3 Exports {{{ */ @@ -1808,13 +1974,13 @@ ExportDeclaration_ | ExportClause FromClause Terminator | ExportClause Terminator | VariableStatement - | "default" LexSetStatement LexSetRegExp HoistableDeclaration - | "default" LexSetStatement LexSetRegExp ClassDeclaration + | "default" LexSetStatement LexOf HoistableDeclaration + | "default" LexSetStatement LexOf ClassDeclaration | "default" LexSetStatement AssignmentExpression Terminator ; ExportDeclaration - : "export" LexSetStatement LexSetRegExp ExportDeclaration_ + : "export" LexSetStatement LexLet LexOf ExportDeclaration_ | "export" Declaration ; @@ -1845,64 +2011,139 @@ ExportSpecifier @begin C /* Cycript (C): Type Encoding {{{ */ TypeSignifier - : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } - | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } + : IdentifierType[identifier] { $$ = CYNew CYTypedIdentifier(@identifier, $identifier); } + | "(" "*" TypeQualifierRightOpt[typed] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + ; + +TypeSignifierNone + : { $$ = CYNew CYTypedIdentifier(@$); } + ; + +TypeSignifierOpt + : TypeSignifier[pass] { $$ = $pass; } + | TypeSignifierNone[pass] { $$ = $pass; } + ; + +Restrict + : "__restrict" + | "restrict" + ; + +RestrictOpt + : Restrict + | + ; + +ParameterModifier + : "throw" "(" ")" + ; + +ParameterModifierOpt + : ParameterModifier + | + ; + +ParameterTail + : TypedParameterListOpt[formal] ")" ParameterModifierOpt { $$ = CYNew CYTypeFunctionWith($formal->variadic_, $formal->parameters_); } ; 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(@$); } + : SuffixedTypeOpt[typed] "[" RestrictOpt NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); } + | "(" "^" TypeQualifierRightOpt[typed] ")" "(" TypedParameters[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeBlockWith($parameters, $$->modifier_); } + | TypeSignifier[typed] "(" ParameterTail[modifier] { $$ = $typed; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + | "("[parenthesis] ParameterTail[modifier] { $$ = CYNew CYTypedIdentifier(@parenthesis); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + ; + +SuffixedTypeOpt + : SuffixedType[pass] { $$ = $pass; } + | TypeSignifierOpt[pass] { $$ = $pass; } ; PrefixedType - : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + : "*" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } ; TypeQualifierLeft - : { $$ = NULL; } - | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); } - | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } + : "const" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeConstant(); } + | "volatile" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeVolatile(); } + ; + +TypeQualifierLeftOpt + : TypeQualifierLeft[pass] { $$ = $pass; } + | { $$ = NULL; } ; TypeQualifierRight - : PrefixedType { $$ = $1; } - | SuffixedType { $$ = $1; } - | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } - | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } + : SuffixedType[pass] { $$ = $pass; } + | PrefixedType[pass] { $$ = $pass; } + | "const" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } + | "volatile" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } + | Restrict TypeQualifierRightOpt[typed] { $$ = $typed; } + ; + +TypeQualifierRightOpt + : TypeQualifierRight[pass] { $$ = $pass; } + | TypeSignifierOpt[pass] { $$ = $pass; } ; 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); } + : "int" { $$ = CYNew CYTypeIntegral(CYTypeNeutral); } + | "unsigned" IntegerTypeOpt[integral] { $$ = $integral->Unsigned(); if ($$ == NULL) CYERR(@1, "incompatible unsigned"); } + | "signed" IntegerTypeOpt[integral] { $$ = $integral->Signed(); if ($$ == NULL) CYERR(@1, "incompatible signed"); } + | "long" IntegerTypeOpt[integral] { $$ = $integral->Long(); if ($$ == NULL) CYERR(@1, "incompatible long"); } + | "short" IntegerTypeOpt[integral] { $$ = $integral->Short(); if ($$ == NULL) CYERR(@1, "incompatible short"); } ; IntegerTypeOpt - : IntegerType { $$ = $1; } - | { $$ = CYNew CYTypeVariable("int"); } + : IntegerType[pass] { $$ = $pass; } + | { $$ = CYNew CYTypeIntegral(CYTypeNeutral); } + ; + +StructFieldListOpt + : TypedIdentifierField[typed] ";" StructFieldListOpt[next] { $$ = CYNew CYTypeStructField($typed, $next); } + | { $$ = NULL; } ; 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")); } + : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); } + | IntegerType[pass] { $$ = $pass; } + | "char" { $$ = CYNew CYTypeCharacter(CYTypeNeutral); } + | "signed" "char" { $$ = CYNew CYTypeCharacter(CYTypeSigned); } + | "unsigned" "char" { $$ = CYNew CYTypeCharacter(CYTypeUnsigned); } + | "struct" IdentifierType[name] { $$ = CYNew CYTypeReference($name); } + ; + +TypedIdentifierMaybe + : TypeQualifierLeft[modifier] "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + | "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); } + | TypeQualifierLeftOpt[modifier] PrimitiveType[specifier] TypeQualifierRightOpt[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + ; + +TypedIdentifierYes + : TypedIdentifierMaybe[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; } + ; + +TypedIdentifierNo + : TypedIdentifierMaybe[typed] { if ($typed->identifier_ != NULL) CYERR($typed->location_, "unexpected identifier"); $$ = $typed; } ; -TypedIdentifier - : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } +TypedIdentifierField + : TypedIdentifierYes[pass] { $$ = $pass; } + | TypeQualifierLeftOpt[modifier] "struct" "{" StructFieldListOpt[fields] "}" TypeQualifierRightOpt[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; $$->specifier_ = CYNew CYTypeStruct(NULL, CYNew CYStructTail($fields)); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + ; + +TypedIdentifierEncoding + : TypedIdentifierNo[pass] { $$ = $pass; } + | TypeQualifierLeftOpt[modifier] "struct" "{" StructFieldListOpt[fields] "}" TypeQualifierRightOpt[typed] { if ($typed->identifier_ != NULL) CYERR($typed->location_, "unexpected identifier"); $$ = $typed; $$->specifier_ = CYNew CYTypeStruct(NULL, CYNew CYStructTail($fields)); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + ; + +TypedIdentifierDefinition + : TypedIdentifierYes[pass] { $$ = $pass; } + | TypeQualifierLeftOpt[modifier] "struct" IdentifierTypeOpt[name] "{" StructFieldListOpt[fields] "}" TypeQualifierRightOpt[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); $$ = $typed; $$->specifier_ = CYNew CYTypeStruct($name, CYNew CYStructTail($fields)); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } ; PrimaryExpression - : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } + : "@encode" "(" TypedIdentifierEncoding[typed] ")" { $$ = CYNew CYEncodedType($typed); } ; /* }}} */ @end @@ -1911,17 +2152,13 @@ PrimaryExpression /* Cycript (Objective-C): @class Declaration {{{ */ ClassSuperOpt /* XXX: why the hell did I choose MemberExpression? */ - : ":" LexSetRegExp MemberExpression { $$ = $3; } + : ":" MemberExpression[extends] { $$ = $extends; } | { $$ = NULL; } ; ImplementationFieldListOpt - : TypedIdentifier ";" ImplementationFieldListOpt { $$ = CYNew CYImplementationField($1, $3); } - | LexSetRegExp { $$ = NULL; } - ; - -ImplementationFields - : BRACE ImplementationFieldListOpt "}" { $$ = $2; } + : TypedIdentifierField[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $next); } + | { $$ = NULL; } ; MessageScope @@ -1930,54 +2167,54 @@ MessageScope ; TypeOpt - : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) CYERR($3->location_, "unexpected identifier"); $$ = $3; } + : "(" TypedIdentifierNo[type] ")" { $$ = $type; } | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } ; MessageParameter - : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); } + : Word[tag] ":" TypeOpt[type] BindingIdentifier[identifier] { $type->identifier_ = $identifier; $$ = CYNew CYMessageParameter($tag, $type); } ; MessageParameterList - : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; } + : MessageParameter[parameter] MessageParameterListOpt[next] { $parameter->SetNext($next); $$ = $parameter; } ; MessageParameterListOpt - : MessageParameterList { $$ = $1; } - | { $$ = NULL; } + : MessageParameterList[pass] { $$ = $pass; } + | TypedParameterList_[formal] { if ($formal->variadic_) CYERR(@$, "unsupported variadic"); /*XXX*/ if ($formal->parameters_ != NULL) CYERR(@$, "temporarily unsupported"); $$ = NULL; } ; MessageParameters - : MessageParameterList { $$ = $1; } - | Word { $$ = CYNew CYMessageParameter($1, NULL); } + : MessageParameterList[pass] { $$ = $pass; } + | Word[tag] { $$ = CYNew CYMessageParameter($tag, NULL); } ; ClassMessageDeclaration - : MessageScope TypeOpt MessageParameters BRACE LexPushSuperOn FunctionBody "}" LexPopSuper { $$ = CYNew CYMessage($1, $2, $3, $6); } + : MessageScope[instance] TypeOpt[type] MessageParameters[parameters] "{" LexPushSuperOn FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYMessage($instance, $type, $parameters, $code); } ; ClassMessageDeclarationListOpt - : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; } + : ClassMessageDeclarationListOpt[next] ClassMessageDeclaration[message] { $message->SetNext($next); $$ = $message; } | { $$ = NULL; } ; // XXX: this should be AssignmentExpressionNoRight ClassProtocols - : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); } + : ShiftExpression[name] ClassProtocolsOpt[next] { $$ = CYNew CYProtocol($name, $next); } ; ClassProtocolsOpt - : "," ClassProtocols { $$ = $2; } + : "," ClassProtocols[protocols] { $$ = $protocols; } | { $$ = NULL; } ; ClassProtocolListOpt - : "<" ClassProtocols ">" { $$ = $2; } + : "<" ClassProtocols[protocols] ">" { $$ = $protocols; } | { $$ = NULL; } ; ImplementationStatement - : "@implementation" Identifier ClassSuperOpt ClassProtocolListOpt ImplementationFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYImplementation($2, $3, $4, $5, $6); } + : "@implementation" Identifier[name] ClassSuperOpt[extends] ClassProtocolListOpt[protocols] "{" ImplementationFieldListOpt[fields] "}" ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYImplementation($name, $extends, $protocols, $fields, $messages); } ; CategoryName @@ -1985,92 +2222,106 @@ CategoryName ; CategoryStatement - : "@implementation" Identifier CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); } + : "@implementation" Identifier[name] CategoryName ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYCategory($name, $messages); } ; Statement__ - : ImplementationStatement { $$ = $1; } - | CategoryStatement { $$ = $1; } + : ImplementationStatement[pass] { $$ = $pass; } + | CategoryStatement[pass] { $$ = $pass; } ; /* }}} */ /* Cycript (Objective-C): Send Message {{{ */ VariadicCall - : "," AssignmentExpressionClassic VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); } + : "," AssignmentExpressionClassic[value] VariadicCall[next] { $$ = CYNew CYArgument(NULL, $value, $next); } | { $$ = NULL; } ; SelectorWordOpt - : WordOpt { driver.contexts_.back().words_.push_back($1); } { $$ = $1; } + : WordOpt[name] { driver.contexts_.back().words_.push_back($name); } { $$ = $name; } | AutoComplete { driver.mode_ = CYDriver::AutoMessage; YYACCEPT; } ; SelectorCall_ - : SelectorCall { $$ = $1; } - | VariadicCall { $$ = $1; } + : SelectorCall[pass] { $$ = $pass; } + | VariadicCall[pass] { $$ = $pass; } ; SelectorCall - : SelectorWordOpt ":" AssignmentExpressionClassic SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); } + : SelectorWordOpt[name] ":" AssignmentExpressionClassic[value] SelectorCall_[next] { $$ = CYNew CYArgument($name ?: CYNew CYWord(""), $value, $next); } ; SelectorList - : SelectorCall { $$ = $1; } - | Word { $$ = CYNew CYArgument($1, NULL); } + : SelectorCall[pass] { $$ = $pass; } + | Word[name] { $$ = CYNew CYArgument($name, NULL); } ; MessageExpression - : "[" LexPushInOff AssignmentExpressionClassic { 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); } + : "[" AssignmentExpressionClassic[self] { driver.contexts_.push_back($self); } SelectorList[arguments] "]" { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($self, $arguments); } + | "[" LexOf "super" { driver.context_ = NULL; } SelectorList[arguments] "]" { $$ = CYNew CYSendSuper($arguments); } ; SelectorExpression_ - : WordOpt ":" SelectorExpressionOpt { $$ = CYNew CYSelectorPart($1, true, $3); } + : WordOpt[name] ":" SelectorExpressionOpt[next] { $$ = CYNew CYSelectorPart($name, true, $next); } ; SelectorExpression - : SelectorExpression_ { $$ = $1; } - | Word { $$ = CYNew CYSelectorPart($1, false, NULL); } + : SelectorExpression_[pass] { $$ = $pass; } + | Word[name] { $$ = CYNew CYSelectorPart($name, false, NULL); } ; SelectorExpressionOpt - : SelectorExpression_ { $$ = $1; } + : SelectorExpression_[pass] { $$ = $pass; } | { $$ = NULL; } ; PrimaryExpression - : MessageExpression { $$ = $1; } - | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } + : MessageExpression[pass] { $$ = $pass; } + | "@selector" "(" SelectorExpression[parts] ")" { $$ = CYNew CYSelector($parts); } ; /* }}} */ @end /* Cycript: @import Directive {{{ */ ModulePath - : ModulePath "." Word { $$ = CYNew CYModule($3, $1); } - | Word { $$ = CYNew CYModule($1); } + : ModulePath[next] "." Word[part] { $$ = CYNew CYModule($part, $next); } + | Word[part] { $$ = CYNew CYModule($part); } ; -Declaration__ - : "@import" ModulePath { $$ = CYNew CYImport($2); } +Declaration_ + : "@import" ModulePath[path] { $$ = CYNew CYImport($path); } ; /* }}} */ @begin ObjectiveC /* Cycript (Objective-C): Boxed Expressions {{{ */ BoxableExpression - : NullLiteral { $$ = $1; } - | BooleanLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - | StringLiteral { $$ = $1; } - | ArrayLiteral { $$ = $1; } - | ObjectLiteral { $$ = $1; } - | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; } + : NullLiteral[pass] { $$ = $pass; } + | BooleanLiteral[pass] { $$ = $pass; } + | NumericLiteral[pass] { $$ = $pass; } + | StringLiteral[pass] { $$ = $pass; } + | CoverParenthesizedExpressionAndArrowParameterList[pass] { $$ = $pass; } | "YES" { $$ = CYNew CYTrue(); } | "NO" { $$ = CYNew CYFalse(); } ; +KeyValuePairList_ + : "," KeyValuePairListOpt[next] { $$ = $next; } + | { $$ = NULL; } + +KeyValuePairList + : AssignmentExpression[key] ":" AssignmentExpression[value] KeyValuePairList_[next] { $$ = CYNew CYObjCKeyValue($key, $value, $next); } + ; + +KeyValuePairListOpt + : KeyValuePairList[pass] { $$ = $pass; } + | LexOf { $$ = NULL; } + ; + PrimaryExpression - : "@" BoxableExpression { $$ = CYNew CYBox($2); } + : "@" BoxableExpression[expression] { $$ = CYNew CYBox($expression); } + | "@" "[" ElementListOpt[elements] "]" { $$ = CYNew CYObjCArray($elements); } + | "@" "{" KeyValuePairListOpt[pairs] "}" { $$ = CYNew CYObjCDictionary($pairs); } + | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); } | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); } | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); } @@ -2080,67 +2331,115 @@ PrimaryExpression /* }}} */ /* Cycript (Objective-C): Block Expressions {{{ */ PrimaryExpression - : "^" TypedIdentifier { if ($2->identifier_ != NULL) CYERR($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else CYERR($2->location_, "expected parameters"); } + : "^" TypedIdentifierNo[type] "{" FunctionBody[code] "}" { if (CYTypeFunctionWith *function = $type->Function()) $$ = CYNew CYObjCBlock($type, function->parameters_, $code); else CYERR($type->location_, "expected parameters"); } ; /* }}} */ /* Cycript (Objective-C): Instance Literals {{{ */ PrimaryExpression - : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); } + : "#" NumericLiteral[address] { $$ = CYNew CYInstanceLiteral($address); } ; /* }}} */ @end @begin C /* Cycript (C): Pointer Indirection/Addressing {{{ */ -LeftHandSideExpression - : LexSetRegExp "*" UnaryExpression { $$ = CYNew CYIndirect($3); } +UnaryExpression_ + : IndirectExpression[pass] { $$ = $pass; } + ; + +IndirectExpression + : "*" UnaryExpression[rhs] { $$ = CYNew CYIndirect($rhs); } ; UnaryExpression_ - : "&" UnaryExpression { $$ = CYNew CYAddressOf($2); } + : "&" UnaryExpression[rhs] { $$ = CYNew CYAddressOf($rhs); } ; MemberAccess - : "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); } - | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); } + : "->" "[" Expression[property] "]" { $$ = CYNew CYIndirectMember(NULL, $property); } + | "->" IdentifierName[property] { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($property)); } | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; } ; /* }}} */ -/* Cycript (C): auto Compatibility {{{ */ -Var_ - : "auto" - ; -/* }}} */ /* Cycript (C): Lambda Expressions {{{ */ TypedParameterList_ - : "," TypedParameterList { $$ = $2; } - | { $$ = NULL; } + : "," TypedParameterList[parameters] { $$ = $parameters; } + | { $$ = CYNew CYTypedFormal(false); } ; TypedParameterList - : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } + : TypedIdentifierMaybe[typed] TypedParameterList_[formal] { $$ = $formal; $$->parameters_ = CYNew CYTypedParameter($typed, $$->parameters_); } + | "..." { $$ = CYNew CYTypedFormal(true); } ; TypedParameterListOpt - : TypedParameterList { $$ = $1; } - | { $$ = NULL; } + : TypedParameterList[pass] { $$ = $pass; } + | "void" { $$ = CYNew CYTypedFormal(false); } + | { $$ = CYNew CYTypedFormal(false); } + ; + +TypedParameters + : TypedParameterListOpt[formal] { if ($formal->variadic_) CYERR(@$, "unsupported variadic"); $$ = $formal->parameters_; } ; PrimaryExpression - : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); } + : "[" LexOf "&" "]" "(" TypedParameters[parameters] ")" "->" TypedIdentifierNo[type] "{" FunctionBody[code] "}" { $$ = CYNew CYLambda($type, $parameters, $code); } + ; +/* }}} */ +/* Cycript (C): Structure Definitions {{{ */ +IdentifierNoOf + : "struct" NewLineOpt { $$ = CYNew CYIdentifier("struct"); } + ; + +Statement__ + : "struct" NewLineNot IdentifierType[name] "{" StructFieldListOpt[fields] "}" { $$ = CYNew CYStructDefinition($name, CYNew CYStructTail($fields)); } + ; + +PrimaryExpression + : "(" LexOf "struct" NewLineOpt IdentifierType[name] TypeQualifierRightOpt[typed] ")" { $typed->specifier_ = CYNew CYTypeReference($name); $$ = CYNew CYTypeExpression($typed); } ; /* }}} */ /* Cycript (C): Type Definitions {{{ */ +IdentifierNoOf + : "typedef" NewLineOpt { $$ = CYNew CYIdentifier("typedef"); } + ; + +TypeDefinition + : "typedef" NewLineNot TypedIdentifierDefinition[typed] TerminatorHard { $$ = CYNew CYTypeDefinition($typed); } + ; + Statement__ - : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) CYERR($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } + : TypeDefinition[pass] { $$ = $pass; } + ; + +PrimaryExpression + : "(" LexOf "typedef" NewLineOpt TypedIdentifierEncoding[typed] ")" { $$ = CYNew CYTypeExpression($typed); } ; /* }}} */ /* Cycript (C): extern "C" {{{ */ +IdentifierNoOf + : "extern" NewLineOpt { $$ = CYNew CYIdentifier("extern"); } + ; + +ExternCStatement + : TypedIdentifierField[typed] TerminatorHard { $$ = CYNew CYExternal(CYNew CYString("C"), $typed); } + | TypeDefinition[pass] { $$ = $pass; } + ; + +ExternCStatementListOpt + : ExternCStatement[statement] ExternCStatementListOpt[next] { $$ = $statement; CYSetLast($$) = $next; } + | { $$ = NULL; } + ; + +ExternC + : "{" ExternCStatementListOpt[pass] "}" { $$ = $pass; } + | ExternCStatement[pass] { $$ = $pass; } + ; + Statement__ - : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) CYERR(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) CYERR($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } + : "extern" NewLineNot StringLiteral[abi] { if (strcmp($abi->Value(), "C") != 0) CYERR(@abi, "unknown extern binding"); } ExternC[pass] { $$ = $pass; } ; /* }}} */ - @end @begin E4X @@ -2193,8 +2492,8 @@ XMLMarkup /* 11.1 Primary Expressions {{{ */ PrimaryExpression : PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); } - | XMLInitialiser { $$ = $1; } - | XMLListInitialiser { $$ = $1; } + | XMLInitilizer { $$ = $1; } + | XMLListInitilizer { $$ = $1; } ; PropertyIdentifier @@ -2210,7 +2509,7 @@ AttributeIdentifier PropertySelector_ : PropertySelector { $$ = $1; } - | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); } + | "[" Expression "]" { $$ = CYNew CYSelector($2); } ; PropertySelector @@ -2234,7 +2533,7 @@ WildcardIdentifier ; /* }}} */ /* 11.1.4 XML Initializer {{{ */ -XMLInitialiser +XMLInitilizer : XMLMarkup { $$ = $1; } | XMLElement { $$ = $1; } ; @@ -2249,7 +2548,7 @@ XMLTagContent ; XMLExpression - : BRACE LexPushRegExp Expression LexPop "}" + : "{" LexPushRegExp Expression LexPop "}" ; XMLTagName @@ -2289,7 +2588,7 @@ XMLElementContentOpt ; /* }}} */ /* 11.1.5 XMLList Initializer {{{ */ -XMLListInitialiser +XMLListInitilizer : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "" LexPopIn { $$ = CYNew CYXMLList($4); } ; /* }}} */ @@ -2319,16 +2618,16 @@ Statement__ /* JavaScript FTL: Array Comprehensions {{{ */ Comprehension - : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); } + : AssignmentExpression[expression] ComprehensionFor[comprehension] ComprehensionTail[next] { $comprehension->SetNext($next); $$ = CYNew CYArrayComprehension($expression, $comprehension); } ; ComprehensionFor - : "for" "each" "(" LexPushInOn LexicalBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($5, $8); } + : "for" "each" "(" LexPushInOn LexBind ForBinding[binding] "!in" LexPopIn Expression[iterable] ")" { $$ = CYNew CYForOfComprehension($binding, $iterable); } ; /* }}} */ /* JavaScript FTL: for each {{{ */ IterationStatement - : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); } + : "for" "each" "(" LexPushInOn ForInStatementInitializer[initializer] "!in" LexPopIn Expression[iterable] ")" Statement[code] { $$ = CYNew CYForOf($initializer, $iterable, $code); } ; /* }}} */ @@ -2338,69 +2637,94 @@ PrimaryExpression ; ArrayComprehension - : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; } + : "[" Comprehension[comprehension] "]" { $$ = $comprehension; } ; Comprehension - : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); } + : LexOf ComprehensionFor[comprehension] ComprehensionTail[next] AssignmentExpression[expression] { $comprehension->SetNext($next); $$ = CYNew CYArrayComprehension($expression, $comprehension); } ; ComprehensionTail : { $$ = NULL; } - | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); } - | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); } + | ComprehensionFor[comprehension] ComprehensionTail[next] { $comprehension->SetNext($next); $$ = $comprehension; } + | ComprehensionIf[comprehension] ComprehensionTail[next] { $comprehension->SetNext($next); $$ = $comprehension; } ; ComprehensionFor - : "for" "(" LexPushInOn ForBinding "!in" LexPopIn Expression ")" { $$ = CYNew CYForInComprehension($4, $7); } - | "for" "(" LexPushInOn ForBinding "of" LexPopIn Expression ")" { $$ = CYNew CYForOfComprehension($4, $7); } + : "for" "(" LexPushInOn LexBind ForBinding[binding] "!in" LexPopIn Expression[iterable] ")" { $$ = CYNew CYForInComprehension($binding, $iterable); } + | "for" "(" LexPushInOn LexBind ForBinding[binding] "of" LexPopIn Expression[iterable] ")" { $$ = CYNew CYForOfComprehension($binding, $iterable); } ; ComprehensionIf - : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); } - ; -/* }}} */ -/* JavaScript FTW: Coalesce Operator {{{ */ -ConditionalExpression - : LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); } + : "if" "(" AssignmentExpression[test] ")" { $$ = CYNew CYIfComprehension($test); } ; /* }}} */ /* JavaScript FTW: Named Arguments {{{ */ ArgumentList - : LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); } + : LexOf WordNoUnary[tag] ":" AssignmentExpression[value] ArgumentList_[next] { $$ = CYNew CYArgument($tag, $value, $next); } + ; +/* }}} */ +/* JavaScript FTW: Subscript Access {{{ */ +MemberAccess + : "." "[" AssignmentExpression[property] "]" { $$ = CYNew CYSubscriptMember(NULL, $property); } + ; +/* }}} */ + +/* JavaScript FTW: Java "Anonymous Inner Classes" {{{ */ +BracedParameter + : "{" PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYExtend(NULL, $properties); } ; /* }}} */ + /* JavaScript FTW: Ruby Blocks {{{ */ RubyProcParameterList_ - : "," RubyProcParameterList { $$ = $2; } + : "," RubyProcParameterList[parameters] { $$ = $parameters; } | { $$ = NULL; } ; RubyProcParameterList - : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); } - | { $$ = NULL; } + : BindingIdentifier[identifier] RubyProcParameterList_[next] { $$ = CYNew CYFunctionParameter(CYNew CYBinding($identifier), $next); } + | LexOf { $$ = NULL; } ; RubyProcParameters - : LexSetRegExp "|" RubyProcParameterList "|" { $$ = $3; } - | LexSetRegExp "||" { $$ = NULL; } + : "|" RubyProcParameterList[parameters] "|" { $$ = $parameters; } + | "||" { $$ = NULL; } ; RubyProcParametersOpt - : RubyProcParameters { $$ = $1; } + : RubyProcParameters[pass] { $$ = $pass; } | { $$ = NULL; } ; -RubyProcExpression - : "{" RubyProcParametersOpt StatementListOpt "}" { $$ = CYNew CYRubyProc($2, $3); } +BracedParameter + : ";{" RubyProcParametersOpt[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyBlock(NULL, CYNew CYRubyProc($parameters, $code)); } ; PrimaryExpression - : BRACE LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); } + : "{" RubyProcParameters[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); } ; -PostfixExpression - : PostfixExpression RubyProcExpression { $$ = CYNew CYRubyBlock($1, $2); } +BracedExpression_ + : AccessExpression[pass] LexNewLineOrOpt { $$ = $pass; } + | BracedExpression_[lhs] { if (!$lhs->IsNew()) CYMAP(OpenBrace_, OpenBrace); } BracedParameter[rhs] LexNewLineOrOpt { $rhs->SetLeft($lhs); $$ = $rhs; } + ; + +BracedExpression + : BracedExpression_[pass] "\n" { $$ = $pass; } + | BracedExpression_[pass] { $$ = $pass; } + ; +/* }}} */ +/* JavaScript FTW: Ruby Scopes {{{ */ +MemberAccess + : "::" "[" Expression[property] "]" { $$ = CYNew CYResolveMember(NULL, $property); } + | "::" IdentifierName[property] { $$ = CYNew CYResolveMember(NULL, CYNew CYString($property)); } + | "::" AutoComplete { driver.mode_ = CYDriver::AutoResolve; YYACCEPT; } + ; +/* }}} */ +/* JavaScript FTW: Ruby Symbols {{{ */ +PrimaryExpression + : ":" Word[name] { $$ = CYNew CYSymbol($name->Word()); } ; /* }}} */