X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/62014ea9ffc6c31f053863a89d783475a3937d74..697d6fd2b2bf66a1f0bf1f28de0ced96fc14cbfc:/Parser.hpp diff --git a/Parser.hpp b/Parser.hpp index b848c7b..63aa17a 100644 --- a/Parser.hpp +++ b/Parser.hpp @@ -1,10 +1,55 @@ +/* Cycript - Remote Execution Server and Disassembler + * Copyright (C) 2009 Jay Freeman (saurik) +*/ + +/* Modified BSD License {{{ */ +/* + * 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. +*/ +/* }}} */ + #ifndef CYPARSER_HPP #define CYPARSER_HPP -#include +// XXX: wtf is this here?! +#define CYPA 16 + +#include + #include #include +#include + #include "location.hh" #include "Pooling.hpp" @@ -28,34 +73,139 @@ struct CYNext { }; struct CYThing { - virtual void Output(std::ostream &out) const = 0; + virtual void Output(struct CYOutput &out) const = 0; }; -_finline std::ostream &operator <<(std::ostream &out, const CYThing &rhs) { - rhs.Output(out); - return out; -} +struct CYOutput { + std::ostream &out_; + bool pretty_; + unsigned indent_; + + enum { + NoMode, + NoLetter, + NoPlus, + NoHyphen, + Terminated + } mode_; + + CYOutput(std::ostream &out) : + out_(out), + pretty_(false), + indent_(0), + mode_(NoMode) + { + } + + void Check(char value); + void Terminate(); + + CYOutput &operator <<(char rhs); + CYOutput &operator <<(const char *rhs); -struct CYPart { - virtual void Part(std::ostream &out) const = 0; + _finline CYOutput &operator <<(const CYThing *rhs) { + if (rhs != NULL) + rhs->Output(*this); + return *this; + } + + _finline CYOutput &operator <<(const CYThing &rhs) { + rhs.Output(*this); + return *this; + } }; -struct CYSource : - CYNext -{ - virtual void Show(std::ostream &out) const; - virtual void Output(std::ostream &out) const = 0; - virtual void Output(std::ostream &out, bool block) const; +struct CYPropertyName { + virtual void PropertyName(CYOutput &out) const = 0; }; -struct CYName : - CYThing +struct CYExpression; + +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), + CYNoBF = (CYNoBrace | CYNoFunction), +}; + +struct CYContext { + apr_pool_t *pool_; + + CYContext(apr_pool_t *pool) : + pool_(pool) + { + } + + template + void Replace(Type_ *&value) { + if (value != NULL) + while (Type_ *replace = value->Replace(*this)) + value = replace; + } +}; + +struct CYStatement : + CYNext { - virtual const char *Name() const = 0; + void Single(CYOutput &out, CYFlags flags) const; + void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const; + + CYStatement *ReplaceAll(CYContext &context); + + 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 CYExpression *ClassName(CYContext &context, bool object) = 0; + virtual void ClassName(CYOutput &out, bool object) const = 0; }; struct CYWord : - CYName + CYThing, + CYPropertyName, + CYClassName { const char *word_; @@ -68,13 +218,17 @@ struct CYWord : return word_; } - virtual const char *Name() const { - return Value(); - } + virtual void Output(CYOutput &out) const; - virtual void Output(std::ostream &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(); +} + struct CYIdentifier : CYWord { @@ -85,25 +239,55 @@ struct CYIdentifier : }; struct CYLabel : - CYNext + CYStatement { - CYIdentifier *identifier_; + CYIdentifier *name_; + CYStatement *statement_; - CYLabel(CYIdentifier *identifier, CYLabel *next) : - CYNext(next), - identifier_(identifier) + CYLabel(CYIdentifier *name, CYStatement *statement) : + name_(name), + statement_(statement) { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYStatement : - CYSource +struct CYProgram : + CYThing +{ + CYStatement *statements_; + + CYProgram(CYStatement *statements) : + statements_(statements) + { + } + + virtual void Replace(CYContext &context); + + virtual void Output(CYOutput &out) const; +}; + +struct CYBlock : + CYStatement, + CYThing { - CYLabel *label_; + CYStatement *statements_; - void AddLabel(CYIdentifier *identifier) { - label_ = new CYLabel(identifier, label_); + CYBlock(CYStatement *statements) : + statements_(statements) + { } + + operator CYStatement *() const { + return statements_; + } + + virtual CYStatement *Replace(CYContext &context); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; enum CYState { @@ -121,17 +305,25 @@ class CYDriver { const char *data_; size_t size_; + FILE *file_; + + bool strict_; + + enum Condition { + RegExpCondition, + }; std::string filename_; struct Error { + bool warning_; cy::location location_; std::string message_; }; typedef std::vector Errors; - CYSource *source_; + CYProgram *program_; Errors errors_; private: @@ -141,82 +333,288 @@ class CYDriver { public: CYDriver(const std::string &filename); ~CYDriver(); + + void BeginCondition(Condition condition); + + void Warning(const cy::location &location, const char *message); }; -struct CYForInitialiser : - CYPart -{ +struct CYForInitialiser { + virtual void For(CYOutput &out) const = 0; }; -struct CYForInInitialiser : - CYPart -{ +struct CYForInInitialiser { + virtual void ForIn(CYOutput &out, CYFlags flags) const = 0; + virtual const char *ForEachIn() const = 0; + virtual CYExpression *ForEachIn(CYContext &out) = 0; }; +struct CYNumber; +struct CYString; + struct CYExpression : CYNext, CYForInitialiser, - CYForInInitialiser + CYForInInitialiser, + CYClassName, + CYThing { - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const = 0; - void Output(std::ostream &out, bool raw) const; + virtual unsigned Precedence() const = 0; + + virtual bool RightHand() const { + return true; + } + + virtual void For(CYOutput &out) const; + virtual void ForIn(CYOutput &out, CYFlags flags) const; + + virtual const char *ForEachIn() const; + virtual CYExpression *ForEachIn(CYContext &out); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const = 0; + void Output(CYOutput &out, unsigned precedence, CYFlags flags) const; + + virtual CYExpression *ClassName(CYContext &context, bool object); + virtual void ClassName(CYOutput &out, bool object) const; + + CYExpression *ReplaceAll(CYContext &context); + + virtual CYExpression *Replace(CYContext &context) = 0; + + virtual CYExpression *Primitive(CYContext &context) { + return this; + } + + virtual CYNumber *Number(CYContext &context) { + return NULL; + } + + virtual CYString *String(CYContext &context) { + return NULL; + } + + virtual const char *Word() const { + return NULL; + } }; -_finline std::ostream &operator <<(std::ostream &out, const CYExpression &rhs) { - rhs.Output(out, false); - return out; -} +#define CYAlphabetic(value) \ + virtual bool Alphabetic() const { \ + return value; \ + } -struct CYLiteral : +#define CYPrecedence(value) \ + virtual unsigned Precedence() const { \ + return value; \ + } + +#define CYRightHand(value) \ + virtual bool RightHand() const { \ + return value; \ + } + +struct CYCompound : CYExpression { + CYExpression *expressions_; + + CYCompound(CYExpression *expressions) : + expressions_(expressions) + { + } + + void AddPrev(CYExpression *expression) { + CYExpression *last(expression); + while (last->next_ != NULL) + last = last->next_; + last->SetNext(expressions_); + expressions_ = expression; + } + + CYPrecedence(17) + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; }; -struct CYSelectorPart : - CYNext +struct CYFunctionParameter : + CYNext, + CYThing { - CYWord *name_; - bool value_; + CYIdentifier *name_; + + CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) : + CYNext(next), + name_(name) + { + } + + virtual void Output(CYOutput &out) const; +}; + +struct CYComprehension : + CYNext, + CYThing +{ + virtual const char *Name() const = 0; - CYSelectorPart(CYWord *name, bool value, CYSelectorPart *next) : - CYNext(next), + 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 : + CYComprehension +{ + CYIdentifier *name_; + CYExpression *set_; + + CYForInComprehension(CYIdentifier *name, CYExpression *set) : name_(name), - value_(value) + set_(set) { } - virtual void Output(std::ostream &out) const; + virtual const char *Name() const { + return name_->Value(); + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; -struct CYSelector : +struct CYForEachInComprehension : + CYComprehension +{ + CYIdentifier *name_; + CYExpression *set_; + + CYForEachInComprehension(CYIdentifier *name, CYExpression *set) : + name_(name), + set_(set) + { + } + + virtual const char *Name() const { + return name_->Value(); + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; +}; + +struct CYIfComprehension : + CYComprehension +{ + CYExpression *test_; + + CYIfComprehension(CYExpression *test) : + test_(test) + { + } + + virtual const char *Name() const { + return NULL; + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; +}; + +struct CYArrayComprehension : + CYExpression +{ + CYExpression *expression_; + CYComprehension *comprehensions_; + + CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) : + expression_(expression), + comprehensions_(comprehensions) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYLiteral : + CYExpression +{ + CYPrecedence(0) + CYRightHand(false) +}; + +struct CYTrivial : CYLiteral { - CYSelectorPart *name_; + virtual CYExpression *Replace(CYContext &context); +}; - CYSelector(CYSelectorPart *name) : - name_(name) +struct CYMagic : + CYExpression +{ + CYPrecedence(0) + CYRightHand(false) +}; + +struct CYRange { + uint64_t lo_; + uint64_t hi_; + + CYRange(uint64_t lo, uint64_t hi) : + lo_(lo), hi_(hi) { } - virtual void Output(std::ostream &out) const; + bool operator [](uint8_t value) const { + return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1; + } + + void operator()(uint8_t value) { + if (value >> 7) + return; + (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f); + } }; +extern CYRange DigitRange_; +extern CYRange WordStartRange_; +extern CYRange WordEndRange_; + struct CYString : - CYLiteral, - CYName + 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->Value()), size_(strlen(value_)) { } @@ -225,16 +623,19 @@ struct CYString : return value_; } - virtual const char *Name() const { - return Value(); - } + virtual const char *Word() const; + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); - virtual void Output(std::ostream &out) const; + virtual CYString *Concat(CYContext &out, CYString *rhs) const; + virtual void Output(CYOutput &out, CYFlags flags) const; + virtual void PropertyName(CYOutput &out) const; }; struct CYNumber : - CYLiteral, - CYName + CYTrivial, + CYPropertyName { double value_; @@ -247,42 +648,63 @@ struct CYNumber : return value_; } - virtual const char *Name() const { - throw; + 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 : + CYTrivial +{ + const char *value_; + + CYRegEx(const char *value) : + value_(value) + { + } + + const char *Value() const { + return value_; } - virtual void Output(std::ostream &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYNull : CYWord, - CYLiteral + CYTrivial { CYNull() : CYWord("null") { } - virtual void Output(std::ostream &out) const; + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYThis : CYWord, - CYExpression + CYMagic { CYThis() : CYWord("this") { } - virtual void Output(std::ostream &out) const; + 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(std::ostream &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYFalse : @@ -297,6 +719,9 @@ struct CYFalse : virtual bool Value() const { return false; } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); }; struct CYTrue : @@ -311,6 +736,9 @@ struct CYTrue : virtual bool Value() const { return true; } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); }; struct CYVariable : @@ -323,7 +751,11 @@ struct CYVariable : { } - virtual void Output(std::ostream &out) const; + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYPrefix : @@ -336,9 +768,13 @@ struct CYPrefix : { } + virtual bool Alphabetic() const = 0; virtual const char *Operator() const = 0; - virtual void Output(std::ostream &out) const; + CYPrecedence(4) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYInfix : @@ -353,9 +789,15 @@ struct CYInfix : { } + void SetLeft(CYExpression *lhs) { + lhs_ = lhs; + } + + virtual bool Alphabetic() const = 0; virtual const char *Operator() const = 0; - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYPostfix : @@ -370,26 +812,50 @@ struct CYPostfix : virtual const char *Operator() const = 0; - virtual void Output(std::ostream &out) const; + CYPrecedence(3) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYAssignment : - CYInfix + CYExpression { + CYExpression *lhs_; + CYExpression *rhs_; + CYAssignment(CYExpression *lhs, CYExpression *rhs) : - CYInfix(lhs, rhs) + lhs_(lhs), + rhs_(rhs) { } + void SetLeft(CYExpression *lhs) { + lhs_ = lhs; + } + virtual const char *Operator() const = 0; + + CYPrecedence(16) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYArgument : - CYNext + CYNext, + CYThing { 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), @@ -397,7 +863,8 @@ struct CYArgument : { } - void Output(std::ostream &out, bool send) const; + void Replace(CYContext &context); + void Output(CYOutput &out) const; }; struct CYBlank : @@ -414,19 +881,21 @@ 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) { } - virtual void Output(std::ostream &out) const; + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; struct CYElement : - CYNext + CYNext, + CYThing { CYExpression *value_; @@ -436,7 +905,8 @@ struct CYElement : { } - void Output(std::ostream &out) const; + void Replace(CYContext &context); + void Output(CYOutput &out) const; }; struct CYArray : @@ -444,16 +914,16 @@ struct CYArray : { CYElement *elements_; - CYArray(CYElement *elements) : + CYArray(CYElement *elements = NULL) : elements_(elements) { } - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYDeclaration : - CYThing, CYForInInitialiser { CYIdentifier *identifier_; @@ -465,40 +935,65 @@ struct CYDeclaration : { } - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const; + virtual void ForIn(CYOutput &out, CYFlags flags) const; + + virtual const char *ForEachIn() const; + virtual CYExpression *ForEachIn(CYContext &out); + + void Replace(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYDeclarations : - CYStatement, - CYForInitialiser + CYNext, + CYForInitialiser, + CYThing { CYDeclaration *declaration_; - CYDeclarations *next_; - CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) : - declaration_(declaration), - next_(next) + CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) : + CYNext(next), + declaration_(declaration) { } - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const; + virtual void For(CYOutput &out) const; + + void Replace(CYContext &context); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYParameter : - CYNext, - CYThing +struct CYVar : + CYStatement { - CYIdentifier *name_; + CYDeclarations *declarations_; - CYParameter(CYIdentifier *name, CYParameter *next) : - CYNext(next), - name_(name) + CYVar(CYDeclarations *declarations) : + declarations_(declarations) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYLet : + CYStatement +{ + CYDeclarations *declarations_; + CYBlock code_; + + CYLet(CYDeclarations *declarations, CYStatement *statements) : + declarations_(declarations), + code_(statements) { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYFor : @@ -517,7 +1012,8 @@ struct CYFor : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYForIn : @@ -534,81 +1030,123 @@ struct CYForIn : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYForEachIn : + CYStatement +{ + CYForInInitialiser *initialiser_; + CYExpression *set_; + CYStatement *code_; + + CYForEachIn(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 CYProperty : - CYNext + CYNext, + CYThing { - CYName *name_; + CYPropertyName *name_; CYExpression *value_; - CYProperty(CYName *name, CYExpression *value, CYProperty *next) : + CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) : CYNext(next), name_(name), value_(value) { } - virtual void Output(std::ostream &out) const; + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; struct CYObject : CYLiteral { - CYProperty *property_; + CYProperty *properties_; - CYObject(CYProperty *property) : - property_(property) + CYObject(CYProperty *properties) : + properties_(properties) { } - void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; }; struct CYCatch : CYThing { CYIdentifier *name_; - CYStatement *code_; + CYBlock code_; - CYCatch(CYIdentifier *name, CYStatement *code) : + CYCatch(CYIdentifier *name, CYStatement *statements) : name_(name), - code_(code) + code_(statements) { } - virtual void Output(std::ostream &out) const; + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYMessage : +struct CYMember : CYExpression { - CYExpression *self_; - CYArgument *arguments_; + CYExpression *object_; + CYExpression *property_; - CYMessage(CYExpression *self, CYArgument *arguments) : - self_(self), - arguments_(arguments) + CYMember(CYExpression *object, CYExpression *property) : + object_(object), + property_(property) { } - virtual void Output(std::ostream &out) const; + void SetLeft(CYExpression *object) { + object_ = object; + } + + void Replace_(CYContext &context); }; -struct CYMember : - CYExpression +struct CYDirectMember : + CYMember { - CYExpression *object_; - CYExpression *property_; + CYDirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) + { + } - CYMember(CYExpression *object, CYExpression *property) : - object_(object), - property_(property) + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYIndirectMember : + CYMember +{ + CYIndirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYNew : @@ -623,7 +1161,14 @@ struct CYNew : { } - virtual void Output(std::ostream &out) const; + virtual unsigned Precedence() const { + return arguments_ == NULL ? 2 : 1; + } + + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYCall : @@ -632,13 +1177,17 @@ struct CYCall : CYExpression *function_; CYArgument *arguments_; - CYCall(CYExpression *function, CYArgument *arguments) : + CYCall(CYExpression *function, CYArgument *arguments = NULL) : function_(function), arguments_(arguments) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYIf : @@ -648,14 +1197,15 @@ struct CYIf : CYStatement *true_; CYStatement *false_; - CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false) : + CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) : test_(test), true_(_true), false_(_false) { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYDoWhile : @@ -670,7 +1220,8 @@ struct CYDoWhile : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYWhile : @@ -685,36 +1236,53 @@ struct CYWhile : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYLambda : - CYExpression -{ +struct CYFunction { CYIdentifier *name_; - CYParameter *parameters_; - CYSource *body_; + CYFunctionParameter *parameters_; + CYBlock code_; - CYLambda(CYIdentifier *name, CYParameter *parameters, CYSource *body) : + CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : name_(name), parameters_(parameters), - body_(body) + code_(statements) { } - virtual void Output(std::ostream &out) const; + virtual void Replace_(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYFunction : - CYLambda, - CYSource +struct CYFunctionExpression : + CYFunction, + CYExpression { - CYFunction(CYIdentifier *name, CYParameter *parameters, CYSource *body) : - CYLambda(name, parameters, body) + CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(name, parameters, statements) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +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 : @@ -727,7 +1295,8 @@ struct CYExpress : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYContinue : @@ -740,7 +1309,8 @@ struct CYContinue : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYBreak : @@ -753,7 +1323,8 @@ struct CYBreak : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYReturn : @@ -766,31 +1337,47 @@ struct CYReturn : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYEmpty : CYStatement { - virtual void Output(std::ostream &out) const; - virtual void Output(std::ostream &out, bool block) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFinally : + CYThing +{ + CYBlock code_; + + CYFinally(CYStatement *statements) : + code_(statements) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; struct CYTry : CYStatement { - CYStatement *try_; + CYBlock code_; CYCatch *catch_; - CYStatement *finally_; + CYFinally *finally_; - CYTry(CYStatement *_try, CYCatch *_catch, CYStatement *finally) : - try_(_try), + CYTry(CYStatement *statements, CYCatch *_catch, CYFinally *finally) : + code_(statements), catch_(_catch), finally_(finally) { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYThrow : @@ -803,7 +1390,8 @@ struct CYThrow : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYWith : @@ -818,7 +1406,8 @@ struct CYWith : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYSwitch : @@ -833,7 +1422,8 @@ struct CYSwitch : { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYCondition : @@ -844,12 +1434,16 @@ struct CYCondition : CYExpression *false_; CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) : + test_(test), true_(_true), false_(_false) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(15) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; struct CYAddressOf : @@ -864,7 +1458,9 @@ struct CYAddressOf : return "&"; } - virtual void Output(std::ostream &out) const; + CYAlphabetic(false) + + virtual CYExpression *Replace(CYContext &context); }; struct CYIndirect : @@ -879,13 +1475,18 @@ struct CYIndirect : return "*"; } - virtual void Output(std::ostream &out) const; + CYAlphabetic(false) + + 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) \ { \ @@ -896,38 +1497,43 @@ struct CYIndirect : } \ }; -#define CYPrefix_(op, name) \ +#define CYPrefix_(alphabetic, op, name, args...) \ struct CY ## name : \ CYPrefix \ - { \ + { args \ CY ## name(CYExpression *rhs) : \ CYPrefix(rhs) \ { \ } \ + \ + CYAlphabetic(alphabetic) \ \ virtual const char *Operator() const { \ return op; \ } \ }; -#define CYInfix_(op, name) \ +#define CYInfix_(alphabetic, precedence, op, name, args...) \ struct CY ## name : \ CYInfix \ - { \ + { args \ CY ## name(CYExpression *lhs, CYExpression *rhs) : \ CYInfix(lhs, rhs) \ { \ } \ + \ + CYAlphabetic(alphabetic) \ + CYPrecedence(precedence) \ \ virtual const char *Operator() const { \ return op; \ } \ }; -#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) \ { \ @@ -941,38 +1547,39 @@ struct CYIndirect : CYPostfix_("++", PostIncrement) CYPostfix_("--", PostDecrement) -CYPrefix_("delete", Delete) -CYPrefix_("void", Void) -CYPrefix_("typeof", TypeOf) -CYPrefix_("++", PreIncrement) -CYPrefix_("--", PreDecrement) -CYPrefix_("-", Negate) -CYPrefix_("~", BitwiseNot) -CYPrefix_("!", LogicalNot) - -CYInfix_("*", Multiply) -CYInfix_("/", Divide) -CYInfix_("%", Modulus) -CYInfix_("+", Add) -CYInfix_("-", Subtract) -CYInfix_("<<", ShiftLeft) -CYInfix_(">>", ShiftRightSigned) -CYInfix_(">>>", ShiftRightUnsigned) -CYInfix_("<", Less) -CYInfix_(">", Greater) -CYInfix_("<=", LessOrEqual) -CYInfix_(">=", GreaterOrEqual) -CYInfix_("instanceof", InstanceOf) -CYInfix_("in", In) -CYInfix_("==", Equal) -CYInfix_("!=", NotEqual) -CYInfix_("===", Identical) -CYInfix_("!==", NotIdentical) -CYInfix_("&", BitwiseAnd) -CYInfix_("^", BitwiseXOr) -CYInfix_("|", BitwiseOr) -CYInfix_("&&", LogicalAnd) -CYInfix_("||", LogicalOr) +CYPrefix_(true, "delete", Delete) +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, "/", Divide) +CYInfix_(false, 5, "%", Modulus) +CYInfix_(false, 6, "+", Add, CYReplace) +CYInfix_(false, 6, "-", Subtract) +CYInfix_(false, 7, "<<", ShiftLeft) +CYInfix_(false, 7, ">>", ShiftRightSigned) +CYInfix_(false, 7, ">>>", ShiftRightUnsigned) +CYInfix_(false, 8, "<", Less) +CYInfix_(false, 8, ">", Greater) +CYInfix_(false, 8, "<=", LessOrEqual) +CYInfix_(false, 8, ">=", GreaterOrEqual) +CYInfix_(true, 8, "instanceof", InstanceOf) +CYInfix_(true, 8, "in", In) +CYInfix_(false, 9, "==", Equal) +CYInfix_(false, 9, "!=", NotEqual) +CYInfix_(false, 9, "===", Identical) +CYInfix_(false, 9, "!==", NotIdentical) +CYInfix_(false, 10, "&", BitwiseAnd) +CYInfix_(false, 11, "^", BitwiseXOr) +CYInfix_(false, 12, "|", BitwiseOr) +CYInfix_(false, 13, "&&", LogicalAnd) +CYInfix_(false, 14, "||", LogicalOr) CYAssignment_("=", ) CYAssignment_("*=", Multiply)