Parser.hpp

   1 /* Cycript - Error.hppution 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 // XXX: wtf is this here?!
  44 #define CYPA 16
  45
  46 #include <iostream>
  47
  48 #include <string>
  49 #include <vector>
  50
  51 #include <cstdlib>
  52
  53 #include "location.hh"
  54 #include "Pooling.hpp"
  55
  56 template <typename Type_>
  57 struct CYNext {
  58     Type_ *next_;
  59
  60     CYNext() :
  61         next_(NULL)
  62     {
  63     }
  64
  65     CYNext(Type_ *next) :
  66         next_(next)
  67     {
  68     }
  69
  70     void SetNext(Type_ *next) {
  71         next_ = next;
  72     }
  73 };
  74
  75 struct CYThing {
  76     virtual void Output(struct CYOutput &out) const = 0;
  77 };
  78
  79 struct CYOutput {
  80     std::ostream &out_;
  81     bool pretty_;
  82     unsigned indent_;
  83
  84     enum {
  85         NoMode,
  86         NoLetter,
  87         NoPlus,
  88         NoHyphen,
  89         Terminated
  90     } mode_;
  91
  92     CYOutput(std::ostream &out) :
  93         out_(out),
  94         pretty_(false),
  95         indent_(0),
  96         mode_(NoMode)
  97     {
  98     }
  99
 100     void Check(char value);
 101     void Terminate();
 102
 103     CYOutput &operator <<(char rhs);
 104     CYOutput &operator <<(const char *rhs);
 105
 106     _finline CYOutput &operator <<(const CYThing *rhs) {
 107         if (rhs != NULL)
 108             rhs->Output(*this);
 109         return *this;
 110     }
 111
 112     _finline CYOutput &operator <<(const CYThing &rhs) {
 113         rhs.Output(*this);
 114         return *this;
 115     }
 116 };
 117
 118 struct CYPropertyName {
 119     virtual void PropertyName(CYOutput &out) const = 0;
 120 };
 121
 122 struct CYExpression;
 123
 124 enum CYNeeded {
 125     CYNever     = -1,
 126     CYSometimes =  0,
 127     CYAlways    =  1,
 128 };
 129
 130 enum CYFlags {
 131     CYNoFlags =      0,
 132     CYNoBrace =      (1 << 0),
 133     CYNoFunction =   (1 << 1),
 134     CYNoIn =         (1 << 2),
 135     CYNoCall =       (1 << 3),
 136     CYNoRightHand =  (1 << 4),
 137     CYNoDangle =     (1 << 5),
 138     CYNoBF =         (CYNoBrace | CYNoFunction),
 139 };
 140
 141 struct CYContext {
 142     apr_pool_t *pool_;
 143
 144     CYContext(apr_pool_t *pool) :
 145         pool_(pool)
 146     {
 147     }
 148
 149     template <typename Type_>
 150     void Replace(Type_ *&value) {
 151         if (value != NULL)
 152             while (Type_ *replace = value->Replace(*this))
 153                 value = replace;
 154     }
 155 };
 156
 157 struct CYStatement :
 158     CYNext<CYStatement>
 159 {
 160     void Single(CYOutput &out, CYFlags flags) const;
 161     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 162
 163     CYStatement *ReplaceAll(CYContext &context);
 164
 165     virtual CYStatement *Replace(CYContext &context) = 0;
 166
 167   private:
 168     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 169 };
 170
 171 struct CYStatements {
 172     CYStatement *first_;
 173     CYStatement *last_;
 174
 175     CYStatements() :
 176         first_(NULL),
 177         last_(NULL)
 178     {
 179     }
 180
 181     operator CYStatement *() const {
 182         return first_;
 183     }
 184
 185     CYStatements &operator ->*(CYStatement *next) {
 186         if (next != NULL)
 187             if (first_ == NULL) {
 188                 first_ = next;
 189                 last_ = next;
 190             } else for (;; last_ = last_->next_)
 191                 if (last_->next_ == NULL) {
 192                     last_->next_ = next;
 193                     last_ = next;
 194                     break;
 195                 }
 196         return *this;
 197     }
 198 };
 199
 200 struct CYClassName {
 201     virtual CYExpression *ClassName(CYContext &context, bool object) = 0;
 202     virtual void ClassName(CYOutput &out, bool object) const = 0;
 203 };
 204
 205 struct CYWord :
 206     CYThing,
 207     CYPropertyName,
 208     CYClassName
 209 {
 210     const char *word_;
 211
 212     CYWord(const char *word) :
 213         word_(word)
 214     {
 215     }
 216
 217     const char *Value() const {
 218         return word_;
 219     }
 220
 221     virtual void Output(CYOutput &out) const;
 222
 223     virtual CYExpression *ClassName(CYContext &context, bool object);
 224     virtual void ClassName(CYOutput &out, bool object) const;
 225     virtual void PropertyName(CYOutput &out) const;
 226 };
 227
 228 _finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) {
 229     return lhs << rhs.Value();
 230 }
 231
 232 struct CYIdentifier :
 233     CYWord
 234 {
 235     CYIdentifier(const char *word) :
 236         CYWord(word)
 237     {
 238     }
 239 };
 240
 241 struct CYLabel :
 242     CYStatement
 243 {
 244     CYIdentifier *name_;
 245     CYStatement *statement_;
 246
 247     CYLabel(CYIdentifier *name, CYStatement *statement) :
 248         name_(name),
 249         statement_(statement)
 250     {
 251     }
 252
 253     virtual CYStatement *Replace(CYContext &context);
 254     virtual void Output(CYOutput &out, CYFlags flags) const;
 255 };
 256
 257 struct CYProgram :
 258     CYThing
 259 {
 260     CYStatement *statements_;
 261
 262     CYProgram(CYStatement *statements) :
 263         statements_(statements)
 264     {
 265     }
 266
 267     virtual void Replace(CYContext &context);
 268
 269     virtual void Output(CYOutput &out) const;
 270 };
 271
 272 struct CYBlock :
 273     CYStatement,
 274     CYThing
 275 {
 276     CYStatement *statements_;
 277
 278     CYBlock(CYStatement *statements) :
 279         statements_(statements)
 280     {
 281     }
 282
 283     operator CYStatement *() const {
 284         return statements_;
 285     }
 286
 287     virtual CYStatement *Replace(CYContext &context);
 288
 289     virtual void Output(CYOutput &out) const;
 290     virtual void Output(CYOutput &out, CYFlags flags) const;
 291 };
 292
 293 enum CYState {
 294     CYClear,
 295     CYRestricted,
 296     CYNewLine
 297 };
 298
 299 class CYDriver {
 300   public:
 301     CYPool pool_;
 302
 303     CYState state_;
 304     void *scanner_;
 305
 306     const char *data_;
 307     size_t size_;
 308     FILE *file_;
 309
 310     bool strict_;
 311
 312     enum Condition {
 313         RegExpCondition,
 314         XMLContentCondition,
 315         XMLTagCondition,
 316     };
 317
 318     std::string filename_;
 319
 320     struct Error {
 321         bool warning_;
 322         cy::location location_;
 323         std::string message_;
 324     };
 325
 326     typedef std::vector<Error> Errors;
 327
 328     CYProgram *program_;
 329     Errors errors_;
 330
 331   private:
 332     void ScannerInit();
 333     void ScannerDestroy();
 334
 335   public:
 336     CYDriver(const std::string &filename);
 337     ~CYDriver();
 338
 339     Condition GetCondition();
 340     void SetCondition(Condition condition);
 341
 342     void PushCondition(Condition condition);
 343     void PopCondition();
 344
 345     void Warning(const cy::location &location, const char *message);
 346 };
 347
 348 struct CYForInitialiser {
 349     virtual void For(CYOutput &out) const = 0;
 350 };
 351
 352 struct CYForInInitialiser {
 353     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
 354     virtual const char *ForEachIn() const = 0;
 355     virtual CYExpression *ForEachIn(CYContext &out) = 0;
 356 };
 357
 358 struct CYNumber;
 359 struct CYString;
 360
 361 struct CYExpression :
 362     CYNext<CYExpression>,
 363     CYForInitialiser,
 364     CYForInInitialiser,
 365     CYClassName,
 366     CYThing
 367 {
 368     virtual unsigned Precedence() const = 0;
 369
 370     virtual bool RightHand() const {
 371         return true;
 372     }
 373
 374     virtual void For(CYOutput &out) const;
 375     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 376
 377     virtual const char *ForEachIn() const;
 378     virtual CYExpression *ForEachIn(CYContext &out);
 379
 380     virtual void Output(CYOutput &out) const;
 381     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 382     void Output(CYOutput &out, unsigned precedence, CYFlags flags) const;
 383
 384     virtual CYExpression *ClassName(CYContext &context, bool object);
 385     virtual void ClassName(CYOutput &out, bool object) const;
 386
 387     CYExpression *ReplaceAll(CYContext &context);
 388
 389     virtual CYExpression *Replace(CYContext &context) = 0;
 390
 391     virtual CYExpression *Primitive(CYContext &context) {
 392         return this;
 393     }
 394
 395     virtual CYNumber *Number(CYContext &context) {
 396         return NULL;
 397     }
 398
 399     virtual CYString *String(CYContext &context) {
 400         return NULL;
 401     }
 402
 403     virtual const char *Word() const {
 404         return NULL;
 405     }
 406 };
 407
 408 #define CYAlphabetic(value) \
 409     virtual bool Alphabetic() const { \
 410         return value; \
 411     }
 412
 413 #define CYPrecedence(value) \
 414     virtual unsigned Precedence() const { \
 415         return value; \
 416     }
 417
 418 #define CYRightHand(value) \
 419     virtual bool RightHand() const { \
 420         return value; \
 421     }
 422
 423 struct CYCompound :
 424     CYExpression
 425 {
 426     CYExpression *expressions_;
 427
 428     CYCompound(CYExpression *expressions) :
 429         expressions_(expressions)
 430     {
 431     }
 432
 433     void AddPrev(CYExpression *expression) {
 434         CYExpression *last(expression);
 435         while (last->next_ != NULL)
 436             last = last->next_;
 437         last->SetNext(expressions_);
 438         expressions_ = expression;
 439     }
 440
 441     CYPrecedence(17)
 442
 443     virtual CYExpression *Replace(CYContext &context);
 444     void Output(CYOutput &out, CYFlags flags) const;
 445 };
 446
 447 struct CYFunctionParameter :
 448     CYNext<CYFunctionParameter>,
 449     CYThing
 450 {
 451     CYIdentifier *name_;
 452
 453     CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) :
 454         CYNext<CYFunctionParameter>(next),
 455         name_(name)
 456     {
 457     }
 458
 459     virtual void Output(CYOutput &out) const;
 460 };
 461
 462 struct CYComprehension :
 463     CYNext<CYComprehension>,
 464     CYThing
 465 {
 466     virtual const char *Name() const = 0;
 467
 468     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;
 469     CYFunctionParameter *Parameters(CYContext &context) const;
 470     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 471     virtual void Output(CYOutput &out) const = 0;
 472 };
 473
 474 struct CYForInComprehension :
 475     CYComprehension
 476 {
 477     CYIdentifier *name_;
 478     CYExpression *set_;
 479
 480     CYForInComprehension(CYIdentifier *name, CYExpression *set) :
 481         name_(name),
 482         set_(set)
 483     {
 484     }
 485
 486     virtual const char *Name() const {
 487         return name_->Value();
 488     }
 489
 490     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 491     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 492     virtual void Output(CYOutput &out) const;
 493 };
 494
 495 struct CYForEachInComprehension :
 496     CYComprehension
 497 {
 498     CYIdentifier *name_;
 499     CYExpression *set_;
 500
 501     CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
 502         name_(name),
 503         set_(set)
 504     {
 505     }
 506
 507     virtual const char *Name() const {
 508         return name_->Value();
 509     }
 510
 511     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 512     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 513     virtual void Output(CYOutput &out) const;
 514 };
 515
 516 struct CYIfComprehension :
 517     CYComprehension
 518 {
 519     CYExpression *test_;
 520
 521     CYIfComprehension(CYExpression *test) :
 522         test_(test)
 523     {
 524     }
 525
 526     virtual const char *Name() const {
 527         return NULL;
 528     }
 529
 530     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 531     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 532     virtual void Output(CYOutput &out) const;
 533 };
 534
 535 struct CYArrayComprehension :
 536     CYExpression
 537 {
 538     CYExpression *expression_;
 539     CYComprehension *comprehensions_;
 540
 541     CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
 542         expression_(expression),
 543         comprehensions_(comprehensions)
 544     {
 545     }
 546
 547     CYPrecedence(0)
 548
 549     virtual CYExpression *Replace(CYContext &context);
 550     virtual void Output(CYOutput &out, CYFlags flags) const;
 551 };
 552
 553 struct CYLiteral :
 554     CYExpression
 555 {
 556     CYPrecedence(0)
 557     CYRightHand(false)
 558 };
 559
 560 struct CYTrivial :
 561     CYLiteral
 562 {
 563     virtual CYExpression *Replace(CYContext &context);
 564 };
 565
 566 struct CYMagic :
 567     CYExpression
 568 {
 569     CYPrecedence(0)
 570     CYRightHand(false)
 571 };
 572
 573 struct CYRange {
 574     uint64_t lo_;
 575     uint64_t hi_;
 576
 577     CYRange(uint64_t lo, uint64_t hi) :
 578         lo_(lo), hi_(hi)
 579     {
 580     }
 581
 582     bool operator [](uint8_t value) const {
 583         return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1;
 584     }
 585
 586     void operator()(uint8_t value) {
 587         if (value >> 7)
 588             return;
 589         (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f);
 590     }
 591 };
 592
 593 extern CYRange DigitRange_;
 594 extern CYRange WordStartRange_;
 595 extern CYRange WordEndRange_;
 596
 597 struct CYString :
 598     CYTrivial,
 599     CYPropertyName
 600 {
 601     const char *value_;
 602     size_t size_;
 603
 604     CYString() :
 605         value_(NULL),
 606         size_(0)
 607     {
 608     }
 609
 610     CYString(const char *value) :
 611         value_(value),
 612         size_(strlen(value))
 613     {
 614     }
 615
 616     CYString(const char *value, size_t size) :
 617         value_(value),
 618         size_(size)
 619     {
 620     }
 621
 622     CYString(const CYWord *word) :
 623         value_(word->Value()),
 624         size_(strlen(value_))
 625     {
 626     }
 627
 628     const char *Value() const {
 629         return value_;
 630     }
 631
 632     virtual const char *Word() const;
 633
 634     virtual CYNumber *Number(CYContext &context);
 635     virtual CYString *String(CYContext &context);
 636
 637     virtual CYString *Concat(CYContext &out, CYString *rhs) const;
 638     virtual void Output(CYOutput &out, CYFlags flags) const;
 639     virtual void PropertyName(CYOutput &out) const;
 640 };
 641
 642 struct CYNumber :
 643     CYTrivial,
 644     CYPropertyName
 645 {
 646     double value_;
 647
 648     CYNumber(double value) :
 649         value_(value)
 650     {
 651     }
 652
 653     double Value() const {
 654         return value_;
 655     }
 656
 657     virtual CYNumber *Number(CYContext &context);
 658     virtual CYString *String(CYContext &context);
 659
 660     virtual void Output(CYOutput &out, CYFlags flags) const;
 661     virtual void PropertyName(CYOutput &out) const;
 662 };
 663
 664 struct CYRegEx :
 665     CYTrivial
 666 {
 667     const char *value_;
 668
 669     CYRegEx(const char *value) :
 670         value_(value)
 671     {
 672     }
 673
 674     const char *Value() const {
 675         return value_;
 676     }
 677
 678     virtual void Output(CYOutput &out, CYFlags flags) const;
 679 };
 680
 681 struct CYNull :
 682     CYWord,
 683     CYTrivial
 684 {
 685     CYNull() :
 686         CYWord("null")
 687     {
 688     }
 689
 690     virtual CYNumber *Number(CYContext &context);
 691     virtual CYString *String(CYContext &context);
 692
 693     virtual void Output(CYOutput &out, CYFlags flags) const;
 694 };
 695
 696 struct CYThis :
 697     CYWord,
 698     CYMagic
 699 {
 700     CYThis() :
 701         CYWord("this")
 702     {
 703     }
 704
 705     virtual CYExpression *Replace(CYContext &context);
 706     virtual void Output(CYOutput &out, CYFlags flags) const;
 707 };
 708
 709 struct CYBoolean :
 710     CYTrivial
 711 {
 712     virtual bool Value() const = 0;
 713     virtual void Output(CYOutput &out, CYFlags flags) const;
 714 };
 715
 716 struct CYFalse :
 717     CYWord,
 718     CYBoolean
 719 {
 720     CYFalse() :
 721         CYWord("false")
 722     {
 723     }
 724
 725     virtual bool Value() const {
 726         return false;
 727     }
 728
 729     virtual CYNumber *Number(CYContext &context);
 730     virtual CYString *String(CYContext &context);
 731 };
 732
 733 struct CYTrue :
 734     CYWord,
 735     CYBoolean
 736 {
 737     CYTrue() :
 738         CYWord("true")
 739     {
 740     }
 741
 742     virtual bool Value() const {
 743         return true;
 744     }
 745
 746     virtual CYNumber *Number(CYContext &context);
 747     virtual CYString *String(CYContext &context);
 748 };
 749
 750 struct CYVariable :
 751     CYExpression
 752 {
 753     CYIdentifier *name_;
 754
 755     CYVariable(CYIdentifier *name) :
 756         name_(name)
 757     {
 758     }
 759
 760     CYPrecedence(0)
 761     CYRightHand(false)
 762
 763     virtual CYExpression *Replace(CYContext &context);
 764     virtual void Output(CYOutput &out, CYFlags flags) const;
 765 };
 766
 767 struct CYPrefix :
 768     CYExpression
 769 {
 770     CYExpression *rhs_;
 771
 772     CYPrefix(CYExpression *rhs) :
 773         rhs_(rhs)
 774     {
 775     }
 776
 777     virtual bool Alphabetic() const = 0;
 778     virtual const char *Operator() const = 0;
 779
 780     CYPrecedence(4)
 781
 782     virtual CYExpression *Replace(CYContext &context);
 783     virtual void Output(CYOutput &out, CYFlags flags) const;
 784 };
 785
 786 struct CYInfix :
 787     CYExpression
 788 {
 789     CYExpression *lhs_;
 790     CYExpression *rhs_;
 791
 792     CYInfix(CYExpression *lhs, CYExpression *rhs) :
 793         lhs_(lhs),
 794         rhs_(rhs)
 795     {
 796     }
 797
 798     void SetLeft(CYExpression *lhs) {
 799         lhs_ = lhs;
 800     }
 801
 802     virtual bool Alphabetic() const = 0;
 803     virtual const char *Operator() const = 0;
 804
 805     virtual CYExpression *Replace(CYContext &context);
 806     virtual void Output(CYOutput &out, CYFlags flags) const;
 807 };
 808
 809 struct CYPostfix :
 810     CYExpression
 811 {
 812     CYExpression *lhs_;
 813
 814     CYPostfix(CYExpression *lhs) :
 815         lhs_(lhs)
 816     {
 817     }
 818
 819     virtual const char *Operator() const = 0;
 820
 821     CYPrecedence(3)
 822
 823     virtual CYExpression *Replace(CYContext &context);
 824     virtual void Output(CYOutput &out, CYFlags flags) const;
 825 };
 826
 827 struct CYAssignment :
 828     CYExpression
 829 {
 830     CYExpression *lhs_;
 831     CYExpression *rhs_;
 832
 833     CYAssignment(CYExpression *lhs, CYExpression *rhs) :
 834         lhs_(lhs),
 835         rhs_(rhs)
 836     {
 837     }
 838
 839     void SetLeft(CYExpression *lhs) {
 840         lhs_ = lhs;
 841     }
 842
 843     virtual const char *Operator() const = 0;
 844
 845     CYPrecedence(16)
 846
 847     virtual CYExpression *Replace(CYContext &context);
 848     virtual void Output(CYOutput &out, CYFlags flags) const;
 849 };
 850
 851 struct CYArgument :
 852     CYNext<CYArgument>,
 853     CYThing
 854 {
 855     CYWord *name_;
 856     CYExpression *value_;
 857
 858     CYArgument(CYExpression *value, CYArgument *next = NULL) :
 859         CYNext<CYArgument>(next),
 860         name_(NULL),
 861         value_(value)
 862     {
 863     }
 864
 865     CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
 866         CYNext<CYArgument>(next),
 867         name_(name),
 868         value_(value)
 869     {
 870     }
 871
 872     void Replace(CYContext &context);
 873     void Output(CYOutput &out) const;
 874 };
 875
 876 struct CYBlank :
 877     public CYWord
 878 {
 879     CYBlank() :
 880         CYWord("")
 881     {
 882     }
 883 };
 884
 885 struct CYClause :
 886     CYThing,
 887     CYNext<CYClause>
 888 {
 889     CYExpression *case_;
 890     CYStatement *statements_;
 891
 892     CYClause(CYExpression *_case, CYStatement *statements) :
 893         case_(_case),
 894         statements_(statements)
 895     {
 896     }
 897
 898     void Replace(CYContext &context);
 899     virtual void Output(CYOutput &out) const;
 900 };
 901
 902 struct CYElement :
 903     CYNext<CYElement>,
 904     CYThing
 905 {
 906     CYExpression *value_;
 907
 908     CYElement(CYExpression *value, CYElement *next) :
 909         CYNext<CYElement>(next),
 910         value_(value)
 911     {
 912     }
 913
 914     void Replace(CYContext &context);
 915     void Output(CYOutput &out) const;
 916 };
 917
 918 struct CYArray :
 919     CYLiteral
 920 {
 921     CYElement *elements_;
 922
 923     CYArray(CYElement *elements = NULL) :
 924         elements_(elements)
 925     {
 926     }
 927
 928     virtual CYExpression *Replace(CYContext &context);
 929     virtual void Output(CYOutput &out, CYFlags flags) const;
 930 };
 931
 932 struct CYProperty :
 933     CYNext<CYProperty>,
 934     CYThing
 935 {
 936     CYPropertyName *name_;
 937     CYExpression *value_;
 938
 939     CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
 940         CYNext<CYProperty>(next),
 941         name_(name),
 942         value_(value)
 943     {
 944     }
 945
 946     void Replace(CYContext &context);
 947     virtual void Output(CYOutput &out) const;
 948 };
 949
 950 struct CYDeclaration :
 951     CYForInInitialiser
 952 {
 953     CYIdentifier *identifier_;
 954     CYExpression *initialiser_;
 955
 956     CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) :
 957         identifier_(identifier),
 958         initialiser_(initialiser)
 959     {
 960     }
 961
 962     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 963
 964     virtual const char *ForEachIn() const;
 965     virtual CYExpression *ForEachIn(CYContext &out);
 966
 967     void Replace(CYContext &context);
 968
 969     virtual void Output(CYOutput &out, CYFlags flags) const;
 970 };
 971
 972 struct CYDeclarations :
 973     CYNext<CYDeclarations>,
 974     CYForInitialiser,
 975     CYThing
 976 {
 977     CYDeclaration *declaration_;
 978
 979     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
 980         CYNext<CYDeclarations>(next),
 981         declaration_(declaration)
 982     {
 983     }
 984
 985     virtual void For(CYOutput &out) const;
 986
 987     void Replace(CYContext &context);
 988     CYProperty *Property(CYContext &context);
 989
 990     virtual void Output(CYOutput &out) const;
 991     virtual void Output(CYOutput &out, CYFlags flags) const;
 992 };
 993
 994 struct CYVar :
 995     CYStatement
 996 {
 997     CYDeclarations *declarations_;
 998
 999     CYVar(CYDeclarations *declarations) :
1000         declarations_(declarations)
1001     {
1002     }
1003
1004     virtual CYStatement *Replace(CYContext &context);
1005     virtual void Output(CYOutput &out, CYFlags flags) const;
1006 };
1007
1008 struct CYLet :
1009     CYStatement
1010 {
1011     CYDeclarations *declarations_;
1012     CYBlock code_;
1013
1014     CYLet(CYDeclarations *declarations, CYStatement *statements) :
1015         declarations_(declarations),
1016         code_(statements)
1017     {
1018     }
1019
1020     virtual CYStatement *Replace(CYContext &context);
1021     virtual void Output(CYOutput &out, CYFlags flags) const;
1022 };
1023
1024 struct CYFor :
1025     CYStatement
1026 {
1027     CYForInitialiser *initialiser_;
1028     CYExpression *test_;
1029     CYExpression *increment_;
1030     CYStatement *code_;
1031
1032     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
1033         initialiser_(initialiser),
1034         test_(test),
1035         increment_(increment),
1036         code_(code)
1037     {
1038     }
1039
1040     virtual CYStatement *Replace(CYContext &context);
1041     virtual void Output(CYOutput &out, CYFlags flags) const;
1042 };
1043
1044 struct CYForIn :
1045     CYStatement
1046 {
1047     CYForInInitialiser *initialiser_;
1048     CYExpression *set_;
1049     CYStatement *code_;
1050
1051     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1052         initialiser_(initialiser),
1053         set_(set),
1054         code_(code)
1055     {
1056     }
1057
1058     virtual CYStatement *Replace(CYContext &context);
1059     virtual void Output(CYOutput &out, CYFlags flags) const;
1060 };
1061
1062 struct CYForEachIn :
1063     CYStatement
1064 {
1065     CYForInInitialiser *initialiser_;
1066     CYExpression *set_;
1067     CYStatement *code_;
1068
1069     CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1070         initialiser_(initialiser),
1071         set_(set),
1072         code_(code)
1073     {
1074     }
1075
1076     virtual CYStatement *Replace(CYContext &context);
1077     virtual void Output(CYOutput &out, CYFlags flags) const;
1078 };
1079
1080 struct CYObject :
1081     CYLiteral
1082 {
1083     CYProperty *properties_;
1084
1085     CYObject(CYProperty *properties) :
1086         properties_(properties)
1087     {
1088     }
1089
1090     virtual CYExpression *Replace(CYContext &context);
1091     void Output(CYOutput &out, CYFlags flags) const;
1092 };
1093
1094 struct CYMember :
1095     CYExpression
1096 {
1097     CYExpression *object_;
1098     CYExpression *property_;
1099
1100     CYMember(CYExpression *object, CYExpression *property) :
1101         object_(object),
1102         property_(property)
1103     {
1104     }
1105
1106     void SetLeft(CYExpression *object) {
1107         object_ = object;
1108     }
1109
1110     void Replace_(CYContext &context);
1111 };
1112
1113 struct CYDirectMember :
1114     CYMember
1115 {
1116     CYDirectMember(CYExpression *object, CYExpression *property) :
1117         CYMember(object, property)
1118     {
1119     }
1120
1121     CYPrecedence(1)
1122     CYRightHand(false)
1123
1124     virtual CYExpression *Replace(CYContext &context);
1125     virtual void Output(CYOutput &out, CYFlags flags) const;
1126 };
1127
1128 struct CYIndirectMember :
1129     CYMember
1130 {
1131     CYIndirectMember(CYExpression *object, CYExpression *property) :
1132         CYMember(object, property)
1133     {
1134     }
1135
1136     CYPrecedence(1)
1137     CYRightHand(false)
1138
1139     virtual CYExpression *Replace(CYContext &context);
1140     virtual void Output(CYOutput &out, CYFlags flags) const;
1141 };
1142
1143 struct CYNew :
1144     CYExpression
1145 {
1146     CYExpression *constructor_;
1147     CYArgument *arguments_;
1148
1149     CYNew(CYExpression *constructor, CYArgument *arguments) :
1150         constructor_(constructor),
1151         arguments_(arguments)
1152     {
1153     }
1154
1155     virtual unsigned Precedence() const {
1156         return arguments_ == NULL ? 2 : 1;
1157     }
1158
1159     CYRightHand(false)
1160
1161     virtual CYExpression *Replace(CYContext &context);
1162     virtual void Output(CYOutput &out, CYFlags flags) const;
1163 };
1164
1165 struct CYCall :
1166     CYExpression
1167 {
1168     CYExpression *function_;
1169     CYArgument *arguments_;
1170
1171     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1172         function_(function),
1173         arguments_(arguments)
1174     {
1175     }
1176
1177     CYPrecedence(1)
1178     CYRightHand(false)
1179
1180     virtual CYExpression *Replace(CYContext &context);
1181     virtual void Output(CYOutput &out, CYFlags flags) const;
1182 };
1183
1184 struct CYIf :
1185     CYStatement
1186 {
1187     CYExpression *test_;
1188     CYStatement *true_;
1189     CYStatement *false_;
1190
1191     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1192         test_(test),
1193         true_(_true),
1194         false_(_false)
1195     {
1196     }
1197
1198     virtual CYStatement *Replace(CYContext &context);
1199     virtual void Output(CYOutput &out, CYFlags flags) const;
1200 };
1201
1202 struct CYDoWhile :
1203     CYStatement
1204 {
1205     CYExpression *test_;
1206     CYStatement *code_;
1207
1208     CYDoWhile(CYExpression *test, CYStatement *code) :
1209         test_(test),
1210         code_(code)
1211     {
1212     }
1213
1214     virtual CYStatement *Replace(CYContext &context);
1215     virtual void Output(CYOutput &out, CYFlags flags) const;
1216 };
1217
1218 struct CYWhile :
1219     CYStatement
1220 {
1221     CYExpression *test_;
1222     CYStatement *code_;
1223
1224     CYWhile(CYExpression *test, CYStatement *code) :
1225         test_(test),
1226         code_(code)
1227     {
1228     }
1229
1230     virtual CYStatement *Replace(CYContext &context);
1231     virtual void Output(CYOutput &out, CYFlags flags) const;
1232 };
1233
1234 struct CYFunction {
1235     CYIdentifier *name_;
1236     CYFunctionParameter *parameters_;
1237     CYBlock code_;
1238
1239     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1240         name_(name),
1241         parameters_(parameters),
1242         code_(statements)
1243     {
1244     }
1245
1246     virtual void Replace_(CYContext &context);
1247     virtual void Output(CYOutput &out, CYFlags flags) const;
1248 };
1249
1250 struct CYFunctionExpression :
1251     CYFunction,
1252     CYExpression
1253 {
1254     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1255         CYFunction(name, parameters, statements)
1256     {
1257     }
1258
1259     CYPrecedence(0)
1260     CYRightHand(false)
1261
1262     virtual CYExpression *Replace(CYContext &context);
1263     virtual void Output(CYOutput &out, CYFlags flags) const;
1264 };
1265
1266 struct CYFunctionStatement :
1267     CYFunction,
1268     CYStatement
1269 {
1270     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1271         CYFunction(name, parameters, statements)
1272     {
1273     }
1274
1275     virtual CYStatement *Replace(CYContext &context);
1276     virtual void Output(CYOutput &out, CYFlags flags) const;
1277 };
1278
1279 struct CYExpress :
1280     CYStatement
1281 {
1282     CYExpression *expression_;
1283
1284     CYExpress(CYExpression *expression) :
1285         expression_(expression)
1286     {
1287     }
1288
1289     virtual CYStatement *Replace(CYContext &context);
1290     virtual void Output(CYOutput &out, CYFlags flags) const;
1291 };
1292
1293 struct CYContinue :
1294     CYStatement
1295 {
1296     CYIdentifier *label_;
1297
1298     CYContinue(CYIdentifier *label) :
1299         label_(label)
1300     {
1301     }
1302
1303     virtual CYStatement *Replace(CYContext &context);
1304     virtual void Output(CYOutput &out, CYFlags flags) const;
1305 };
1306
1307 struct CYBreak :
1308     CYStatement
1309 {
1310     CYIdentifier *label_;
1311
1312     CYBreak(CYIdentifier *label) :
1313         label_(label)
1314     {
1315     }
1316
1317     virtual CYStatement *Replace(CYContext &context);
1318     virtual void Output(CYOutput &out, CYFlags flags) const;
1319 };
1320
1321 struct CYReturn :
1322     CYStatement
1323 {
1324     CYExpression *value_;
1325
1326     CYReturn(CYExpression *value) :
1327         value_(value)
1328     {
1329     }
1330
1331     virtual CYStatement *Replace(CYContext &context);
1332     virtual void Output(CYOutput &out, CYFlags flags) const;
1333 };
1334
1335 struct CYEmpty :
1336     CYStatement
1337 {
1338     virtual CYStatement *Replace(CYContext &context);
1339     virtual void Output(CYOutput &out, CYFlags flags) const;
1340 };
1341
1342 struct CYFinally :
1343     CYThing
1344 {
1345     CYBlock code_;
1346
1347     CYFinally(CYStatement *statements) :
1348         code_(statements)
1349     {
1350     }
1351
1352     void Replace(CYContext &context);
1353     virtual void Output(CYOutput &out) const;
1354 };
1355
1356 namespace cy {
1357 namespace Syntax {
1358
1359 struct Catch :
1360     CYThing
1361 {
1362     CYIdentifier *name_;
1363     CYBlock code_;
1364
1365     Catch(CYIdentifier *name, CYStatement *statements) :
1366         name_(name),
1367         code_(statements)
1368     {
1369     }
1370
1371     void Replace(CYContext &context);
1372     virtual void Output(CYOutput &out) const;
1373 };
1374
1375 struct Try :
1376     CYStatement
1377 {
1378     CYBlock code_;
1379     Catch *catch_;
1380     CYFinally *finally_;
1381
1382     Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
1383         code_(statements),
1384         catch_(_catch),
1385         finally_(finally)
1386     {
1387     }
1388
1389     virtual CYStatement *Replace(CYContext &context);
1390     virtual void Output(CYOutput &out, CYFlags flags) const;
1391 };
1392
1393 struct Throw :
1394     CYStatement
1395 {
1396     CYExpression *value_;
1397
1398     Throw(CYExpression *value) :
1399         value_(value)
1400     {
1401     }
1402
1403     virtual CYStatement *Replace(CYContext &context);
1404     virtual void Output(CYOutput &out, CYFlags flags) const;
1405 };
1406
1407 } }
1408
1409 struct CYWith :
1410     CYStatement
1411 {
1412     CYExpression *scope_;
1413     CYStatement *code_;
1414
1415     CYWith(CYExpression *scope, CYStatement *code) :
1416         scope_(scope),
1417         code_(code)
1418     {
1419     }
1420
1421     virtual CYStatement *Replace(CYContext &context);
1422     virtual void Output(CYOutput &out, CYFlags flags) const;
1423 };
1424
1425 struct CYSwitch :
1426     CYStatement
1427 {
1428     CYExpression *value_;
1429     CYClause *clauses_;
1430
1431     CYSwitch(CYExpression *value, CYClause *clauses) :
1432         value_(value),
1433         clauses_(clauses)
1434     {
1435     }
1436
1437     virtual CYStatement *Replace(CYContext &context);
1438     virtual void Output(CYOutput &out, CYFlags flags) const;
1439 };
1440
1441 struct CYCondition :
1442     CYExpression
1443 {
1444     CYExpression *test_;
1445     CYExpression *true_;
1446     CYExpression *false_;
1447
1448     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1449         test_(test),
1450         true_(_true),
1451         false_(_false)
1452     {
1453     }
1454
1455     CYPrecedence(15)
1456
1457     virtual CYExpression *Replace(CYContext &context);
1458     virtual void Output(CYOutput &out, CYFlags flags) const;
1459 };
1460
1461 struct CYAddressOf :
1462     CYPrefix
1463 {
1464     CYAddressOf(CYExpression *rhs) :
1465         CYPrefix(rhs)
1466     {
1467     }
1468
1469     virtual const char *Operator() const {
1470         return "&";
1471     }
1472
1473     CYAlphabetic(false)
1474
1475     virtual CYExpression *Replace(CYContext &context);
1476 };
1477
1478 struct CYIndirect :
1479     CYPrefix
1480 {
1481     CYIndirect(CYExpression *rhs) :
1482         CYPrefix(rhs)
1483     {
1484     }
1485
1486     virtual const char *Operator() const {
1487         return "^";
1488     }
1489
1490     CYAlphabetic(false)
1491
1492     virtual CYExpression *Replace(CYContext &context);
1493 };
1494
1495 #define CYReplace \
1496     virtual CYExpression *Replace(CYContext &context);
1497
1498 #define CYPostfix_(op, name, args...) \
1499     struct CY ## name : \
1500         CYPostfix \
1501     { args \
1502         CY ## name(CYExpression *lhs) : \
1503             CYPostfix(lhs) \
1504         { \
1505         } \
1506     \
1507         virtual const char *Operator() const { \
1508             return op; \
1509         } \
1510     };
1511
1512 #define CYPrefix_(alphabetic, op, name, args...) \
1513     struct CY ## name : \
1514         CYPrefix \
1515     { args \
1516         CY ## name(CYExpression *rhs) : \
1517             CYPrefix(rhs) \
1518         { \
1519         } \
1520     \
1521         CYAlphabetic(alphabetic) \
1522     \
1523         virtual const char *Operator() const { \
1524             return op; \
1525         } \
1526     };
1527
1528 #define CYInfix_(alphabetic, precedence, op, name, args...) \
1529     struct CY ## name : \
1530         CYInfix \
1531     { args \
1532         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
1533             CYInfix(lhs, rhs) \
1534         { \
1535         } \
1536     \
1537         CYAlphabetic(alphabetic) \
1538         CYPrecedence(precedence) \
1539     \
1540         virtual const char *Operator() const { \
1541             return op; \
1542         } \
1543     };
1544
1545 #define CYAssignment_(op, name, args...) \
1546     struct CY ## name ## Assign : \
1547         CYAssignment \
1548     { args \
1549         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
1550             CYAssignment(lhs, rhs) \
1551         { \
1552         } \
1553     \
1554         virtual const char *Operator() const { \
1555             return op; \
1556         } \
1557     };
1558
1559 CYPostfix_("++", PostIncrement)
1560 CYPostfix_("--", PostDecrement)
1561
1562 CYPrefix_(true, "delete", Delete)
1563 CYPrefix_(true, "void", Void)
1564 CYPrefix_(true, "typeof", TypeOf)
1565 CYPrefix_(false, "++", PreIncrement)
1566 CYPrefix_(false, "--", PreDecrement)
1567 CYPrefix_(false, "+", Affirm)
1568 CYPrefix_(false, "-", Negate)
1569 CYPrefix_(false, "~", BitwiseNot)
1570 CYPrefix_(false, "!", LogicalNot)
1571
1572 CYInfix_(false, 5, "*", Multiply)
1573 CYInfix_(false, 5, "/", Divide)
1574 CYInfix_(false, 5, "%", Modulus)
1575 CYInfix_(false, 6, "+", Add, CYReplace)
1576 CYInfix_(false, 6, "-", Subtract)
1577 CYInfix_(false, 7, "<<", ShiftLeft)
1578 CYInfix_(false, 7, ">>", ShiftRightSigned)
1579 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
1580 CYInfix_(false, 8, "<", Less)
1581 CYInfix_(false, 8, ">", Greater)
1582 CYInfix_(false, 8, "<=", LessOrEqual)
1583 CYInfix_(false, 8, ">=", GreaterOrEqual)
1584 CYInfix_(true, 8, "instanceof", InstanceOf)
1585 CYInfix_(true, 8, "in", In)
1586 CYInfix_(false, 9, "==", Equal)
1587 CYInfix_(false, 9, "!=", NotEqual)
1588 CYInfix_(false, 9, "===", Identical)
1589 CYInfix_(false, 9, "!==", NotIdentical)
1590 CYInfix_(false, 10, "&", BitwiseAnd)
1591 CYInfix_(false, 11, "^", BitwiseXOr)
1592 CYInfix_(false, 12, "|", BitwiseOr)
1593 CYInfix_(false, 13, "&&", LogicalAnd)
1594 CYInfix_(false, 14, "||", LogicalOr)
1595
1596 CYAssignment_("=", )
1597 CYAssignment_("*=", Multiply)
1598 CYAssignment_("/=", Divide)
1599 CYAssignment_("%=", Modulus)
1600 CYAssignment_("+=", Add)
1601 CYAssignment_("-=", Subtract)
1602 CYAssignment_("<<=", ShiftLeft)
1603 CYAssignment_(">>=", ShiftRightSigned)
1604 CYAssignment_(">>>=", ShiftRightUnsigned)
1605 CYAssignment_("&=", BitwiseAnd)
1606 CYAssignment_("^=", BitwiseXOr)
1607 CYAssignment_("|=", BitwiseOr)
1608
1609 #endif/*CYPARSER_HPP*/