-/* Cycript - Remote Execution Server and Disassembler
+/* Cycript - Inlining/Optimizing JavaScript Compiler
* Copyright (C) 2009 Jay Freeman (saurik)
*/
#include "Parser.hpp"
@begin ObjectiveC
-#include "ObjectiveC.hpp"
+#include "ObjectiveC/Syntax.hpp"
+@end
+
+@begin E4X
+#include "E4X.hpp"
@end
typedef struct {
CYAssignment *assignment_;
CYBoolean *boolean_;
CYClause *clause_;
- CYCatch *catch_;
+ cy::Syntax::Catch *catch_;
CYComprehension *comprehension_;
CYCompound *compound_;
CYDeclaration *declaration_;
CYMessageParameter *messageParameter_;
CYSelectorPart *selector_;
@end
+
+@begin E4X
+ CYAttribute *attribute_;
+@end
};
} YYSTYPE;
%lex-param { void *scanner }
@begin E4X
-%token At "@"
-%token ColonColon "::"
-%token LeftRight "<>"
-%token LeftSlashRight "</>"
-%token PeriodPeriod ".."
-
%token XMLCDATA
%token XMLComment
%token XMLPI
+
+%token XMLAttributeValue
+%token XMLName
+%token XMLTagCharacters
+%token XMLText
+%token XMLWhitespace
+@end
+
+@begin E4X
+%token LeftRight "<>"
+%token LeftSlashRight "</>"
+
+%token SlashRight "/>"
+%token LeftSlash "</"
+
+%token At "@"
+%token ColonColon "::"
+%token PeriodPeriod ".."
@end
%token Ampersand "&"
// Woah?!
%token <identifier_> Each "each"
+@begin E4X
+// E4X Conditional
+%token <identifier_> Namespace "namespace"
+%token <identifier_> XML "xml"
+@end
+
%token <identifier_> Identifier_
%token <number_> NumericLiteral
%token <string_> StringLiteral
%type <expression_> AdditiveExpression
%type <expression_> AdditiveExpressionNoBF
+%type <expression_> AdditiveExpressionNoWC
%type <argument_> ArgumentList
%type <argument_> ArgumentList_
%type <argument_> ArgumentListOpt
%type <literal_> ArrayLiteral
%type <expression_> AssigneeExpression
%type <expression_> AssigneeExpressionNoBF
+%type <expression_> AssigneeExpressionNoWC
%type <expression_> AssignmentExpression
%type <assignment_> AssignmentExpression_
%type <expression_> AssignmentExpressionNoBF
%type <expression_> AssignmentExpressionNoIn
+%type <expression_> AssignmentExpressionNoWC
%type <expression_> BitwiseANDExpression
%type <expression_> BitwiseANDExpressionNoBF
%type <expression_> BitwiseANDExpressionNoIn
+%type <expression_> BitwiseANDExpressionNoWC
%type <statement_> Block
%type <statement_> Block_
%type <boolean_> BooleanLiteral
%type <expression_> BitwiseORExpression
%type <expression_> BitwiseORExpressionNoBF
%type <expression_> BitwiseORExpressionNoIn
+%type <expression_> BitwiseORExpressionNoWC
%type <expression_> BitwiseXORExpression
%type <expression_> BitwiseXORExpressionNoBF
%type <expression_> BitwiseXORExpressionNoIn
+%type <expression_> BitwiseXORExpressionNoWC
%type <statement_> BreakStatement
%type <expression_> CallExpression
%type <expression_> CallExpressionNoBF
%type <expression_> ConditionalExpression
%type <expression_> ConditionalExpressionNoBF
%type <expression_> ConditionalExpressionNoIn
+%type <expression_> ConditionalExpressionNoWC
%type <statement_> ContinueStatement
%type <clause_> DefaultClause
%type <statement_> DoWhileStatement
%type <expression_> EqualityExpression
%type <expression_> EqualityExpressionNoBF
%type <expression_> EqualityExpressionNoIn
+%type <expression_> EqualityExpressionNoWC
%type <expression_> Expression
%type <expression_> ExpressionOpt
%type <compound_> Expression_
%type <statement_> FunctionBody
%type <statement_> FunctionDeclaration
%type <expression_> FunctionExpression
+%type <expression_> FunctionExpression_
%type <identifier_> Identifier
%type <identifier_> IdentifierOpt
%type <comprehension_> IfComprehension
%type <statement_> LabelledStatement
%type <expression_> LeftHandSideExpression
%type <expression_> LeftHandSideExpressionNoBF
+%type <expression_> LeftHandSideExpressionNoWC
//%type <statement_> LetStatement
%type <literal_> Literal
+%type <literal_> LiteralNoRE
+%type <literal_> LiteralRE
%type <expression_> LogicalANDExpression
%type <expression_> LogicalANDExpressionNoBF
%type <expression_> LogicalANDExpressionNoIn
+%type <expression_> LogicalANDExpressionNoWC
%type <expression_> LogicalORExpression
%type <expression_> LogicalORExpressionNoBF
%type <expression_> LogicalORExpressionNoIn
+%type <expression_> LogicalORExpressionNoWC
%type <member_> MemberAccess
%type <expression_> MemberExpression
%type <expression_> MemberExpression_
%type <expression_> MemberExpressionNoBF
+%type <expression_> MemberExpressionNoWC
%type <expression_> MultiplicativeExpression
%type <expression_> MultiplicativeExpressionNoBF
+%type <expression_> MultiplicativeExpressionNoWC
%type <expression_> NewExpression
%type <expression_> NewExpression_
%type <expression_> NewExpressionNoBF
+%type <expression_> NewExpressionNoWC
%type <null_> NullLiteral
%type <literal_> ObjectLiteral
%type <expression_> PostfixExpression
%type <expression_> PostfixExpressionNoBF
+%type <expression_> PostfixExpressionNoWC
%type <expression_> PrimaryExpression
-%type <expression_> PrimaryExpression_
+%type <expression_> PrimaryExpressionNo
%type <expression_> PrimaryExpressionNoBF
-%type <expression_> PrimaryExpressionNoBF_
+%type <expression_> PrimaryExpressionNoWC
+%type <expression_> PrimaryExpressionNoWC_
+@begin E4X
+%type <expression_> PrimaryExpressionWC
+@end
+%type <expression_> PrimaryExpressionBF
%type <statement_> Program
%type <propertyName_> PropertyName
%type <property_> PropertyNameAndValueList
%type <infix_> RelationalExpression_
%type <expression_> RelationalExpressionNoBF
%type <expression_> RelationalExpressionNoIn
+%type <expression_> RelationalExpressionNoWC
%type <infix_> RelationalExpressionNoIn_
%type <statement_> ReturnStatement
%type <expression_> ShiftExpression
%type <expression_> ShiftExpressionNoBF
+%type <expression_> ShiftExpressionNoWC
%type <statement_> SourceElement
%type <statement_> SourceElement_
%type <statement_> SourceElements
%type <expression_> UnaryExpression
%type <expression_> UnaryExpression_
%type <expression_> UnaryExpressionNoBF
+%type <expression_> UnaryExpressionNoWC
%type <declaration_> VariableDeclaration
%type <declaration_> VariableDeclarationNoIn
%type <declarations_> VariableDeclarationList
%type <word_> WordOpt
@end
+@begin E4X
+%type <identifier_> PropertyIdentifier_
+%type <identifier_> PropertySelector
+%type <identifier_> PropertySelector_
+%type <identifier_> QualifiedIdentifier
+%type <identifier_> QualifiedIdentifier_
+%type <identifier_> WildcardIdentifier
+%type <identifier_> XMLComment
+%type <identifier_> XMLCDATA
+%type <identifier_> XMLElement
+%type <identifier_> XMLElementContent
+%type <identifier_> XMLMarkup
+%type <identifier_> XMLPI
+
+%type <attribute_> AttributeIdentifier
+%type <statement_> DefaultXMLNamespaceStatement
+%type <expression_> PropertyIdentifier
+%type <expression_> XMLListInitialiser
+%type <expression_> XMLInitialiser
+@end
+
+/*
%left "*" "/" "%"
%left "+" "-"
%left "<<" ">>" ">>>"
%left "||"
%right "=" "*=" "/=" "%=" "+=" "-=" "<<=" ">>=" ">>>=" "&=" "^=" "|="
+*/
%nonassoc "if"
%nonassoc "else"
%%
+/* Lexer State {{{ */
+LexSetRegExp
+ : { driver.SetCondition(CYDriver::RegExpCondition); }
+ ;
+/* }}} */
+
StrictSemi
: { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); }
;
| "extends" { $$ = $1; }
| "false" { $$ = $1; }
| "finally" { $$ = $1; }
- | "for" { $$ = $1; }
+ /* XXX: | "for" { $$ = $1; } */
| "function" { $$ = $1; }
| "if" { $$ = $1; }
| "import" { $$ = $1; }
| { $$ = NULL; }
;
-Literal
+LiteralNoRE
: NullLiteral { $$ = $1; }
| BooleanLiteral { $$ = $1; }
| NumericLiteral { $$ = $1; }
| StringLiteral { $$ = $1; }
- | RegularExpressionLiteral { $$ = $1; }
+ ;
+
+LiteralRE
+ : RegularExpressionLiteral { $$ = $1; }
+ ;
+
+Literal
+ : LiteralNoRE { $$ = $1; }
+ | LiteralRE { $$ = $1; }
;
NullLiteral
;
/* 11.1 Primary Expressions {{{ */
-PrimaryExpression_
- : ObjectLiteral { $$ = $1; }
- | PrimaryExpressionNoBF_ { $$ = $1; }
+PrimaryExpression
+ : PrimaryExpressionNoWC { $$ = $1; }
+@begin E4X
+ | LexSetRegExp PrimaryExpressionWC { $$ = $1; }
+@end
+ ;
+
+PrimaryExpressionNoBF
+ : PrimaryExpressionNo { $$ = $1; }
+@begin E4X
+ | PrimaryExpressionWC { $$ = $1; }
+@end
+ ;
+
+PrimaryExpressionNoWC_
+ : PrimaryExpressionBF { $$ = $1; }
+ | PrimaryExpressionNo { $$ = $1; }
;
-PrimaryExpressionNoBF_
+PrimaryExpressionNoWC
+ : LexSetRegExp PrimaryExpressionNoWC_ { $$ = $2; }
+ ;
+
+PrimaryExpressionNo
: "this" { $$ = $1; }
| Identifier { $$ = new(driver.pool_) CYVariable($1); }
| Literal { $$ = $1; }
| "(" Expression ")" { $$ = $2; }
;
-LexBeginRegExp
- : { driver.BeginCondition(CYDriver::RegExpCondition); }
- ;
-
-PrimaryExpression
- : LexBeginRegExp PrimaryExpression_ { $$ = $2; }
- ;
-
-PrimaryExpressionNoBF
- : PrimaryExpressionNoBF_ { $$ = $1; }
+PrimaryExpressionBF
+ : ObjectLiteral { $$ = $1; }
;
/* }}} */
/* 11.1.4 Array Initialiser {{{ */
ElementOpt
: Element { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
ElementListOpt
: ElementList { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
ElementList
: PrimaryExpression { $$ = $1; }
| FunctionExpression { $$ = $1; }
| MemberExpression MemberAccess { $2->SetLeft($1); $$ = $2; }
- | LexBeginRegExp MemberExpression_ { $$ = $2; }
+ | LexSetRegExp MemberExpression_ { $$ = $2; }
;
MemberExpressionNoBF
| MemberExpression_ { $$ = $1; }
;
+MemberExpressionNoWC
+ : PrimaryExpressionNoWC { $$ = $1; }
+ | FunctionExpression { $$ = $1; }
+ | MemberExpression MemberAccess { $2->SetLeft($1); $$ = $2; }
+ | LexSetRegExp MemberExpression_ { $$ = $2; }
+ ;
+
NewExpression_
: "new" NewExpression { $$ = new(driver.pool_) CYNew($2, NULL); }
;
NewExpression
: MemberExpression { $$ = $1; }
- | LexBeginRegExp NewExpression_ { $$ = $2; }
+ | LexSetRegExp NewExpression_ { $$ = $2; }
;
NewExpressionNoBF
| NewExpression_ { $$ = $1; }
;
+NewExpressionNoWC
+ : MemberExpressionNoWC { $$ = $1; }
+ | LexSetRegExp NewExpression_ { $$ = $2; }
+ ;
+
CallExpression
- : MemberExpression Arguments { $$ = new(driver.pool_) CYCall($1, $2); }
+ : PrimaryExpressionNoWC Arguments { $$ = new(driver.pool_) CYCall($1, $2); }
| CallExpression Arguments { $$ = new(driver.pool_) CYCall($1, $2); }
| CallExpression MemberAccess { $2->SetLeft($1); $$ = $2; }
;
ArgumentListOpt
: ArgumentList { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
ArgumentList
: NewExpressionNoBF { $$ = $1; }
| CallExpressionNoBF { $$ = $1; }
;
+
+LeftHandSideExpressionNoWC
+ : NewExpressionNoWC { $$ = $1; }
+ | CallExpression { $$ = $1; }
+ ;
/* }}} */
/* 11.3 Postfix Expressions {{{ */
PostfixExpression
| LeftHandSideExpressionNoBF "++" { $$ = new(driver.pool_) CYPostIncrement($1); }
| LeftHandSideExpressionNoBF "--" { $$ = new(driver.pool_) CYPostDecrement($1); }
;
+
+PostfixExpressionNoWC
+ : AssigneeExpressionNoWC { $$ = $1; }
+ | LeftHandSideExpression "++" { $$ = new(driver.pool_) CYPostIncrement($1); }
+ | LeftHandSideExpression "--" { $$ = new(driver.pool_) CYPostDecrement($1); }
+ ;
/* }}} */
/* 11.4 Unary Operators {{{ */
UnaryExpression_
UnaryExpression
: PostfixExpression { $$ = $1; }
- | LexBeginRegExp UnaryExpression_ { $$ = $2; }
+ | LexSetRegExp UnaryExpression_ { $$ = $2; }
;
UnaryExpressionNoBF
: PostfixExpressionNoBF { $$ = $1; }
| UnaryExpression_ { $$ = $1; }
;
+
+UnaryExpressionNoWC
+ : PostfixExpressionNoWC { $$ = $1; }
+ | LexSetRegExp UnaryExpression_ { $$ = $2; }
+ ;
/* }}} */
/* 11.5 Multiplicative Operators {{{ */
MultiplicativeExpression
| MultiplicativeExpressionNoBF "/" UnaryExpression { $$ = new(driver.pool_) CYDivide($1, $3); }
| MultiplicativeExpressionNoBF "%" UnaryExpression { $$ = new(driver.pool_) CYModulus($1, $3); }
;
+
+MultiplicativeExpressionNoWC
+ : UnaryExpressionNoWC { $$ = $1; }
+ | MultiplicativeExpression "*" UnaryExpression { $$ = new(driver.pool_) CYMultiply($1, $3); }
+ | MultiplicativeExpression "/" UnaryExpression { $$ = new(driver.pool_) CYDivide($1, $3); }
+ | MultiplicativeExpression "%" UnaryExpression { $$ = new(driver.pool_) CYModulus($1, $3); }
+ ;
/* }}} */
/* 11.6 Additive Operators {{{ */
AdditiveExpression
| AdditiveExpressionNoBF "+" MultiplicativeExpression { $$ = new(driver.pool_) CYAdd($1, $3); }
| AdditiveExpressionNoBF "-" MultiplicativeExpression { $$ = new(driver.pool_) CYSubtract($1, $3); }
;
+
+AdditiveExpressionNoWC
+ : MultiplicativeExpressionNoWC{ $$ = $1; }
+ | AdditiveExpression "+" MultiplicativeExpression { $$ = new(driver.pool_) CYAdd($1, $3); }
+ | AdditiveExpression "-" MultiplicativeExpression { $$ = new(driver.pool_) CYSubtract($1, $3); }
+ ;
/* }}} */
/* 11.7 Bitwise Shift Operators {{{ */
ShiftExpression
| ShiftExpressionNoBF ">>" AdditiveExpression { $$ = new(driver.pool_) CYShiftRightSigned($1, $3); }
| ShiftExpressionNoBF ">>>" AdditiveExpression { $$ = new(driver.pool_) CYShiftRightUnsigned($1, $3); }
;
+
+ShiftExpressionNoWC
+ : AdditiveExpressionNoWC { $$ = $1; }
+ | ShiftExpression "<<" AdditiveExpression { $$ = new(driver.pool_) CYShiftLeft($1, $3); }
+ | ShiftExpression ">>" AdditiveExpression { $$ = new(driver.pool_) CYShiftRightSigned($1, $3); }
+ | ShiftExpression ">>>" AdditiveExpression { $$ = new(driver.pool_) CYShiftRightUnsigned($1, $3); }
+ ;
/* }}} */
/* 11.8 Relational Operators {{{ */
RelationalExpressionNoIn_
: ShiftExpressionNoBF { $$ = $1; }
| RelationalExpressionNoBF RelationalExpression_ { $2->SetLeft($1); $$ = $2; }
;
+
+RelationalExpressionNoWC
+ : ShiftExpressionNoWC { $$ = $1; }
+ | RelationalExpression RelationalExpression_ { $2->SetLeft($1); $$ = $2; }
+ ;
/* }}} */
/* 11.9 Equality Operators {{{ */
EqualityExpression
| EqualityExpressionNoBF "===" RelationalExpression { $$ = new(driver.pool_) CYIdentical($1, $3); }
| EqualityExpressionNoBF "!==" RelationalExpression { $$ = new(driver.pool_) CYNotIdentical($1, $3); }
;
+
+EqualityExpressionNoWC
+ : RelationalExpressionNoWC { $$ = $1; }
+ | EqualityExpression "==" RelationalExpression { $$ = new(driver.pool_) CYEqual($1, $3); }
+ | EqualityExpression "!=" RelationalExpression { $$ = new(driver.pool_) CYNotEqual($1, $3); }
+ | EqualityExpression "===" RelationalExpression { $$ = new(driver.pool_) CYIdentical($1, $3); }
+ | EqualityExpression "!==" RelationalExpression { $$ = new(driver.pool_) CYNotIdentical($1, $3); }
+ ;
/* }}} */
/* 11.10 Binary Bitwise Operators {{{ */
BitwiseANDExpression
| BitwiseANDExpressionNoBF "&" EqualityExpression { $$ = new(driver.pool_) CYBitwiseAnd($1, $3); }
;
+BitwiseANDExpressionNoWC
+ : EqualityExpressionNoWC { $$ = $1; }
+ | BitwiseANDExpression "&" EqualityExpression { $$ = new(driver.pool_) CYBitwiseAnd($1, $3); }
+ ;
+
BitwiseXORExpression
: BitwiseANDExpression { $$ = $1; }
| BitwiseXORExpression "^" BitwiseANDExpression { $$ = new(driver.pool_) CYBitwiseXOr($1, $3); }
| BitwiseXORExpressionNoBF "^" BitwiseANDExpression { $$ = new(driver.pool_) CYBitwiseXOr($1, $3); }
;
+BitwiseXORExpressionNoWC
+ : BitwiseANDExpressionNoWC { $$ = $1; }
+ | BitwiseXORExpression "^" BitwiseANDExpression { $$ = new(driver.pool_) CYBitwiseXOr($1, $3); }
+ ;
+
BitwiseORExpression
: BitwiseXORExpression { $$ = $1; }
| BitwiseORExpression "|" BitwiseXORExpression { $$ = new(driver.pool_) CYBitwiseOr($1, $3); }
: BitwiseXORExpressionNoBF { $$ = $1; }
| BitwiseORExpressionNoBF "|" BitwiseXORExpression { $$ = new(driver.pool_) CYBitwiseOr($1, $3); }
;
+
+BitwiseORExpressionNoWC
+ : BitwiseXORExpressionNoWC { $$ = $1; }
+ | BitwiseORExpression "|" BitwiseXORExpression { $$ = new(driver.pool_) CYBitwiseOr($1, $3); }
+ ;
/* }}} */
/* 11.11 Binary Logical Operators {{{ */
LogicalANDExpression
| LogicalANDExpressionNoBF "&&" BitwiseORExpression { $$ = new(driver.pool_) CYLogicalAnd($1, $3); }
;
+LogicalANDExpressionNoWC
+ : BitwiseORExpressionNoWC { $$ = $1; }
+ | LogicalANDExpression "&&" BitwiseORExpression { $$ = new(driver.pool_) CYLogicalAnd($1, $3); }
+ ;
+
LogicalORExpression
: LogicalANDExpression { $$ = $1; }
| LogicalORExpression "||" LogicalANDExpression { $$ = new(driver.pool_) CYLogicalOr($1, $3); }
: LogicalANDExpressionNoBF { $$ = $1; }
| LogicalORExpressionNoBF "||" LogicalANDExpression { $$ = new(driver.pool_) CYLogicalOr($1, $3); }
;
+
+LogicalORExpressionNoWC
+ : LogicalANDExpressionNoWC { $$ = $1; }
+ | LogicalORExpression "||" LogicalANDExpression { $$ = new(driver.pool_) CYLogicalOr($1, $3); }
+ ;
/* }}} */
/* 11.12 Conditional Operator ( ? : ) {{{ */
ConditionalExpression
: LogicalORExpressionNoBF { $$ = $1; }
| LogicalORExpressionNoBF "?" AssignmentExpression ":" AssignmentExpression { $$ = new(driver.pool_) CYCondition($1, $3, $5); }
;
+
+ConditionalExpressionNoWC
+ : LogicalORExpressionNoWC { $$ = $1; }
+ | LogicalORExpression "?" AssignmentExpression ":" AssignmentExpression { $$ = new(driver.pool_) CYCondition($1, $3, $5); }
+ ;
/* }}} */
/* 11.13 Assignment Operators {{{ */
AssignmentExpression_
AssigneeExpression
: LeftHandSideExpression { $$ = $1; }
- | LexBeginRegExp UnaryAssigneeExpression { $$ = $2; }
+ | LexSetRegExp UnaryAssigneeExpression { $$ = $2; }
;
AssigneeExpressionNoBF
| UnaryAssigneeExpression { $$ = $1; }
;
+AssigneeExpressionNoWC
+ : LeftHandSideExpressionNoWC { $$ = $1; }
+ | LexSetRegExp UnaryAssigneeExpression { $$ = $2; }
+ ;
+
AssignmentExpression
: ConditionalExpression { $$ = $1; }
| AssigneeExpression AssignmentExpression_ { $2->SetLeft($1); $$ = $2; }
: ConditionalExpressionNoBF { $$ = $1; }
| AssigneeExpressionNoBF AssignmentExpression_ { $2->SetLeft($1); $$ = $2; }
;
+
+AssignmentExpressionNoWC
+ : ConditionalExpressionNoWC { $$ = $1; }
+ | AssigneeExpression AssignmentExpression_ { $2->SetLeft($1); $$ = $2; }
+ ;
/* }}} */
/* 11.14 Comma Operator {{{ */
Expression_
ExpressionOpt
: Expression { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
ExpressionNoInOpt
: ExpressionNoIn { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
Expression
;
Statement
- : LexBeginRegExp Statement_ { $$ = $2; }
+ : LexSetRegExp Statement_ { $$ = $2; }
;
/* }}} */
/* 12.1 Block {{{ */
StatementListOpt
: StatementList { $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
/* }}} */
/* 12.2 Variable Statement {{{ */
ForStatementInitialiser
: ExpressionNoInOpt { $$ = $1; }
- | LexBeginRegExp "var" VariableDeclarationListNoIn { $$ = $3; }
+ | LexSetRegExp "var" VariableDeclarationListNoIn { $$ = $3; }
;
/* }}} */
/* 12.6.4 The for-in Statement {{{ */
ForInStatementInitialiser
: LeftHandSideExpression { $$ = $1; }
- | LexBeginRegExp "var" VariableDeclarationNoIn { $$ = $3; }
+ | LexSetRegExp "var" VariableDeclarationNoIn { $$ = $3; }
;
/* }}} */
/* }}} */
/* 12.13 The throw Statement {{{ */
ThrowStatement
- : "throw" Expression Terminator { $$ = new(driver.pool_) CYThrow($2); }
+ : "throw" Expression Terminator { $$ = new(driver.pool_) cy::Syntax::Throw($2); }
;
/* }}} */
/* 12.14 The try Statement {{{ */
TryStatement
- : "try" Block_ CatchOpt FinallyOpt { $$ = new(driver.pool_) CYTry($2, $3, $4); }
+ : "try" Block_ CatchOpt FinallyOpt { $$ = new(driver.pool_) cy::Syntax::Try($2, $3, $4); }
;
CatchOpt
- : "catch" "(" Identifier ")" Block_ { $$ = new(driver.pool_) CYCatch($3, $5); }
+ : "catch" "(" Identifier ")" Block_ { $$ = new(driver.pool_) cy::Syntax::Catch($3, $5); }
| { $$ = NULL; }
;
: "function" Identifier "(" FormalParameterList ")" "{" FunctionBody "}" { $$ = new(driver.pool_) CYFunctionStatement($2, $4, $7); }
;
+FunctionExpression_
+ : "function" IdentifierOpt "(" FormalParameterList ")" "{" FunctionBody "}" { $$ = new(driver.pool_) CYFunctionExpression($2, $4, $7); }
+ ;
+
FunctionExpression
- : LexBeginRegExp "function" IdentifierOpt "(" FormalParameterList ")" "{" FunctionBody "}" { $$ = new(driver.pool_) CYFunctionExpression($3, $5, $8); }
+ : LexSetRegExp FunctionExpression_ { $$ = $2; }
;
FormalParameterList_
SourceElements
: SourceElement SourceElements { $1->SetNext($2); $$ = $1; }
- | LexBeginRegExp { $$ = NULL; }
+ | LexSetRegExp { $$ = NULL; }
;
SourceElement_
;
SourceElement
- : LexBeginRegExp SourceElement_ { $$ = $2; }
+ : LexSetRegExp SourceElement_ { $$ = $2; }
;
/* }}} */
/* Cycript (Objective-C): @class Declaration {{{ */
ClassSuperOpt
/* XXX: why the hell did I choose MemberExpressionNoBF? */
- : ":" LexBeginRegExp MemberExpressionNoBF { $$ = $3; }
+ : ":" LexSetRegExp MemberExpressionNoBF { $$ = $3; }
| { $$ = NULL; }
;
: "@class" ClassName ClassMessageDeclarationListOpt "@end" { $$ = new(driver.pool_) CYCategory($2, $3); }
;
-PrimaryExpression_
+PrimaryExpressionBF
: ClassExpression { $$ = $1; }
;
;
MessageExpression
- : "[" AssignmentExpression SelectorList "]" { $$ = new(driver.pool_) CYSendDirect($2, $3); }
- | "[" LexBeginRegExp "super" SelectorList "]" { $$ = new(driver.pool_) CYSendSuper($4); }
+ : "[" AssignmentExpressionNoWC SelectorList "]" { $$ = new(driver.pool_) CYSendDirect($2, $3); }
+ | "[" LexSetRegExp "super" SelectorList "]" { $$ = new(driver.pool_) CYSendSuper($4); }
;
SelectorExpressionOpt
| Word { $$ = new(driver.pool_) CYSelectorPart($1, false, NULL); }
;
-PrimaryExpressionNoBF_
+PrimaryExpressionNo
: MessageExpression { $$ = $1; }
| "@selector" "(" SelectorExpression ")" { $$ = new(driver.pool_) CYSelector($3); }
;
@end
@begin E4X
+/* Lexer State {{{ */
+LexPushRegExp
+ : { driver.PushCondition(CYDriver::RegExpCondition); }
+ ;
+
+LexPushXMLContent
+ : { driver.PushCondition(CYDriver::XMLContentCondition); }
+ ;
+
+LexPushXMLTag
+ : { driver.PushCondition(CYDriver::XMLTagCondition); }
+ ;
+
+LexPop
+ : { driver.PopCondition(); }
+ ;
+
+LexSetXMLContent
+ : { driver.SetCondition(CYDriver::XMLContentCondition); }
+ ;
+
+LexSetXMLTag
+ : { driver.SetCondition(CYDriver::XMLTagCondition); }
+ ;
+/* }}} */
+
+XMLWhitespaceOpt
+ : XMLWhitespace
+ |
+ ;
+
+/* 8.1 Context Keywords {{{ */
+Identifier
+ : "namespace" { $$ = $1; }
+ | "xml" { $$ = $1; }
+ ;
+/* }}} */
/* 8.3 XML Initialiser Input Elements {{{ */
XMLMarkup
- : XMLComment
- | XMLCDATA
- | XMLPI
+ : XMLComment { $$ = $1; }
+ | XMLCDATA { $$ = $1; }
+ | XMLPI { $$ = $1; }
;
/* }}} */
/* 11.1 Primary Expressions {{{ */
-PrimaryExpressionNoBF_
- : PropertyIdentifier
- | XMLInitialiser
- | XMLListInitialiser
+PrimaryExpressionWC
+ : PropertyIdentifier { $$ = $1; }
+ | XMLInitialiser { $$ = $1; }
+ | XMLListInitialiser { $$ = $1; }
;
PropertyIdentifier
- : AttributeIdentifier
- | QualifiedIdentifier
- | WildcardIdentifier
+ : AttributeIdentifier { $$ = $1; }
+ | QualifiedIdentifier { $$ = $1; }
+ | WildcardIdentifier { $$ = $1; }
;
/* }}} */
/* 11.1.1 Attribute Identifiers {{{ */
AttributeIdentifier
- : "@" PropertySelector
- | "@" QualifiedIdentifier
- | "@" "[" Expression "]"
+ : "@" QualifiedIdentifier_ { $$ = new(driver.pool_) CYAttribute($2); }
+ ;
+
+PropertySelector_
+ : PropertySelector
+ | "[" Expression "]"
;
PropertySelector
- : Identifier
- | WildcardIdentifier
+ : Word { $$ = $1; }
+ | WildcardIdentifier { $$ = $1; }
;
/* }}} */
/* 11.1.2 Qualified Identifiers {{{ */
+QualifiedIdentifier_
+ : PropertySelector_ { $$ = $1; }
+ | QualifiedIdentifier { $$ = $1; }
+ ;
+
QualifiedIdentifier
- : PropertySelector "::" PropertySelector
- | PropertySelector "::" "[" Expression "]"
+ : PropertySelector "::" PropertySelector_ { $$ = new(driver.pool_) CYQName($1, $3); }
;
/* }}} */
/* 11.1.3 Wildcard Identifiers {{{ */
WildcardIdentifier
- : "*"
+ : "*" { $$ = new(driver.pool_) CYWildcard(); }
;
/* }}} */
/* 11.1.4 XML Initialiser {{{ */
XMLInitialiser
- : XMLMarkup
- | XMLElement
+ : XMLMarkup { $$ = $1; }
+ | XMLElement { $$ = $1; }
;
XMLElement
- : "<" XMLTagContent XMLWhitespaceOpt "/>"
- | "<" XMLTagContent XMLWhitespace ">" XMLElementContentOpt "</" XMLTagName XMLWhitespaceOpt ">"
+ : "<" XMLTagContent_ "/>" LexPop
+ | "<" XMLTagContent_ ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt ">" LexPop
+ ;
+
+XMLTagContent_
+ : LexPushXMLTag XMLTagContent XMLWhitespaceOpt
;
XMLTagContent
: XMLTagName XMLAttributesOpt
;
+XMLExpression
+ : "{" LexPushRegExp Expression "}" LexPop
+ ;
+
XMLTagName
- : "{" Expression "}"
+ : XMLExpression
| XMLName
;
XMLAttributes
- : XMLWhitespace "{" Expression "}"
+ : XMLWhitespace XMLExpression
| XMLAttributeOpt XMLAttributes
;
|
;
+XMLAttributeValue_
+ : XMLExpression
+ | XMLAttributeValue
+ ;
+
XMLAttribute
- : XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt "{" Expression "}"
- | XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt XMLAttributeValue
+ : XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt XMLAttributeValue_
;
XMLAttributeOpt
;
XMLElementContent
- : "{" Expression "}" XMLElementContentOpt
+ : XMLExpression XMLElementContentOpt
| XMLMarkup XMLElementContentOpt
| XMLText XMLElementContentOpt
| XMLElement XMLElementContentOpt
/* }}} */
/* 11.1.5 XMLList Initialiser {{{ */
XMLListInitialiser
- : "<>" XMLElementContent "</>"
+ : "<>" LexPushXMLContent XMLElementContent "</>" LexPop { $$ = new(driver.pool_) CYXMLList($3); }
+ ;
+/* }}} */
+/* 11.2 Left-Hand-Side Expressions {{{ */
+PropertyIdentifier_
+ : Word { $$ = $1; }
+ | PropertyIdentifier { $$ = $1; }
+ ;
+
+MemberAccess
+ : "." PropertyIdentifier { $$ = new(driver.pool_) CYPropertyMember(NULL, $2); }
+ | ".." PropertyIdentifier_ { $$ = new(driver.pool_) CYDescendantMember(NULL, $2); }
+ | "." "(" Expression ")" { $$ = new(driver.pool_) CYFilteringPredicate(NULL, $3); }
+ ;
+/* }}} */
+/* 12.1 The default xml namespace Statement {{{ */
+DefaultXMLNamespaceStatement
+ : "default" "xml" "namespace" "=" Expression Terminator { $$ = new(driver.pool_) CYDefaultXMLNamespace($5); }
+ ;
+
+Statement_
+ : DefaultXMLNamespaceStatement { $$ = $1; }
;
/* }}} */
@end
: ForComprehension ComprehensionListOpt { $1->SetNext($2); $$ = $1; }
;
-PrimaryExpressionNoBF_
+PrimaryExpressionNo
: "[" AssignmentExpression ComprehensionList "]" { $$ = new(driver.pool_) CYArrayComprehension($2, $3); }
;
/* }}} */
*//* }}} */
/* JavaScript FTW: Function Statements {{{ */
Statement
- : LexBeginRegExp FunctionDeclaration { driver.Warning(yylloc, "warning, FunctionDeclaration is a SourceElement, not a Statement"); } { $$ = $2; }
+ : LexSetRegExp FunctionDeclaration { driver.Warning(yylloc, "warning, FunctionDeclaration is a SourceElement, not a Statement"); } { $$ = $2; }
;
/* }}} */
projects / cycript.git / blobdiff