Syntax.hpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2015  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #ifndef CYCRIPT_SYNTAX_HPP
  23 #define CYCRIPT_SYNTAX_HPP
  24
  25 #include <cstdio>
  26 #include <cstdlib>
  27
  28 #include <streambuf>
  29 #include <string>
  30 #include <vector>
  31
  32 #include "List.hpp"
  33 #include "Location.hpp"
  34 #include "Options.hpp"
  35 #include "Pooling.hpp"
  36 #include "String.hpp"
  37
  38 double CYCastDouble(const char *value, size_t size);
  39 double CYCastDouble(const char *value);
  40 double CYCastDouble(CYUTF8String value);
  41
  42 void CYNumerify(std::ostringstream &str, double value);
  43 void CYStringify(std::ostringstream &str, const char *data, size_t size, bool c = false);
  44
  45 // XXX: this really should not be here ... :/
  46 void *CYPoolFile(CYPool &pool, const char *path, size_t *psize);
  47 CYUTF8String CYPoolFileUTF8String(CYPool &pool, const char *path);
  48
  49 struct CYContext;
  50
  51 struct CYThing {
  52     virtual void Output(struct CYOutput &out) const = 0;
  53 };
  54
  55 struct CYOutput {
  56     std::streambuf &out_;
  57     CYPosition position_;
  58
  59     CYOptions &options_;
  60     bool pretty_;
  61     unsigned indent_;
  62     unsigned recent_;
  63     bool right_;
  64
  65     enum {
  66         NoMode,
  67         NoLetter,
  68         NoPlus,
  69         NoHyphen,
  70         Terminated
  71     } mode_;
  72
  73     CYOutput(std::streambuf &out, CYOptions &options) :
  74         out_(out),
  75         options_(options),
  76         pretty_(false),
  77         indent_(0),
  78         recent_(0),
  79         right_(false),
  80         mode_(NoMode)
  81     {
  82     }
  83
  84     void Check(char value);
  85     void Terminate();
  86
  87     _finline void operator ()(char value) {
  88         _assert(out_.sputc(value) != EOF);
  89         recent_ = indent_;
  90         if (value == '\n')
  91             position_.Lines(1);
  92         else
  93             position_.Columns(1);
  94     }
  95
  96     _finline void operator ()(const char *data, std::streamsize size) {
  97         _assert(out_.sputn(data, size) == size);
  98         recent_ = indent_;
  99         position_.Columns(size);
 100     }
 101
 102     _finline void operator ()(const char *data) {
 103         return operator ()(data, strlen(data));
 104     }
 105
 106     CYOutput &operator <<(char rhs);
 107     CYOutput &operator <<(const char *rhs);
 108
 109     _finline CYOutput &operator <<(const CYThing *rhs) {
 110         if (rhs != NULL)
 111             rhs->Output(*this);
 112         return *this;
 113     }
 114
 115     _finline CYOutput &operator <<(const CYThing &rhs) {
 116         rhs.Output(*this);
 117         return *this;
 118     }
 119 };
 120
 121 struct CYExpression;
 122 struct CYAssignment;
 123
 124 struct CYPropertyName {
 125     virtual bool Computed() const {
 126         return false;
 127     }
 128
 129     virtual bool Constructor() const {
 130         return false;
 131     }
 132
 133     virtual CYExpression *PropertyName(CYContext &context) = 0;
 134     virtual void PropertyName(CYOutput &out) const = 0;
 135 };
 136
 137 enum CYNeeded {
 138     CYNever     = -1,
 139     CYSometimes =  0,
 140     CYAlways    =  1,
 141 };
 142
 143 enum CYFlags {
 144     CYNoFlags =      0,
 145     CYNoBrace =      (1 << 0),
 146     CYNoFunction =   (1 << 1),
 147     CYNoClass =      (1 << 2),
 148     CYNoIn =         (1 << 3),
 149     CYNoCall =       (1 << 4),
 150     CYNoRightHand =  (1 << 5),
 151     CYNoDangle =     (1 << 6),
 152     CYNoInteger =    (1 << 7),
 153     CYNoColon =      (1 << 8),
 154     CYNoBFC =        (CYNoBrace | CYNoFunction | CYNoClass),
 155 };
 156
 157 _finline CYFlags operator ~(CYFlags rhs) {
 158     return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
 159 }
 160
 161 _finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
 162     return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
 163 }
 164
 165 _finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
 166     return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
 167 }
 168
 169 _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
 170     return lhs = lhs | rhs;
 171 }
 172
 173 _finline CYFlags CYLeft(CYFlags flags) {
 174     return flags & ~(CYNoDangle | CYNoInteger);
 175 }
 176
 177 _finline CYFlags CYRight(CYFlags flags) {
 178     return flags & ~CYNoBFC;
 179 }
 180
 181 _finline CYFlags CYCenter(CYFlags flags) {
 182     return CYLeft(CYRight(flags));
 183 }
 184
 185 enum CYCompactType {
 186     CYCompactNone,
 187     CYCompactLong,
 188     CYCompactShort,
 189 };
 190
 191 #define CYCompact(type) \
 192     virtual CYCompactType Compact() const { \
 193         return CYCompact ## type; \
 194     }
 195
 196 struct CYStatement :
 197     CYNext<CYStatement>,
 198     CYThing
 199 {
 200     void Single(CYOutput &out, CYFlags flags, CYCompactType request) const;
 201     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 202     virtual void Output(CYOutput &out) const;
 203
 204     virtual CYStatement *Replace(CYContext &context) = 0;
 205
 206     virtual CYCompactType Compact() const = 0;
 207     virtual CYStatement *Return();
 208
 209   private:
 210     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 211 };
 212
 213 typedef CYList<CYStatement> CYStatements;
 214
 215 struct CYForInitializer :
 216     CYStatement
 217 {
 218     virtual CYForInitializer *Replace(CYContext &context) = 0;
 219     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 220 };
 221
 222 struct CYWord :
 223     CYThing,
 224     CYPropertyName
 225 {
 226     const char *word_;
 227
 228     CYWord(const char *word) :
 229         word_(word)
 230     {
 231     }
 232
 233     virtual bool Constructor() const {
 234         return strcmp(word_, "constructor") == 0;
 235     }
 236
 237     virtual const char *Word() const;
 238     virtual void Output(CYOutput &out) const;
 239
 240     virtual CYExpression *PropertyName(CYContext &context);
 241     virtual void PropertyName(CYOutput &out) const;
 242 };
 243
 244 _finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) {
 245     lhs << &rhs << '=';
 246     return lhs << rhs.Word();
 247 }
 248
 249 enum CYIdentifierKind {
 250     CYIdentifierArgument,
 251     CYIdentifierCatch,
 252     CYIdentifierGlobal,
 253     CYIdentifierLexical,
 254     CYIdentifierMagic,
 255     CYIdentifierOther,
 256     CYIdentifierVariable,
 257 };
 258
 259 struct CYIdentifier :
 260     CYNext<CYIdentifier>,
 261     CYWord
 262 {
 263     CYLocation location_;
 264     size_t offset_;
 265     size_t usage_;
 266
 267     CYIdentifier(const char *word) :
 268         CYWord(word),
 269         offset_(0),
 270         usage_(0)
 271     {
 272     }
 273
 274     virtual const char *Word() const;
 275     CYIdentifier *Replace(CYContext &context, CYIdentifierKind);
 276 };
 277
 278 struct CYLabel :
 279     CYStatement
 280 {
 281     CYIdentifier *name_;
 282     CYStatement *statement_;
 283
 284     CYLabel(CYIdentifier *name, CYStatement *statement) :
 285         name_(name),
 286         statement_(statement)
 287     {
 288     }
 289
 290     CYCompact(Short)
 291
 292     virtual CYStatement *Replace(CYContext &context);
 293     virtual void Output(CYOutput &out, CYFlags flags) const;
 294 };
 295
 296 struct CYCStringLess :
 297     std::binary_function<const char *, const char *, bool>
 298 {
 299     _finline bool operator ()(const char *lhs, const char *rhs) const {
 300         return strcmp(lhs, rhs) < 0;
 301     }
 302 };
 303
 304 struct CYIdentifierValueLess :
 305     std::binary_function<CYIdentifier *, CYIdentifier *, bool>
 306 {
 307     _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const {
 308         return CYCStringLess()(lhs->Word(), rhs->Word());
 309     }
 310 };
 311
 312 struct CYIdentifierFlags :
 313     CYNext<CYIdentifierFlags>
 314 {
 315     CYIdentifier *identifier_;
 316     CYIdentifierKind kind_;
 317     unsigned count_;
 318     unsigned offset_;
 319
 320     CYIdentifierFlags(CYIdentifier *identifier, CYIdentifierKind kind, CYIdentifierFlags *next = NULL) :
 321         CYNext<CYIdentifierFlags>(next),
 322         identifier_(identifier),
 323         kind_(kind),
 324         count_(0),
 325         offset_(0)
 326     {
 327     }
 328 };
 329
 330 struct CYScope {
 331     bool transparent_;
 332     CYScope *parent_;
 333     bool damaged_;
 334     CYIdentifierFlags *shadow_;
 335
 336     CYIdentifierFlags *internal_;
 337
 338     CYScope(bool transparent, CYContext &context);
 339
 340     CYIdentifierFlags *Lookup(CYContext &context, const char *word);
 341     CYIdentifierFlags *Lookup(CYContext &context, CYIdentifier *identifier);
 342
 343     CYIdentifierFlags *Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierKind kind);
 344     void Merge(CYContext &context, const CYIdentifierFlags *flags);
 345
 346     void Close(CYContext &context, CYStatement *&statements);
 347     void Close(CYContext &context);
 348     void Damage();
 349 };
 350
 351 struct CYScript :
 352     CYThing
 353 {
 354     CYStatement *code_;
 355
 356     CYScript(CYStatement *code) :
 357         code_(code)
 358     {
 359     }
 360
 361     virtual void Replace(CYContext &context);
 362     virtual void Output(CYOutput &out) const;
 363 };
 364
 365 struct CYNonLocal;
 366 struct CYThisScope;
 367
 368 struct CYContext {
 369     CYOptions &options_;
 370
 371     CYScope *scope_;
 372     CYThisScope *this_;
 373     CYIdentifier *super_;
 374
 375     CYNonLocal *nonlocal_;
 376     CYNonLocal *nextlocal_;
 377     unsigned unique_;
 378
 379     std::vector<CYIdentifier *> replace_;
 380
 381     CYContext(CYOptions &options) :
 382         options_(options),
 383         scope_(NULL),
 384         this_(NULL),
 385         super_(NULL),
 386         nonlocal_(NULL),
 387         nextlocal_(NULL),
 388         unique_(0)
 389     {
 390     }
 391
 392     void ReplaceAll(CYStatement *&statement) {
 393         if (statement == NULL)
 394             return;
 395         CYStatement *next(statement->next_);
 396
 397         Replace(statement);
 398         ReplaceAll(next);
 399
 400         if (statement == NULL)
 401             statement = next;
 402         else
 403             statement->SetNext(next);
 404     }
 405
 406     template <typename Type_>
 407     void Replace(Type_ *&value) {
 408         for (;;) if (value == NULL)
 409             break;
 410         else {
 411             Type_ *replace(value->Replace(*this));
 412             if (replace != value)
 413                 value = replace;
 414             else break;
 415         }
 416     }
 417
 418     void NonLocal(CYStatement *&statements);
 419     CYIdentifier *Unique();
 420 };
 421
 422 struct CYNonLocal {
 423     CYIdentifier *identifier_;
 424
 425     CYNonLocal() :
 426         identifier_(NULL)
 427     {
 428     }
 429
 430     CYIdentifier *Target(CYContext &context) {
 431         if (identifier_ == NULL)
 432             identifier_ = context.Unique();
 433         return identifier_;
 434     }
 435 };
 436
 437 struct CYThisScope :
 438     CYNext<CYThisScope>
 439 {
 440     CYIdentifier *identifier_;
 441
 442     CYThisScope() :
 443         identifier_(NULL)
 444     {
 445     }
 446
 447     CYIdentifier *Identifier(CYContext &context) {
 448         if (next_ != NULL)
 449             return next_->Identifier(context);
 450         if (identifier_ == NULL)
 451             identifier_ = context.Unique();
 452         return identifier_;
 453     }
 454 };
 455
 456 struct CYBlock :
 457     CYStatement
 458 {
 459     CYStatement *code_;
 460
 461     CYBlock(CYStatement *code) :
 462         code_(code)
 463     {
 464     }
 465
 466     CYCompact(Short)
 467
 468     virtual CYStatement *Replace(CYContext &context);
 469
 470     virtual void Output(CYOutput &out, CYFlags flags) const;
 471
 472     virtual CYStatement *Return();
 473 };
 474
 475 struct CYTarget;
 476 struct CYVar;
 477
 478 struct CYForInInitializer {
 479     virtual CYStatement *Initialize(CYContext &context, CYExpression *value) = 0;
 480
 481     virtual CYTarget *Replace(CYContext &context) = 0;
 482     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 483 };
 484
 485 struct CYFunctionParameter;
 486
 487 struct CYNumber;
 488 struct CYString;
 489
 490 struct CYExpression :
 491     CYThing
 492 {
 493     virtual int Precedence() const = 0;
 494
 495     virtual bool RightHand() const {
 496         return true;
 497     }
 498
 499     virtual bool Eval() const {
 500         return false;
 501     }
 502
 503     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
 504
 505     virtual void Output(CYOutput &out) const;
 506     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 507     void Output(CYOutput &out, int precedence, CYFlags flags) const;
 508
 509     virtual CYExpression *Replace(CYContext &context) = 0;
 510
 511     virtual CYExpression *Primitive(CYContext &context) {
 512         return NULL;
 513     }
 514
 515     virtual CYFunctionParameter *Parameter() const;
 516
 517     virtual CYNumber *Number(CYContext &context) {
 518         return NULL;
 519     }
 520
 521     virtual CYString *String(CYContext &context) {
 522         return NULL;
 523     }
 524
 525     virtual const char *Word() const {
 526         return NULL;
 527     }
 528 };
 529
 530 struct CYTarget :
 531     CYExpression,
 532     CYForInInitializer
 533 {
 534     virtual bool RightHand() const {
 535         return false;
 536     }
 537
 538     virtual bool IsNew() const {
 539         return false;
 540     }
 541
 542     virtual CYStatement *Initialize(CYContext &context, CYExpression *value);
 543
 544     virtual CYTarget *Replace(CYContext &context) = 0;
 545     using CYExpression::Output;
 546 };
 547
 548 #define CYAlphabetic(value) \
 549     virtual bool Alphabetic() const { \
 550         return value; \
 551     }
 552
 553 #define CYPrecedence(value) \
 554     static const int Precedence_ = value; \
 555     virtual int Precedence() const { \
 556         return Precedence_; \
 557     }
 558
 559 struct CYCompound :
 560     CYExpression
 561 {
 562     CYExpression *expression_;
 563     CYExpression *next_;
 564
 565     CYCompound(CYExpression *expression, CYExpression *next) :
 566         expression_(expression),
 567         next_(next)
 568     {
 569         _assert(expression_ != NULL);
 570         _assert(next != NULL);
 571     }
 572
 573     CYPrecedence(17)
 574
 575     virtual CYExpression *Replace(CYContext &context);
 576     void Output(CYOutput &out, CYFlags flags) const;
 577
 578     virtual CYFunctionParameter *Parameter() const;
 579 };
 580
 581 struct CYParenthetical :
 582     CYTarget
 583 {
 584     CYExpression *expression_;
 585
 586     CYParenthetical(CYExpression *expression) :
 587         expression_(expression)
 588     {
 589     }
 590
 591     CYPrecedence(0)
 592
 593     virtual CYTarget *Replace(CYContext &context);
 594     void Output(CYOutput &out, CYFlags flags) const;
 595 };
 596
 597 struct CYBinding;
 598
 599 struct CYFunctionParameter :
 600     CYNext<CYFunctionParameter>,
 601     CYThing
 602 {
 603     CYBinding *binding_;
 604
 605     CYFunctionParameter(CYBinding *binding, CYFunctionParameter *next = NULL) :
 606         CYNext<CYFunctionParameter>(next),
 607         binding_(binding)
 608     {
 609     }
 610
 611     void Replace(CYContext &context, CYStatement *&statements);
 612     void Output(CYOutput &out) const;
 613 };
 614
 615 struct CYComprehension :
 616     CYNext<CYComprehension>,
 617     CYThing
 618 {
 619     CYComprehension(CYComprehension *next = NULL) :
 620         CYNext<CYComprehension>(next)
 621     {
 622     }
 623
 624     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;
 625     CYFunctionParameter *Parameters(CYContext &context) const;
 626     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 627     virtual void Output(CYOutput &out) const = 0;
 628 };
 629
 630 struct CYForInComprehension :
 631     CYComprehension
 632 {
 633     CYBinding *binding_;
 634     CYExpression *iterable_;
 635
 636     CYForInComprehension(CYBinding *binding, CYExpression *iterable, CYComprehension *next = NULL) :
 637         CYComprehension(next),
 638         binding_(binding),
 639         iterable_(iterable)
 640     {
 641     }
 642
 643     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 644     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 645     virtual void Output(CYOutput &out) const;
 646 };
 647
 648 struct CYForOfComprehension :
 649     CYComprehension
 650 {
 651     CYBinding *binding_;
 652     CYExpression *iterable_;
 653
 654     CYForOfComprehension(CYBinding *binding, CYExpression *iterable, CYComprehension *next = NULL) :
 655         CYComprehension(next),
 656         binding_(binding),
 657         iterable_(iterable)
 658     {
 659     }
 660
 661     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 662     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 663     virtual void Output(CYOutput &out) const;
 664 };
 665
 666 struct CYIfComprehension :
 667     CYComprehension
 668 {
 669     CYExpression *test_;
 670
 671     CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) :
 672         CYComprehension(next),
 673         test_(test)
 674     {
 675     }
 676
 677     virtual CYFunctionParameter *Parameter(CYContext &context) const;
 678     virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const;
 679     virtual void Output(CYOutput &out) const;
 680 };
 681
 682 struct CYArrayComprehension :
 683     CYTarget
 684 {
 685     CYExpression *expression_;
 686     CYComprehension *comprehensions_;
 687
 688     CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
 689         expression_(expression),
 690         comprehensions_(comprehensions)
 691     {
 692     }
 693
 694     CYPrecedence(0)
 695
 696     virtual CYTarget *Replace(CYContext &context);
 697     virtual void Output(CYOutput &out, CYFlags flags) const;
 698 };
 699
 700 struct CYLiteral :
 701     CYTarget
 702 {
 703     CYLocation location_;
 704
 705     CYPrecedence(0)
 706
 707     virtual CYExpression *Primitive(CYContext &context) {
 708         return this;
 709     }
 710 };
 711
 712 struct CYTrivial :
 713     CYLiteral
 714 {
 715     virtual CYTarget *Replace(CYContext &context);
 716 };
 717
 718 struct CYMagic :
 719     CYTarget
 720 {
 721     CYPrecedence(0)
 722 };
 723
 724 struct CYRange {
 725     uint64_t lo_;
 726     uint64_t hi_;
 727
 728     CYRange(uint64_t lo, uint64_t hi) :
 729         lo_(lo), hi_(hi)
 730     {
 731     }
 732
 733     bool operator [](uint8_t value) const {
 734         return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1;
 735     }
 736
 737     void operator()(uint8_t value) {
 738         if (value >> 7)
 739             return;
 740         (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f);
 741     }
 742 };
 743
 744 extern CYRange DigitRange_;
 745 extern CYRange WordStartRange_;
 746 extern CYRange WordEndRange_;
 747
 748 struct CYString :
 749     CYTrivial,
 750     CYPropertyName
 751 {
 752     const char *value_;
 753     size_t size_;
 754
 755     CYString() :
 756         value_(NULL),
 757         size_(0)
 758     {
 759     }
 760
 761     CYString(const char *value) :
 762         value_(value),
 763         size_(strlen(value))
 764     {
 765     }
 766
 767     CYString(const char *value, size_t size) :
 768         value_(value),
 769         size_(size)
 770     {
 771     }
 772
 773     CYString(const CYWord *word) :
 774         value_(word->Word()),
 775         size_(strlen(value_))
 776     {
 777     }
 778
 779     const char *Value() const {
 780         return value_;
 781     }
 782
 783     virtual const char *Word() const;
 784
 785     virtual CYNumber *Number(CYContext &context);
 786     virtual CYString *String(CYContext &context);
 787
 788     CYString *Concat(CYContext &out, CYString *rhs) const;
 789     virtual void Output(CYOutput &out, CYFlags flags) const;
 790
 791     virtual CYExpression *PropertyName(CYContext &context);
 792     virtual void PropertyName(CYOutput &out) const;
 793 };
 794
 795 struct CYElementValue;
 796
 797 struct CYSpan :
 798     CYNext<CYSpan>
 799 {
 800     CYExpression *expression_;
 801     CYString *string_;
 802
 803     CYSpan(CYExpression *expression, CYString *string, CYSpan *next) :
 804         CYNext<CYSpan>(next),
 805         expression_(expression),
 806         string_(string)
 807     {
 808     }
 809
 810     CYElementValue *Replace(CYContext &context);
 811 };
 812
 813 struct CYTemplate :
 814     CYTarget
 815 {
 816     CYString *string_;
 817     CYSpan *spans_;
 818
 819     CYTemplate(CYString *string, CYSpan *spans) :
 820         string_(string),
 821         spans_(spans)
 822     {
 823     }
 824
 825     CYPrecedence(0)
 826
 827     virtual CYTarget *Replace(CYContext &context);
 828     virtual void Output(CYOutput &out, CYFlags flags) const;
 829 };
 830
 831 struct CYNumber :
 832     CYTrivial,
 833     CYPropertyName
 834 {
 835     double value_;
 836
 837     CYNumber(double value) :
 838         value_(value)
 839     {
 840     }
 841
 842     double Value() const {
 843         return value_;
 844     }
 845
 846     virtual CYNumber *Number(CYContext &context);
 847     virtual CYString *String(CYContext &context);
 848
 849     virtual void Output(CYOutput &out, CYFlags flags) const;
 850
 851     virtual CYExpression *PropertyName(CYContext &context);
 852     virtual void PropertyName(CYOutput &out) const;
 853 };
 854
 855 struct CYComputed :
 856     CYPropertyName
 857 {
 858     CYExpression *expression_;
 859
 860     CYComputed(CYExpression *expression) :
 861         expression_(expression)
 862     {
 863     }
 864
 865     virtual bool Computed() const {
 866         return true;
 867     }
 868
 869     virtual CYExpression *PropertyName(CYContext &context);
 870     virtual void PropertyName(CYOutput &out) const;
 871 };
 872
 873 struct CYRegEx :
 874     CYTrivial
 875 {
 876     const char *value_;
 877     size_t size_;
 878
 879     CYRegEx(const char *value, size_t size) :
 880         value_(value),
 881         size_(size)
 882     {
 883     }
 884
 885     const char *Value() const {
 886         return value_;
 887     }
 888
 889     virtual void Output(CYOutput &out, CYFlags flags) const;
 890 };
 891
 892 struct CYNull :
 893     CYTrivial
 894 {
 895     virtual CYNumber *Number(CYContext &context);
 896     virtual CYString *String(CYContext &context);
 897
 898     virtual void Output(CYOutput &out, CYFlags flags) const;
 899 };
 900
 901 struct CYThis :
 902     CYMagic
 903 {
 904     virtual CYTarget *Replace(CYContext &context);
 905     virtual void Output(CYOutput &out, CYFlags flags) const;
 906 };
 907
 908 struct CYBoolean :
 909     CYTrivial
 910 {
 911     CYPrecedence(4)
 912
 913     virtual bool RightHand() const {
 914         return true;
 915     }
 916
 917     virtual bool Value() const = 0;
 918     virtual void Output(CYOutput &out, CYFlags flags) const;
 919 };
 920
 921 struct CYFalse :
 922     CYBoolean
 923 {
 924     virtual bool Value() const {
 925         return false;
 926     }
 927
 928     virtual CYNumber *Number(CYContext &context);
 929     virtual CYString *String(CYContext &context);
 930 };
 931
 932 struct CYTrue :
 933     CYBoolean
 934 {
 935     virtual bool Value() const {
 936         return true;
 937     }
 938
 939     virtual CYNumber *Number(CYContext &context);
 940     virtual CYString *String(CYContext &context);
 941 };
 942
 943 struct CYVariable :
 944     CYTarget
 945 {
 946     CYIdentifier *name_;
 947
 948     CYVariable(CYIdentifier *name) :
 949         name_(name)
 950     {
 951     }
 952
 953     CYVariable(const char *name) :
 954         name_(new($pool) CYIdentifier(name))
 955     {
 956     }
 957
 958     CYPrecedence(0)
 959
 960     virtual bool Eval() const {
 961         return strcmp(name_->Word(), "eval") == 0;
 962     }
 963
 964     virtual CYTarget *Replace(CYContext &context);
 965     virtual void Output(CYOutput &out, CYFlags flags) const;
 966
 967     virtual CYFunctionParameter *Parameter() const;
 968 };
 969
 970 struct CYSymbol :
 971     CYTarget
 972 {
 973     const char *name_;
 974
 975     CYSymbol(const char *name) :
 976         name_(name)
 977     {
 978     }
 979
 980     CYPrecedence(0)
 981
 982     virtual CYTarget *Replace(CYContext &context);
 983     virtual void Output(CYOutput &out, CYFlags flags) const;
 984 };
 985
 986 struct CYPrefix :
 987     CYExpression
 988 {
 989     CYExpression *rhs_;
 990
 991     CYPrefix(CYExpression *rhs) :
 992         rhs_(rhs)
 993     {
 994     }
 995
 996     virtual bool Alphabetic() const = 0;
 997     virtual const char *Operator() const = 0;
 998
 999     CYPrecedence(4)
1000
1001     virtual CYExpression *Replace(CYContext &context);
1002     virtual void Output(CYOutput &out, CYFlags flags) const;
1003 };
1004
1005 struct CYInfix :
1006     CYExpression
1007 {
1008     CYExpression *lhs_;
1009     CYExpression *rhs_;
1010
1011     CYInfix(CYExpression *lhs, CYExpression *rhs) :
1012         lhs_(lhs),
1013         rhs_(rhs)
1014     {
1015     }
1016
1017     void SetLeft(CYExpression *lhs) {
1018         lhs_ = lhs;
1019     }
1020
1021     virtual bool Alphabetic() const = 0;
1022     virtual const char *Operator() const = 0;
1023
1024     virtual CYExpression *Replace(CYContext &context);
1025     virtual void Output(CYOutput &out, CYFlags flags) const;
1026 };
1027
1028 struct CYPostfix :
1029     CYExpression
1030 {
1031     CYExpression *lhs_;
1032
1033     CYPostfix(CYExpression *lhs) :
1034         lhs_(lhs)
1035     {
1036     }
1037
1038     virtual const char *Operator() const = 0;
1039
1040     CYPrecedence(3)
1041
1042     virtual CYExpression *Replace(CYContext &context);
1043     virtual void Output(CYOutput &out, CYFlags flags) const;
1044 };
1045
1046 struct CYAssignment :
1047     CYExpression
1048 {
1049     CYTarget *lhs_;
1050     CYExpression *rhs_;
1051
1052     CYAssignment(CYTarget *lhs, CYExpression *rhs) :
1053         lhs_(lhs),
1054         rhs_(rhs)
1055     {
1056     }
1057
1058     void SetRight(CYExpression *rhs) {
1059         rhs_ = rhs;
1060     }
1061
1062     virtual const char *Operator() const = 0;
1063
1064     CYPrecedence(16)
1065
1066     virtual CYExpression *Replace(CYContext &context);
1067     virtual void Output(CYOutput &out, CYFlags flags) const;
1068 };
1069
1070 struct CYArgument :
1071     CYNext<CYArgument>,
1072     CYThing
1073 {
1074     CYWord *name_;
1075     CYExpression *value_;
1076
1077     CYArgument(CYExpression *value, CYArgument *next = NULL) :
1078         CYNext<CYArgument>(next),
1079         name_(NULL),
1080         value_(value)
1081     {
1082     }
1083
1084     CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
1085         CYNext<CYArgument>(next),
1086         name_(name),
1087         value_(value)
1088     {
1089     }
1090
1091     CYArgument *Replace(CYContext &context);
1092     void Output(CYOutput &out) const;
1093 };
1094
1095 struct CYClause :
1096     CYThing,
1097     CYNext<CYClause>
1098 {
1099     CYExpression *value_;
1100     CYStatement *code_;
1101
1102     CYClause(CYExpression *value, CYStatement *code) :
1103         value_(value),
1104         code_(code)
1105     {
1106     }
1107
1108     void Replace(CYContext &context);
1109     virtual void Output(CYOutput &out) const;
1110 };
1111
1112 struct CYElement :
1113     CYNext<CYElement>,
1114     CYThing
1115 {
1116     CYElement(CYElement *next) :
1117         CYNext<CYElement>(next)
1118     {
1119     }
1120
1121     virtual bool Elision() const = 0;
1122
1123     virtual void Replace(CYContext &context) = 0;
1124 };
1125
1126 struct CYElementValue :
1127     CYElement
1128 {
1129     CYExpression *value_;
1130
1131     CYElementValue(CYExpression *value, CYElement *next = NULL) :
1132         CYElement(next),
1133         value_(value)
1134     {
1135     }
1136
1137     virtual bool Elision() const {
1138         return value_ == NULL;
1139     }
1140
1141     virtual void Replace(CYContext &context);
1142     virtual void Output(CYOutput &out) const;
1143 };
1144
1145 struct CYElementSpread :
1146     CYElement
1147 {
1148     CYExpression *value_;
1149
1150     CYElementSpread(CYExpression *value, CYElement *next = NULL) :
1151         CYElement(next),
1152         value_(value)
1153     {
1154     }
1155
1156     virtual bool Elision() const {
1157         return false;
1158     }
1159
1160     virtual void Replace(CYContext &context);
1161     virtual void Output(CYOutput &out) const;
1162 };
1163
1164 struct CYArray :
1165     CYLiteral
1166 {
1167     CYElement *elements_;
1168
1169     CYArray(CYElement *elements = NULL) :
1170         elements_(elements)
1171     {
1172     }
1173
1174     virtual CYTarget *Replace(CYContext &context);
1175     virtual void Output(CYOutput &out, CYFlags flags) const;
1176 };
1177
1178 struct CYBinding {
1179     CYIdentifier *identifier_;
1180     CYExpression *initializer_;
1181
1182     CYBinding(CYIdentifier *identifier, CYExpression *initializer = NULL) :
1183         identifier_(identifier),
1184         initializer_(initializer)
1185     {
1186     }
1187
1188     CYTarget *Target(CYContext &context);
1189
1190     virtual CYAssignment *Replace(CYContext &context, CYIdentifierKind kind);
1191     virtual void Output(CYOutput &out, CYFlags flags) const;
1192 };
1193
1194 struct CYForLexical :
1195     CYForInInitializer
1196 {
1197     bool constant_;
1198     CYBinding *binding_;
1199
1200     CYForLexical(bool constant, CYBinding *binding) :
1201         constant_(constant),
1202         binding_(binding)
1203     {
1204     }
1205
1206     virtual CYStatement *Initialize(CYContext &context, CYExpression *value);
1207
1208     virtual CYTarget *Replace(CYContext &context);
1209     virtual void Output(CYOutput &out, CYFlags flags) const;
1210 };
1211
1212 struct CYForVariable :
1213     CYForInInitializer
1214 {
1215     CYBinding *binding_;
1216
1217     CYForVariable(CYBinding *binding) :
1218         binding_(binding)
1219     {
1220     }
1221
1222     virtual CYStatement *Initialize(CYContext &context, CYExpression *value);
1223
1224     virtual CYTarget *Replace(CYContext &context);
1225     virtual void Output(CYOutput &out, CYFlags flags) const;
1226 };
1227
1228 struct CYBindings :
1229     CYNext<CYBindings>,
1230     CYThing
1231 {
1232     CYBinding *binding_;
1233
1234     CYBindings(CYBinding *binding, CYBindings *next = NULL) :
1235         CYNext<CYBindings>(next),
1236         binding_(binding)
1237     {
1238     }
1239
1240     CYExpression *Replace(CYContext &context, CYIdentifierKind kind);
1241
1242     CYArgument *Argument(CYContext &context);
1243     CYFunctionParameter *Parameter(CYContext &context);
1244
1245     virtual void Output(CYOutput &out) const;
1246     virtual void Output(CYOutput &out, CYFlags flags) const;
1247 };
1248
1249 struct CYVar :
1250     CYForInitializer
1251 {
1252     CYBindings *bindings_;
1253
1254     CYVar(CYBindings *bindings) :
1255         bindings_(bindings)
1256     {
1257     }
1258
1259     CYCompact(None)
1260
1261     virtual CYForInitializer *Replace(CYContext &context);
1262     virtual void Output(CYOutput &out, CYFlags flags) const;
1263 };
1264
1265 struct CYLexical :
1266     CYForInitializer
1267 {
1268     bool constant_;
1269     CYBindings *bindings_;
1270
1271     CYLexical(bool constant, CYBindings *bindings) :
1272         constant_(constant),
1273         bindings_(bindings)
1274     {
1275     }
1276
1277     CYCompact(None)
1278
1279     virtual CYForInitializer *Replace(CYContext &context);
1280     virtual void Output(CYOutput &out, CYFlags flags) const;
1281 };
1282
1283 struct CYBuilder {
1284     CYList<CYBindings> bindings_;
1285     CYList<CYStatement> statements_;
1286
1287     operator bool() const {
1288         return statements_ != NULL;
1289     }
1290 };
1291
1292 struct CYProperty :
1293     CYNext<CYProperty>,
1294     CYThing
1295 {
1296     CYPropertyName *name_;
1297
1298     CYProperty(CYPropertyName *name, CYProperty *next = NULL) :
1299         CYNext<CYProperty>(next),
1300         name_(name)
1301     {
1302     }
1303
1304     virtual bool Update() const;
1305
1306     CYProperty *ReplaceAll(CYContext &context, CYBuilder &builder, CYExpression *self, bool update);
1307     void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, bool protect);
1308
1309     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) = 0;
1310
1311     virtual void Replace(CYContext &context) = 0;
1312     virtual void Output(CYOutput &out) const;
1313 };
1314
1315 struct CYPropertyValue :
1316     CYProperty
1317 {
1318     CYExpression *value_;
1319
1320     CYPropertyValue(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
1321         CYProperty(name, next),
1322         value_(value)
1323     {
1324     }
1325
1326     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1327     virtual void Replace(CYContext &context);
1328     virtual void Output(CYOutput &out) const;
1329 };
1330
1331 struct CYFor :
1332     CYStatement
1333 {
1334     CYForInitializer *initializer_;
1335     CYExpression *test_;
1336     CYExpression *increment_;
1337     CYStatement *code_;
1338
1339     CYFor(CYForInitializer *initializer, CYExpression *test, CYExpression *increment, CYStatement *code) :
1340         initializer_(initializer),
1341         test_(test),
1342         increment_(increment),
1343         code_(code)
1344     {
1345     }
1346
1347     CYCompact(Long)
1348
1349     virtual CYStatement *Replace(CYContext &context);
1350     virtual void Output(CYOutput &out, CYFlags flags) const;
1351 };
1352
1353 struct CYForIn :
1354     CYStatement
1355 {
1356     CYForInInitializer *initializer_;
1357     CYExpression *iterable_;
1358     CYStatement *code_;
1359
1360     CYForIn(CYForInInitializer *initializer, CYExpression *iterable, CYStatement *code) :
1361         initializer_(initializer),
1362         iterable_(iterable),
1363         code_(code)
1364     {
1365     }
1366
1367     CYCompact(Long)
1368
1369     virtual CYStatement *Replace(CYContext &context);
1370     virtual void Output(CYOutput &out, CYFlags flags) const;
1371 };
1372
1373 struct CYForInitialized :
1374     CYStatement
1375 {
1376     CYBinding *binding_;
1377     CYExpression *iterable_;
1378     CYStatement *code_;
1379
1380     CYForInitialized(CYBinding *binding, CYExpression *iterable, CYStatement *code) :
1381         binding_(binding),
1382         iterable_(iterable),
1383         code_(code)
1384     {
1385     }
1386
1387     CYCompact(Long)
1388
1389     virtual CYStatement *Replace(CYContext &context);
1390     virtual void Output(CYOutput &out, CYFlags flags) const;
1391 };
1392
1393 struct CYForOf :
1394     CYStatement
1395 {
1396     CYForInInitializer *initializer_;
1397     CYExpression *iterable_;
1398     CYStatement *code_;
1399
1400     CYForOf(CYForInInitializer *initializer, CYExpression *iterable, CYStatement *code) :
1401         initializer_(initializer),
1402         iterable_(iterable),
1403         code_(code)
1404     {
1405     }
1406
1407     CYCompact(Long)
1408
1409     virtual CYStatement *Replace(CYContext &context);
1410     virtual void Output(CYOutput &out, CYFlags flags) const;
1411 };
1412
1413 struct CYObject :
1414     CYLiteral
1415 {
1416     CYProperty *properties_;
1417
1418     CYObject(CYProperty *properties = NULL) :
1419         properties_(properties)
1420     {
1421     }
1422
1423     CYTarget *Replace(CYContext &context, CYTarget *seed);
1424
1425     virtual CYTarget *Replace(CYContext &context);
1426     void Output(CYOutput &out, CYFlags flags) const;
1427 };
1428
1429 struct CYMember :
1430     CYTarget
1431 {
1432     CYExpression *object_;
1433     CYExpression *property_;
1434
1435     CYMember(CYExpression *object, CYExpression *property) :
1436         object_(object),
1437         property_(property)
1438     {
1439     }
1440
1441     void SetLeft(CYExpression *object) {
1442         object_ = object;
1443     }
1444 };
1445
1446 struct CYDirectMember :
1447     CYMember
1448 {
1449     CYDirectMember(CYExpression *object, CYExpression *property) :
1450         CYMember(object, property)
1451     {
1452     }
1453
1454     CYPrecedence(1)
1455
1456     virtual CYTarget *Replace(CYContext &context);
1457     virtual void Output(CYOutput &out, CYFlags flags) const;
1458 };
1459
1460 struct CYIndirectMember :
1461     CYMember
1462 {
1463     CYIndirectMember(CYExpression *object, CYExpression *property) :
1464         CYMember(object, property)
1465     {
1466     }
1467
1468     CYPrecedence(1)
1469
1470     virtual CYTarget *Replace(CYContext &context);
1471     virtual void Output(CYOutput &out, CYFlags flags) const;
1472 };
1473
1474 struct CYResolveMember :
1475     CYMember
1476 {
1477     CYResolveMember(CYExpression *object, CYExpression *property) :
1478         CYMember(object, property)
1479     {
1480     }
1481
1482     CYPrecedence(1)
1483
1484     virtual CYTarget *Replace(CYContext &context);
1485     virtual void Output(CYOutput &out, CYFlags flags) const;
1486 };
1487
1488 namespace cy {
1489 namespace Syntax {
1490
1491 struct New :
1492     CYTarget
1493 {
1494     CYExpression *constructor_;
1495     CYArgument *arguments_;
1496
1497     New(CYExpression *constructor, CYArgument *arguments = NULL) :
1498         constructor_(constructor),
1499         arguments_(arguments)
1500     {
1501     }
1502
1503     virtual int Precedence() const {
1504         return arguments_ == NULL ? 2 : 1;
1505     }
1506
1507     virtual bool IsNew() const {
1508         return true;
1509     }
1510
1511     virtual CYTarget *Replace(CYContext &context);
1512     virtual void Output(CYOutput &out, CYFlags flags) const;
1513
1514     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1515 };
1516
1517 } }
1518
1519 struct CYApply :
1520     CYTarget
1521 {
1522     CYArgument *arguments_;
1523
1524     CYApply(CYArgument *arguments = NULL) :
1525         arguments_(arguments)
1526     {
1527     }
1528
1529     CYPrecedence(1)
1530
1531     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1532 };
1533
1534 struct CYCall :
1535     CYApply
1536 {
1537     CYExpression *function_;
1538
1539     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1540         CYApply(arguments),
1541         function_(function)
1542     {
1543     }
1544
1545     virtual void Output(CYOutput &out, CYFlags flags) const;
1546     virtual CYTarget *Replace(CYContext &context);
1547 };
1548
1549 struct CYEval :
1550     CYApply
1551 {
1552     CYEval(CYArgument *arguments) :
1553         CYApply(arguments)
1554     {
1555     }
1556
1557     virtual void Output(CYOutput &out, CYFlags flags) const;
1558     virtual CYTarget *Replace(CYContext &context);
1559 };
1560
1561 struct CYRubyProc;
1562
1563 struct CYBraced :
1564     CYTarget
1565 {
1566     CYTarget *lhs_;
1567
1568     CYBraced(CYTarget *lhs = NULL) :
1569         lhs_(lhs)
1570     {
1571     }
1572
1573     CYPrecedence(1)
1574
1575     void SetLeft(CYTarget *lhs) {
1576         lhs_ = lhs;
1577     }
1578 };
1579
1580 struct CYRubyBlock :
1581     CYBraced
1582 {
1583     CYRubyProc *proc_;
1584
1585     CYRubyBlock(CYTarget *lhs, CYRubyProc *proc) :
1586         CYBraced(lhs),
1587         proc_(proc)
1588     {
1589     }
1590
1591     virtual CYTarget *Replace(CYContext &context);
1592     virtual void Output(CYOutput &out, CYFlags flags) const;
1593
1594     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1595 };
1596
1597 struct CYExtend :
1598     CYBraced
1599 {
1600     CYObject object_;
1601
1602     CYExtend(CYTarget *lhs, CYProperty *properties = NULL) :
1603         CYBraced(lhs),
1604         object_(properties)
1605     {
1606     }
1607
1608     virtual CYTarget *Replace(CYContext &context);
1609     virtual void Output(CYOutput &out, CYFlags flags) const;
1610 };
1611
1612 struct CYIf :
1613     CYStatement
1614 {
1615     CYExpression *test_;
1616     CYStatement *true_;
1617     CYStatement *false_;
1618
1619     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1620         test_(test),
1621         true_(_true),
1622         false_(_false)
1623     {
1624     }
1625
1626     CYCompact(Long)
1627
1628     virtual CYStatement *Replace(CYContext &context);
1629     virtual void Output(CYOutput &out, CYFlags flags) const;
1630
1631     virtual CYStatement *Return();
1632 };
1633
1634 struct CYDoWhile :
1635     CYStatement
1636 {
1637     CYExpression *test_;
1638     CYStatement *code_;
1639
1640     CYDoWhile(CYExpression *test, CYStatement *code) :
1641         test_(test),
1642         code_(code)
1643     {
1644     }
1645
1646     CYCompact(None)
1647
1648     virtual CYStatement *Replace(CYContext &context);
1649     virtual void Output(CYOutput &out, CYFlags flags) const;
1650 };
1651
1652 struct CYWhile :
1653     CYStatement
1654 {
1655     CYExpression *test_;
1656     CYStatement *code_;
1657
1658     CYWhile(CYExpression *test, CYStatement *code) :
1659         test_(test),
1660         code_(code)
1661     {
1662     }
1663
1664     CYCompact(Long)
1665
1666     virtual CYStatement *Replace(CYContext &context);
1667     virtual void Output(CYOutput &out, CYFlags flags) const;
1668 };
1669
1670 struct CYFunction {
1671     CYFunctionParameter *parameters_;
1672     CYStatement *code_;
1673
1674     CYNonLocal *nonlocal_;
1675     bool implicit_;
1676     CYThisScope this_;
1677     CYIdentifier *super_;
1678
1679     CYFunction(CYFunctionParameter *parameters, CYStatement *code) :
1680         parameters_(parameters),
1681         code_(code),
1682         nonlocal_(NULL),
1683         implicit_(false),
1684         super_(NULL)
1685     {
1686     }
1687
1688     void Replace(CYContext &context);
1689     void Output(CYOutput &out) const;
1690 };
1691
1692 struct CYFunctionExpression :
1693     CYFunction,
1694     CYTarget
1695 {
1696     CYIdentifier *name_;
1697
1698     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
1699         CYFunction(parameters, code),
1700         name_(name)
1701     {
1702     }
1703
1704     CYPrecedence(0)
1705
1706     CYTarget *Replace(CYContext &context) override;
1707     virtual void Output(CYOutput &out, CYFlags flags) const;
1708 };
1709
1710 struct CYFatArrow :
1711     CYFunction,
1712     CYExpression
1713 {
1714     CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
1715         CYFunction(parameters, code)
1716     {
1717     }
1718
1719     CYPrecedence(0)
1720
1721     CYExpression *Replace(CYContext &context) override;
1722     virtual void Output(CYOutput &out, CYFlags flags) const;
1723 };
1724
1725 struct CYRubyProc :
1726     CYFunction,
1727     CYTarget
1728 {
1729     CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) :
1730         CYFunction(parameters, code)
1731     {
1732     }
1733
1734     CYPrecedence(0)
1735
1736     CYTarget *Replace(CYContext &context) override;
1737     virtual void Output(CYOutput &out, CYFlags flags) const;
1738 };
1739
1740 struct CYFunctionStatement :
1741     CYFunction,
1742     CYStatement
1743 {
1744     CYIdentifier *name_;
1745
1746     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
1747         CYFunction(parameters, code),
1748         name_(name)
1749     {
1750     }
1751
1752     CYCompact(None)
1753
1754     CYStatement *Replace(CYContext &context) override;
1755     virtual void Output(CYOutput &out, CYFlags flags) const;
1756 };
1757
1758 struct CYPropertyMethod;
1759
1760 struct CYMethod :
1761     CYFunction,
1762     CYProperty
1763 {
1764     CYMethod(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1765         CYFunction(parameters, code),
1766         CYProperty(name, next)
1767     {
1768     }
1769
1770     virtual CYFunctionExpression *Constructor();
1771
1772     using CYProperty::Replace;
1773     virtual void Replace(CYContext &context);
1774 };
1775
1776 struct CYPropertyGetter :
1777     CYMethod
1778 {
1779     CYPropertyGetter(CYPropertyName *name, CYStatement *code, CYProperty *next = NULL) :
1780         CYMethod(name, NULL, code, next)
1781     {
1782     }
1783
1784     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1785     virtual void Output(CYOutput &out) const;
1786 };
1787
1788 struct CYPropertySetter :
1789     CYMethod
1790 {
1791     CYPropertySetter(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1792         CYMethod(name, parameters, code, next)
1793     {
1794     }
1795
1796     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1797     virtual void Output(CYOutput &out) const;
1798 };
1799
1800 struct CYPropertyMethod :
1801     CYMethod
1802 {
1803     CYPropertyMethod(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1804         CYMethod(name, parameters, code, next)
1805     {
1806     }
1807
1808     bool Update() const override;
1809
1810     virtual CYFunctionExpression *Constructor();
1811
1812     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1813     virtual void Output(CYOutput &out) const;
1814 };
1815
1816 struct CYClassTail :
1817     CYThing
1818 {
1819     CYExpression *extends_;
1820
1821     CYFunctionExpression *constructor_;
1822     CYList<CYProperty> instance_;
1823     CYList<CYProperty> static_;
1824
1825     CYClassTail(CYExpression *extends) :
1826         extends_(extends),
1827         constructor_(NULL)
1828     {
1829     }
1830
1831     void Output(CYOutput &out) const;
1832 };
1833
1834 struct CYClassExpression :
1835     CYTarget
1836 {
1837     CYIdentifier *name_;
1838     CYClassTail *tail_;
1839
1840     CYClassExpression(CYIdentifier *name, CYClassTail *tail) :
1841         name_(name),
1842         tail_(tail)
1843     {
1844     }
1845
1846     CYPrecedence(0)
1847
1848     CYTarget *Replace(CYContext &context) override;
1849     virtual void Output(CYOutput &out, CYFlags flags) const;
1850 };
1851
1852 struct CYClassStatement :
1853     CYStatement
1854 {
1855     CYIdentifier *name_;
1856     CYClassTail *tail_;
1857
1858     CYClassStatement(CYIdentifier *name, CYClassTail *tail) :
1859         name_(name),
1860         tail_(tail)
1861     {
1862     }
1863
1864     CYCompact(Long)
1865
1866     CYStatement *Replace(CYContext &context) override;
1867     virtual void Output(CYOutput &out, CYFlags flags) const;
1868 };
1869
1870 struct CYSuperCall :
1871     CYTarget
1872 {
1873     CYArgument *arguments_;
1874
1875     CYSuperCall(CYArgument *arguments) :
1876         arguments_(arguments)
1877     {
1878     }
1879
1880     CYPrecedence(2)
1881
1882     CYTarget *Replace(CYContext &context) override;
1883     virtual void Output(CYOutput &out, CYFlags flags) const;
1884 };
1885
1886 struct CYSuperAccess :
1887     CYTarget
1888 {
1889     CYExpression *property_;
1890
1891     CYSuperAccess(CYExpression *property) :
1892         property_(property)
1893     {
1894     }
1895
1896     CYPrecedence(1)
1897
1898     CYTarget *Replace(CYContext &context) override;
1899     virtual void Output(CYOutput &out, CYFlags flags) const;
1900 };
1901
1902 struct CYExpress :
1903     CYForInitializer
1904 {
1905     CYExpression *expression_;
1906
1907     CYExpress(CYExpression *expression) :
1908         expression_(expression)
1909     {
1910         if (expression_ == NULL)
1911             throw;
1912     }
1913
1914     CYCompact(None)
1915
1916     CYForInitializer *Replace(CYContext &context) override;
1917     virtual void Output(CYOutput &out, CYFlags flags) const;
1918
1919     virtual CYStatement *Return();
1920 };
1921
1922 struct CYContinue :
1923     CYStatement
1924 {
1925     CYIdentifier *label_;
1926
1927     CYContinue(CYIdentifier *label) :
1928         label_(label)
1929     {
1930     }
1931
1932     CYCompact(Short)
1933
1934     CYStatement *Replace(CYContext &context) override;
1935     virtual void Output(CYOutput &out, CYFlags flags) const;
1936 };
1937
1938 struct CYBreak :
1939     CYStatement
1940 {
1941     CYIdentifier *label_;
1942
1943     CYBreak(CYIdentifier *label) :
1944         label_(label)
1945     {
1946     }
1947
1948     CYCompact(Short)
1949
1950     CYStatement *Replace(CYContext &context) override;
1951     virtual void Output(CYOutput &out, CYFlags flags) const;
1952 };
1953
1954 struct CYReturn :
1955     CYStatement
1956 {
1957     CYExpression *value_;
1958
1959     CYReturn(CYExpression *value) :
1960         value_(value)
1961     {
1962     }
1963
1964     CYCompact(None)
1965
1966     CYStatement *Replace(CYContext &context) override;
1967     virtual void Output(CYOutput &out, CYFlags flags) const;
1968 };
1969
1970 struct CYYieldGenerator :
1971     CYExpression
1972 {
1973     CYExpression *value_;
1974
1975     CYYieldGenerator(CYExpression *value) :
1976         value_(value)
1977     {
1978     }
1979
1980     CYPrecedence(0)
1981
1982     CYExpression *Replace(CYContext &context) override;
1983     virtual void Output(CYOutput &out, CYFlags flags) const;
1984 };
1985
1986 struct CYYieldValue :
1987     CYExpression
1988 {
1989     CYExpression *value_;
1990
1991     CYYieldValue(CYExpression *value) :
1992         value_(value)
1993     {
1994     }
1995
1996     CYPrecedence(0)
1997
1998     virtual CYExpression *Replace(CYContext &context);
1999     virtual void Output(CYOutput &out, CYFlags flags) const;
2000 };
2001
2002 struct CYEmpty :
2003     CYForInitializer
2004 {
2005     CYCompact(Short)
2006
2007     virtual CYForInitializer *Replace(CYContext &context);
2008     virtual void Output(CYOutput &out, CYFlags flags) const;
2009 };
2010
2011 struct CYFinally :
2012     CYThing
2013 {
2014     CYStatement *code_;
2015
2016     CYFinally(CYStatement *code) :
2017         code_(code)
2018     {
2019     }
2020
2021     void Replace(CYContext &context);
2022     virtual void Output(CYOutput &out) const;
2023 };
2024
2025 struct CYTypeSpecifier :
2026     CYThing
2027 {
2028     virtual CYTarget *Replace(CYContext &context) = 0;
2029 };
2030
2031 struct CYTypeError :
2032     CYTypeSpecifier
2033 {
2034     CYTypeError() {
2035     }
2036
2037     virtual CYTarget *Replace(CYContext &context);
2038     virtual void Output(CYOutput &out) const;
2039 };
2040
2041 enum CYTypeSigning {
2042     CYTypeNeutral,
2043     CYTypeSigned,
2044     CYTypeUnsigned,
2045 };
2046
2047 struct CYTypeCharacter :
2048     CYTypeSpecifier
2049 {
2050     CYTypeSigning signing_;
2051
2052     CYTypeCharacter(CYTypeSigning signing) :
2053         signing_(signing)
2054     {
2055     }
2056
2057     virtual CYTarget *Replace(CYContext &context);
2058     virtual void Output(CYOutput &out) const;
2059 };
2060
2061 struct CYTypeIntegral :
2062     CYTypeSpecifier
2063 {
2064     CYTypeSigning signing_;
2065     int length_;
2066
2067     CYTypeIntegral(CYTypeSigning signing, int length = 1) :
2068         signing_(signing),
2069         length_(length)
2070     {
2071     }
2072
2073     CYTypeIntegral *Long() {
2074         if (length_ != 1 && length_ != 2)
2075             return NULL;
2076         ++length_;
2077         return this;
2078     }
2079
2080     CYTypeIntegral *Short() {
2081         if (length_ != 1)
2082             return NULL;
2083         --length_;
2084         return this;
2085     }
2086
2087     CYTypeIntegral *Signed() {
2088         if (signing_ != CYTypeNeutral)
2089             return NULL;
2090         signing_ = CYTypeSigned;
2091         return this;
2092     }
2093
2094     CYTypeIntegral *Unsigned() {
2095         if (signing_ != CYTypeNeutral)
2096             return NULL;
2097         signing_ = CYTypeUnsigned;
2098         return this;
2099     }
2100
2101     virtual CYTarget *Replace(CYContext &context);
2102     virtual void Output(CYOutput &out) const;
2103 };
2104
2105 struct CYTypeVoid :
2106     CYTypeSpecifier
2107 {
2108     CYTypeVoid() {
2109     }
2110
2111     virtual CYTarget *Replace(CYContext &context);
2112     virtual void Output(CYOutput &out) const;
2113 };
2114
2115 struct CYTypeReference :
2116     CYTypeSpecifier
2117 {
2118     CYIdentifier *name_;
2119
2120     CYTypeReference(CYIdentifier *name) :
2121         name_(name)
2122     {
2123     }
2124
2125     virtual CYTarget *Replace(CYContext &context);
2126     virtual void Output(CYOutput &out) const;
2127 };
2128
2129 struct CYTypeVariable :
2130     CYTypeSpecifier
2131 {
2132     CYIdentifier *name_;
2133
2134     CYTypeVariable(CYIdentifier *name) :
2135         name_(name)
2136     {
2137     }
2138
2139     CYTypeVariable(const char *name) :
2140         name_(new($pool) CYIdentifier(name))
2141     {
2142     }
2143
2144     virtual CYTarget *Replace(CYContext &context);
2145     virtual void Output(CYOutput &out) const;
2146 };
2147
2148 struct CYTypeFunctionWith;
2149
2150 struct CYTypeModifier :
2151     CYNext<CYTypeModifier>
2152 {
2153     CYTypeModifier(CYTypeModifier *next) :
2154         CYNext<CYTypeModifier>(next)
2155     {
2156     }
2157
2158     virtual int Precedence() const = 0;
2159
2160     virtual CYTarget *Replace_(CYContext &context, CYTarget *type) = 0;
2161     CYTarget *Replace(CYContext &context, CYTarget *type);
2162
2163     virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0;
2164     void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const;
2165
2166     virtual CYTypeFunctionWith *Function() { return NULL; }
2167 };
2168
2169 struct CYTypeArrayOf :
2170     CYTypeModifier
2171 {
2172     CYExpression *size_;
2173
2174     CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) :
2175         CYTypeModifier(next),
2176         size_(size)
2177     {
2178     }
2179
2180     CYPrecedence(1)
2181
2182     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2183     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2184 };
2185
2186 struct CYTypeConstant :
2187     CYTypeModifier
2188 {
2189     CYTypeConstant(CYTypeModifier *next = NULL) :
2190         CYTypeModifier(next)
2191     {
2192     }
2193
2194     CYPrecedence(0)
2195
2196     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2197     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2198 };
2199
2200 struct CYTypePointerTo :
2201     CYTypeModifier
2202 {
2203     CYTypePointerTo(CYTypeModifier *next = NULL) :
2204         CYTypeModifier(next)
2205     {
2206     }
2207
2208     CYPrecedence(0)
2209
2210     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2211     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2212 };
2213
2214 struct CYTypeVolatile :
2215     CYTypeModifier
2216 {
2217     CYTypeVolatile(CYTypeModifier *next = NULL) :
2218         CYTypeModifier(next)
2219     {
2220     }
2221
2222     CYPrecedence(0)
2223
2224     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2225     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2226 };
2227
2228 struct CYTypedIdentifier :
2229     CYNext<CYTypedIdentifier>,
2230     CYThing
2231 {
2232     CYLocation location_;
2233     CYIdentifier *identifier_;
2234     CYTypeSpecifier *specifier_;
2235     CYTypeModifier *modifier_;
2236
2237     CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) :
2238         location_(location),
2239         identifier_(identifier),
2240         specifier_(NULL),
2241         modifier_(NULL)
2242     {
2243     }
2244
2245     CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) :
2246         identifier_(NULL),
2247         specifier_(specifier),
2248         modifier_(modifier)
2249     {
2250     }
2251
2252     inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) {
2253         CYSetLast(modifier_) = modifier;
2254         return this;
2255     }
2256
2257     virtual CYTarget *Replace(CYContext &context);
2258     virtual void Output(CYOutput &out) const;
2259
2260     CYTypeFunctionWith *Function();
2261 };
2262
2263 struct CYEncodedType :
2264     CYTarget
2265 {
2266     CYTypedIdentifier *typed_;
2267
2268     CYEncodedType(CYTypedIdentifier *typed) :
2269         typed_(typed)
2270     {
2271     }
2272
2273     CYPrecedence(1)
2274
2275     virtual CYTarget *Replace(CYContext &context);
2276     virtual void Output(CYOutput &out, CYFlags flags) const;
2277 };
2278
2279 struct CYTypedParameter :
2280     CYNext<CYTypedParameter>,
2281     CYThing
2282 {
2283     CYTypedIdentifier *typed_;
2284
2285     CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) :
2286         CYNext<CYTypedParameter>(next),
2287         typed_(typed)
2288     {
2289     }
2290
2291     CYArgument *Argument(CYContext &context);
2292     CYFunctionParameter *Parameters(CYContext &context);
2293     CYExpression *TypeSignature(CYContext &context, CYExpression *prefix);
2294
2295     virtual void Output(CYOutput &out) const;
2296 };
2297
2298 struct CYTypedFormal {
2299     bool variadic_;
2300     CYTypedParameter *parameters_;
2301
2302     CYTypedFormal(bool variadic) :
2303         variadic_(variadic),
2304         parameters_(NULL)
2305     {
2306     }
2307 };
2308
2309 struct CYLambda :
2310     CYTarget
2311 {
2312     CYTypedIdentifier *typed_;
2313     CYTypedParameter *parameters_;
2314     CYStatement *code_;
2315
2316     CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :
2317         typed_(typed),
2318         parameters_(parameters),
2319         code_(code)
2320     {
2321     }
2322
2323     CYPrecedence(1)
2324
2325     virtual CYTarget *Replace(CYContext &context);
2326     virtual void Output(CYOutput &out, CYFlags flags) const;
2327 };
2328
2329 struct CYModule :
2330     CYNext<CYModule>,
2331     CYThing
2332 {
2333     CYWord *part_;
2334
2335     CYModule(CYWord *part, CYModule *next = NULL) :
2336         CYNext<CYModule>(next),
2337         part_(part)
2338     {
2339     }
2340
2341     CYString *Replace(CYContext &context, const char *separator) const;
2342     void Output(CYOutput &out) const;
2343 };
2344
2345 struct CYImport :
2346     CYStatement
2347 {
2348     CYModule *module_;
2349
2350     CYImport(CYModule *module) :
2351         module_(module)
2352     {
2353     }
2354
2355     CYCompact(None)
2356
2357     virtual CYStatement *Replace(CYContext &context);
2358     virtual void Output(CYOutput &out, CYFlags flags) const;
2359 };
2360
2361 struct CYImportSpecifier :
2362     CYNext<CYImportSpecifier>
2363 {
2364     CYWord *name_;
2365     CYIdentifier *binding_;
2366
2367     CYImportSpecifier(CYWord *name, CYIdentifier *binding) :
2368         name_(name),
2369         binding_(binding)
2370     {
2371     }
2372
2373     CYStatement *Replace(CYContext &context, CYIdentifier *module);
2374 };
2375
2376 struct CYImportDeclaration :
2377     CYStatement
2378 {
2379     CYImportSpecifier *specifiers_;
2380     CYString *module_;
2381
2382     CYImportDeclaration(CYImportSpecifier *specifiers, CYString *module) :
2383         specifiers_(specifiers),
2384         module_(module)
2385     {
2386     }
2387
2388     CYCompact(None)
2389
2390     virtual CYStatement *Replace(CYContext &context);
2391     virtual void Output(CYOutput &out, CYFlags flags) const;
2392 };
2393
2394 struct CYExternal :
2395     CYStatement
2396 {
2397     CYString *abi_;
2398     CYTypedIdentifier *typed_;
2399
2400     CYExternal(CYString *abi, CYTypedIdentifier *typed) :
2401         abi_(abi),
2402         typed_(typed)
2403     {
2404     }
2405
2406     CYCompact(None)
2407
2408     virtual CYStatement *Replace(CYContext &context);
2409     virtual void Output(CYOutput &out, CYFlags flags) const;
2410 };
2411
2412 struct CYTypeExpression :
2413     CYTarget
2414 {
2415     CYTypedIdentifier *typed_;
2416
2417     CYTypeExpression(CYTypedIdentifier *typed) :
2418         typed_(typed)
2419     {
2420     }
2421
2422     CYPrecedence(0)
2423
2424     virtual CYTarget *Replace(CYContext &context);
2425     virtual void Output(CYOutput &out, CYFlags flags) const;
2426 };
2427
2428 struct CYTypeDefinition :
2429     CYStatement
2430 {
2431     CYTypedIdentifier *typed_;
2432
2433     CYTypeDefinition(CYTypedIdentifier *typed) :
2434         typed_(typed)
2435     {
2436     }
2437
2438     CYCompact(None)
2439
2440     virtual CYStatement *Replace(CYContext &context);
2441     virtual void Output(CYOutput &out, CYFlags flags) const;
2442 };
2443
2444 struct CYTypeBlockWith :
2445     CYTypeModifier
2446 {
2447     CYTypedParameter *parameters_;
2448
2449     CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
2450         CYTypeModifier(next),
2451         parameters_(parameters)
2452     {
2453     }
2454
2455     CYPrecedence(0)
2456
2457     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2458     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2459 };
2460
2461 struct CYTypeFunctionWith :
2462     CYTypeModifier
2463 {
2464     bool variadic_;
2465     CYTypedParameter *parameters_;
2466
2467     CYTypeFunctionWith(bool variadic, CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
2468         CYTypeModifier(next),
2469         variadic_(variadic),
2470         parameters_(parameters)
2471     {
2472     }
2473
2474     CYPrecedence(1)
2475
2476     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2477     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2478
2479     virtual CYTypeFunctionWith *Function() { return this; }
2480 };
2481
2482 struct CYTypeStructField :
2483     CYNext<CYTypeStructField>
2484 {
2485     CYTypedIdentifier *typed_;
2486
2487     CYTypeStructField(CYTypedIdentifier *typed, CYTypeStructField *next = NULL) :
2488         CYNext<CYTypeStructField>(next),
2489         typed_(typed)
2490     {
2491     }
2492 };
2493
2494 struct CYStructTail :
2495     CYThing
2496 {
2497     CYTypeStructField *fields_;
2498
2499     CYStructTail(CYTypeStructField *fields) :
2500         fields_(fields)
2501     {
2502     }
2503
2504     CYTarget *Replace(CYContext &context);
2505     virtual void Output(CYOutput &out) const;
2506 };
2507
2508 struct CYTypeStruct :
2509     CYTypeSpecifier
2510 {
2511     CYIdentifier *name_;
2512     CYStructTail *tail_;
2513
2514     CYTypeStruct(CYIdentifier *name, CYStructTail *tail) :
2515         name_(name),
2516         tail_(tail)
2517     {
2518     }
2519
2520     virtual CYTarget *Replace(CYContext &context);
2521     virtual void Output(CYOutput &out) const;
2522 };
2523
2524 struct CYStructDefinition :
2525     CYStatement
2526 {
2527     CYIdentifier *name_;
2528     CYStructTail *tail_;
2529
2530     CYStructDefinition(CYIdentifier *name, CYStructTail *tail) :
2531         name_(name),
2532         tail_(tail)
2533     {
2534     }
2535
2536     CYCompact(None)
2537
2538     virtual CYStatement *Replace(CYContext &context);
2539     virtual void Output(CYOutput &out, CYFlags flags) const;
2540 };
2541
2542 namespace cy {
2543 namespace Syntax {
2544
2545 struct Catch :
2546     CYThing
2547 {
2548     CYIdentifier *name_;
2549     CYStatement *code_;
2550
2551     Catch(CYIdentifier *name, CYStatement *code) :
2552         name_(name),
2553         code_(code)
2554     {
2555     }
2556
2557     void Replace(CYContext &context);
2558     virtual void Output(CYOutput &out) const;
2559 };
2560
2561 struct Try :
2562     CYStatement
2563 {
2564     CYStatement *code_;
2565     Catch *catch_;
2566     CYFinally *finally_;
2567
2568     Try(CYStatement *code, Catch *_catch, CYFinally *finally) :
2569         code_(code),
2570         catch_(_catch),
2571         finally_(finally)
2572     {
2573     }
2574
2575     CYCompact(Short)
2576
2577     virtual CYStatement *Replace(CYContext &context);
2578     virtual void Output(CYOutput &out, CYFlags flags) const;
2579 };
2580
2581 struct Throw :
2582     CYStatement
2583 {
2584     CYExpression *value_;
2585
2586     Throw(CYExpression *value = NULL) :
2587         value_(value)
2588     {
2589     }
2590
2591     CYCompact(None)
2592
2593     virtual CYStatement *Replace(CYContext &context);
2594     virtual void Output(CYOutput &out, CYFlags flags) const;
2595 };
2596
2597 } }
2598
2599 struct CYWith :
2600     CYStatement
2601 {
2602     CYExpression *scope_;
2603     CYStatement *code_;
2604
2605     CYWith(CYExpression *scope, CYStatement *code) :
2606         scope_(scope),
2607         code_(code)
2608     {
2609     }
2610
2611     CYCompact(Long)
2612
2613     virtual CYStatement *Replace(CYContext &context);
2614     virtual void Output(CYOutput &out, CYFlags flags) const;
2615 };
2616
2617 struct CYSwitch :
2618     CYStatement
2619 {
2620     CYExpression *value_;
2621     CYClause *clauses_;
2622
2623     CYSwitch(CYExpression *value, CYClause *clauses) :
2624         value_(value),
2625         clauses_(clauses)
2626     {
2627     }
2628
2629     CYCompact(Long)
2630
2631     virtual CYStatement *Replace(CYContext &context);
2632     virtual void Output(CYOutput &out, CYFlags flags) const;
2633 };
2634
2635 struct CYDebugger :
2636     CYStatement
2637 {
2638     CYDebugger()
2639     {
2640     }
2641
2642     CYCompact(None)
2643
2644     virtual CYStatement *Replace(CYContext &context);
2645     virtual void Output(CYOutput &out, CYFlags flags) const;
2646 };
2647
2648 struct CYCondition :
2649     CYExpression
2650 {
2651     CYExpression *test_;
2652     CYExpression *true_;
2653     CYExpression *false_;
2654
2655     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
2656         test_(test),
2657         true_(_true),
2658         false_(_false)
2659     {
2660     }
2661
2662     CYPrecedence(15)
2663
2664     virtual CYExpression *Replace(CYContext &context);
2665     virtual void Output(CYOutput &out, CYFlags flags) const;
2666 };
2667
2668 struct CYAddressOf :
2669     CYPrefix
2670 {
2671     CYAddressOf(CYExpression *rhs) :
2672         CYPrefix(rhs)
2673     {
2674     }
2675
2676     virtual const char *Operator() const {
2677         return "&";
2678     }
2679
2680     CYAlphabetic(false)
2681
2682     virtual CYExpression *Replace(CYContext &context);
2683 };
2684
2685 struct CYIndirect :
2686     CYTarget
2687 {
2688     CYExpression *rhs_;
2689
2690     CYIndirect(CYExpression *rhs) :
2691         rhs_(rhs)
2692     {
2693     }
2694
2695     // XXX: this should be checked
2696     CYPrecedence(2)
2697
2698     virtual CYTarget *Replace(CYContext &context);
2699     virtual void Output(CYOutput &out, CYFlags flags) const;
2700 };
2701
2702 #define CYReplace \
2703     virtual CYExpression *Replace(CYContext &context);
2704
2705 #define CYPostfix_(op, name, args...) \
2706     struct CY ## name : \
2707         CYPostfix \
2708     { args \
2709         CY ## name(CYExpression *lhs) : \
2710             CYPostfix(lhs) \
2711         { \
2712         } \
2713     \
2714         virtual const char *Operator() const { \
2715             return op; \
2716         } \
2717     };
2718
2719 #define CYPrefix_(alphabetic, op, name, args...) \
2720     struct CY ## name : \
2721         CYPrefix \
2722     { args \
2723         CY ## name(CYExpression *rhs) : \
2724             CYPrefix(rhs) \
2725         { \
2726         } \
2727     \
2728         CYAlphabetic(alphabetic) \
2729     \
2730         virtual const char *Operator() const { \
2731             return op; \
2732         } \
2733     };
2734
2735 #define CYInfix_(alphabetic, precedence, op, name, args...) \
2736     struct CY ## name : \
2737         CYInfix \
2738     { args \
2739         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
2740             CYInfix(lhs, rhs) \
2741         { \
2742         } \
2743     \
2744         CYAlphabetic(alphabetic) \
2745         CYPrecedence(precedence) \
2746     \
2747         virtual const char *Operator() const { \
2748             return op; \
2749         } \
2750     };
2751
2752 #define CYAssignment_(op, name, args...) \
2753     struct CY ## name ## Assign : \
2754         CYAssignment \
2755     { args \
2756         CY ## name ## Assign(CYTarget *lhs, CYExpression *rhs) : \
2757             CYAssignment(lhs, rhs) \
2758         { \
2759         } \
2760     \
2761         virtual const char *Operator() const { \
2762             return op; \
2763         } \
2764     };
2765
2766 CYPostfix_("++", PostIncrement)
2767 CYPostfix_("--", PostDecrement)
2768
2769 CYPrefix_(true, "delete", Delete)
2770 CYPrefix_(true, "void", Void)
2771 CYPrefix_(true, "typeof", TypeOf)
2772 CYPrefix_(false, "++", PreIncrement)
2773 CYPrefix_(false, "--", PreDecrement)
2774 CYPrefix_(false, "+", Affirm)
2775 CYPrefix_(false, "-", Negate)
2776 CYPrefix_(false, "~", BitwiseNot)
2777 CYPrefix_(false, "!", LogicalNot)
2778
2779 CYInfix_(false, 5, "*", Multiply, CYReplace)
2780 CYInfix_(false, 5, "/", Divide)
2781 CYInfix_(false, 5, "%", Modulus)
2782 CYInfix_(false, 6, "+", Add, CYReplace)
2783 CYInfix_(false, 6, "-", Subtract)
2784 CYInfix_(false, 7, "<<", ShiftLeft)
2785 CYInfix_(false, 7, ">>", ShiftRightSigned)
2786 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
2787 CYInfix_(false, 8, "<", Less)
2788 CYInfix_(false, 8, ">", Greater)
2789 CYInfix_(false, 8, "<=", LessOrEqual)
2790 CYInfix_(false, 8, ">=", GreaterOrEqual)
2791 CYInfix_(true, 8, "instanceof", InstanceOf)
2792 CYInfix_(true, 8, "in", In)
2793 CYInfix_(false, 9, "==", Equal)
2794 CYInfix_(false, 9, "!=", NotEqual)
2795 CYInfix_(false, 9, "===", Identical)
2796 CYInfix_(false, 9, "!==", NotIdentical)
2797 CYInfix_(false, 10, "&", BitwiseAnd)
2798 CYInfix_(false, 11, "^", BitwiseXOr)
2799 CYInfix_(false, 12, "|", BitwiseOr)
2800 CYInfix_(false, 13, "&&", LogicalAnd)
2801 CYInfix_(false, 14, "||", LogicalOr)
2802
2803 CYAssignment_("=", )
2804 CYAssignment_("*=", Multiply)
2805 CYAssignment_("/=", Divide)
2806 CYAssignment_("%=", Modulus)
2807 CYAssignment_("+=", Add)
2808 CYAssignment_("-=", Subtract)
2809 CYAssignment_("<<=", ShiftLeft)
2810 CYAssignment_(">>=", ShiftRightSigned)
2811 CYAssignment_(">>>=", ShiftRightUnsigned)
2812 CYAssignment_("&=", BitwiseAnd)
2813 CYAssignment_("^=", BitwiseXOr)
2814 CYAssignment_("|=", BitwiseOr)
2815
2816 #endif/*CYCRIPT_PARSER_HPP*/