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