X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/ac9d4181bbfb217fda1fd531c3cd466b10a38564..341d1456832396678c21074a7ec2a07181e12f49:/Cycript.yy.in diff --git a/Cycript.yy.in b/Cycript.yy.in index 3a31f1e..8b00100 100644 --- a/Cycript.yy.in +++ b/Cycript.yy.in @@ -1,36 +1,34 @@ /* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2013 Jay Freeman (saurik) + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* GNU 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 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 + * 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 General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Cycript. If not, see . + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . **/ /* }}} */ -@if Bison23 %{ - -@if Bison24 %code top { +%code top { #define cyscanner driver.scanner_ #define YYSTACKEXPANDABLE 1 -@if Bison23 #define yyerrok (yyerrstatus_ = 0) -@if Bison24 } +} -@if Bison24 %code requires { +%code requires { #include "Driver.hpp" #include "Parser.hpp" -#define CYNew new($pool) +#include "Stack.hpp" +#define CYNew new(driver.pool_) @begin ObjectiveC #include "ObjectiveC/Syntax.hpp" @@ -58,7 +56,6 @@ typedef struct { cy::Syntax::Catch *catch_; CYComment *comment_; CYComprehension *comprehension_; - CYCompound *compound_; CYDeclaration *declaration_; CYDeclarations *declarations_; CYElement *element_; @@ -75,27 +72,31 @@ typedef struct { CYModule *module_; CYNull *null_; CYNumber *number_; + CYParenthetical *parenthetical_; CYProgram *program_; CYProperty *property_; CYPropertyName *propertyName_; CYRubyProc *rubyProc_; - CYTypeSpecifier *specifier_; CYStatement *statement_; CYString *string_; CYThis *this_; CYTrue *true_; CYWord *word_; +@begin C + CYTypeModifier *modifier_; + CYTypeSpecifier *specifier_; + CYTypedIdentifier *typedIdentifier_; + CYTypedParameter *typedParameter_; +@end + @begin ObjectiveC CYClassName *className_; - CYField *field_; + CYClassField *classField_; CYMessage *message_; CYMessageParameter *messageParameter_; CYProtocol *protocol_; CYSelectorPart *selector_; - CYTypeModifier *modifier_; - CYTypedIdentifier *typedIdentifier_; - CYTypedParameter *typedParameter_; @end @begin E4X @@ -107,18 +108,15 @@ typedef struct { } YYSTYPE; #define YYSTYPE YYSTYPE -@if Bison24 } +} -@if Bison24 %code provides { -int cylex(YYSTYPE *, cy::location *, void *); -@if Bison24 } +%code provides { +int cylex(YYSTYPE *, CYLocation *, void *); +} -@if Bison23 %} +%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_; @@ -127,6 +125,8 @@ int cylex(YYSTYPE *, cy::location *, void *); %locations %defines +%define api.location.type { CYLocation } + //%glr-parser //%expect 1 @@ -173,6 +173,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %token EqualEqual "==" %token EqualEqualEqual "===" %token EqualRight "=>" +%token EqualRight_ "\n=>" %token Exclamation "!" %token ExclamationEqual "!=" %token ExclamationEqualEqual "!==" @@ -237,78 +238,70 @@ int cylex(YYSTYPE *, cy::location *, void *); %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 AtNull "@null" +%token AtYes "@YES" +%token AtNo "@NO" +%token AtTrue "@true" +%token AtFalse "@false" %token Yes "YES" %token No "NO" @end -%token False "false" -%token Null "null" -%token True "true" - -// ES3/ES5/WIE/JSC Reserved -%token Auto "auto" -%token Break "break" -%token Case "case" -%token Catch "catch" -%token Continue "continue" -%token Default "default" -%token Delete "delete" -%token Do "do" -%token Else "else" -%token Finally "finally" -%token For "for" -%token Function "function" -%token Function_ ";function" -%token If "if" -%token In "in" -%token In_ "!in" -%token InstanceOf "instanceof" -%token New "new" -%token Return "return" -%token Switch "switch" -%token This "this" -%token Throw "throw" -%token Try "try" -%token TypeOf "typeof" -%token Var "var" -%token Void "void" -%token While "while" -%token With "with" - -// ES3/IE6 Future, ES5/JSC Reserved -%token Debugger "debugger" - -// ES3/ES5/IE6 Future, JSC Reserved -%token Const "const" - -// ES3/ES5/IE6/JSC Future -%token Class "class" -%token Enum "enum" -%token Export "export" -%token Extends "extends" -%token Import "import" -%token Super "super" - -// ES3 Future, ES5 Strict Future -%token Implements "implements" -%token Interface "interface" -%token Package "package" -%token Private "private" -%token Protected "protected" -%token Public "public" -%token Static "static" +%token False "false" +%token Null "null" +%token True "true" + +%token Break "break" +%token Case "case" +%token Catch "catch" +%token Class "class" +%token Const "const" +%token Continue "continue" +%token Debugger "debugger" +%token Default "default" +%token Delete "delete" +%token Do "do" +%token Else "else" +%token Enum "enum" +%token Export "export" +%token Extends "extends" +%token Finally "finally" +%token For "for" +%token Function "function" +%token Function_ ";function" +%token If "if" +%token Import "import" +%token In "in" +%token In_ "!in" +%token InstanceOf "instanceof" +%token New "new" +%token Return "return" +%token Super "super" +%token Switch "switch" +%token This "this" +%token Throw "throw" +%token Try "try" +%token TypeOf "typeof" +%token Var "var" +%token Void "void" +%token While "while" +%token With "with" -// ES3 Future %token Abstract "abstract" +%token Await "await" %token Boolean "boolean" %token Byte "byte" %token Char "char" @@ -316,25 +309,29 @@ int cylex(YYSTYPE *, cy::location *, void *); %token Final "final" %token Float "float" %token Goto "goto" +%token Implements "implements" %token Int "int" +%token Interface "interface" +%token Let "let" %token Long "long" %token Native "native" +%token Package "package" +%token Private "private" +%token Protected "protected" +%token Public "public" %token Short "short" +%token Static "static" %token Synchronized "synchronized" %token Throws "throws" %token Transient "transient" %token Volatile "volatile" - -// ES5 Strict -%token Let "let" %token Yield "yield" -// Woah?! +%token Auto "auto" %token Each "each" %token Of "of" @begin E4X -// E4X Conditional %token Namespace "namespace" %token XML "xml" @end @@ -393,8 +390,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %type ElseStatementOpt %type EmptyStatement %type EqualityExpression -%type Expression_ -%type Expression +%type Expression %type ExpressionOpt %type ExpressionStatement %type FinallyOpt @@ -426,12 +422,12 @@ 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 Parenthetical %type PostfixExpression %type PrimaryExpression %type Program @@ -469,16 +465,32 @@ 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 ArrayedType %type BoxableExpression %type CategoryStatement %type ClassExpression -%type ClassFieldListOpt -%type ClassFields +%type ClassFieldListOpt +%type ClassFields %type ClassStatement %type ClassSuperOpt %type ClassMessageDeclaration @@ -488,20 +500,12 @@ int cylex(YYSTYPE *, cy::location *, void *); %type ClassProtocolListOpt %type ClassProtocols %type ClassProtocolsOpt -%type EncodedType -%type FunctionedType -%type IntegerType -%type IntegerTypeOpt %type MessageExpression %type MessageParameter %type MessageParameters %type MessageParameterList %type MessageParameterListOpt %type MessageScope -%type ModifiedType -%type Module -%type PrefixedType -%type PrimitiveType %type SelectorCall_ %type SelectorCall %type SelectorExpression_ @@ -509,16 +513,7 @@ int cylex(YYSTYPE *, cy::location *, void *); %type SelectorExpressionOpt %type SelectorList %type SelectorWordOpt -%type SuffixedType -%type TypeOpt -%type TypeParenthetical -%type TypeQualifierLeft -%type TypeQualifierRight -%type TypeSignifier -%type TypedIdentifier -%type TypedParameterList_ -%type TypedParameterList -%type TypedParameterListOpt +%type TypeOpt %type VariadicCall @end @@ -573,16 +568,16 @@ 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 : @begin ObjectiveC - { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; } + { if (yyla.empty()) driver.no_.AtImplementation = true; else if (yyla.type == yytranslate_(token::AtImplementation)) yyla.type = yytranslate_(token::AtImplementation_); } @end ; @@ -613,74 +608,77 @@ NewLineOpt Word : Identifier { $$ = $1; } - | "auto" { $$ = $1; } - | "break" NewLineOpt { $$ = $1; } - | "case" { $$ = $1; } - | "catch" { $$ = $1; } - | "class" { $$ = $1; } - | "const" { $$ = $1; } - | "continue" NewLineOpt { $$ = $1; } - | "debugger" { $$ = $1; } - | "default" { $$ = $1; } - | "delete" { $$ = $1; } - | "do" { $$ = $1; } - | "else" { $$ = $1; } - | "enum" { $$ = $1; } - | "export" { $$ = $1; } - | "extends" { $$ = $1; } - | "false" { $$ = $1; } - | "finally" { $$ = $1; } - /* XXX: | "for" { $$ = $1; } */ - | "function" { $$ = $1; } - | "if" { $$ = $1; } - | "import" { $$ = $1; } - /* XXX: | "in" { $$ = $1; } */ - | "!in" { $$ = $1; } - /* XXX: | "instanceof" { $$ = $1; } */ + + | "auto" { $$ = CYNew CYWord("auto"); } + | "break" NewLineOpt { $$ = CYNew CYWord("break"); } + | "case" { $$ = CYNew CYWord("case"); } + | "catch" { $$ = CYNew CYWord("catch"); } + | "class" { $$ = CYNew CYWord("class"); } + | "const" { $$ = CYNew CYWord("const"); } + | "continue" NewLineOpt { $$ = CYNew CYWord("continue"); } + | "debugger" { $$ = CYNew CYWord("debugger"); } + | "default" { $$ = CYNew CYWord("default"); } + | "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); } + | "do" { $$ = CYNew CYWord("do"); } + | "else" { $$ = CYNew CYWord("else"); } + | "enum" { $$ = CYNew CYWord("enum"); } + | "export" { $$ = CYNew CYWord("export"); } + | "extends" { $$ = CYNew CYWord("extends"); } + | "false" { $$ = CYNew CYWord("false"); } + | "finally" { $$ = CYNew CYWord("finally"); } + /* XXX: | "for" { $$ = CYNew CYWord("for"); } */ + | "function" { $$ = CYNew CYWord("function"); } + | "if" { $$ = CYNew CYWord("if"); } + | "import" { $$ = CYNew CYWord("import"); } + /* XXX: | "in" { $$ = CYNew CYWord("in"); } */ + | "!in" { $$ = CYNew CYWord("in"); } + /* XXX: | "instanceof" { $$ = CYNew CYWord("instanceof"); } */ // XXX: as it currently is not an Identifier | "let" { $$ = $1; } - | "new" { $$ = $1; } - | "null" { $$ = $1; } - | "return" NewLineOpt { $$ = $1; } - | "super" { $$ = $1; } - | "switch" { $$ = $1; } - | "this" { $$ = $1; } - | "throw" NewLineOpt { $$ = $1; } - | "true" { $$ = $1; } - | "try" { $$ = $1; } - | "typeof" { $$ = $1; } - | "var" { $$ = $1; } - | "void" { $$ = $1; } - | "while" { $$ = $1; } - | "with" { $$ = $1; } + | "new" LexSetRegExp { $$ = CYNew CYWord("new"); } + | "null" { $$ = CYNew CYWord("null"); } + | "return" NewLineOpt { $$ = CYNew CYWord("return"); } + | "super" { $$ = CYNew CYWord("super"); } + | "switch" { $$ = CYNew CYWord("switch"); } + | "this" { $$ = CYNew CYWord("this"); } + | "throw" NewLineOpt { $$ = CYNew CYWord("throw"); } + | "true" { $$ = CYNew CYWord("true"); } + | "try" { $$ = CYNew CYWord("try"); } + | "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); } + | "var" { $$ = CYNew CYWord("var"); } + | "void" LexSetRegExp { $$ = CYNew CYWord("void"); } + | "while" { $$ = CYNew CYWord("while"); } + | "with" { $$ = CYNew CYWord("with"); } ; +@begin ObjectiveC WordOpt : Word { $$ = $1; } | { $$ = NULL; } ; +@end IdentifierType : Identifier_ { $$ = $1; } - | "implements" { $$ = $1; } - | "interface" { $$ = $1; } - | "package" { $$ = $1; } - | "private" { $$ = $1; } - | "protected" { $$ = $1; } - | "public" { $$ = $1; } - | "static" { $$ = $1; } - | "abstract" { $$ = $1; } + | "await" { $$ = $1; } | "boolean" { $$ = $1; } | "byte" { $$ = $1; } | "double" { $$ = $1; } | "final" { $$ = $1; } | "float" { $$ = $1; } | "goto" { $$ = $1; } + | "implements" { $$ = $1; } + | "interface" { $$ = $1; } | "native" { $$ = $1; } + | "package" { $$ = $1; } + | "private" { $$ = $1; } + | "protected" { $$ = $1; } + | "public" { $$ = $1; } + | "static" { $$ = $1; } | "synchronized" { $$ = $1; } | "throws" { $$ = $1; } | "transient" { $$ = $1; } @@ -688,7 +686,7 @@ IdentifierType // XXX: currently I only have this as Word // | "let" { $$ = $1; } - | "yield" { $$ = $1; } + | "yield" NewLineOpt { $$ = $1; } | "each" { $$ = $1; } | "of" { $$ = $1; } @@ -702,11 +700,14 @@ Identifier | "short" { $$ = $1; } | "volatile" { $$ = $1; } @begin C + | "extern" { $$ = $1; } + | "signed" { $$ = $1; } | "typedef" { $$ = $1; } | "unsigned" { $$ = $1; } - | "signed" { $$ = $1; } - | "YES" { $$ = $1; } +@end +@begin ObjectiveC | "NO" { $$ = $1; } + | "YES" { $$ = $1; } @end ; @@ -731,24 +732,24 @@ ValueLiteral /* }}} */ /* 7.8.1 Null Literals {{{ */ NullLiteral - : "null" { $$ = $1; } + : "null" { $$ = CYNew CYNull(); } ; /* }}} */ /* 7.8.2 Boolean Literals {{{ */ BooleanLiteral - : "true" { $$ = $1; } - | "false" { $$ = $1; } + : "true" { $$ = CYNew CYTrue(); } + | "false" { $$ = CYNew CYFalse(); } ; /* }}} */ /* 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 != yytranslate_(token::CloseBrace) && !yyla.value.newline_) { error(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi ; TerminatorOpt @@ -759,12 +760,7 @@ TerminatorOpt /* 11.1 Primary Expressions {{{ */ Parenthetical - : "(" LexPushInOff Expression ")" LexPopIn { $$ = $3; } - ; - -ParentheticalOpt - : Parenthetical { $$ = $1; } - | { $$ = NULL; } + : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); } ; Variable @@ -772,7 +768,7 @@ Variable ; PrimaryExpression - : "this" { $$ = $1; } + : "this" { $$ = CYNew CYThis(); } | Variable { $$ = $1; } | Literal { $$ = $1; } | ArrayInitialiser { $$ = $1; } @@ -917,6 +913,7 @@ ArgumentList_ ArgumentList : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); } + | LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); } ; ArgumentListOpt @@ -1052,13 +1049,9 @@ AssignmentExpression ; /* }}} */ /* 11.14 Comma Operator {{{ */ -Expression_ - : "," Expression { $$ = $2; } - | { $$ = NULL; } - ; - Expression - : AssignmentExpression Expression_ { $$ = CYNew CYCompound($1, $2); } + : AssignmentExpression { $$ = $1; } + | AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); } ; ExpressionOpt @@ -1303,7 +1296,7 @@ LabelledStatement /* }}} */ /* 12.13 The throw Statement {{{ */ ThrowStatement - : "throw" LexSetRegExp "\n" StrictSemi { YYABORT; } + : "throw" LexSetRegExp "\n" StrictSemi { error(@1, "throw without exception"); } | "throw" Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); } ; /* }}} */ @@ -1371,7 +1364,8 @@ ArrowFunction ArrowParameters : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); } - //| ParentheticalOpt { $$ = $1; } + | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; } + | Parenthetical { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); } ; ConciseBody @@ -1394,32 +1388,20 @@ ProgramBodyOpt ; /* }}} */ -@begin ObjectiveC -/* Cycript (Objective-C): Type Encoding {{{ */ -TypeParenthetical - : "(" LexPushInOff PrefixedType ")" LexPopIn { $$ = $3; } - ; - +@begin C +/* Cycript (C): Type Encoding {{{ */ TypeSignifier - : IdentifierType { $$ = CYNew CYTypedIdentifier($1); } - | TypeParenthetical { $$ = $1; } - ; - -ArrayedType - : ArrayedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } - | TypeSignifier { $$ = $1; } - | { $$ = CYNew CYTypedIdentifier(); } - ; - -FunctionedType - : "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypeFunctionWith($3); } + : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } + | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } ; SuffixedType - : ArrayedType { $$ = $1; } + : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); } - | TypeParenthetical FunctionedType { $$ = $1; CYSetLast($2) = $$->modifier_; $$->modifier_ = $2; } - | FunctionedType { $$ = CYNew CYTypedIdentifier(); CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } + | 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 @@ -1465,14 +1447,13 @@ TypedIdentifier : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } ; -EncodedType - : TypedIdentifier { $$ = CYNew CYEncodedType($1); } - ; - PrimaryExpression - : "@encode" "(" EncodedType ")" { $$ = $3; } + : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } ; /* }}} */ +@end + +@begin ObjectiveC /* Cycript (Objective-C): @class Declaration {{{ */ ClassSuperOpt /* XXX: why the hell did I choose MemberExpression? */ @@ -1481,7 +1462,7 @@ ClassSuperOpt ; ClassFieldListOpt - : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $3); } + : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); } | LexSetRegExp { $$ = NULL; } ; @@ -1495,12 +1476,12 @@ MessageScope ; TypeOpt - : "(" LexSetRegExp EncodedType ")" { $$ = $3; } - | { $$ = NULL; } + : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) error($3->location_, "unexpected identifier"); $$ = $3; } + | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } ; MessageParameter - : Word ":" TypeOpt Identifier { $$ = CYNew CYMessageParameter($1, $3, $4); } + : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); } ; MessageParameterList @@ -1514,7 +1495,7 @@ MessageParameterListOpt MessageParameters : MessageParameterList { $$ = $1; } - | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); } + | Word { $$ = CYNew CYMessageParameter($1, NULL); } ; ClassMessageDeclaration @@ -1594,7 +1575,7 @@ SelectorCall_ ; SelectorCall - : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); } + : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); } ; SelectorList @@ -1626,7 +1607,9 @@ PrimaryExpression | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } ; /* }}} */ -/* Cycript (Objective-C): @import Directive {{{ */ +@end + +/* Cycript: @import Directive {{{ */ Module : Module "." Word { $$ = CYNew CYModule($3, $1); } | Word { $$ = CYNew CYModule($1); } @@ -1636,6 +1619,8 @@ Declaration__ : "@import" Module { $$ = CYNew CYImport($2); } ; /* }}} */ + +@begin ObjectiveC /* Cycript (Objective-C): Boxed Expressions {{{ */ BoxableExpression : NullLiteral { $$ = $1; } @@ -1651,16 +1636,16 @@ BoxableExpression PrimaryExpression : "@" BoxableExpression { $$ = CYNew CYBox($2); } + | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); } + | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); } + | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); } + | "@false" { $$ = CYNew CYBox(CYNew CYFalse()); } + | "@null" { $$ = CYNew CYBox(CYNew CYNull()); } ; /* }}} */ /* Cycript (Objective-C): Block Expressions {{{ */ -ModifiedType - : TypeQualifierLeft PrimitiveType { $$ = CYNew CYTypedIdentifier(); $$->specifier_ = $2; $$->modifier_ = $1; } - | ModifiedType "*" { $$ = $1; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } - ; - PrimaryExpression - : "^" ModifiedType "(" LexPushInOff TypedParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYObjCBlock($2, $5, $10); } + : "^" 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 {{{ */ @@ -1712,9 +1697,15 @@ PrimaryExpression /* }}} */ /* Cycript (C): Type Definitions {{{ */ Statement__ - : "typedef" TypedIdentifier Terminator { $$ = CYNew CYTypeDefinition($2); } + : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) error($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } ; /* }}} */ +/* Cycript (C): extern "C" {{{ */ +Statement__ + : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) error(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) error($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } + ; +/* }}} */ + @end /* YUI: Documentation Comments {{{ */