Parser.hpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2013  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU General Public License, Version 3 {{{ */
   6 /*
   7  * Cycript is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation, either version 3 of the License,
  10  * or (at your option) any later version.
  11  *
  12  * Cycript is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #ifndef CYCRIPT_PARSER_HPP
  23 #define CYCRIPT_PARSER_HPP
  24
  25 #include <iostream>
  26
  27 #include <string>
  28 #include <vector>
  29 #include <map>
  30 #include <set>
  31
  32 #include <cstdio>
  33 #include <cstdlib>
  34
  35 #include "List.hpp"
  36 #include "Pooling.hpp"
  37 #include "Options.hpp"
  38
  39 struct CYContext;
  40
  41 struct CYThing {
  42     virtual ~CYThing() {
  43     }
  44
  45     virtual void Output(struct CYOutput &out) const = 0;
  46 };
  47
  48 struct CYOutput {
  49     std::ostream &out_;
  50     CYOptions &options_;
  51     bool pretty_;
  52     unsigned indent_;
  53     bool right_;
  54
  55     enum {
  56         NoMode,
  57         NoLetter,
  58         NoPlus,
  59         NoHyphen,
  60         Terminated
  61     } mode_;
  62
  63     CYOutput(std::ostream &out, CYOptions &options) :
  64         out_(out),
  65         options_(options),
  66         pretty_(false),
  67         indent_(0),
  68         right_(false),
  69         mode_(NoMode)
  70     {
  71     }
  72
  73     void Check(char value);
  74     void Terminate();
  75
  76     CYOutput &operator <<(char rhs);
  77     CYOutput &operator <<(const char *rhs);
  78
  79     _finline CYOutput &operator <<(const CYThing *rhs) {
  80         if (rhs != NULL)
  81             rhs->Output(*this);
  82         return *this;
  83     }
  84
  85     _finline CYOutput &operator <<(const CYThing &rhs) {
  86         rhs.Output(*this);
  87         return *this;
  88     }
  89 };
  90
  91 struct CYPropertyName {
  92     virtual void PropertyName(CYOutput &out) const = 0;
  93
  94     virtual ~CYPropertyName() {
  95     }
  96 };
  97
  98 struct CYExpression;
  99 struct CYAssignment;
 100
 101 enum CYNeeded {
 102     CYNever     = -1,
 103     CYSometimes =  0,
 104     CYAlways    =  1,
 105 };
 106
 107 enum CYFlags {
 108     CYNoFlags =      0,
 109     CYNoBrace =      (1 << 0),
 110     CYNoFunction =   (1 << 1),
 111     CYNoIn =         (1 << 2),
 112     CYNoCall =       (1 << 3),
 113     CYNoRightHand =  (1 << 4),
 114     CYNoDangle =     (1 << 5),
 115     CYNoInteger =    (1 << 6),
 116     CYNoBF =         (CYNoBrace | CYNoFunction),
 117 };
 118
 119 _finline CYFlags operator ~(CYFlags rhs) {
 120     return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
 121 }
 122
 123 _finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
 124     return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
 125 }
 126
 127 _finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
 128     return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
 129 }
 130
 131 _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
 132     return lhs = lhs | rhs;
 133 }
 134
 135 _finline CYFlags CYLeft(CYFlags flags) {
 136     return flags & ~(CYNoDangle | CYNoInteger);
 137 }
 138
 139 _finline CYFlags CYRight(CYFlags flags) {
 140     return flags & ~CYNoBF;
 141 }
 142
 143 _finline CYFlags CYCenter(CYFlags flags) {
 144     return CYLeft(CYRight(flags));
 145 }
 146
 147 struct CYStatement :
 148     CYNext<CYStatement>
 149 {
 150     virtual ~CYStatement() {
 151     }
 152
 153     void Single(CYOutput &out, CYFlags flags) const;
 154     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 155
 156     virtual CYStatement *Replace(CYContext &context) = 0;
 157
 158   private:
 159     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 160 };
 161
 162 struct CYStatements {
 163     CYStatement *first_;
 164     CYStatement *last_;
 165
 166     CYStatements() :
 167         first_(NULL),
 168         last_(NULL)
 169     {
 170     }
 171
 172     operator CYStatement *() const {
 173         return first_;
 174     }
 175
 176     CYStatements &operator ->*(CYStatement *next) {
 177         if (next != NULL)
 178             if (first_ == NULL) {
 179                 first_ = next;
 180                 last_ = next;
 181             } else for (;; last_ = last_->next_)
 182                 if (last_->next_ == NULL) {
 183                     last_->next_ = next;
 184                     last_ = next;
 185                     break;
 186                 }
 187         return *this;
 188     }
 189 };
 190
 191 struct CYClassName {
 192     virtual ~CYClassName() {
 193     }
 194
 195     virtual CYExpression *ClassName(CYContext &context, bool object) = 0;
 196     virtual void ClassName(CYOutput &out, bool object) const = 0;
 197 };
 198
 199 struct CYWord :
 200     CYThing,
 201     CYPropertyName,
 202     CYClassName
 203 {
 204     const char *word_;
 205
 206     CYWord(const char *word) :
 207         word_(word)
 208     {
 209     }
 210
 211     void Set(const char *value) {
 212         word_ = value;
 213     }
 214
 215     virtual const char *Word() const;
 216     virtual void Output(CYOutput &out) const;
 217
 218     virtual CYExpression *ClassName(CYContext &context, bool object);
 219     virtual void ClassName(CYOutput &out, bool object) const;
 220     virtual void PropertyName(CYOutput &out) const;
 221 };
 222
 223 _finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) {
 224     lhs << &rhs << '=';
 225     return lhs << rhs.Word();
 226 }
 227
 228 struct CYIdentifier :
 229     CYNext<CYIdentifier>,
 230     CYWord
 231 {
 232     CYIdentifier *replace_;
 233     size_t offset_;
 234     size_t usage_;
 235
 236     CYIdentifier(const char *word) :
 237         CYWord(word),
 238         replace_(NULL),
 239         offset_(0),
 240         usage_(0)
 241     {
 242     }
 243
 244     virtual const char *Word() const;
 245     CYIdentifier *Replace(CYContext &context);
 246 };
 247
 248 struct CYComment :
 249     CYStatement
 250 {
 251     const char *value_;
 252
 253     CYComment(const char *value) :
 254         value_(value)
 255     {
 256     }
 257
 258     virtual CYStatement *Replace(CYContext &context);
 259     virtual void Output(CYOutput &out, CYFlags flags) const;
 260 };
 261
 262 struct CYLabel :
 263     CYStatement
 264 {
 265     CYIdentifier *name_;
 266     CYStatement *statement_;
 267
 268     CYLabel(CYIdentifier *name, CYStatement *statement) :
 269         name_(name),
 270         statement_(statement)
 271     {
 272     }
 273
 274     virtual CYStatement *Replace(CYContext &context);
 275     virtual void Output(CYOutput &out, CYFlags flags) const;
 276 };
 277
 278 struct CYCStringLess :
 279     std::binary_function<const char *, const char *, bool>
 280 {
 281     _finline bool operator ()(const char *lhs, const char *rhs) const {
 282         return strcmp(lhs, rhs) < 0;
 283     }
 284 };
 285
 286 struct CYIdentifierValueLess :
 287     std::binary_function<CYIdentifier *, CYIdentifier *, bool>
 288 {
 289     _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const {
 290         return CYCStringLess()(lhs->Word(), rhs->Word());
 291     }
 292 };
 293
 294 enum CYIdentifierFlags {
 295     CYIdentifierArgument,
 296     CYIdentifierVariable,
 297     CYIdentifierOther,
 298     CYIdentifierMagic,
 299     CYIdentifierCatch,
 300 };
 301
 302 typedef std::set<const char *, CYCStringLess> CYCStringSet;
 303 typedef std::set<CYIdentifier *, CYIdentifierValueLess> CYIdentifierValueSet;
 304 typedef std::map<CYIdentifier *, CYIdentifierFlags> CYIdentifierAddressFlagsMap;
 305
 306 struct CYIdentifierUsage {
 307     CYIdentifier *identifier_;
 308     size_t usage_;
 309 };
 310
 311 typedef std::vector<CYIdentifierUsage> CYIdentifierUsageVector;
 312
 313 struct CYScope {
 314     bool transparent_;
 315
 316     CYContext &context_;
 317     CYStatement *&statements_;
 318
 319     CYScope *parent_;
 320
 321     CYIdentifierAddressFlagsMap internal_;
 322     CYIdentifierValueSet identifiers_;
 323
 324     CYScope(bool transparent, CYContext &context, CYStatement *&statements);
 325     virtual ~CYScope();
 326
 327     void Close();
 328
 329     void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags);
 330     virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier);
 331     void Merge(CYContext &context, CYIdentifier *identifier);
 332     void Scope(CYContext &context, CYStatement *&statements);
 333 };
 334
 335 struct CYProgram :
 336     CYThing
 337 {
 338     CYStatement *statements_;
 339
 340     CYProgram(CYStatement *statements) :
 341         statements_(statements)
 342     {
 343     }
 344
 345     virtual void Replace(CYContext &context);
 346     virtual void Output(CYOutput &out) const;
 347 };
 348
 349 struct CYNonLocal;
 350 struct CYThisScope;
 351
 352 struct CYContext {
 353     CYOptions &options_;
 354
 355     CYScope *scope_;
 356     CYThisScope *this_;
 357
 358     CYIdentifierUsageVector rename_;
 359
 360     CYNonLocal *nonlocal_;
 361     CYNonLocal *nextlocal_;
 362     unsigned unique_;
 363
 364     CYContext(CYOptions &options) :
 365         options_(options),
 366         scope_(NULL),
 367         this_(NULL),
 368         nonlocal_(NULL),
 369         nextlocal_(NULL),
 370         unique_(0)
 371     {
 372     }
 373
 374     virtual ~CYContext() {
 375     }
 376
 377     template <typename Type_>
 378     void ReplaceAll(Type_ *&values) {
 379         Type_ **last(&values);
 380         CYForEach (next, values) {
 381             Replace(*last = next);
 382             if (*last != NULL)
 383                 last = &(*last)->next_;
 384         }
 385     }
 386
 387     template <typename Type_>
 388     void Replace(Type_ *&value) {
 389         for (;;) if (value == NULL)
 390             break;
 391         else {
 392             Type_ *replace(value->Replace(*this));
 393             if (replace != value)
 394                 value = replace;
 395             else break;
 396         }
 397     }
 398
 399     void NonLocal(CYStatement *&statements);
 400     CYIdentifier *Unique();
 401 };
 402
 403 struct CYNonLocal {
 404     CYIdentifier *identifier_;
 405
 406     CYNonLocal() :
 407         identifier_(NULL)
 408     {
 409     }
 410
 411     CYIdentifier *Target(CYContext &context) {
 412         if (identifier_ == NULL)
 413             identifier_ = context.Unique();
 414         return identifier_;
 415     }
 416 };
 417
 418 struct CYThisScope :
 419     CYNext<CYThisScope>
 420 {
 421     CYIdentifier *identifier_;
 422
 423     CYThisScope() :
 424         identifier_(NULL)
 425     {
 426     }
 427
 428     CYIdentifier *Identifier(CYContext &context) {
 429         if (next_ != NULL)
 430             return next_->Identifier(context);
 431         if (identifier_ == NULL)
 432             identifier_ = context.Unique();
 433         return identifier_;
 434     }
 435 };
 436
 437 struct CYBlock :
 438     CYStatement,
 439     CYThing
 440 {
 441     CYStatement *statements_;
 442
 443     CYBlock(CYStatement *statements) :
 444         statements_(statements)
 445     {
 446     }
 447
 448     operator CYStatement *() const {
 449         return statements_;
 450     }
 451
 452     void AddPrev(CYStatement *statement) {
 453         CYSetLast(statement) = statements_;
 454         statements_ = statement;
 455     }
 456
 457     virtual CYStatement *Replace(CYContext &context);
 458
 459     virtual void Output(CYOutput &out) const;
 460     virtual void Output(CYOutput &out, CYFlags flags) const;
 461 };
 462
 463 class CYStream :
 464     public std::istream
 465 {
 466   private:
 467     class CYBuffer :
 468         public std::streambuf
 469     {
 470       public:
 471         CYBuffer(const char *start, const char *end) {
 472             setg(const_cast<char *>(start), const_cast<char *>(start), const_cast<char *>(end));
 473         }
 474     } buffer_;
 475
 476   public:
 477     CYStream(const char *start, const char *end) :
 478         std::istream(&buffer_),
 479         buffer_(start, end)
 480     {
 481     }
 482 };
 483
 484 struct CYForInitialiser {
 485     virtual ~CYForInitialiser() {
 486     }
 487
 488     virtual CYExpression *Replace(CYContext &context) = 0;
 489     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 490 };
 491
 492 struct CYForInInitialiser {
 493     virtual ~CYForInInitialiser() {
 494     }
 495
 496     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
 497     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
 498
 499     virtual CYExpression *Replace(CYContext &context) = 0;
 500     virtual CYAssignment *Assignment(CYContext &context) = 0;
 501
 502     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 503 };
 504
 505 struct CYNumber;
 506 struct CYString;
 507
 508 struct CYExpression :
 509     CYNext<CYExpression>,
 510     CYForInitialiser,
 511     CYForInInitialiser,
 512     CYClassName,
 513     CYThing
 514 {
 515     virtual int Precedence() const = 0;
 516
 517     virtual bool RightHand() const {
 518         return true;
 519     }
 520
 521     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 522     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 523
 524     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
 525
 526     virtual void Output(CYOutput &out) const;
 527     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 528     void Output(CYOutput &out, int precedence, CYFlags flags) const;
 529
 530     virtual CYExpression *ClassName(CYContext &context, bool object);
 531     virtual void ClassName(CYOutput &out, bool object) const;
 532
 533     virtual CYExpression *Replace(CYContext &context) = 0;
 534     virtual CYAssignment *Assignment(CYContext &context);
 535
 536     virtual CYExpression *Primitive(CYContext &context) {
 537         return this;
 538     }
 539
 540     virtual CYNumber *Number(CYContext &context) {
 541         return NULL;
 542     }
 543
 544     virtual CYString *String(CYContext &context) {
 545         return NULL;
 546     }
 547
 548     virtual const char *Word() const {
 549         return NULL;
 550     }
 551 };
 552
 553 #define CYAlphabetic(value) \
 554     virtual bool Alphabetic() const { \
 555         return value; \
 556     }
 557
 558 #define CYPrecedence(value) \
 559     static const int Precedence_ = value; \
 560     virtual int Precedence() const { \
 561         return Precedence_; \
 562     }
 563
 564 #define CYRightHand(value) \
 565     virtual bool RightHand() const { \
 566         return value; \
 567     }
 568
 569 struct CYCompound :
 570     CYExpression
 571 {
 572     CYExpression *expressions_;
 573
 574     CYCompound(CYExpression *expressions = NULL) :
 575         expressions_(expressions)
 576     {
 577     }
 578
 579     void AddPrev(CYExpression *expression) {
 580         CYSetLast(expression) = expressions_;
 581         expressions_ = expression;
 582     }
 583
 584     CYPrecedence(17)
 585
 586     virtual CYExpression *Replace(CYContext &context);
 587     void Output(CYOutput &out, CYFlags flags) const;
 588
 589     virtual CYExpression *Primitive(CYContext &context);
 590 };
 591
 592 struct CYDeclaration;
 593
 594 struct CYFunctionParameter :
 595     CYNext<CYFunctionParameter>,
 596     CYThing
 597 {
 598     CYForInInitialiser *initialiser_;
 599
 600     CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) :
 601         CYNext<CYFunctionParameter>(next),
 602         initialiser_(initialiser)
 603     {
 604     }
 605
 606     void Replace(CYContext &context, CYBlock &code);
 607     void Output(CYOutput &out) const;
 608 };
 609
 610 struct CYComprehension :
 611     CYNext<CYComprehension>,
 612     CYThing
 613 {
 614     CYComprehension(CYComprehension *next = NULL) :
 615         CYNext<CYComprehension>(next)
 616     {
 617     }
 618
 619     CYComprehension *Modify(CYComprehension *next) {
 620         next_ = next;
 621         return this;
 622     }
 623
 624     virtual const char *Name() const = 0;
 625
 626     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;
 627     CYFunctionParameter *Parameters(CYContext &context) const;
 628     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 629     virtual void Output(CYOutput &out) const = 0;
 630 };
 631
 632 struct CYForInComprehension :
 633     CYComprehension
 634 {
 635     CYIdentifier *name_;
 636     CYExpression *set_;
 637
 638     CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) :
 639         CYComprehension(next),
 640         name_(name),
 641         set_(set)
 642     {
 643     }
 644
 645     virtual const char *Name() const {
 646         return name_->Word();
 647     }
 648
 649     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 650     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 651     virtual void Output(CYOutput &out) const;
 652 };
 653
 654 struct CYForOfComprehension :
 655     CYComprehension
 656 {
 657     CYIdentifier *name_;
 658     CYExpression *set_;
 659
 660     CYForOfComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) :
 661         CYComprehension(next),
 662         name_(name),
 663         set_(set)
 664     {
 665     }
 666
 667     virtual const char *Name() const {
 668         return name_->Word();
 669     }
 670
 671     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 672     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 673     virtual void Output(CYOutput &out) const;
 674 };
 675
 676 struct CYIfComprehension :
 677     CYComprehension
 678 {
 679     CYExpression *test_;
 680
 681     CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) :
 682         CYComprehension(next),
 683         test_(test)
 684     {
 685     }
 686
 687     virtual const char *Name() const {
 688         return NULL;
 689     }
 690
 691     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 692     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 693     virtual void Output(CYOutput &out) const;
 694 };
 695
 696 struct CYArrayComprehension :
 697     CYExpression
 698 {
 699     CYExpression *expression_;
 700     CYComprehension *comprehensions_;
 701
 702     CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
 703         expression_(expression),
 704         comprehensions_(comprehensions)
 705     {
 706     }
 707
 708     CYPrecedence(0)
 709
 710     virtual CYExpression *Replace(CYContext &context);
 711     virtual void Output(CYOutput &out, CYFlags flags) const;
 712 };
 713
 714 struct CYLiteral :
 715     CYExpression
 716 {
 717     CYPrecedence(0)
 718     CYRightHand(false)
 719 };
 720
 721 struct CYTrivial :
 722     CYLiteral
 723 {
 724     virtual CYExpression *Replace(CYContext &context);
 725 };
 726
 727 struct CYMagic :
 728     CYExpression
 729 {
 730     CYPrecedence(0)
 731     CYRightHand(false)
 732 };
 733
 734 struct CYRange {
 735     uint64_t lo_;
 736     uint64_t hi_;
 737
 738     CYRange(uint64_t lo, uint64_t hi) :
 739         lo_(lo), hi_(hi)
 740     {
 741     }
 742
 743     bool operator [](uint8_t value) const {
 744         return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1;
 745     }
 746
 747     void operator()(uint8_t value) {
 748         if (value >> 7)
 749             return;
 750         (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f);
 751     }
 752 };
 753
 754 extern CYRange DigitRange_;
 755 extern CYRange WordStartRange_;
 756 extern CYRange WordEndRange_;
 757
 758 struct CYString :
 759     CYTrivial,
 760     CYPropertyName
 761 {
 762     const char *value_;
 763     size_t size_;
 764
 765     CYString() :
 766         value_(NULL),
 767         size_(0)
 768     {
 769     }
 770
 771     CYString(const char *value) :
 772         value_(value),
 773         size_(strlen(value))
 774     {
 775     }
 776
 777     CYString(const char *value, size_t size) :
 778         value_(value),
 779         size_(size)
 780     {
 781     }
 782
 783     CYString(const CYWord *word) :
 784         value_(word->Word()),
 785         size_(strlen(value_))
 786     {
 787     }
 788
 789     const char *Value() const {
 790         return value_;
 791     }
 792
 793     virtual const char *Word() const;
 794
 795     virtual CYNumber *Number(CYContext &context);
 796     virtual CYString *String(CYContext &context);
 797
 798     CYString *Concat(CYContext &out, CYString *rhs) const;
 799     virtual void Output(CYOutput &out, CYFlags flags) const;
 800     virtual void PropertyName(CYOutput &out) const;
 801 };
 802
 803 struct CYNumber :
 804     CYTrivial,
 805     CYPropertyName
 806 {
 807     double value_;
 808
 809     CYNumber(double value) :
 810         value_(value)
 811     {
 812     }
 813
 814     double Value() const {
 815         return value_;
 816     }
 817
 818     virtual CYNumber *Number(CYContext &context);
 819     virtual CYString *String(CYContext &context);
 820
 821     virtual void Output(CYOutput &out, CYFlags flags) const;
 822     virtual void PropertyName(CYOutput &out) const;
 823 };
 824
 825 struct CYRegEx :
 826     CYTrivial
 827 {
 828     const char *value_;
 829
 830     CYRegEx(const char *value) :
 831         value_(value)
 832     {
 833     }
 834
 835     const char *Value() const {
 836         return value_;
 837     }
 838
 839     virtual void Output(CYOutput &out, CYFlags flags) const;
 840 };
 841
 842 struct CYNull :
 843     CYWord,
 844     CYTrivial
 845 {
 846     CYNull() :
 847         CYWord("null")
 848     {
 849     }
 850
 851     virtual CYNumber *Number(CYContext &context);
 852     virtual CYString *String(CYContext &context);
 853
 854     virtual void Output(CYOutput &out, CYFlags flags) const;
 855 };
 856
 857 struct CYThis :
 858     CYWord,
 859     CYMagic
 860 {
 861     CYThis() :
 862         CYWord("this")
 863     {
 864     }
 865
 866     virtual CYExpression *Replace(CYContext &context);
 867     virtual void Output(CYOutput &out, CYFlags flags) const;
 868 };
 869
 870 struct CYBoolean :
 871     CYTrivial
 872 {
 873     virtual bool Value() const = 0;
 874     virtual void Output(CYOutput &out, CYFlags flags) const;
 875 };
 876
 877 struct CYFalse :
 878     CYWord,
 879     CYBoolean
 880 {
 881     CYFalse() :
 882         CYWord("false")
 883     {
 884     }
 885
 886     virtual bool Value() const {
 887         return false;
 888     }
 889
 890     virtual CYNumber *Number(CYContext &context);
 891     virtual CYString *String(CYContext &context);
 892 };
 893
 894 struct CYTrue :
 895     CYWord,
 896     CYBoolean
 897 {
 898     CYTrue() :
 899         CYWord("true")
 900     {
 901     }
 902
 903     virtual bool Value() const {
 904         return true;
 905     }
 906
 907     virtual CYNumber *Number(CYContext &context);
 908     virtual CYString *String(CYContext &context);
 909 };
 910
 911 struct CYVariable :
 912     CYExpression
 913 {
 914     CYIdentifier *name_;
 915
 916     CYVariable(CYIdentifier *name) :
 917         name_(name)
 918     {
 919     }
 920
 921     CYVariable(const char *name) :
 922         name_(new($pool) CYIdentifier(name))
 923     {
 924     }
 925
 926     CYPrecedence(0)
 927     CYRightHand(false)
 928
 929     virtual CYExpression *Replace(CYContext &context);
 930     virtual void Output(CYOutput &out, CYFlags flags) const;
 931 };
 932
 933 struct CYPrefix :
 934     CYExpression
 935 {
 936     CYExpression *rhs_;
 937
 938     CYPrefix(CYExpression *rhs) :
 939         rhs_(rhs)
 940     {
 941     }
 942
 943     virtual bool Alphabetic() const = 0;
 944     virtual const char *Operator() const = 0;
 945
 946     CYPrecedence(4)
 947
 948     virtual CYExpression *Replace(CYContext &context);
 949     virtual void Output(CYOutput &out, CYFlags flags) const;
 950 };
 951
 952 struct CYInfix :
 953     CYExpression
 954 {
 955     CYExpression *lhs_;
 956     CYExpression *rhs_;
 957
 958     CYInfix(CYExpression *lhs, CYExpression *rhs) :
 959         lhs_(lhs),
 960         rhs_(rhs)
 961     {
 962     }
 963
 964     void SetLeft(CYExpression *lhs) {
 965         lhs_ = lhs;
 966     }
 967
 968     virtual bool Alphabetic() const = 0;
 969     virtual const char *Operator() const = 0;
 970
 971     virtual CYExpression *Replace(CYContext &context);
 972     virtual void Output(CYOutput &out, CYFlags flags) const;
 973 };
 974
 975 struct CYPostfix :
 976     CYExpression
 977 {
 978     CYExpression *lhs_;
 979
 980     CYPostfix(CYExpression *lhs) :
 981         lhs_(lhs)
 982     {
 983     }
 984
 985     virtual const char *Operator() const = 0;
 986
 987     CYPrecedence(3)
 988
 989     virtual CYExpression *Replace(CYContext &context);
 990     virtual void Output(CYOutput &out, CYFlags flags) const;
 991 };
 992
 993 struct CYAssignment :
 994     CYExpression
 995 {
 996     CYExpression *lhs_;
 997     CYExpression *rhs_;
 998
 999     CYAssignment(CYExpression *lhs, CYExpression *rhs) :
1000         lhs_(lhs),
1001         rhs_(rhs)
1002     {
1003     }
1004
1005     void SetLeft(CYExpression *lhs) {
1006         lhs_ = lhs;
1007     }
1008
1009     virtual const char *Operator() const = 0;
1010
1011     CYPrecedence(16)
1012
1013     virtual CYExpression *Replace(CYContext &context);
1014     virtual void Output(CYOutput &out, CYFlags flags) const;
1015 };
1016
1017 struct CYArgument :
1018     CYNext<CYArgument>,
1019     CYThing
1020 {
1021     CYWord *name_;
1022     CYExpression *value_;
1023
1024     CYArgument(CYExpression *value, CYArgument *next = NULL) :
1025         CYNext<CYArgument>(next),
1026         name_(NULL),
1027         value_(value)
1028     {
1029     }
1030
1031     CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
1032         CYNext<CYArgument>(next),
1033         name_(name),
1034         value_(value)
1035     {
1036     }
1037
1038     CYArgument *Replace(CYContext &context);
1039     void Output(CYOutput &out) const;
1040 };
1041
1042 struct CYBlank :
1043     public CYWord
1044 {
1045     CYBlank() :
1046         CYWord("")
1047     {
1048     }
1049 };
1050
1051 struct CYClause :
1052     CYThing,
1053     CYNext<CYClause>
1054 {
1055     CYExpression *case_;
1056     CYStatement *statements_;
1057
1058     CYClause(CYExpression *_case, CYStatement *statements) :
1059         case_(_case),
1060         statements_(statements)
1061     {
1062     }
1063
1064     void Replace(CYContext &context);
1065     virtual void Output(CYOutput &out) const;
1066 };
1067
1068 struct CYElement :
1069     CYNext<CYElement>,
1070     CYThing
1071 {
1072     CYExpression *value_;
1073
1074     CYElement(CYExpression *value, CYElement *next) :
1075         CYNext<CYElement>(next),
1076         value_(value)
1077     {
1078     }
1079
1080     void Replace(CYContext &context);
1081     void Output(CYOutput &out) const;
1082 };
1083
1084 struct CYArray :
1085     CYLiteral
1086 {
1087     CYElement *elements_;
1088
1089     CYArray(CYElement *elements = NULL) :
1090         elements_(elements)
1091     {
1092     }
1093
1094     virtual CYExpression *Replace(CYContext &context);
1095     virtual void Output(CYOutput &out, CYFlags flags) const;
1096 };
1097
1098 struct CYProperty :
1099     CYNext<CYProperty>,
1100     CYThing
1101 {
1102     CYPropertyName *name_;
1103     CYExpression *value_;
1104
1105     CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
1106         CYNext<CYProperty>(next),
1107         name_(name),
1108         value_(value)
1109     {
1110     }
1111
1112     void Replace(CYContext &context);
1113     virtual void Output(CYOutput &out) const;
1114 };
1115
1116 struct CYDeclaration :
1117     CYForInInitialiser
1118 {
1119     CYIdentifier *identifier_;
1120     CYExpression *initialiser_;
1121
1122     CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) :
1123         identifier_(identifier),
1124         initialiser_(initialiser)
1125     {
1126     }
1127
1128     virtual void ForIn(CYOutput &out, CYFlags flags) const;
1129     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
1130
1131     virtual CYExpression *Replace(CYContext &context);
1132
1133     virtual CYAssignment *Assignment(CYContext &context);
1134     CYVariable *Variable(CYContext &context);
1135
1136     virtual void Output(CYOutput &out, CYFlags flags) const;
1137 };
1138
1139 struct CYDeclarations :
1140     CYNext<CYDeclarations>,
1141     CYThing
1142 {
1143     CYDeclaration *declaration_;
1144
1145     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
1146         CYNext<CYDeclarations>(next),
1147         declaration_(declaration)
1148     {
1149     }
1150
1151     void Replace(CYContext &context);
1152
1153     CYCompound *Compound(CYContext &context);
1154     CYProperty *Property(CYContext &context);
1155     CYArgument *Argument(CYContext &context);
1156     CYFunctionParameter *Parameter(CYContext &context);
1157
1158     virtual void Output(CYOutput &out) const;
1159     virtual void Output(CYOutput &out, CYFlags flags) const;
1160 };
1161
1162 struct CYForDeclarations :
1163     CYForInitialiser
1164 {
1165     CYDeclarations *declarations_;
1166
1167     CYForDeclarations(CYDeclarations *declarations) :
1168         declarations_(declarations)
1169     {
1170     }
1171
1172     virtual CYCompound *Replace(CYContext &context);
1173     virtual void Output(CYOutput &out, CYFlags flags) const;
1174 };
1175
1176 struct CYVar :
1177     CYStatement
1178 {
1179     CYDeclarations *declarations_;
1180
1181     CYVar(CYDeclarations *declarations) :
1182         declarations_(declarations)
1183     {
1184     }
1185
1186     virtual CYStatement *Replace(CYContext &context);
1187     virtual void Output(CYOutput &out, CYFlags flags) const;
1188 };
1189
1190 struct CYLetStatement :
1191     CYStatement
1192 {
1193     CYDeclarations *declarations_;
1194     CYStatement *code_;
1195
1196     CYLetStatement(CYDeclarations *declarations, CYStatement *code) :
1197         declarations_(declarations),
1198         code_(code)
1199     {
1200     }
1201
1202     virtual CYStatement *Replace(CYContext &context);
1203     virtual void Output(CYOutput &out, CYFlags flags) const;
1204 };
1205
1206 struct CYFor :
1207     CYStatement
1208 {
1209     CYForInitialiser *initialiser_;
1210     CYExpression *test_;
1211     CYExpression *increment_;
1212     CYStatement *code_;
1213
1214     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
1215         initialiser_(initialiser),
1216         test_(test),
1217         increment_(increment),
1218         code_(code)
1219     {
1220     }
1221
1222     virtual CYStatement *Replace(CYContext &context);
1223     virtual void Output(CYOutput &out, CYFlags flags) const;
1224 };
1225
1226 struct CYForIn :
1227     CYStatement
1228 {
1229     CYForInInitialiser *initialiser_;
1230     CYExpression *set_;
1231     CYStatement *code_;
1232
1233     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1234         initialiser_(initialiser),
1235         set_(set),
1236         code_(code)
1237     {
1238     }
1239
1240     virtual CYStatement *Replace(CYContext &context);
1241     virtual void Output(CYOutput &out, CYFlags flags) const;
1242 };
1243
1244 struct CYForOf :
1245     CYStatement
1246 {
1247     CYForInInitialiser *initialiser_;
1248     CYExpression *set_;
1249     CYStatement *code_;
1250
1251     CYForOf(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1252         initialiser_(initialiser),
1253         set_(set),
1254         code_(code)
1255     {
1256     }
1257
1258     virtual CYStatement *Replace(CYContext &context);
1259     virtual void Output(CYOutput &out, CYFlags flags) const;
1260 };
1261
1262 struct CYObject :
1263     CYLiteral
1264 {
1265     CYProperty *properties_;
1266
1267     CYObject(CYProperty *properties = NULL) :
1268         properties_(properties)
1269     {
1270     }
1271
1272     virtual CYExpression *Replace(CYContext &context);
1273     void Output(CYOutput &out, CYFlags flags) const;
1274 };
1275
1276 struct CYMember :
1277     CYExpression
1278 {
1279     CYExpression *object_;
1280     CYExpression *property_;
1281
1282     CYMember(CYExpression *object, CYExpression *property) :
1283         object_(object),
1284         property_(property)
1285     {
1286     }
1287
1288     void SetLeft(CYExpression *object) {
1289         object_ = object;
1290     }
1291 };
1292
1293 struct CYDirectMember :
1294     CYMember
1295 {
1296     CYDirectMember(CYExpression *object, CYExpression *property) :
1297         CYMember(object, property)
1298     {
1299     }
1300
1301     CYPrecedence(1)
1302     CYRightHand(false)
1303
1304     virtual CYExpression *Replace(CYContext &context);
1305     virtual void Output(CYOutput &out, CYFlags flags) const;
1306 };
1307
1308 struct CYIndirectMember :
1309     CYMember
1310 {
1311     CYIndirectMember(CYExpression *object, CYExpression *property) :
1312         CYMember(object, property)
1313     {
1314     }
1315
1316     CYPrecedence(1)
1317     CYRightHand(false)
1318
1319     virtual CYExpression *Replace(CYContext &context);
1320     virtual void Output(CYOutput &out, CYFlags flags) const;
1321 };
1322
1323 namespace cy {
1324 namespace Syntax {
1325
1326 struct New :
1327     CYExpression
1328 {
1329     CYExpression *constructor_;
1330     CYArgument *arguments_;
1331
1332     New(CYExpression *constructor, CYArgument *arguments) :
1333         constructor_(constructor),
1334         arguments_(arguments)
1335     {
1336     }
1337
1338     virtual int Precedence() const {
1339         return arguments_ == NULL ? 2 : 1;
1340     }
1341
1342     CYRightHand(false)
1343
1344     virtual CYExpression *Replace(CYContext &context);
1345     virtual void Output(CYOutput &out, CYFlags flags) const;
1346
1347     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1348 };
1349
1350 } }
1351
1352 struct CYCall :
1353     CYExpression
1354 {
1355     CYExpression *function_;
1356     CYArgument *arguments_;
1357
1358     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1359         function_(function),
1360         arguments_(arguments)
1361     {
1362     }
1363
1364     CYPrecedence(1)
1365     CYRightHand(false)
1366
1367     virtual CYExpression *Replace(CYContext &context);
1368     virtual void Output(CYOutput &out, CYFlags flags) const;
1369
1370     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1371 };
1372
1373 struct CYRubyProc;
1374
1375 struct CYRubyBlock :
1376     CYExpression
1377 {
1378     CYExpression *call_;
1379     CYRubyProc *proc_;
1380
1381     CYRubyBlock(CYExpression *call, CYRubyProc *proc) :
1382         call_(call),
1383         proc_(proc)
1384     {
1385     }
1386
1387     CYPrecedence(1)
1388     CYRightHand(false)
1389
1390     virtual CYExpression *Replace(CYContext &context);
1391     virtual void Output(CYOutput &out, CYFlags flags) const;
1392 };
1393
1394 struct CYIf :
1395     CYStatement
1396 {
1397     CYExpression *test_;
1398     CYStatement *true_;
1399     CYStatement *false_;
1400
1401     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1402         test_(test),
1403         true_(_true),
1404         false_(_false)
1405     {
1406     }
1407
1408     virtual CYStatement *Replace(CYContext &context);
1409     virtual void Output(CYOutput &out, CYFlags flags) const;
1410 };
1411
1412 struct CYDoWhile :
1413     CYStatement
1414 {
1415     CYExpression *test_;
1416     CYStatement *code_;
1417
1418     CYDoWhile(CYExpression *test, CYStatement *code) :
1419         test_(test),
1420         code_(code)
1421     {
1422     }
1423
1424     virtual CYStatement *Replace(CYContext &context);
1425     virtual void Output(CYOutput &out, CYFlags flags) const;
1426 };
1427
1428 struct CYWhile :
1429     CYStatement
1430 {
1431     CYExpression *test_;
1432     CYStatement *code_;
1433
1434     CYWhile(CYExpression *test, CYStatement *code) :
1435         test_(test),
1436         code_(code)
1437     {
1438     }
1439
1440     virtual CYStatement *Replace(CYContext &context);
1441     virtual void Output(CYOutput &out, CYFlags flags) const;
1442 };
1443
1444 // XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass)
1445 struct CYFunction {
1446     CYIdentifier *name_;
1447     CYFunctionParameter *parameters_;
1448     CYBlock code_;
1449
1450     CYNonLocal *nonlocal_;
1451     CYThisScope this_;
1452
1453     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1454         name_(name),
1455         parameters_(parameters),
1456         code_(statements),
1457         nonlocal_(NULL)
1458     {
1459     }
1460
1461     virtual ~CYFunction() {
1462     }
1463
1464     void Inject(CYContext &context);
1465     virtual void Replace_(CYContext &context, bool outer);
1466     virtual void Output(CYOutput &out, CYFlags flags) const;
1467 };
1468
1469 // XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression
1470 struct CYFunctionExpression :
1471     CYFunction,
1472     CYExpression
1473 {
1474     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1475         CYFunction(name, parameters, statements)
1476     {
1477     }
1478
1479     CYPrecedence(0)
1480     CYRightHand(false)
1481
1482     virtual CYExpression *Replace(CYContext &context);
1483     virtual void Output(CYOutput &out, CYFlags flags) const;
1484 };
1485
1486 // XXX: this should derive from CYAnonymousFunction
1487 struct CYFatArrow :
1488     CYFunction,
1489     CYExpression
1490 {
1491     CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) :
1492         CYFunction(NULL, parameters, statements)
1493     {
1494     }
1495
1496     CYPrecedence(0)
1497     CYRightHand(false)
1498
1499     virtual CYExpression *Replace(CYContext &context);
1500     virtual void Output(CYOutput &out, CYFlags flags) const;
1501 };
1502
1503 // XXX: this should derive from CYAnonymousFunctionExpression
1504 struct CYRubyProc :
1505     CYFunctionExpression
1506 {
1507     CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) :
1508         CYFunctionExpression(NULL, parameters, statements)
1509     {
1510     }
1511
1512     virtual CYExpression *Replace(CYContext &context);
1513     virtual void Output(CYOutput &out, CYFlags flags) const;
1514 };
1515
1516 // XXX: this should derive from CYNamedFunction
1517 struct CYFunctionStatement :
1518     CYFunction,
1519     CYStatement
1520 {
1521     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1522         CYFunction(name, parameters, statements)
1523     {
1524     }
1525
1526     virtual CYStatement *Replace(CYContext &context);
1527     virtual void Output(CYOutput &out, CYFlags flags) const;
1528 };
1529
1530 struct CYExpress :
1531     CYStatement
1532 {
1533     CYExpression *expression_;
1534
1535     CYExpress(CYExpression *expression) :
1536         expression_(expression)
1537     {
1538         if (expression == NULL)
1539             throw;
1540     }
1541
1542     virtual CYStatement *Replace(CYContext &context);
1543     virtual void Output(CYOutput &out, CYFlags flags) const;
1544 };
1545
1546 struct CYContinue :
1547     CYStatement
1548 {
1549     CYIdentifier *label_;
1550
1551     CYContinue(CYIdentifier *label) :
1552         label_(label)
1553     {
1554     }
1555
1556     virtual CYStatement *Replace(CYContext &context);
1557     virtual void Output(CYOutput &out, CYFlags flags) const;
1558 };
1559
1560 struct CYBreak :
1561     CYStatement
1562 {
1563     CYIdentifier *label_;
1564
1565     CYBreak(CYIdentifier *label) :
1566         label_(label)
1567     {
1568     }
1569
1570     virtual CYStatement *Replace(CYContext &context);
1571     virtual void Output(CYOutput &out, CYFlags flags) const;
1572 };
1573
1574 struct CYReturn :
1575     CYStatement
1576 {
1577     CYExpression *value_;
1578
1579     CYReturn(CYExpression *value) :
1580         value_(value)
1581     {
1582     }
1583
1584     virtual CYStatement *Replace(CYContext &context);
1585     virtual void Output(CYOutput &out, CYFlags flags) const;
1586 };
1587
1588 struct CYEmpty :
1589     CYStatement
1590 {
1591     virtual CYStatement *Replace(CYContext &context);
1592     virtual void Output(CYOutput &out, CYFlags flags) const;
1593 };
1594
1595 struct CYFinally :
1596     CYThing
1597 {
1598     CYBlock code_;
1599
1600     CYFinally(CYStatement *statements) :
1601         code_(statements)
1602     {
1603     }
1604
1605     void Replace(CYContext &context);
1606     virtual void Output(CYOutput &out) const;
1607 };
1608
1609 struct CYTypeModifier :
1610     CYNext<CYTypeModifier>
1611 {
1612     CYTypeModifier(CYTypeModifier *next) :
1613         CYNext<CYTypeModifier>(next)
1614     {
1615     }
1616
1617     virtual int Precedence() const = 0;
1618
1619     virtual CYExpression *Replace_(CYContext &context, CYExpression *type) = 0;
1620     CYExpression *Replace(CYContext &context, CYExpression *type);
1621
1622     virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0;
1623     void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const;
1624 };
1625
1626 struct CYTypeArrayOf :
1627     CYTypeModifier
1628 {
1629     CYExpression *size_;
1630
1631     CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) :
1632         CYTypeModifier(next),
1633         size_(size)
1634     {
1635     }
1636
1637     CYPrecedence(1)
1638
1639     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1640     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1641 };
1642
1643 struct CYTypeConstant :
1644     CYTypeModifier
1645 {
1646     CYTypeConstant(CYTypeModifier *next = NULL) :
1647         CYTypeModifier(next)
1648     {
1649     }
1650
1651     CYPrecedence(0)
1652
1653     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1654     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1655 };
1656
1657 struct CYTypePointerTo :
1658     CYTypeModifier
1659 {
1660     CYTypePointerTo(CYTypeModifier *next = NULL) :
1661         CYTypeModifier(next)
1662     {
1663     }
1664
1665     CYPrecedence(0)
1666
1667     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1668     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1669 };
1670
1671 struct CYTypeVolatile :
1672     CYTypeModifier
1673 {
1674     CYTypeVolatile(CYTypeModifier *next = NULL) :
1675         CYTypeModifier(next)
1676     {
1677     }
1678
1679     CYPrecedence(0)
1680
1681     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1682     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1683 };
1684
1685 struct CYTypedIdentifier :
1686     CYNext<CYTypedIdentifier>,
1687     CYThing
1688 {
1689     CYIdentifier *identifier_;
1690     CYExpression *type_;
1691     CYTypeModifier *modifier_;
1692
1693     CYTypedIdentifier(CYIdentifier *identifier = NULL) :
1694         identifier_(identifier),
1695         type_(NULL),
1696         modifier_(NULL)
1697     {
1698     }
1699
1700     CYTypedIdentifier(CYExpression *type, CYTypeModifier *modifier = NULL) :
1701         identifier_(NULL),
1702         type_(type),
1703         modifier_(modifier)
1704     {
1705     }
1706
1707     inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) {
1708         CYSetLast(modifier_) = modifier;
1709         return this;
1710     }
1711
1712     virtual CYExpression *Replace(CYContext &context);
1713     virtual void Output(CYOutput &out) const;
1714 };
1715
1716 struct CYEncodedType :
1717     CYExpression
1718 {
1719     CYTypedIdentifier *typed_;
1720
1721     CYEncodedType(CYTypedIdentifier *typed) :
1722         typed_(typed)
1723     {
1724     }
1725
1726     CYPrecedence(1)
1727
1728     virtual CYExpression *Replace(CYContext &context);
1729     virtual void Output(CYOutput &out, CYFlags flags) const;
1730 };
1731
1732 struct CYTypedParameter :
1733     CYNext<CYTypedParameter>,
1734     CYThing
1735 {
1736     CYTypedIdentifier *typed_;
1737
1738     CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) :
1739         CYNext<CYTypedParameter>(next),
1740         typed_(typed)
1741     {
1742     }
1743
1744     CYArgument *Argument(CYContext &context);
1745     CYFunctionParameter *Parameters(CYContext &context);
1746     CYExpression *TypeSignature(CYContext &context, CYExpression *prefix);
1747
1748     virtual void Output(CYOutput &out) const;
1749 };
1750
1751 struct CYLambda :
1752     CYExpression
1753 {
1754     CYTypedIdentifier *typed_;
1755     CYTypedParameter *parameters_;
1756     CYStatement *statements_;
1757
1758     CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
1759         typed_(typed),
1760         parameters_(parameters),
1761         statements_(statements)
1762     {
1763     }
1764
1765     CYPrecedence(1)
1766
1767     virtual CYExpression *Replace(CYContext &context);
1768     virtual void Output(CYOutput &out, CYFlags flags) const;
1769 };
1770
1771 struct CYTypeDefinition :
1772     CYStatement
1773 {
1774     CYTypedIdentifier *typed_;
1775
1776     CYTypeDefinition(CYTypedIdentifier *typed) :
1777         typed_(typed)
1778     {
1779     }
1780
1781     virtual CYStatement *Replace(CYContext &context);
1782     virtual void Output(CYOutput &out, CYFlags flags) const;
1783 };
1784
1785 struct CYTypeBlockWith :
1786     CYTypeModifier
1787 {
1788     CYTypedParameter *parameters_;
1789
1790     CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
1791         CYTypeModifier(next),
1792         parameters_(parameters)
1793     {
1794     }
1795
1796     CYPrecedence(0)
1797
1798     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1799     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1800 };
1801
1802 struct CYTypeFunctionWith :
1803     CYTypeModifier
1804 {
1805     CYTypedParameter *parameters_;
1806
1807     CYTypeFunctionWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
1808         CYTypeModifier(next),
1809         parameters_(parameters)
1810     {
1811     }
1812
1813     CYPrecedence(1)
1814
1815     virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
1816     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
1817 };
1818
1819 namespace cy {
1820 namespace Syntax {
1821
1822 struct Catch :
1823     CYThing
1824 {
1825     CYIdentifier *name_;
1826     CYBlock code_;
1827
1828     Catch(CYIdentifier *name, CYStatement *statements) :
1829         name_(name),
1830         code_(statements)
1831     {
1832     }
1833
1834     void Replace(CYContext &context);
1835     virtual void Output(CYOutput &out) const;
1836 };
1837
1838 struct Try :
1839     CYStatement
1840 {
1841     CYBlock code_;
1842     Catch *catch_;
1843     CYFinally *finally_;
1844
1845     Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
1846         code_(statements),
1847         catch_(_catch),
1848         finally_(finally)
1849     {
1850     }
1851
1852     virtual CYStatement *Replace(CYContext &context);
1853     virtual void Output(CYOutput &out, CYFlags flags) const;
1854 };
1855
1856 struct Throw :
1857     CYStatement
1858 {
1859     CYExpression *value_;
1860
1861     Throw(CYExpression *value = NULL) :
1862         value_(value)
1863     {
1864     }
1865
1866     virtual CYStatement *Replace(CYContext &context);
1867     virtual void Output(CYOutput &out, CYFlags flags) const;
1868 };
1869
1870 } }
1871
1872 struct CYWith :
1873     CYStatement
1874 {
1875     CYExpression *scope_;
1876     CYStatement *code_;
1877
1878     CYWith(CYExpression *scope, CYStatement *code) :
1879         scope_(scope),
1880         code_(code)
1881     {
1882     }
1883
1884     virtual CYStatement *Replace(CYContext &context);
1885     virtual void Output(CYOutput &out, CYFlags flags) const;
1886 };
1887
1888 struct CYSwitch :
1889     CYStatement
1890 {
1891     CYExpression *value_;
1892     CYClause *clauses_;
1893
1894     CYSwitch(CYExpression *value, CYClause *clauses) :
1895         value_(value),
1896         clauses_(clauses)
1897     {
1898     }
1899
1900     virtual CYStatement *Replace(CYContext &context);
1901     virtual void Output(CYOutput &out, CYFlags flags) const;
1902 };
1903
1904 struct CYDebugger :
1905     CYStatement
1906 {
1907     CYDebugger()
1908     {
1909     }
1910
1911     virtual CYStatement *Replace(CYContext &context);
1912     virtual void Output(CYOutput &out, CYFlags flags) const;
1913 };
1914
1915 struct CYCondition :
1916     CYExpression
1917 {
1918     CYExpression *test_;
1919     CYExpression *true_;
1920     CYExpression *false_;
1921
1922     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1923         test_(test),
1924         true_(_true),
1925         false_(_false)
1926     {
1927     }
1928
1929     CYPrecedence(15)
1930
1931     virtual CYExpression *Replace(CYContext &context);
1932     virtual void Output(CYOutput &out, CYFlags flags) const;
1933 };
1934
1935 struct CYAddressOf :
1936     CYPrefix
1937 {
1938     CYAddressOf(CYExpression *rhs) :
1939         CYPrefix(rhs)
1940     {
1941     }
1942
1943     virtual const char *Operator() const {
1944         return "&";
1945     }
1946
1947     CYAlphabetic(false)
1948
1949     virtual CYExpression *Replace(CYContext &context);
1950 };
1951
1952 struct CYIndirect :
1953     CYPrefix
1954 {
1955     CYIndirect(CYExpression *rhs) :
1956         CYPrefix(rhs)
1957     {
1958     }
1959
1960     virtual const char *Operator() const {
1961         return "*";
1962     }
1963
1964     CYAlphabetic(false)
1965
1966     virtual CYExpression *Replace(CYContext &context);
1967 };
1968
1969 #define CYReplace \
1970     virtual CYExpression *Replace(CYContext &context);
1971
1972 #define CYPostfix_(op, name, args...) \
1973     struct CY ## name : \
1974         CYPostfix \
1975     { args \
1976         CY ## name(CYExpression *lhs) : \
1977             CYPostfix(lhs) \
1978         { \
1979         } \
1980     \
1981         virtual const char *Operator() const { \
1982             return op; \
1983         } \
1984     };
1985
1986 #define CYPrefix_(alphabetic, op, name, args...) \
1987     struct CY ## name : \
1988         CYPrefix \
1989     { args \
1990         CY ## name(CYExpression *rhs) : \
1991             CYPrefix(rhs) \
1992         { \
1993         } \
1994     \
1995         CYAlphabetic(alphabetic) \
1996     \
1997         virtual const char *Operator() const { \
1998             return op; \
1999         } \
2000     };
2001
2002 #define CYInfix_(alphabetic, precedence, op, name, args...) \
2003     struct CY ## name : \
2004         CYInfix \
2005     { args \
2006         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
2007             CYInfix(lhs, rhs) \
2008         { \
2009         } \
2010     \
2011         CYAlphabetic(alphabetic) \
2012         CYPrecedence(precedence) \
2013     \
2014         virtual const char *Operator() const { \
2015             return op; \
2016         } \
2017     };
2018
2019 #define CYAssignment_(op, name, args...) \
2020     struct CY ## name ## Assign : \
2021         CYAssignment \
2022     { args \
2023         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
2024             CYAssignment(lhs, rhs) \
2025         { \
2026         } \
2027     \
2028         virtual const char *Operator() const { \
2029             return op; \
2030         } \
2031     };
2032
2033 CYPostfix_("++", PostIncrement)
2034 CYPostfix_("--", PostDecrement)
2035
2036 CYPrefix_(true, "delete", Delete)
2037 CYPrefix_(true, "void", Void)
2038 CYPrefix_(true, "typeof", TypeOf)
2039 CYPrefix_(false, "++", PreIncrement)
2040 CYPrefix_(false, "--", PreDecrement)
2041 CYPrefix_(false, "+", Affirm)
2042 CYPrefix_(false, "-", Negate)
2043 CYPrefix_(false, "~", BitwiseNot)
2044 CYPrefix_(false, "!", LogicalNot)
2045
2046 CYInfix_(false, 5, "*", Multiply)
2047 CYInfix_(false, 5, "/", Divide)
2048 CYInfix_(false, 5, "%", Modulus)
2049 CYInfix_(false, 6, "+", Add, CYReplace)
2050 CYInfix_(false, 6, "-", Subtract)
2051 CYInfix_(false, 7, "<<", ShiftLeft)
2052 CYInfix_(false, 7, ">>", ShiftRightSigned)
2053 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
2054 CYInfix_(false, 8, "<", Less)
2055 CYInfix_(false, 8, ">", Greater)
2056 CYInfix_(false, 8, "<=", LessOrEqual)
2057 CYInfix_(false, 8, ">=", GreaterOrEqual)
2058 CYInfix_(true, 8, "instanceof", InstanceOf)
2059 CYInfix_(true, 8, "in", In)
2060 CYInfix_(false, 9, "==", Equal)
2061 CYInfix_(false, 9, "!=", NotEqual)
2062 CYInfix_(false, 9, "===", Identical)
2063 CYInfix_(false, 9, "!==", NotIdentical)
2064 CYInfix_(false, 10, "&", BitwiseAnd)
2065 CYInfix_(false, 11, "^", BitwiseXOr)
2066 CYInfix_(false, 12, "|", BitwiseOr)
2067 CYInfix_(false, 13, "&&", LogicalAnd)
2068 CYInfix_(false, 14, "||", LogicalOr)
2069
2070 CYAssignment_("=", )
2071 CYAssignment_("*=", Multiply)
2072 CYAssignment_("/=", Divide)
2073 CYAssignment_("%=", Modulus)
2074 CYAssignment_("+=", Add)
2075 CYAssignment_("-=", Subtract)
2076 CYAssignment_("<<=", ShiftLeft)
2077 CYAssignment_(">>=", ShiftRightSigned)
2078 CYAssignment_(">>>=", ShiftRightUnsigned)
2079 CYAssignment_("&=", BitwiseAnd)
2080 CYAssignment_("^=", BitwiseXOr)
2081 CYAssignment_("|=", BitwiseOr)
2082
2083 #endif/*CYCRIPT_PARSER_HPP*/