/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2010 Jay Freeman (saurik)
+ * Copyright (C) 2009-2015 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 <http://www.gnu.org/licenses/>.
+ * 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 <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"
#include "E4X/Syntax.hpp"
@end
-typedef struct {
- bool newline_;
-
- 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_;
+#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_; }
+
+@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_;
+%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
%parse-param { CYDriver &driver }
%lex-param { void *cyscanner }
+/* Token Declarations {{{ */
@begin E4X
%token XMLCDATA
%token XMLComment
@begin E4X ObjectiveC
%token At "@"
+%token Pound "#"
@end
%token Ampersand "&"
%token Equal "="
%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 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 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_> 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 _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 <assignment_> AssignmentExpression_
+%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_> 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 <statement_> DoWhileStatement
-%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 <expression_> Expression
%type <expression_> ExpressionOpt
%type <statement_> ExpressionStatement
-%type <finally_> FinallyOpt
-%type <comprehension_> ForComprehension
-%type <statement_> ForStatement
-%type <for_> ForStatementInitialiser
-%type <statement_> ForInStatement
-%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 <comprehension_> IfComprehension
+%type <identifier_> IdentifierType
+%type <word_> IdentifierName
+%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_> LiteralNoRE
%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 <expression_> Parenthetical
%type <expression_> PostfixExpression
%type <expression_> PrimaryExpression
-%type <statement_> Program
-%type <statement_> ProgramBody
-%type <statement_> ProgramBodyOpt
%type <propertyName_> PropertyName_
%type <propertyName_> PropertyName
-%type <property_> PropertyNameAndValueList_
-%type <property_> PropertyNameAndValueList
-%type <property_> PropertyNameAndValueListOpt
-%type <expression_> RelationalExpression_
+%type <property_> PropertyDefinition
+%type <property_> PropertyDefinitionList_
+%type <property_> PropertyDefinitionList
+%type <property_> PropertyDefinitionListOpt
%type <expression_> RelationalExpression
%type <statement_> ReturnStatement
%type <rubyProc_> RubyProcExpression
%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 <declarations_> VariableDeclarationList_
%type <declarations_> VariableDeclarationList
%type <statement_> VariableStatement
-%type <statement_> WhileStatement
%type <statement_> WithStatement
+%type <word_> Word
+@begin ObjectiveC
+%type <word_> WordOpt
+@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 <classField_> ClassFieldListOpt
+%type <classField_> ClassFields
%type <statement_> ClassStatement
%type <expression_> ClassSuperOpt
-%type <field_> ClassFieldList
%type <message_> ClassMessageDeclaration
%type <message_> ClassMessageDeclarationListOpt
%type <className_> ClassName
-%type <className_> ClassNameOpt
%type <protocol_> ClassProtocolListOpt
%type <protocol_> ClassProtocols
%type <protocol_> ClassProtocolsOpt
%type <selector_> SelectorExpressionOpt
%type <argument_> SelectorList
%type <word_> SelectorWordOpt
-%type <expression_> TypeOpt
+%type <typedIdentifier_> TypeOpt
%type <argument_> VariadicCall
-%type <word_> Word
-%type <word_> WordOpt
@end
@begin E4X
%type <expression_> XMLListInitialiser
%type <expression_> XMLInitialiser
@end
-
+/* }}} */
+/* Token Priorities {{{ */
%nonassoc ""
%left "++" "--"
%nonassoc "if"
%nonassoc "else"
+/* }}} */
-%start Program
+%start Script
%%
: { driver.SetCondition(CYDriver::RegExpCondition); }
;
-LexSetStatement
- : { switch (yychar) {
- case token::Function:
- yychar = token::Function_;
- break;
-
- case token::OpenBrace:
- case token::OpenBrace_:
- yychar = token::OpenBrace__;
- break;
- } }
+LexNewLine
+ : { if (!yyla.empty() && yyla.type_get() != yyeof_) error(@$, "unexpected lookahead"); driver.next_ = true; }
;
-/* }}} */
-BRACE
- : "{"
- | "\n{"
+LexNoBrace
+ : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); }
;
-StrictSemi
- : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); }
+LexNoClass
+ : { CYMAP(_class__, _class_); }
;
-Terminator_
- : ";"
- | "\n" StrictSemi
+LexNoFunction
+ : { CYMAP(_function__, _function_); }
;
-Terminator
- : Terminator_
- | error { if (yychar != 0 && yychar != token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
+LexSetStatement
+ : LexNoBrace LexNoClass LexNoFunction
;
-
-TerminatorOpt
- : Terminator_
- | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
+/* }}} */
+/* Virtual Tokens {{{ */
+BRACE
+ : "{"
+ | "\n{"
;
-/*CommaOpt
- : ","
- |
- ;*/
+Var_
+ : "var"
+ ;
+/* }}} */
-@begin ObjectiveC
-NewLineOpt
- : "\n"
- |
+/* 11.6 Names and Keywords {{{ */
+IdentifierName
+ : Word { $$ = $1; }
+ | "for" { $$ = CYNew CYWord("for"); }
+ | "in" { $$ = CYNew CYWord("in"); }
+ | "instanceof" { $$ = CYNew CYWord("instanceof"); }
;
Word
: Identifier { $$ = $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; } */
- /* XXX: | "instanceof" { $$ = $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; }
;
+@end
+/* }}} */
+/* 11.8.1 Null Literals {{{ */
+NullLiteral
+ : "null" { $$ = CYNew CYNull(); }
+ ;
+/* }}} */
+/* 11.8.2 Boolean Literals {{{ */
+BooleanLiteral
+ : "true" { $$ = CYNew CYTrue(); }
+ | "false" { $$ = CYNew CYFalse(); }
+ ;
+/* }}} */
-PrimaryExpression
- : "@" LiteralNoRE { $$ = CYNew CYBox($2); }
- | "@" ArrayLiteral { $$ = CYNew CYBox($2); }
- | "@" ObjectLiteral { $$ = CYNew CYBox($2); }
- | "@" Parenthetical { $$ = CYNew CYBox($2); }
+/* 11.9 Automatic Semicolon Insertion {{{ */
+StrictSemi
+ : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); }
;
-@end
-Identifier
- : Identifier_ { $$ = $1; }
+TerminatorSoft
+ : ";"
+ | "\n" StrictSemi
+ ;
- | "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: is this allowed?! | "let" { $$ = $1; }
- | "yield" { $$ = $1; }
-
- | "each" { $$ = $1; }
+Terminator
+ : ";"
+ | 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
;
-IdentifierOpt
- : Identifier { $$ = $1; }
- | { $$ = NULL; }
+TerminatorOpt
+ : ";"
+ | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
;
+/* }}} */
-LiteralNoRE
- : NullLiteral { $$ = $1; }
- | BooleanLiteral { $$ = $1; }
- | NumericLiteral { $$ = $1; }
- | StringLiteral { $$ = $1; }
+/* 12.1 Identifiers {{{ */
+IdentifierReference
+ : Identifier { $$ = CYNew CYVariable($1); }
+ // XXX: | "yield"
;
-Literal
- : LiteralNoRE { $$ = $1; }
- | RegularExpressionLiteral { $$ = $1; }
+BindingIdentifier
+ : Identifier { $$ = $1; }
+ // XXX: | "yield"
;
-NullLiteral
- : "null" { $$ = $1; }
+LabelIdentifier
+ : Identifier { $$ = $1; }
+ // XXX: | yield
;
-BooleanLiteral
- : "true" { $$ = $1; }
- | "false" { $$ = $1; }
+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
;
-/* 11.1 Primary Expressions {{{ */
-Parenthetical
- : "(" LexPushInOff Expression LexPopIn ")" { $$ = $3; }
+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; }
- | Identifier { $$ = CYNew CYVariable($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; }
;
-/* }}} */
-/* 11.1.4.1 Array Initialiser {{{ */
-ArrayLiteral
- : "[" LexPushInOff ElementListOpt LexPopIn "]" { $$ = CYNew CYArray($3); }
- ;
-Element
- : AssignmentExpression { $$ = $1; }
+CoverParenthesizedExpressionAndArrowParameterList
+ : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }
+ | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }
;
-
-ElementOpt
- : Element { $$ = $1; }
- | LexSetRegExp { $$ = NULL; }
+/* }}} */
+/* 12.2.4 Literals {{{ */
+Literal
+ : NullLiteral { $$ = $1; }
+ | BooleanLiteral { $$ = $1; }
+ | NumericLiteral { $$ = $1; }
+ | StringLiteral { $$ = $1; }
+ ;
+/* }}} */
+/* 12.2.5 Array Initializer {{{ */
+ArrayLiteral
+ : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
;
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.5 Object Initialiser {{{ */
+/* 12.2.6 Object Initializer {{{ */
ObjectLiteral
- : BRACE LexPushInOff PropertyNameAndValueListOpt LexPopIn "}" { $$ = CYNew CYObject($3); }
+ : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); }
;
-PropertyNameAndValueList_
- : "," PropertyNameAndValueList { $$ = $2; }
+PropertyDefinitionList_
+ : "," PropertyDefinitionList { $$ = $2; }
+ | "," LexSetRegExp { $$ = NULL; }
| { $$ = NULL; }
;
-PropertyNameAndValueList
- : PropertyName ":" AssignmentExpression PropertyNameAndValueList_ { $$ = CYNew CYProperty($1, $3, $4); }
+PropertyDefinitionList
+ : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; }
;
-PropertyNameAndValueListOpt
- : PropertyNameAndValueList { $$ = $1; }
- | { $$ = NULL; }
+PropertyDefinitionListOpt
+ : PropertyDefinitionList { $$ = $1; }
+ | LexSetRegExp { $$ = NULL; }
+ ;
+
+PropertyDefinition
+ // XXX: this should be IdentifierName
+ : LexSetRegExp Identifier { $$ = CYNew CYProperty($2, CYNew CYVariable($2)); }
+ | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); }
+ //| MethodDefinition
;
PropertyName_
- : Identifier { $$ = $1; }
+ : IdentifierName { $$ = $1; }
| StringLiteral { $$ = $1; }
| NumericLiteral { $$ = $1; }
;
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); }
- | "." Identifier { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
+ : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
+ | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
| "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
;
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); }
;
;
Arguments
- : "(" LexPushInOff ArgumentListOpt LexPopIn ")" { $$ = $3; }
+ : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; }
;
ArgumentList_
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 {{{ */
-RelationalExpression_
- : ShiftExpression { $$ = $1; }
- ;
-
+/* 12.9 Relational Operators {{{ */
RelationalExpression
- : RelationalExpression_ { $$ = $1; }
- | RelationalExpression "<" RelationalExpression_ { $$ = CYNew CYLess($1, $3); }
- | RelationalExpression ">" RelationalExpression_ { $$ = CYNew CYGreater($1, $3); }
- | RelationalExpression "<=" RelationalExpression_ { $$ = CYNew CYLessOrEqual($1, $3); }
- | RelationalExpression ">=" RelationalExpression_ { $$ = CYNew CYGreaterOrEqual($1, $3); }
- | RelationalExpression "instanceof" RelationalExpression_ { $$ = CYNew CYInstanceOf($1, $3); }
- | RelationalExpression "in" RelationalExpression_ { $$ = CYNew CYIn($1, $3); }
+ : ShiftExpression { $$ = $1; }
+ | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); }
+ | RelationalExpression ">" ShiftExpression { $$ = CYNew CYGreater($1, $3); }
+ | RelationalExpression "<=" ShiftExpression { $$ = CYNew CYLessOrEqual($1, $3); }
+ | RelationalExpression ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual($1, $3); }
+ | RelationalExpression "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf($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); }
+ | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
;
/* }}} */
-/* 11.13 Assignment Operators {{{ */
-AssignmentExpression_
- : "=" AssignmentExpression { $$ = CYNew CYAssign(NULL, $2); }
- | "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign(NULL, $2); }
- | "/=" AssignmentExpression { $$ = CYNew CYDivideAssign(NULL, $2); }
- | "%=" AssignmentExpression { $$ = CYNew CYModulusAssign(NULL, $2); }
- | "+=" AssignmentExpression { $$ = CYNew CYAddAssign(NULL, $2); }
- | "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign(NULL, $2); }
- | "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign(NULL, $2); }
- | ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign(NULL, $2); }
- | ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign(NULL, $2); }
- | "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign(NULL, $2); }
- | "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign(NULL, $2); }
- | "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign(NULL, $2); }
- ;
-
+/* 12.14 Assignment Operators {{{ */
AssignmentExpression
: ConditionalExpression { $$ = $1; }
- | LeftHandSideExpression AssignmentExpression_ { $2->SetLeft($1); $$ = $2; }
+ // XXX: | YieldExpression { $$ = $1; }
+ | ArrowFunction { $$ = $1; }
+ | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
+ | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
+ | LeftHandSideExpression "/=" AssignmentExpression { $$ = CYNew CYDivideAssign($1, $3); }
+ | LeftHandSideExpression "%=" AssignmentExpression { $$ = CYNew CYModulusAssign($1, $3); }
+ | LeftHandSideExpression "+=" AssignmentExpression { $$ = CYNew CYAddAssign($1, $3); }
+ | LeftHandSideExpression "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign($1, $3); }
+ | LeftHandSideExpression "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign($1, $3); }
+ | LeftHandSideExpression ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign($1, $3); }
+ | LeftHandSideExpression ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign($1, $3); }
+ | LeftHandSideExpression "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign($1, $3); }
+ | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
+ | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
+ ;
+
+AssignmentExpressionOpt
+ : AssignmentExpression { $$ = $1; }
+ | LexSetRegExp { $$ = NULL; }
;
/* }}} */
-/* 11.14 Comma Operator {{{ */
-Expression_
- : "," Expression { $$ = CYNew CYCompound($2); }
- | { $$ = NULL; }
- ;
-
+/* 12.15 Comma Operator ( , ) {{{ */
Expression
- : AssignmentExpression Expression_ { if ($2) { $2->AddPrev($1); $$ = $2; } else $$ = $1; }
+ : 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
StatementListOpt
: StatementList { $$ = $1; }
- | LexSetRegExp { $$ = NULL; }
+ | LexSetStatement LexSetRegExp { $$ = NULL; }
;
StatementListItem
| Declaration { $$ = $1; }
;
/* }}} */
-/* 12.2 Declarations {{{ */
-BindingIdentifier
- : Identifier { $$ = $1; }
- ;
-
-// 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); }
+ : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
;
VariableDeclarationList_
;
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 Iteration Statements {{{ */
+/* 13.7+ Iteration Statements {{{ */
IterationStatement
- : DoWhileStatement { $$ = $1; }
- | WhileStatement { $$ = $1; }
- | ForStatement { $$ = $1; }
- | ForInStatement { $$ = $1; }
- ;
-/* }}} */
-/* 12.6.1 The do-while Statement {{{ */
-DoWhileStatement
: "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
- ;
-/* }}} */
-/* 12.6.2 The while Statement {{{ */
-WhileStatement
- : "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
- ;
-/* }}} */
-/* 12.6.3 The for Statement {{{ */
-ForStatement
- : "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 Statement {{{ */
-ForInStatement
- : "for" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
+ | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
;
-ForInStatementInitialiser
+ForInStatementInitializer
: LeftHandSideExpression { $$ = $1; }
- | LexSetRegExp "var" VariableDeclaration { $$ = $3; }
+ | LexSetRegExp Var_ VariableDeclaration { $$ = $3; }
;
/* }}} */
+/* 13.8 The continue Statement {{{ */
+Continue
+ : "continue" LexNewLine
+ ;
-/* 12.7 The continue Statement {{{ */
ContinueStatement
- : "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" 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" 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" 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 Function Definition {{{ */
+/* 14.1+ Function Definitions {{{ */
FunctionDeclaration
: ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
;
FunctionExpression
- : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt LexPopIn ")" BRACE LexPushInOff FunctionBody LexPopIn "}" { $$ = CYNew CYFunctionExpression($2, $5, $10); }
+ : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); }
;
FormalParameterList_
: StatementListOpt { $$ = $1; }
;
/* }}} */
-/* 14 Program {{{ */
-Program
- : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); }
+/* 14.2 Arrow Function Definitions {{{ */
+ArrowFunction
+ : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
+ ;
+
+ArrowParameters
+ : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
+ | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }
;
-ProgramBody
+ConciseBody
+ : AssignmentExpression { $$ = CYNew CYReturn($1); }
+ | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }
+ ;
+/* }}} */
+/* 14.3+ Method Definitions {{{ */
+/* }}} */
+/* 14.4+ Generator Function Definitions {{{ */
+/* }}} */
+/* 14.5+ Class Definitions {{{ */
+/* }}} */
+
+/* 15.1 Scripts {{{ */
+Script
+ : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); }
+ ;
+
+ScriptBody
: StatementList { $$ = $1; }
;
-ProgramBodyOpt
- : ProgramBody { $$ = $1; }
- | { $$ = NULL; }
+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; }
+ ;
+
+SuffixedType
+ : 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
+ : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
+ ;
+
+TypeQualifierLeft
+ : { $$ = NULL; }
+ | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); }
+ | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); }
+ ;
+
+TypeQualifierRight
+ : PrefixedType { $$ = $1; }
+ | SuffixedType { $$ = $1; }
+ | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); }
+ | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); }
+ ;
+
+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); }
+ ;
+
+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")); }
+ ;
+
+TypedIdentifier
+ : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
+ ;
+
+PrimaryExpression
+ : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); }
;
/* }}} */
+@end
@begin ObjectiveC
/* Cycript (Objective-C): @class Declaration {{{ */
| { $$ = NULL; }
;
-ClassField
- : Expression Identifier ";"
- ;
-
-ClassFieldList
- : BRACE ClassFieldListOpt "}" { $$ = NULL; }
+ClassFieldListOpt
+ : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); }
+ | LexSetRegExp { $$ = NULL; }
;
-ClassFieldListOpt
- : ClassFieldListOpt ClassField
- |
+ClassFields
+ : BRACE ClassFieldListOpt "}" { $$ = $2; }
;
MessageScope
;
TypeOpt
- : "(" Expression ")" { $$ = $2; }
- | "(" LexSetRegExp "void" ")" { $$ = NULL; }
- | { $$ = 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 ClassFieldList ClassMessageDeclarationListOpt LexPopIn "@end" { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); }
- ;
-
ClassStatement
- : ";@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFieldList 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
;
MessageExpression
- : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList LexPopIn "]" { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
- | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList LexPopIn "]" { $$ = CYNew CYSendSuper($6); }
+ : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
+ | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); }
;
SelectorExpression_
PrimaryExpression
: MessageExpression { $$ = $1; }
- | "@selector" "(" LexPushInOff SelectorExpression LexPopIn ")" { $$ = CYNew CYSelector($4); }
+ | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); }
;
/* }}} */
-/* Cycript (Objective-C): @import Directive {{{ */
-PathName
- : "/" PathName
- | "." PathName
- | Word PathName
- |
+@end
+
+/* Cycript: @import Directive {{{ */
+Module
+ : Module "." Word { $$ = CYNew CYModule($3, $1); }
+ | Word { $$ = CYNew CYModule($1); }
;
-ImportPath
- : "<" PathName ">"
- | StringLiteral
+Declaration__
+ : "@import" Module { $$ = CYNew CYImport($2); }
;
+/* }}} */
-StatementListItem
- : "@import" ImportPath { $$ = CYNew CYImport(); }
+@begin ObjectiveC
+/* Cycript (Objective-C): Boxed Expressions {{{ */
+BoxableExpression
+ : NullLiteral { $$ = $1; }
+ | BooleanLiteral { $$ = $1; }
+ | NumericLiteral { $$ = $1; }
+ | StringLiteral { $$ = $1; }
+ | ArrayLiteral { $$ = $1; }
+ | ObjectLiteral { $$ = $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 {{{ */
+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
+ : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); }
;
/* }}} */
@end
MemberAccess
: "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); }
- | "->" Identifier { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); }
+ | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); }
| "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; }
;
/* }}} */
-@end
+/* Cycript (C): auto Compatibility {{{ */
+Var_
+ : "auto"
+ ;
+/* }}} */
+/* 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__
- : Comment { $$ = $1; }
+ : "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
@begin E4X
/* Lexer State {{{ */
: { driver.SetCondition(CYDriver::XMLTagCondition); }
;
/* }}} */
-
+/* Virtual Tokens {{{ */
XMLWhitespaceOpt
: XMLWhitespace
|
;
+/* }}} */
/* 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; }
| XMLPI { $$ = $1; }
;
/* }}} */
+
/* 11.1 Primary Expressions {{{ */
PrimaryExpression
: PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); }
PropertySelector_
: PropertySelector { $$ = $1; }
- | "[" LexPushInOff Expression LexPopIn "]" { $$ = CYNew CYSelector($3); }
+ | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); }
;
PropertySelector
: "*" { $$ = CYNew CYWildcard(); }
;
/* }}} */
-/* 11.1.4 XML Initialiser {{{ */
+/* 11.1.4 XML Initializer {{{ */
XMLInitialiser
: XMLMarkup { $$ = $1; }
| XMLElement { $$ = $1; }
;
XMLElement
- : "<" LexPushInOff XMLTagContent LexPop LexPopIn "/>"
- | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop LexPopIn ">"
+ : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn
+ | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop ">" LexPopIn
;
XMLTagContent
|
;
/* }}} */
-/* 11.1.5 XMLList Initialiser {{{ */
+/* 11.1.5 XMLList Initializer {{{ */
XMLListInitialiser
- : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop LexPopIn "</>" { $$ = CYNew CYXMLList($4); }
+ : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "</>" LexPopIn { $$ = CYNew CYXMLList($4); }
;
/* }}} */
+
/* 11.2 Left-Hand-Side Expressions {{{ */
PropertyIdentifier_
: Identifier { $$ = $1; }
/* }}} */
@end
-/* ECMAScript5: Object Literal Trailing Comma {{{ */
-PropertyNameAndValueList_
- : "," { $$ = NULL; }
+/* JavaScript FTL: Array Comprehensions {{{ */
+Comprehension
+ : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
;
-/* }}} */
-/* JavaScript 1.7: Array Comprehensions {{{ */
-IfComprehension
- : "if" "(" Expression ")" { $$ = CYNew CYIfComprehension($3); }
+ComprehensionFor
+ : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); }
+ | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
+ ;
+/* }}} */
+/* JavaScript FTL: for each {{{ */
+IterationStatement
+ : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
+ ;
+/* }}} */
+/* JavaScript FTL: let Statements {{{ */
+LetStatement
+ : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
;
-ForComprehension
- : "for" "(" LexPushInOn Identifier LexPopIn "!in" Expression ")" { $$ = CYNew CYForInComprehension($4, $7); }
- | "for" "each" "(" LexPushInOn Identifier LexPopIn "!in" Expression ")" { $$ = CYNew CYForEachInComprehension($5, $8); }
+Statement__
+ : LetStatement
;
+/* }}} */
-ComprehensionList
- : ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; }
+/* JavaScript FTW: Array Comprehensions {{{ */
+PrimaryExpression
+ : ArrayComprehension
;
-ComprehensionListOpt
- : ComprehensionList { $$ = $1; }
- | IfComprehension { $$ = $1; }
- | { $$ = NULL; }
+ArrayComprehension
+ : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; }
;
-PrimaryExpression
- : "[" LexPushInOff AssignmentExpression ComprehensionList LexPopIn "]" { $$ = CYNew CYArrayComprehension($3, $4); }
+Comprehension
+ : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); }
;
-/* }}} */
-/* JavaScript 1.7: for each {{{ */
-ForInStatement
- : "for" "each" "(" LexPushInOn ForInStatementInitialiser LexPopIn "!in" Expression ")" Statement { $$ = CYNew CYForEachIn($5, $8, $10); }
+
+ComprehensionTail
+ : { $$ = NULL; }
+ | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); }
+ | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); }
;
-/* }}} */
-/* JavaScript 1.7: let Statements {{{ */
-LetStatement
- : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
+
+ComprehensionFor
+ : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); }
;
-Statement__
- : LetStatement
+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; }
;
PrimaryExpression
- : "{" LexPushInOff RubyProcParameters StatementListOpt LexPopIn "}" { $$ = CYNew CYRubyProc($3, $4); }
+ : "{" LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); }
;
CallExpression
projects / cycript.git / blobdiff