/* 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 <http://www.gnu.org/licenses/>.
+ * 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 <http://www.gnu.org/licenses/>.
**/
/* }}} */
-@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"
@end
#include "Highlight.hpp"
+}
+
+%union { bool bool_; }
+
+%union { CYArgument *argument_; }
+%union { CYAssignment *assignment_; }
+%union { CYBoolean *boolean_; }
+%union { CYClause *clause_; }
+%union { cy::Syntax::Catch *catch_; }
+%union { CYComprehension *comprehension_; }
+%union { CYDeclaration *declaration_; }
+%union { CYDeclarations *declarations_; }
+%union { CYElement *element_; }
+%union { CYExpression *expression_; }
+%union { CYFalse *false_; }
+%union { CYFinally *finally_; }
+%union { CYForInitializer *for_; }
+%union { CYForInInitializer *forin_; }
+%union { CYFunctionParameter *functionParameter_; }
+%union { CYIdentifier *identifier_; }
+%union { CYInfix *infix_; }
+%union { CYLiteral *literal_; }
+%union { CYMember *member_; }
+%union { CYModule *module_; }
+%union { CYNull *null_; }
+%union { CYNumber *number_; }
+%union { CYParenthetical *parenthetical_; }
+%union { CYProperty *property_; }
+%union { CYPropertyName *propertyName_; }
+%union { CYRubyProc *rubyProc_; }
+%union { CYSpan *span_; }
+%union { CYStatement *statement_; }
+%union { CYString *string_; }
+%union { CYThis *this_; }
+%union { CYTrue *true_; }
+%union { CYWord *word_; }
-typedef struct {
- bool newline_;
- hi::Value highlight_;
-
- union {
- bool bool_;
-
- CYDriver::Condition condition_;
-
- CYArgument *argument_;
- CYAssignment *assignment_;
- CYBoolean *boolean_;
- CYClause *clause_;
- cy::Syntax::Catch *catch_;
- CYComment *comment_;
- CYComprehension *comprehension_;
- CYCompound *compound_;
- CYDeclaration *declaration_;
- CYDeclarations *declarations_;
- CYElement *element_;
- CYExpression *expression_;
- CYFalse *false_;
- CYFinally *finally_;
- CYForInitialiser *for_;
- CYForInInitialiser *forin_;
- CYFunctionParameter *functionParameter_;
- CYIdentifier *identifier_;
- CYInfix *infix_;
- CYLiteral *literal_;
- CYMember *member_;
- CYNull *null_;
- CYNumber *number_;
- CYProgram *program_;
- CYProperty *property_;
- CYPropertyName *propertyName_;
- CYRubyProc *rubyProc_;
- CYStatement *statement_;
- CYString *string_;
- CYThis *this_;
- CYTrue *true_;
- CYWord *word_;
+@begin C
+%union { CYTypeModifier *modifier_; }
+%union { CYTypeSpecifier *specifier_; }
+%union { CYTypedIdentifier *typedIdentifier_; }
+%union { CYTypedParameter *typedParameter_; }
+@end
@begin ObjectiveC
- CYClassName *className_;
- CYField *field_;
- CYMessage *message_;
- CYMessageParameter *messageParameter_;
- CYProtocol *protocol_;
- CYSelectorPart *selector_;
- CYTypeModifier *type_;
- CYTypedIdentifier *typedIdentifier_;
- CYTypedParameter *typedParameter_;
+%union { CYClassName *className_; }
+%union { CYClassField *classField_; }
+%union { CYMessage *message_; }
+%union { CYMessageParameter *messageParameter_; }
+%union { CYProtocol *protocol_; }
+%union { CYSelectorPart *selector_; }
@end
@begin E4X
- CYAttribute *attribute_;
- CYPropertyIdentifier *propertyIdentifier_;
- CYSelector *selector_;
+%union { CYAttribute *attribute_; }
+%union { CYPropertyIdentifier *propertyIdentifier_; }
+%union { CYSelector *selector_; }
@end
- };
-} YYSTYPE;
-#define YYSTYPE YYSTYPE
-@if Bison24 }
+%code provides {
+
+struct YYSTYPE {
+ cy::parser::semantic_type semantic_;
+ hi::Value highlight_;
+};
-@if Bison24 %code provides {
-int cylex(YYSTYPE *, cy::location *, void *);
-@if Bison24 }
+int cylex(YYSTYPE *, CYLocation *, void *);
-@if Bison23 %}
+}
-%name-prefix="cy"
+%code {
-@if Bison23 %skeleton "lalr1.cc"
-@if Bison24 %language "C++"
+#undef yylex
+_finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, void *scanner) {
+ YYSTYPE data;
+ int token(cylex(&data, location, scanner));
+ *semantic = data.semantic_;
+ return token;
+}
+
+#define CYMAP(to, from) do { \
+ if (yyla.empty()) \
+ yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, cyscanner)); \
+ if (yyla.type == yytranslate_(token::from)) \
+ yyla.type = yytranslate_(token::to); \
+} while (false)
+
+}
+
+%name-prefix "cy"
+
+%language "C++"
%initial-action {
@$.begin.filename = @$.end.filename = &driver.filename_;
%locations
%defines
+%define api.location.type { CYLocation }
+
//%glr-parser
//%expect 1
@begin E4X ObjectiveC
%token At "@"
+%token Pound "#"
@end
%token Ampersand "&"
%token EqualEqual "=="
%token EqualEqualEqual "==="
%token EqualRight "=>"
+%token EqualRight_ "\n=>"
%token Exclamation "!"
%token ExclamationEqual "!="
%token ExclamationEqualEqual "!=="
%token SemiColon ";"
%token NewLine "\n"
-%token <comment_> Comment
+%token Comment
%token OpenParen "("
%token CloseParen ")"
%token OpenBracket "["
%token CloseBracket "]"
-%token AtError "@error"
+%token At_error_ "@error"
@begin Java
-%token AtClass "@class"
+%token At_class_ "@class"
+@end
+
+@begin C
+%token _typedef_ "typedef"
+%token _unsigned_ "unsigned"
+%token _signed_ "signed"
+%token _extern_ "extern"
+@end
+
+@begin C
+%token At_encode_ "@encode"
@end
@begin ObjectiveC
-%token AtImplementation "@implementation"
-%token AtImplementation_ ";@implementation"
-%token AtImport "@import"
-%token AtEncode "@encode"
-%token AtEnd "@end"
-%token AtSelector "@selector"
+%token At_implementation_ "@implementation"
+%token At_import_ "@import"
+%token At_end_ "@end"
+%token At_selector_ "@selector"
+%token At_null_ "@null"
+%token At_YES_ "@YES"
+%token At_NO_ "@NO"
+%token At_true_ "@true"
+%token At_false_ "@false"
+%token _YES_ "YES"
+%token _NO_ "NO"
@end
-%token <false_> False "false"
-%token <null_> Null "null"
-%token <true_> True "true"
-
-// ES3/ES5/WIE/JSC Reserved
-%token <word_> Auto "auto"
-%token <word_> Break "break"
-%token <word_> Case "case"
-%token <word_> Catch "catch"
-%token <word_> Continue "continue"
-%token <word_> Default "default"
-%token <word_> Delete "delete"
-%token <word_> Do "do"
-%token <word_> Else "else"
-%token <word_> Finally "finally"
-%token <word_> For "for"
-%token <word_> Function "function"
-%token <word_> Function_ ";function"
-%token <word_> If "if"
-%token <word_> In "in"
-%token <word_> In_ "!in"
-%token <word_> InstanceOf "instanceof"
-%token <word_> New "new"
-%token <word_> Return "return"
-%token <word_> Switch "switch"
-%token <this_> This "this"
-%token <word_> Throw "throw"
-%token <word_> Try "try"
-%token <word_> TypeOf "typeof"
-%token <word_> Var "var"
-%token <word_> Void "void"
-%token <word_> While "while"
-%token <word_> With "with"
-
-// ES3/IE6 Future, ES5/JSC Reserved
-%token <word_> Debugger "debugger"
-
-// ES3/ES5/IE6 Future, JSC Reserved
-%token <word_> Const "const"
-
-// ES3/ES5/IE6/JSC Future
-%token <word_> Class "class"
-%token <word_> Enum "enum"
-%token <word_> Export "export"
-%token <word_> Extends "extends"
-%token <word_> Import "import"
-%token <word_> Super "super"
-
-// ES3 Future, ES5 Strict Future
-%token <identifier_> Implements "implements"
-%token <identifier_> Interface "interface"
-%token <identifier_> Package "package"
-%token <identifier_> Private "private"
-%token <identifier_> Protected "protected"
-%token <identifier_> Public "public"
-%token <identifier_> Static "static"
-
-// ES3 Future
-%token <identifier_> Abstract "abstract"
-%token <identifier_> Boolean "boolean"
-%token <identifier_> Byte "byte"
-%token <identifier_> Char "char"
-%token <identifier_> Double "double"
-%token <identifier_> Final "final"
-%token <identifier_> Float "float"
-%token <identifier_> Goto "goto"
-%token <identifier_> Int "int"
-%token <identifier_> Long "long"
-%token <identifier_> Native "native"
-%token <identifier_> Short "short"
-%token <identifier_> Synchronized "synchronized"
-%token <identifier_> Throws "throws"
-%token <identifier_> Transient "transient"
-%token <identifier_> Volatile "volatile"
-
-// ES5 Strict
-%token <identifier_> Let "let"
-%token <identifier_> Yield "yield"
-
-// Woah?!
-%token <identifier_> Each "each"
-%token <identifier_> Of "of"
+%token _false_ "false"
+%token _null_ "null"
+%token _true_ "true"
+
+%token _break_ "break"
+%token _case_ "case"
+%token _catch_ "catch"
+%token _class_ "class"
+%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"
+
+%token _abstract_ "abstract"
+%token _await_ "await"
+%token _boolean_ "boolean"
+%token _byte_ "byte"
+%token _char_ "char"
+%token _double_ "double"
+%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"
+%token _yield_ "yield"
+
+%token _undefined_ "undefined"
+
+@begin ObjectiveC
+%token _bool_ "bool"
+%token _BOOL_ "BOOL"
+%token _id_ "id"
+%token _nil_ "nil"
+%token _NULL_ "NULL"
+%token _SEL_ "SEL"
+@end
+
+%token _auto_ "auto"
+%token _each_ "each"
+%token _of_ "of"
@begin E4X
-// E4X Conditional
-%token <identifier_> Namespace "namespace"
-%token <identifier_> XML "xml"
+%token _namespace_ "namespace"
+%token _xml_ "xml"
@end
%token AutoComplete
%token <string_> StringLiteral
%token <literal_> RegularExpressionLiteral
+%token <string_> NoSubstitutionTemplate
+%token <string_> TemplateHead
+%token <string_> TemplateMiddle
+%token <string_> TemplateTail
+
%type <expression_> AdditiveExpression
%type <argument_> ArgumentList_
%type <argument_> ArgumentList
%type <argument_> ArgumentListOpt
%type <argument_> Arguments
+%type <expression_> ArrayComprehension
%type <literal_> ArrayLiteral
%type <expression_> ArrowFunction
%type <functionParameter_> ArrowParameters
%type <expression_> AssignmentExpression
+%type <expression_> AssignmentExpressionOpt
%type <identifier_> Binding
%type <identifier_> BindingIdentifier
%type <expression_> BitwiseANDExpression
-%type <statement_> Block_
%type <statement_> Block
+%type <statement_> BlockStatement
%type <boolean_> BooleanLiteral
%type <declaration_> BindingElement
%type <expression_> BitwiseORExpression
%type <clause_> CaseBlock
%type <clause_> CaseClause
%type <clause_> CaseClausesOpt
-%type <catch_> CatchOpt
-%type <comprehension_> ComprehensionForList
-%type <comprehension_> ComprehensionForListOpt
-%type <comprehension_> ComprehensionList
-%type <comprehension_> ComprehensionListOpt
+%type <catch_> Catch
+%type <identifier_> CatchParameter
+%type <expression_> Comprehension
+%type <comprehension_> ComprehensionFor
+%type <comprehension_> ComprehensionIf
+%type <comprehension_> ComprehensionTail
%type <expression_> ConditionalExpression
%type <statement_> ContinueStatement
%type <statement_> ConciseBody
+%type <parenthetical_> CoverParenthesizedExpressionAndArrowParameterList
%type <statement_> DebuggerStatement
%type <statement_> Declaration__
%type <statement_> Declaration_
%type <statement_> Declaration
%type <clause_> DefaultClause
-%type <expression_> Element
-%type <expression_> ElementOpt
%type <element_> ElementList
%type <element_> ElementListOpt
%type <statement_> ElseStatementOpt
%type <statement_> EmptyStatement
%type <expression_> EqualityExpression
-%type <compound_> Expression_
-%type <compound_> Expression
+%type <expression_> Expression
%type <expression_> ExpressionOpt
%type <statement_> ExpressionStatement
-%type <finally_> FinallyOpt
-%type <comprehension_> ForComprehension
-%type <for_> ForStatementInitialiser
-%type <forin_> ForInStatementInitialiser
+%type <finally_> Finally
+%type <for_> ForStatementInitializer
+%type <forin_> ForInStatementInitializer
%type <declaration_> FormalParameter
%type <functionParameter_> FormalParameterList_
%type <functionParameter_> FormalParameterList
%type <statement_> FunctionBody
%type <statement_> FunctionDeclaration
%type <expression_> FunctionExpression
+%type <statement_> HoistableDeclaration
%type <identifier_> Identifier
%type <identifier_> IdentifierOpt
+%type <identifier_> IdentifierType
%type <word_> IdentifierName
-%type <comprehension_> IfComprehension
+%type <expression_> IdentifierReference
%type <statement_> IfStatement
-%type <expression_> Initialiser
-%type <expression_> InitialiserOpt
+%type <expression_> Initializer
+%type <expression_> InitializerOpt
%type <statement_> IterationStatement
+%type <identifier_> LabelIdentifier
+%type <statement_> LabelledItem
%type <statement_> LabelledStatement
%type <expression_> LeftHandSideExpression
%type <statement_> LetStatement
%type <statement_> LexicalDeclaration
%type <literal_> Literal
-%type <literal_> ValueLiteral
%type <expression_> LogicalANDExpression
%type <expression_> LogicalORExpression
%type <member_> MemberAccess
%type <expression_> MemberExpression_
%type <expression_> MemberExpression
+%type <module_> Module
%type <expression_> MultiplicativeExpression
%type <expression_> NewExpression
%type <null_> NullLiteral
%type <literal_> ObjectLiteral
-%type <compound_> Parenthetical
-%type <compound_> ParentheticalOpt
%type <expression_> PostfixExpression
%type <expression_> PrimaryExpression
-%type <statement_> Program
-%type <statement_> ProgramBody
-%type <statement_> ProgramBodyOpt
%type <propertyName_> PropertyName_
%type <propertyName_> PropertyName
%type <property_> PropertyDefinition
%type <functionParameter_> RubyProcParameterList
%type <functionParameter_> RubyProcParameters
%type <functionParameter_> RubyProcParametersOpt
+%type <statement_> Script
+%type <statement_> ScriptBody
+%type <statement_> ScriptBodyOpt
%type <expression_> ShiftExpression
%type <declaration_> SingleNameBinding
%type <statement_> Statement__
%type <statement_> StatementListOpt
%type <statement_> StatementListItem
%type <statement_> SwitchStatement
+%type <expression_> TemplateLiteral
+%type <span_> TemplateSpans
%type <statement_> ThrowStatement
%type <statement_> TryStatement
%type <expression_> UnaryExpression_
%type <statement_> VariableStatement
%type <statement_> WithStatement
%type <word_> Word
+@begin ObjectiveC
%type <word_> WordOpt
-%type <expression_> Variable
+@end
+
+@begin C
+%type <specifier_> IntegerType
+%type <specifier_> IntegerTypeOpt
+%type <typedIdentifier_> PrefixedType
+%type <specifier_> PrimitiveType
+%type <typedIdentifier_> SuffixedType
+%type <typedIdentifier_> TypeSignifier
+%type <modifier_> TypeQualifierLeft
+%type <typedIdentifier_> TypeQualifierRight
+%type <typedIdentifier_> TypedIdentifier
+%type <typedParameter_> TypedParameterList_
+%type <typedParameter_> TypedParameterList
+%type <typedParameter_> TypedParameterListOpt
+@end
@begin ObjectiveC
%type <expression_> BoxableExpression
%type <statement_> CategoryStatement
-%type <expression_> ClassExpression
-%type <field_> ClassFieldListOpt
-%type <field_> ClassFields
+%type <classField_> ClassFieldListOpt
+%type <classField_> ClassFields
%type <statement_> ClassStatement
%type <expression_> ClassSuperOpt
%type <message_> ClassMessageDeclaration
%type <message_> ClassMessageDeclarationListOpt
%type <className_> ClassName
-%type <className_> ClassNameOpt
%type <protocol_> ClassProtocolListOpt
%type <protocol_> ClassProtocols
%type <protocol_> ClassProtocolsOpt
-%type <expression_> EncodedType
%type <expression_> MessageExpression
%type <messageParameter_> MessageParameter
%type <messageParameter_> MessageParameters
%type <messageParameter_> MessageParameterList
%type <messageParameter_> MessageParameterListOpt
%type <bool_> MessageScope
-%type <type_> ModifiedType
-%type <typedIdentifier_> PrefixedType
-%type <expression_> PrimitiveType
-%type <type_> QualifiedType
%type <argument_> SelectorCall_
%type <argument_> SelectorCall
%type <selector_> SelectorExpression_
%type <selector_> SelectorExpressionOpt
%type <argument_> SelectorList
%type <word_> SelectorWordOpt
-%type <typedIdentifier_> SuffixedType
-%type <expression_> TypeOpt
-%type <typedIdentifier_> TypedIdentifier
-%type <typedParameter_> TypedParameterList_
-%type <typedParameter_> TypedParameterList
-%type <typedParameter_> TypedParameterListOpt
+%type <typedIdentifier_> TypeOpt
%type <argument_> VariadicCall
@end
%nonassoc "else"
/* }}} */
-%start Program
+%start Script
%%
: { driver.SetCondition(CYDriver::RegExpCondition); }
;
+LexNewLine
+ : { if (!yyla.empty() && yyla.type_get() != yyeof_) error(@$, "unexpected lookahead"); driver.next_ = true; }
+ ;
+
LexNoBrace
- : { if (yychar == yyempty_) driver.no_.OpenBrace = true; else if (yychar == token::OpenBrace || yychar == token::OpenBrace_) yychar = token::OpenBrace__; }
+ : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); }
;
-LexNoFunction
- : { if (yychar == yyempty_) driver.no_.Function = true; else if (yychar == token::Function) yychar = token::Function_; }
+LexNoClass
+ : { CYMAP(_class__, _class_); }
;
-LexNoAtImplementation :
-@begin ObjectiveC
- { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; }
-@end
+LexNoFunction
+ : { CYMAP(_function__, _function_); }
;
LexSetStatement
- : LexNoBrace LexNoFunction LexNoAtImplementation
+ : LexNoBrace LexNoClass LexNoFunction
;
/* }}} */
/* Virtual Tokens {{{ */
;
/* }}} */
-/* 7.6 Identifier Names and Identifiers {{{ */
+/* 11.6 Names and Keywords {{{ */
IdentifierName
: Word { $$ = $1; }
- ;
-
-NewLineOpt
- : "\n"
- |
+ | "for" { $$ = CYNew CYWord("for"); }
+ | "in" { $$ = CYNew CYWord("in"); }
+ | "instanceof" { $$ = CYNew CYWord("instanceof"); }
;
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; } */
-
- // 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; }
+ | "auto" { $$ = CYNew CYWord("auto"); }
+ | "break" { $$ = CYNew CYWord("break"); }
+ | "case" { $$ = CYNew CYWord("case"); }
+ | "catch" { $$ = CYNew CYWord("catch"); }
+ | "class" { $$ = CYNew CYWord("class"); }
+ | "!class" { $$ = CYNew CYWord("class"); }
+ | "const" { $$ = CYNew CYWord("const"); }
+ | "continue" { $$ = CYNew CYWord("continue"); }
+ | "debugger" { $$ = CYNew CYWord("debugger"); }
+ | "default" { $$ = CYNew CYWord("default"); }
+ | "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); }
+ | "do" { $$ = CYNew CYWord("do"); }
+ | "else" { $$ = CYNew CYWord("else"); }
+ | "enum" { $$ = CYNew CYWord("enum"); }
+ | "export" { $$ = CYNew CYWord("export"); }
+ | "extends" { $$ = CYNew CYWord("extends"); }
+ | "false" { $$ = CYNew CYWord("false"); }
+ | "finally" { $$ = CYNew CYWord("finally"); }
+ | "function" { $$ = CYNew CYWord("function"); }
+ | "if" { $$ = CYNew CYWord("if"); }
+ | "import" { $$ = CYNew CYWord("import"); }
+ | "!in" { $$ = CYNew CYWord("in"); }
+ | "new" LexSetRegExp { $$ = CYNew CYWord("new"); }
+ | "null" { $$ = CYNew CYWord("null"); }
+ | "return" { $$ = CYNew CYWord("return"); }
+ | "super" { $$ = CYNew CYWord("super"); }
+ | "switch" { $$ = CYNew CYWord("switch"); }
+ | "this" { $$ = CYNew CYWord("this"); }
+ | "throw" { $$ = CYNew CYWord("throw"); }
+ | "true" { $$ = CYNew CYWord("true"); }
+ | "try" { $$ = CYNew CYWord("try"); }
+ | "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); }
+ | "var" { $$ = CYNew CYWord("var"); }
+ | "void" LexSetRegExp { $$ = CYNew CYWord("void"); }
+ | "while" { $$ = CYNew CYWord("while"); }
+ | "with" { $$ = CYNew CYWord("with"); }
+
+ // XXX: should be Identifier
+ | "let" { $$ = CYNew CYIdentifier("let"); }
;
+@begin ObjectiveC
WordOpt
: Word { $$ = $1; }
| { $$ = NULL; }
;
-
-Identifier
- : Identifier_ { $$ = $1; }
-
- | "implements" { $$ = $1; }
- | "interface" { $$ = $1; }
- | "package" { $$ = $1; }
- | "private" { $$ = $1; }
- | "protected" { $$ = $1; }
- | "public" { $$ = $1; }
- | "static" { $$ = $1; }
-
- | "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; }
-
- | "yield" { $$ = $1; }
-
- | "each" { $$ = $1; }
- | "of" { $$ = $1; }
- ;
-
-IdentifierOpt
- : Identifier { $$ = $1; }
- | { $$ = NULL; }
- ;
-/* }}} */
-
-/* 7.8 Literals {{{ */
-Literal
- : NullLiteral { $$ = $1; }
- | ValueLiteral { $$ = $1; }
- ;
-
-ValueLiteral
- : BooleanLiteral { $$ = $1; }
- | NumericLiteral { $$ = $1; }
- | StringLiteral { $$ = $1; }
- | RegularExpressionLiteral { $$ = $1; }
- ;
+@end
/* }}} */
-/* 7.8.1 Null Literals {{{ */
+/* 11.8.1 Null Literals {{{ */
NullLiteral
- : "null" { $$ = $1; }
+ : "null" { $$ = CYNew CYNull(); }
;
/* }}} */
-/* 7.8.2 Boolean Literals {{{ */
+/* 11.8.2 Boolean Literals {{{ */
BooleanLiteral
- : "true" { $$ = $1; }
- | "false" { $$ = $1; }
+ : "true" { $$ = CYNew CYTrue(); }
+ | "false" { $$ = CYNew CYFalse(); }
;
/* }}} */
-/* 7.9 Automatic Semicolon Insertion {{{ */
+/* 11.9 Automatic Semicolon Insertion {{{ */
StrictSemi
- : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); }
+ : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
+ ;
+
+TerminatorSoft
+ : ";"
+ | "\n" StrictSemi
;
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) && !driver.newline_) { error(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
;
TerminatorOpt
;
/* }}} */
-/* 11.1 Primary Expressions {{{ */
-Parenthetical
- : "(" LexPushInOff Expression ")" LexPopIn { $$ = $3; }
+/* 12.1 Identifiers {{{ */
+IdentifierReference
+ : Identifier { $$ = CYNew CYVariable($1); }
+ // XXX: | "yield"
;
-ParentheticalOpt
- : Parenthetical { $$ = $1; }
- | { $$ = NULL; }
+BindingIdentifier
+ : Identifier { $$ = $1; }
+ // XXX: | "yield"
;
-Variable
- : Identifier { $$ = CYNew CYVariable($1); }
+LabelIdentifier
+ : Identifier { $$ = $1; }
+ // XXX: | yield
;
+IdentifierType
+ : Identifier_ { $$ = $1; }
+ | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
+ | "await" { $$ = CYNew CYIdentifier("await"); }
+ | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
+ | "byte" { $$ = CYNew CYIdentifier("byte"); }
+ | "double" { $$ = CYNew CYIdentifier("double"); }
+ | "each" { $$ = CYNew CYIdentifier("each"); }
+ | "final" { $$ = CYNew CYIdentifier("final"); }
+ | "float" { $$ = CYNew CYIdentifier("float"); }
+ | "goto" { $$ = CYNew CYIdentifier("goto"); }
+ | "implements" { $$ = CYNew CYIdentifier("implements"); }
+ | "interface" { $$ = CYNew CYIdentifier("interface"); }
+ | "native" { $$ = CYNew CYIdentifier("native"); }
+ | "of" { $$ = CYNew CYIdentifier("of"); }
+ | "package" { $$ = CYNew CYIdentifier("package"); }
+ | "private" { $$ = CYNew CYIdentifier("private"); }
+ | "protected" { $$ = CYNew CYIdentifier("protected"); }
+ | "public" { $$ = CYNew CYIdentifier("public"); }
+ | "static" { $$ = CYNew CYIdentifier("static"); }
+ | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); }
+ | "throws" { $$ = CYNew CYIdentifier("throws"); }
+ | "transient" { $$ = CYNew CYIdentifier("transient"); }
+ | "yield" { $$ = CYNew CYIdentifier("yield"); }
+@begin ObjectiveC
+ | "bool" { $$ = CYNew CYIdentifier("bool"); }
+ | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); }
+ | "id" { $$ = CYNew CYIdentifier("id"); }
+ | "SEL" { $$ = CYNew CYIdentifier("SEL"); }
+@end
+ ;
+
+Identifier
+ : IdentifierType
+ | "char" { $$ = CYNew CYIdentifier("char"); }
+ | "int" { $$ = CYNew CYIdentifier("int"); }
+ | "long" { $$ = CYNew CYIdentifier("long"); }
+ | "short" { $$ = CYNew CYIdentifier("short"); }
+ | "undefined" { $$ = CYNew CYIdentifier("undefined"); }
+ | "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
+ | "nil" { $$ = CYNew CYIdentifier("nil"); }
+ | "NO" { $$ = CYNew CYIdentifier("NO"); }
+ | "NULL" { $$ = CYNew CYIdentifier("NULL"); }
+ | "YES" { $$ = CYNew CYIdentifier("YES"); }
+@end
+ ;
+
+IdentifierOpt
+ : Identifier { $$ = $1; }
+ | { $$ = NULL; }
+ ;
+/* }}} */
+/* 12.2 Primary Expression {{{ */
PrimaryExpression
- : "this" { $$ = $1; }
- | Variable { $$ = $1; }
+ : "this" { $$ = CYNew CYThis(); }
+ | IdentifierReference { $$ = $1; }
| Literal { $$ = $1; }
| ArrayLiteral { $$ = $1; }
| ObjectLiteral { $$ = $1; }
- | FunctionExpression { $$ = $1; }
- | Parenthetical { $$ = $1; }
+ | RegularExpressionLiteral { $$ = $1; }
+ | TemplateLiteral { $$ = $1; }
+ | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) error(@1, "invalid parenthetical"); $$ = $1; }
| AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; }
;
+
+CoverParenthesizedExpressionAndArrowParameterList
+ : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }
+ | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }
+ ;
+/* }}} */
+/* 12.2.4 Literals {{{ */
+Literal
+ : NullLiteral { $$ = $1; }
+ | BooleanLiteral { $$ = $1; }
+ | NumericLiteral { $$ = $1; }
+ | StringLiteral { $$ = $1; }
+ ;
/* }}} */
-/* 11.1.4.1 Array Initialiser {{{ */
+/* 12.2.5 Array Initializer {{{ */
ArrayLiteral
: "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
;
-Element
- : AssignmentExpression { $$ = $1; }
- ;
-
-ElementOpt
- : Element { $$ = $1; }
- | LexSetRegExp { $$ = NULL; }
- ;
-
ElementList
- : ElementOpt "," ElementListOpt { $$ = CYNew CYElement($1, $3); }
- | Element { $$ = CYNew CYElement($1, NULL); }
+ : AssignmentExpressionOpt "," ElementListOpt { $$ = CYNew CYElementValue($1, $3); }
+ | LexSetRegExp "..." AssignmentExpression { $$ = CYNew CYElementSpread($3); }
+ | AssignmentExpression { $$ = CYNew CYElementValue($1, NULL); }
;
ElementListOpt
| LexSetRegExp { $$ = NULL; }
;
/* }}} */
-/* 11.1.4.2 Array Comprehension {{{ */
-PrimaryExpression
- : "[" LexPushInOff AssignmentExpression ComprehensionForList "]" LexPopIn { $$ = CYNew CYArrayComprehension($3, $4); }
- ;
-
-ComprehensionForList
- : "for" Binding "in" Expression ComprehensionForListOpt { $$ = CYNew CYForInComprehension($2, $4, $5); }
- | "for" Binding "of" Expression ComprehensionForListOpt { $$ = CYNew CYForOfComprehension($2, $4, $5); }
- ;
-
-ComprehensionForListOpt
- : ComprehensionForList { $$ = $1; }
- | "if" Expression { $$ = CYNew CYIfComprehension($2); }
- | { $$ = NULL; }
- ;
-/* }}} */
-/* 11.1.5 Object Initialiser {{{ */
+/* 12.2.6 Object Initializer {{{ */
ObjectLiteral
: BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); }
;
PropertyName
: LexSetRegExp PropertyName_ { $$ = $2; }
;
+
+
+Initializer
+ : "=" AssignmentExpression { $$ = $2; }
+ ;
+
+InitializerOpt
+ : Initializer { $$ = $1; }
+ | { $$ = NULL; }
+ ;
/* }}} */
+/* 12.2.9 Template Literals {{{ */
+TemplateLiteral
+ : NoSubstitutionTemplate { $$ = CYNew CYTemplate($1, NULL); }
+ | TemplateHead TemplateSpans { $$ = CYNew CYTemplate($1, $2); }
+ ;
-/* 11.2 Left-Hand-Side Expressions {{{ */
+TemplateSpans
+ : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); }
+ | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); }
+ ;
+/* }}} */
+
+/* 12.3+ Left-Hand-Side Expressions {{{ */
MemberAccess
: "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
| "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
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); }
;
ArgumentList
: AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }
+ | LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); }
;
ArgumentListOpt
| CallExpression { $$ = $1; }
;
/* }}} */
-/* 11.3 Postfix Expressions {{{ */
+/* 12.4 Postfix Expressions {{{ */
PostfixExpression
: %prec "" LeftHandSideExpression { $$ = $1; }
| LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); }
| LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); }
;
/* }}} */
-/* 11.4 Unary Operators {{{ */
+/* 12.5 Unary Operators {{{ */
UnaryExpression_
: "delete" UnaryExpression { $$ = CYNew CYDelete($2); }
| "void" UnaryExpression { $$ = CYNew CYVoid($2); }
| LexSetRegExp UnaryExpression_ { $$ = $2; }
;
/* }}} */
-/* 11.5 Multiplicative Operators {{{ */
+/* 12.6 Multiplicative Operators {{{ */
MultiplicativeExpression
: UnaryExpression { $$ = $1; }
| MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); }
| MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); }
;
/* }}} */
-/* 11.6 Additive Operators {{{ */
+/* 12.7 Additive Operators {{{ */
AdditiveExpression
: MultiplicativeExpression { $$ = $1; }
| AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); }
| AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); }
;
/* }}} */
-/* 11.7 Bitwise Shift Operators {{{ */
+/* 12.8 Bitwise Shift Operators {{{ */
ShiftExpression
: AdditiveExpression { $$ = $1; }
| ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); }
| ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); }
;
/* }}} */
-/* 11.8 Relational Operators {{{ */
+/* 12.9 Relational Operators {{{ */
RelationalExpression
: ShiftExpression { $$ = $1; }
| RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); }
| RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); }
;
/* }}} */
-/* 11.9 Equality Operators {{{ */
+/* 12.10 Equality Operators {{{ */
EqualityExpression
: RelationalExpression { $$ = $1; }
| EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); }
| EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); }
;
/* }}} */
-/* 11.10 Binary Bitwise Operators {{{ */
+/* 12.11 Binary Bitwise Operators {{{ */
BitwiseANDExpression
: EqualityExpression { $$ = $1; }
| BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); }
| BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); }
;
/* }}} */
-/* 11.11 Binary Logical Operators {{{ */
+/* 12.12 Binary Logical Operators {{{ */
LogicalANDExpression
: BitwiseORExpression { $$ = $1; }
| LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); }
| LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); }
;
/* }}} */
-/* 11.12 Conditional Operator ( ? : ) {{{ */
+/* 12.13 Conditional Operator ( ? : ) {{{ */
ConditionalExpression
: LogicalORExpression { $$ = $1; }
| LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
;
/* }}} */
-/* 11.13 Assignment Operators {{{ */
+/* 12.14 Assignment Operators {{{ */
AssignmentExpression
: ConditionalExpression { $$ = $1; }
+ // XXX: | YieldExpression { $$ = $1; }
| ArrowFunction { $$ = $1; }
| LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
| LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
| LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
| LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
;
-/* }}} */
-/* 11.14 Comma Operator {{{ */
-Expression_
- : "," Expression { $$ = $2; }
- | { $$ = CYNew CYCompound(); }
- ;
+AssignmentExpressionOpt
+ : AssignmentExpression { $$ = $1; }
+ | LexSetRegExp { $$ = NULL; }
+ ;
+/* }}} */
+/* 12.15 Comma Operator ( , ) {{{ */
Expression
- : AssignmentExpression Expression_ { $2->AddPrev($1); $$ = $2; }
+ : AssignmentExpression { $$ = $1; }
+ /* XXX: I have this backwards... */
+ | AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); }
;
ExpressionOpt
;
/* }}} */
-/* 12 Statements {{{ */
+/* 13 Statements and Declarations {{{ */
Statement__
- : Block { $$ = $1; }
+ : BlockStatement { $$ = $1; }
| VariableStatement { $$ = $1; }
| EmptyStatement { $$ = $1; }
| IfStatement { $$ = $1; }
;
Declaration__
- : FunctionDeclaration { $$ = $1; }
+ : HoistableDeclaration { $$ = $1; }
+ // XXX: | ClassDeclaration { $$ = $1; }
| LexicalDeclaration { $$ = $1; }
;
: LexSetStatement Declaration_ { $$ = $2; }
;
+HoistableDeclaration
+ : FunctionDeclaration
+ // XXX: | GeneratorDeclaration
+ ;
+
BreakableStatement
: IterationStatement { $$ = $1; }
| SwitchStatement { $$ = $1; }
;
/* }}} */
-/* 12.1 Block {{{ */
-Block_
- : BRACE StatementListOpt "}" { $$ = $2; }
+/* 13.2 Block {{{ */
+BlockStatement
+ : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
;
Block
- : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
+ : BRACE StatementListOpt "}" { $$ = $2; }
;
StatementList
| Declaration { $$ = $1; }
;
/* }}} */
-
-/* 12.2 Declarations {{{ */
-BindingIdentifier
- : Identifier { $$ = $1; }
- ;
-
-Binding
- : BindingIdentifier
- ;
-
-// XXX: BindingPattern
-/* }}} */
-/* 12.2.1 Let and Const Declarations {{{ */
+/* 13.3+ Let and Const Declarations {{{ */
LexicalDeclaration
: LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
;
: "let"
| "const"
;
+
+Binding
+ : BindingIdentifier
+ ;
+
+// XXX: lots of binding stuff
/* }}} */
-/* 12.2.2 Variable Statement {{{ */
+/* 13.3.2+ Variable Statement {{{ */
VariableStatement
: Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
;
;
VariableDeclaration
- : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
- // XXX: | BindingPattern Initialiser { $$ = CYNew CYDeclaration($1, $2); }
- ;
-
-Initialiser
- : "=" AssignmentExpression { $$ = $2; }
- ;
-
-InitialiserOpt
- : Initialiser { $$ = $1; }
- | { $$ = NULL; }
+ : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); }
+ // XXX: | BindingPattern Initializer { $$ = CYNew CYDeclaration($1, $2); }
;
/* }}} */
-/* 12.2.4 Destructuring Binding Patterns {{{ */
+/* 13.3.3+ Destructuring Binding Patterns {{{ */
// XXX: *
BindingElement
;
SingleNameBinding
- : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
+ : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); }
;
/* }}} */
-
-/* 12.3 Empty Statement {{{ */
+/* 13.4 Empty Statement {{{ */
EmptyStatement
: ";" { $$ = CYNew CYEmpty(); }
;
/* }}} */
-/* 12.4 Expression Statement {{{ */
+/* 13.5 Expression Statement {{{ */
ExpressionStatement
: Expression Terminator { $$ = CYNew CYExpress($1); }
;
/* }}} */
-/* 12.5 The if Statement {{{ */
+/* 13.6 The if Statement {{{ */
ElseStatementOpt
: "else" Statement { $$ = $2; }
| %prec "if" { $$ = NULL; }
: "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); }
;
/* }}} */
-
-/* 12.6.1 The do-while Statement {{{ */
+/* 13.7+ Iteration Statements {{{ */
IterationStatement
: "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
- ;
-/* }}} */
-/* 12.6.2 The while Statement {{{ */
-IterationStatement
- : "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
- ;
-/* }}} */
-/* 12.6.3 The for Statement {{{ */
-IterationStatement
- : "for" "(" LexPushInOn ForStatementInitialiser ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
+ | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
+ | "for" "(" LexPushInOn ForStatementInitializer ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
+ | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
+ | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }
;
-ForStatementInitialiser
+ForStatementInitializer
: ExpressionOpt { $$ = $1; }
| LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
;
-/* }}} */
-/* 12.6.4 The for-in and for-of Statements {{{ */
-IterationStatement
- : "for" "(" LexPushInOn ForInStatementInitialiser "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
- | "for" "(" LexPushInOn ForInStatementInitialiser "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }
- ;
-ForInStatementInitialiser
+ForInStatementInitializer
: LeftHandSideExpression { $$ = $1; }
| LexSetRegExp Var_ VariableDeclaration { $$ = $3; }
;
/* }}} */
+/* 13.8 The continue Statement {{{ */
+Continue
+ : "continue" LexNewLine
+ ;
-/* 12.7 The continue Statement {{{ */
ContinueStatement
- : "continue" "\n" StrictSemi { $$ = CYNew CYContinue(NULL); }
- | "continue" IdentifierOpt Terminator { $$ = CYNew CYContinue($2); }
+ : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); }
+ | Continue Identifier Terminator { $$ = CYNew CYContinue($2); }
;
/* }}} */
-/* 12.8 The break Statement {{{ */
+/* 13.9 The break Statement {{{ */
+Break
+ : "break" LexNewLine
+ ;
+
BreakStatement
- : "break" "\n" StrictSemi { $$ = CYNew CYBreak(NULL); }
- | "break" IdentifierOpt Terminator { $$ = CYNew CYBreak($2); }
+ : Break TerminatorSoft { $$ = CYNew CYBreak(NULL); }
+ | Break Identifier Terminator { $$ = CYNew CYBreak($2); }
;
/* }}} */
-/* 12.9 The return Statement {{{ */
+/* 13.10 The return Statement {{{ */
+Return
+ : "return" LexNewLine
+ ;
+
ReturnStatement
- : "return" LexSetRegExp "\n" StrictSemi { $$ = CYNew CYReturn(NULL); }
- | "return" ExpressionOpt Terminator { $$ = CYNew CYReturn($2); }
+ : Return LexSetRegExp TerminatorSoft { $$ = CYNew CYReturn(NULL); }
+ | Return Expression Terminator { $$ = CYNew CYReturn($2); }
;
/* }}} */
-/* 12.10 The with Statement {{{ */
+/* 13.11 The with Statement {{{ */
WithStatement
: "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); }
;
/* }}} */
-
-/* 12.11 The switch Statement {{{ */
+/* 13.12 The switch Statement {{{ */
SwitchStatement
: "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); }
;
| { $$ = NULL; }
;
+// XXX: the standard makes certain you can only have one of these
DefaultClause
: "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
;
/* }}} */
-/* 12.12 Labelled Statements {{{ */
+/* 13.13 Labelled Statements {{{ */
LabelledStatement
- : Identifier ":" Statement { $$ = CYNew CYLabel($1, $3); }
+ : LabelIdentifier ":" LabelledItem { $$ = CYNew CYLabel($1, $3); }
+ ;
+
+LabelledItem
+ : Statement { $$ = $1; }
+ | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; }
;
/* }}} */
-/* 12.13 The throw Statement {{{ */
+/* 13.14 The throw Statement {{{ */
+Throw
+ : "throw" LexNewLine
+ ;
+
ThrowStatement
- : "throw" LexSetRegExp "\n" StrictSemi { YYABORT; }
- | "throw" Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); }
+ : Throw LexSetRegExp TerminatorSoft { error(@1, "throw without exception"); }
+ | Throw Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); }
;
/* }}} */
-/* 12.14 The try Statement {{{ */
+/* 13.15 The try Statement {{{ */
TryStatement
- : "try" Block_ CatchOpt FinallyOpt { $$ = CYNew cy::Syntax::Try($2, $3, $4); }
+ : "try" Block Catch { $$ = CYNew cy::Syntax::Try($2, $3, NULL); }
+ | "try" Block Finally { $$ = CYNew cy::Syntax::Try($2, NULL, $3); }
+ | "try" Block Catch Finally { $$ = CYNew cy::Syntax::Try($2, $3, $4); }
;
-CatchOpt
- : "catch" "(" Identifier ")" Block_ { $$ = CYNew cy::Syntax::Catch($3, $5); }
- | { $$ = NULL; }
+Catch
+ : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); }
;
-FinallyOpt
- : "finally" Block_ { $$ = CYNew CYFinally($2); }
- | { $$ = NULL; }
+Finally
+ : "finally" Block { $$ = CYNew CYFinally($2); }
+ ;
+
+CatchParameter
+ : BindingIdentifier { $$ = $1; }
+ // XXX: BindingPattern
;
/* }}} */
-/* 12.14 The debugger Statement {{{ */
+/* 13.16 The debugger Statement {{{ */
DebuggerStatement
: "debugger" Terminator { $$ = CYNew CYDebugger(); }
;
/* }}} */
-/* 13.1 Function Definitions {{{ */
+/* 14.1+ Function Definitions {{{ */
FunctionDeclaration
: ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
;
: StatementListOpt { $$ = $1; }
;
/* }}} */
-/* 13.2 Arrow Function Definitions {{{ */
+/* 14.2 Arrow Function Definitions {{{ */
ArrowFunction
: LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
;
ArrowParameters
: BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
- //| ParentheticalOpt { $$ = $1; }
+ | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }
;
ConciseBody
| LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }
;
/* }}} */
-/* 14 Program {{{ */
-Program
- : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); }
+/* 14.3+ Method Definitions {{{ */
+/* }}} */
+/* 14.4+ Generator Function Definitions {{{ */
+/* }}} */
+/* 14.5+ Class Definitions {{{ */
+/* }}} */
+
+/* 15.1 Scripts {{{ */
+Script
+ : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); }
;
-ProgramBody
+ScriptBody
: StatementList { $$ = $1; }
;
-ProgramBodyOpt
- : ProgramBody { $$ = $1; }
+ScriptBodyOpt
+ : ScriptBody { $$ = $1; }
| LexSetStatement LexSetRegExp { $$ = NULL; }
;
/* }}} */
+/* 15.2+ Modules {{{ */
+/* }}} */
+/* 15.2.2+ Imports {{{ */
+/* }}} */
+/* 15.2.3+ Exports {{{ */
+/* }}} */
+
+@begin C
+/* Cycript (C): Type Encoding {{{ */
+TypeSignifier
+ : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); }
+ | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; }
+ ;
-@begin ObjectiveC
-/* Cycript (Objective-C): Type Encoding {{{ */
SuffixedType
- : IdentifierOpt { $$ = CYNew CYTypedIdentifier($1); }
- | "(" LexPushInOff PrefixedType ")" LexPopIn { $$ = $3; }
- | SuffixedType "[" NumericLiteral "]" { CYSetLast($1->type_) = CYNew CYTypeArrayOf($3); $$ = $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"); }
+ ;
+
+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")); }
;
-EncodedType
- : TypedIdentifier { $$ = CYNew CYEncodedType($1->type_); }
+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? */
;
ClassFieldListOpt
- : Expression Identifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $2, $4); }
+ : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); }
| LexSetRegExp { $$ = NULL; }
;
;
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
MessageParameters
: MessageParameterList { $$ = $1; }
- | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); }
+ | Word { $$ = CYNew CYMessageParameter($1, NULL); }
;
ClassMessageDeclaration
ClassMessageDeclarationListOpt
: ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; }
- | ClassMessageDeclarationListOpt Comment { $$ = $1; }
| { $$ = NULL; }
;
| "(" AssignmentExpression ")" { $$ = $2; }
;
-ClassNameOpt
- : ClassName { $$ = $1; }
- | { $$ = NULL; }
- ;
-
// XXX: this should be AssignmentExpressionNoRight
ClassProtocols
: ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }
| { $$ = NULL; }
;
-ClassExpression
- : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" LexPopIn { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); }
- ;
-
ClassStatement
- : ";@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }
+ : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }
;
CategoryName
;
CategoryStatement
- : ";@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
- ;
-
-PrimaryExpression
- : ClassExpression { $$ = $1; }
+ : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
;
Statement__
;
SelectorCall
- : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); }
+ : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); }
;
SelectorList
| "@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; }
| StringLiteral { $$ = $1; }
| ArrayLiteral { $$ = $1; }
| ObjectLiteral { $$ = $1; }
- | Parenthetical { $$ = $1; }
+ | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; }
+ | "YES" { $$ = CYNew CYTrue(); }
+ | "NO" { $$ = CYNew CYFalse(); }
;
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 {{{ */
-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
: "auto"
;
/* }}} */
-@end
+/* Cycript (C): Lambda Expressions {{{ */
+TypedParameterList_
+ : "," TypedParameterList { $$ = $2; }
+ | { $$ = NULL; }
+ ;
-/* YUI: Documentation Comments {{{ */
+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__
- : Comment { $$ = $1; }
+ : "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
+
@begin E4X
/* Lexer State {{{ */
LexPushRegExp
/* 8.1 Context Keywords {{{ */
Identifier
- : "namespace" { $$ = $1; }
- | "xml" { $$ = $1; }
+ : "namespace" { $$ = CYNew CYIdentifier("namespace"); }
+ | "xml" { $$ = CYNew CYIdentifier("xml"); }
;
/* }}} */
-/* 8.3 XML Initialiser Input Elements {{{ */
+/* 8.3 XML Initializer Input Elements {{{ */
XMLMarkup
: XMLComment { $$ = $1; }
| XMLCDATA { $$ = $1; }
: "*" { $$ = CYNew CYWildcard(); }
;
/* }}} */
-/* 11.1.4 XML Initialiser {{{ */
+/* 11.1.4 XML Initializer {{{ */
XMLInitialiser
: XMLMarkup { $$ = $1; }
| XMLElement { $$ = $1; }
|
;
/* }}} */
-/* 11.1.5 XMLList Initialiser {{{ */
+/* 11.1.5 XMLList Initializer {{{ */
XMLListInitialiser
: "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "</>" LexPopIn { $$ = CYNew CYXMLList($4); }
;
/* }}} */
@end
-/* JavaScript 1.7: Array Comprehensions {{{ */
-IfComprehension
- : "if" "(" Expression ")" { $$ = CYNew CYIfComprehension($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; }
+/* JavaScript FTL: Array Comprehensions {{{ */
+Comprehension
+ : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
;
-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 {{{ */
+/* JavaScript FTL: for each {{{ */
IterationStatement
- : "for" "each" "(" LexPushInOn ForInStatementInitialiser "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
+ : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
;
/* }}} */
-/* JavaScript 1.7: let Statements {{{ */
+/* JavaScript FTL: let Statements {{{ */
LetStatement
: "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
;
;
/* }}} */
+/* JavaScript FTW: Array Comprehensions {{{ */
+PrimaryExpression
+ : ArrayComprehension
+ ;
+
+ArrayComprehension
+ : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; }
+ ;
+
+Comprehension
+ : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); }
+ ;
+
+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); }
+ ;
+/* }}} */
+/* JavaScript FTW: Coalesce Operator {{{ */
+ConditionalExpression
+ : LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); }
+ ;
+/* }}} */
/* JavaScript FTW: Ruby Blocks {{{ */
RubyProcParameterList_
: "," RubyProcParameterList { $$ = $2; }
projects / cycript.git / blobdiff