X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/484bab66e94c8bf2c01534ad3cab752ad3a366f0..8e216accc5c795e2cf42f89276841b175ed33f58:/Parser.ypp.in diff --git a/Parser.ypp.in b/Parser.ypp.in index 148d2d0..88c01bf 100644 --- a/Parser.ypp.in +++ b/Parser.ypp.in @@ -80,6 +80,7 @@ %union { CYWord *word_; } @begin C +%union { CYTypeStructField *structField_; } %union { CYTypeModifier *modifier_; } %union { CYTypeSpecifier *specifier_; } %union { CYTypedIdentifier *typedIdentifier_; } @@ -87,9 +88,9 @@ @end @begin ObjectiveC +%union { CYImplementationField *implementationField_; } %union { CYMessage *message_; } %union { CYMessageParameter *messageParameter_; } -%union { CYImplementationField *implementationField_; } %union { CYProtocol *protocol_; } %union { CYSelectorPart *selector_; } @end @@ -113,25 +114,13 @@ int cylex(YYSTYPE *, CYLocation *, void *); %code { -typedef cy::parser::token tk; - #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; - } - lex: - if (driver.newline_ == CYDriver::NewLineHere) - driver.newline_ = CYDriver::NewLineLast; - else if (driver.newline_ == CYDriver::NewLineLast) - driver.newline_ = CYDriver::NewLineNone; +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_; @@ -161,19 +150,27 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY break; case tk::NewLine: - driver.newline_ = CYDriver::NewLineHere; - if (!driver.next_) - goto lex; + driver.newline_ = true; + goto lex; break; } - driver.next_ = false; 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) @@ -183,12 +180,6 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY yyla.type = yytranslate_(token::to); \ } while (false) -#define CYLIN(from) do { \ - CYLEX(); \ - if (yyla.type == yytranslate_(token::from) && driver.newline_ == CYDriver::NewLineLast) \ - yyla.type = yytranslate_(token::from ## _); \ -} while (false) - #define CYERR(location, message) do { \ error(location, message); \ YYABORT; \ @@ -215,6 +206,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 @@ -267,14 +267,12 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token EqualEqual "==" %token EqualEqualEqual "===" %token EqualRight "=>" -%token EqualRight_ "\n=>" %token Exclamation "!" %token ExclamationEqual "!=" %token ExclamationEqualEqual "!==" %token Hyphen "-" %token HyphenEqual "-=" %token HyphenHyphen "--" -%token HyphenHyphen_ "\n--" %token HyphenRight "->" %token Left "<" %token LeftEqual "<=" @@ -290,7 +288,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 ">>" @@ -308,6 +305,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token Question "?" %token SemiColon ";" %token NewLine "\n" +%token __ "" %token Comment @@ -315,8 +313,7 @@ _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 "}" @@ -334,6 +331,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 @@ -421,6 +419,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %token _package_ "package" %token _private_ "private" %token _protected_ "protected" +%token ___proto___ "__proto__" %token _prototype_ "prototype" %token _public_ "public" %token _set_ "set" @@ -444,7 +443,6 @@ _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" @@ -455,7 +453,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY @end %token AutoComplete -%token YieldStar +%token YieldStar "yield *" %token Identifier_ %token NumericLiteral @@ -548,6 +546,7 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type IdentifierNoOf %type IdentifierType %type IdentifierTypeNoOf +%type IdentifierTypeOpt %type IdentifierName %type IdentifierReference %type IfStatement @@ -588,6 +587,8 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type RegularExpressionSlash %type RelationalExpression %type ReturnStatement +%type RubyBlockExpression_ +%type RubyBlockExpression %type RubyProcExpression %type RubyProcParameterList_ %type RubyProcParameterList @@ -631,11 +632,18 @@ _finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CY %type IntegerTypeOpt %type PrefixedType %type PrimitiveType +%type StructFieldListOpt %type SuffixedType +%type SuffixedTypeOpt %type TypeSignifier +%type TypeSignifierOpt %type TypeQualifierLeft +%type TypeQualifierLeftOpt %type TypeQualifierRight -%type TypedIdentifier +%type TypeQualifierRightOpt +%type TypedIdentifierMaybe +%type TypedIdentifierNo +%type TypedIdentifierYes %type TypedParameterList_ %type TypedParameterList %type TypedParameterListOpt @@ -647,13 +655,12 @@ _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 MessageExpression %type MessageParameter @@ -716,17 +723,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(); }; -LexNewLine - : { CYMPT(@$); driver.next_ = true; } +LexNewLineOrOpt + : { CYLEX(); if (driver.hold_ != empty_symbol) CYERR(@$, "unexpected hold"); if (driver.newline_) { driver.hold_ = yyla.type; yyla.type = yytranslate_(cy::parser::token::NewLine); } } + ; + +LexNewLineOrNot + : { CYLEX(); if (driver.hold_ != empty_symbol) CYERR(@$, "unexpected hold"); driver.hold_ = yyla.type; yyla.type = yytranslate_(driver.newline_ ? cy::parser::token::NewLine : cy::parser::token::__); } ; LexNoStar @@ -734,7 +747,7 @@ LexNoStar ; LexNoBrace - : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); } + : { CYMAP(OpenBrace_, OpenBrace); } ; LexNoClass @@ -750,11 +763,6 @@ LexSetStatement ; /* }}} */ /* Virtual Tokens {{{ */ -BRACE - : "{" - | "\n{" - ; - Var_ : "var" ; @@ -768,14 +776,8 @@ IdentifierName | "instanceof" { $$ = CYNew CYWord("instanceof"); } ; -NewLineOpt - : "\n" - | - ; - Word : IdentifierNoOf[pass] { $$ = $pass; } - | "auto" { $$ = CYNew CYWord("auto"); } | "break" { $$ = CYNew CYWord("break"); } | "case" { $$ = CYNew CYWord("case"); } | "catch" { $$ = CYNew CYWord("catch"); } @@ -813,8 +815,6 @@ Word | "while" { $$ = CYNew CYWord("while"); } | "with" { $$ = CYNew CYWord("with"); } | "yield" { $$ = CYNew CYIdentifier("yield"); } - - | Yield LexOf NewLineOpt { $$ = CYNew CYIdentifier("yield"); } ; @begin ObjectiveC @@ -851,14 +851,23 @@ StrictSemi : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } ; +NewLineNot + : LexNewLineOrNot "" + ; + +NewLineOpt + : LexNewLineOrNot "\n" + | NewLineNot + ; + TerminatorSoft - : ";" - | "\n" StrictSemi + : LexNewLineOrNot "\n" StrictSemi + | NewLineNot LexOf Terminator ; Terminator : ";" - | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && driver.newline_ == CYDriver::NewLineNone) CYERR(@error, "required semi-colon"); else CYEOK(); } StrictSemi + | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) CYERR(@error, "required semi-colon"); else CYEOK(); } StrictSemi ; TerminatorOpt @@ -913,6 +922,7 @@ IdentifierTypeNoOf | "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"); } @@ -934,6 +944,11 @@ IdentifierType | "of" { $$ = CYNew CYIdentifier("of"); } ; +IdentifierTypeOpt + : IdentifierType[pass] { $$ = $pass; } + | { $$ = NULL; } + ; + IdentifierNoOf : IdentifierTypeNoOf | "char" { $$ = CYNew CYIdentifier("char"); } @@ -943,9 +958,8 @@ IdentifierNoOf | "static" { $$ = CYNew CYIdentifier("static"); } | "volatile" { $$ = CYNew CYIdentifier("volatile"); } @begin C - | "extern" { $$ = CYNew CYIdentifier("extern"); } | "signed" { $$ = CYNew CYIdentifier("signed"); } - | "typedef" { $$ = CYNew CYIdentifier("typedef"); } + | "struct" { $$ = CYNew CYIdentifier("struct"); } | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); } @end @begin ObjectiveC @@ -1011,7 +1025,7 @@ ElementListOpt /* }}} */ /* 12.2.6 Object Initializer {{{ */ ObjectLiteral - : BRACE PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYObject($properties); } + : "{" PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYObject($properties); } ; PropertyDefinitionList_ @@ -1066,12 +1080,12 @@ InitializerOpt /* 12.2.9 Template Literals {{{ */ TemplateLiteral : NoSubstitutionTemplate[string] { $$ = CYNew CYTemplate($string, NULL); } - | TemplateHead[string] TemplateSpans[spans] { $$ = CYNew CYTemplate($string, $spans); } + | TemplateHead[string] LexPushInOff TemplateSpans[spans] { $$ = CYNew CYTemplate($string, $spans); } ; TemplateSpans : Expression[value] TemplateMiddle[string] TemplateSpans[spans] { $$ = CYNew CYSpan($value, $string, $spans); } - | Expression[value] TemplateTail[string] { $$ = CYNew CYSpan($value, $string, NULL); } + | Expression[value] TemplateTail[string] LexPopIn { $$ = CYNew CYSpan($value, $string, NULL); } ; /* }}} */ @@ -1092,8 +1106,8 @@ MemberExpression ; SuperProperty - : "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); } "[" Expression[property] "]" { $$ = CYNew CYSuperAccess($property); } - | "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); } "." IdentifierName[property] { $$ = CYNew CYSuperAccess(CYNew CYString($property)); } + : Super "[" Expression[property] "]" { $$ = CYNew CYSuperAccess($property); } + | Super "." IdentifierName[property] { $$ = CYNew CYSuperAccess(CYNew CYString($property)); } ; MetaProperty @@ -1121,7 +1135,7 @@ CallExpression ; SuperCall - : "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); } Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); } + : Super Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); } ; Arguments @@ -1149,19 +1163,15 @@ AccessExpression ; LeftHandSideExpression - : AccessExpression[pass] LexCrement { $$ = $pass; } + : RubyBlockExpression[pass] { $$ = $pass; } | IndirectExpression[pass] { $$ = $pass; } ; /* }}} */ /* 12.4 Postfix Expressions {{{ */ -LexCrement - : { CYLIN(PlusPlus); CYLIN(HyphenHyphen); } - ; - PostfixExpression - : AccessExpression[lhs] LexCrement { $$ = $lhs; } - | AccessExpression[lhs] LexCrement "++" { $$ = CYNew CYPostIncrement($lhs); } - | AccessExpression[lhs] LexCrement "--" { $$ = CYNew CYPostDecrement($lhs); } + : RubyBlockExpression[pass] { $$ = $pass; } + | AccessExpression[lhs] LexNewLineOrOpt "++" { $$ = CYNew CYPostIncrement($lhs); } + | AccessExpression[lhs] LexNewLineOrOpt "--" { $$ = CYNew CYPostDecrement($lhs); } ; /* }}} */ /* 12.5 Unary Operators {{{ */ @@ -1170,9 +1180,7 @@ UnaryExpression_ | "void" UnaryExpression[rhs] { $$ = CYNew CYVoid($rhs); } | "typeof" UnaryExpression[rhs] { $$ = CYNew CYTypeOf($rhs); } | "++" UnaryExpression[rhs] { $$ = CYNew CYPreIncrement($rhs); } - | "\n++" UnaryExpression[rhs] { $$ = CYNew CYPreIncrement($rhs); } | "--" UnaryExpression[rhs] { $$ = CYNew CYPreDecrement($rhs); } - | "\n--" UnaryExpression[rhs] { $$ = CYNew CYPreDecrement($rhs); } | "+" UnaryExpression[rhs] { $$ = CYNew CYAffirm($rhs); } | "-" UnaryExpression[rhs] { $$ = CYNew CYNegate($rhs); } | "~" UnaryExpression[rhs] { $$ = CYNew CYBitwiseNot($rhs); } @@ -1180,7 +1188,7 @@ UnaryExpression_ ; UnaryExpression - : PostfixExpression[expression] LexOpenBrace { $$ = $expression; } + : PostfixExpression[expression] { $$ = $expression; } | UnaryExpression_[pass] { $$ = $pass; } ; /* }}} */ @@ -1366,7 +1374,7 @@ BlockStatement ; Block - : BRACE StatementListOpt[code] "}" { $$ = $code; } + : "{" StatementListOpt[code] "}" { $$ = $code; } ; StatementList @@ -1457,7 +1465,7 @@ ObjectBindingPattern ; ArrayBindingPattern - : "let [" { CYNOT(@$); } + : "let [" BindingElementListOpt "]" ; BindingPropertyList_ @@ -1474,6 +1482,17 @@ BindingPropertyListOpt | LexOf ; +BindingElementList + : BindingElementOpt[element] "," BindingElementListOpt[next] + | BindingRestElement[element] + | BindingElement[element] + ; + +BindingElementListOpt + : BindingElementList[pass] + | LexBind LexOf + ; + BindingProperty : SingleNameBinding | LexOf PropertyName ":" BindingElement @@ -1484,12 +1503,17 @@ BindingElement | LexBind LexOf BindingPattern InitializerOpt[initializer] { CYNOT(@$); } ; +BindingElementOpt + : BindingElement[pass] + | LexBind LexOf + ; + SingleNameBinding : BindingIdentifier[identifier] InitializerOpt[initializer] { $$ = CYNew CYBinding($identifier, $initializer); } ; BindingRestElement - : "..." BindingIdentifier + : LexBind LexOf "..." BindingIdentifier ; /* }}} */ /* 13.4 Empty Statement {{{ */ @@ -1533,7 +1557,7 @@ ForStatementInitializer ; ForInStatementInitializer - : LexLet LexOf AccessExpression[pass] LexCrement { $$ = $pass; } + : LexLet LexOf RubyBlockExpression[pass] { $$ = $pass; } | LexLet LexOf IndirectExpression[pass] { $$ = $pass; } | LexLet LexOf Var_ LexBind ForBinding[binding] { $$ = CYNew CYForVariable($binding); } | ForDeclaration[pass] { $$ = $pass; } @@ -1549,33 +1573,21 @@ ForBinding ; /* }}} */ /* 13.8 The continue Statement {{{ */ -Continue - : "continue" LexNewLine - ; - ContinueStatement - : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); } - | Continue Identifier[label] Terminator { $$ = CYNew CYContinue($label); } + : "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[label] Terminator { $$ = CYNew CYBreak($label); } + : "break" TerminatorSoft { $$ = CYNew CYBreak(NULL); } + | "break" NewLineNot LexOf Identifier[label] Terminator { $$ = CYNew CYBreak($label); } ; /* }}} */ /* 13.10 The return Statement {{{ */ -Return - : "return"[return] { if (!driver.return_.top()) CYERR(@return, "invalid return"); } LexNewLine - ; - ReturnStatement - : Return LexOf TerminatorSoft { $$ = CYNew CYReturn(NULL); } - | Return Expression[value] Terminator { $$ = CYNew CYReturn($value); } + : Return TerminatorSoft { $$ = CYNew CYReturn(NULL); } + | Return NewLineNot Expression[value] Terminator { $$ = CYNew CYReturn($value); } ; /* }}} */ /* 13.11 The with Statement {{{ */ @@ -1589,7 +1601,7 @@ SwitchStatement ; CaseBlock - : BRACE CaseClausesOpt[clauses] "}" { $$ = $clauses; } + : "{" CaseClausesOpt[clauses] "}" { $$ = $clauses; } ; CaseClause @@ -1618,13 +1630,9 @@ LabelledItem ; /* }}} */ /* 13.14 The throw Statement {{{ */ -Throw - : "throw" LexNewLine - ; - ThrowStatement - : Throw[throw] LexOf TerminatorSoft { CYERR(@throw, "throw without exception"); } - | Throw Expression[value] Terminator { $$ = CYNew cy::Syntax::Throw($value); } + : "throw"[throw] TerminatorSoft { CYERR(@throw, "throw without exception"); } + | "throw" NewLineNot Expression[value] Terminator { $$ = CYNew cy::Syntax::Throw($value); } ; /* }}} */ /* 13.15 The try Statement {{{ */ @@ -1655,11 +1663,11 @@ DebuggerStatement /* 14.1 Function Definitions {{{ */ FunctionDeclaration - : ";function" BindingIdentifier[name] "(" FormalParameters[parameters] ")" BRACE LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionStatement($name, $parameters, $code); } + : ";function" BindingIdentifier[name] "(" FormalParameters[parameters] ")" "{" LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionStatement($name, $parameters, $code); } ; FunctionExpression - : "function" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" BRACE LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionExpression($name, $parameters, $code); } + : "function" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" "{" LexPushSuperOff FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYFunctionExpression($name, $parameters, $code); } ; StrictFormalParameters @@ -1677,7 +1685,7 @@ FormalParameterList_ ; FormalParameterList - : LexBind LexOf FunctionRestParameter { CYNOT(@$); } + : FunctionRestParameter { CYNOT(@$); } | FormalParameter[binding] FormalParameterList_[next] { $$ = CYNew CYFunctionParameter($binding, $next); } ; @@ -1698,12 +1706,8 @@ FunctionStatementList ; /* }}} */ /* 14.2 Arrow Function Definitions {{{ */ -LexEqualRight - : { CYLIN(EqualRight); } - ; - ArrowFunction - : ArrowParameters[parameters] LexEqualRight "=>" LexNoBrace ConciseBody[code] { $$ = CYNew CYFatArrow($parameters, $code); } + : ArrowParameters[parameters] LexNewLineOrOpt "=>" LexNoBrace ConciseBody[code] { $$ = CYNew CYFatArrow($parameters, $code); } ; ArrowParameters @@ -1718,10 +1722,10 @@ ConciseBody /* }}} */ /* 14.3 Method Definitions {{{ */ MethodDefinition - : PropertyName[name] "(" StrictFormalParameters[parameters] ")" BRACE FunctionBody[code] "}" { $$ = CYNew CYPropertyMethod($name, $parameters, $code); } + : PropertyName[name] "(" StrictFormalParameters[parameters] ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertyMethod($name, $parameters, $code); } | GeneratorMethod[pass] { $$ = $pass; } - | "get" PropertyName[name] "(" ")" BRACE FunctionBody[code] "}" { $$ = CYNew CYPropertyGetter($name, $code); } - | "set" PropertyName[name] "(" PropertySetParameterList[parameter] ")" BRACE FunctionBody[code] "}" { $$ = CYNew CYPropertySetter($name, $parameter, $code); } + | "get" PropertyName[name] "(" ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertyGetter($name, $code); } + | "set" PropertyName[name] "(" PropertySetParameterList[parameter] ")" "{" FunctionBody[code] "}" { $$ = CYNew CYPropertySetter($name, $parameter, $code); } ; PropertySetParameterList @@ -1730,29 +1734,26 @@ PropertySetParameterList /* }}} */ /* 14.4 Generator Function Definitions {{{ */ GeneratorMethod - : "*" PropertyName[name] "(" StrictFormalParameters[parameters] ")" BRACE GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($name, $parameters, $code); */ } + : "*" PropertyName[name] "(" StrictFormalParameters[parameters] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($name, $parameters, $code); */ } ; GeneratorDeclaration - : ";function" LexOf "*" BindingIdentifier[name] "(" FormalParameters[code] ")" BRACE GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($name, $parameters, $code); */ } + : ";function" LexOf "*" BindingIdentifier[name] "(" FormalParameters[code] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($name, $parameters, $code); */ } ; GeneratorExpression - : "function" LexOf "*" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" BRACE GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($name, $parameters, $code); */ } + : "function" LexOf "*" BindingIdentifierOpt[name] "(" FormalParameters[parameters] ")" "{" GeneratorBody[code] "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($name, $parameters, $code); */ } ; GeneratorBody : LexPushYieldOn FunctionStatementList[code] LexPopYield { $$ = $code; } ; -Yield - : "!yield" LexNewLine LexNoStar - ; - YieldExpression - : Yield LexOf NewLineOpt { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } - | Yield AssignmentExpression[value] { CYNOT(@$); /* $$ = CYNew CYYieldValue($value); */ } - | Yield LexOf YieldStar AssignmentExpression[generator] { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($generator); */ } + : "!yield" LexNewLineOrNot "\n" LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } + | "!yield" LexNewLineOrNot "" LexNoStar LexOf { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } + | "!yield" LexNewLineOrNot "" LexNoStar AssignmentExpression[value] { CYNOT(@$); /* $$ = CYNew CYYieldValue($value); */ } + | "!yield" LexNewLineOrNot "" LexNoStar LexOf "yield *" AssignmentExpression[generator] { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($generator); */ } ; /* }}} */ /* 14.5 Class Definitions {{{ */ @@ -1765,7 +1766,7 @@ ClassExpression ; ClassTail - : ClassHeritageOpt[tail] { driver.class_.push($tail); } BRACE LexPushSuperOn ClassBodyOpt "}" LexPopSuper { driver.class_.pop(); $$ = $tail; } + : ClassHeritageOpt[tail] { driver.class_.push($tail); } "{" LexPushSuperOn ClassBodyOpt "}" LexPopSuper { driver.class_.pop(); $$ = $tail; } ; ClassHeritage @@ -1868,7 +1869,7 @@ NameSpaceImport ; NamedImports - : BRACE ImportsListOpt "}" + : "{" ImportsListOpt "}" ; FromClause @@ -1946,33 +1947,50 @@ ExportSpecifier /* Cycript (C): Type Encoding {{{ */ TypeSignifier : IdentifierType[identifier] { $$ = CYNew CYTypedIdentifier(@identifier, $identifier); } - | "(" "*" TypeQualifierRight[typed] ")" { $$ = $typed; } + | "(" "*" TypeQualifierRightOpt[typed] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + ; + +TypeSignifierOpt + : TypeSignifier[pass] { $$ = $pass; } + | { $$ = CYNew CYTypedIdentifier(@$); } ; SuffixedType - : SuffixedType[typed] "[" NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); } - | "(" "^" TypeQualifierRight[typed] ")" "(" TypedParameterListOpt[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeBlockWith($parameters, $$->modifier_); } + : SuffixedTypeOpt[typed] "[" NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); } + | "(" "^" TypeQualifierRightOpt[typed] ")" "(" TypedParameterListOpt[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeBlockWith($parameters, $$->modifier_); } | TypeSignifier[typed] "(" TypedParameterListOpt[parameters] ")" { $$ = $typed; $$->modifier_ = CYNew CYTypeFunctionWith($parameters, $$->modifier_); } | "("[parenthesis] TypedParameterListOpt[parameters] ")" { $$ = CYNew CYTypedIdentifier(@parenthesis); $$->modifier_ = CYNew CYTypeFunctionWith($parameters, $$->modifier_); } - | TypeSignifier[pass] { $$ = $pass; } - | { $$ = CYNew CYTypedIdentifier(@$); } + ; + +SuffixedTypeOpt + : SuffixedType[pass] { $$ = $pass; } + | TypeSignifierOpt[pass] { $$ = $pass; } ; PrefixedType - : "*" TypeQualifierRight[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + : "*" TypeQualifierRightOpt[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } ; TypeQualifierLeft - : { $$ = NULL; } - | "const" TypeQualifierLeft[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeConstant(); } - | "volatile" TypeQualifierLeft[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeVolatile(); } + : "const" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeConstant(); } + | "volatile" TypeQualifierLeftOpt[modifier] { $$ = $modifier; CYSetLast($$) = CYNew CYTypeVolatile(); } + ; + +TypeQualifierLeftOpt + : TypeQualifierLeft[pass] { $$ = $pass; } + | { $$ = NULL; } ; TypeQualifierRight - : PrefixedType[pass] { $$ = $pass; } - | SuffixedType[pass] { $$ = $pass; } - | "const" TypeQualifierRight[typed] { $$ = $typed; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } - | "volatile" TypeQualifierRight[typed] { $$ = $typed; $$->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_); } + ; + +TypeQualifierRightOpt + : TypeQualifierRight[pass] { $$ = $pass; } + | TypeSignifierOpt[pass] { $$ = $pass; } ; IntegerType @@ -1988,21 +2006,36 @@ IntegerTypeOpt | { $$ = CYNew CYTypeVariable("int"); } ; +StructFieldListOpt + : TypedIdentifierMaybe[typed] ";" StructFieldListOpt[next] { $$ = CYNew CYTypeStructField($typed, $next); } + | { $$ = NULL; } + ; + PrimitiveType : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); } | IntegerType[pass] { $$ = $pass; } - | "void" { $$ = CYNew CYTypeVoid(); } | "char" { $$ = CYNew CYTypeVariable("char"); } | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); } | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); } + | "struct" IdentifierTypeOpt[name] "{" StructFieldListOpt[fields] "}" { $$ = CYNew CYTypeStruct($name, $fields); } ; -TypedIdentifier - : TypeQualifierLeft[modifier] PrimitiveType[specifier] TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } +TypedIdentifierMaybe + : TypeQualifierLeftOpt[modifier] PrimitiveType[specifier] TypeQualifierRightOpt[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + | TypeQualifierLeft[modifier] "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; } + | "void" TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = CYNew CYTypeVoid(); } + ; + +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; } ; PrimaryExpression - : "@encode" "(" TypedIdentifier[typed] ")" { $$ = CYNew CYEncodedType($typed); } + : "@encode" "(" TypedIdentifierMaybe[typed] ")" { $$ = CYNew CYEncodedType($typed); } ; /* }}} */ @end @@ -2016,21 +2049,17 @@ ClassSuperOpt ; ImplementationFieldListOpt - : TypedIdentifier[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $next); } + : TypedIdentifierMaybe[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $next); } | { $$ = NULL; } ; -ImplementationFields - : BRACE ImplementationFieldListOpt[fields] "}" { $$ = $fields; } - ; - MessageScope : "+" { $$ = false; } | "-" { $$ = true; } ; TypeOpt - : "(" TypedIdentifier[type] ")" { if ($type->identifier_ != NULL) CYERR($type->location_, "unexpected identifier"); $$ = $type; } + : "(" TypedIdentifierNo[type] ")" { $$ = $type; } | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } ; @@ -2053,7 +2082,7 @@ MessageParameters ; ClassMessageDeclaration - : MessageScope[instance] TypeOpt[type] MessageParameters[parameters] BRACE LexPushSuperOn FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYMessage($instance, $type, $parameters, $code); } + : MessageScope[instance] TypeOpt[type] MessageParameters[parameters] "{" LexPushSuperOn FunctionBody[code] "}" LexPopSuper { $$ = CYNew CYMessage($instance, $type, $parameters, $code); } ; ClassMessageDeclarationListOpt @@ -2077,7 +2106,7 @@ ClassProtocolListOpt ; ImplementationStatement - : "@implementation" Identifier[name] ClassSuperOpt[extends] ClassProtocolListOpt[protocols] ImplementationFields[fields] ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYImplementation($name, $extends, $protocols, $fields, $messages); } + : "@implementation" Identifier[name] ClassSuperOpt[extends] ClassProtocolListOpt[protocols] "{" ImplementationFieldListOpt[fields] "}" ClassMessageDeclarationListOpt[messages] "@end" { $$ = CYNew CYImplementation($name, $extends, $protocols, $fields, $messages); } ; CategoryName @@ -2180,7 +2209,7 @@ PrimaryExpression /* }}} */ /* Cycript (Objective-C): Block Expressions {{{ */ PrimaryExpression - : "^" TypedIdentifier[type] { if ($type->identifier_ != NULL) CYERR($type->location_, "unexpected identifier"); } BRACE FunctionBody[code] "}" { if (CYTypeFunctionWith *function = $type->Function()) $$ = CYNew CYObjCBlock($type, function->parameters_, $code); else CYERR($type->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 {{{ */ @@ -2210,11 +2239,6 @@ MemberAccess | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; } ; /* }}} */ -/* Cycript (C): auto Compatibility {{{ */ -Var_ - : "auto" - ; -/* }}} */ /* Cycript (C): Lambda Expressions {{{ */ TypedParameterList_ : "," TypedParameterList[parameters] { $$ = $parameters; } @@ -2222,26 +2246,39 @@ TypedParameterList_ ; TypedParameterList - : TypedIdentifier[typed] TypedParameterList_[next] { $$ = CYNew CYTypedParameter($typed, $next); } + : TypedIdentifierMaybe[typed] TypedParameterList_[next] { $$ = CYNew CYTypedParameter($typed, $next); } ; TypedParameterListOpt : TypedParameterList[pass] { $$ = $pass; } + | "void" { $$ = NULL; } | { $$ = NULL; } ; PrimaryExpression - : "[" LexOf "&" "]" "(" TypedParameterListOpt[parameters] ")" "->" TypedIdentifier[type] BRACE FunctionBody[code] "}" { $$ = CYNew CYLambda($type, $parameters, $code); } + : "[" LexOf "&" "]" "(" TypedParameterListOpt[parameters] ")" "->" TypedIdentifierMaybe[type] "{" FunctionBody[code] "}" { $$ = CYNew CYLambda($type, $parameters, $code); } ; /* }}} */ /* Cycript (C): Type Definitions {{{ */ +IdentifierNoOf + : "typedef" NewLineOpt { $$ = CYNew CYIdentifier("typedef"); } + ; + Statement__ - : "typedef" TypedIdentifier[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($typed); } + : "typedef" NewLineNot TypedIdentifierYes[typed] Terminator { $$ = CYNew CYTypeDefinition($typed); } + ; + +PrimaryExpression + : "(" LexOf "typedef" NewLineOpt TypedIdentifierNo[typed] ")" { $$ = CYNew CYTypeExpression($typed); } ; /* }}} */ /* Cycript (C): extern "C" {{{ */ +IdentifierNoOf + : "extern" NewLineOpt { $$ = CYNew CYIdentifier("extern"); } + ; + Statement__ - : "extern" StringLiteral[abi] { if (strcmp($abi->Value(), "C") != 0) CYERR(@abi, "unknown extern binding"); } TypedIdentifier[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($abi, $typed); } + : "extern" NewLineNot StringLiteral[abi] { if (strcmp($abi->Value(), "C") != 0) CYERR(@abi, "unknown extern binding"); } TypedIdentifierYes[typed] Terminator { $$ = CYNew CYExternal($abi, $typed); } ; /* }}} */ @@ -2353,7 +2390,7 @@ XMLTagContent ; XMLExpression - : BRACE LexPushRegExp Expression LexPop "}" + : "{" LexPushRegExp Expression LexPop "}" ; XMLTagName @@ -2495,20 +2532,22 @@ RubyProcParametersOpt | { $$ = NULL; } ; -LexOpenBrace - : { CYLIN(OpenBrace); } - ; - RubyProcExpression : "{" RubyProcParametersOpt[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); } ; PrimaryExpression - : BRACE RubyProcParameters[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); } + : "{" RubyProcParameters[parameters] StatementListOpt[code] "}" { $$ = CYNew CYRubyProc($parameters, $code); } ; -PostfixExpression - : PostfixExpression[lhs] LexOpenBrace RubyProcExpression[rhs] { $$ = CYNew CYRubyBlock($lhs, $rhs); } +RubyBlockExpression_ + : AccessExpression[pass] LexNewLineOrOpt { $$ = $pass; } + | RubyBlockExpression_[lhs] RubyProcExpression[rhs] LexNewLineOrOpt { $$ = CYNew CYRubyBlock($lhs, $rhs); } + ; + +RubyBlockExpression + : RubyBlockExpression_[pass] "\n" { $$ = $pass; } + | RubyBlockExpression_[pass] { $$ = $pass; } ; /* }}} */