%union { CYForInInitializer *forin_; }
%union { CYFunctionParameter *functionParameter_; }
%union { CYIdentifier *identifier_; }
+%union { CYImportSpecifier *import_; }
%union { CYInfix *infix_; }
%union { CYLiteral *literal_; }
%union { CYMethod *method_; }
%union { CYWord *word_; }
@begin C
+%union { CYTypeStructField *structField_; }
%union { CYTypeModifier *modifier_; }
%union { CYTypeSpecifier *specifier_; }
%union { CYTypedIdentifier *typedIdentifier_; }
@end
@begin ObjectiveC
+%union { CYImplementationField *implementationField_; }
%union { CYMessage *message_; }
%union { CYMessageParameter *messageParameter_; }
-%union { CYImplementationField *implementationField_; }
%union { CYProtocol *protocol_; }
%union { CYSelectorPart *selector_; }
@end
%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_;
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)
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; \
%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
%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 "<="
%token Plus "+"
%token PlusEqual "+="
%token PlusPlus "++"
-%token PlusPlus_ "\n++"
%token Right ">"
%token RightEqual ">="
%token RightRight ">>"
%token Question "?"
%token SemiColon ";"
%token NewLine "\n"
+%token __ ""
%token Comment
%token CloseParen ")"
%token OpenBrace "{"
-%token OpenBrace_ "\n{"
-%token OpenBrace__ ";{"
+%token OpenBrace_ ";{"
%token OpenBrace_let "let {"
%token CloseBrace "}"
%token _typedef_ "typedef"
%token _unsigned_ "unsigned"
%token _signed_ "signed"
+%token _struct_ "struct"
%token _extern_ "extern"
@end
%token _null_ "null"
%token _true_ "true"
+%token _as_ "as"
%token _break_ "break"
%token _case_ "case"
%token _catch_ "catch"
%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 _SEL_ "SEL"
@end
-%token _auto_ "auto"
%token _each_ "each"
%token _of_ "of"
%token _of__ "!of"
@end
%token AutoComplete
-%token YieldStar
+%token YieldStar "yield *"
%token <identifier_> Identifier_
%token <number_> NumericLiteral
%type <expression_> ExpressionOpt
%type <for_> ExpressionStatement_
%type <statement_> ExpressionStatement
+%type <statement_> ExternC
+%type <statement_> ExternCStatement
+%type <statement_> ExternCStatementListOpt
%type <finally_> Finally
%type <binding_> ForBinding
%type <forin_> ForDeclaration
%type <functionParameter_> FormalParameterList_
%type <functionParameter_> FormalParameterList
%type <functionParameter_> FormalParameters
+%type <string_> FromClause
%type <statement_> FunctionBody
%type <statement_> FunctionDeclaration
%type <target_> FunctionExpression
%type <identifier_> IdentifierNoOf
%type <identifier_> IdentifierType
%type <identifier_> IdentifierTypeNoOf
+%type <identifier_> IdentifierTypeOpt
%type <word_> IdentifierName
%type <variable_> IdentifierReference
%type <statement_> IfStatement
+%type <import_> ImportClause
+%type <statement_> ImportDeclaration
+%type <import_> ImportSpecifier
+%type <identifier_> ImportedBinding
+%type <import_> ImportedDefaultBinding
+%type <import_> ImportsList_
+%type <import_> ImportsList
+%type <import_> ImportsListOpt
%type <target_> IndirectExpression
%type <expression_> Initializer
%type <expression_> InitializerOpt
%type <access_> MemberAccess
%type <target_> MemberExpression
%type <method_> MethodDefinition
+%type <statement_> ModuleBody
+%type <statement_> ModuleBodyOpt
+%type <statement_> ModuleItem
+%type <statement_> ModuleItemList
+%type <statement_> ModuleItemListOpt
%type <module_> ModulePath
+%type <string_> ModuleSpecifier
%type <expression_> MultiplicativeExpression
+%type <import_> NameSpaceImport
+%type <import_> NamedImports
%type <target_> NewExpression
%type <null_> NullLiteral
%type <literal_> ObjectLiteral
%type <bool_> RegularExpressionSlash
%type <expression_> RelationalExpression
%type <statement_> ReturnStatement
+%type <target_> RubyBlockExpression_
+%type <target_> RubyBlockExpression
%type <rubyProc_> RubyProcExpression
%type <functionParameter_> RubyProcParameterList_
%type <functionParameter_> RubyProcParameterList
%type <span_> TemplateSpans
%type <statement_> ThrowStatement
%type <statement_> TryStatement
+%type <statement_> TypeDefinition
%type <expression_> UnaryExpression_
%type <expression_> UnaryExpression
%type <binding_> VariableDeclaration
%type <specifier_> IntegerTypeOpt
%type <typedIdentifier_> PrefixedType
%type <specifier_> PrimitiveType
+%type <structField_> StructFieldListOpt
%type <typedIdentifier_> SuffixedType
+%type <typedIdentifier_> SuffixedTypeOpt
%type <typedIdentifier_> TypeSignifier
+%type <typedIdentifier_> TypeSignifierNone
+%type <typedIdentifier_> TypeSignifierOpt
+%type <modifier_> ParameterTail
%type <modifier_> TypeQualifierLeft
+%type <modifier_> TypeQualifierLeftOpt
%type <typedIdentifier_> TypeQualifierRight
-%type <typedIdentifier_> TypedIdentifier
+%type <typedIdentifier_> TypeQualifierRightOpt
+%type <typedIdentifier_> TypedIdentifierDefinition
+%type <typedIdentifier_> TypedIdentifierEncoding
+%type <typedIdentifier_> TypedIdentifierField
+%type <typedIdentifier_> TypedIdentifierMaybe
+%type <typedIdentifier_> TypedIdentifierNo
+%type <typedIdentifier_> TypedIdentifierYes
%type <typedParameter_> TypedParameterList_
%type <typedParameter_> TypedParameterList
%type <typedParameter_> TypedParameterListOpt
%type <statement_> CategoryStatement
%type <expression_> ClassSuperOpt
%type <expression_> ConditionalExpressionClassic
-%type <implementationField_> ImplementationFieldListOpt
-%type <implementationField_> ImplementationFields
%type <message_> ClassMessageDeclaration
%type <message_> ClassMessageDeclarationListOpt
%type <protocol_> ClassProtocolListOpt
%type <protocol_> ClassProtocols
%type <protocol_> ClassProtocolsOpt
+%type <implementationField_> ImplementationFieldListOpt
%type <statement_> ImplementationStatement
%type <target_> MessageExpression
%type <messageParameter_> MessageParameter
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
;
LexNoBrace
- : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); }
+ : { CYMAP(OpenBrace_, OpenBrace); }
;
LexNoClass
;
/* }}} */
/* Virtual Tokens {{{ */
-BRACE
- : "{"
- | "\n{"
- ;
-
Var_
: "var"
;
| "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"); }
| "while" { $$ = CYNew CYWord("while"); }
| "with" { $$ = CYNew CYWord("with"); }
| "yield" { $$ = CYNew CYIdentifier("yield"); }
-
- | Yield LexOf NewLineOpt { $$ = CYNew CYIdentifier("yield"); }
;
@begin ObjectiveC
: { 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_ == 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
IdentifierTypeNoOf
: Identifier_[pass] { $$ = $pass; }
| "abstract" { $$ = CYNew CYIdentifier("abstract"); }
+ | "as" { $$ = CYNew CYIdentifier("as"); }
| "await" { $$ = CYNew CYIdentifier("await"); }
| "boolean" { $$ = CYNew CYIdentifier("boolean"); }
| "byte" { $$ = CYNew CYIdentifier("byte"); }
| "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"); }
| "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
/* }}} */
/* 12.2.6 Object Initializer {{{ */
ObjectLiteral
- : BRACE PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYObject($properties); }
+ : "{" PropertyDefinitionListOpt[properties] "}" { $$ = CYNew CYObject($properties); }
;
PropertyDefinitionList_
/* 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); }
;
/* }}} */
;
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
;
SuperCall
- : "super"[super] { if (!driver.super_.top()) CYERR(@super, "invalid super"); } Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); }
+ : Super Arguments[arguments] { $$ = CYNew CYSuperCall($arguments); }
;
Arguments
;
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 {{{ */
| "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); }
;
UnaryExpression
- : PostfixExpression[expression] LexOpenBrace { $$ = $expression; }
+ : PostfixExpression[expression] { $$ = $expression; }
| UnaryExpression_[pass] { $$ = $pass; }
;
/* }}} */
;
Block
- : BRACE StatementListOpt[code] "}" { $$ = $code; }
+ : "{" StatementListOpt[code] "}" { $$ = $code; }
;
StatementList
- : StatementListItem[statement] StatementListOpt[next] { $statement->SetNext($next); $$ = $statement; }
+ : StatementListItem[statement] StatementListOpt[next] { $$ = $statement; CYSetLast($$) = $next; }
;
StatementListOpt
;
ArrayBindingPattern
- : "let [" { CYNOT(@$); }
+ : "let [" BindingElementListOpt "]"
;
BindingPropertyList_
| LexOf
;
+BindingElementList
+ : BindingElementOpt[element] "," BindingElementListOpt[next]
+ | BindingRestElement[element]
+ | BindingElement[element]
+ ;
+
+BindingElementListOpt
+ : BindingElementList[pass]
+ | LexBind LexOf
+ ;
+
BindingProperty
: SingleNameBinding
| LexOf PropertyName ":" 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 {{{ */
;
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; }
;
/* }}} */
/* 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 {{{ */
;
CaseBlock
- : BRACE CaseClausesOpt[clauses] "}" { $$ = $clauses; }
+ : "{" CaseClausesOpt[clauses] "}" { $$ = $clauses; }
;
CaseClause
;
/* }}} */
/* 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 {{{ */
/* 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
;
FormalParameterList
- : LexBind LexOf FunctionRestParameter { CYNOT(@$); }
+ : FunctionRestParameter { CYNOT(@$); }
| FormalParameter[binding] FormalParameterList_[next] { $$ = CYNew CYFunctionParameter($binding, $next); }
;
;
/* }}} */
/* 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
/* }}} */
/* 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
/* }}} */
/* 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 {{{ */
;
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
/* }}} */
/* 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 LexLet LexOf ImportDeclaration
- | LexSetStatement LexLet LexOf 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" LexOf ModuleSpecifier Terminator
+ : "import" ImportClause[specifiers] FromClause[module] Terminator { $$ = CYNew CYImportDeclaration($specifiers, $module); }
+ | "import" LexOf ModuleSpecifier[module] Terminator { $$ = CYNew CYImportDeclaration(NULL, $module); }
;
ImportClause
- : ImportedDefaultBinding
- | LexOf NameSpaceImport
- | LexOf 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
- | LexOf
+ : ImportsList[pass] { $$ = $pass; }
+ | LexOf { $$ = NULL; }
;
ImportSpecifier
- : ImportedBinding
- | LexOf 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 {{{ */
/* Cycript (C): Type Encoding {{{ */
TypeSignifier
: IdentifierType[identifier] { $$ = CYNew CYTypedIdentifier(@identifier, $identifier); }
- | "(" "*" TypeQualifierRight[typed] ")" { $$ = $typed; }
+ | "(" "*" 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[parameters] ")" ParameterModifierOpt { $$ = CYNew CYTypeFunctionWith($parameters); }
;
SuffixedType
- : SuffixedType[typed] "[" NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); }
- | "(" "^" TypeQualifierRight[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[typed] "[" RestrictOpt NumericLiteral[size] "]" { $$ = $typed; $$->modifier_ = CYNew CYTypeArrayOf($size, $$->modifier_); }
+ | "(" "^" TypeQualifierRightOpt[typed] ")" "(" TypedParameterListOpt[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[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_); }
+ | Restrict TypeQualifierRightOpt[typed] { $$ = $typed; }
+ ;
+
+TypeQualifierRightOpt
+ : TypeQualifierRight[pass] { $$ = $pass; }
+ | TypeSignifierOpt[pass] { $$ = $pass; }
;
IntegerType
| { $$ = CYNew CYTypeVariable("int"); }
;
+StructFieldListOpt
+ : TypedIdentifierField[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" 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[modifier] PrimitiveType[specifier] TypeQualifierRight[typed] { $$ = $typed; $$->specifier_ = $specifier; CYSetLast($modifier) = $$->modifier_; $$->modifier_ = $modifier; }
+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[typed] ")" { $$ = CYNew CYEncodedType($typed); }
+ : "@encode" "(" TypedIdentifierEncoding[typed] ")" { $$ = CYNew CYEncodedType($typed); }
;
/* }}} */
@end
;
ImplementationFieldListOpt
- : TypedIdentifier[typed] ";" ImplementationFieldListOpt[next] { $$ = CYNew CYImplementationField($typed, $next); }
+ : TypedIdentifierField[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")); }
;
;
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
;
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
/* }}} */
/* 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 {{{ */
| "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; }
;
/* }}} */
-/* Cycript (C): auto Compatibility {{{ */
-Var_
- : "auto"
- ;
-/* }}} */
/* Cycript (C): Lambda Expressions {{{ */
TypedParameterList_
: "," TypedParameterList[parameters] { $$ = $parameters; }
;
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] ")" "->" 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[typed] { if ($typed->identifier_ == NULL) CYERR($typed->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($typed); }
+ : 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[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"); } ExternC[pass] { $$ = $pass; }
;
/* }}} */
-
@end
@begin E4X
;
XMLExpression
- : BRACE LexPushRegExp Expression LexPop "}"
+ : "{" LexPushRegExp Expression LexPop "}"
;
XMLTagName
| { $$ = 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; }
;
/* }}} */