1 /* Cycript - Optimizing JavaScript Compiler/Runtime
2 * Copyright (C) 2009-2013 Jay Freeman (saurik)
5 /* GNU General Public License, Version 3 {{{ */
7 * Cycript is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation, either version 3 of the License,
10 * or (at your option) any later version.
12 * Cycript is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Cycript. If not, see <http://www.gnu.org/licenses/>.
24 @if Bison24 %code top {
25 #define cyscanner driver.scanner_
26 #define YYSTACKEXPANDABLE 1
27 @if Bison23 #define yyerrok (yyerrstatus_ = 0)
30 @if Bison24 %code requires {
33 #define CYNew new($pool)
36 #include "ObjectiveC/Syntax.hpp"
40 #include "E4X/Syntax.hpp"
43 #include "Highlight.hpp"
52 CYDriver::Condition condition_;
54 CYArgument *argument_;
55 CYAssignment *assignment_;
58 cy::Syntax::Catch *catch_;
60 CYComprehension *comprehension_;
61 CYCompound *compound_;
62 CYDeclaration *declaration_;
63 CYDeclarations *declarations_;
65 CYExpression *expression_;
68 CYForInitialiser *for_;
69 CYForInInitialiser *forin_;
70 CYFunctionParameter *functionParameter_;
71 CYIdentifier *identifier_;
79 CYProperty *property_;
80 CYPropertyName *propertyName_;
81 CYRubyProc *rubyProc_;
82 CYStatement *statement_;
89 CYClassName *className_;
92 CYMessageParameter *messageParameter_;
93 CYProtocol *protocol_;
94 CYSelectorPart *selector_;
95 CYTypeModifier *modifier_;
96 CYTypedIdentifier *typedIdentifier_;
97 CYTypedParameter *typedParameter_;
101 CYAttribute *attribute_;
102 CYPropertyIdentifier *propertyIdentifier_;
103 CYSelector *selector_;
108 #define YYSTYPE YYSTYPE
111 @if Bison24 %code provides {
112 int cylex(YYSTYPE *, cy::location *, void *);
119 @if Bison23 %skeleton "lalr1.cc"
120 @if Bison24 %language "C++"
123 @$.begin.filename = @$.end.filename = &driver.filename_;
134 %parse-param { CYDriver &driver }
135 %lex-param { void *cyscanner }
137 /* Token Declarations {{{ */
143 %token XMLAttributeValue
145 %token XMLTagCharacters
151 %token LeftRight "<>"
152 %token LeftSlashRight "</>"
154 %token SlashRight "/>"
155 %token LeftSlash "</"
157 %token ColonColon "::"
158 %token PeriodPeriod ".."
161 @begin E4X ObjectiveC
167 %token AmpersandAmpersand "&&"
168 %token AmpersandEqual "&="
170 %token CarrotEqual "^="
172 %token EqualEqual "=="
173 %token EqualEqualEqual "==="
174 %token EqualRight "=>"
175 %token Exclamation "!"
176 %token ExclamationEqual "!="
177 %token ExclamationEqualEqual "!=="
179 %token HyphenEqual "-="
180 %token HyphenHyphen "--"
181 %token HyphenHyphen_ "\n--"
182 %token HyphenRight "->"
184 %token LeftEqual "<="
186 %token LeftLeftEqual "<<="
188 %token PercentEqual "%="
190 %token PeriodPeriodPeriod "..."
192 %token PipeEqual "|="
195 %token PlusEqual "+="
197 %token PlusPlus_ "\n++"
199 %token RightEqual ">="
200 %token RightRight ">>"
201 %token RightRightEqual ">>="
202 %token RightRightRight ">>>"
203 %token RightRightRightEqual ">>>="
205 %token SlashEqual "/="
207 %token StarEqual "*="
216 %token <comment_> Comment
219 %token CloseParen ")"
222 %token OpenBrace_ "\n{"
223 %token OpenBrace__ ";{"
224 %token CloseBrace "}"
226 %token OpenBracket "["
227 %token CloseBracket "]"
229 %token AtError "@error"
232 %token AtClass "@class"
236 %token <identifier_> Typedef "typedef"
240 %token AtImplementation "@implementation"
241 %token AtImplementation_ ";@implementation"
242 %token AtImport "@import"
243 %token AtEncode "@encode"
245 %token AtSelector "@selector"
246 %token <identifier_> Yes "YES"
247 %token <identifier_> No "NO"
250 %token <false_> False "false"
251 %token <null_> Null "null"
252 %token <true_> True "true"
254 // ES3/ES5/WIE/JSC Reserved
255 %token <word_> Auto "auto"
256 %token <word_> Break "break"
257 %token <word_> Case "case"
258 %token <word_> Catch "catch"
259 %token <word_> Continue "continue"
260 %token <word_> Default "default"
261 %token <word_> Delete "delete"
262 %token <word_> Do "do"
263 %token <word_> Else "else"
264 %token <word_> Finally "finally"
265 %token <word_> For "for"
266 %token <word_> Function "function"
267 %token <word_> Function_ ";function"
268 %token <word_> If "if"
269 %token <word_> In "in"
270 %token <word_> In_ "!in"
271 %token <word_> InstanceOf "instanceof"
272 %token <word_> New "new"
273 %token <word_> Return "return"
274 %token <word_> Switch "switch"
275 %token <this_> This "this"
276 %token <word_> Throw "throw"
277 %token <word_> Try "try"
278 %token <word_> TypeOf "typeof"
279 %token <word_> Var "var"
280 %token <word_> Void "void"
281 %token <word_> While "while"
282 %token <word_> With "with"
284 // ES3/IE6 Future, ES5/JSC Reserved
285 %token <word_> Debugger "debugger"
287 // ES3/ES5/IE6 Future, JSC Reserved
288 %token <word_> Const "const"
290 // ES3/ES5/IE6/JSC Future
291 %token <word_> Class "class"
292 %token <word_> Enum "enum"
293 %token <word_> Export "export"
294 %token <word_> Extends "extends"
295 %token <word_> Import "import"
296 %token <word_> Super "super"
298 // ES3 Future, ES5 Strict Future
299 %token <identifier_> Implements "implements"
300 %token <identifier_> Interface "interface"
301 %token <identifier_> Package "package"
302 %token <identifier_> Private "private"
303 %token <identifier_> Protected "protected"
304 %token <identifier_> Public "public"
305 %token <identifier_> Static "static"
308 %token <identifier_> Abstract "abstract"
309 %token <identifier_> Boolean "boolean"
310 %token <identifier_> Byte "byte"
311 %token <identifier_> Char "char"
312 %token <identifier_> Double "double"
313 %token <identifier_> Final "final"
314 %token <identifier_> Float "float"
315 %token <identifier_> Goto "goto"
316 %token <identifier_> Int "int"
317 %token <identifier_> Long "long"
318 %token <identifier_> Native "native"
319 %token <identifier_> Short "short"
320 %token <identifier_> Synchronized "synchronized"
321 %token <identifier_> Throws "throws"
322 %token <identifier_> Transient "transient"
323 %token <identifier_> Volatile "volatile"
326 %token <identifier_> Let "let"
327 %token <identifier_> Yield "yield"
330 %token <identifier_> Each "each"
331 %token <identifier_> Of "of"
335 %token <identifier_> Namespace "namespace"
336 %token <identifier_> XML "xml"
341 %token <identifier_> Identifier_
342 %token <number_> NumericLiteral
343 %token <string_> StringLiteral
344 %token <literal_> RegularExpressionLiteral
346 %type <expression_> AdditiveExpression
347 %type <argument_> ArgumentList_
348 %type <argument_> ArgumentList
349 %type <argument_> ArgumentListOpt
350 %type <argument_> Arguments
351 %type <expression_> ArrayComprehension
352 %type <expression_> ArrayInitialiser
353 %type <literal_> ArrayLiteral
354 %type <expression_> ArrowFunction
355 %type <functionParameter_> ArrowParameters
356 %type <expression_> AssignmentExpression
357 %type <identifier_> Binding
358 %type <identifier_> BindingIdentifier
359 %type <expression_> BitwiseANDExpression
360 %type <statement_> Block_
361 %type <statement_> Block
362 %type <boolean_> BooleanLiteral
363 %type <declaration_> BindingElement
364 %type <expression_> BitwiseORExpression
365 %type <expression_> BitwiseXORExpression
366 %type <statement_> BreakStatement
367 %type <statement_> BreakableStatement
368 %type <expression_> CallExpression_
369 %type <expression_> CallExpression
370 %type <clause_> CaseBlock
371 %type <clause_> CaseClause
372 %type <clause_> CaseClausesOpt
373 %type <catch_> CatchOpt
374 %type <expression_> Comprehension
375 %type <comprehension_> ComprehensionFor
376 %type <comprehension_> ComprehensionIf
377 %type <comprehension_> ComprehensionTail
378 %type <expression_> ConditionalExpression
379 %type <statement_> ContinueStatement
380 %type <statement_> ConciseBody
381 %type <statement_> DebuggerStatement
382 %type <statement_> Declaration__
383 %type <statement_> Declaration_
384 %type <statement_> Declaration
385 %type <clause_> DefaultClause
386 %type <expression_> Element
387 %type <expression_> ElementOpt
388 %type <element_> ElementList
389 %type <element_> ElementListOpt
390 %type <statement_> ElseStatementOpt
391 %type <statement_> EmptyStatement
392 %type <expression_> EqualityExpression
393 %type <compound_> Expression_
394 %type <compound_> Expression
395 %type <expression_> ExpressionOpt
396 %type <statement_> ExpressionStatement
397 %type <finally_> FinallyOpt
398 %type <for_> ForStatementInitialiser
399 %type <forin_> ForInStatementInitialiser
400 %type <declaration_> FormalParameter
401 %type <functionParameter_> FormalParameterList_
402 %type <functionParameter_> FormalParameterList
403 %type <functionParameter_> FormalParameterListOpt
404 %type <statement_> FunctionBody
405 %type <statement_> FunctionDeclaration
406 %type <expression_> FunctionExpression
407 %type <identifier_> Identifier
408 %type <identifier_> IdentifierOpt
409 %type <word_> IdentifierName
410 %type <statement_> IfStatement
411 %type <expression_> Initialiser
412 %type <expression_> InitialiserOpt
413 %type <statement_> IterationStatement
414 %type <statement_> LabelledStatement
415 %type <expression_> LeftHandSideExpression
416 %type <statement_> LetStatement
417 %type <statement_> LexicalDeclaration
418 %type <literal_> Literal
419 %type <literal_> ValueLiteral
420 %type <expression_> LogicalANDExpression
421 %type <expression_> LogicalORExpression
422 %type <member_> MemberAccess
423 %type <expression_> MemberExpression_
424 %type <expression_> MemberExpression
425 %type <expression_> MultiplicativeExpression
426 %type <expression_> NewExpression
427 %type <null_> NullLiteral
428 %type <literal_> ObjectLiteral
429 %type <compound_> Parenthetical
430 %type <compound_> ParentheticalOpt
431 %type <expression_> PostfixExpression
432 %type <expression_> PrimaryExpression
433 %type <statement_> Program
434 %type <statement_> ProgramBody
435 %type <statement_> ProgramBodyOpt
436 %type <propertyName_> PropertyName_
437 %type <propertyName_> PropertyName
438 %type <property_> PropertyDefinition
439 %type <property_> PropertyDefinitionList_
440 %type <property_> PropertyDefinitionList
441 %type <property_> PropertyDefinitionListOpt
442 %type <expression_> RelationalExpression
443 %type <statement_> ReturnStatement
444 %type <rubyProc_> RubyProcExpression
445 %type <functionParameter_> RubyProcParameterList_
446 %type <functionParameter_> RubyProcParameterList
447 %type <functionParameter_> RubyProcParameters
448 %type <functionParameter_> RubyProcParametersOpt
449 %type <expression_> ShiftExpression
450 %type <declaration_> SingleNameBinding
451 %type <statement_> Statement__
452 %type <statement_> Statement_
453 %type <statement_> Statement
454 %type <statement_> StatementList
455 %type <statement_> StatementListOpt
456 %type <statement_> StatementListItem
457 %type <statement_> SwitchStatement
458 %type <statement_> ThrowStatement
459 %type <statement_> TryStatement
460 %type <expression_> UnaryExpression_
461 %type <expression_> UnaryExpression
462 %type <declaration_> VariableDeclaration
463 %type <declarations_> VariableDeclarationList_
464 %type <declarations_> VariableDeclarationList
465 %type <statement_> VariableStatement
466 %type <statement_> WithStatement
468 %type <word_> WordOpt
469 %type <expression_> Variable
472 %type <typedIdentifier_> ArrayedType
473 %type <expression_> BoxableExpression
474 %type <statement_> CategoryStatement
475 %type <expression_> ClassExpression
476 %type <field_> ClassFieldListOpt
477 %type <field_> ClassFields
478 %type <statement_> ClassStatement
479 %type <expression_> ClassSuperOpt
480 %type <message_> ClassMessageDeclaration
481 %type <message_> ClassMessageDeclarationListOpt
482 %type <className_> ClassName
483 %type <className_> ClassNameOpt
484 %type <protocol_> ClassProtocolListOpt
485 %type <protocol_> ClassProtocols
486 %type <protocol_> ClassProtocolsOpt
487 %type <expression_> EncodedType
488 %type <modifier_> FunctionedType
489 %type <expression_> MessageExpression
490 %type <messageParameter_> MessageParameter
491 %type <messageParameter_> MessageParameters
492 %type <messageParameter_> MessageParameterList
493 %type <messageParameter_> MessageParameterListOpt
494 %type <bool_> MessageScope
495 %type <typedIdentifier_> ModifiedType
496 %type <module_> Module
497 %type <typedIdentifier_> PrefixedType
498 %type <expression_> PrimitiveType
499 %type <argument_> SelectorCall_
500 %type <argument_> SelectorCall
501 %type <selector_> SelectorExpression_
502 %type <selector_> SelectorExpression
503 %type <selector_> SelectorExpressionOpt
504 %type <argument_> SelectorList
505 %type <word_> SelectorWordOpt
506 %type <typedIdentifier_> SuffixedType
507 %type <expression_> TypeOpt
508 %type <typedIdentifier_> TypeParenthetical
509 %type <modifier_> TypeQualifierLeft
510 %type <typedIdentifier_> TypeQualifierRight
511 %type <typedIdentifier_> TypeSignifier
512 %type <typedIdentifier_> TypedIdentifier
513 %type <typedParameter_> TypedParameterList_
514 %type <typedParameter_> TypedParameterList
515 %type <typedParameter_> TypedParameterListOpt
516 %type <argument_> VariadicCall
520 %type <propertyIdentifier_> PropertyIdentifier_
521 %type <selector_> PropertySelector_
522 %type <selector_> PropertySelector
523 %type <identifier_> QualifiedIdentifier_
524 %type <identifier_> QualifiedIdentifier
525 %type <identifier_> WildcardIdentifier
526 %type <identifier_> XMLComment
527 %type <identifier_> XMLCDATA
528 %type <identifier_> XMLElement
529 %type <identifier_> XMLElementContent
530 %type <identifier_> XMLMarkup
531 %type <identifier_> XMLPI
533 %type <attribute_> AttributeIdentifier
534 /* XXX: %type <statement_> DefaultXMLNamespaceStatement */
535 %type <expression_> PropertyIdentifier
536 %type <expression_> XMLListInitialiser
537 %type <expression_> XMLInitialiser
540 /* Token Priorities {{{ */
552 /* Lexer State {{{ */
554 : { driver.in_.push(true); }
558 : { driver.in_.push(false); }
562 : { driver.in_.pop(); }
566 : { driver.SetCondition(CYDriver::RegExpCondition); }
570 : { if (yychar == yyempty_) driver.no_.OpenBrace = true; else if (yychar == token::OpenBrace || yychar == token::OpenBrace_) yychar = token::OpenBrace__; }
574 : { if (yychar == yyempty_) driver.no_.Function = true; else if (yychar == token::Function) yychar = token::Function_; }
577 LexNoAtImplementation :
579 { if (yychar == yyempty_) driver.no_.AtImplementation = true; else if (yychar == token::AtImplementation) yychar = token::AtImplementation_; }
584 : LexNoBrace LexNoFunction LexNoAtImplementation
587 /* Virtual Tokens {{{ */
598 /* 7.6 Identifier Names and Identifiers {{{ */
609 : Identifier { $$ = $1; }
610 | "auto" { $$ = $1; }
611 | "break" NewLineOpt { $$ = $1; }
612 | "case" { $$ = $1; }
613 | "catch" { $$ = $1; }
614 | "class" { $$ = $1; }
615 | "const" { $$ = $1; }
616 | "continue" NewLineOpt { $$ = $1; }
617 | "debugger" { $$ = $1; }
618 | "default" { $$ = $1; }
619 | "delete" { $$ = $1; }
621 | "else" { $$ = $1; }
622 | "enum" { $$ = $1; }
623 | "export" { $$ = $1; }
624 | "extends" { $$ = $1; }
625 | "false" { $$ = $1; }
626 | "finally" { $$ = $1; }
627 /* XXX: | "for" { $$ = $1; } */
628 | "function" { $$ = $1; }
630 | "import" { $$ = $1; }
631 /* XXX: | "in" { $$ = $1; } */
633 /* XXX: | "instanceof" { $$ = $1; } */
635 // XXX: as it currently is not an Identifier
639 | "null" { $$ = $1; }
640 | "return" NewLineOpt { $$ = $1; }
641 | "super" { $$ = $1; }
642 | "switch" { $$ = $1; }
643 | "this" { $$ = $1; }
644 | "throw" NewLineOpt { $$ = $1; }
645 | "true" { $$ = $1; }
647 | "typeof" { $$ = $1; }
649 | "void" { $$ = $1; }
650 | "while" { $$ = $1; }
651 | "with" { $$ = $1; }
660 : Identifier_ { $$ = $1; }
663 | "typedef" { $$ = $1; }
668 | "implements" { $$ = $1; }
669 | "interface" { $$ = $1; }
670 | "package" { $$ = $1; }
671 | "private" { $$ = $1; }
672 | "protected" { $$ = $1; }
673 | "public" { $$ = $1; }
674 | "static" { $$ = $1; }
676 | "abstract" { $$ = $1; }
677 | "boolean" { $$ = $1; }
678 | "byte" { $$ = $1; }
679 | "char" { $$ = $1; }
680 | "double" { $$ = $1; }
681 | "final" { $$ = $1; }
682 | "float" { $$ = $1; }
683 | "goto" { $$ = $1; }
685 | "long" { $$ = $1; }
686 | "native" { $$ = $1; }
687 | "short" { $$ = $1; }
688 | "synchronized" { $$ = $1; }
689 | "throws" { $$ = $1; }
690 | "transient" { $$ = $1; }
691 | "volatile" { $$ = $1; }
693 // XXX: currently I only have this as Word
694 // | "let" { $$ = $1; }
696 | "yield" { $$ = $1; }
698 | "each" { $$ = $1; }
703 : Identifier { $$ = $1; }
708 /* 7.8 Literals {{{ */
710 : NullLiteral { $$ = $1; }
711 | ValueLiteral { $$ = $1; }
715 : BooleanLiteral { $$ = $1; }
716 | NumericLiteral { $$ = $1; }
717 | StringLiteral { $$ = $1; }
718 | RegularExpressionLiteral { $$ = $1; }
721 /* 7.8.1 Null Literals {{{ */
723 : "null" { $$ = $1; }
726 /* 7.8.2 Boolean Literals {{{ */
728 : "true" { $$ = $1; }
729 | "false" { $$ = $1; }
733 /* 7.9 Automatic Semicolon Insertion {{{ */
735 : { driver.Warning(yylloc, "warning, automatic semi-colon insertion required"); }
740 | error { if (yychar != yyeof_ && yychar != token::CloseBrace && !yylval.newline_) YYABORT; else { yyerrok; driver.errors_.pop_back(); } } StrictSemi
745 | error { yyerrok; driver.errors_.pop_back(); } StrictSemi
749 /* 11.1 Primary Expressions {{{ */
751 : "(" LexPushInOff Expression ")" LexPopIn { $$ = $3; }
755 : Parenthetical { $$ = $1; }
760 : Identifier { $$ = CYNew CYVariable($1); }
764 : "this" { $$ = $1; }
765 | Variable { $$ = $1; }
766 | Literal { $$ = $1; }
767 | ArrayInitialiser { $$ = $1; }
768 | ObjectLiteral { $$ = $1; }
769 | Parenthetical { $$ = $1; }
770 | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; }
773 /* 11.1.4 Array Initializer {{{ */
775 : ArrayLiteral { $$ = $1; }
776 | ArrayComprehension { $$ = $1; }
779 /* 11.1.4.1 Array Literal {{{ */
781 : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); }
785 : AssignmentExpression { $$ = $1; }
789 : Element { $$ = $1; }
790 | LexSetRegExp { $$ = NULL; }
794 : ElementOpt "," ElementListOpt { $$ = CYNew CYElement($1, $3); }
795 | Element { $$ = CYNew CYElement($1, NULL); }
799 : ElementList { $$ = $1; }
800 | LexSetRegExp { $$ = NULL; }
803 /* 11.1.4.2 Array Comprehension {{{ */
805 : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; }
809 : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); }
814 | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); }
815 | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); }
819 : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); }
823 : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); }
826 /* 11.1.5 Object Initialiser {{{ */
828 : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); }
831 PropertyDefinitionList_
832 : "," PropertyDefinitionList { $$ = $2; }
833 | "," LexSetRegExp { $$ = NULL; }
837 PropertyDefinitionList
838 : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; }
841 PropertyDefinitionListOpt
842 : PropertyDefinitionList { $$ = $1; }
843 | LexSetRegExp { $$ = NULL; }
847 // XXX: this should be IdentifierName
848 : LexSetRegExp Identifier { $$ = CYNew CYProperty($2, CYNew CYVariable($2)); }
849 | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); }
854 : IdentifierName { $$ = $1; }
855 | StringLiteral { $$ = $1; }
856 | NumericLiteral { $$ = $1; }
860 : LexSetRegExp PropertyName_ { $$ = $2; }
864 /* 11.2 Left-Hand-Side Expressions {{{ */
866 : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); }
867 | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); }
868 | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; }
872 : MemberExpression { $$ = $1; }
873 //| "super" { $$ = $1; }
877 : LexSetRegExp PrimaryExpression { $$ = $2; }
878 | LexSetRegExp FunctionExpression { $$ = $2; }
879 | MemberExpression_ { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
880 | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); }
884 : MemberExpression { $$ = $1; }
885 | LexSetRegExp "new" NewExpression { $$ = CYNew cy::Syntax::New($3, NULL); }
894 : CallExpression_ Arguments { $$ = CYNew CYCall($1, $2); }
895 | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; }
899 : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; }
903 : "," ArgumentList { $$ = $2; }
908 : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); }
912 : ArgumentList { $$ = $1; }
913 | LexSetRegExp { $$ = NULL; }
916 LeftHandSideExpression
917 : NewExpression { $$ = $1; }
918 | CallExpression { $$ = $1; }
921 /* 11.3 Postfix Expressions {{{ */
923 : %prec "" LeftHandSideExpression { $$ = $1; }
924 | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); }
925 | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); }
928 /* 11.4 Unary Operators {{{ */
930 : "delete" UnaryExpression { $$ = CYNew CYDelete($2); }
931 | "void" UnaryExpression { $$ = CYNew CYVoid($2); }
932 | "typeof" UnaryExpression { $$ = CYNew CYTypeOf($2); }
933 | "++" UnaryExpression { $$ = CYNew CYPreIncrement($2); }
934 | "\n++" UnaryExpression { $$ = CYNew CYPreIncrement($2); }
935 | "--" UnaryExpression { $$ = CYNew CYPreDecrement($2); }
936 | "\n--" UnaryExpression { $$ = CYNew CYPreDecrement($2); }
937 | "+" UnaryExpression { $$ = CYNew CYAffirm($2); }
938 | "-" UnaryExpression { $$ = CYNew CYNegate($2); }
939 | "~" UnaryExpression { $$ = CYNew CYBitwiseNot($2); }
940 | "!" UnaryExpression { $$ = CYNew CYLogicalNot($2); }
944 : PostfixExpression { $$ = $1; }
945 | LexSetRegExp UnaryExpression_ { $$ = $2; }
948 /* 11.5 Multiplicative Operators {{{ */
949 MultiplicativeExpression
950 : UnaryExpression { $$ = $1; }
951 | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); }
952 | MultiplicativeExpression "/" UnaryExpression { $$ = CYNew CYDivide($1, $3); }
953 | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); }
956 /* 11.6 Additive Operators {{{ */
958 : MultiplicativeExpression { $$ = $1; }
959 | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); }
960 | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); }
963 /* 11.7 Bitwise Shift Operators {{{ */
965 : AdditiveExpression { $$ = $1; }
966 | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); }
967 | ShiftExpression ">>" AdditiveExpression { $$ = CYNew CYShiftRightSigned($1, $3); }
968 | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); }
971 /* 11.8 Relational Operators {{{ */
973 : ShiftExpression { $$ = $1; }
974 | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); }
975 | RelationalExpression ">" ShiftExpression { $$ = CYNew CYGreater($1, $3); }
976 | RelationalExpression "<=" ShiftExpression { $$ = CYNew CYLessOrEqual($1, $3); }
977 | RelationalExpression ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual($1, $3); }
978 | RelationalExpression "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf($1, $3); }
979 | RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); }
982 /* 11.9 Equality Operators {{{ */
984 : RelationalExpression { $$ = $1; }
985 | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); }
986 | EqualityExpression "!=" RelationalExpression { $$ = CYNew CYNotEqual($1, $3); }
987 | EqualityExpression "===" RelationalExpression { $$ = CYNew CYIdentical($1, $3); }
988 | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); }
991 /* 11.10 Binary Bitwise Operators {{{ */
993 : EqualityExpression { $$ = $1; }
994 | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); }
998 : BitwiseANDExpression { $$ = $1; }
999 | BitwiseXORExpression "^" BitwiseANDExpression { $$ = CYNew CYBitwiseXOr($1, $3); }
1003 : BitwiseXORExpression { $$ = $1; }
1004 | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); }
1007 /* 11.11 Binary Logical Operators {{{ */
1008 LogicalANDExpression
1009 : BitwiseORExpression { $$ = $1; }
1010 | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); }
1014 : LogicalANDExpression { $$ = $1; }
1015 | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); }
1018 /* 11.12 Conditional Operator ( ? : ) {{{ */
1019 ConditionalExpression
1020 : LogicalORExpression { $$ = $1; }
1021 | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); }
1022 | LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); }
1025 /* 11.13 Assignment Operators {{{ */
1026 AssignmentExpression
1027 : ConditionalExpression { $$ = $1; }
1028 | ArrowFunction { $$ = $1; }
1029 | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); }
1030 | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); }
1031 | LeftHandSideExpression "/=" AssignmentExpression { $$ = CYNew CYDivideAssign($1, $3); }
1032 | LeftHandSideExpression "%=" AssignmentExpression { $$ = CYNew CYModulusAssign($1, $3); }
1033 | LeftHandSideExpression "+=" AssignmentExpression { $$ = CYNew CYAddAssign($1, $3); }
1034 | LeftHandSideExpression "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign($1, $3); }
1035 | LeftHandSideExpression "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign($1, $3); }
1036 | LeftHandSideExpression ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign($1, $3); }
1037 | LeftHandSideExpression ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign($1, $3); }
1038 | LeftHandSideExpression "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign($1, $3); }
1039 | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); }
1040 | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); }
1043 /* 11.14 Comma Operator {{{ */
1045 : "," Expression { $$ = $2; }
1046 | { $$ = CYNew CYCompound(); }
1050 : AssignmentExpression Expression_ { $2->AddPrev($1); $$ = $2; }
1054 : Expression { $$ = $1; }
1055 | LexSetRegExp { $$ = NULL; }
1059 /* 12 Statements {{{ */
1061 : Block { $$ = $1; }
1062 | VariableStatement { $$ = $1; }
1063 | EmptyStatement { $$ = $1; }
1064 | IfStatement { $$ = $1; }
1065 | BreakableStatement { $$ = $1; }
1066 | ContinueStatement { $$ = $1; }
1067 | BreakStatement { $$ = $1; }
1068 | ReturnStatement { $$ = $1; }
1069 | WithStatement { $$ = $1; }
1070 | LabelledStatement { $$ = $1; }
1071 | ThrowStatement { $$ = $1; }
1072 | TryStatement { $$ = $1; }
1073 | DebuggerStatement { $$ = $1; }
1077 : LexSetRegExp Statement__ { $$ = $2; }
1078 | ExpressionStatement { $$ = $1; }
1082 : LexSetStatement Statement_ { $$ = $2; }
1086 : FunctionDeclaration { $$ = $1; }
1087 | LexicalDeclaration { $$ = $1; }
1091 : LexSetRegExp Declaration__ { $$ = $2; }
1095 : LexSetStatement Declaration_ { $$ = $2; }
1099 : IterationStatement { $$ = $1; }
1100 | SwitchStatement { $$ = $1; }
1103 /* 12.1 Block {{{ */
1105 : BRACE StatementListOpt "}" { $$ = $2; }
1109 : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); }
1113 : StatementListItem StatementListOpt { $1->SetNext($2); $$ = $1; }
1117 : StatementList { $$ = $1; }
1118 | LexSetStatement LexSetRegExp { $$ = NULL; }
1122 : Statement { $$ = $1; }
1123 | Declaration { $$ = $1; }
1127 /* 12.2 Declarations {{{ */
1129 : Identifier { $$ = $1; }
1136 // XXX: BindingPattern
1138 /* 12.2.1 Let and Const Declarations {{{ */
1140 : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
1148 /* 12.2.2 Variable Statement {{{ */
1150 : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); }
1153 VariableDeclarationList_
1154 : "," VariableDeclarationList { $$ = $2; }
1158 VariableDeclarationList
1159 : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); }
1163 : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
1164 // XXX: | BindingPattern Initialiser { $$ = CYNew CYDeclaration($1, $2); }
1168 : "=" AssignmentExpression { $$ = $2; }
1172 : Initialiser { $$ = $1; }
1176 /* 12.2.4 Destructuring Binding Patterns {{{ */
1180 : SingleNameBinding { $$ = $1; }
1184 : BindingIdentifier InitialiserOpt { $$ = CYNew CYDeclaration($1, $2); }
1188 /* 12.3 Empty Statement {{{ */
1190 : ";" { $$ = CYNew CYEmpty(); }
1193 /* 12.4 Expression Statement {{{ */
1195 : Expression Terminator { $$ = CYNew CYExpress($1); }
1198 /* 12.5 The if Statement {{{ */
1200 : "else" Statement { $$ = $2; }
1201 | %prec "if" { $$ = NULL; }
1205 : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); }
1209 /* 12.6.1 The do-while Statement {{{ */
1211 : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); }
1214 /* 12.6.2 The while Statement {{{ */
1216 : "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); }
1219 /* 12.6.3 The for Statement {{{ */
1221 : "for" "(" LexPushInOn ForStatementInitialiser ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); }
1224 ForStatementInitialiser
1225 : ExpressionOpt { $$ = $1; }
1226 | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); }
1229 /* 12.6.4 The for-in and for-of Statements {{{ */
1231 : "for" "(" LexPushInOn ForInStatementInitialiser "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); }
1232 | "for" "(" LexPushInOn ForInStatementInitialiser "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); }
1235 ForInStatementInitialiser
1236 : LeftHandSideExpression { $$ = $1; }
1237 | LexSetRegExp Var_ VariableDeclaration { $$ = $3; }
1241 /* 12.7 The continue Statement {{{ */
1243 : "continue" "\n" StrictSemi { $$ = CYNew CYContinue(NULL); }
1244 | "continue" IdentifierOpt Terminator { $$ = CYNew CYContinue($2); }
1247 /* 12.8 The break Statement {{{ */
1249 : "break" "\n" StrictSemi { $$ = CYNew CYBreak(NULL); }
1250 | "break" IdentifierOpt Terminator { $$ = CYNew CYBreak($2); }
1253 /* 12.9 The return Statement {{{ */
1255 : "return" LexSetRegExp "\n" StrictSemi { $$ = CYNew CYReturn(NULL); }
1256 | "return" ExpressionOpt Terminator { $$ = CYNew CYReturn($2); }
1259 /* 12.10 The with Statement {{{ */
1261 : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); }
1265 /* 12.11 The switch Statement {{{ */
1267 : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); }
1271 : BRACE CaseClausesOpt "}" { $$ = $2; }
1275 : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); }
1279 : CaseClause CaseClausesOpt { $1->SetNext($2); $$ = $1; }
1280 | DefaultClause CaseClausesOpt { $1->SetNext($2); $$ = $1; }
1285 : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); }
1288 /* 12.12 Labelled Statements {{{ */
1290 : Identifier ":" Statement { $$ = CYNew CYLabel($1, $3); }
1293 /* 12.13 The throw Statement {{{ */
1295 : "throw" LexSetRegExp "\n" StrictSemi { YYABORT; }
1296 | "throw" Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); }
1299 /* 12.14 The try Statement {{{ */
1301 : "try" Block_ CatchOpt FinallyOpt { $$ = CYNew cy::Syntax::Try($2, $3, $4); }
1305 : "catch" "(" Identifier ")" Block_ { $$ = CYNew cy::Syntax::Catch($3, $5); }
1310 : "finally" Block_ { $$ = CYNew CYFinally($2); }
1314 /* 12.14 The debugger Statement {{{ */
1316 : "debugger" Terminator { $$ = CYNew CYDebugger(); }
1320 /* 13.1 Function Definitions {{{ */
1322 : ";function" Identifier "(" FormalParameterListOpt ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); }
1326 : "function" IdentifierOpt "(" LexPushInOff FormalParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); }
1329 FormalParameterList_
1330 : "," FormalParameterList { $$ = $2; }
1335 // XXX: : FunctionRestParameter { $$ = $1; }
1336 : FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); }
1339 FormalParameterListOpt
1340 : FormalParameterList
1344 /* XXX: FunctionRestParameter
1345 : "..." BindingIdentifier { $$ = CYNew CYFunctionRestParameter($2); }
1349 : BindingElement { $$ = $1; }
1353 : StatementListOpt { $$ = $1; }
1356 /* 13.2 Arrow Function Definitions {{{ */
1358 : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); }
1362 : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
1363 //| ParentheticalOpt { $$ = $1; }
1367 : AssignmentExpression { $$ = CYNew CYReturn($1); }
1368 | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; }
1371 /* 14 Program {{{ */
1373 : ProgramBodyOpt { driver.program_ = CYNew CYProgram($1); }
1377 : StatementList { $$ = $1; }
1381 : ProgramBody { $$ = $1; }
1382 | LexSetStatement LexSetRegExp { $$ = NULL; }
1387 /* Cycript (Objective-C): Type Encoding {{{ */
1389 : "(" LexPushInOff PrefixedType ")" LexPopIn { $$ = $3; }
1393 : Identifier { $$ = CYNew CYTypedIdentifier($1); }
1394 | TypeParenthetical { $$ = $1; }
1398 : ArrayedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); }
1399 | TypeSignifier { $$ = $1; }
1400 | { $$ = CYNew CYTypedIdentifier(); }
1404 : "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypeFunctionWith($3); }
1408 : ArrayedType { $$ = $1; }
1409 | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }
1410 | TypeParenthetical FunctionedType { $$ = $1; CYSetLast($2) = $$->modifier_; $$->modifier_ = $2; }
1411 | FunctionedType { $$ = CYNew CYTypedIdentifier(); CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
1415 : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
1419 : "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); }
1420 /* XXX: | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } */
1425 : "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); }
1426 | PrefixedType { $$ = $1; }
1427 | SuffixedType { $$ = $1; }
1431 : Variable { $$ = $1; }
1432 | "void" { $$ = CYNew cy::Syntax::New(CYNew CYVariable(CYNew CYIdentifier("Type")), CYNew CYArgument(CYNew CYString("v"))); }
1436 : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->type_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
1440 : TypedIdentifier { $$ = CYNew CYEncodedType($1); }
1444 : AtEncode "(" EncodedType ")" { $$ = $3; }
1447 /* Cycript (Objective-C): @class Declaration {{{ */
1449 /* XXX: why the hell did I choose MemberExpression? */
1450 : ":" LexSetRegExp MemberExpression { $$ = $3; }
1455 : Expression Identifier ";" ClassFieldListOpt { $$ = CYNew CYField($1, $2, $4); }
1456 | LexSetRegExp { $$ = NULL; }
1460 : BRACE ClassFieldListOpt "}" { $$ = $2; }
1464 : "+" { $$ = false; }
1465 | "-" { $$ = true; }
1469 : "(" LexSetRegExp EncodedType ")" { $$ = $3; }
1474 : Word ":" TypeOpt Identifier { $$ = CYNew CYMessageParameter($1, $3, $4); }
1477 MessageParameterList
1478 : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; }
1481 MessageParameterListOpt
1482 : MessageParameterList { $$ = $1; }
1487 : MessageParameterList { $$ = $1; }
1488 | Word { $$ = CYNew CYMessageParameter($1, NULL, NULL); }
1491 ClassMessageDeclaration
1492 : MessageScope TypeOpt MessageParameters BRACE FunctionBody "}" { $$ = CYNew CYMessage($1, $2, $3, $5); }
1495 ClassMessageDeclarationListOpt
1496 : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; }
1497 | ClassMessageDeclarationListOpt Comment { $$ = $1; }
1502 : Identifier { $$ = $1; }
1503 | "(" AssignmentExpression ")" { $$ = $2; }
1507 : ClassName { $$ = $1; }
1511 // XXX: this should be AssignmentExpressionNoRight
1513 : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); }
1517 : "," ClassProtocols { $$ = $2; }
1521 ClassProtocolListOpt
1522 : "<" ClassProtocols ">" { $$ = $2; }
1527 : "@implementation" LexPushInOff ClassNameOpt ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" LexPopIn { $$ = CYNew CYClassExpression($3, $4, $5, $6, $7); }
1531 : ";@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); }
1539 : ";@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); }
1543 : ClassExpression { $$ = $1; }
1547 : ClassStatement { $$ = $1; }
1548 | CategoryStatement { $$ = $1; }
1551 /* Cycript (Objective-C): Send Message {{{ */
1553 : "," AssignmentExpression VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); }
1558 : WordOpt { driver.contexts_.back().words_.push_back($1); } { $$ = $1; }
1559 | AutoComplete { driver.mode_ = CYDriver::AutoMessage; YYACCEPT; }
1563 : SelectorCall { $$ = $1; }
1564 | VariadicCall { $$ = $1; }
1568 : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYBlank(), $3, $4); }
1572 : SelectorCall { $$ = $1; }
1573 | Word { $$ = CYNew CYArgument($1, NULL); }
1577 : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); }
1578 | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); }
1582 : WordOpt ":" SelectorExpressionOpt { $$ = CYNew CYSelectorPart($1, true, $3); }
1586 : SelectorExpression_ { $$ = $1; }
1587 | Word { $$ = CYNew CYSelectorPart($1, false, NULL); }
1590 SelectorExpressionOpt
1591 : SelectorExpression_ { $$ = $1; }
1596 : MessageExpression { $$ = $1; }
1597 | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); }
1600 /* Cycript (Objective-C): @import Directive {{{ */
1602 : Module "." Word { $$ = CYNew CYModule($3, $1); }
1603 | Word { $$ = CYNew CYModule($1); }
1607 : "@import" Module { $$ = CYNew CYImport($2); }
1610 /* Cycript (Objective-C): Boxed Expressions {{{ */
1612 : NullLiteral { $$ = $1; }
1613 | BooleanLiteral { $$ = $1; }
1614 | NumericLiteral { $$ = $1; }
1615 | StringLiteral { $$ = $1; }
1616 | ArrayLiteral { $$ = $1; }
1617 | ObjectLiteral { $$ = $1; }
1618 | Parenthetical { $$ = $1; }
1619 | "YES" { $$ = CYNew CYTrue(); }
1620 | "NO" { $$ = CYNew CYFalse(); }
1624 : "@" BoxableExpression { $$ = CYNew CYBox($2); }
1627 /* Cycript (Objective-C): Block Expressions {{{ */
1629 : TypeQualifierLeft PrimitiveType { $$ = CYNew CYTypedIdentifier(); $$->type_ = $2; $$->modifier_ = $1; }
1630 | ModifiedType "*" { $$ = $1; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); }
1634 : "^" ModifiedType "(" LexPushInOff TypedParameterListOpt ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYObjCBlock($2, $5, $10); }
1640 /* Cycript (C): Pointer Indirection/Addressing {{{ */
1641 LeftHandSideExpression
1642 : LexSetRegExp "*" UnaryExpression { $$ = CYNew CYIndirect($3); }
1646 : "&" UnaryExpression { $$ = CYNew CYAddressOf($2); }
1650 : "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); }
1651 | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); }
1652 | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; }
1655 /* Cycript (C): auto Compatibility {{{ */
1660 /* Cycript (C): Lambda Expressions {{{ */
1662 : "," TypedParameterList { $$ = $2; }
1667 : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); }
1670 TypedParameterListOpt
1671 : TypedParameterList { $$ = $1; }
1676 : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); }
1679 /* Cycript (C): Type Definitions {{{ */
1681 : "typedef" TypedIdentifier Terminator { $$ = CYNew CYTypeDefinition($2); }
1686 /* YUI: Documentation Comments {{{ */
1688 : Comment { $$ = $1; }
1693 /* Lexer State {{{ */
1695 : { driver.PushCondition(CYDriver::RegExpCondition); }
1699 : { driver.PushCondition(CYDriver::XMLContentCondition); }
1703 : { driver.PushCondition(CYDriver::XMLTagCondition); }
1707 : { driver.PopCondition(); }
1711 : { driver.SetCondition(CYDriver::XMLContentCondition); }
1715 : { driver.SetCondition(CYDriver::XMLTagCondition); }
1718 /* Virtual Tokens {{{ */
1725 /* 8.1 Context Keywords {{{ */
1727 : "namespace" { $$ = $1; }
1728 | "xml" { $$ = $1; }
1731 /* 8.3 XML Initialiser Input Elements {{{ */
1733 : XMLComment { $$ = $1; }
1734 | XMLCDATA { $$ = $1; }
1735 | XMLPI { $$ = $1; }
1739 /* 11.1 Primary Expressions {{{ */
1741 : PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); }
1742 | XMLInitialiser { $$ = $1; }
1743 | XMLListInitialiser { $$ = $1; }
1747 : AttributeIdentifier { $$ = $1; }
1748 | QualifiedIdentifier { $$ = $1; }
1749 | WildcardIdentifier { $$ = $1; }
1752 /* 11.1.1 Attribute Identifiers {{{ */
1754 : "@" QualifiedIdentifier_ { $$ = CYNew CYAttribute($2); }
1758 : PropertySelector { $$ = $1; }
1759 | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); }
1763 : Identifier { $$ = CYNew CYSelector($1); }
1764 | WildcardIdentifier { $$ = $1; }
1767 /* 11.1.2 Qualified Identifiers {{{ */
1768 QualifiedIdentifier_
1769 : PropertySelector_ { $$ = CYNew CYQualified(NULL, $1); }
1770 | QualifiedIdentifier { $$ = $1; }
1774 : PropertySelector "::" PropertySelector_ { $$ = CYNew CYQualified($1, $3); }
1777 /* 11.1.3 Wildcard Identifiers {{{ */
1779 : "*" { $$ = CYNew CYWildcard(); }
1782 /* 11.1.4 XML Initialiser {{{ */
1784 : XMLMarkup { $$ = $1; }
1785 | XMLElement { $$ = $1; }
1789 : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn
1790 | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop ">" LexPopIn
1794 : LexPushXMLTag XMLTagName XMLAttributes
1798 : BRACE LexPushRegExp Expression LexPop "}"
1807 : XMLAttributes_ XMLAttribute
1812 : XMLAttributes_ XMLWhitespace XMLExpression XMLWhitespaceOpt
1813 | XMLAttributes_ XMLWhitespaceOpt
1822 : XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt XMLAttributeValue_
1826 : XMLExpression XMLElementContentOpt
1827 | XMLMarkup XMLElementContentOpt
1828 | XMLText XMLElementContentOpt
1829 | XMLElement XMLElementContentOpt
1832 XMLElementContentOpt
1837 /* 11.1.5 XMLList Initialiser {{{ */
1839 : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "</>" LexPopIn { $$ = CYNew CYXMLList($4); }
1843 /* 11.2 Left-Hand-Side Expressions {{{ */
1845 : Identifier { $$ = $1; }
1846 | PropertyIdentifier { $$ = $1; }
1850 : "." PropertyIdentifier { $$ = CYNew CYPropertyMember(NULL, $2); }
1851 | ".." PropertyIdentifier_ { $$ = CYNew CYDescendantMember(NULL, $2); }
1852 | "." "(" Expression ")" { $$ = CYNew CYFilteringPredicate(NULL, $3); }
1855 /* 12.1 The default xml namespace Statement {{{ */
1856 /* XXX: DefaultXMLNamespaceStatement
1857 : "default" "xml" "namespace" "=" Expression Terminator { $$ = CYNew CYDefaultXMLNamespace($5); }
1861 : DefaultXMLNamespaceStatement { $$ = $1; }
1866 /* JavaScript 1.7: Array Comprehensions {{{ */
1868 : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); }
1872 : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); }
1873 | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); }
1876 /* JavaScript 1.7: for each {{{ */
1878 : "for" "each" "(" LexPushInOn ForInStatementInitialiser "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); }
1881 /* JavaScript 1.7: let Statements {{{ */
1883 : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); }
1891 /* JavaScript FTW: Ruby Blocks {{{ */
1892 RubyProcParameterList_
1893 : "," RubyProcParameterList { $$ = $2; }
1897 RubyProcParameterList
1898 : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); }
1903 : "|" RubyProcParameterList "|" { $$ = $2; }
1904 | "||" { $$ = NULL; }
1907 RubyProcParametersOpt
1908 : RubyProcParameters
1913 : "{" RubyProcParametersOpt StatementListOpt "}" { $$ = CYNew CYRubyProc($2, $3); }
1917 : "{" LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); }
1921 : CallExpression_ RubyProcExpression { $$ = CYNew CYRubyBlock($1, $2); }