X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/1fdca2fae613a1e5619ef9625f9bb158bb0682f2..511f56b025a791a6f62910bdd2fe01caaaf917c2:/Parser.hpp diff --git a/Parser.hpp b/Parser.hpp index 33de680..63270a1 100644 --- a/Parser.hpp +++ b/Parser.hpp @@ -1,91 +1,71 @@ -/* Cycript - Remove Execution Server and Disassembler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2014 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ /* }}} */ -#ifndef CYPARSER_HPP -#define CYPARSER_HPP +#ifndef CYCRIPT_PARSER_HPP +#define CYCRIPT_PARSER_HPP + +#include -#include #include #include +#include +#include -#include "location.hh" -#include "Pooling.hpp" - -template -struct CYNext { - Type_ *next_; +#include +#include - CYNext() : - next_(NULL) - { - } +#include "List.hpp" +#include "Pooling.hpp" +#include "Options.hpp" - CYNext(Type_ *next) : - next_(next) - { - } +struct CYContext; - void SetNext(Type_ *next) { - next_ = next; +struct CYThing { + virtual ~CYThing() { } -}; -struct CYThing { virtual void Output(struct CYOutput &out) const = 0; }; struct CYOutput { std::ostream &out_; + CYOptions &options_; bool pretty_; unsigned indent_; + bool right_; enum { NoMode, NoLetter, + NoPlus, NoHyphen, Terminated } mode_; - CYOutput(std::ostream &out) : + CYOutput(std::ostream &out, CYOptions &options) : out_(out), + options_(options), pretty_(false), indent_(0), + right_(false), mode_(NoMode) { } @@ -110,9 +90,109 @@ struct CYOutput { struct CYPropertyName { virtual void PropertyName(CYOutput &out) const = 0; + + virtual ~CYPropertyName() { + } +}; + +struct CYExpression; +struct CYAssignment; + +enum CYNeeded { + CYNever = -1, + CYSometimes = 0, + CYAlways = 1, +}; + +enum CYFlags { + CYNoFlags = 0, + CYNoBrace = (1 << 0), + CYNoFunction = (1 << 1), + CYNoIn = (1 << 2), + CYNoCall = (1 << 3), + CYNoRightHand = (1 << 4), + CYNoDangle = (1 << 5), + CYNoInteger = (1 << 6), + CYNoBF = (CYNoBrace | CYNoFunction), +}; + +_finline CYFlags operator ~(CYFlags rhs) { + return static_cast(~static_cast(rhs)); +} + +_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { + return static_cast(static_cast(lhs) & static_cast(rhs)); +} + +_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { + return static_cast(static_cast(lhs) | static_cast(rhs)); +} + +_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { + return lhs = lhs | rhs; +} + +_finline CYFlags CYLeft(CYFlags flags) { + return flags & ~(CYNoDangle | CYNoInteger); +} + +_finline CYFlags CYRight(CYFlags flags) { + return flags & ~CYNoBF; +} + +_finline CYFlags CYCenter(CYFlags flags) { + return CYLeft(CYRight(flags)); +} + +struct CYStatement : + CYNext +{ + virtual ~CYStatement() { + } + + void Single(CYOutput &out, CYFlags flags) const; + void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const; + + virtual CYStatement *Replace(CYContext &context) = 0; + + private: + virtual void Output(CYOutput &out, CYFlags flags) const = 0; +}; + +struct CYStatements { + CYStatement *first_; + CYStatement *last_; + + CYStatements() : + first_(NULL), + last_(NULL) + { + } + + operator CYStatement *() const { + return first_; + } + + CYStatements &operator ->*(CYStatement *next) { + if (next != NULL) + if (first_ == NULL) { + first_ = next; + last_ = next; + } else for (;; last_ = last_->next_) + if (last_->next_ == NULL) { + last_->next_ = next; + last_ = next; + break; + } + return *this; + } }; struct CYClassName { + virtual ~CYClassName() { + } + + virtual CYExpression *ClassName(CYContext &context, bool object) = 0; virtual void ClassName(CYOutput &out, bool object) const = 0; }; @@ -128,177 +208,321 @@ struct CYWord : { } - const char *Value() const { - return word_; + void Set(const char *value) { + word_ = value; } + virtual const char *Word() const; virtual void Output(CYOutput &out) const; + virtual CYExpression *ClassName(CYContext &context, bool object); virtual void ClassName(CYOutput &out, bool object) const; virtual void PropertyName(CYOutput &out) const; }; _finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) { - return lhs << rhs.Value(); + lhs << &rhs << '='; + return lhs << rhs.Word(); } struct CYIdentifier : + CYNext, CYWord { + CYIdentifier *replace_; + size_t offset_; + size_t usage_; + CYIdentifier(const char *word) : - CYWord(word) + CYWord(word), + replace_(NULL), + offset_(0), + usage_(0) + { + } + + virtual const char *Word() const; + CYIdentifier *Replace(CYContext &context); +}; + +struct CYComment : + CYStatement +{ + const char *value_; + + CYComment(const char *value) : + value_(value) { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYLabel : - CYNext + CYStatement { CYIdentifier *name_; + CYStatement *statement_; - CYLabel(CYIdentifier *name, CYLabel *next) : - CYNext(next), - name_(name) + CYLabel(CYIdentifier *name, CYStatement *statement) : + name_(name), + statement_(statement) { } -}; -enum CYNeeded { - CYNever = -1, - CYSometimes = 0, - CYAlways = 1, + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -enum CYFlags { - CYNoFlags = 0, - CYNoBrace = (1 << 0), - CYNoFunction = (1 << 1), - CYNoIn = (1 << 2), - CYNoCall = (1 << 3), - CYNoRightHand = (1 << 4), - CYNoDangle = (1 << 5), - CYNoBF = (CYNoBrace | CYNoFunction), +struct CYCStringLess : + std::binary_function +{ + _finline bool operator ()(const char *lhs, const char *rhs) const { + return strcmp(lhs, rhs) < 0; + } }; -struct CYStatement : - CYNext +struct CYIdentifierValueLess : + std::binary_function { - CYLabel *labels_; - - CYStatement() : - labels_(NULL) - { + _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const { + return CYCStringLess()(lhs->Word(), rhs->Word()); } +}; - void AddLabel(CYIdentifier *identifier) { - labels_ = new CYLabel(identifier, labels_); - } +enum CYIdentifierFlags { + CYIdentifierArgument, + CYIdentifierVariable, + CYIdentifierOther, + CYIdentifierMagic, + CYIdentifierCatch, +}; - bool Single(CYOutput &out, CYFlags flags) const; - void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const; +typedef std::set CYCStringSet; +typedef std::set CYIdentifierValueSet; +typedef std::map CYIdentifierAddressFlagsMap; - private: - virtual void Output(CYOutput &out, CYFlags flags) const = 0; +struct CYIdentifierUsage { + CYIdentifier *identifier_; + size_t usage_; }; -struct CYBlock : - CYStatement +typedef std::vector CYIdentifierUsageVector; + +struct CYScope { + bool transparent_; + + CYContext &context_; + CYStatement *&statements_; + + CYScope *parent_; + + CYIdentifierAddressFlagsMap internal_; + CYIdentifierValueSet identifiers_; + + CYScope(bool transparent, CYContext &context, CYStatement *&statements); + virtual ~CYScope(); + + void Close(); + + void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags); + virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier); + void Merge(CYContext &context, CYIdentifier *identifier); + void Scope(CYContext &context, CYStatement *&statements); +}; + +struct CYProgram : + CYThing { CYStatement *statements_; - CYBlock(CYStatement *statements) : + CYProgram(CYStatement *statements) : statements_(statements) { } - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -enum CYState { - CYClear, - CYRestricted, - CYNewLine -}; +struct CYNonLocal; +struct CYThisScope; -class CYDriver { - public: - CYPool pool_; +struct CYContext { + CYOptions &options_; - CYState state_; - void *scanner_; + CYScope *scope_; + CYThisScope *this_; - const char *data_; - size_t size_; - FILE *file_; + CYIdentifierUsageVector rename_; - bool strict_; + CYNonLocal *nonlocal_; + CYNonLocal *nextlocal_; + unsigned unique_; - enum Condition { - RegExStart, - RegExRest - }; + CYContext(CYOptions &options) : + options_(options), + scope_(NULL), + this_(NULL), + nonlocal_(NULL), + nextlocal_(NULL), + unique_(0) + { + } - std::string filename_; + virtual ~CYContext() { + } - struct Error { - bool warning_; - cy::location location_; - std::string message_; - }; + template + void ReplaceAll(Type_ *&values) { + Type_ **last(&values); + CYForEach (next, values) { + Replace(*last = next); + if (*last != NULL) + last = &(*last)->next_; + } + } - typedef std::vector Errors; + template + void Replace(Type_ *&value) { + for (;;) if (value == NULL) + break; + else { + Type_ *replace(value->Replace(*this)); + if (replace != value) + value = replace; + else break; + } + } - CYStatement *program_; - Errors errors_; + void NonLocal(CYStatement *&statements); + CYIdentifier *Unique(); +}; - private: - void ScannerInit(); - void ScannerDestroy(); +struct CYNonLocal { + CYIdentifier *identifier_; + + CYNonLocal() : + identifier_(NULL) + { + } + + CYIdentifier *Target(CYContext &context) { + if (identifier_ == NULL) + identifier_ = context.Unique(); + return identifier_; + } +}; + +struct CYThisScope : + CYNext +{ + CYIdentifier *identifier_; + + CYThisScope() : + identifier_(NULL) + { + } - public: - CYDriver(const std::string &filename); - ~CYDriver(); + CYIdentifier *Identifier(CYContext &context) { + if (next_ != NULL) + return next_->Identifier(context); + if (identifier_ == NULL) + identifier_ = context.Unique(); + return identifier_; + } +}; + +struct CYBlock : + CYStatement, + CYThing +{ + CYStatement *statements_; + + CYBlock(CYStatement *statements) : + statements_(statements) + { + } + + operator CYStatement *() const { + return statements_; + } + + void AddPrev(CYStatement *statement) { + CYSetLast(statement) = statements_; + statements_ = statement; + } - void SetCondition(Condition condition); + virtual CYStatement *Replace(CYContext &context); - void Warning(const cy::location &location, const char *message); + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYForInitialiser { - virtual void For(CYOutput &out) const = 0; + virtual ~CYForInitialiser() { + } + + virtual CYExpression *Replace(CYContext &context) = 0; + virtual void Output(CYOutput &out, CYFlags flags) const = 0; }; struct CYForInInitialiser { + virtual ~CYForInInitialiser() { + } + virtual void ForIn(CYOutput &out, CYFlags flags) const = 0; - virtual const char *ForEachIn() const = 0; - virtual void ForEachIn(CYOutput &out) const = 0; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0; + + virtual CYExpression *Replace(CYContext &context) = 0; + virtual CYAssignment *Assignment(CYContext &context) = 0; + + virtual void Output(CYOutput &out, CYFlags flags) const = 0; }; +struct CYNumber; +struct CYString; + struct CYExpression : - CYNext, CYForInitialiser, CYForInInitialiser, CYClassName, CYThing { - virtual unsigned Precedence() const = 0; + virtual int Precedence() const = 0; virtual bool RightHand() const { return true; } - virtual void For(CYOutput &out) const; virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); - virtual const char *ForEachIn() const; - virtual void ForEachIn(CYOutput &out) const; + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); virtual void Output(CYOutput &out) const; virtual void Output(CYOutput &out, CYFlags flags) const = 0; - void Output(CYOutput &out, unsigned precedence, CYFlags flags) const; + void Output(CYOutput &out, int precedence, CYFlags flags) const; + virtual CYExpression *ClassName(CYContext &context, bool object); virtual void ClassName(CYOutput &out, bool object) const; + virtual CYExpression *Replace(CYContext &context) = 0; + virtual CYAssignment *Assignment(CYContext &context); + + virtual CYExpression *Primitive(CYContext &context) { + return NULL; + } + + virtual CYNumber *Number(CYContext &context) { + return NULL; + } + + virtual CYString *String(CYContext &context) { + return NULL; + } + virtual const char *Word() const { return NULL; } @@ -310,8 +534,9 @@ struct CYExpression : } #define CYPrecedence(value) \ - virtual unsigned Precedence() const { \ - return value; \ + static const int Precedence_ = value; \ + virtual int Precedence() const { \ + return Precedence_; \ } #define CYRightHand(value) \ @@ -322,37 +547,64 @@ struct CYExpression : struct CYCompound : CYExpression { - CYExpression *expressions_; + CYExpression *expression_; + CYExpression *next_; - CYCompound(CYExpression *expressions) : - expressions_(expressions) + CYCompound(CYExpression *expression, CYExpression *next = NULL) : + expression_(expression), + next_(next) { - } - - void AddPrev(CYExpression *expression) { - CYExpression *last(expression); - while (last->next_ != NULL) - last = last->next_; - last->SetNext(expressions_); - expressions_ = expression; + if (expression_ == NULL) + throw; + _assert(expression_ != NULL); } CYPrecedence(17) + virtual CYExpression *Replace(CYContext &context); void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *Primitive(CYContext &context); }; -struct CYComprehension : - CYNext, +struct CYDeclaration; + +struct CYFunctionParameter : + CYNext, CYThing { + CYForInInitialiser *initialiser_; + + CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) : + CYNext(next), + initialiser_(initialiser) + { + } + + void Replace(CYContext &context, CYBlock &code); void Output(CYOutput &out) const; - virtual const char *Name() const = 0; +}; - virtual void Begin_(CYOutput &out) const = 0; +struct CYComprehension : + CYNext, + CYThing +{ + CYComprehension(CYComprehension *next = NULL) : + CYNext(next) + { + } - virtual void End_(CYOutput &out) const { + CYComprehension *Modify(CYComprehension *next) { + next_ = next; + return this; } + + virtual const char *Name() const = 0; + + virtual CYFunctionParameter *Parameter(CYContext &context) const = 0; + CYFunctionParameter *Parameters(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const = 0; }; struct CYForInComprehension : @@ -361,37 +613,42 @@ struct CYForInComprehension : CYIdentifier *name_; CYExpression *set_; - CYForInComprehension(CYIdentifier *name, CYExpression *set) : + CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), name_(name), set_(set) { } virtual const char *Name() const { - return name_->Value(); + return name_->Word(); } - virtual void Begin_(CYOutput &out) const; + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; -struct CYForEachInComprehension : +struct CYForOfComprehension : CYComprehension { CYIdentifier *name_; CYExpression *set_; - CYForEachInComprehension(CYIdentifier *name, CYExpression *set) : + CYForOfComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), name_(name), set_(set) { } virtual const char *Name() const { - return name_->Value(); + return name_->Word(); } - virtual void Begin_(CYOutput &out) const; - virtual void End_(CYOutput &out) const; + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; struct CYIfComprehension : @@ -399,7 +656,8 @@ struct CYIfComprehension : { CYExpression *test_; - CYIfComprehension(CYExpression *test) : + CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) : + CYComprehension(next), test_(test) { } @@ -408,7 +666,9 @@ struct CYIfComprehension : return NULL; } - virtual void Begin_(CYOutput &out) const; + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; struct CYArrayComprehension : @@ -425,6 +685,7 @@ struct CYArrayComprehension : CYPrecedence(0) + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -433,6 +694,16 @@ struct CYLiteral : { CYPrecedence(0) CYRightHand(false) + + virtual CYExpression *Primitive(CYContext &context) { + return this; + } +}; + +struct CYTrivial : + CYLiteral +{ + virtual CYExpression *Replace(CYContext &context); }; struct CYMagic : @@ -442,50 +713,18 @@ struct CYMagic : CYRightHand(false) }; -struct CYSelectorPart : - CYNext, - CYThing -{ - CYWord *name_; - bool value_; +struct CYRange { + uint64_t lo_; + uint64_t hi_; - CYSelectorPart(CYWord *name, bool value, CYSelectorPart *next) : - CYNext(next), - name_(name), - value_(value) + CYRange(uint64_t lo, uint64_t hi) : + lo_(lo), hi_(hi) { } - virtual void Output(CYOutput &out) const; -}; - -struct CYSelector : - CYLiteral -{ - CYSelectorPart *name_; - - CYSelector(CYSelectorPart *name) : - name_(name) - { - } - - CYPrecedence(1) - - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYRange { - uint64_t lo_; - uint64_t hi_; - - CYRange(uint64_t lo, uint64_t hi) : - lo_(lo), hi_(hi) - { - } - - bool operator [](uint8_t value) const { - return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1; - } + bool operator [](uint8_t value) const { + return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1; + } void operator()(uint8_t value) { if (value >> 7) @@ -499,20 +738,32 @@ extern CYRange WordStartRange_; extern CYRange WordEndRange_; struct CYString : - CYLiteral, + CYTrivial, CYPropertyName { const char *value_; size_t size_; + CYString() : + value_(NULL), + size_(0) + { + } + + CYString(const char *value) : + value_(value), + size_(strlen(value)) + { + } + CYString(const char *value, size_t size) : value_(value), size_(size) { } - CYString(const CYIdentifier *identifier) : - value_(identifier->Value()), + CYString(const CYWord *word) : + value_(word->Word()), size_(strlen(value_)) { } @@ -523,12 +774,16 @@ struct CYString : virtual const char *Word() const; + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + CYString *Concat(CYContext &out, CYString *rhs) const; virtual void Output(CYOutput &out, CYFlags flags) const; virtual void PropertyName(CYOutput &out) const; }; struct CYNumber : - CYLiteral, + CYTrivial, CYPropertyName { double value_; @@ -542,12 +797,15 @@ struct CYNumber : return value_; } + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; virtual void PropertyName(CYOutput &out) const; }; struct CYRegEx : - CYLiteral + CYTrivial { const char *value_; @@ -565,13 +823,16 @@ struct CYRegEx : struct CYNull : CYWord, - CYLiteral + CYTrivial { CYNull() : CYWord("null") { } + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -584,11 +845,12 @@ struct CYThis : { } + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYBoolean : - CYLiteral + CYTrivial { virtual bool Value() const = 0; virtual void Output(CYOutput &out, CYFlags flags) const; @@ -606,6 +868,9 @@ struct CYFalse : virtual bool Value() const { return false; } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); }; struct CYTrue : @@ -620,6 +885,9 @@ struct CYTrue : virtual bool Value() const { return true; } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); }; struct CYVariable : @@ -632,9 +900,15 @@ struct CYVariable : { } + CYVariable(const char *name) : + name_(new($pool) CYIdentifier(name)) + { + } + CYPrecedence(0) CYRightHand(false) + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -651,6 +925,9 @@ struct CYPrefix : virtual bool Alphabetic() const = 0; virtual const char *Operator() const = 0; + CYPrecedence(4) + + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -673,6 +950,7 @@ struct CYInfix : virtual bool Alphabetic() const = 0; virtual const char *Operator() const = 0; + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -688,6 +966,9 @@ struct CYPostfix : virtual const char *Operator() const = 0; + CYPrecedence(3) + + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -709,6 +990,9 @@ struct CYAssignment : virtual const char *Operator() const = 0; + CYPrecedence(16) + + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -719,6 +1003,13 @@ struct CYArgument : CYWord *name_; CYExpression *value_; + CYArgument(CYExpression *value, CYArgument *next = NULL) : + CYNext(next), + name_(NULL), + value_(value) + { + } + CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : CYNext(next), name_(name), @@ -726,6 +1017,7 @@ struct CYArgument : { } + CYArgument *Replace(CYContext &context); void Output(CYOutput &out) const; }; @@ -743,14 +1035,15 @@ struct CYClause : CYNext { CYExpression *case_; - CYStatement *code_; + CYStatement *statements_; - CYClause(CYExpression *_case, CYStatement *code) : + CYClause(CYExpression *_case, CYStatement *statements) : case_(_case), - code_(code) + statements_(statements) { } + void Replace(CYContext &context); virtual void Output(CYOutput &out) const; }; @@ -766,6 +1059,7 @@ struct CYElement : { } + void Replace(CYContext &context); void Output(CYOutput &out) const; }; @@ -774,53 +1068,93 @@ struct CYArray : { CYElement *elements_; - CYArray(CYElement *elements) : + CYArray(CYElement *elements = NULL) : elements_(elements) { } + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; +struct CYProperty : + CYNext, + CYThing +{ + CYPropertyName *name_; + CYExpression *value_; + + CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) : + CYNext(next), + name_(name), + value_(value) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + struct CYDeclaration : CYForInInitialiser { CYIdentifier *identifier_; CYExpression *initialiser_; - CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser) : + CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) : identifier_(identifier), initialiser_(initialiser) { } virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); - virtual const char *ForEachIn() const; - virtual void ForEachIn(CYOutput &out) const; + virtual CYExpression *Replace(CYContext &context); + + virtual CYAssignment *Assignment(CYContext &context); + CYVariable *Variable(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYDeclarations : CYNext, - CYForInitialiser, CYThing { CYDeclaration *declaration_; - CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) : + CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) : CYNext(next), declaration_(declaration) { } - virtual void For(CYOutput &out) const; + void Replace(CYContext &context); + + CYCompound *Compound(CYContext &context); + CYProperty *Property(CYContext &context); + CYArgument *Argument(CYContext &context); + CYFunctionParameter *Parameter(CYContext &context); virtual void Output(CYOutput &out) const; virtual void Output(CYOutput &out, CYFlags flags) const; }; +struct CYForDeclarations : + CYForInitialiser +{ + CYDeclarations *declarations_; + + CYForDeclarations(CYDeclarations *declarations) : + declarations_(declarations) + { + } + + virtual CYCompound *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + struct CYVar : CYStatement { @@ -831,526 +1165,839 @@ struct CYVar : { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYLet : +struct CYLetStatement : CYStatement { CYDeclarations *declarations_; - CYStatement *statements_; + CYStatement *code_; - CYLet(CYDeclarations *declarations, CYStatement *statements) : + CYLetStatement(CYDeclarations *declarations, CYStatement *code) : declarations_(declarations), - statements_(statements) + code_(code) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFor : + CYStatement +{ + CYForInitialiser *initialiser_; + CYExpression *test_; + CYExpression *increment_; + CYStatement *code_; + + CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) : + initialiser_(initialiser), + test_(test), + increment_(increment), + code_(code) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYField : - CYNext +struct CYForIn : + CYStatement { - virtual void Output(CYOutput &out) const; + CYForInInitialiser *initialiser_; + CYExpression *set_; + CYStatement *code_; + + CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) : + initialiser_(initialiser), + set_(set), + code_(code) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYMessageParameter : - CYNext +struct CYForOf : + CYStatement { - CYWord *tag_; - CYExpression *type_; - CYIdentifier *name_; + CYForInInitialiser *initialiser_; + CYExpression *set_; + CYStatement *code_; - CYMessageParameter(CYWord *tag, CYExpression *type, CYIdentifier *name) : - tag_(tag), - type_(type), - name_(name) + CYForOf(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) : + initialiser_(initialiser), + set_(set), + code_(code) { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYMessage : - CYNext +struct CYObject : + CYLiteral { - bool instance_; - CYExpression *type_; - CYMessageParameter *parameter_; - CYStatement *body_; + CYProperty *properties_; + + CYObject(CYProperty *properties = NULL) : + properties_(properties) + { + } + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYMember : + CYExpression +{ + CYExpression *object_; + CYExpression *property_; + + CYMember(CYExpression *object, CYExpression *property) : + object_(object), + property_(property) + { + } - CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYStatement *body) : - instance_(instance), - type_(type), - parameter_(parameter), - body_(body) + void SetLeft(CYExpression *object) { + object_ = object; + } +}; + +struct CYDirectMember : + CYMember +{ + CYDirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) { } - virtual void Output(CYOutput &out, bool replace) const; + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYClass { - CYClassName *name_; - CYExpression *super_; - CYField *fields_; - CYMessage *messages_; +struct CYIndirectMember : + CYMember +{ + CYIndirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) + { + } - CYClass(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) : + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +namespace cy { +namespace Syntax { + +struct New : + CYExpression +{ + CYExpression *constructor_; + CYArgument *arguments_; + + New(CYExpression *constructor, CYArgument *arguments) : + constructor_(constructor), + arguments_(arguments) + { + } + + virtual int Precedence() const { + return arguments_ == NULL ? 2 : 1; + } + + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); +}; + +} } + +struct CYCall : + CYExpression +{ + CYExpression *function_; + CYArgument *arguments_; + + CYCall(CYExpression *function, CYArgument *arguments = NULL) : + function_(function), + arguments_(arguments) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); +}; + +struct CYRubyProc; + +struct CYRubyBlock : + CYExpression +{ + CYExpression *call_; + CYRubyProc *proc_; + + CYRubyBlock(CYExpression *call, CYRubyProc *proc) : + call_(call), + proc_(proc) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYIf : + CYStatement +{ + CYExpression *test_; + CYStatement *true_; + CYStatement *false_; + + CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) : + test_(test), + true_(_true), + false_(_false) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYDoWhile : + CYStatement +{ + CYExpression *test_; + CYStatement *code_; + + CYDoWhile(CYExpression *test, CYStatement *code) : + test_(test), + code_(code) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYWhile : + CYStatement +{ + CYExpression *test_; + CYStatement *code_; + + CYWhile(CYExpression *test, CYStatement *code) : + test_(test), + code_(code) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass) +struct CYFunction { + CYIdentifier *name_; + CYFunctionParameter *parameters_; + CYBlock code_; + + CYNonLocal *nonlocal_; + CYThisScope this_; + + CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : name_(name), - super_(super), - fields_(fields), - messages_(messages) + parameters_(parameters), + code_(statements), + nonlocal_(NULL) { } + virtual ~CYFunction() { + } + + void Inject(CYContext &context); + virtual void Replace_(CYContext &context, bool outer); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYClassExpression : - CYClass, +// XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression +struct CYFunctionExpression : + CYFunction, CYExpression { - CYClassExpression(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) : - CYClass(name, super, fields, messages) + CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(name, parameters, statements) { } CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYAnonymousFunction +struct CYFatArrow : + CYFunction, + CYExpression +{ + CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(NULL, parameters, statements) + { + } + + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYAnonymousFunctionExpression +struct CYRubyProc : + CYFunctionExpression +{ + CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) : + CYFunctionExpression(NULL, parameters, statements) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYNamedFunction +struct CYFunctionStatement : + CYFunction, + CYStatement +{ + CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(name, parameters, statements) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYExpress : + CYStatement +{ + CYExpression *expression_; + + CYExpress(CYExpression *expression) : + expression_(expression) + { + if (expression_ == NULL) + throw; + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYContinue : + CYStatement +{ + CYIdentifier *label_; + + CYContinue(CYIdentifier *label) : + label_(label) + { + } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYClassStatement : - CYClass, +struct CYBreak : CYStatement { - CYClassStatement(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) : - CYClass(name, super, fields, messages) + CYIdentifier *label_; + + CYBreak(CYIdentifier *label) : + label_(label) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYCategory : +struct CYReturn : CYStatement { - CYClassName *name_; - CYMessage *messages_; + CYExpression *value_; - CYCategory(CYClassName *name, CYMessage *messages) : - name_(name), - messages_(messages) + CYReturn(CYExpression *value) : + value_(value) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYFunctionParameter : - CYNext, +struct CYEmpty : + CYStatement +{ + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFinally : CYThing { - CYIdentifier *name_; + CYBlock code_; - CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next) : - CYNext(next), - name_(name) + CYFinally(CYStatement *statements) : + code_(statements) { } + void Replace(CYContext &context); virtual void Output(CYOutput &out) const; }; -struct CYFor : - CYStatement +struct CYTypeSpecifier : + CYThing { - CYForInitialiser *initialiser_; - CYExpression *test_; - CYExpression *increment_; - CYStatement *code_; + virtual CYExpression *Replace(CYContext &context) = 0; +}; - CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) : - initialiser_(initialiser), - test_(test), - increment_(increment), - code_(code) - { +struct CYTypeError : + CYTypeSpecifier +{ + CYTypeError() { } - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYForIn : - CYStatement +struct CYTypeVoid : + CYTypeSpecifier { - CYForInInitialiser *initialiser_; - CYExpression *set_; - CYStatement *code_; - - CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) : - initialiser_(initialiser), - set_(set), - code_(code) - { + CYTypeVoid() { } - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYForEachIn : - CYStatement +struct CYTypeVariable : + CYTypeSpecifier { - CYForInInitialiser *initialiser_; - CYExpression *set_; - CYStatement *code_; + CYIdentifier *name_; - CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) : - initialiser_(initialiser), - set_(set), - code_(code) + CYTypeVariable(CYIdentifier *name) : + name_(name) { } - virtual void Output(CYOutput &out, CYFlags flags) const; + CYTypeVariable(const char *name) : + name_(new($pool) CYIdentifier(name)) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYProperty : - CYNext, - CYThing +struct CYTypeUnsigned : + CYTypeSpecifier { - CYPropertyName *name_; - CYExpression *value_; + CYTypeSpecifier *specifier_; - CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next) : - CYNext(next), - name_(name), - value_(value) + CYTypeUnsigned(CYTypeSpecifier *specifier) : + specifier_(specifier) { } + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out) const; }; -struct CYObject : - CYLiteral +struct CYTypeSigned : + CYTypeSpecifier { - CYProperty *property_; + CYTypeSpecifier *specifier_; - CYObject(CYProperty *property) : - property_(property) + CYTypeSigned(CYTypeSpecifier *specifier) : + specifier_(specifier) { } - void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYCatch : - CYThing +struct CYTypeLong : + CYTypeSpecifier { - CYIdentifier *name_; - CYStatement *code_; + CYTypeSpecifier *specifier_; - CYCatch(CYIdentifier *name, CYStatement *code) : - name_(name), - code_(code) + CYTypeLong(CYTypeSpecifier *specifier) : + specifier_(specifier) { } + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out) const; }; -struct CYSend : - CYExpression +struct CYTypeShort : + CYTypeSpecifier { - CYExpression *self_; - CYArgument *arguments_; + CYTypeSpecifier *specifier_; - CYSend(CYExpression *self, CYArgument *arguments) : - self_(self), - arguments_(arguments) + CYTypeShort(CYTypeSpecifier *specifier) : + specifier_(specifier) { } - CYPrecedence(0) - - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYMember : - CYExpression +struct CYTypeModifier : + CYNext { - CYExpression *object_; - CYExpression *property_; - - CYMember(CYExpression *object, CYExpression *property) : - object_(object), - property_(property) + CYTypeModifier(CYTypeModifier *next) : + CYNext(next) { } - void SetLeft(CYExpression *object) { - object_ = object; - } + virtual int Precedence() const = 0; + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type) = 0; + CYExpression *Replace(CYContext &context, CYExpression *type); + + virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0; + void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const; }; -struct CYDirectMember : - CYMember +struct CYTypeArrayOf : + CYTypeModifier { - CYDirectMember(CYExpression *object, CYExpression *property) : - CYMember(object, property) + CYExpression *size_; + + CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + size_(size) { } CYPrecedence(1) - CYRightHand(false) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYIndirectMember : - CYMember +struct CYTypeConstant : + CYTypeModifier { - CYIndirectMember(CYExpression *object, CYExpression *property) : - CYMember(object, property) + CYTypeConstant(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - CYPrecedence(1) - CYRightHand(false) + CYPrecedence(0) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYNew : - CYExpression +struct CYTypePointerTo : + CYTypeModifier { - CYExpression *constructor_; - CYArgument *arguments_; - - CYNew(CYExpression *constructor, CYArgument *arguments) : - constructor_(constructor), - arguments_(arguments) + CYTypePointerTo(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - virtual unsigned Precedence() const { - return arguments_ == NULL ? 2 : 1; - } - - CYRightHand(false) + CYPrecedence(0) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYCall : - CYExpression +struct CYTypeVolatile : + CYTypeModifier { - CYExpression *function_; - CYArgument *arguments_; - - CYCall(CYExpression *function, CYArgument *arguments) : - function_(function), - arguments_(arguments) + CYTypeVolatile(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - CYPrecedence(1) - CYRightHand(false) + CYPrecedence(0) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYIf : - CYStatement +struct CYTypedIdentifier : + CYNext, + CYThing { - CYExpression *test_; - CYStatement *true_; - CYStatement *false_; + CYIdentifier *identifier_; + CYTypeSpecifier *specifier_; + CYTypeModifier *modifier_; - CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false) : - test_(test), - true_(_true), - false_(_false) + CYTypedIdentifier(CYIdentifier *identifier = NULL) : + identifier_(identifier), + specifier_(NULL), + modifier_(NULL) { } - virtual void Output(CYOutput &out, CYFlags flags) const; + CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) : + identifier_(NULL), + specifier_(specifier), + modifier_(modifier) + { + } + + inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) { + CYSetLast(modifier_) = modifier; + return this; + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYDoWhile : - CYStatement +struct CYEncodedType : + CYExpression { - CYExpression *test_; - CYStatement *code_; + CYTypedIdentifier *typed_; - CYDoWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) + CYEncodedType(CYTypedIdentifier *typed) : + typed_(typed) { } + CYPrecedence(1) + + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYWhile : - CYStatement +struct CYTypedParameter : + CYNext, + CYThing { - CYExpression *test_; - CYStatement *code_; + CYTypedIdentifier *typed_; - CYWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) + CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) : + CYNext(next), + typed_(typed) { } - virtual void Output(CYOutput &out, CYFlags flags) const; + CYArgument *Argument(CYContext &context); + CYFunctionParameter *Parameters(CYContext &context); + CYExpression *TypeSignature(CYContext &context, CYExpression *prefix); + + virtual void Output(CYOutput &out) const; }; -struct CYFunction { - CYIdentifier *name_; - CYFunctionParameter *parameters_; - CYStatement *body_; +struct CYLambda : + CYExpression +{ + CYTypedIdentifier *typed_; + CYTypedParameter *parameters_; + CYStatement *statements_; - CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) : - name_(name), + CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) : + typed_(typed), parameters_(parameters), - body_(body) + statements_(statements) { } + CYPrecedence(1) + + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYFunctionExpression : - CYFunction, - CYExpression +struct CYModule : + CYNext, + CYThing { - CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) : - CYFunction(name, parameters, body) + CYWord *part_; + + CYModule(CYWord *part, CYModule *next = NULL) : + CYNext(next), + part_(part) { } - CYPrecedence(0) - CYRightHand(false) - - virtual void Output(CYOutput &out, CYFlags flags) const; + CYString *Replace(CYContext &context, const char *separator) const; + void Output(CYOutput &out) const; }; -struct CYFunctionStatement : - CYFunction, +struct CYImport : CYStatement { - CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) : - CYFunction(name, parameters, body) + CYModule *module_; + + CYImport(CYModule *module) : + module_(module) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYExpress : +struct CYExternal : CYStatement { - CYExpression *expression_; + CYString *abi_; + CYTypedIdentifier *typed_; - CYExpress(CYExpression *expression) : - expression_(expression) + CYExternal(CYString *abi, CYTypedIdentifier *typed) : + abi_(abi), + typed_(typed) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYContinue : +struct CYTypeDefinition : CYStatement { - CYIdentifier *label_; + CYTypedIdentifier *typed_; - CYContinue(CYIdentifier *label) : - label_(label) + CYTypeDefinition(CYTypedIdentifier *typed) : + typed_(typed) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYBreak : - CYStatement +struct CYTypeBlockWith : + CYTypeModifier { - CYIdentifier *label_; + CYTypedParameter *parameters_; - CYBreak(CYIdentifier *label) : - label_(label) + CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + parameters_(parameters) { } - virtual void Output(CYOutput &out, CYFlags flags) const; + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYReturn : - CYStatement +struct CYTypeFunctionWith : + CYTypeModifier { - CYExpression *value_; + CYTypedParameter *parameters_; - CYReturn(CYExpression *value) : - value_(value) + CYTypeFunctionWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + parameters_(parameters) { } - virtual void Output(CYOutput &out, CYFlags flags) const; -}; + CYPrecedence(1) -struct CYEmpty : - CYStatement -{ - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYFinally : +namespace cy { +namespace Syntax { + +struct Catch : CYThing { - CYStatement *code_; + CYIdentifier *name_; + CYBlock code_; - CYFinally(CYStatement *code) : - code_(code) + Catch(CYIdentifier *name, CYStatement *statements) : + name_(name), + code_(statements) { } + void Replace(CYContext &context); virtual void Output(CYOutput &out) const; }; -struct CYTry : +struct Try : CYStatement { - CYStatement *code_; - CYCatch *catch_; + CYBlock code_; + Catch *catch_; CYFinally *finally_; - CYTry(CYStatement *code, CYCatch *_catch, CYFinally *finally) : - code_(code), + Try(CYStatement *statements, Catch *_catch, CYFinally *finally) : + code_(statements), catch_(_catch), finally_(finally) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYThrow : +struct Throw : CYStatement { CYExpression *value_; - CYThrow(CYExpression *value) : + Throw(CYExpression *value = NULL) : value_(value) { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; +} } + struct CYWith : CYStatement { @@ -1363,6 +2010,7 @@ struct CYWith : { } + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -1378,6 +2026,18 @@ struct CYSwitch : { } + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYDebugger : + CYStatement +{ + CYDebugger() + { + } + + virtual CYStatement *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -1397,6 +2057,7 @@ struct CYCondition : CYPrecedence(15) + virtual CYExpression *Replace(CYContext &context); virtual void Output(CYOutput &out, CYFlags flags) const; }; @@ -1413,9 +2074,8 @@ struct CYAddressOf : } CYAlphabetic(false) - CYPrecedence(2) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); }; struct CYIndirect : @@ -1431,48 +2091,47 @@ struct CYIndirect : } CYAlphabetic(false) - CYPrecedence(1) - virtual void Output(CYOutput &out, CYFlags flags) const; + virtual CYExpression *Replace(CYContext &context); }; -#define CYPostfix_(op, name) \ +#define CYReplace \ + virtual CYExpression *Replace(CYContext &context); + +#define CYPostfix_(op, name, args...) \ struct CY ## name : \ CYPostfix \ - { \ + { args \ CY ## name(CYExpression *lhs) : \ CYPostfix(lhs) \ { \ } \ - \ - CYPrecedence(3) \ \ virtual const char *Operator() const { \ return op; \ } \ }; -#define CYPrefix_(alphabetic, op, name) \ +#define CYPrefix_(alphabetic, op, name, args...) \ struct CY ## name : \ CYPrefix \ - { \ + { args \ CY ## name(CYExpression *rhs) : \ CYPrefix(rhs) \ { \ } \ \ CYAlphabetic(alphabetic) \ - CYPrecedence(4) \ \ virtual const char *Operator() const { \ return op; \ } \ }; -#define CYInfix_(alphabetic, precedence, op, name) \ +#define CYInfix_(alphabetic, precedence, op, name, args...) \ struct CY ## name : \ CYInfix \ - { \ + { args \ CY ## name(CYExpression *lhs, CYExpression *rhs) : \ CYInfix(lhs, rhs) \ { \ @@ -1486,16 +2145,14 @@ struct CYIndirect : } \ }; -#define CYAssignment_(op, name) \ +#define CYAssignment_(op, name, args...) \ struct CY ## name ## Assign : \ CYAssignment \ - { \ + { args \ CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \ CYAssignment(lhs, rhs) \ { \ } \ - \ - CYPrecedence(16) \ \ virtual const char *Operator() const { \ return op; \ @@ -1510,14 +2167,15 @@ CYPrefix_(true, "void", Void) CYPrefix_(true, "typeof", TypeOf) CYPrefix_(false, "++", PreIncrement) CYPrefix_(false, "--", PreDecrement) +CYPrefix_(false, "+", Affirm) CYPrefix_(false, "-", Negate) CYPrefix_(false, "~", BitwiseNot) CYPrefix_(false, "!", LogicalNot) -CYInfix_(false, 5, "*", Multiply) +CYInfix_(false, 5, "*", Multiply, CYReplace) CYInfix_(false, 5, "/", Divide) CYInfix_(false, 5, "%", Modulus) -CYInfix_(false, 6, "+", Add) +CYInfix_(false, 6, "+", Add, CYReplace) CYInfix_(false, 6, "-", Subtract) CYInfix_(false, 7, "<<", ShiftLeft) CYInfix_(false, 7, ">>", ShiftRightSigned) @@ -1551,4 +2209,4 @@ CYAssignment_("&=", BitwiseAnd) CYAssignment_("^=", BitwiseXOr) CYAssignment_("|=", BitwiseOr) -#endif/*CYPARSER_HPP*/ +#endif/*CYCRIPT_PARSER_HPP*/