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 void For(CYOutput &out) const = 0;
 534     virtual CYExpression *Replace(CYContext &context) = 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 For(CYOutput &out) const;
 565     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 566     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 567
 568     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
 569
 570     virtual void Output(CYOutput &out) const;
 571     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 572     void Output(CYOutput &out, unsigned precedence, CYFlags flags) const;
 573
 574     virtual CYExpression *ClassName(CYContext &context, bool object);
 575     virtual void ClassName(CYOutput &out, bool object) const;
 576
 577     virtual CYExpression *Replace(CYContext &context) = 0;
 578     virtual CYAssignment *Assignment(CYContext &context);
 579
 580     virtual CYExpression *Primitive(CYContext &context) {
 581         return this;
 582     }
 583
 584     virtual CYNumber *Number(CYContext &context) {
 585         return NULL;
 586     }
 587
 588     virtual CYString *String(CYContext &context) {
 589         return NULL;
 590     }
 591
 592     virtual const char *Word() const {
 593         return NULL;
 594     }
 595 };
 596
 597 #define CYAlphabetic(value) \
 598     virtual bool Alphabetic() const { \
 599         return value; \
 600     }
 601
 602 #define CYPrecedence(value) \
 603     static const unsigned Precedence_ = value; \
 604     virtual unsigned Precedence() const { \
 605         return Precedence_; \
 606     }
 607
 608 #define CYRightHand(value) \
 609     virtual bool RightHand() const { \
 610         return value; \
 611     }
 612
 613 struct CYCompound :
 614     CYExpression
 615 {
 616     CYExpression *expressions_;
 617
 618     CYCompound(CYExpression *expressions = NULL) :
 619         expressions_(expressions)
 620     {
 621     }
 622
 623     void AddPrev(CYExpression *expression) {
 624         CYSetLast(expression, expressions_);
 625         expressions_ = expression;
 626     }
 627
 628     CYPrecedence(17)
 629
 630     virtual CYExpression *Replace(CYContext &context);
 631     void Output(CYOutput &out, CYFlags flags) const;
 632 };
 633
 634 struct CYFunctionParameter :
 635     CYNext<CYFunctionParameter>,
 636     CYThing
 637 {
 638     CYIdentifier *name_;
 639
 640     CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) :
 641         CYNext<CYFunctionParameter>(next),
 642         name_(name)
 643     {
 644     }
 645
 646     virtual CYFunctionParameter *Replace(CYContext &context, CYBlock &code);
 647     virtual void Output(CYOutput &out) const;
 648 };
 649
 650 struct CYOptionalFunctionParameter :
 651     CYFunctionParameter
 652 {
 653     CYExpression *initializer_;
 654
 655     CYOptionalFunctionParameter(CYIdentifier *name, CYExpression *initializer, CYFunctionParameter *next = NULL) :
 656         CYFunctionParameter(name, next),
 657         initializer_(initializer)
 658     {
 659     }
 660
 661     virtual CYFunctionParameter *Replace(CYContext &context, CYBlock &code);
 662     virtual void Output(CYOutput &out) const;
 663 };
 664
 665 struct CYComprehension :
 666     CYNext<CYComprehension>,
 667     CYThing
 668 {
 669     virtual const char *Name() const = 0;
 670
 671     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;
 672     CYFunctionParameter *Parameters(CYContext &context) const;
 673     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 674     virtual void Output(CYOutput &out) const = 0;
 675 };
 676
 677 struct CYForInComprehension :
 678     CYComprehension
 679 {
 680     CYIdentifier *name_;
 681     CYExpression *set_;
 682
 683     CYForInComprehension(CYIdentifier *name, CYExpression *set) :
 684         name_(name),
 685         set_(set)
 686     {
 687     }
 688
 689     virtual const char *Name() const {
 690         return name_->Word();
 691     }
 692
 693     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 694     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 695     virtual void Output(CYOutput &out) const;
 696 };
 697
 698 struct CYForEachInComprehension :
 699     CYComprehension
 700 {
 701     CYIdentifier *name_;
 702     CYExpression *set_;
 703
 704     CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
 705         name_(name),
 706         set_(set)
 707     {
 708     }
 709
 710     virtual const char *Name() const {
 711         return name_->Word();
 712     }
 713
 714     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 715     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 716     virtual void Output(CYOutput &out) const;
 717 };
 718
 719 struct CYIfComprehension :
 720     CYComprehension
 721 {
 722     CYExpression *test_;
 723
 724     CYIfComprehension(CYExpression *test) :
 725         test_(test)
 726     {
 727     }
 728
 729     virtual const char *Name() const {
 730         return NULL;
 731     }
 732
 733     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 734     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 735     virtual void Output(CYOutput &out) const;
 736 };
 737
 738 struct CYArrayComprehension :
 739     CYExpression
 740 {
 741     CYExpression *expression_;
 742     CYComprehension *comprehensions_;
 743
 744     CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
 745         expression_(expression),
 746         comprehensions_(comprehensions)
 747     {
 748     }
 749
 750     CYPrecedence(0)
 751
 752     virtual CYExpression *Replace(CYContext &context);
 753     virtual void Output(CYOutput &out, CYFlags flags) const;
 754 };
 755
 756 struct CYLiteral :
 757     CYExpression
 758 {
 759     CYPrecedence(0)
 760     CYRightHand(false)
 761 };
 762
 763 struct CYTrivial :
 764     CYLiteral
 765 {
 766     virtual CYExpression *Replace(CYContext &context);
 767 };
 768
 769 struct CYMagic :
 770     CYExpression
 771 {
 772     CYPrecedence(0)
 773     CYRightHand(false)
 774 };
 775
 776 struct CYRange {
 777     uint64_t lo_;
 778     uint64_t hi_;
 779
 780     CYRange(uint64_t lo, uint64_t hi) :
 781         lo_(lo), hi_(hi)
 782     {
 783     }
 784
 785     bool operator [](uint8_t value) const {
 786         return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1;
 787     }
 788
 789     void operator()(uint8_t value) {
 790         if (value >> 7)
 791             return;
 792         (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f);
 793     }
 794 };
 795
 796 extern CYRange DigitRange_;
 797 extern CYRange WordStartRange_;
 798 extern CYRange WordEndRange_;
 799
 800 struct CYString :
 801     CYTrivial,
 802     CYPropertyName
 803 {
 804     const char *value_;
 805     size_t size_;
 806
 807     CYString() :
 808         value_(NULL),
 809         size_(0)
 810     {
 811     }
 812
 813     CYString(const char *value) :
 814         value_(value),
 815         size_(strlen(value))
 816     {
 817     }
 818
 819     CYString(const char *value, size_t size) :
 820         value_(value),
 821         size_(size)
 822     {
 823     }
 824
 825     CYString(const CYWord *word) :
 826         value_(word->Word()),
 827         size_(strlen(value_))
 828     {
 829     }
 830
 831     const char *Value() const {
 832         return value_;
 833     }
 834
 835     virtual const char *Word() const;
 836
 837     virtual CYNumber *Number(CYContext &context);
 838     virtual CYString *String(CYContext &context);
 839
 840     CYString *Concat(CYContext &out, CYString *rhs) const;
 841     virtual void Output(CYOutput &out, CYFlags flags) const;
 842     virtual void PropertyName(CYOutput &out) const;
 843 };
 844
 845 struct CYNumber :
 846     CYTrivial,
 847     CYPropertyName
 848 {
 849     double value_;
 850
 851     CYNumber(double value) :
 852         value_(value)
 853     {
 854     }
 855
 856     double Value() const {
 857         return value_;
 858     }
 859
 860     virtual CYNumber *Number(CYContext &context);
 861     virtual CYString *String(CYContext &context);
 862
 863     virtual void Output(CYOutput &out, CYFlags flags) const;
 864     virtual void PropertyName(CYOutput &out) const;
 865 };
 866
 867 struct CYRegEx :
 868     CYTrivial
 869 {
 870     const char *value_;
 871
 872     CYRegEx(const char *value) :
 873         value_(value)
 874     {
 875     }
 876
 877     const char *Value() const {
 878         return value_;
 879     }
 880
 881     virtual void Output(CYOutput &out, CYFlags flags) const;
 882 };
 883
 884 struct CYNull :
 885     CYWord,
 886     CYTrivial
 887 {
 888     CYNull() :
 889         CYWord("null")
 890     {
 891     }
 892
 893     virtual CYNumber *Number(CYContext &context);
 894     virtual CYString *String(CYContext &context);
 895
 896     virtual void Output(CYOutput &out, CYFlags flags) const;
 897 };
 898
 899 struct CYThis :
 900     CYWord,
 901     CYMagic
 902 {
 903     CYThis() :
 904         CYWord("this")
 905     {
 906     }
 907
 908     virtual CYExpression *Replace(CYContext &context);
 909     virtual void Output(CYOutput &out, CYFlags flags) const;
 910 };
 911
 912 struct CYBoolean :
 913     CYTrivial
 914 {
 915     virtual bool Value() const = 0;
 916     virtual void Output(CYOutput &out, CYFlags flags) const;
 917 };
 918
 919 struct CYFalse :
 920     CYWord,
 921     CYBoolean
 922 {
 923     CYFalse() :
 924         CYWord("false")
 925     {
 926     }
 927
 928     virtual bool Value() const {
 929         return false;
 930     }
 931
 932     virtual CYNumber *Number(CYContext &context);
 933     virtual CYString *String(CYContext &context);
 934 };
 935
 936 struct CYTrue :
 937     CYWord,
 938     CYBoolean
 939 {
 940     CYTrue() :
 941         CYWord("true")
 942     {
 943     }
 944
 945     virtual bool Value() const {
 946         return true;
 947     }
 948
 949     virtual CYNumber *Number(CYContext &context);
 950     virtual CYString *String(CYContext &context);
 951 };
 952
 953 struct CYVariable :
 954     CYExpression
 955 {
 956     CYIdentifier *name_;
 957
 958     CYVariable(CYIdentifier *name) :
 959         name_(name)
 960     {
 961     }
 962
 963     CYVariable(const char *name) :
 964         name_(new($pool) CYIdentifier(name))
 965     {
 966     }
 967
 968     CYPrecedence(0)
 969     CYRightHand(false)
 970
 971     virtual CYExpression *Replace(CYContext &context);
 972     virtual void Output(CYOutput &out, CYFlags flags) const;
 973 };
 974
 975 struct CYPrefix :
 976     CYExpression
 977 {
 978     CYExpression *rhs_;
 979
 980     CYPrefix(CYExpression *rhs) :
 981         rhs_(rhs)
 982     {
 983     }
 984
 985     virtual bool Alphabetic() const = 0;
 986     virtual const char *Operator() const = 0;
 987
 988     CYPrecedence(4)
 989
 990     virtual CYExpression *Replace(CYContext &context);
 991     virtual void Output(CYOutput &out, CYFlags flags) const;
 992 };
 993
 994 struct CYInfix :
 995     CYExpression
 996 {
 997     CYExpression *lhs_;
 998     CYExpression *rhs_;
 999
1000     CYInfix(CYExpression *lhs, CYExpression *rhs) :
1001         lhs_(lhs),
1002         rhs_(rhs)
1003     {
1004     }
1005
1006     void SetLeft(CYExpression *lhs) {
1007         lhs_ = lhs;
1008     }
1009
1010     virtual bool Alphabetic() const = 0;
1011     virtual const char *Operator() const = 0;
1012
1013     virtual CYExpression *Replace(CYContext &context);
1014     virtual void Output(CYOutput &out, CYFlags flags) const;
1015 };
1016
1017 struct CYPostfix :
1018     CYExpression
1019 {
1020     CYExpression *lhs_;
1021
1022     CYPostfix(CYExpression *lhs) :
1023         lhs_(lhs)
1024     {
1025     }
1026
1027     virtual const char *Operator() const = 0;
1028
1029     CYPrecedence(3)
1030
1031     virtual CYExpression *Replace(CYContext &context);
1032     virtual void Output(CYOutput &out, CYFlags flags) const;
1033 };
1034
1035 struct CYAssignment :
1036     CYExpression
1037 {
1038     CYExpression *lhs_;
1039     CYExpression *rhs_;
1040
1041     CYAssignment(CYExpression *lhs, CYExpression *rhs) :
1042         lhs_(lhs),
1043         rhs_(rhs)
1044     {
1045     }
1046
1047     void SetLeft(CYExpression *lhs) {
1048         lhs_ = lhs;
1049     }
1050
1051     virtual const char *Operator() const = 0;
1052
1053     CYPrecedence(16)
1054
1055     virtual CYExpression *Replace(CYContext &context);
1056     virtual void Output(CYOutput &out, CYFlags flags) const;
1057 };
1058
1059 struct CYArgument :
1060     CYNext<CYArgument>,
1061     CYThing
1062 {
1063     CYWord *name_;
1064     CYExpression *value_;
1065
1066     CYArgument(CYExpression *value, CYArgument *next = NULL) :
1067         CYNext<CYArgument>(next),
1068         name_(NULL),
1069         value_(value)
1070     {
1071     }
1072
1073     CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
1074         CYNext<CYArgument>(next),
1075         name_(name),
1076         value_(value)
1077     {
1078     }
1079
1080     void Replace(CYContext &context);
1081     void Output(CYOutput &out) const;
1082 };
1083
1084 struct CYBlank :
1085     public CYWord
1086 {
1087     CYBlank() :
1088         CYWord("")
1089     {
1090     }
1091 };
1092
1093 struct CYClause :
1094     CYThing,
1095     CYNext<CYClause>
1096 {
1097     CYExpression *case_;
1098     CYStatement *statements_;
1099
1100     CYClause(CYExpression *_case, CYStatement *statements) :
1101         case_(_case),
1102         statements_(statements)
1103     {
1104     }
1105
1106     void Replace(CYContext &context);
1107     virtual void Output(CYOutput &out) const;
1108 };
1109
1110 struct CYElement :
1111     CYNext<CYElement>,
1112     CYThing
1113 {
1114     CYExpression *value_;
1115
1116     CYElement(CYExpression *value, CYElement *next) :
1117         CYNext<CYElement>(next),
1118         value_(value)
1119     {
1120     }
1121
1122     void Replace(CYContext &context);
1123     void Output(CYOutput &out) const;
1124 };
1125
1126 struct CYArray :
1127     CYLiteral
1128 {
1129     CYElement *elements_;
1130
1131     CYArray(CYElement *elements = NULL) :
1132         elements_(elements)
1133     {
1134     }
1135
1136     virtual CYExpression *Replace(CYContext &context);
1137     virtual void Output(CYOutput &out, CYFlags flags) const;
1138 };
1139
1140 struct CYProperty :
1141     CYNext<CYProperty>,
1142     CYThing
1143 {
1144     CYPropertyName *name_;
1145     CYExpression *value_;
1146
1147     CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
1148         CYNext<CYProperty>(next),
1149         name_(name),
1150         value_(value)
1151     {
1152     }
1153
1154     void Replace(CYContext &context);
1155     virtual void Output(CYOutput &out) const;
1156 };
1157
1158 struct CYDeclaration :
1159     CYForInInitialiser
1160 {
1161     CYIdentifier *identifier_;
1162     CYExpression *initialiser_;
1163
1164     CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) :
1165         identifier_(identifier),
1166         initialiser_(initialiser)
1167     {
1168     }
1169
1170     virtual void ForIn(CYOutput &out, CYFlags flags) const;
1171     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
1172
1173     virtual CYExpression *Replace(CYContext &context);
1174     virtual CYAssignment *Assignment(CYContext &context);
1175
1176     virtual void Output(CYOutput &out, CYFlags flags) const;
1177 };
1178
1179 struct CYDeclarations :
1180     CYNext<CYDeclarations>,
1181     CYThing,
1182     CYForInitialiser
1183 {
1184     CYDeclaration *declaration_;
1185
1186     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
1187         CYNext<CYDeclarations>(next),
1188         declaration_(declaration)
1189     {
1190     }
1191
1192     virtual void For(CYOutput &out) const;
1193
1194     virtual CYCompound *Replace(CYContext &context);
1195     CYProperty *Property(CYContext &context);
1196
1197     virtual void Output(CYOutput &out) const;
1198     virtual void Output(CYOutput &out, CYFlags flags) const;
1199 };
1200
1201 struct CYVar :
1202     CYStatement
1203 {
1204     CYDeclarations *declarations_;
1205
1206     CYVar(CYDeclarations *declarations) :
1207         declarations_(declarations)
1208     {
1209     }
1210
1211     virtual CYStatement *Replace(CYContext &context);
1212     virtual void Output(CYOutput &out, CYFlags flags) const;
1213 };
1214
1215 struct CYLet :
1216     CYStatement
1217 {
1218     CYDeclarations *declarations_;
1219     CYBlock code_;
1220
1221     CYLet(CYDeclarations *declarations, CYStatement *statements) :
1222         declarations_(declarations),
1223         code_(statements)
1224     {
1225     }
1226
1227     virtual CYStatement *Replace(CYContext &context);
1228     virtual void Output(CYOutput &out, CYFlags flags) const;
1229 };
1230
1231 struct CYFor :
1232     CYStatement
1233 {
1234     CYForInitialiser *initialiser_;
1235     CYExpression *test_;
1236     CYExpression *increment_;
1237     CYStatement *code_;
1238
1239     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
1240         initialiser_(initialiser),
1241         test_(test),
1242         increment_(increment),
1243         code_(code)
1244     {
1245     }
1246
1247     virtual CYStatement *Replace(CYContext &context);
1248     virtual void Output(CYOutput &out, CYFlags flags) const;
1249 };
1250
1251 struct CYForIn :
1252     CYStatement
1253 {
1254     CYForInInitialiser *initialiser_;
1255     CYExpression *set_;
1256     CYStatement *code_;
1257
1258     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1259         initialiser_(initialiser),
1260         set_(set),
1261         code_(code)
1262     {
1263     }
1264
1265     virtual CYStatement *Replace(CYContext &context);
1266     virtual void Output(CYOutput &out, CYFlags flags) const;
1267 };
1268
1269 struct CYForEachIn :
1270     CYStatement
1271 {
1272     CYForInInitialiser *initialiser_;
1273     CYExpression *set_;
1274     CYStatement *code_;
1275
1276     CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1277         initialiser_(initialiser),
1278         set_(set),
1279         code_(code)
1280     {
1281     }
1282
1283     virtual CYStatement *Replace(CYContext &context);
1284     virtual void Output(CYOutput &out, CYFlags flags) const;
1285 };
1286
1287 struct CYObject :
1288     CYLiteral
1289 {
1290     CYProperty *properties_;
1291
1292     CYObject(CYProperty *properties = NULL) :
1293         properties_(properties)
1294     {
1295     }
1296
1297     virtual CYExpression *Replace(CYContext &context);
1298     void Output(CYOutput &out, CYFlags flags) const;
1299 };
1300
1301 struct CYMember :
1302     CYExpression
1303 {
1304     CYExpression *object_;
1305     CYExpression *property_;
1306
1307     CYMember(CYExpression *object, CYExpression *property) :
1308         object_(object),
1309         property_(property)
1310     {
1311     }
1312
1313     void SetLeft(CYExpression *object) {
1314         object_ = object;
1315     }
1316
1317     void Replace_(CYContext &context);
1318 };
1319
1320 struct CYDirectMember :
1321     CYMember
1322 {
1323     CYDirectMember(CYExpression *object, CYExpression *property) :
1324         CYMember(object, property)
1325     {
1326     }
1327
1328     CYPrecedence(1)
1329     CYRightHand(false)
1330
1331     virtual CYExpression *Replace(CYContext &context);
1332     virtual void Output(CYOutput &out, CYFlags flags) const;
1333 };
1334
1335 struct CYIndirectMember :
1336     CYMember
1337 {
1338     CYIndirectMember(CYExpression *object, CYExpression *property) :
1339         CYMember(object, property)
1340     {
1341     }
1342
1343     CYPrecedence(1)
1344     CYRightHand(false)
1345
1346     virtual CYExpression *Replace(CYContext &context);
1347     virtual void Output(CYOutput &out, CYFlags flags) const;
1348 };
1349
1350 namespace cy {
1351 namespace Syntax {
1352
1353 struct New :
1354     CYExpression
1355 {
1356     CYExpression *constructor_;
1357     CYArgument *arguments_;
1358
1359     New(CYExpression *constructor, CYArgument *arguments) :
1360         constructor_(constructor),
1361         arguments_(arguments)
1362     {
1363     }
1364
1365     virtual unsigned Precedence() const {
1366         return arguments_ == NULL ? 2 : 1;
1367     }
1368
1369     CYRightHand(false)
1370
1371     virtual CYExpression *Replace(CYContext &context);
1372     virtual void Output(CYOutput &out, CYFlags flags) const;
1373
1374     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1375 };
1376
1377 } }
1378
1379 struct CYCall :
1380     CYExpression
1381 {
1382     CYExpression *function_;
1383     CYArgument *arguments_;
1384
1385     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1386         function_(function),
1387         arguments_(arguments)
1388     {
1389     }
1390
1391     CYPrecedence(1)
1392     CYRightHand(false)
1393
1394     virtual CYExpression *Replace(CYContext &context);
1395     virtual void Output(CYOutput &out, CYFlags flags) const;
1396
1397     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1398 };
1399
1400 struct CYRubyProc;
1401
1402 struct CYRubyBlock :
1403     CYExpression
1404 {
1405     CYExpression *call_;
1406     CYRubyProc *proc_;
1407
1408     CYRubyBlock(CYExpression *call, CYRubyProc *proc) :
1409         call_(call),
1410         proc_(proc)
1411     {
1412     }
1413
1414     CYPrecedence(1)
1415     CYRightHand(false)
1416
1417     virtual CYExpression *Replace(CYContext &context);
1418     virtual void Output(CYOutput &out, CYFlags flags) const;
1419 };
1420
1421 struct CYIf :
1422     CYStatement
1423 {
1424     CYExpression *test_;
1425     CYStatement *true_;
1426     CYStatement *false_;
1427
1428     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1429         test_(test),
1430         true_(_true),
1431         false_(_false)
1432     {
1433     }
1434
1435     virtual CYStatement *Replace(CYContext &context);
1436     virtual void Output(CYOutput &out, CYFlags flags) const;
1437 };
1438
1439 struct CYDoWhile :
1440     CYStatement
1441 {
1442     CYExpression *test_;
1443     CYStatement *code_;
1444
1445     CYDoWhile(CYExpression *test, CYStatement *code) :
1446         test_(test),
1447         code_(code)
1448     {
1449     }
1450
1451     virtual CYStatement *Replace(CYContext &context);
1452     virtual void Output(CYOutput &out, CYFlags flags) const;
1453 };
1454
1455 struct CYWhile :
1456     CYStatement
1457 {
1458     CYExpression *test_;
1459     CYStatement *code_;
1460
1461     CYWhile(CYExpression *test, CYStatement *code) :
1462         test_(test),
1463         code_(code)
1464     {
1465     }
1466
1467     virtual CYStatement *Replace(CYContext &context);
1468     virtual void Output(CYOutput &out, CYFlags flags) const;
1469 };
1470
1471 // XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass)
1472 struct CYFunction {
1473     CYIdentifier *name_;
1474     CYFunctionParameter *parameters_;
1475     CYBlock code_;
1476     CYNonLocal *nonlocal_;
1477
1478     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1479         name_(name),
1480         parameters_(parameters),
1481         code_(statements),
1482         nonlocal_(NULL)
1483     {
1484     }
1485
1486     virtual ~CYFunction() {
1487     }
1488
1489     void Inject(CYContext &context);
1490     virtual void Replace_(CYContext &context, bool outer);
1491     virtual void Output(CYOutput &out, CYFlags flags) const;
1492 };
1493
1494 // XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression
1495 struct CYFunctionExpression :
1496     CYFunction,
1497     CYExpression
1498 {
1499     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1500         CYFunction(name, parameters, statements)
1501     {
1502     }
1503
1504     CYPrecedence(0)
1505     CYRightHand(false)
1506
1507     virtual CYExpression *Replace(CYContext &context);
1508     virtual void Output(CYOutput &out, CYFlags flags) const;
1509 };
1510
1511 // XXX: this should derive from CYAnonymousFunctionExpression
1512 struct CYRubyProc :
1513     CYFunctionExpression
1514 {
1515     CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) :
1516         CYFunctionExpression(NULL, parameters, statements)
1517     {
1518     }
1519
1520     virtual CYExpression *Replace(CYContext &context);
1521     virtual void Output(CYOutput &out, CYFlags flags) const;
1522 };
1523
1524 // XXX: this should derive from CYNamedFunction
1525 struct CYFunctionStatement :
1526     CYFunction,
1527     CYStatement
1528 {
1529     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1530         CYFunction(name, parameters, statements)
1531     {
1532     }
1533
1534     virtual CYStatement *Replace(CYContext &context);
1535     virtual void Output(CYOutput &out, CYFlags flags) const;
1536 };
1537
1538 struct CYExpress :
1539     CYStatement
1540 {
1541     CYExpression *expression_;
1542
1543     CYExpress(CYExpression *expression) :
1544         expression_(expression)
1545     {
1546         if (expression == NULL)
1547             throw;
1548     }
1549
1550     virtual CYStatement *Replace(CYContext &context);
1551     virtual void Output(CYOutput &out, CYFlags flags) const;
1552 };
1553
1554 struct CYContinue :
1555     CYStatement
1556 {
1557     CYIdentifier *label_;
1558
1559     CYContinue(CYIdentifier *label) :
1560         label_(label)
1561     {
1562     }
1563
1564     virtual CYStatement *Replace(CYContext &context);
1565     virtual void Output(CYOutput &out, CYFlags flags) const;
1566 };
1567
1568 struct CYBreak :
1569     CYStatement
1570 {
1571     CYIdentifier *label_;
1572
1573     CYBreak(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 CYReturn :
1583     CYStatement
1584 {
1585     CYExpression *value_;
1586
1587     CYReturn(CYExpression *value) :
1588         value_(value)
1589     {
1590     }
1591
1592     virtual CYStatement *Replace(CYContext &context);
1593     virtual void Output(CYOutput &out, CYFlags flags) const;
1594 };
1595
1596 struct CYEmpty :
1597     CYStatement
1598 {
1599     virtual CYStatement *Replace(CYContext &context);
1600     virtual void Output(CYOutput &out, CYFlags flags) const;
1601 };
1602
1603 struct CYFinally :
1604     CYThing
1605 {
1606     CYBlock code_;
1607
1608     CYFinally(CYStatement *statements) :
1609         code_(statements)
1610     {
1611     }
1612
1613     void Replace(CYContext &context);
1614     virtual void Output(CYOutput &out) const;
1615 };
1616
1617 namespace cy {
1618 namespace Syntax {
1619
1620 struct Catch :
1621     CYThing
1622 {
1623     CYIdentifier *name_;
1624     CYBlock code_;
1625
1626     Catch(CYIdentifier *name, CYStatement *statements) :
1627         name_(name),
1628         code_(statements)
1629     {
1630     }
1631
1632     void Replace(CYContext &context);
1633     virtual void Output(CYOutput &out) const;
1634 };
1635
1636 struct Try :
1637     CYStatement
1638 {
1639     CYBlock code_;
1640     Catch *catch_;
1641     CYFinally *finally_;
1642
1643     Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
1644         code_(statements),
1645         catch_(_catch),
1646         finally_(finally)
1647     {
1648     }
1649
1650     virtual CYStatement *Replace(CYContext &context);
1651     virtual void Output(CYOutput &out, CYFlags flags) const;
1652 };
1653
1654 struct Throw :
1655     CYStatement
1656 {
1657     CYExpression *value_;
1658
1659     Throw(CYExpression *value = NULL) :
1660         value_(value)
1661     {
1662     }
1663
1664     virtual CYStatement *Replace(CYContext &context);
1665     virtual void Output(CYOutput &out, CYFlags flags) const;
1666 };
1667
1668 } }
1669
1670 struct CYWith :
1671     CYStatement
1672 {
1673     CYExpression *scope_;
1674     CYStatement *code_;
1675
1676     CYWith(CYExpression *scope, CYStatement *code) :
1677         scope_(scope),
1678         code_(code)
1679     {
1680     }
1681
1682     virtual CYStatement *Replace(CYContext &context);
1683     virtual void Output(CYOutput &out, CYFlags flags) const;
1684 };
1685
1686 struct CYSwitch :
1687     CYStatement
1688 {
1689     CYExpression *value_;
1690     CYClause *clauses_;
1691
1692     CYSwitch(CYExpression *value, CYClause *clauses) :
1693         value_(value),
1694         clauses_(clauses)
1695     {
1696     }
1697
1698     virtual CYStatement *Replace(CYContext &context);
1699     virtual void Output(CYOutput &out, CYFlags flags) const;
1700 };
1701
1702 struct CYCondition :
1703     CYExpression
1704 {
1705     CYExpression *test_;
1706     CYExpression *true_;
1707     CYExpression *false_;
1708
1709     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1710         test_(test),
1711         true_(_true),
1712         false_(_false)
1713     {
1714     }
1715
1716     CYPrecedence(15)
1717
1718     virtual CYExpression *Replace(CYContext &context);
1719     virtual void Output(CYOutput &out, CYFlags flags) const;
1720 };
1721
1722 struct CYAddressOf :
1723     CYPrefix
1724 {
1725     CYAddressOf(CYExpression *rhs) :
1726         CYPrefix(rhs)
1727     {
1728     }
1729
1730     virtual const char *Operator() const {
1731         return "&";
1732     }
1733
1734     CYAlphabetic(false)
1735
1736     virtual CYExpression *Replace(CYContext &context);
1737 };
1738
1739 struct CYIndirect :
1740     CYPrefix
1741 {
1742     CYIndirect(CYExpression *rhs) :
1743         CYPrefix(rhs)
1744     {
1745     }
1746
1747     virtual const char *Operator() const {
1748         return "*";
1749     }
1750
1751     CYAlphabetic(false)
1752
1753     virtual CYExpression *Replace(CYContext &context);
1754 };
1755
1756 #define CYReplace \
1757     virtual CYExpression *Replace(CYContext &context);
1758
1759 #define CYPostfix_(op, name, args...) \
1760     struct CY ## name : \
1761         CYPostfix \
1762     { args \
1763         CY ## name(CYExpression *lhs) : \
1764             CYPostfix(lhs) \
1765         { \
1766         } \
1767     \
1768         virtual const char *Operator() const { \
1769             return op; \
1770         } \
1771     };
1772
1773 #define CYPrefix_(alphabetic, op, name, args...) \
1774     struct CY ## name : \
1775         CYPrefix \
1776     { args \
1777         CY ## name(CYExpression *rhs) : \
1778             CYPrefix(rhs) \
1779         { \
1780         } \
1781     \
1782         CYAlphabetic(alphabetic) \
1783     \
1784         virtual const char *Operator() const { \
1785             return op; \
1786         } \
1787     };
1788
1789 #define CYInfix_(alphabetic, precedence, op, name, args...) \
1790     struct CY ## name : \
1791         CYInfix \
1792     { args \
1793         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
1794             CYInfix(lhs, rhs) \
1795         { \
1796         } \
1797     \
1798         CYAlphabetic(alphabetic) \
1799         CYPrecedence(precedence) \
1800     \
1801         virtual const char *Operator() const { \
1802             return op; \
1803         } \
1804     };
1805
1806 #define CYAssignment_(op, name, args...) \
1807     struct CY ## name ## Assign : \
1808         CYAssignment \
1809     { args \
1810         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
1811             CYAssignment(lhs, rhs) \
1812         { \
1813         } \
1814     \
1815         virtual const char *Operator() const { \
1816             return op; \
1817         } \
1818     };
1819
1820 CYPostfix_("++", PostIncrement)
1821 CYPostfix_("--", PostDecrement)
1822
1823 CYPrefix_(true, "delete", Delete)
1824 CYPrefix_(true, "void", Void)
1825 CYPrefix_(true, "typeof", TypeOf)
1826 CYPrefix_(false, "++", PreIncrement)
1827 CYPrefix_(false, "--", PreDecrement)
1828 CYPrefix_(false, "+", Affirm)
1829 CYPrefix_(false, "-", Negate)
1830 CYPrefix_(false, "~", BitwiseNot)
1831 CYPrefix_(false, "!", LogicalNot)
1832
1833 CYInfix_(false, 5, "*", Multiply)
1834 CYInfix_(false, 5, "/", Divide)
1835 CYInfix_(false, 5, "%", Modulus)
1836 CYInfix_(false, 6, "+", Add, CYReplace)
1837 CYInfix_(false, 6, "-", Subtract)
1838 CYInfix_(false, 7, "<<", ShiftLeft)
1839 CYInfix_(false, 7, ">>", ShiftRightSigned)
1840 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
1841 CYInfix_(false, 8, "<", Less)
1842 CYInfix_(false, 8, ">", Greater)
1843 CYInfix_(false, 8, "<=", LessOrEqual)
1844 CYInfix_(false, 8, ">=", GreaterOrEqual)
1845 CYInfix_(true, 8, "instanceof", InstanceOf)
1846 CYInfix_(true, 8, "in", In)
1847 CYInfix_(false, 9, "==", Equal)
1848 CYInfix_(false, 9, "!=", NotEqual)
1849 CYInfix_(false, 9, "===", Identical)
1850 CYInfix_(false, 9, "!==", NotIdentical)
1851 CYInfix_(false, 10, "&", BitwiseAnd)
1852 CYInfix_(false, 11, "^", BitwiseXOr)
1853 CYInfix_(false, 12, "|", BitwiseOr)
1854 CYInfix_(false, 13, "&&", LogicalAnd)
1855 CYInfix_(false, 14, "||", LogicalOr)
1856
1857 CYAssignment_("=", )
1858 CYAssignment_("*=", Multiply)
1859 CYAssignment_("/=", Divide)
1860 CYAssignment_("%=", Modulus)
1861 CYAssignment_("+=", Add)
1862 CYAssignment_("-=", Subtract)
1863 CYAssignment_("<<=", ShiftLeft)
1864 CYAssignment_(">>=", ShiftRightSigned)
1865 CYAssignment_(">>>=", ShiftRightUnsigned)
1866 CYAssignment_("&=", BitwiseAnd)
1867 CYAssignment_("^=", BitwiseXOr)
1868 CYAssignment_("|=", BitwiseOr)
1869
1870 #endif/*CYCRIPT_PARSER_HPP*/