X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/cf7d4c691503f6711d7e407b2bc30100de19ce2e..f33b048af6516bdeff373d3eb709f3d445233dc4:/Parser.hpp diff --git a/Parser.hpp b/Parser.hpp index 3fb903a..365d1a5 100644 --- a/Parser.hpp +++ b/Parser.hpp @@ -1,39 +1,95 @@ +/* Cycript - Remove 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 +#include +#include -class CYParser { - public: - void *scanner_; +#include "location.hh" +#include "Pooling.hpp" - private: - void ScannerInit(); - void ScannerDestroy(); +template +struct CYNext { + Type_ *next_; - public: - CYParser(); - ~CYParser(); -}; + CYNext() : + next_(NULL) + { + } -struct CYSource { - CYSource *next_; + CYNext(Type_ *next) : + next_(next) + { + } - void SetNext(CYSource *next) { + void SetNext(Type_ *next) { next_ = next; } }; -struct CYName { - virtual const char *Name() const = 0; +struct CYThing { + virtual void Output(std::ostream &out) const = 0; }; -struct CYToken { - virtual const char *Text() const = 0; +_finline std::ostream &operator <<(std::ostream &out, const CYThing &rhs) { + rhs.Output(out); + return out; +} + +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 CYName : + CYThing +{ + virtual const char *Name() const = 0; }; struct CYWord : - virtual CYToken, CYName { const char *word_; @@ -43,32 +99,34 @@ struct CYWord : { } - virtual const char *Text() const { + const char *Value() const { return word_; } virtual const char *Name() const { - return Text(); + return Value(); } + + virtual void Output(std::ostream &out) const; }; struct CYIdentifier : CYWord { - const char *word_; - - virtual const char *Text() const { - return word_; + CYIdentifier(const char *word) : + CYWord(word) + { } }; -struct CYLabel { +struct CYLabel : + CYNext +{ CYIdentifier *identifier_; - CYLabel *next_; CYLabel(CYIdentifier *identifier, CYLabel *next) : - identifier_(identifier), - next_(next) + CYNext(next), + identifier_(identifier) { } }; @@ -83,61 +141,247 @@ struct CYStatement : } }; -struct CYForInitialiser { +enum CYState { + CYClear, + CYRestricted, + CYNewLine }; -struct CYForInInitialiser { +class CYDriver { + public: + CYPool pool_; + + CYState state_; + void *scanner_; + + const char *data_; + size_t size_; + + std::string filename_; + + struct Error { + cy::location location_; + std::string message_; + }; + + typedef std::vector Errors; + + CYSource *source_; + Errors errors_; + + private: + void ScannerInit(); + void ScannerDestroy(); + + public: + CYDriver(const std::string &filename); + ~CYDriver(); +}; + +struct CYPart { + virtual void Part(std::ostream &out) const = 0; +}; + +struct CYForInitialiser : + CYPart +{ +}; + +struct CYForInInitialiser : + CYPart +{ +}; + +enum CYFlags { + CYNoFlags = 0, + CYNoBrace = (1 << 0), + CYNoFunction = (1 << 1), + CYNoLeader = (1 << 2), + CYNoTrailer = (1 << 3), + CYNoIn = (1 << 4), }; struct CYExpression : - CYStatement, + CYNext, CYForInitialiser, CYForInInitialiser { + virtual unsigned Precedence() const = 0; + virtual void Part(std::ostream &out) const; + virtual void Output(std::ostream &out, CYFlags flags) const = 0; + void Output(std::ostream &out, unsigned precedence, CYFlags flags) const; + + virtual const char *Word() const { + return NULL; + } +}; + +#define CYAlphabetic(value) \ + virtual bool Alphabetic() const { \ + return value; \ + } + +#define CYPrecedence(value) \ + virtual unsigned Precedence() 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) + + void Output(std::ostream &out, CYFlags flags) const; }; struct CYLiteral : CYExpression { + CYPrecedence(0) +}; + +struct CYMagic : + CYExpression +{ + CYPrecedence(0) +}; + +struct CYSelectorPart : + CYNext +{ + CYWord *name_; + bool value_; + + CYSelectorPart(CYWord *name, bool value, CYSelectorPart *next) : + CYNext(next), + name_(name), + value_(value) + { + } + + virtual void Output(std::ostream &out) const; +}; + +struct CYSelector : + CYLiteral +{ + CYSelectorPart *name_; + + CYSelector(CYSelectorPart *name) : + name_(name) + { + } + + CYPrecedence(1) + + virtual void Output(std::ostream &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; + } + + void operator()(uint8_t value) { + if (value >> 7) + return; + (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f); + } }; +extern CYRange WordStartRange_; +extern CYRange WordEndRange_; + struct CYString : CYLiteral, CYName { const char *value_; + size_t size_; - CYString(const char *value) : - value_(value) + CYString(const char *value, size_t size) : + value_(value), + size_(size) { } CYString(const CYIdentifier *identifier) : - value_(identifier->Text()) + value_(identifier->Value()), + size_(strlen(value_)) { } - const char *String() const { + const char *Value() const { return value_; } virtual const char *Name() const { - return String(); + return Value(); + } + + virtual const char *Word() const { + if (size_ == 0 || !WordStartRange_[value_[0]]) + return NULL; + for (size_t i(1); i != size_; ++i) + if (!WordEndRange_[value_[i]]) + return NULL; + return Value(); } + + virtual void Output(std::ostream &out) const { + return Output(out, CYNoFlags); + } + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYNumber : - virtual CYToken, CYLiteral, CYName { - double Number() const { - throw; + double value_; + + CYNumber(double value) : + value_(value) + { + } + + double Value() const { + return value_; } virtual const char *Name() const { throw; } + + virtual void Output(std::ostream &out) const { + return Output(out, CYNoFlags); + } + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYNull : @@ -148,21 +392,27 @@ struct CYNull : CYWord("null") { } + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYThis : CYWord, - CYExpression + CYMagic { CYThis() : CYWord("this") { } + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYBoolean : CYLiteral { + virtual bool Value() const = 0; + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYFalse : @@ -173,6 +423,8 @@ struct CYFalse : CYWord("false") { } + + virtual bool Value() const; }; struct CYTrue : @@ -183,6 +435,8 @@ struct CYTrue : CYWord("true") { } + + virtual bool Value() const; }; struct CYVariable : @@ -194,6 +448,10 @@ struct CYVariable : name_(name) { } + + CYPrecedence(0) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYPrefix : @@ -205,6 +463,11 @@ struct CYPrefix : rhs_(rhs) { } + + virtual bool Alphabetic() const = 0; + virtual const char *Operator() const = 0; + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYInfix : @@ -218,6 +481,11 @@ struct CYInfix : rhs_(rhs) { } + + virtual bool Alphabetic() const = 0; + virtual const char *Operator() const = 0; + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYPostfix : @@ -229,28 +497,43 @@ struct CYPostfix : lhs_(lhs) { } + + virtual const char *Operator() const = 0; + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYAssignment : - CYInfix + CYExpression { + CYExpression *lhs_; + CYExpression *rhs_; + CYAssignment(CYExpression *lhs, CYExpression *rhs) : - CYInfix(lhs, rhs) + lhs_(lhs), + rhs_(rhs) { } + + virtual const char *Operator() const = 0; + + virtual void Output(std::ostream &out, CYFlags flags) const; }; -struct CYArgument { +struct CYArgument : + CYNext +{ CYWord *name_; CYExpression *value_; - CYArgument *next_; CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : + CYNext(next), name_(name), - value_(value), - next_(next) + value_(value) { } + + void Output(std::ostream &out) const; }; struct CYBlank : @@ -262,10 +545,12 @@ struct CYBlank : } }; -struct CYClause { +struct CYClause : + CYThing, + CYNext +{ CYExpression *case_; CYStatement *code_; - CYClause *next_; CYClause(CYExpression *_case, CYStatement *code) : case_(_case), @@ -273,25 +558,38 @@ struct CYClause { { } - void SetNext(CYClause *next) { - next_ = next; - } + virtual void Output(std::ostream &out) const; }; struct CYElement : - CYLiteral + CYNext { CYExpression *value_; - CYElement *next_; CYElement(CYExpression *value, CYElement *next) : - value_(value), - next_(next) + CYNext(next), + value_(value) { } + + void Output(std::ostream &out) const; +}; + +struct CYArray : + CYLiteral +{ + CYElement *elements_; + + CYArray(CYElement *elements) : + elements_(elements) + { + } + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYDeclaration : + CYThing, CYForInInitialiser { CYIdentifier *identifier_; @@ -302,6 +600,9 @@ struct CYDeclaration : initialiser_(initialiser) { } + + virtual void Part(std::ostream &out) const; + virtual void Output(std::ostream &out) const; }; struct CYDeclarations : @@ -316,17 +617,83 @@ struct CYDeclarations : next_(next) { } + + virtual void Part(std::ostream &out) const; + virtual void Output(std::ostream &out) const; +}; + +struct CYField : + CYNext +{ + virtual void Output(std::ostream &out) const; }; -struct CYParameter { +struct CYMessageParameter : + CYNext +{ + CYWord *tag_; + CYExpression *type_; CYIdentifier *name_; - CYParameter *next_; - CYParameter(CYIdentifier *name, CYParameter *next) : + CYMessageParameter(CYWord *tag, CYExpression *type, CYIdentifier *name) : + tag_(tag), + type_(type), + name_(name) + { + } +}; + +struct CYMessage : + CYSource +{ + bool instance_; + CYExpression *type_; + CYMessageParameter *parameter_; + CYSource *body_; + + CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYSource *body) : + instance_(instance), + type_(type), + parameter_(parameter), + body_(body) + { + } + + virtual void Output(std::ostream &out) const; +}; + +struct CYClass : + CYSource +{ + CYIdentifier *name_; + CYExpression *super_; + CYField *fields_; + CYMessage *messages_; + + CYClass(CYIdentifier *name, CYExpression *super, CYField *fields, CYMessage *messages) : name_(name), - next_(next) + super_(super), + fields_(fields), + messages_(messages) { } + + virtual void Output(std::ostream &out) const; +}; + +struct CYFunctionParameter : + CYNext, + CYThing +{ + CYIdentifier *name_; + + CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next) : + CYNext(next), + name_(name) + { + } + + virtual void Output(std::ostream &out) const; }; struct CYFor : @@ -344,6 +711,8 @@ struct CYFor : code_(code) { } + + virtual void Output(std::ostream &out) const; }; struct CYForIn : @@ -359,24 +728,42 @@ struct CYForIn : code_(code) { } + + virtual void Output(std::ostream &out) const; }; struct CYProperty : - CYLiteral + CYNext { CYName *name_; CYExpression *value_; - CYProperty *next_; CYProperty(CYName *name, CYExpression *value, CYProperty *next) : + CYNext(next), name_(name), - value_(value), - next_(next) + value_(value) { } + + virtual void Output(std::ostream &out) const; }; -struct CYCatch { +struct CYObject : + CYLiteral +{ + CYProperty *property_; + + CYObject(CYProperty *property) : + property_(property) + { + } + + void Output(std::ostream &out, CYFlags flags) const; +}; + +struct CYCatch : + CYThing +{ CYIdentifier *name_; CYStatement *code_; @@ -385,19 +772,25 @@ struct CYCatch { code_(code) { } + + virtual void Output(std::ostream &out) const; }; -struct CYMessage : +struct CYSend : CYExpression { CYExpression *self_; CYArgument *arguments_; - CYMessage(CYExpression *self, CYArgument *arguments) : + CYSend(CYExpression *self, CYArgument *arguments) : self_(self), arguments_(arguments) { } + + CYPrecedence(0) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYMember : @@ -411,6 +804,10 @@ struct CYMember : property_(property) { } + + CYPrecedence(1) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYNew : @@ -424,6 +821,10 @@ struct CYNew : arguments_(arguments) { } + + CYPrecedence(1) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYCall : @@ -437,6 +838,10 @@ struct CYCall : arguments_(arguments) { } + + CYPrecedence(2) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYIf : @@ -452,6 +857,8 @@ struct CYIf : false_(_false) { } + + virtual void Output(std::ostream &out) const; }; struct CYDoWhile : @@ -465,6 +872,8 @@ struct CYDoWhile : code_(code) { } + + virtual void Output(std::ostream &out) const; }; struct CYWhile : @@ -478,30 +887,52 @@ struct CYWhile : code_(code) { } + + virtual void Output(std::ostream &out) const; }; struct CYLambda : CYExpression { CYIdentifier *name_; - CYParameter *parameters_; + CYFunctionParameter *parameters_; CYSource *body_; - CYLambda(CYIdentifier *name, CYParameter *parameters, CYSource *body) : + CYLambda(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) : name_(name), parameters_(parameters), body_(body) { } + + CYPrecedence(0) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; struct CYFunction : - CYLambda + CYLambda, + CYSource { - CYFunction(CYIdentifier *name, CYParameter *parameters, CYSource *body) : + CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) : CYLambda(name, parameters, body) { } + + virtual void Output(std::ostream &out) const; +}; + +struct CYExpress : + CYStatement +{ + CYExpression *expression_; + + CYExpress(CYExpression *expression) : + expression_(expression) + { + } + + virtual void Output(std::ostream &out) const; }; struct CYContinue : @@ -513,6 +944,8 @@ struct CYContinue : label_(label) { } + + virtual void Output(std::ostream &out) const; }; struct CYBreak : @@ -524,6 +957,8 @@ struct CYBreak : label_(label) { } + + virtual void Output(std::ostream &out) const; }; struct CYReturn : @@ -535,11 +970,15 @@ struct CYReturn : value_(value) { } + + virtual void Output(std::ostream &out) const; }; struct CYEmpty : CYStatement { + virtual void Output(std::ostream &out) const; + virtual void Output(std::ostream &out, bool block) const; }; struct CYTry : @@ -555,6 +994,8 @@ struct CYTry : finally_(finally) { } + + virtual void Output(std::ostream &out) const; }; struct CYThrow : @@ -566,6 +1007,8 @@ struct CYThrow : value_(value) { } + + virtual void Output(std::ostream &out) const; }; struct CYWith : @@ -579,6 +1022,8 @@ struct CYWith : code_(code) { } + + virtual void Output(std::ostream &out) const; }; struct CYSwitch : @@ -592,6 +1037,8 @@ struct CYSwitch : clauses_(clauses) { } + + virtual void Output(std::ostream &out) const; }; struct CYCondition : @@ -602,10 +1049,51 @@ struct CYCondition : CYExpression *false_; CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) : + test_(test), true_(_true), false_(_false) { } + + CYPrecedence(15) + + virtual void Output(std::ostream &out, CYFlags flags) const; +}; + +struct CYAddressOf : + CYPrefix +{ + CYAddressOf(CYExpression *rhs) : + CYPrefix(rhs) + { + } + + virtual const char *Operator() const { + return "&"; + } + + CYAlphabetic(false) + CYPrecedence(2) + + virtual void Output(std::ostream &out, CYFlags flags) const; +}; + +struct CYIndirect : + CYPrefix +{ + CYIndirect(CYExpression *rhs) : + CYPrefix(rhs) + { + } + + virtual const char *Operator() const { + return "*"; + } + + CYAlphabetic(false) + CYPrecedence(1) + + virtual void Output(std::ostream &out, CYFlags flags) const; }; #define CYPostfix_(op, name) \ @@ -616,9 +1104,15 @@ struct CYCondition : CYPostfix(lhs) \ { \ } \ + \ + CYPrecedence(3) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ }; -#define CYPrefix_(op, name) \ +#define CYPrefix_(alphabetic, op, name) \ struct CY ## name : \ CYPrefix \ { \ @@ -626,9 +1120,16 @@ struct CYCondition : CYPrefix(rhs) \ { \ } \ + \ + CYAlphabetic(alphabetic) \ + CYPrecedence(4) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ }; -#define CYInfix_(op, name) \ +#define CYInfix_(alphabetic, precedence, op, name) \ struct CY ## name : \ CYInfix \ { \ @@ -636,6 +1137,13 @@ struct CYCondition : CYInfix(lhs, rhs) \ { \ } \ + \ + CYAlphabetic(alphabetic) \ + CYPrecedence(precedence) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ }; #define CYAssignment_(op, name) \ @@ -646,45 +1154,49 @@ struct CYCondition : CYAssignment(lhs, rhs) \ { \ } \ + \ + CYPrecedence(16) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ }; CYPostfix_("++", PostIncrement) CYPostfix_("--", PostDecrement) -CYPrefix_("delete", Delete) -CYPrefix_("void", Void) -CYPrefix_("typeof", TypeOf) -CYPrefix_("++", PreIncrement) -CYPrefix_("--", PreDecrement) -CYPrefix_("-", Negate) -CYPrefix_("~", BitwiseNot) -CYPrefix_("!", LogicalNot) -CYPrefix_("*", Indirect) -CYPrefix_("&", AddressOf) - -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, "-", Negate) +CYPrefix_(false, "~", BitwiseNot) +CYPrefix_(false, "!", LogicalNot) + +CYInfix_(false, 5, "*", Multiply) +CYInfix_(false, 5, "/", Divide) +CYInfix_(false, 5, "%", Modulus) +CYInfix_(false, 6, "+", Add) +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)