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
 102 enum CYNeeded {
 103     CYNever     = -1,
 104     CYSometimes =  0,
 105     CYAlways    =  1,
 106 };
 107
 108 enum CYFlags {
 109     CYNoFlags =      0,
 110     CYNoBrace =      (1 << 0),
 111     CYNoFunction =   (1 << 1),
 112     CYNoIn =         (1 << 2),
 113     CYNoCall =       (1 << 3),
 114     CYNoRightHand =  (1 << 4),
 115     CYNoDangle =     (1 << 5),
 116     CYNoInteger =    (1 << 6),
 117     CYNoBF =         (CYNoBrace | CYNoFunction),
 118 };
 119
 120 _finline CYFlags operator ~(CYFlags rhs) {
 121     return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
 122 }
 123
 124 _finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
 125     return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
 126 }
 127
 128 _finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
 129     return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
 130 }
 131
 132 _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
 133     return lhs = lhs | rhs;
 134 }
 135
 136 _finline CYFlags CYLeft(CYFlags flags) {
 137     return flags & ~(CYNoDangle | CYNoInteger);
 138 }
 139
 140 _finline CYFlags CYRight(CYFlags flags) {
 141     return flags & ~CYNoBF;
 142 }
 143
 144 _finline CYFlags CYCenter(CYFlags flags) {
 145     return CYLeft(CYRight(flags));
 146 }
 147
 148 struct CYStatement :
 149     CYNext<CYStatement>
 150 {
 151     virtual ~CYStatement() {
 152     }
 153
 154     void Single(CYOutput &out, CYFlags flags) const;
 155     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 156
 157     virtual CYStatement *Collapse(CYContext &context);
 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             last = &(*last)->next_;
 388         }
 389     }
 390
 391     template <typename Type_>
 392     void Replace(Type_ *&value) {
 393         for (;;) if (value == NULL)
 394             break;
 395         else {
 396             Type_ *replace(value->Replace(*this));
 397             if (replace != value)
 398                 value = replace;
 399             else break;
 400         }
 401     }
 402
 403     void NonLocal(CYStatement *&statements);
 404     CYIdentifier *Unique();
 405 };
 406
 407 struct CYNonLocal {
 408     CYIdentifier *identifier_;
 409
 410     CYNonLocal() :
 411         identifier_(NULL)
 412     {
 413     }
 414
 415     CYIdentifier *Target(CYContext &context) {
 416         if (identifier_ == NULL)
 417             identifier_ = context.Unique();
 418         return identifier_;
 419     }
 420 };
 421
 422 struct CYBlock :
 423     CYStatement,
 424     CYThing
 425 {
 426     CYStatement *statements_;
 427
 428     CYBlock(CYStatement *statements) :
 429         statements_(statements)
 430     {
 431     }
 432
 433     operator CYStatement *() const {
 434         return statements_;
 435     }
 436
 437     void AddPrev(CYStatement *statement) {
 438         CYSetLast(statement, statements_);
 439         statements_ = statement;
 440     }
 441
 442     virtual CYStatement *Replace(CYContext &context);
 443
 444     virtual void Output(CYOutput &out) const;
 445     virtual void Output(CYOutput &out, CYFlags flags) const;
 446 };
 447
 448 enum CYState {
 449     CYClear,
 450     CYRestricted,
 451     CYNewLine
 452 };
 453
 454 class CYDriver {
 455   public:
 456     CYState state_;
 457     void *scanner_;
 458
 459     const char *data_;
 460     size_t size_;
 461     FILE *file_;
 462
 463     bool strict_;
 464
 465     enum Condition {
 466         RegExpCondition,
 467         XMLContentCondition,
 468         XMLTagCondition,
 469     };
 470
 471     std::string filename_;
 472
 473     struct Error {
 474         bool warning_;
 475         cy::location location_;
 476         std::string message_;
 477     };
 478
 479     typedef std::vector<Error> Errors;
 480
 481     CYProgram *program_;
 482     Errors errors_;
 483
 484     bool auto_;
 485
 486     struct Context {
 487         CYExpression *context_;
 488
 489         Context(CYExpression *context) :
 490             context_(context)
 491         {
 492         }
 493
 494         typedef std::vector<CYWord *> Words;
 495         Words words_;
 496     };
 497
 498     typedef std::vector<Context> Contexts;
 499     Contexts contexts_;
 500
 501     CYExpression *context_;
 502
 503     enum Mode {
 504         AutoNone,
 505         AutoPrimary,
 506         AutoDirect,
 507         AutoIndirect,
 508         AutoMessage
 509     } mode_;
 510
 511   private:
 512     void ScannerInit();
 513     void ScannerDestroy();
 514
 515   public:
 516     CYDriver(const std::string &filename = "");
 517     ~CYDriver();
 518
 519     Condition GetCondition();
 520     void SetCondition(Condition condition);
 521
 522     void PushCondition(Condition condition);
 523     void PopCondition();
 524
 525     void Warning(const cy::location &location, const char *message);
 526 };
 527
 528 struct CYForInitialiser {
 529     virtual ~CYForInitialiser() {
 530     }
 531
 532     virtual void For(CYOutput &out) const = 0;
 533     virtual CYExpression *Replace(CYContext &context) = 0;
 534 };
 535
 536 struct CYForInInitialiser {
 537     virtual ~CYForInInitialiser() {
 538     }
 539
 540     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
 541     virtual const char *ForEachIn() const = 0;
 542     virtual CYExpression *ForEachIn(CYContext &out) = 0;
 543     virtual CYExpression *Replace(CYContext &context) = 0;
 544 };
 545
 546 struct CYNumber;
 547 struct CYString;
 548
 549 struct CYExpression :
 550     CYNext<CYExpression>,
 551     CYForInitialiser,
 552     CYForInInitialiser,
 553     CYClassName,
 554     CYThing
 555 {
 556     virtual unsigned Precedence() const = 0;
 557
 558     virtual bool RightHand() const {
 559         return true;
 560     }
 561
 562     virtual void For(CYOutput &out) const;
 563     virtual void ForIn(CYOutput &out, CYFlags flags) const;
 564
 565     virtual const char *ForEachIn() const;
 566     virtual CYExpression *ForEachIn(CYContext &out);
 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
 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
1171     virtual const char *ForEachIn() const;
1172     virtual CYExpression *ForEachIn(CYContext &out);
1173
1174     virtual CYExpression *Replace(CYContext &context);
1175     virtual CYAssignment *Assignment(CYContext &context);
1176
1177     virtual void Output(CYOutput &out, CYFlags flags) const;
1178 };
1179
1180 struct CYDeclarations :
1181     CYNext<CYDeclarations>,
1182     CYThing,
1183     CYForInitialiser
1184 {
1185     CYDeclaration *declaration_;
1186
1187     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
1188         CYNext<CYDeclarations>(next),
1189         declaration_(declaration)
1190     {
1191     }
1192
1193     virtual void For(CYOutput &out) const;
1194
1195     virtual CYCompound *Replace(CYContext &context);
1196     CYProperty *Property(CYContext &context);
1197
1198     virtual void Output(CYOutput &out) const;
1199     virtual void Output(CYOutput &out, CYFlags flags) const;
1200 };
1201
1202 struct CYVar :
1203     CYStatement
1204 {
1205     CYDeclarations *declarations_;
1206
1207     CYVar(CYDeclarations *declarations) :
1208         declarations_(declarations)
1209     {
1210     }
1211
1212     virtual CYStatement *Replace(CYContext &context);
1213     virtual void Output(CYOutput &out, CYFlags flags) const;
1214 };
1215
1216 struct CYLet :
1217     CYStatement
1218 {
1219     CYDeclarations *declarations_;
1220     CYBlock code_;
1221
1222     CYLet(CYDeclarations *declarations, CYStatement *statements) :
1223         declarations_(declarations),
1224         code_(statements)
1225     {
1226     }
1227
1228     virtual CYStatement *Replace(CYContext &context);
1229     virtual void Output(CYOutput &out, CYFlags flags) const;
1230 };
1231
1232 struct CYFor :
1233     CYStatement
1234 {
1235     CYForInitialiser *initialiser_;
1236     CYExpression *test_;
1237     CYExpression *increment_;
1238     CYStatement *code_;
1239
1240     CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
1241         initialiser_(initialiser),
1242         test_(test),
1243         increment_(increment),
1244         code_(code)
1245     {
1246     }
1247
1248     virtual CYStatement *Replace(CYContext &context);
1249     virtual void Output(CYOutput &out, CYFlags flags) const;
1250 };
1251
1252 struct CYForIn :
1253     CYStatement
1254 {
1255     CYForInInitialiser *initialiser_;
1256     CYExpression *set_;
1257     CYStatement *code_;
1258
1259     CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1260         initialiser_(initialiser),
1261         set_(set),
1262         code_(code)
1263     {
1264     }
1265
1266     virtual CYStatement *Replace(CYContext &context);
1267     virtual void Output(CYOutput &out, CYFlags flags) const;
1268 };
1269
1270 struct CYForEachIn :
1271     CYStatement
1272 {
1273     CYForInInitialiser *initialiser_;
1274     CYExpression *set_;
1275     CYStatement *code_;
1276
1277     CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
1278         initialiser_(initialiser),
1279         set_(set),
1280         code_(code)
1281     {
1282     }
1283
1284     virtual CYStatement *Replace(CYContext &context);
1285     virtual void Output(CYOutput &out, CYFlags flags) const;
1286 };
1287
1288 struct CYObject :
1289     CYLiteral
1290 {
1291     CYProperty *properties_;
1292
1293     CYObject(CYProperty *properties = NULL) :
1294         properties_(properties)
1295     {
1296     }
1297
1298     virtual CYExpression *Replace(CYContext &context);
1299     void Output(CYOutput &out, CYFlags flags) const;
1300 };
1301
1302 struct CYMember :
1303     CYExpression
1304 {
1305     CYExpression *object_;
1306     CYExpression *property_;
1307
1308     CYMember(CYExpression *object, CYExpression *property) :
1309         object_(object),
1310         property_(property)
1311     {
1312     }
1313
1314     void SetLeft(CYExpression *object) {
1315         object_ = object;
1316     }
1317
1318     void Replace_(CYContext &context);
1319 };
1320
1321 struct CYDirectMember :
1322     CYMember
1323 {
1324     CYDirectMember(CYExpression *object, CYExpression *property) :
1325         CYMember(object, property)
1326     {
1327     }
1328
1329     CYPrecedence(1)
1330     CYRightHand(false)
1331
1332     virtual CYExpression *Replace(CYContext &context);
1333     virtual void Output(CYOutput &out, CYFlags flags) const;
1334 };
1335
1336 struct CYIndirectMember :
1337     CYMember
1338 {
1339     CYIndirectMember(CYExpression *object, CYExpression *property) :
1340         CYMember(object, property)
1341     {
1342     }
1343
1344     CYPrecedence(1)
1345     CYRightHand(false)
1346
1347     virtual CYExpression *Replace(CYContext &context);
1348     virtual void Output(CYOutput &out, CYFlags flags) const;
1349 };
1350
1351 namespace cy {
1352 namespace Syntax {
1353
1354 struct New :
1355     CYExpression
1356 {
1357     CYExpression *constructor_;
1358     CYArgument *arguments_;
1359
1360     New(CYExpression *constructor, CYArgument *arguments) :
1361         constructor_(constructor),
1362         arguments_(arguments)
1363     {
1364     }
1365
1366     virtual unsigned Precedence() const {
1367         return arguments_ == NULL ? 2 : 1;
1368     }
1369
1370     CYRightHand(false)
1371
1372     virtual CYExpression *Replace(CYContext &context);
1373     virtual void Output(CYOutput &out, CYFlags flags) const;
1374
1375     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1376 };
1377
1378 } }
1379
1380 struct CYCall :
1381     CYExpression
1382 {
1383     CYExpression *function_;
1384     CYArgument *arguments_;
1385
1386     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1387         function_(function),
1388         arguments_(arguments)
1389     {
1390     }
1391
1392     CYPrecedence(1)
1393     CYRightHand(false)
1394
1395     virtual CYExpression *Replace(CYContext &context);
1396     virtual void Output(CYOutput &out, CYFlags flags) const;
1397
1398     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
1399 };
1400
1401 struct CYRubyProc;
1402
1403 struct CYRubyBlock :
1404     CYExpression
1405 {
1406     CYExpression *call_;
1407     CYRubyProc *proc_;
1408
1409     CYRubyBlock(CYExpression *call, CYRubyProc *proc) :
1410         call_(call),
1411         proc_(proc)
1412     {
1413     }
1414
1415     CYPrecedence(1)
1416     CYRightHand(false)
1417
1418     virtual CYExpression *Replace(CYContext &context);
1419     virtual void Output(CYOutput &out, CYFlags flags) const;
1420 };
1421
1422 struct CYIf :
1423     CYStatement
1424 {
1425     CYExpression *test_;
1426     CYStatement *true_;
1427     CYStatement *false_;
1428
1429     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1430         test_(test),
1431         true_(_true),
1432         false_(_false)
1433     {
1434     }
1435
1436     virtual CYStatement *Replace(CYContext &context);
1437     virtual void Output(CYOutput &out, CYFlags flags) const;
1438 };
1439
1440 struct CYDoWhile :
1441     CYStatement
1442 {
1443     CYExpression *test_;
1444     CYStatement *code_;
1445
1446     CYDoWhile(CYExpression *test, CYStatement *code) :
1447         test_(test),
1448         code_(code)
1449     {
1450     }
1451
1452     virtual CYStatement *Replace(CYContext &context);
1453     virtual void Output(CYOutput &out, CYFlags flags) const;
1454 };
1455
1456 struct CYWhile :
1457     CYStatement
1458 {
1459     CYExpression *test_;
1460     CYStatement *code_;
1461
1462     CYWhile(CYExpression *test, CYStatement *code) :
1463         test_(test),
1464         code_(code)
1465     {
1466     }
1467
1468     virtual CYStatement *Replace(CYContext &context);
1469     virtual void Output(CYOutput &out, CYFlags flags) const;
1470 };
1471
1472 // XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass)
1473 struct CYFunction {
1474     CYIdentifier *name_;
1475     CYFunctionParameter *parameters_;
1476     CYBlock code_;
1477     CYNonLocal *nonlocal_;
1478
1479     CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1480         name_(name),
1481         parameters_(parameters),
1482         code_(statements),
1483         nonlocal_(NULL)
1484     {
1485     }
1486
1487     virtual ~CYFunction() {
1488     }
1489
1490     void Inject(CYContext &context);
1491     virtual void Replace_(CYContext &context, bool outer);
1492     virtual void Output(CYOutput &out, CYFlags flags) const;
1493 };
1494
1495 // XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression
1496 struct CYFunctionExpression :
1497     CYFunction,
1498     CYExpression
1499 {
1500     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1501         CYFunction(name, parameters, statements)
1502     {
1503     }
1504
1505     CYPrecedence(0)
1506     CYRightHand(false)
1507
1508     virtual CYExpression *Replace(CYContext &context);
1509     virtual void Output(CYOutput &out, CYFlags flags) const;
1510 };
1511
1512 // XXX: this should derive from CYAnonymousFunctionExpression
1513 struct CYRubyProc :
1514     CYFunctionExpression
1515 {
1516     CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) :
1517         CYFunctionExpression(NULL, parameters, statements)
1518     {
1519     }
1520
1521     virtual CYExpression *Replace(CYContext &context);
1522     virtual void Output(CYOutput &out, CYFlags flags) const;
1523 };
1524
1525 // XXX: this should derive from CYNamedFunction
1526 struct CYFunctionStatement :
1527     CYFunction,
1528     CYStatement
1529 {
1530     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
1531         CYFunction(name, parameters, statements)
1532     {
1533     }
1534
1535     virtual CYStatement *Replace(CYContext &context);
1536     virtual void Output(CYOutput &out, CYFlags flags) const;
1537 };
1538
1539 struct CYExpress :
1540     CYStatement
1541 {
1542     CYExpression *expression_;
1543
1544     CYExpress(CYExpression *expression) :
1545         expression_(expression)
1546     {
1547         if (expression == NULL)
1548             throw;
1549     }
1550
1551     virtual CYStatement *Collapse(CYContext &context);
1552     virtual CYStatement *Replace(CYContext &context);
1553     virtual void Output(CYOutput &out, CYFlags flags) const;
1554 };
1555
1556 struct CYContinue :
1557     CYStatement
1558 {
1559     CYIdentifier *label_;
1560
1561     CYContinue(CYIdentifier *label) :
1562         label_(label)
1563     {
1564     }
1565
1566     virtual CYStatement *Replace(CYContext &context);
1567     virtual void Output(CYOutput &out, CYFlags flags) const;
1568 };
1569
1570 struct CYBreak :
1571     CYStatement
1572 {
1573     CYIdentifier *label_;
1574
1575     CYBreak(CYIdentifier *label) :
1576         label_(label)
1577     {
1578     }
1579
1580     virtual CYStatement *Replace(CYContext &context);
1581     virtual void Output(CYOutput &out, CYFlags flags) const;
1582 };
1583
1584 struct CYReturn :
1585     CYStatement
1586 {
1587     CYExpression *value_;
1588
1589     CYReturn(CYExpression *value) :
1590         value_(value)
1591     {
1592     }
1593
1594     virtual CYStatement *Replace(CYContext &context);
1595     virtual void Output(CYOutput &out, CYFlags flags) const;
1596 };
1597
1598 struct CYEmpty :
1599     CYStatement
1600 {
1601     virtual CYStatement *Collapse(CYContext &context);
1602     virtual CYStatement *Replace(CYContext &context);
1603     virtual void Output(CYOutput &out, CYFlags flags) const;
1604 };
1605
1606 struct CYFinally :
1607     CYThing
1608 {
1609     CYBlock code_;
1610
1611     CYFinally(CYStatement *statements) :
1612         code_(statements)
1613     {
1614     }
1615
1616     void Replace(CYContext &context);
1617     virtual void Output(CYOutput &out) const;
1618 };
1619
1620 namespace cy {
1621 namespace Syntax {
1622
1623 struct Catch :
1624     CYThing
1625 {
1626     CYIdentifier *name_;
1627     CYBlock code_;
1628
1629     Catch(CYIdentifier *name, CYStatement *statements) :
1630         name_(name),
1631         code_(statements)
1632     {
1633     }
1634
1635     void Replace(CYContext &context);
1636     virtual void Output(CYOutput &out) const;
1637 };
1638
1639 struct Try :
1640     CYStatement
1641 {
1642     CYBlock code_;
1643     Catch *catch_;
1644     CYFinally *finally_;
1645
1646     Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
1647         code_(statements),
1648         catch_(_catch),
1649         finally_(finally)
1650     {
1651     }
1652
1653     virtual CYStatement *Replace(CYContext &context);
1654     virtual void Output(CYOutput &out, CYFlags flags) const;
1655 };
1656
1657 struct Throw :
1658     CYStatement
1659 {
1660     CYExpression *value_;
1661
1662     Throw(CYExpression *value = NULL) :
1663         value_(value)
1664     {
1665     }
1666
1667     virtual CYStatement *Replace(CYContext &context);
1668     virtual void Output(CYOutput &out, CYFlags flags) const;
1669 };
1670
1671 } }
1672
1673 struct CYWith :
1674     CYStatement
1675 {
1676     CYExpression *scope_;
1677     CYStatement *code_;
1678
1679     CYWith(CYExpression *scope, CYStatement *code) :
1680         scope_(scope),
1681         code_(code)
1682     {
1683     }
1684
1685     virtual CYStatement *Replace(CYContext &context);
1686     virtual void Output(CYOutput &out, CYFlags flags) const;
1687 };
1688
1689 struct CYSwitch :
1690     CYStatement
1691 {
1692     CYExpression *value_;
1693     CYClause *clauses_;
1694
1695     CYSwitch(CYExpression *value, CYClause *clauses) :
1696         value_(value),
1697         clauses_(clauses)
1698     {
1699     }
1700
1701     virtual CYStatement *Replace(CYContext &context);
1702     virtual void Output(CYOutput &out, CYFlags flags) const;
1703 };
1704
1705 struct CYCondition :
1706     CYExpression
1707 {
1708     CYExpression *test_;
1709     CYExpression *true_;
1710     CYExpression *false_;
1711
1712     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
1713         test_(test),
1714         true_(_true),
1715         false_(_false)
1716     {
1717     }
1718
1719     CYPrecedence(15)
1720
1721     virtual CYExpression *Replace(CYContext &context);
1722     virtual void Output(CYOutput &out, CYFlags flags) const;
1723 };
1724
1725 struct CYAddressOf :
1726     CYPrefix
1727 {
1728     CYAddressOf(CYExpression *rhs) :
1729         CYPrefix(rhs)
1730     {
1731     }
1732
1733     virtual const char *Operator() const {
1734         return "&";
1735     }
1736
1737     CYAlphabetic(false)
1738
1739     virtual CYExpression *Replace(CYContext &context);
1740 };
1741
1742 struct CYIndirect :
1743     CYPrefix
1744 {
1745     CYIndirect(CYExpression *rhs) :
1746         CYPrefix(rhs)
1747     {
1748     }
1749
1750     virtual const char *Operator() const {
1751         return "*";
1752     }
1753
1754     CYAlphabetic(false)
1755
1756     virtual CYExpression *Replace(CYContext &context);
1757 };
1758
1759 #define CYReplace \
1760     virtual CYExpression *Replace(CYContext &context);
1761
1762 #define CYPostfix_(op, name, args...) \
1763     struct CY ## name : \
1764         CYPostfix \
1765     { args \
1766         CY ## name(CYExpression *lhs) : \
1767             CYPostfix(lhs) \
1768         { \
1769         } \
1770     \
1771         virtual const char *Operator() const { \
1772             return op; \
1773         } \
1774     };
1775
1776 #define CYPrefix_(alphabetic, op, name, args...) \
1777     struct CY ## name : \
1778         CYPrefix \
1779     { args \
1780         CY ## name(CYExpression *rhs) : \
1781             CYPrefix(rhs) \
1782         { \
1783         } \
1784     \
1785         CYAlphabetic(alphabetic) \
1786     \
1787         virtual const char *Operator() const { \
1788             return op; \
1789         } \
1790     };
1791
1792 #define CYInfix_(alphabetic, precedence, op, name, args...) \
1793     struct CY ## name : \
1794         CYInfix \
1795     { args \
1796         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
1797             CYInfix(lhs, rhs) \
1798         { \
1799         } \
1800     \
1801         CYAlphabetic(alphabetic) \
1802         CYPrecedence(precedence) \
1803     \
1804         virtual const char *Operator() const { \
1805             return op; \
1806         } \
1807     };
1808
1809 #define CYAssignment_(op, name, args...) \
1810     struct CY ## name ## Assign : \
1811         CYAssignment \
1812     { args \
1813         CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
1814             CYAssignment(lhs, rhs) \
1815         { \
1816         } \
1817     \
1818         virtual const char *Operator() const { \
1819             return op; \
1820         } \
1821     };
1822
1823 CYPostfix_("++", PostIncrement)
1824 CYPostfix_("--", PostDecrement)
1825
1826 CYPrefix_(true, "delete", Delete)
1827 CYPrefix_(true, "void", Void)
1828 CYPrefix_(true, "typeof", TypeOf)
1829 CYPrefix_(false, "++", PreIncrement)
1830 CYPrefix_(false, "--", PreDecrement)
1831 CYPrefix_(false, "+", Affirm)
1832 CYPrefix_(false, "-", Negate)
1833 CYPrefix_(false, "~", BitwiseNot)
1834 CYPrefix_(false, "!", LogicalNot)
1835
1836 CYInfix_(false, 5, "*", Multiply)
1837 CYInfix_(false, 5, "/", Divide)
1838 CYInfix_(false, 5, "%", Modulus)
1839 CYInfix_(false, 6, "+", Add, CYReplace)
1840 CYInfix_(false, 6, "-", Subtract)
1841 CYInfix_(false, 7, "<<", ShiftLeft)
1842 CYInfix_(false, 7, ">>", ShiftRightSigned)
1843 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
1844 CYInfix_(false, 8, "<", Less)
1845 CYInfix_(false, 8, ">", Greater)
1846 CYInfix_(false, 8, "<=", LessOrEqual)
1847 CYInfix_(false, 8, ">=", GreaterOrEqual)
1848 CYInfix_(true, 8, "instanceof", InstanceOf)
1849 CYInfix_(true, 8, "in", In)
1850 CYInfix_(false, 9, "==", Equal)
1851 CYInfix_(false, 9, "!=", NotEqual)
1852 CYInfix_(false, 9, "===", Identical)
1853 CYInfix_(false, 9, "!==", NotIdentical)
1854 CYInfix_(false, 10, "&", BitwiseAnd)
1855 CYInfix_(false, 11, "^", BitwiseXOr)
1856 CYInfix_(false, 12, "|", BitwiseOr)
1857 CYInfix_(false, 13, "&&", LogicalAnd)
1858 CYInfix_(false, 14, "||", LogicalOr)
1859
1860 CYAssignment_("=", )
1861 CYAssignment_("*=", Multiply)
1862 CYAssignment_("/=", Divide)
1863 CYAssignment_("%=", Modulus)
1864 CYAssignment_("+=", Add)
1865 CYAssignment_("-=", Subtract)
1866 CYAssignment_("<<=", ShiftLeft)
1867 CYAssignment_(">>=", ShiftRightSigned)
1868 CYAssignment_(">>>=", ShiftRightUnsigned)
1869 CYAssignment_("&=", BitwiseAnd)
1870 CYAssignment_("^=", BitwiseXOr)
1871 CYAssignment_("|=", BitwiseOr)
1872
1873 #endif/*CYCRIPT_PARSER_HPP*/