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 CYDeclaration :
 933     CYForInInitialiser
 934 {
 935     CYIdentifier *identifier_;
 936     CYExpression *initialiser_;
 937
 938     CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser) :
 939         identifier_(identifier),
 940         initialiser_(initialiser)
 941     {
 942     }
 943
 944     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 945
 946     virtual const char *ForEachIn() const;
 947     virtual CYExpression *ForEachIn(CYContext &out);
 948
 949     void Replace(CYContext &context);
 950
 951     virtual void Output(CYOutput &out, CYFlags flags) const;
 952 };
 953
 954 struct CYDeclarations :
 955     CYNext<CYDeclarations>,
 956     CYForInitialiser,
 957     CYThing
 958 {
 959     CYDeclaration *declaration_;
 960
 961     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
 962         CYNext<CYDeclarations>(next),
 963         declaration_(declaration)
 964     {
 965     }
 966
 967     virtual void For(CYOutput &out) const;
 968
 969     void Replace(CYContext &context);
 970
 971     virtual void Output(CYOutput &out) const;
 972     virtual void Output(CYOutput &out, CYFlags flags) const;
 973 };
 974
 975 struct CYVar :
 976     CYStatement
 977 {
 978     CYDeclarations *declarations_;
 979
 980     CYVar(CYDeclarations *declarations) :
 981         declarations_(declarations)
 982     {
 983     }
 984
 985     virtual CYStatement *Replace(CYContext &context);
 986     virtual void Output(CYOutput &out, CYFlags flags) const;
 987 };
 988
 989 struct CYLet :
 990     CYStatement
 991 {
 992     CYDeclarations *declarations_;
 993     CYBlock code_;
 994
 995     CYLet(CYDeclarations *declarations, CYStatement *statements) :
 996         declarations_(declarations),
 997         code_(statements)
 998     {
 999     }
1000
1001     virtual CYStatement *Replace(CYContext &context);
1002     virtual void Output(CYOutput &out, CYFlags flags) const;
1003 };
1004
1005 struct CYFor :
1006     CYStatement
1007 {
1008     CYForInitialiser *initialiser_;
1009     CYExpression *test_;
1010     CYExpression *increment_;
1011     CYStatement *code_;
1012
1013     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
1014         initialiser_(initialiser),
1015         test_(test),
1016         increment_(increment),
1017         code_(code)
1018     {
1019     }
1020
1021     virtual CYStatement *Replace(CYContext &context);
1022     virtual void Output(CYOutput &out, CYFlags flags) const;
1023 };
1024
1025 struct CYForIn :
1026     CYStatement
1027 {
1028     CYForInInitialiser *initialiser_;
1029     CYExpression *set_;
1030     CYStatement *code_;
1031
1032     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1033         initialiser_(initialiser),
1034         set_(set),
1035         code_(code)
1036     {
1037     }
1038
1039     virtual CYStatement *Replace(CYContext &context);
1040     virtual void Output(CYOutput &out, CYFlags flags) const;
1041 };
1042
1043 struct CYForEachIn :
1044     CYStatement
1045 {
1046     CYForInInitialiser *initialiser_;
1047     CYExpression *set_;
1048     CYStatement *code_;
1049
1050     CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1051         initialiser_(initialiser),
1052         set_(set),
1053         code_(code)
1054     {
1055     }
1056
1057     virtual CYStatement *Replace(CYContext &context);
1058     virtual void Output(CYOutput &out, CYFlags flags) const;
1059 };
1060
1061 struct CYProperty :
1062     CYNext<CYProperty>,
1063     CYThing
1064 {
1065     CYPropertyName *name_;
1066     CYExpression *value_;
1067
1068     CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
1069         CYNext<CYProperty>(next),
1070         name_(name),
1071         value_(value)
1072     {
1073     }
1074
1075     void Replace(CYContext &context);
1076     virtual void Output(CYOutput &out) const;
1077 };
1078
1079 struct CYObject :
1080     CYLiteral
1081 {
1082     CYProperty *properties_;
1083
1084     CYObject(CYProperty *properties) :
1085         properties_(properties)
1086     {
1087     }
1088
1089     virtual CYExpression *Replace(CYContext &context);
1090     void Output(CYOutput &out, CYFlags flags) const;
1091 };
1092
1093 struct CYMember :
1094     CYExpression
1095 {
1096     CYExpression *object_;
1097     CYExpression *property_;
1098
1099     CYMember(CYExpression *object, CYExpression *property) :
1100         object_(object),
1101         property_(property)
1102     {
1103     }
1104
1105     void SetLeft(CYExpression *object) {
1106         object_ = object;
1107     }
1108
1109     void Replace_(CYContext &context);
1110 };
1111
1112 struct CYDirectMember :
1113     CYMember
1114 {
1115     CYDirectMember(CYExpression *object, CYExpression *property) :
1116         CYMember(object, property)
1117     {
1118     }
1119
1120     CYPrecedence(1)
1121     CYRightHand(false)
1122
1123     virtual CYExpression *Replace(CYContext &context);
1124     virtual void Output(CYOutput &out, CYFlags flags) const;
1125 };
1126
1127 struct CYIndirectMember :
1128     CYMember
1129 {
1130     CYIndirectMember(CYExpression *object, CYExpression *property) :
1131         CYMember(object, property)
1132     {
1133     }
1134
1135     CYPrecedence(1)
1136     CYRightHand(false)
1137
1138     virtual CYExpression *Replace(CYContext &context);
1139     virtual void Output(CYOutput &out, CYFlags flags) const;
1140 };
1141
1142 struct CYNew :
1143     CYExpression
1144 {
1145     CYExpression *constructor_;
1146     CYArgument *arguments_;
1147
1148     CYNew(CYExpression *constructor, CYArgument *arguments) :
1149         constructor_(constructor),
1150         arguments_(arguments)
1151     {
1152     }
1153
1154     virtual unsigned Precedence() const {
1155         return arguments_ == NULL ? 2 : 1;
1156     }
1157
1158     CYRightHand(false)
1159
1160     virtual CYExpression *Replace(CYContext &context);
1161     virtual void Output(CYOutput &out, CYFlags flags) const;
1162 };
1163
1164 struct CYCall :
1165     CYExpression
1166 {
1167     CYExpression *function_;
1168     CYArgument *arguments_;
1169
1170     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1171         function_(function),
1172         arguments_(arguments)
1173     {
1174     }
1175
1176     CYPrecedence(1)
1177     CYRightHand(false)
1178
1179     virtual CYExpression *Replace(CYContext &context);
1180     virtual void Output(CYOutput &out, CYFlags flags) const;
1181 };
1182
1183 struct CYIf :
1184     CYStatement
1185 {
1186     CYExpression *test_;
1187     CYStatement *true_;
1188     CYStatement *false_;
1189
1190     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1191         test_(test),
1192         true_(_true),
1193         false_(_false)
1194     {
1195     }
1196
1197     virtual CYStatement *Replace(CYContext &context);
1198     virtual void Output(CYOutput &out, CYFlags flags) const;
1199 };
1200
1201 struct CYDoWhile :
1202     CYStatement
1203 {
1204     CYExpression *test_;
1205     CYStatement *code_;
1206
1207     CYDoWhile(CYExpression *test, CYStatement *code) :
1208         test_(test),
1209         code_(code)
1210     {
1211     }
1212
1213     virtual CYStatement *Replace(CYContext &context);
1214     virtual void Output(CYOutput &out, CYFlags flags) const;
1215 };
1216
1217 struct CYWhile :
1218     CYStatement
1219 {
1220     CYExpression *test_;
1221     CYStatement *code_;
1222
1223     CYWhile(CYExpression *test, CYStatement *code) :
1224         test_(test),
1225         code_(code)
1226     {
1227     }
1228
1229     virtual CYStatement *Replace(CYContext &context);
1230     virtual void Output(CYOutput &out, CYFlags flags) const;
1231 };
1232
1233 struct CYFunction {
1234     CYIdentifier *name_;
1235     CYFunctionParameter *parameters_;
1236     CYBlock code_;
1237
1238     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1239         name_(name),
1240         parameters_(parameters),
1241         code_(statements)
1242     {
1243     }
1244
1245     virtual void Replace_(CYContext &context);
1246     virtual void Output(CYOutput &out, CYFlags flags) const;
1247 };
1248
1249 struct CYFunctionExpression :
1250     CYFunction,
1251     CYExpression
1252 {
1253     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1254         CYFunction(name, parameters, statements)
1255     {
1256     }
1257
1258     CYPrecedence(0)
1259     CYRightHand(false)
1260
1261     virtual CYExpression *Replace(CYContext &context);
1262     virtual void Output(CYOutput &out, CYFlags flags) const;
1263 };
1264
1265 struct CYFunctionStatement :
1266     CYFunction,
1267     CYStatement
1268 {
1269     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1270         CYFunction(name, parameters, statements)
1271     {
1272     }
1273
1274     virtual CYStatement *Replace(CYContext &context);
1275     virtual void Output(CYOutput &out, CYFlags flags) const;
1276 };
1277
1278 struct CYExpress :
1279     CYStatement
1280 {
1281     CYExpression *expression_;
1282
1283     CYExpress(CYExpression *expression) :
1284         expression_(expression)
1285     {
1286     }
1287
1288     virtual CYStatement *Replace(CYContext &context);
1289     virtual void Output(CYOutput &out, CYFlags flags) const;
1290 };
1291
1292 struct CYContinue :
1293     CYStatement
1294 {
1295     CYIdentifier *label_;
1296
1297     CYContinue(CYIdentifier *label) :
1298         label_(label)
1299     {
1300     }
1301
1302     virtual CYStatement *Replace(CYContext &context);
1303     virtual void Output(CYOutput &out, CYFlags flags) const;
1304 };
1305
1306 struct CYBreak :
1307     CYStatement
1308 {
1309     CYIdentifier *label_;
1310
1311     CYBreak(CYIdentifier *label) :
1312         label_(label)
1313     {
1314     }
1315
1316     virtual CYStatement *Replace(CYContext &context);
1317     virtual void Output(CYOutput &out, CYFlags flags) const;
1318 };
1319
1320 struct CYReturn :
1321     CYStatement
1322 {
1323     CYExpression *value_;
1324
1325     CYReturn(CYExpression *value) :
1326         value_(value)
1327     {
1328     }
1329
1330     virtual CYStatement *Replace(CYContext &context);
1331     virtual void Output(CYOutput &out, CYFlags flags) const;
1332 };
1333
1334 struct CYEmpty :
1335     CYStatement
1336 {
1337     virtual CYStatement *Replace(CYContext &context);
1338     virtual void Output(CYOutput &out, CYFlags flags) const;
1339 };
1340
1341 struct CYFinally :
1342     CYThing
1343 {
1344     CYBlock code_;
1345
1346     CYFinally(CYStatement *statements) :
1347         code_(statements)
1348     {
1349     }
1350
1351     void Replace(CYContext &context);
1352     virtual void Output(CYOutput &out) const;
1353 };
1354
1355 namespace cy {
1356 namespace Syntax {
1357
1358 struct Catch :
1359     CYThing
1360 {
1361     CYIdentifier *name_;
1362     CYBlock code_;
1363
1364     Catch(CYIdentifier *name, CYStatement *statements) :
1365         name_(name),
1366         code_(statements)
1367     {
1368     }
1369
1370     void Replace(CYContext &context);
1371     virtual void Output(CYOutput &out) const;
1372 };
1373
1374 struct Try :
1375     CYStatement
1376 {
1377     CYBlock code_;
1378     Catch *catch_;
1379     CYFinally *finally_;
1380
1381     Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
1382         code_(statements),
1383         catch_(_catch),
1384         finally_(finally)
1385     {
1386     }
1387
1388     virtual CYStatement *Replace(CYContext &context);
1389     virtual void Output(CYOutput &out, CYFlags flags) const;
1390 };
1391
1392 struct Throw :
1393     CYStatement
1394 {
1395     CYExpression *value_;
1396
1397     Throw(CYExpression *value) :
1398         value_(value)
1399     {
1400     }
1401
1402     virtual CYStatement *Replace(CYContext &context);
1403     virtual void Output(CYOutput &out, CYFlags flags) const;
1404 };
1405
1406 } }
1407
1408 struct CYWith :
1409     CYStatement
1410 {
1411     CYExpression *scope_;
1412     CYStatement *code_;
1413
1414     CYWith(CYExpression *scope, CYStatement *code) :
1415         scope_(scope),
1416         code_(code)
1417     {
1418     }
1419
1420     virtual CYStatement *Replace(CYContext &context);
1421     virtual void Output(CYOutput &out, CYFlags flags) const;
1422 };
1423
1424 struct CYSwitch :
1425     CYStatement
1426 {
1427     CYExpression *value_;
1428     CYClause *clauses_;
1429
1430     CYSwitch(CYExpression *value, CYClause *clauses) :
1431         value_(value),
1432         clauses_(clauses)
1433     {
1434     }
1435
1436     virtual CYStatement *Replace(CYContext &context);
1437     virtual void Output(CYOutput &out, CYFlags flags) const;
1438 };
1439
1440 struct CYCondition :
1441     CYExpression
1442 {
1443     CYExpression *test_;
1444     CYExpression *true_;
1445     CYExpression *false_;
1446
1447     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1448         test_(test),
1449         true_(_true),
1450         false_(_false)
1451     {
1452     }
1453
1454     CYPrecedence(15)
1455
1456     virtual CYExpression *Replace(CYContext &context);
1457     virtual void Output(CYOutput &out, CYFlags flags) const;
1458 };
1459
1460 struct CYAddressOf :
1461     CYPrefix
1462 {
1463     CYAddressOf(CYExpression *rhs) :
1464         CYPrefix(rhs)
1465     {
1466     }
1467
1468     virtual const char *Operator() const {
1469         return "&";
1470     }
1471
1472     CYAlphabetic(false)
1473
1474     virtual CYExpression *Replace(CYContext &context);
1475 };
1476
1477 struct CYIndirect :
1478     CYPrefix
1479 {
1480     CYIndirect(CYExpression *rhs) :
1481         CYPrefix(rhs)
1482     {
1483     }
1484
1485     virtual const char *Operator() const {
1486         return "^";
1487     }
1488
1489     CYAlphabetic(false)
1490
1491     virtual CYExpression *Replace(CYContext &context);
1492 };
1493
1494 #define CYReplace \
1495     virtual CYExpression *Replace(CYContext &context);
1496
1497 #define CYPostfix_(op, name, args...) \
1498     struct CY ## name : \
1499         CYPostfix \
1500     { args \
1501         CY ## name(CYExpression *lhs) : \
1502             CYPostfix(lhs) \
1503         { \
1504         } \
1505     \
1506         virtual const char *Operator() const { \
1507             return op; \
1508         } \
1509     };
1510
1511 #define CYPrefix_(alphabetic, op, name, args...) \
1512     struct CY ## name : \
1513         CYPrefix \
1514     { args \
1515         CY ## name(CYExpression *rhs) : \
1516             CYPrefix(rhs) \
1517         { \
1518         } \
1519     \
1520         CYAlphabetic(alphabetic) \
1521     \
1522         virtual const char *Operator() const { \
1523             return op; \
1524         } \
1525     };
1526
1527 #define CYInfix_(alphabetic, precedence, op, name, args...) \
1528     struct CY ## name : \
1529         CYInfix \
1530     { args \
1531         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
1532             CYInfix(lhs, rhs) \
1533         { \
1534         } \
1535     \
1536         CYAlphabetic(alphabetic) \
1537         CYPrecedence(precedence) \
1538     \
1539         virtual const char *Operator() const { \
1540             return op; \
1541         } \
1542     };
1543
1544 #define CYAssignment_(op, name, args...) \
1545     struct CY ## name ## Assign : \
1546         CYAssignment \
1547     { args \
1548         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
1549             CYAssignment(lhs, rhs) \
1550         { \
1551         } \
1552     \
1553         virtual const char *Operator() const { \
1554             return op; \
1555         } \
1556     };
1557
1558 CYPostfix_("++", PostIncrement)
1559 CYPostfix_("--", PostDecrement)
1560
1561 CYPrefix_(true, "delete", Delete)
1562 CYPrefix_(true, "void", Void)
1563 CYPrefix_(true, "typeof", TypeOf)
1564 CYPrefix_(false, "++", PreIncrement)
1565 CYPrefix_(false, "--", PreDecrement)
1566 CYPrefix_(false, "+", Affirm)
1567 CYPrefix_(false, "-", Negate)
1568 CYPrefix_(false, "~", BitwiseNot)
1569 CYPrefix_(false, "!", LogicalNot)
1570
1571 CYInfix_(false, 5, "*", Multiply)
1572 CYInfix_(false, 5, "/", Divide)
1573 CYInfix_(false, 5, "%", Modulus)
1574 CYInfix_(false, 6, "+", Add, CYReplace)
1575 CYInfix_(false, 6, "-", Subtract)
1576 CYInfix_(false, 7, "<<", ShiftLeft)
1577 CYInfix_(false, 7, ">>", ShiftRightSigned)
1578 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
1579 CYInfix_(false, 8, "<", Less)
1580 CYInfix_(false, 8, ">", Greater)
1581 CYInfix_(false, 8, "<=", LessOrEqual)
1582 CYInfix_(false, 8, ">=", GreaterOrEqual)
1583 CYInfix_(true, 8, "instanceof", InstanceOf)
1584 CYInfix_(true, 8, "in", In)
1585 CYInfix_(false, 9, "==", Equal)
1586 CYInfix_(false, 9, "!=", NotEqual)
1587 CYInfix_(false, 9, "===", Identical)
1588 CYInfix_(false, 9, "!==", NotIdentical)
1589 CYInfix_(false, 10, "&", BitwiseAnd)
1590 CYInfix_(false, 11, "^", BitwiseXOr)
1591 CYInfix_(false, 12, "|", BitwiseOr)
1592 CYInfix_(false, 13, "&&", LogicalAnd)
1593 CYInfix_(false, 14, "||", LogicalOr)
1594
1595 CYAssignment_("=", )
1596 CYAssignment_("*=", Multiply)
1597 CYAssignment_("/=", Divide)
1598 CYAssignment_("%=", Modulus)
1599 CYAssignment_("+=", Add)
1600 CYAssignment_("-=", Subtract)
1601 CYAssignment_("<<=", ShiftLeft)
1602 CYAssignment_(">>=", ShiftRightSigned)
1603 CYAssignment_(">>>=", ShiftRightUnsigned)
1604 CYAssignment_("&=", BitwiseAnd)
1605 CYAssignment_("^=", BitwiseXOr)
1606 CYAssignment_("|=", BitwiseOr)
1607
1608 #endif/*CYPARSER_HPP*/