Parser.hpp

   1 /* Cycript - Remove Execution Server and Disassembler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #ifndef CYPARSER_HPP
  41 #define CYPARSER_HPP
  42
  43 #include <cstdlib>
  44 #include <string>
  45 #include <vector>
  46
  47 #include "location.hh"
  48 #include "Pooling.hpp"
  49
  50 template <typename Type_>
  51 struct CYNext {
  52     Type_ *next_;
  53
  54     CYNext() :
  55         next_(NULL)
  56     {
  57     }
  58
  59     CYNext(Type_ *next) :
  60         next_(next)
  61     {
  62     }
  63
  64     void SetNext(Type_ *next) {
  65         next_ = next;
  66     }
  67 };
  68
  69 struct CYThing {
  70     virtual void Output(struct CYOutput &out) const = 0;
  71 };
  72
  73 struct CYOutput {
  74     std::ostream &out_;
  75
  76     CYOutput(std::ostream &out) :
  77         out_(out)
  78     {
  79     }
  80
  81     _finline CYOutput &operator <<(char rhs) {
  82         out_ << rhs;
  83         return *this;
  84     }
  85
  86     _finline CYOutput &operator <<(const char *rhs) {
  87         out_ << rhs;
  88         return *this;
  89     }
  90
  91     _finline CYOutput &operator <<(const CYThing &rhs) {
  92         rhs.Output(*this);
  93         return *this;
  94     }
  95 };
  96
  97 struct CYSource :
  98     CYNext<CYSource>
  99 {
 100     virtual bool IsBlock() const {
 101         return next_ != NULL;
 102     }
 103
 104     virtual void Show(CYOutput &out) const;
 105     virtual void Output(CYOutput &out) const = 0;
 106     virtual void Output(CYOutput &out, bool block) const;
 107     virtual void Output_(CYOutput &out) const;
 108 };
 109
 110 struct CYPropertyName {
 111     virtual void PropertyName(CYOutput &out) const = 0;
 112 };
 113
 114 struct CYClassName {
 115     virtual void ClassName(CYOutput &out, bool object) const = 0;
 116 };
 117
 118 struct CYWord :
 119     CYThing,
 120     CYPropertyName,
 121     CYClassName
 122 {
 123     const char *word_;
 124
 125     CYWord(const char *word) :
 126         word_(word)
 127     {
 128     }
 129
 130     const char *Value() const {
 131         return word_;
 132     }
 133
 134     virtual void Output(CYOutput &out) const;
 135
 136     virtual void ClassName(CYOutput &out, bool object) const;
 137     virtual void PropertyName(CYOutput &out) const;
 138 };
 139
 140 _finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) {
 141     return lhs << rhs.Value();
 142 }
 143
 144 struct CYIdentifier :
 145     CYWord
 146 {
 147     CYIdentifier(const char *word) :
 148         CYWord(word)
 149     {
 150     }
 151 };
 152
 153 struct CYLabel :
 154     CYNext<CYLabel>
 155 {
 156     CYIdentifier *name_;
 157
 158     CYLabel(CYIdentifier *name, CYLabel *next) :
 159         CYNext<CYLabel>(next),
 160         name_(name)
 161     {
 162     }
 163 };
 164
 165 struct CYStatement :
 166     CYSource
 167 {
 168     CYLabel *labels_;
 169
 170     CYStatement() :
 171         labels_(NULL)
 172     {
 173     }
 174
 175     void AddLabel(CYIdentifier *identifier) {
 176         labels_ = new CYLabel(identifier, labels_);
 177     }
 178
 179     virtual void Output_(CYOutput &out) const;
 180 };
 181
 182 struct CYBlock :
 183     CYStatement
 184 {
 185     CYStatement *statements_;
 186
 187     CYBlock(CYStatement *statements) :
 188         statements_(statements)
 189     {
 190     }
 191
 192     virtual bool IsBlock() const {
 193         return true;
 194     }
 195
 196     virtual void Output(CYOutput &out) const;
 197 };
 198
 199 enum CYState {
 200     CYClear,
 201     CYRestricted,
 202     CYNewLine
 203 };
 204
 205 class CYDriver {
 206   public:
 207     CYPool pool_;
 208
 209     CYState state_;
 210     void *scanner_;
 211
 212     const char *data_;
 213     size_t size_;
 214     FILE *file_;
 215
 216     std::string filename_;
 217
 218     struct Error {
 219         cy::location location_;
 220         std::string message_;
 221     };
 222
 223     typedef std::vector<Error> Errors;
 224
 225     CYSource *source_;
 226     Errors errors_;
 227
 228   private:
 229     void ScannerInit();
 230     void ScannerDestroy();
 231
 232   public:
 233     CYDriver(const std::string &filename);
 234     ~CYDriver();
 235 };
 236
 237 enum CYFlags {
 238     CYNoFlags =    0,
 239     CYNoBrace =    (1 << 0),
 240     CYNoFunction = (1 << 1),
 241     CYNoLeader =   (1 << 2),
 242     CYNoTrailer =  (1 << 3),
 243     CYNoIn =       (1 << 4),
 244     CYNoHyphen =   (1 << 5),
 245     CYNoBF =       (CYNoBrace | CYNoFunction),
 246 };
 247
 248 struct CYForInitialiser {
 249     virtual void For(CYOutput &out) const = 0;
 250 };
 251
 252 struct CYForInInitialiser {
 253     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
 254     virtual const char *ForEachIn() const = 0;
 255     virtual void ForEachIn(CYOutput &out) const = 0;
 256 };
 257
 258 struct CYExpression :
 259     CYNext<CYExpression>,
 260     CYForInitialiser,
 261     CYForInInitialiser,
 262     CYClassName
 263 {
 264     virtual unsigned Precedence() const = 0;
 265
 266     virtual void For(CYOutput &out) const;
 267     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 268
 269     virtual const char *ForEachIn() const;
 270     virtual void ForEachIn(CYOutput &out) const;
 271
 272     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 273     void Output(CYOutput &out, unsigned precedence, CYFlags flags) const;
 274
 275     virtual void ClassName(CYOutput &out, bool object) const;
 276
 277     virtual const char *Word() const {
 278         return NULL;
 279     }
 280 };
 281
 282 #define CYAlphabetic(value) \
 283     virtual bool Alphabetic() const { \
 284         return value; \
 285     }
 286
 287 #define CYPrecedence(value) \
 288     virtual unsigned Precedence() const { \
 289         return value; \
 290     }
 291
 292 struct CYCompound :
 293     CYExpression
 294 {
 295     CYExpression *expressions_;
 296
 297     CYCompound(CYExpression *expressions) :
 298         expressions_(expressions)
 299     {
 300     }
 301
 302     void AddPrev(CYExpression *expression) {
 303         CYExpression *last(expression);
 304         while (last->next_ != NULL)
 305             last = last->next_;
 306         last->SetNext(expressions_);
 307         expressions_ = expression;
 308     }
 309
 310     CYPrecedence(17)
 311
 312     void Output(CYOutput &out, CYFlags flags) const;
 313 };
 314
 315 struct CYComprehension :
 316     CYNext<CYComprehension>
 317 {
 318     void Output(CYOutput &out) const;
 319     virtual const char *Name() const = 0;
 320
 321     virtual void Begin_(CYOutput &out) const = 0;
 322
 323     virtual void End_(CYOutput &out) const {
 324     }
 325 };
 326
 327 struct CYForInComprehension :
 328     CYComprehension
 329 {
 330     CYIdentifier *name_;
 331     CYExpression *set_;
 332
 333     CYForInComprehension(CYIdentifier *name, CYExpression *set) :
 334         name_(name),
 335         set_(set)
 336     {
 337     }
 338
 339     virtual const char *Name() const {
 340         return name_->Value();
 341     }
 342
 343     virtual void Begin_(CYOutput &out) const;
 344 };
 345
 346 struct CYForEachInComprehension :
 347     CYComprehension
 348 {
 349     CYIdentifier *name_;
 350     CYExpression *set_;
 351
 352     CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
 353         name_(name),
 354         set_(set)
 355     {
 356     }
 357
 358     virtual const char *Name() const {
 359         return name_->Value();
 360     }
 361
 362     virtual void Begin_(CYOutput &out) const;
 363     virtual void End_(CYOutput &out) const;
 364 };
 365
 366 struct CYIfComprehension :
 367     CYComprehension
 368 {
 369     CYExpression *test_;
 370
 371     CYIfComprehension(CYExpression *test) :
 372         test_(test)
 373     {
 374     }
 375
 376     virtual const char *Name() const {
 377         return NULL;
 378     }
 379
 380     virtual void Begin_(CYOutput &out) const;
 381 };
 382
 383 struct CYArrayComprehension :
 384     CYExpression
 385 {
 386     CYExpression *expression_;
 387     CYComprehension *comprehensions_;
 388
 389     CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
 390         expression_(expression),
 391         comprehensions_(comprehensions)
 392     {
 393     }
 394
 395     CYPrecedence(0)
 396
 397     virtual void Output(CYOutput &out, CYFlags flags) const;
 398 };
 399
 400 struct CYLiteral :
 401     CYExpression
 402 {
 403     CYPrecedence(0)
 404 };
 405
 406 struct CYMagic :
 407     CYExpression
 408 {
 409     CYPrecedence(0)
 410 };
 411
 412 struct CYSelectorPart :
 413     CYNext<CYSelectorPart>
 414 {
 415     CYWord *name_;
 416     bool value_;
 417
 418     CYSelectorPart(CYWord *name, bool value, CYSelectorPart *next) :
 419         CYNext<CYSelectorPart>(next),
 420         name_(name),
 421         value_(value)
 422     {
 423     }
 424
 425     virtual void Output(CYOutput &out) const;
 426 };
 427
 428 struct CYSelector :
 429     CYLiteral
 430 {
 431     CYSelectorPart *name_;
 432
 433     CYSelector(CYSelectorPart *name) :
 434         name_(name)
 435     {
 436     }
 437
 438     CYPrecedence(1)
 439
 440     virtual void Output(CYOutput &out, CYFlags flags) const;
 441 };
 442
 443 struct CYRange {
 444     uint64_t lo_;
 445     uint64_t hi_;
 446
 447     CYRange(uint64_t lo, uint64_t hi) :
 448         lo_(lo), hi_(hi)
 449     {
 450     }
 451
 452     bool operator [](uint8_t value) const {
 453         return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1;
 454     }
 455
 456     void operator()(uint8_t value) {
 457         if (value >> 7)
 458             return;
 459         (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f);
 460     }
 461 };
 462
 463 extern CYRange DigitRange_;
 464 extern CYRange WordStartRange_;
 465 extern CYRange WordEndRange_;
 466
 467 struct CYString :
 468     CYLiteral,
 469     CYPropertyName
 470 {
 471     const char *value_;
 472     size_t size_;
 473
 474     CYString(const char *value, size_t size) :
 475         value_(value),
 476         size_(size)
 477     {
 478     }
 479
 480     CYString(const CYIdentifier *identifier) :
 481         value_(identifier->Value()),
 482         size_(strlen(value_))
 483     {
 484     }
 485
 486     const char *Value() const {
 487         return value_;
 488     }
 489
 490     virtual const char *Word() const {
 491         if (size_ == 0 || !WordStartRange_[value_[0]])
 492             return NULL;
 493         for (size_t i(1); i != size_; ++i)
 494             if (!WordEndRange_[value_[i]])
 495                 return NULL;
 496         return Value();
 497     }
 498
 499     virtual void Output(CYOutput &out) const {
 500         return Output(out, CYNoFlags);
 501     }
 502
 503     virtual void Output(CYOutput &out, CYFlags flags) const;
 504     virtual void PropertyName(CYOutput &out) const;
 505 };
 506
 507 struct CYNumber :
 508     CYLiteral,
 509     CYPropertyName
 510 {
 511     double value_;
 512
 513     CYNumber(double value) :
 514         value_(value)
 515     {
 516     }
 517
 518     double Value() const {
 519         return value_;
 520     }
 521
 522     virtual void Output(CYOutput &out) const {
 523         return Output(out, CYNoFlags);
 524     }
 525
 526     virtual void Output(CYOutput &out, CYFlags flags) const;
 527     virtual void PropertyName(CYOutput &out) const;
 528 };
 529
 530 struct CYNull :
 531     CYWord,
 532     CYLiteral
 533 {
 534     CYNull() :
 535         CYWord("null")
 536     {
 537     }
 538
 539     virtual void Output(CYOutput &out, CYFlags flags) const;
 540 };
 541
 542 struct CYThis :
 543     CYWord,
 544     CYMagic
 545 {
 546     CYThis() :
 547         CYWord("this")
 548     {
 549     }
 550
 551     virtual void Output(CYOutput &out, CYFlags flags) const;
 552 };
 553
 554 struct CYBoolean :
 555     CYLiteral
 556 {
 557     virtual bool Value() const = 0;
 558     virtual void Output(CYOutput &out, CYFlags flags) const;
 559 };
 560
 561 struct CYFalse :
 562     CYWord,
 563     CYBoolean
 564 {
 565     CYFalse() :
 566         CYWord("false")
 567     {
 568     }
 569
 570     virtual bool Value() const;
 571 };
 572
 573 struct CYTrue :
 574     CYWord,
 575     CYBoolean
 576 {
 577     CYTrue() :
 578         CYWord("true")
 579     {
 580     }
 581
 582     virtual bool Value() const;
 583 };
 584
 585 struct CYVariable :
 586     CYExpression
 587 {
 588     CYIdentifier *name_;
 589
 590     CYVariable(CYIdentifier *name) :
 591         name_(name)
 592     {
 593     }
 594
 595     CYPrecedence(0)
 596
 597     virtual void Output(CYOutput &out, CYFlags flags) const;
 598 };
 599
 600 struct CYPrefix :
 601     CYExpression
 602 {
 603     CYExpression *rhs_;
 604
 605     CYPrefix(CYExpression *rhs) :
 606         rhs_(rhs)
 607     {
 608     }
 609
 610     virtual bool Alphabetic() const = 0;
 611     virtual const char *Operator() const = 0;
 612
 613     virtual void Output(CYOutput &out, CYFlags flags) const;
 614 };
 615
 616 struct CYInfix :
 617     CYExpression
 618 {
 619     CYExpression *lhs_;
 620     CYExpression *rhs_;
 621
 622     CYInfix(CYExpression *lhs, CYExpression *rhs) :
 623         lhs_(lhs),
 624         rhs_(rhs)
 625     {
 626     }
 627
 628     void SetLeft(CYExpression *lhs) {
 629         lhs_ = lhs;
 630     }
 631
 632     virtual bool Alphabetic() const = 0;
 633     virtual const char *Operator() const = 0;
 634
 635     virtual void Output(CYOutput &out, CYFlags flags) const;
 636 };
 637
 638 struct CYPostfix :
 639     CYExpression
 640 {
 641     CYExpression *lhs_;
 642
 643     CYPostfix(CYExpression *lhs) :
 644         lhs_(lhs)
 645     {
 646     }
 647
 648     virtual const char *Operator() const = 0;
 649
 650     virtual void Output(CYOutput &out, CYFlags flags) const;
 651 };
 652
 653 struct CYAssignment :
 654     CYExpression
 655 {
 656     CYExpression *lhs_;
 657     CYExpression *rhs_;
 658
 659     CYAssignment(CYExpression *lhs, CYExpression *rhs) :
 660         lhs_(lhs),
 661         rhs_(rhs)
 662     {
 663     }
 664
 665     void SetLeft(CYExpression *lhs) {
 666         lhs_ = lhs;
 667     }
 668
 669     virtual const char *Operator() const = 0;
 670
 671     virtual void Output(CYOutput &out, CYFlags flags) const;
 672 };
 673
 674 struct CYArgument :
 675     CYNext<CYArgument>
 676 {
 677     CYWord *name_;
 678     CYExpression *value_;
 679
 680     CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
 681         CYNext<CYArgument>(next),
 682         name_(name),
 683         value_(value)
 684     {
 685     }
 686
 687     void Output(CYOutput &out) const;
 688 };
 689
 690 struct CYBlank :
 691     public CYWord
 692 {
 693     CYBlank() :
 694         CYWord("")
 695     {
 696     }
 697 };
 698
 699 struct CYClause :
 700     CYThing,
 701     CYNext<CYClause>
 702 {
 703     CYExpression *case_;
 704     CYStatement *code_;
 705
 706     CYClause(CYExpression *_case, CYStatement *code) :
 707         case_(_case),
 708         code_(code)
 709     {
 710     }
 711
 712     virtual void Output(CYOutput &out) const;
 713 };
 714
 715 struct CYElement :
 716     CYNext<CYElement>
 717 {
 718     CYExpression *value_;
 719
 720     CYElement(CYExpression *value, CYElement *next) :
 721         CYNext<CYElement>(next),
 722         value_(value)
 723     {
 724     }
 725
 726     void Output(CYOutput &out) const;
 727 };
 728
 729 struct CYArray :
 730     CYLiteral
 731 {
 732     CYElement *elements_;
 733
 734     CYArray(CYElement *elements) :
 735         elements_(elements)
 736     {
 737     }
 738
 739     virtual void Output(CYOutput &out, CYFlags flags) const;
 740 };
 741
 742 struct CYDeclaration :
 743     CYForInInitialiser
 744 {
 745     CYIdentifier *identifier_;
 746     CYExpression *initialiser_;
 747
 748     CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser) :
 749         identifier_(identifier),
 750         initialiser_(initialiser)
 751     {
 752     }
 753
 754     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 755
 756     virtual const char *ForEachIn() const;
 757     virtual void ForEachIn(CYOutput &out) const;
 758
 759     virtual void Output(CYOutput &out, CYFlags flags) const;
 760 };
 761
 762 struct CYDeclarations :
 763     CYNext<CYDeclarations>,
 764     CYForInitialiser
 765 {
 766     CYDeclaration *declaration_;
 767
 768     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) :
 769         CYNext<CYDeclarations>(next),
 770         declaration_(declaration)
 771     {
 772     }
 773
 774     virtual void For(CYOutput &out) const;
 775     virtual void Output(CYOutput &out, CYFlags flags) const;
 776 };
 777
 778 struct CYVar :
 779     CYStatement
 780 {
 781     CYDeclarations *declarations_;
 782
 783     CYVar(CYDeclarations *declarations) :
 784         declarations_(declarations)
 785     {
 786     }
 787
 788     virtual void Output(CYOutput &out) const;
 789 };
 790
 791 struct CYLet :
 792     CYStatement
 793 {
 794     CYDeclarations *declarations_;
 795     CYStatement *statements_;
 796
 797     CYLet(CYDeclarations *declarations, CYStatement *statements) :
 798         declarations_(declarations),
 799         statements_(statements)
 800     {
 801     }
 802
 803     virtual void Output(CYOutput &out) const;
 804 };
 805
 806 struct CYField :
 807     CYNext<CYField>
 808 {
 809     virtual void Output(CYOutput &out) const;
 810 };
 811
 812 struct CYMessageParameter :
 813     CYNext<CYMessageParameter>
 814 {
 815     CYWord *tag_;
 816     CYExpression *type_;
 817     CYIdentifier *name_;
 818
 819     CYMessageParameter(CYWord *tag, CYExpression *type, CYIdentifier *name) :
 820         tag_(tag),
 821         type_(type),
 822         name_(name)
 823     {
 824     }
 825 };
 826
 827 struct CYMessage :
 828     CYNext<CYMessage>
 829 {
 830     bool instance_;
 831     CYExpression *type_;
 832     CYMessageParameter *parameter_;
 833     CYSource *body_;
 834
 835     CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYSource *body) :
 836         instance_(instance),
 837         type_(type),
 838         parameter_(parameter),
 839         body_(body)
 840     {
 841     }
 842
 843     virtual void Output(CYOutput &out, bool replace) const;
 844 };
 845
 846 struct CYClass :
 847     CYExpression,
 848     CYStatement
 849 {
 850     CYClassName *name_;
 851     CYExpression *super_;
 852     CYField *fields_;
 853     CYMessage *messages_;
 854
 855     CYClass(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) :
 856         name_(name),
 857         super_(super),
 858         fields_(fields),
 859         messages_(messages)
 860     {
 861     }
 862
 863     CYPrecedence(0)
 864
 865     virtual void Output(CYOutput &out) const;
 866     virtual void Output(CYOutput &out, CYFlags flags) const;
 867 };
 868
 869 struct CYCategory :
 870     CYStatement
 871 {
 872     CYClassName *name_;
 873     CYMessage *messages_;
 874
 875     CYCategory(CYClassName *name, CYMessage *messages) :
 876         name_(name),
 877         messages_(messages)
 878     {
 879     }
 880
 881     virtual void Output(CYOutput &out) const;
 882 };
 883
 884 struct CYFunctionParameter :
 885     CYNext<CYFunctionParameter>,
 886     CYThing
 887 {
 888     CYIdentifier *name_;
 889
 890     CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next) :
 891         CYNext<CYFunctionParameter>(next),
 892         name_(name)
 893     {
 894     }
 895
 896     virtual void Output(CYOutput &out) const;
 897 };
 898
 899 struct CYFor :
 900     CYStatement
 901 {
 902     CYForInitialiser *initialiser_;
 903     CYExpression *test_;
 904     CYExpression *increment_;
 905     CYStatement *code_;
 906
 907     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
 908         initialiser_(initialiser),
 909         test_(test),
 910         increment_(increment),
 911         code_(code)
 912     {
 913     }
 914
 915     virtual void Output(CYOutput &out) const;
 916 };
 917
 918 struct CYForIn :
 919     CYStatement
 920 {
 921     CYForInInitialiser *initialiser_;
 922     CYExpression *set_;
 923     CYStatement *code_;
 924
 925     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
 926         initialiser_(initialiser),
 927         set_(set),
 928         code_(code)
 929     {
 930     }
 931
 932     virtual void Output(CYOutput &out) const;
 933 };
 934
 935 struct CYForEachIn :
 936     CYStatement
 937 {
 938     CYForInInitialiser *initialiser_;
 939     CYExpression *set_;
 940     CYStatement *code_;
 941
 942     CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
 943         initialiser_(initialiser),
 944         set_(set),
 945         code_(code)
 946     {
 947     }
 948
 949     virtual void Output(CYOutput &out) const;
 950 };
 951
 952 struct CYProperty :
 953     CYNext<CYProperty>
 954 {
 955     CYPropertyName *name_;
 956     CYExpression *value_;
 957
 958     CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next) :
 959         CYNext<CYProperty>(next),
 960         name_(name),
 961         value_(value)
 962     {
 963     }
 964
 965     virtual void Output(CYOutput &out) const;
 966 };
 967
 968 struct CYObject :
 969     CYLiteral
 970 {
 971     CYProperty *property_;
 972
 973     CYObject(CYProperty *property) :
 974         property_(property)
 975     {
 976     }
 977
 978     void Output(CYOutput &out, CYFlags flags) const;
 979 };
 980
 981 struct CYCatch :
 982     CYThing
 983 {
 984     CYIdentifier *name_;
 985     CYStatement *code_;
 986
 987     CYCatch(CYIdentifier *name, CYStatement *code) :
 988         name_(name),
 989         code_(code)
 990     {
 991     }
 992
 993     virtual void Output(CYOutput &out) const;
 994 };
 995
 996 struct CYSend :
 997     CYExpression
 998 {
 999     CYExpression *self_;
1000     CYArgument *arguments_;
1001
1002     CYSend(CYExpression *self, CYArgument *arguments) :
1003         self_(self),
1004         arguments_(arguments)
1005     {
1006     }
1007
1008     CYPrecedence(0)
1009
1010     virtual void Output(CYOutput &out, CYFlags flags) const;
1011 };
1012
1013 struct CYMember :
1014     CYExpression
1015 {
1016     CYExpression *object_;
1017     CYExpression *property_;
1018
1019     CYMember(CYExpression *object, CYExpression *property) :
1020         object_(object),
1021         property_(property)
1022     {
1023     }
1024
1025     void SetLeft(CYExpression *object) {
1026         object_ = object;
1027     }
1028 };
1029
1030 struct CYDirectMember :
1031     CYMember
1032 {
1033     CYDirectMember(CYExpression *object, CYExpression *property) :
1034         CYMember(object, property)
1035     {
1036     }
1037
1038     CYPrecedence(1)
1039
1040     virtual void Output(CYOutput &out, CYFlags flags) const;
1041 };
1042
1043 struct CYIndirectMember :
1044     CYMember
1045 {
1046     CYIndirectMember(CYExpression *object, CYExpression *property) :
1047         CYMember(object, property)
1048     {
1049     }
1050
1051     CYPrecedence(1)
1052
1053     virtual void Output(CYOutput &out, CYFlags flags) const;
1054 };
1055
1056 struct CYNew :
1057     CYExpression
1058 {
1059     CYExpression *constructor_;
1060     CYArgument *arguments_;
1061
1062     CYNew(CYExpression *constructor, CYArgument *arguments) :
1063         constructor_(constructor),
1064         arguments_(arguments)
1065     {
1066     }
1067
1068     CYPrecedence(1)
1069
1070     virtual void Output(CYOutput &out, CYFlags flags) const;
1071 };
1072
1073 struct CYCall :
1074     CYExpression
1075 {
1076     CYExpression *function_;
1077     CYArgument *arguments_;
1078
1079     CYCall(CYExpression *function, CYArgument *arguments) :
1080         function_(function),
1081         arguments_(arguments)
1082     {
1083     }
1084
1085     CYPrecedence(2)
1086
1087     virtual void Output(CYOutput &out, CYFlags flags) const;
1088 };
1089
1090 struct CYIf :
1091     CYStatement
1092 {
1093     CYExpression *test_;
1094     CYStatement *true_;
1095     CYStatement *false_;
1096
1097     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false) :
1098         test_(test),
1099         true_(_true),
1100         false_(_false)
1101     {
1102     }
1103
1104     virtual void Output(CYOutput &out) const;
1105 };
1106
1107 struct CYDoWhile :
1108     CYStatement
1109 {
1110     CYExpression *test_;
1111     CYStatement *code_;
1112
1113     CYDoWhile(CYExpression *test, CYStatement *code) :
1114         test_(test),
1115         code_(code)
1116     {
1117     }
1118
1119     virtual void Output(CYOutput &out) const;
1120 };
1121
1122 struct CYWhile :
1123     CYStatement
1124 {
1125     CYExpression *test_;
1126     CYStatement *code_;
1127
1128     CYWhile(CYExpression *test, CYStatement *code) :
1129         test_(test),
1130         code_(code)
1131     {
1132     }
1133
1134     virtual void Output(CYOutput &out) const;
1135 };
1136
1137 struct CYLambda :
1138     CYExpression
1139 {
1140     CYIdentifier *name_;
1141     CYFunctionParameter *parameters_;
1142     CYSource *body_;
1143
1144     CYLambda(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) :
1145         name_(name),
1146         parameters_(parameters),
1147         body_(body)
1148     {
1149     }
1150
1151     CYPrecedence(0)
1152
1153     virtual void Output(CYOutput &out, CYFlags flags) const;
1154 };
1155
1156 struct CYFunction :
1157     CYLambda,
1158     CYSource
1159 {
1160     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) :
1161         CYLambda(name, parameters, body)
1162     {
1163     }
1164
1165     virtual void Output(CYOutput &out) const;
1166 };
1167
1168 struct CYExpress :
1169     CYStatement
1170 {
1171     CYExpression *expression_;
1172
1173     CYExpress(CYExpression *expression) :
1174         expression_(expression)
1175     {
1176     }
1177
1178     virtual void Output(CYOutput &out) const;
1179 };
1180
1181 struct CYContinue :
1182     CYStatement
1183 {
1184     CYIdentifier *label_;
1185
1186     CYContinue(CYIdentifier *label) :
1187         label_(label)
1188     {
1189     }
1190
1191     virtual void Output(CYOutput &out) const;
1192 };
1193
1194 struct CYBreak :
1195     CYStatement
1196 {
1197     CYIdentifier *label_;
1198
1199     CYBreak(CYIdentifier *label) :
1200         label_(label)
1201     {
1202     }
1203
1204     virtual void Output(CYOutput &out) const;
1205 };
1206
1207 struct CYReturn :
1208     CYStatement
1209 {
1210     CYExpression *value_;
1211
1212     CYReturn(CYExpression *value) :
1213         value_(value)
1214     {
1215     }
1216
1217     virtual void Output(CYOutput &out) const;
1218 };
1219
1220 struct CYEmpty :
1221     CYStatement
1222 {
1223     virtual void Output(CYOutput &out) const;
1224     virtual void Output(CYOutput &out, bool block) const;
1225 };
1226
1227 struct CYTry :
1228     CYStatement
1229 {
1230     CYStatement *try_;
1231     CYCatch *catch_;
1232     CYStatement *finally_;
1233
1234     CYTry(CYStatement *_try, CYCatch *_catch, CYStatement *finally) :
1235         try_(_try),
1236         catch_(_catch),
1237         finally_(finally)
1238     {
1239     }
1240
1241     virtual void Output(CYOutput &out) const;
1242 };
1243
1244 struct CYThrow :
1245     CYStatement
1246 {
1247     CYExpression *value_;
1248
1249     CYThrow(CYExpression *value) :
1250         value_(value)
1251     {
1252     }
1253
1254     virtual void Output(CYOutput &out) const;
1255 };
1256
1257 struct CYWith :
1258     CYStatement
1259 {
1260     CYExpression *scope_;
1261     CYStatement *code_;
1262
1263     CYWith(CYExpression *scope, CYStatement *code) :
1264         scope_(scope),
1265         code_(code)
1266     {
1267     }
1268
1269     virtual void Output(CYOutput &out) const;
1270 };
1271
1272 struct CYSwitch :
1273     CYStatement
1274 {
1275     CYExpression *value_;
1276     CYClause *clauses_;
1277
1278     CYSwitch(CYExpression *value, CYClause *clauses) :
1279         value_(value),
1280         clauses_(clauses)
1281     {
1282     }
1283
1284     virtual void Output(CYOutput &out) const;
1285 };
1286
1287 struct CYCondition :
1288     CYExpression
1289 {
1290     CYExpression *test_;
1291     CYExpression *true_;
1292     CYExpression *false_;
1293
1294     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1295         test_(test),
1296         true_(_true),
1297         false_(_false)
1298     {
1299     }
1300
1301     CYPrecedence(15)
1302
1303     virtual void Output(CYOutput &out, CYFlags flags) const;
1304 };
1305
1306 struct CYAddressOf :
1307     CYPrefix
1308 {
1309     CYAddressOf(CYExpression *rhs) :
1310         CYPrefix(rhs)
1311     {
1312     }
1313
1314     virtual const char *Operator() const {
1315         return "&";
1316     }
1317
1318     CYAlphabetic(false)
1319     CYPrecedence(2)
1320
1321     virtual void Output(CYOutput &out, CYFlags flags) const;
1322 };
1323
1324 struct CYIndirect :
1325     CYPrefix
1326 {
1327     CYIndirect(CYExpression *rhs) :
1328         CYPrefix(rhs)
1329     {
1330     }
1331
1332     virtual const char *Operator() const {
1333         return "*";
1334     }
1335
1336     CYAlphabetic(false)
1337     CYPrecedence(1)
1338
1339     virtual void Output(CYOutput &out, CYFlags flags) const;
1340 };
1341
1342 #define CYPostfix_(op, name) \
1343     struct CY ## name : \
1344         CYPostfix \
1345     { \
1346         CY ## name(CYExpression *lhs) : \
1347             CYPostfix(lhs) \
1348         { \
1349         } \
1350     \
1351         CYPrecedence(3) \
1352     \
1353         virtual const char *Operator() const { \
1354             return op; \
1355         } \
1356     };
1357
1358 #define CYPrefix_(alphabetic, op, name) \
1359     struct CY ## name : \
1360         CYPrefix \
1361     { \
1362         CY ## name(CYExpression *rhs) : \
1363             CYPrefix(rhs) \
1364         { \
1365         } \
1366     \
1367         CYAlphabetic(alphabetic) \
1368         CYPrecedence(4) \
1369     \
1370         virtual const char *Operator() const { \
1371             return op; \
1372         } \
1373     };
1374
1375 #define CYInfix_(alphabetic, precedence, op, name) \
1376     struct CY ## name : \
1377         CYInfix \
1378     { \
1379         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
1380             CYInfix(lhs, rhs) \
1381         { \
1382         } \
1383     \
1384         CYAlphabetic(alphabetic) \
1385         CYPrecedence(precedence) \
1386     \
1387         virtual const char *Operator() const { \
1388             return op; \
1389         } \
1390     };
1391
1392 #define CYAssignment_(op, name) \
1393     struct CY ## name ## Assign : \
1394         CYAssignment \
1395     { \
1396         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
1397             CYAssignment(lhs, rhs) \
1398         { \
1399         } \
1400     \
1401         CYPrecedence(16) \
1402     \
1403         virtual const char *Operator() const { \
1404             return op; \
1405         } \
1406     };
1407
1408 CYPostfix_("++", PostIncrement)
1409 CYPostfix_("--", PostDecrement)
1410
1411 CYPrefix_(true, "delete", Delete)
1412 CYPrefix_(true, "void", Void)
1413 CYPrefix_(true, "typeof", TypeOf)
1414 CYPrefix_(false, "++", PreIncrement)
1415 CYPrefix_(false, "--", PreDecrement)
1416 CYPrefix_(false, "-", Negate)
1417 CYPrefix_(false, "~", BitwiseNot)
1418 CYPrefix_(false, "!", LogicalNot)
1419
1420 CYInfix_(false, 5, "*", Multiply)
1421 CYInfix_(false, 5, "/", Divide)
1422 CYInfix_(false, 5, "%", Modulus)
1423 CYInfix_(false, 6, "+", Add)
1424 CYInfix_(false, 6, "-", Subtract)
1425 CYInfix_(false, 7, "<<", ShiftLeft)
1426 CYInfix_(false, 7, ">>", ShiftRightSigned)
1427 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
1428 CYInfix_(false, 8, "<", Less)
1429 CYInfix_(false, 8, ">", Greater)
1430 CYInfix_(false, 8, "<=", LessOrEqual)
1431 CYInfix_(false, 8, ">=", GreaterOrEqual)
1432 CYInfix_(true, 8, "instanceof", InstanceOf)
1433 CYInfix_(true, 8, "in", In)
1434 CYInfix_(false, 9, "==", Equal)
1435 CYInfix_(false, 9, "!=", NotEqual)
1436 CYInfix_(false, 9, "===", Identical)
1437 CYInfix_(false, 9, "!==", NotIdentical)
1438 CYInfix_(false, 10, "&", BitwiseAnd)
1439 CYInfix_(false, 11, "^", BitwiseXOr)
1440 CYInfix_(false, 12, "|", BitwiseOr)
1441 CYInfix_(false, 13, "&&", LogicalAnd)
1442 CYInfix_(false, 14, "||", LogicalOr)
1443
1444 CYAssignment_("=", )
1445 CYAssignment_("*=", Multiply)
1446 CYAssignment_("/=", Divide)
1447 CYAssignment_("%=", Modulus)
1448 CYAssignment_("+=", Add)
1449 CYAssignment_("-=", Subtract)
1450 CYAssignment_("<<=", ShiftLeft)
1451 CYAssignment_(">>=", ShiftRightSigned)
1452 CYAssignment_(">>>=", ShiftRightUnsigned)
1453 CYAssignment_("&=", BitwiseAnd)
1454 CYAssignment_("^=", BitwiseXOr)
1455 CYAssignment_("|=", BitwiseOr)
1456
1457 #endif/*CYPARSER_HPP*/