X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/440424e2bd3babd0bb2c266ba931b3c41ccc0f65..2ca4dab349cc3f91032b17ced6b76023b4e67115:/Cycript.yy.in diff --git a/Cycript.yy.in b/Cycript.yy.in index 7ffc951..29a3755 100644 --- a/Cycript.yy.in +++ b/Cycript.yy.in @@ -1,33 +1,31 @@ /* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2012 Jay Freeman (saurik) + * Copyright (C) 2009-2014 Jay Freeman (saurik) */ -/* GNU Lesser General Public License, Version 3 {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Cycript is free software: you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Cycript is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with Cycript. If not, see . + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . **/ /* }}} */ -@if Bison23 %{ - -@if Bison24 %code top { +%code top { #define cyscanner driver.scanner_ #define YYSTACKEXPANDABLE 1 -@if Bison23 #define yyerrok (yyerrstatus_ = 0) -@if Bison24 } +} -@if Bison24 %code requires { +%code requires { +#include "Driver.hpp" #include "Parser.hpp" #define CYNew new($pool) @@ -71,6 +69,7 @@ typedef struct { CYInfix *infix_; CYLiteral *literal_; CYMember *member_; + CYModule *module_; CYNull *null_; CYNumber *number_; CYProgram *program_; @@ -81,10 +80,14 @@ typedef struct { CYString *string_; CYThis *this_; CYTrue *true_; - CYTypeModifier *type_; + CYWord *word_; + +@begin C + CYTypeModifier *modifier_; + CYTypeSpecifier *specifier_; CYTypedIdentifier *typedIdentifier_; CYTypedParameter *typedParameter_; - CYWord *word_; +@end @begin ObjectiveC CYClassName *className_; @@ -104,18 +107,15 @@ typedef struct { } YYSTYPE; #define YYSTYPE YYSTYPE -@if Bison24 } - -@if Bison24 %code provides { -int cylex(YYSTYPE *, cy::location *, void *); -@if Bison24 } +} -@if Bison23 %} +%code provides { +int cylex(YYSTYPE *, CYLocation *, void *); +} -%name-prefix="cy" +%name-prefix "cy" -@if Bison23 %skeleton "lalr1.cc" -@if Bison24 %language "C++" +%language "C++" %initial-action { @$.begin.filename = @$.end.filename = &driver.filename_; @@ -124,6 +124,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %locations %defines +%define api.location.type { CYLocation } + //%glr-parser //%expect 1 @@ -158,6 +160,7 @@ int cylex(YYSTYPE *, cy::location *, void *); @begin E4X ObjectiveC %token At "@" +%token Pound "#" @end %token Ampersand "&" @@ -223,17 +226,31 @@ int cylex(YYSTYPE *, cy::location *, void *); %token OpenBracket "[" %token CloseBracket "]" +%token AtError "@error" + @begin Java %token AtClass "@class" @end +@begin C +%token Typedef "typedef" +%token Unsigned "unsigned" +%token Signed "signed" +%token Extern "extern" +@end + +@begin C +%token AtEncode "@encode" +@end + @begin ObjectiveC %token AtImplementation "@implementation" %token AtImplementation_ ";@implementation" %token AtImport "@import" -%token AtEncode "@encode" %token AtEnd "@end" %token AtSelector "@selector" +%token Yes "YES" +%token No "NO" @end %token False "false" @@ -337,6 +354,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %type ArgumentList %type ArgumentListOpt %type Arguments +%type ArrayComprehension +%type ArrayInitialiser %type ArrayLiteral %type ArrowFunction %type ArrowParameters @@ -358,10 +377,10 @@ int cylex(YYSTYPE *, cy::location *, void *); %type CaseClause %type CaseClausesOpt %type CatchOpt -%type ComprehensionForList -%type ComprehensionForListOpt -%type ComprehensionList -%type ComprehensionListOpt +%type Comprehension +%type ComprehensionFor +%type ComprehensionIf +%type ComprehensionTail %type ConditionalExpression %type ContinueStatement %type ConciseBody @@ -382,7 +401,6 @@ int cylex(YYSTYPE *, cy::location *, void *); %type ExpressionOpt %type ExpressionStatement %type FinallyOpt -%type ForComprehension %type ForStatementInitialiser %type ForInStatementInitialiser %type FormalParameter @@ -394,8 +412,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %type FunctionExpression %type Identifier %type IdentifierOpt +%type IdentifierType %type IdentifierName -%type IfComprehension %type IfStatement %type Initialiser %type InitialiserOpt @@ -411,12 +429,13 @@ int cylex(YYSTYPE *, cy::location *, void *); %type MemberAccess %type MemberExpression_ %type MemberExpression +%type Module %type MultiplicativeExpression %type NewExpression %type NullLiteral %type ObjectLiteral %type Parenthetical -%type ParentheticalOpt +//%type ParentheticalOpt %type PostfixExpression %type PrimaryExpression %type Program @@ -454,9 +473,26 @@ int cylex(YYSTYPE *, cy::location *, void *); %type VariableStatement %type WithStatement %type Word +@begin ObjectiveC %type WordOpt +@end %type Variable +@begin C +%type IntegerType +%type IntegerTypeOpt +%type PrefixedType +%type PrimitiveType +%type SuffixedType +%type TypeSignifier +%type TypeQualifierLeft +%type TypeQualifierRight +%type TypedIdentifier +%type TypedParameterList_ +%type TypedParameterList +%type TypedParameterListOpt +@end + @begin ObjectiveC %type BoxableExpression %type CategoryStatement @@ -472,17 +508,12 @@ int cylex(YYSTYPE *, cy::location *, void *); %type ClassProtocolListOpt %type ClassProtocols %type ClassProtocolsOpt -%type EncodedType %type MessageExpression %type MessageParameter %type MessageParameters %type MessageParameterList %type MessageParameterListOpt %type MessageScope -%type ModifiedType -%type PrefixedType -%type PrimitiveType -%type QualifiedType %type SelectorCall_ %type SelectorCall %type SelectorExpression_ @@ -490,12 +521,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %type SelectorExpressionOpt %type SelectorList %type SelectorWordOpt -%type SuffixedType -%type TypeOpt -%type TypedIdentifier -%type TypedParameterList_ -%type TypedParameterList -%type TypedParameterListOpt +%type TypeOpt %type VariadicCall @end @@ -550,15 +576,17 @@ LexSetRegExp ; LexNoBrace - : { if (yychar == yyempty_) driver.no_.OpenBrace = true; else if (yychar == token::OpenBrace || yychar == token::OpenBrace_) yychar = token::OpenBrace__; } + : { if (yyla.empty()) driver.no_.OpenBrace = true; else if (yyla.type == yytranslate_(token::OpenBrace) || yyla.type == yytranslate_(token::OpenBrace_)) yyla.type = yytranslate_(token::OpenBrace__); } ; LexNoFunction - : { if (yychar == yyempty_) driver.no_.Function = true; else if (yychar == token::Function) yychar = token::Function_; } + : { if (yyla.empty()) driver.no_.Function = true; else if (yyla.type == yytranslate_(token::Function)) yyla.type = yytranslate_(token::Function_); } ; -LexNoAtImplementation - : { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; } +LexNoAtImplementation : +@begin ObjectiveC + { if (yyla.empty()) driver.no_.AtImplementation = true; else if (yyla.type == yytranslate_(token::AtImplementation)) yyla.type = yytranslate_(token::AtImplementation_); } +@end ; LexSetStatement @@ -632,12 +660,14 @@ Word | "with" { $$ = $1; } ; +@begin ObjectiveC WordOpt : Word { $$ = $1; } | { $$ = NULL; } ; +@end -Identifier +IdentifierType : Identifier_ { $$ = $1; } | "implements" { $$ = $1; } @@ -651,19 +681,14 @@ Identifier | "abstract" { $$ = $1; } | "boolean" { $$ = $1; } | "byte" { $$ = $1; } - | "char" { $$ = $1; } | "double" { $$ = $1; } | "final" { $$ = $1; } | "float" { $$ = $1; } | "goto" { $$ = $1; } - | "int" { $$ = $1; } - | "long" { $$ = $1; } | "native" { $$ = $1; } - | "short" { $$ = $1; } | "synchronized" { $$ = $1; } | "throws" { $$ = $1; } | "transient" { $$ = $1; } - | "volatile" { $$ = $1; } // XXX: currently I only have this as Word // | "let" { $$ = $1; } @@ -674,6 +699,25 @@ Identifier | "of" { $$ = $1; } ; +Identifier + : IdentifierType + | "char" { $$ = $1; } + | "int" { $$ = $1; } + | "long" { $$ = $1; } + | "short" { $$ = $1; } + | "volatile" { $$ = $1; } +@begin C + | "typedef" { $$ = $1; } + | "unsigned" { $$ = $1; } + | "signed" { $$ = $1; } + | "extern" { $$ = $1; } +@end +@begin ObjectiveC + | "YES" { $$ = $1; } + | "NO" { $$ = $1; } +@end + ; + IdentifierOpt : Identifier { $$ = $1; } | { $$ = NULL; } @@ -707,12 +751,12 @@ BooleanLiteral /* 7.9 Automatic Semicolon Insertion {{{ */ StrictSemi - : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); } + : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } ; Terminator : ";" - | error { if (yychar != yyeof_ && yychar != token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi + | error { if (yyla.type_get() != yyeof_ && yyla.type != token::CloseBrace && !yyla.value.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi ; TerminatorOpt @@ -726,10 +770,10 @@ Parenthetical : "(" LexPushInOff Expression ")" LexPopIn { $$ = $3; } ; -ParentheticalOpt +/*ParentheticalOpt : Parenthetical { $$ = $1; } | { $$ = NULL; } - ; + ;*/ Variable : Identifier { $$ = CYNew CYVariable($1); } @@ -739,14 +783,19 @@ PrimaryExpression : "this" { $$ = $1; } | Variable { $$ = $1; } | Literal { $$ = $1; } - | ArrayLiteral { $$ = $1; } + | ArrayInitialiser { $$ = $1; } | ObjectLiteral { $$ = $1; } - | FunctionExpression { $$ = $1; } | Parenthetical { $$ = $1; } | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; } ; /* }}} */ -/* 11.1.4.1 Array Initialiser {{{ */ +/* 11.1.4 Array Initializer {{{ */ +ArrayInitialiser + : ArrayLiteral { $$ = $1; } + | ArrayComprehension { $$ = $1; } + ; +/* }}} */ +/* 11.1.4.1 Array Literal {{{ */ ArrayLiteral : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); } ; @@ -771,19 +820,26 @@ ElementListOpt ; /* }}} */ /* 11.1.4.2 Array Comprehension {{{ */ -PrimaryExpression - : "[" LexPushInOff AssignmentExpression ComprehensionForList "]" LexPopIn { $$ = CYNew CYArrayComprehension($3, $4); } +ArrayComprehension + : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; } ; -ComprehensionForList - : "for" Binding "in" Expression ComprehensionForListOpt { $$ = CYNew CYForInComprehension($2, $4, $5); } - | "for" Binding "of" Expression ComprehensionForListOpt { $$ = CYNew CYForOfComprehension($2, $4, $5); } +Comprehension + : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); } ; -ComprehensionForListOpt - : ComprehensionForList { $$ = $1; } - | "if" Expression { $$ = CYNew CYIfComprehension($2); } - | { $$ = NULL; } +ComprehensionTail + : { $$ = NULL; } + | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); } + | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); } + ; + +ComprehensionFor + : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); } + ; + +ComprehensionIf + : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); } ; /* }}} */ /* 11.1.5 Object Initialiser {{{ */ @@ -838,6 +894,7 @@ MemberExpression_ MemberExpression : LexSetRegExp PrimaryExpression { $$ = $2; } + | LexSetRegExp FunctionExpression { $$ = $2; } | MemberExpression_ { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); } ; @@ -981,6 +1038,7 @@ LogicalORExpression ConditionalExpression : LogicalORExpression { $$ = $1; } | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); } + | LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); } ; /* }}} */ /* 11.13 Assignment Operators {{{ */ @@ -1004,11 +1062,11 @@ AssignmentExpression /* 11.14 Comma Operator {{{ */ Expression_ : "," Expression { $$ = $2; } - | { $$ = CYNew CYCompound(); } + | { $$ = NULL; } ; Expression - : AssignmentExpression Expression_ { $2->AddPrev($1); $$ = $2; } + : AssignmentExpression Expression_ { $$ = CYNew CYCompound($1, $2); } ; ExpressionOpt @@ -1344,48 +1402,72 @@ ProgramBodyOpt ; /* }}} */ -@begin ObjectiveC -/* Cycript (Objective-C): Type Encoding {{{ */ +@begin C +/* Cycript (C): Type Encoding {{{ */ +TypeSignifier + : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } + | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } + ; + SuffixedType - : IdentifierOpt { $$ = CYNew CYTypedIdentifier($1); } - | "(" LexPushInOff PrefixedType ")" LexPopIn { $$ = $3; } - | SuffixedType "[" NumericLiteral "]" { CYSetLast($1->type_) = CYNew CYTypeArrayOf($3->Value()); $$ = $1; } + : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } + | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); } + | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); } + | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); } + | TypeSignifier { $$ = $1; } + | { $$ = CYNew CYTypedIdentifier(@$); } ; PrefixedType - : SuffixedType { $$ = $1; } - | "const" PrefixedType { CYSetLast($2->type_) = CYNew CYTypeConstant(); $$ = $2; } - | "*" PrefixedType { CYSetLast($2->type_) = CYNew CYTypePointerTo(); $$ = $2; } + : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } ; -PrimitiveType - : Variable { $$ = $1; } - | "void" { $$ = CYNew cy::Syntax::New(CYNew CYVariable(CYNew CYIdentifier("Type")), CYNew CYArgument(CYNew CYString("v"))); } +TypeQualifierLeft + : { $$ = NULL; } + | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); } + | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } ; -QualifiedType - : PrimitiveType { $$ = CYNew CYTypeVariable($1); } - | "const" QualifiedType { $$ = CYNew CYTypeConstant($2); } +TypeQualifierRight + : PrefixedType { $$ = $1; } + | SuffixedType { $$ = $1; } + | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } + | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } ; -ModifiedType - : QualifiedType { $$ = $1; } - | QualifiedType "*" { $$ = CYNew CYTypePointerTo($1); } - | QualifiedType "const" { $$ = CYNew CYTypeConstant($1); } +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); } ; -TypedIdentifier - : QualifiedType PrefixedType { CYSetLast($2->type_) = $1; $$ = $2;} +IntegerTypeOpt + : IntegerType { $$ = $1; } + | { $$ = CYNew CYTypeVariable("int"); } ; -EncodedType - : TypedIdentifier { $$ = CYNew CYEncodedType($1->type_); } +PrimitiveType + : IdentifierType { $$ = CYNew CYTypeVariable($1); } + | IntegerType { $$ = $1; } + | "void" { $$ = CYNew CYTypeVoid(); } + | "char" { $$ = CYNew CYTypeVariable("char"); } + | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); } + | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); } + ; + +TypedIdentifier + : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } ; PrimaryExpression - : AtEncode "(" EncodedType ")" { $$ = $3; } + : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } ; /* }}} */ +@end + +@begin ObjectiveC /* Cycript (Objective-C): @class Declaration {{{ */ ClassSuperOpt /* XXX: why the hell did I choose MemberExpression? */ @@ -1394,7 +1476,7 @@ ClassSuperOpt ; ClassFieldListOpt - : Expression Identifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $2, $4); } + : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $3); } | LexSetRegExp { $$ = NULL; } ; @@ -1408,7 +1490,7 @@ MessageScope ; TypeOpt - : "(" LexSetRegExp EncodedType ")" { $$ = $3; } + : "(" LexSetRegExp TypedIdentifier ")" { $$ = $3; } | { $$ = NULL; } ; @@ -1539,23 +1621,20 @@ PrimaryExpression | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } ; /* }}} */ -/* Cycript (Objective-C): @import Directive {{{ */ -PathName - : "/" PathName - | "." PathName - | Word PathName - | - ; +@end -ImportPath - : "<" PathName ">" - | StringLiteral +/* Cycript: @import Directive {{{ */ +Module + : Module "." Word { $$ = CYNew CYModule($3, $1); } + | Word { $$ = CYNew CYModule($1); } ; -StatementListItem - : LexSetStatement LexSetRegExp "@import" ImportPath { $$ = CYNew CYImport(); } +Declaration__ + : "@import" Module { $$ = CYNew CYImport($2); } ; /* }}} */ + +@begin ObjectiveC /* Cycript (Objective-C): Boxed Expressions {{{ */ BoxableExpression : NullLiteral { $$ = $1; } @@ -1565,6 +1644,8 @@ BoxableExpression | ArrayLiteral { $$ = $1; } | ObjectLiteral { $$ = $1; } | Parenthetical { $$ = $1; } + | "YES" { $$ = CYNew CYTrue(); } + | "NO" { $$ = CYNew CYFalse(); } ; PrimaryExpression @@ -1572,22 +1653,13 @@ PrimaryExpression ; /* }}} */ /* Cycript (Objective-C): Block Expressions {{{ */ -TypedParameterList_ - : "," TypedParameterList { $$ = $2; } - | { $$ = NULL; } - ; - -TypedParameterList - : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } - ; - -TypedParameterListOpt - : TypedParameterList { $$ = $1; } - | { $$ = NULL; } +PrimaryExpression + : "^" TypedIdentifier { if ($2->identifier_ != NULL) error($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else error($2->location_, "expected parameters"); } ; - +/* }}} */ +/* Cycript (Objective-C): Instance Literals {{{ */ PrimaryExpression - : "^" ModifiedType "(" LexPushInOff TypedParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYObjCBlock($2, $5, $10); } + : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); } ; /* }}} */ @end @@ -1613,6 +1685,36 @@ Var_ : "auto" ; /* }}} */ +/* Cycript (C): Lambda Expressions {{{ */ +TypedParameterList_ + : "," TypedParameterList { $$ = $2; } + | { $$ = NULL; } + ; + +TypedParameterList + : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } + ; + +TypedParameterListOpt + : TypedParameterList { $$ = $1; } + | { $$ = NULL; } + ; + +PrimaryExpression + : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); } + ; +/* }}} */ +/* Cycript (C): Type Definitions {{{ */ +Statement__ + : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) error($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } + ; +/* }}} */ +/* Cycript (C): extern "C" {{{ */ +Statement__ + : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) YYABORT; } TypedIdentifier { if ($4->identifier_ == NULL) error($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } + ; +/* }}} */ + @end /* YUI: Documentation Comments {{{ */ @@ -1796,27 +1898,13 @@ Statement__ @end /* JavaScript 1.7: Array Comprehensions {{{ */ -IfComprehension - : "if" "(" Expression ")" { $$ = CYNew CYIfComprehension($3); } +Comprehension + : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); } ; -ForComprehension - : "for" "(" Identifier "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); } - | "for" "each" "(" Identifier "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); } - ; - -ComprehensionList - : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; } - ; - -ComprehensionListOpt - : ComprehensionList { $$ = $1; } - | IfComprehension { $$ = $1; } - | { $$ = NULL; } - ; - -PrimaryExpression - : "[" LexPushInOff AssignmentExpression ComprehensionList "]" LexPopIn { $$ = CYNew CYArrayComprehension($3, $4); } +ComprehensionFor + : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); } + | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); } ; /* }}} */ /* JavaScript 1.7: for each {{{ */