Syntax.hpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  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 struct CYSubscriptMember :
1489     CYMember
1490 {
1491     CYSubscriptMember(CYExpression *object, CYExpression *property) :
1492         CYMember(object, property)
1493     {
1494     }
1495
1496     CYPrecedence(1)
1497
1498     virtual CYTarget *Replace(CYContext &context);
1499     virtual void Output(CYOutput &out, CYFlags flags) const;
1500 };
1501
1502 namespace cy {
1503 namespace Syntax {
1504
1505 struct New :
1506     CYTarget
1507 {
1508     CYExpression *constructor_;
1509     CYArgument *arguments_;
1510
1511     New(CYExpression *constructor, CYArgument *arguments = NULL) :
1512         constructor_(constructor),
1513         arguments_(arguments)
1514     {
1515     }
1516
1517     virtual int Precedence() const {
1518         return arguments_ == NULL ? 2 : 1;
1519     }
1520
1521     virtual bool IsNew() const {
1522         return true;
1523     }
1524
1525     virtual CYTarget *Replace(CYContext &context);
1526     virtual void Output(CYOutput &out, CYFlags flags) const;
1527
1528     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1529 };
1530
1531 } }
1532
1533 struct CYApply :
1534     CYTarget
1535 {
1536     CYArgument *arguments_;
1537
1538     CYApply(CYArgument *arguments = NULL) :
1539         arguments_(arguments)
1540     {
1541     }
1542
1543     CYPrecedence(1)
1544
1545     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1546 };
1547
1548 struct CYCall :
1549     CYApply
1550 {
1551     CYExpression *function_;
1552
1553     CYCall(CYExpression *function, CYArgument *arguments = NULL) :
1554         CYApply(arguments),
1555         function_(function)
1556     {
1557     }
1558
1559     virtual void Output(CYOutput &out, CYFlags flags) const;
1560     virtual CYTarget *Replace(CYContext &context);
1561 };
1562
1563 struct CYEval :
1564     CYApply
1565 {
1566     CYEval(CYArgument *arguments) :
1567         CYApply(arguments)
1568     {
1569     }
1570
1571     virtual void Output(CYOutput &out, CYFlags flags) const;
1572     virtual CYTarget *Replace(CYContext &context);
1573 };
1574
1575 struct CYRubyProc;
1576
1577 struct CYBraced :
1578     CYTarget
1579 {
1580     CYTarget *lhs_;
1581
1582     CYBraced(CYTarget *lhs = NULL) :
1583         lhs_(lhs)
1584     {
1585     }
1586
1587     CYPrecedence(1)
1588
1589     void SetLeft(CYTarget *lhs) {
1590         lhs_ = lhs;
1591     }
1592 };
1593
1594 struct CYRubyBlock :
1595     CYBraced
1596 {
1597     CYRubyProc *proc_;
1598
1599     CYRubyBlock(CYTarget *lhs, CYRubyProc *proc) :
1600         CYBraced(lhs),
1601         proc_(proc)
1602     {
1603     }
1604
1605     virtual CYTarget *Replace(CYContext &context);
1606     virtual void Output(CYOutput &out, CYFlags flags) const;
1607
1608     virtual CYTarget *AddArgument(CYContext &context, CYExpression *value);
1609 };
1610
1611 struct CYExtend :
1612     CYBraced
1613 {
1614     CYObject object_;
1615
1616     CYExtend(CYTarget *lhs, CYProperty *properties = NULL) :
1617         CYBraced(lhs),
1618         object_(properties)
1619     {
1620     }
1621
1622     virtual CYTarget *Replace(CYContext &context);
1623     virtual void Output(CYOutput &out, CYFlags flags) const;
1624 };
1625
1626 struct CYIf :
1627     CYStatement
1628 {
1629     CYExpression *test_;
1630     CYStatement *true_;
1631     CYStatement *false_;
1632
1633     CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) :
1634         test_(test),
1635         true_(_true),
1636         false_(_false)
1637     {
1638     }
1639
1640     CYCompact(Long)
1641
1642     virtual CYStatement *Replace(CYContext &context);
1643     virtual void Output(CYOutput &out, CYFlags flags) const;
1644
1645     virtual CYStatement *Return();
1646 };
1647
1648 struct CYDoWhile :
1649     CYStatement
1650 {
1651     CYExpression *test_;
1652     CYStatement *code_;
1653
1654     CYDoWhile(CYExpression *test, CYStatement *code) :
1655         test_(test),
1656         code_(code)
1657     {
1658     }
1659
1660     CYCompact(None)
1661
1662     virtual CYStatement *Replace(CYContext &context);
1663     virtual void Output(CYOutput &out, CYFlags flags) const;
1664 };
1665
1666 struct CYWhile :
1667     CYStatement
1668 {
1669     CYExpression *test_;
1670     CYStatement *code_;
1671
1672     CYWhile(CYExpression *test, CYStatement *code) :
1673         test_(test),
1674         code_(code)
1675     {
1676     }
1677
1678     CYCompact(Long)
1679
1680     virtual CYStatement *Replace(CYContext &context);
1681     virtual void Output(CYOutput &out, CYFlags flags) const;
1682 };
1683
1684 struct CYFunction {
1685     CYFunctionParameter *parameters_;
1686     CYStatement *code_;
1687
1688     CYNonLocal *nonlocal_;
1689     bool implicit_;
1690     CYThisScope this_;
1691     CYIdentifier *super_;
1692
1693     CYFunction(CYFunctionParameter *parameters, CYStatement *code) :
1694         parameters_(parameters),
1695         code_(code),
1696         nonlocal_(NULL),
1697         implicit_(false),
1698         super_(NULL)
1699     {
1700     }
1701
1702     void Replace(CYContext &context);
1703     void Output(CYOutput &out) const;
1704 };
1705
1706 struct CYFunctionExpression :
1707     CYFunction,
1708     CYTarget
1709 {
1710     CYIdentifier *name_;
1711
1712     CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
1713         CYFunction(parameters, code),
1714         name_(name)
1715     {
1716     }
1717
1718     CYPrecedence(0)
1719
1720     CYTarget *Replace(CYContext &context) override;
1721     virtual void Output(CYOutput &out, CYFlags flags) const;
1722 };
1723
1724 struct CYFatArrow :
1725     CYFunction,
1726     CYExpression
1727 {
1728     CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
1729         CYFunction(parameters, code)
1730     {
1731     }
1732
1733     CYPrecedence(0)
1734
1735     CYExpression *Replace(CYContext &context) override;
1736     virtual void Output(CYOutput &out, CYFlags flags) const;
1737 };
1738
1739 struct CYRubyProc :
1740     CYFunction,
1741     CYTarget
1742 {
1743     CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) :
1744         CYFunction(parameters, code)
1745     {
1746     }
1747
1748     CYPrecedence(0)
1749
1750     CYTarget *Replace(CYContext &context) override;
1751     virtual void Output(CYOutput &out, CYFlags flags) const;
1752 };
1753
1754 struct CYFunctionStatement :
1755     CYFunction,
1756     CYStatement
1757 {
1758     CYIdentifier *name_;
1759
1760     CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
1761         CYFunction(parameters, code),
1762         name_(name)
1763     {
1764     }
1765
1766     CYCompact(None)
1767
1768     CYStatement *Replace(CYContext &context) override;
1769     virtual void Output(CYOutput &out, CYFlags flags) const;
1770 };
1771
1772 struct CYPropertyMethod;
1773
1774 struct CYMethod :
1775     CYFunction,
1776     CYProperty
1777 {
1778     CYMethod(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1779         CYFunction(parameters, code),
1780         CYProperty(name, next)
1781     {
1782     }
1783
1784     virtual CYFunctionExpression *Constructor();
1785
1786     using CYProperty::Replace;
1787     virtual void Replace(CYContext &context);
1788 };
1789
1790 struct CYPropertyGetter :
1791     CYMethod
1792 {
1793     CYPropertyGetter(CYPropertyName *name, CYStatement *code, CYProperty *next = NULL) :
1794         CYMethod(name, NULL, code, next)
1795     {
1796     }
1797
1798     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1799     virtual void Output(CYOutput &out) const;
1800 };
1801
1802 struct CYPropertySetter :
1803     CYMethod
1804 {
1805     CYPropertySetter(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1806         CYMethod(name, parameters, code, next)
1807     {
1808     }
1809
1810     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1811     virtual void Output(CYOutput &out) const;
1812 };
1813
1814 struct CYPropertyMethod :
1815     CYMethod
1816 {
1817     CYPropertyMethod(CYPropertyName *name, CYFunctionParameter *parameters, CYStatement *code, CYProperty *next = NULL) :
1818         CYMethod(name, parameters, code, next)
1819     {
1820     }
1821
1822     bool Update() const override;
1823
1824     virtual CYFunctionExpression *Constructor();
1825
1826     virtual void Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect);
1827     virtual void Output(CYOutput &out) const;
1828 };
1829
1830 struct CYClassTail :
1831     CYThing
1832 {
1833     CYExpression *extends_;
1834
1835     CYFunctionExpression *constructor_;
1836     CYList<CYProperty> instance_;
1837     CYList<CYProperty> static_;
1838
1839     CYClassTail(CYExpression *extends) :
1840         extends_(extends),
1841         constructor_(NULL)
1842     {
1843     }
1844
1845     void Output(CYOutput &out) const;
1846 };
1847
1848 struct CYClassExpression :
1849     CYTarget
1850 {
1851     CYIdentifier *name_;
1852     CYClassTail *tail_;
1853
1854     CYClassExpression(CYIdentifier *name, CYClassTail *tail) :
1855         name_(name),
1856         tail_(tail)
1857     {
1858     }
1859
1860     CYPrecedence(0)
1861
1862     CYTarget *Replace(CYContext &context) override;
1863     virtual void Output(CYOutput &out, CYFlags flags) const;
1864 };
1865
1866 struct CYClassStatement :
1867     CYStatement
1868 {
1869     CYIdentifier *name_;
1870     CYClassTail *tail_;
1871
1872     CYClassStatement(CYIdentifier *name, CYClassTail *tail) :
1873         name_(name),
1874         tail_(tail)
1875     {
1876     }
1877
1878     CYCompact(Long)
1879
1880     CYStatement *Replace(CYContext &context) override;
1881     virtual void Output(CYOutput &out, CYFlags flags) const;
1882 };
1883
1884 struct CYSuperCall :
1885     CYTarget
1886 {
1887     CYArgument *arguments_;
1888
1889     CYSuperCall(CYArgument *arguments) :
1890         arguments_(arguments)
1891     {
1892     }
1893
1894     CYPrecedence(2)
1895
1896     CYTarget *Replace(CYContext &context) override;
1897     virtual void Output(CYOutput &out, CYFlags flags) const;
1898 };
1899
1900 struct CYSuperAccess :
1901     CYTarget
1902 {
1903     CYExpression *property_;
1904
1905     CYSuperAccess(CYExpression *property) :
1906         property_(property)
1907     {
1908     }
1909
1910     CYPrecedence(1)
1911
1912     CYTarget *Replace(CYContext &context) override;
1913     virtual void Output(CYOutput &out, CYFlags flags) const;
1914 };
1915
1916 struct CYExpress :
1917     CYForInitializer
1918 {
1919     CYExpression *expression_;
1920
1921     CYExpress(CYExpression *expression) :
1922         expression_(expression)
1923     {
1924         if (expression_ == NULL)
1925             throw;
1926     }
1927
1928     CYCompact(None)
1929
1930     CYForInitializer *Replace(CYContext &context) override;
1931     virtual void Output(CYOutput &out, CYFlags flags) const;
1932
1933     virtual CYStatement *Return();
1934 };
1935
1936 struct CYContinue :
1937     CYStatement
1938 {
1939     CYIdentifier *label_;
1940
1941     CYContinue(CYIdentifier *label) :
1942         label_(label)
1943     {
1944     }
1945
1946     CYCompact(Short)
1947
1948     CYStatement *Replace(CYContext &context) override;
1949     virtual void Output(CYOutput &out, CYFlags flags) const;
1950 };
1951
1952 struct CYBreak :
1953     CYStatement
1954 {
1955     CYIdentifier *label_;
1956
1957     CYBreak(CYIdentifier *label) :
1958         label_(label)
1959     {
1960     }
1961
1962     CYCompact(Short)
1963
1964     CYStatement *Replace(CYContext &context) override;
1965     virtual void Output(CYOutput &out, CYFlags flags) const;
1966 };
1967
1968 struct CYReturn :
1969     CYStatement
1970 {
1971     CYExpression *value_;
1972
1973     CYReturn(CYExpression *value) :
1974         value_(value)
1975     {
1976     }
1977
1978     CYCompact(None)
1979
1980     CYStatement *Replace(CYContext &context) override;
1981     virtual void Output(CYOutput &out, CYFlags flags) const;
1982 };
1983
1984 struct CYYieldGenerator :
1985     CYExpression
1986 {
1987     CYExpression *value_;
1988
1989     CYYieldGenerator(CYExpression *value) :
1990         value_(value)
1991     {
1992     }
1993
1994     CYPrecedence(0)
1995
1996     CYExpression *Replace(CYContext &context) override;
1997     virtual void Output(CYOutput &out, CYFlags flags) const;
1998 };
1999
2000 struct CYYieldValue :
2001     CYExpression
2002 {
2003     CYExpression *value_;
2004
2005     CYYieldValue(CYExpression *value) :
2006         value_(value)
2007     {
2008     }
2009
2010     CYPrecedence(0)
2011
2012     virtual CYExpression *Replace(CYContext &context);
2013     virtual void Output(CYOutput &out, CYFlags flags) const;
2014 };
2015
2016 struct CYEmpty :
2017     CYForInitializer
2018 {
2019     CYCompact(Short)
2020
2021     virtual CYForInitializer *Replace(CYContext &context);
2022     virtual void Output(CYOutput &out, CYFlags flags) const;
2023 };
2024
2025 struct CYFinally :
2026     CYThing
2027 {
2028     CYStatement *code_;
2029
2030     CYFinally(CYStatement *code) :
2031         code_(code)
2032     {
2033     }
2034
2035     void Replace(CYContext &context);
2036     virtual void Output(CYOutput &out) const;
2037 };
2038
2039 struct CYTypeSpecifier :
2040     CYThing
2041 {
2042     virtual CYTarget *Replace(CYContext &context) = 0;
2043 };
2044
2045 struct CYTypeError :
2046     CYTypeSpecifier
2047 {
2048     CYTypeError() {
2049     }
2050
2051     virtual CYTarget *Replace(CYContext &context);
2052     virtual void Output(CYOutput &out) const;
2053 };
2054
2055 enum CYTypeSigning {
2056     CYTypeNeutral,
2057     CYTypeSigned,
2058     CYTypeUnsigned,
2059 };
2060
2061 struct CYTypeCharacter :
2062     CYTypeSpecifier
2063 {
2064     CYTypeSigning signing_;
2065
2066     CYTypeCharacter(CYTypeSigning signing) :
2067         signing_(signing)
2068     {
2069     }
2070
2071     virtual CYTarget *Replace(CYContext &context);
2072     virtual void Output(CYOutput &out) const;
2073 };
2074
2075 struct CYTypeInt128 :
2076     CYTypeSpecifier
2077 {
2078     CYTypeSigning signing_;
2079
2080     CYTypeInt128(CYTypeSigning signing) :
2081         signing_(signing)
2082     {
2083     }
2084
2085     virtual CYTarget *Replace(CYContext &context);
2086     virtual void Output(CYOutput &out) const;
2087 };
2088
2089 struct CYTypeIntegral :
2090     CYTypeSpecifier
2091 {
2092     CYTypeSigning signing_;
2093     int length_;
2094
2095     CYTypeIntegral(CYTypeSigning signing, int length = 1) :
2096         signing_(signing),
2097         length_(length)
2098     {
2099     }
2100
2101     CYTypeIntegral *Long() {
2102         if (length_ != 1 && length_ != 2)
2103             return NULL;
2104         ++length_;
2105         return this;
2106     }
2107
2108     CYTypeIntegral *Short() {
2109         if (length_ != 1)
2110             return NULL;
2111         --length_;
2112         return this;
2113     }
2114
2115     CYTypeIntegral *Signed() {
2116         if (signing_ != CYTypeNeutral)
2117             return NULL;
2118         signing_ = CYTypeSigned;
2119         return this;
2120     }
2121
2122     CYTypeIntegral *Unsigned() {
2123         if (signing_ != CYTypeNeutral)
2124             return NULL;
2125         signing_ = CYTypeUnsigned;
2126         return this;
2127     }
2128
2129     virtual CYTarget *Replace(CYContext &context);
2130     virtual void Output(CYOutput &out) const;
2131 };
2132
2133 struct CYTypeVoid :
2134     CYTypeSpecifier
2135 {
2136     CYTypeVoid() {
2137     }
2138
2139     virtual CYTarget *Replace(CYContext &context);
2140     virtual void Output(CYOutput &out) const;
2141 };
2142
2143 enum CYTypeReferenceKind {
2144     CYTypeReferenceStruct,
2145     CYTypeReferenceEnum,
2146 };
2147
2148 struct CYTypeReference :
2149     CYTypeSpecifier
2150 {
2151     CYTypeReferenceKind kind_;
2152     CYIdentifier *name_;
2153
2154     CYTypeReference(CYTypeReferenceKind kind, CYIdentifier *name) :
2155         kind_(kind),
2156         name_(name)
2157     {
2158     }
2159
2160     virtual CYTarget *Replace(CYContext &context);
2161     virtual void Output(CYOutput &out) const;
2162 };
2163
2164 struct CYTypeVariable :
2165     CYTypeSpecifier
2166 {
2167     CYIdentifier *name_;
2168
2169     CYTypeVariable(CYIdentifier *name) :
2170         name_(name)
2171     {
2172     }
2173
2174     CYTypeVariable(const char *name) :
2175         name_(new($pool) CYIdentifier(name))
2176     {
2177     }
2178
2179     virtual CYTarget *Replace(CYContext &context);
2180     virtual void Output(CYOutput &out) const;
2181 };
2182
2183 struct CYTypeFunctionWith;
2184
2185 struct CYTypeModifier :
2186     CYNext<CYTypeModifier>
2187 {
2188     CYTypeModifier(CYTypeModifier *next) :
2189         CYNext<CYTypeModifier>(next)
2190     {
2191     }
2192
2193     virtual int Precedence() const = 0;
2194
2195     virtual CYTarget *Replace_(CYContext &context, CYTarget *type) = 0;
2196     CYTarget *Replace(CYContext &context, CYTarget *type);
2197
2198     virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0;
2199     void Output(CYOutput &out, int precedence, CYIdentifier *identifier, bool space) const;
2200
2201     virtual CYTypeFunctionWith *Function() { return NULL; }
2202 };
2203
2204 struct CYTypeArrayOf :
2205     CYTypeModifier
2206 {
2207     CYExpression *size_;
2208
2209     CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) :
2210         CYTypeModifier(next),
2211         size_(size)
2212     {
2213     }
2214
2215     CYPrecedence(1)
2216
2217     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2218     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2219 };
2220
2221 struct CYTypeConstant :
2222     CYTypeModifier
2223 {
2224     CYTypeConstant(CYTypeModifier *next = NULL) :
2225         CYTypeModifier(next)
2226     {
2227     }
2228
2229     CYPrecedence(0)
2230
2231     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2232     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2233 };
2234
2235 struct CYTypePointerTo :
2236     CYTypeModifier
2237 {
2238     CYTypePointerTo(CYTypeModifier *next = NULL) :
2239         CYTypeModifier(next)
2240     {
2241     }
2242
2243     CYPrecedence(0)
2244
2245     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2246     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2247 };
2248
2249 struct CYTypeVolatile :
2250     CYTypeModifier
2251 {
2252     CYTypeVolatile(CYTypeModifier *next = NULL) :
2253         CYTypeModifier(next)
2254     {
2255     }
2256
2257     CYPrecedence(0)
2258
2259     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2260     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2261 };
2262
2263 struct CYTypedIdentifier :
2264     CYNext<CYTypedIdentifier>,
2265     CYThing
2266 {
2267     CYLocation location_;
2268     CYIdentifier *identifier_;
2269     CYTypeSpecifier *specifier_;
2270     CYTypeModifier *modifier_;
2271
2272     CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) :
2273         location_(location),
2274         identifier_(identifier),
2275         specifier_(NULL),
2276         modifier_(NULL)
2277     {
2278     }
2279
2280     CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) :
2281         identifier_(NULL),
2282         specifier_(specifier),
2283         modifier_(modifier)
2284     {
2285     }
2286
2287     inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) {
2288         CYSetLast(modifier_) = modifier;
2289         return this;
2290     }
2291
2292     virtual CYTarget *Replace(CYContext &context);
2293     virtual void Output(CYOutput &out) const;
2294
2295     CYTypeFunctionWith *Function();
2296 };
2297
2298 struct CYEncodedType :
2299     CYTarget
2300 {
2301     CYTypedIdentifier *typed_;
2302
2303     CYEncodedType(CYTypedIdentifier *typed) :
2304         typed_(typed)
2305     {
2306     }
2307
2308     CYPrecedence(1)
2309
2310     virtual CYTarget *Replace(CYContext &context);
2311     virtual void Output(CYOutput &out, CYFlags flags) const;
2312 };
2313
2314 struct CYTypedParameter :
2315     CYNext<CYTypedParameter>,
2316     CYThing
2317 {
2318     CYTypedIdentifier *typed_;
2319
2320     CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next = NULL) :
2321         CYNext<CYTypedParameter>(next),
2322         typed_(typed)
2323     {
2324     }
2325
2326     CYArgument *Argument(CYContext &context);
2327     CYFunctionParameter *Parameters(CYContext &context);
2328     CYExpression *TypeSignature(CYContext &context, CYExpression *prefix);
2329
2330     virtual void Output(CYOutput &out) const;
2331 };
2332
2333 struct CYTypedFormal {
2334     bool variadic_;
2335     CYTypedParameter *parameters_;
2336
2337     CYTypedFormal(bool variadic) :
2338         variadic_(variadic),
2339         parameters_(NULL)
2340     {
2341     }
2342 };
2343
2344 struct CYLambda :
2345     CYTarget
2346 {
2347     CYTypedIdentifier *typed_;
2348     CYTypedParameter *parameters_;
2349     CYStatement *code_;
2350
2351     CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :
2352         typed_(typed),
2353         parameters_(parameters),
2354         code_(code)
2355     {
2356     }
2357
2358     CYPrecedence(1)
2359
2360     virtual CYTarget *Replace(CYContext &context);
2361     virtual void Output(CYOutput &out, CYFlags flags) const;
2362 };
2363
2364 struct CYModule :
2365     CYNext<CYModule>,
2366     CYThing
2367 {
2368     CYWord *part_;
2369
2370     CYModule(CYWord *part, CYModule *next = NULL) :
2371         CYNext<CYModule>(next),
2372         part_(part)
2373     {
2374     }
2375
2376     CYString *Replace(CYContext &context, const char *separator) const;
2377     void Output(CYOutput &out) const;
2378 };
2379
2380 struct CYImport :
2381     CYStatement
2382 {
2383     CYModule *module_;
2384
2385     CYImport(CYModule *module) :
2386         module_(module)
2387     {
2388     }
2389
2390     CYCompact(None)
2391
2392     virtual CYStatement *Replace(CYContext &context);
2393     virtual void Output(CYOutput &out, CYFlags flags) const;
2394 };
2395
2396 struct CYImportSpecifier :
2397     CYNext<CYImportSpecifier>
2398 {
2399     CYWord *name_;
2400     CYIdentifier *binding_;
2401
2402     CYImportSpecifier(CYWord *name, CYIdentifier *binding) :
2403         name_(name),
2404         binding_(binding)
2405     {
2406     }
2407
2408     CYStatement *Replace(CYContext &context, CYIdentifier *module);
2409 };
2410
2411 struct CYImportDeclaration :
2412     CYStatement
2413 {
2414     CYImportSpecifier *specifiers_;
2415     CYString *module_;
2416
2417     CYImportDeclaration(CYImportSpecifier *specifiers, CYString *module) :
2418         specifiers_(specifiers),
2419         module_(module)
2420     {
2421     }
2422
2423     CYCompact(None)
2424
2425     virtual CYStatement *Replace(CYContext &context);
2426     virtual void Output(CYOutput &out, CYFlags flags) const;
2427 };
2428
2429 struct CYExternalExpression :
2430     CYTarget
2431 {
2432     CYString *abi_;
2433     CYTypedIdentifier *typed_;
2434
2435     CYExternalExpression(CYString *abi, CYTypedIdentifier *typed) :
2436         abi_(abi),
2437         typed_(typed)
2438     {
2439     }
2440
2441     CYPrecedence(0)
2442
2443     virtual CYTarget *Replace(CYContext &context);
2444     virtual void Output(CYOutput &out, CYFlags flags) const;
2445 };
2446
2447 struct CYExternalDefinition :
2448     CYStatement
2449 {
2450     CYString *abi_;
2451     CYTypedIdentifier *typed_;
2452
2453     CYExternalDefinition(CYString *abi, CYTypedIdentifier *typed) :
2454         abi_(abi),
2455         typed_(typed)
2456     {
2457     }
2458
2459     CYCompact(None)
2460
2461     virtual CYStatement *Replace(CYContext &context);
2462     virtual void Output(CYOutput &out, CYFlags flags) const;
2463 };
2464
2465 struct CYTypeExpression :
2466     CYTarget
2467 {
2468     CYTypedIdentifier *typed_;
2469
2470     CYTypeExpression(CYTypedIdentifier *typed) :
2471         typed_(typed)
2472     {
2473     }
2474
2475     CYPrecedence(0)
2476
2477     virtual CYTarget *Replace(CYContext &context);
2478     virtual void Output(CYOutput &out, CYFlags flags) const;
2479 };
2480
2481 struct CYTypeDefinition :
2482     CYStatement
2483 {
2484     CYTypedIdentifier *typed_;
2485
2486     CYTypeDefinition(CYTypedIdentifier *typed) :
2487         typed_(typed)
2488     {
2489     }
2490
2491     CYCompact(None)
2492
2493     virtual CYStatement *Replace(CYContext &context);
2494     virtual void Output(CYOutput &out, CYFlags flags) const;
2495 };
2496
2497 struct CYTypeBlockWith :
2498     CYTypeModifier
2499 {
2500     CYTypedParameter *parameters_;
2501
2502     CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
2503         CYTypeModifier(next),
2504         parameters_(parameters)
2505     {
2506     }
2507
2508     CYPrecedence(0)
2509
2510     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2511     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2512 };
2513
2514 struct CYTypeFunctionWith :
2515     CYTypeModifier
2516 {
2517     bool variadic_;
2518     CYTypedParameter *parameters_;
2519
2520     CYTypeFunctionWith(bool variadic, CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
2521         CYTypeModifier(next),
2522         variadic_(variadic),
2523         parameters_(parameters)
2524     {
2525     }
2526
2527     CYPrecedence(1)
2528
2529     virtual CYTarget *Replace_(CYContext &context, CYTarget *type);
2530     virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
2531
2532     virtual CYTypeFunctionWith *Function() { return this; }
2533 };
2534
2535 struct CYTypeStructField :
2536     CYNext<CYTypeStructField>
2537 {
2538     CYTypedIdentifier *typed_;
2539
2540     CYTypeStructField(CYTypedIdentifier *typed, CYTypeStructField *next = NULL) :
2541         CYNext<CYTypeStructField>(next),
2542         typed_(typed)
2543     {
2544     }
2545 };
2546
2547 struct CYStructTail :
2548     CYThing
2549 {
2550     CYTypeStructField *fields_;
2551
2552     CYStructTail(CYTypeStructField *fields) :
2553         fields_(fields)
2554     {
2555     }
2556
2557     CYTarget *Replace(CYContext &context);
2558     virtual void Output(CYOutput &out) const;
2559 };
2560
2561 struct CYTypeStruct :
2562     CYTypeSpecifier
2563 {
2564     CYIdentifier *name_;
2565     CYStructTail *tail_;
2566
2567     CYTypeStruct(CYIdentifier *name, CYStructTail *tail) :
2568         name_(name),
2569         tail_(tail)
2570     {
2571     }
2572
2573     virtual CYTarget *Replace(CYContext &context);
2574     virtual void Output(CYOutput &out) const;
2575 };
2576
2577 struct CYStructDefinition :
2578     CYStatement
2579 {
2580     CYIdentifier *name_;
2581     CYStructTail *tail_;
2582
2583     CYStructDefinition(CYIdentifier *name, CYStructTail *tail) :
2584         name_(name),
2585         tail_(tail)
2586     {
2587     }
2588
2589     CYCompact(None)
2590
2591     virtual CYStatement *Replace(CYContext &context);
2592     virtual void Output(CYOutput &out, CYFlags flags) const;
2593 };
2594
2595 struct CYEnumConstant :
2596     CYNext<CYEnumConstant>
2597 {
2598     CYIdentifier *name_;
2599     CYNumber *value_;
2600
2601     CYEnumConstant(CYIdentifier *name, CYNumber *value, CYEnumConstant *next = NULL) :
2602         CYNext<CYEnumConstant>(next),
2603         name_(name),
2604         value_(value)
2605     {
2606     }
2607 };
2608
2609 struct CYTypeEnum :
2610     CYTypeSpecifier
2611 {
2612     CYIdentifier *name_;
2613     CYTypeSpecifier *specifier_;
2614     CYEnumConstant *constants_;
2615
2616     CYTypeEnum(CYIdentifier *name, CYTypeSpecifier *specifier, CYEnumConstant *constants) :
2617         name_(name),
2618         specifier_(specifier),
2619         constants_(constants)
2620     {
2621     }
2622
2623     virtual CYTarget *Replace(CYContext &context);
2624     virtual void Output(CYOutput &out) const;
2625 };
2626
2627 namespace cy {
2628 namespace Syntax {
2629
2630 struct Catch :
2631     CYThing
2632 {
2633     CYIdentifier *name_;
2634     CYStatement *code_;
2635
2636     Catch(CYIdentifier *name, CYStatement *code) :
2637         name_(name),
2638         code_(code)
2639     {
2640     }
2641
2642     void Replace(CYContext &context);
2643     virtual void Output(CYOutput &out) const;
2644 };
2645
2646 struct Try :
2647     CYStatement
2648 {
2649     CYStatement *code_;
2650     Catch *catch_;
2651     CYFinally *finally_;
2652
2653     Try(CYStatement *code, Catch *_catch, CYFinally *finally) :
2654         code_(code),
2655         catch_(_catch),
2656         finally_(finally)
2657     {
2658     }
2659
2660     CYCompact(Short)
2661
2662     virtual CYStatement *Replace(CYContext &context);
2663     virtual void Output(CYOutput &out, CYFlags flags) const;
2664 };
2665
2666 struct Throw :
2667     CYStatement
2668 {
2669     CYExpression *value_;
2670
2671     Throw(CYExpression *value = NULL) :
2672         value_(value)
2673     {
2674     }
2675
2676     CYCompact(None)
2677
2678     virtual CYStatement *Replace(CYContext &context);
2679     virtual void Output(CYOutput &out, CYFlags flags) const;
2680 };
2681
2682 } }
2683
2684 struct CYWith :
2685     CYStatement
2686 {
2687     CYExpression *scope_;
2688     CYStatement *code_;
2689
2690     CYWith(CYExpression *scope, CYStatement *code) :
2691         scope_(scope),
2692         code_(code)
2693     {
2694     }
2695
2696     CYCompact(Long)
2697
2698     virtual CYStatement *Replace(CYContext &context);
2699     virtual void Output(CYOutput &out, CYFlags flags) const;
2700 };
2701
2702 struct CYSwitch :
2703     CYStatement
2704 {
2705     CYExpression *value_;
2706     CYClause *clauses_;
2707
2708     CYSwitch(CYExpression *value, CYClause *clauses) :
2709         value_(value),
2710         clauses_(clauses)
2711     {
2712     }
2713
2714     CYCompact(Long)
2715
2716     virtual CYStatement *Replace(CYContext &context);
2717     virtual void Output(CYOutput &out, CYFlags flags) const;
2718 };
2719
2720 struct CYDebugger :
2721     CYStatement
2722 {
2723     CYDebugger()
2724     {
2725     }
2726
2727     CYCompact(None)
2728
2729     virtual CYStatement *Replace(CYContext &context);
2730     virtual void Output(CYOutput &out, CYFlags flags) const;
2731 };
2732
2733 struct CYCondition :
2734     CYExpression
2735 {
2736     CYExpression *test_;
2737     CYExpression *true_;
2738     CYExpression *false_;
2739
2740     CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
2741         test_(test),
2742         true_(_true),
2743         false_(_false)
2744     {
2745     }
2746
2747     CYPrecedence(15)
2748
2749     virtual CYExpression *Replace(CYContext &context);
2750     virtual void Output(CYOutput &out, CYFlags flags) const;
2751 };
2752
2753 struct CYAddressOf :
2754     CYPrefix
2755 {
2756     CYAddressOf(CYExpression *rhs) :
2757         CYPrefix(rhs)
2758     {
2759     }
2760
2761     virtual const char *Operator() const {
2762         return "&";
2763     }
2764
2765     CYAlphabetic(false)
2766
2767     virtual CYExpression *Replace(CYContext &context);
2768 };
2769
2770 struct CYIndirect :
2771     CYTarget
2772 {
2773     CYExpression *rhs_;
2774
2775     CYIndirect(CYExpression *rhs) :
2776         rhs_(rhs)
2777     {
2778     }
2779
2780     // XXX: this should be checked
2781     CYPrecedence(2)
2782
2783     virtual CYTarget *Replace(CYContext &context);
2784     virtual void Output(CYOutput &out, CYFlags flags) const;
2785 };
2786
2787 #define CYReplace \
2788     virtual CYExpression *Replace(CYContext &context);
2789
2790 #define CYPostfix_(op, name, args...) \
2791     struct CY ## name : \
2792         CYPostfix \
2793     { args \
2794         CY ## name(CYExpression *lhs) : \
2795             CYPostfix(lhs) \
2796         { \
2797         } \
2798     \
2799         virtual const char *Operator() const { \
2800             return op; \
2801         } \
2802     };
2803
2804 #define CYPrefix_(alphabetic, op, name, args...) \
2805     struct CY ## name : \
2806         CYPrefix \
2807     { args \
2808         CY ## name(CYExpression *rhs) : \
2809             CYPrefix(rhs) \
2810         { \
2811         } \
2812     \
2813         CYAlphabetic(alphabetic) \
2814     \
2815         virtual const char *Operator() const { \
2816             return op; \
2817         } \
2818     };
2819
2820 #define CYInfix_(alphabetic, precedence, op, name, args...) \
2821     struct CY ## name : \
2822         CYInfix \
2823     { args \
2824         CY ## name(CYExpression *lhs, CYExpression *rhs) : \
2825             CYInfix(lhs, rhs) \
2826         { \
2827         } \
2828     \
2829         CYAlphabetic(alphabetic) \
2830         CYPrecedence(precedence) \
2831     \
2832         virtual const char *Operator() const { \
2833             return op; \
2834         } \
2835     };
2836
2837 #define CYAssignment_(op, name, args...) \
2838     struct CY ## name ## Assign : \
2839         CYAssignment \
2840     { args \
2841         CY ## name ## Assign(CYTarget *lhs, CYExpression *rhs) : \
2842             CYAssignment(lhs, rhs) \
2843         { \
2844         } \
2845     \
2846         virtual const char *Operator() const { \
2847             return op; \
2848         } \
2849     };
2850
2851 CYPostfix_("++", PostIncrement)
2852 CYPostfix_("--", PostDecrement)
2853
2854 CYPrefix_(true, "delete", Delete)
2855 CYPrefix_(true, "void", Void)
2856 CYPrefix_(true, "typeof", TypeOf)
2857 CYPrefix_(false, "++", PreIncrement)
2858 CYPrefix_(false, "--", PreDecrement)
2859 CYPrefix_(false, "+", Affirm)
2860 CYPrefix_(false, "-", Negate)
2861 CYPrefix_(false, "~", BitwiseNot)
2862 CYPrefix_(false, "!", LogicalNot)
2863
2864 CYInfix_(false, 5, "*", Multiply, CYReplace)
2865 CYInfix_(false, 5, "/", Divide)
2866 CYInfix_(false, 5, "%", Modulus)
2867 CYInfix_(false, 6, "+", Add, CYReplace)
2868 CYInfix_(false, 6, "-", Subtract)
2869 CYInfix_(false, 7, "<<", ShiftLeft)
2870 CYInfix_(false, 7, ">>", ShiftRightSigned)
2871 CYInfix_(false, 7, ">>>", ShiftRightUnsigned)
2872 CYInfix_(false, 8, "<", Less)
2873 CYInfix_(false, 8, ">", Greater)
2874 CYInfix_(false, 8, "<=", LessOrEqual)
2875 CYInfix_(false, 8, ">=", GreaterOrEqual)
2876 CYInfix_(true, 8, "instanceof", InstanceOf)
2877 CYInfix_(true, 8, "in", In)
2878 CYInfix_(false, 9, "==", Equal)
2879 CYInfix_(false, 9, "!=", NotEqual)
2880 CYInfix_(false, 9, "===", Identical)
2881 CYInfix_(false, 9, "!==", NotIdentical)
2882 CYInfix_(false, 10, "&", BitwiseAnd)
2883 CYInfix_(false, 11, "^", BitwiseXOr)
2884 CYInfix_(false, 12, "|", BitwiseOr)
2885 CYInfix_(false, 13, "&&", LogicalAnd)
2886 CYInfix_(false, 14, "||", LogicalOr)
2887
2888 CYAssignment_("=", )
2889 CYAssignment_("*=", Multiply)
2890 CYAssignment_("/=", Divide)
2891 CYAssignment_("%=", Modulus)
2892 CYAssignment_("+=", Add)
2893 CYAssignment_("-=", Subtract)
2894 CYAssignment_("<<=", ShiftLeft)
2895 CYAssignment_(">>=", ShiftRightSigned)
2896 CYAssignment_(">>>=", ShiftRightUnsigned)
2897 CYAssignment_("&=", BitwiseAnd)
2898 CYAssignment_("^=", BitwiseXOr)
2899 CYAssignment_("|=", BitwiseOr)
2900
2901 #endif/*CYCRIPT_PARSER_HPP*/