Parser.hpp

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