X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/db5e284073ce1f951343c5825a7e4d64d159582b..8f41509fd52c574f447fe0e40555530de3fda431:/Parser.hpp diff --git a/Parser.hpp b/Parser.hpp index d7322aa..fab18af 100644 --- a/Parser.hpp +++ b/Parser.hpp @@ -1,55 +1,205 @@ -#ifndef CYPARSER_HPP -#define CYPARSER_HPP +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2013 Jay Freeman (saurik) +*/ + +/* GNU General Public License, Version 3 {{{ */ +/* + * Cycript is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. + * + * Cycript 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Cycript. If not, see <http://www.gnu.org/licenses/>. +**/ +/* }}} */ + +#ifndef CYCRIPT_PARSER_HPP +#define CYCRIPT_PARSER_HPP + +#include <iostream> -#include <cstdlib> #include <string> #include <vector> +#include <map> +#include <set> + +#include <cstdio> +#include <cstdlib> +#include "List.hpp" #include "Pooling.hpp" +#include "Options.hpp" + +struct CYContext; -template <typename Type_> -struct CYNext { - Type_ *next_; +struct CYThing { + virtual ~CYThing() { + } + + virtual void Output(struct CYOutput &out) const = 0; +}; - CYNext() : - next_(NULL) +struct CYOutput { + std::ostream &out_; + CYOptions &options_; + bool pretty_; + unsigned indent_; + bool right_; + + enum { + NoMode, + NoLetter, + NoPlus, + NoHyphen, + Terminated + } mode_; + + CYOutput(std::ostream &out, CYOptions &options) : + out_(out), + options_(options), + pretty_(false), + indent_(0), + right_(false), + mode_(NoMode) { } - void SetNext(Type_ *next) { - next_ = next; + void Check(char value); + void Terminate(); + + CYOutput &operator <<(char rhs); + CYOutput &operator <<(const char *rhs); + + _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 CYThing { - virtual void Output(std::ostream &out) const = 0; +struct CYPropertyName { + virtual void PropertyName(CYOutput &out) const = 0; + + virtual ~CYPropertyName() { + } }; -_finline std::ostream &operator <<(std::ostream &out, const CYThing &rhs) { - rhs.Output(out); - return out; -} +struct CYExpression; +struct CYAssignment; -struct CYPart { - virtual void Part(std::ostream &out) const = 0; +enum CYNeeded { + CYNever = -1, + CYSometimes = 0, + CYAlways = 1, }; -struct CYSource : - CYNext<CYSource> -{ - virtual void Show(std::ostream &out) const; - virtual void Output(std::ostream &out) const = 0; - virtual void Output(std::ostream &out, bool block) const; +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), }; -struct CYName : - CYThing +_finline CYFlags operator ~(CYFlags rhs) { + return static_cast<CYFlags>(~static_cast<unsigned>(rhs)); +} + +_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { + return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); +} + +_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { + return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(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<CYStatement> { - virtual const char *Name() const = 0; + 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; }; struct CYWord : - CYName + CYThing, + CYPropertyName, + CYClassName { const char *word_; @@ -58,683 +208,1750 @@ struct CYWord : { } - const char *Value() const { - return word_; + void Set(const char *value) { + word_ = value; } - virtual const char *Name() const { - return Value(); - } + virtual const char *Word() const; + 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) { + lhs << &rhs << '='; + return lhs << rhs.Word(); +} + struct CYIdentifier : + CYNext<CYIdentifier>, 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 CYLabel { - CYIdentifier *identifier_; - CYLabel *next_; +struct CYComment : + CYStatement +{ + const char *value_; - CYLabel(CYIdentifier *identifier, CYLabel *next) : - identifier_(identifier), - next_(next) + CYComment(const char *value) : + value_(value) { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYStatement : - CYSource +struct CYLabel : + CYStatement { - CYLabel *label_; + CYIdentifier *name_; + CYStatement *statement_; - void AddLabel(CYIdentifier *identifier) { - label_ = new CYLabel(identifier, label_); + CYLabel(CYIdentifier *name, CYStatement *statement) : + name_(name), + statement_(statement) + { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -enum CYState { - CYClear, - CYRestricted, - CYNewLine +struct CYCStringLess : + std::binary_function<const char *, const char *, bool> +{ + _finline bool operator ()(const char *lhs, const char *rhs) const { + return strcmp(lhs, rhs) < 0; + } }; -class CYDriver { - public: - CYPool pool_; - CYState state_; - std::string filename_; - std::vector<CYSource *> source_; - void *scanner_; +struct CYIdentifierValueLess : + std::binary_function<CYIdentifier *, CYIdentifier *, bool> +{ + _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const { + return CYCStringLess()(lhs->Word(), rhs->Word()); + } +}; - private: - void ScannerInit(); - void ScannerDestroy(); +enum CYIdentifierFlags { + CYIdentifierArgument, + CYIdentifierVariable, + CYIdentifierOther, + CYIdentifierMagic, + CYIdentifierCatch, +}; - public: - CYDriver(const std::string &filename); - ~CYDriver(); +typedef std::set<const char *, CYCStringLess> CYCStringSet; +typedef std::set<CYIdentifier *, CYIdentifierValueLess> CYIdentifierValueSet; +typedef std::map<CYIdentifier *, CYIdentifierFlags> CYIdentifierAddressFlagsMap; - void Clear(); +struct CYIdentifierUsage { + CYIdentifier *identifier_; + size_t usage_; }; -struct CYForInitialiser : - CYPart -{ +typedef std::vector<CYIdentifierUsage> 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 CYForInInitialiser : - CYPart +struct CYProgram : + CYThing { + CYStatement *statements_; + + CYProgram(CYStatement *statements) : + statements_(statements) + { + } + + virtual void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYExpression : - CYNext<CYExpression>, - CYForInitialiser, - CYForInInitialiser -{ - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const = 0; - void Output(std::ostream &out, bool raw) const; +struct CYNonLocal; +struct CYThisScope; + +struct CYContext { + CYOptions &options_; + + CYScope *scope_; + CYThisScope *this_; + + CYIdentifierUsageVector rename_; + + CYNonLocal *nonlocal_; + CYNonLocal *nextlocal_; + unsigned unique_; + + CYContext(CYOptions &options) : + options_(options), + scope_(NULL), + this_(NULL), + nonlocal_(NULL), + nextlocal_(NULL), + unique_(0) + { + } + + virtual ~CYContext() { + } + + template <typename Type_> + void ReplaceAll(Type_ *&values) { + Type_ **last(&values); + CYForEach (next, values) { + Replace(*last = next); + if (*last != NULL) + last = &(*last)->next_; + } + } + + template <typename Type_> + void Replace(Type_ *&value) { + for (;;) if (value == NULL) + break; + else { + Type_ *replace(value->Replace(*this)); + if (replace != value) + value = replace; + else break; + } + } + + void NonLocal(CYStatement *&statements); + CYIdentifier *Unique(); }; -_finline std::ostream &operator <<(std::ostream &out, const CYExpression &rhs) { - rhs.Output(out, false); - return out; -} +struct CYNonLocal { + CYIdentifier *identifier_; -struct CYLiteral : - CYExpression -{ + CYNonLocal() : + identifier_(NULL) + { + } + + CYIdentifier *Target(CYContext &context) { + if (identifier_ == NULL) + identifier_ = context.Unique(); + return identifier_; + } }; -struct CYString : - CYLiteral, - CYName +struct CYThisScope : + CYNext<CYThisScope> { - const char *value_; - size_t size_; + CYIdentifier *identifier_; - CYString(const char *value, size_t size) : - value_(value), - size_(size) + CYThisScope() : + identifier_(NULL) { } - CYString(const CYIdentifier *identifier) : - value_(identifier->Value()), - size_(strlen(value_)) + 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) { } - const char *Value() const { - return value_; + operator CYStatement *() const { + return statements_; } - virtual const char *Name() const { - return Value(); + void AddPrev(CYStatement *statement) { + CYSetLast(statement) = statements_; + statements_ = statement; } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYNumber : - CYLiteral, - CYName +struct CYForInitialiser { + 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 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 : + CYForInitialiser, + CYForInInitialiser, + CYClassName, + CYThing { - double value_; + virtual int Precedence() const = 0; - CYNumber(double value) : - value_(value) - { + virtual bool RightHand() const { + return true; } - double Value() const { - return value_; + virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); + + 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, 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 const char *Name() const { - throw; + virtual CYNumber *Number(CYContext &context) { + return NULL; + } + + virtual CYString *String(CYContext &context) { + return NULL; } - virtual void Output(std::ostream &out) const; + virtual const char *Word() const { + return NULL; + } }; -struct CYNull : - CYWord, - CYLiteral +#define CYAlphabetic(value) \ + virtual bool Alphabetic() const { \ + return value; \ + } + +#define CYPrecedence(value) \ + static const int Precedence_ = value; \ + virtual int Precedence() const { \ + return Precedence_; \ + } + +#define CYRightHand(value) \ + virtual bool RightHand() const { \ + return value; \ + } + +struct CYCompound : + CYExpression { - CYNull() : - CYWord("null") + CYExpression *expression_; + CYExpression *next_; + + CYCompound(CYExpression *expression, CYExpression *next = NULL) : + expression_(expression), + next_(next) { + if (expression_ == NULL) + throw; + _assert(expression_ != NULL); } - virtual void Output(std::ostream &out) const; + CYPrecedence(17) + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *Primitive(CYContext &context); }; -struct CYThis : - CYWord, - CYExpression +struct CYDeclaration; + +struct CYFunctionParameter : + CYNext<CYFunctionParameter>, + CYThing { - CYThis() : - CYWord("this") + CYForInInitialiser *initialiser_; + + CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) : + CYNext<CYFunctionParameter>(next), + initialiser_(initialiser) { } - virtual void Output(std::ostream &out) const; + void Replace(CYContext &context, CYBlock &code); + void Output(CYOutput &out) const; }; -struct CYBoolean : - CYLiteral +struct CYComprehension : + CYNext<CYComprehension>, + CYThing { - virtual bool Value() const = 0; - virtual void Output(std::ostream &out) const; + CYComprehension(CYComprehension *next = NULL) : + CYNext<CYComprehension>(next) + { + } + + 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 CYFalse : - CYWord, - CYBoolean +struct CYForInComprehension : + CYComprehension { - CYFalse() : - CYWord("false") + CYIdentifier *name_; + CYExpression *set_; + + CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), + name_(name), + set_(set) { } - virtual bool Value() const { - return false; + virtual const char *Name() const { + return name_->Word(); } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; -struct CYTrue : - CYWord, - CYBoolean +struct CYForOfComprehension : + CYComprehension { - CYTrue() : - CYWord("true") + CYIdentifier *name_; + CYExpression *set_; + + CYForOfComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), + name_(name), + set_(set) { } - virtual bool Value() const { - return true; + virtual const char *Name() const { + return name_->Word(); } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; }; -struct CYVariable : +struct CYIfComprehension : + CYComprehension +{ + CYExpression *test_; + + CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) : + CYComprehension(next), + 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 { - CYIdentifier *name_; + CYExpression *expression_; + CYComprehension *comprehensions_; - CYVariable(CYIdentifier *name) : - name_(name) + 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) + + virtual CYExpression *Primitive(CYContext &context) { + return this; + } +}; + +struct CYTrivial : + CYLiteral +{ + virtual CYExpression *Replace(CYContext &context); +}; + +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) + { + } + + 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 : + 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 CYWord *word) : + value_(word->Word()), + size_(strlen(value_)) + { + } + + const char *Value() const { + return value_; + } + + 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 : + CYTrivial, + CYPropertyName +{ + double value_; + + CYNumber(double value) : + value_(value) + { + } + + double Value() const { + 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 : + CYTrivial +{ + const char *value_; + + CYRegEx(const char *value) : + value_(value) + { + } + + const char *Value() const { + return value_; + } + + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYNull : + CYWord, + CYTrivial +{ + CYNull() : + CYWord("null") + { + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYThis : + CYWord, + CYMagic +{ + CYThis() : + CYWord("this") + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYBoolean : + CYTrivial +{ + virtual bool Value() const = 0; + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFalse : + CYWord, + CYBoolean +{ + CYFalse() : + CYWord("false") + { + } + + virtual bool Value() const { + return false; + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); +}; + +struct CYTrue : + CYWord, + CYBoolean +{ + CYTrue() : + CYWord("true") + { + } + + virtual bool Value() const { + return true; + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); +}; + +struct CYVariable : + CYExpression +{ + CYIdentifier *name_; + + CYVariable(CYIdentifier *name) : + name_(name) + { + } + + 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; +}; + +struct CYPrefix : + CYExpression +{ + CYExpression *rhs_; + + CYPrefix(CYExpression *rhs) : + rhs_(rhs) + { + } + + 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; +}; + +struct CYInfix : + CYExpression +{ + CYExpression *lhs_; + CYExpression *rhs_; + + CYInfix(CYExpression *lhs, CYExpression *rhs) : + lhs_(lhs), + rhs_(rhs) + { + } + + void SetLeft(CYExpression *lhs) { + lhs_ = lhs; + } + + virtual bool Alphabetic() const = 0; + virtual const char *Operator() const = 0; + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYPostfix : + CYExpression +{ + CYExpression *lhs_; + + CYPostfix(CYExpression *lhs) : + lhs_(lhs) + { + } + + virtual const char *Operator() const = 0; + + CYPrecedence(3) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYAssignment : + CYExpression +{ + CYExpression *lhs_; + CYExpression *rhs_; + + CYAssignment(CYExpression *lhs, CYExpression *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<CYArgument>, + CYThing +{ + CYWord *name_; + CYExpression *value_; + + CYArgument(CYExpression *value, CYArgument *next = NULL) : + CYNext<CYArgument>(next), + name_(NULL), + value_(value) + { + } + + CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : + CYNext<CYArgument>(next), + name_(name), + value_(value) + { + } + + CYArgument *Replace(CYContext &context); + void Output(CYOutput &out) const; +}; + +struct CYBlank : + public CYWord +{ + CYBlank() : + CYWord("") + { + } +}; + +struct CYClause : + CYThing, + CYNext<CYClause> +{ + CYExpression *case_; + CYStatement *statements_; + + CYClause(CYExpression *_case, CYStatement *statements) : + case_(_case), + statements_(statements) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYElement : + CYNext<CYElement>, + CYThing +{ + CYExpression *value_; + + CYElement(CYExpression *value, CYElement *next) : + CYNext<CYElement>(next), + value_(value) + { + } + + void Replace(CYContext &context); + void Output(CYOutput &out) const; +}; + +struct CYArray : + CYLiteral +{ + CYElement *elements_; + + CYArray(CYElement *elements = NULL) : + elements_(elements) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYProperty : + CYNext<CYProperty>, + CYThing +{ + CYPropertyName *name_; + CYExpression *value_; + + CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) : + CYNext<CYProperty>(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 = NULL) : + identifier_(identifier), + initialiser_(initialiser) + { + } + + virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); + + 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<CYDeclarations>, + CYThing +{ + CYDeclaration *declaration_; + + CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) : + CYNext<CYDeclarations>(next), + declaration_(declaration) + { + } + + 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 +{ + CYDeclarations *declarations_; + + CYVar(CYDeclarations *declarations) : + declarations_(declarations) + { + } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYLetStatement : + CYStatement +{ + CYDeclarations *declarations_; + CYStatement *code_; + + CYLetStatement(CYDeclarations *declarations, CYStatement *code) : + declarations_(declarations), + 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 CYForIn : + CYStatement +{ + 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 CYForOf : + CYStatement +{ + CYForInInitialiser *initialiser_; + CYExpression *set_; + CYStatement *code_; + + 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 CYObject : + CYLiteral +{ + 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) + { + } + + void SetLeft(CYExpression *object) { + object_ = object; + } +}; + +struct CYDirectMember : + CYMember +{ + CYDirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, 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) + { + } + + 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), + parameters_(parameters), + code_(statements), + nonlocal_(NULL) { } - virtual void Output(std::ostream &out) const; + virtual ~CYFunction() { + } + + void Inject(CYContext &context); + virtual void Replace_(CYContext &context, bool outer); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYPrefix : +// XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression +struct CYFunctionExpression : + CYFunction, CYExpression { - CYExpression *rhs_; - - CYPrefix(CYExpression *rhs) : - rhs_(rhs) + CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(name, parameters, statements) { } - virtual const char *Operator() const = 0; + CYPrecedence(0) + CYRightHand(false) - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYInfix : +// XXX: this should derive from CYAnonymousFunction +struct CYFatArrow : + CYFunction, CYExpression { - CYExpression *lhs_; - CYExpression *rhs_; - - CYInfix(CYExpression *lhs, CYExpression *rhs) : - lhs_(lhs), - rhs_(rhs) + CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(NULL, parameters, statements) { } - virtual const char *Operator() const = 0; + CYPrecedence(0) + CYRightHand(false) - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYPostfix : - CYExpression +// XXX: this should derive from CYAnonymousFunctionExpression +struct CYRubyProc : + CYFunctionExpression { - CYExpression *lhs_; - - CYPostfix(CYExpression *lhs) : - lhs_(lhs) + CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) : + CYFunctionExpression(NULL, parameters, statements) { } - 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 CYAssignment : - CYInfix +// XXX: this should derive from CYNamedFunction +struct CYFunctionStatement : + CYFunction, + CYStatement { - CYAssignment(CYExpression *lhs, CYExpression *rhs) : - CYInfix(lhs, rhs) + CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) : + CYFunction(name, parameters, statements) { } - virtual const char *Operator() const = 0; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYArgument { - CYWord *name_; - CYExpression *value_; - CYArgument *next_; +struct CYExpress : + CYStatement +{ + CYExpression *expression_; - CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : - name_(name), - value_(value), - next_(next) + CYExpress(CYExpression *expression) : + expression_(expression) { + if (expression_ == NULL) + throw; } - void Output(std::ostream &out, bool send) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYBlank : - public CYWord +struct CYContinue : + CYStatement { - CYBlank() : - CYWord("") + CYIdentifier *label_; + + CYContinue(CYIdentifier *label) : + label_(label) { } + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYClause : - CYThing, - CYNext<CYClause> +struct CYBreak : + CYStatement { - CYExpression *case_; - CYStatement *code_; + CYIdentifier *label_; - CYClause(CYExpression *_case, CYStatement *code) : - case_(_case), - code_(code) + CYBreak(CYIdentifier *label) : + label_(label) { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYElement : - CYLiteral +struct CYReturn : + CYStatement { CYExpression *value_; - CYElement *next_; - CYElement(CYExpression *value, CYElement *next) : - value_(value), - next_(next) + CYReturn(CYExpression *value) : + value_(value) { } - void Output(std::ostream &out, bool raw) const; - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYDeclaration : - CYThing, - CYForInInitialiser +struct CYEmpty : + CYStatement { - CYIdentifier *identifier_; - CYExpression *initialiser_; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; - CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser) : - identifier_(identifier), - initialiser_(initialiser) +struct CYFinally : + CYThing +{ + CYBlock code_; + + CYFinally(CYStatement *statements) : + code_(statements) { } - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const; + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYDeclarations : - CYStatement, - CYForInitialiser +struct CYTypeSpecifier : + CYThing { - CYDeclaration *declaration_; - CYDeclarations *next_; + virtual CYExpression *Replace(CYContext &context) = 0; +}; - CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) : - declaration_(declaration), - next_(next) - { +struct CYTypeError : + CYTypeSpecifier +{ + CYTypeError() { } - virtual void Part(std::ostream &out) const; - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYParameter : - CYThing +struct CYTypeVoid : + CYTypeSpecifier { - CYIdentifier *name_; - CYParameter *next_; - - CYParameter(CYIdentifier *name, CYParameter *next) : - name_(name), - next_(next) - { + CYTypeVoid() { } - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYFor : - CYStatement +struct CYTypeVariable : + CYTypeSpecifier { - CYForInitialiser *initialiser_; - CYExpression *test_; - CYExpression *increment_; - CYStatement *code_; + CYIdentifier *name_; - CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) : - initialiser_(initialiser), - test_(test), - increment_(increment), - code_(code) + CYTypeVariable(CYIdentifier *name) : + name_(name) + { + } + + CYTypeVariable(const char *name) : + name_(new($pool) CYIdentifier(name)) { } - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYForIn : - CYStatement +struct CYTypeUnsigned : + CYTypeSpecifier { - CYForInInitialiser *initialiser_; - CYExpression *set_; - CYStatement *code_; + CYTypeSpecifier *specifier_; - CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) : - initialiser_(initialiser), - set_(set), - code_(code) + CYTypeUnsigned(CYTypeSpecifier *specifier) : + specifier_(specifier) { } - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYProperty : - CYLiteral +struct CYTypeSigned : + CYTypeSpecifier { - CYName *name_; - CYExpression *value_; - CYProperty *next_; + CYTypeSpecifier *specifier_; - CYProperty(CYName *name, CYExpression *value, CYProperty *next) : - name_(name), - value_(value), - next_(next) + CYTypeSigned(CYTypeSpecifier *specifier) : + specifier_(specifier) { } - void Output(std::ostream &out, bool raw) const; - virtual void Output(std::ostream &out) 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 void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYMessage : - CYExpression +struct CYTypeShort : + CYTypeSpecifier { - CYExpression *self_; - CYArgument *arguments_; + CYTypeSpecifier *specifier_; - CYMessage(CYExpression *self, CYArgument *arguments) : - self_(self), - arguments_(arguments) + CYTypeShort(CYTypeSpecifier *specifier) : + specifier_(specifier) { } - virtual void Output(std::ostream &out) const; + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYMember : - CYExpression +struct CYTypeModifier : + CYNext<CYTypeModifier> { - CYExpression *object_; - CYExpression *property_; - - CYMember(CYExpression *object, CYExpression *property) : - object_(object), - property_(property) + CYTypeModifier(CYTypeModifier *next) : + CYNext<CYTypeModifier>(next) { } - virtual void Output(std::ostream &out) const; + 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 CYNew : - CYExpression +struct CYTypeArrayOf : + CYTypeModifier { - CYExpression *constructor_; - CYArgument *arguments_; + CYExpression *size_; - CYNew(CYExpression *constructor, CYArgument *arguments) : - constructor_(constructor), - arguments_(arguments) + CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + size_(size) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(1) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYCall : - CYExpression +struct CYTypeConstant : + CYTypeModifier { - CYExpression *function_; - CYArgument *arguments_; - - CYCall(CYExpression *function, CYArgument *arguments) : - function_(function), - arguments_(arguments) + CYTypeConstant(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYIf : - CYStatement +struct CYTypePointerTo : + CYTypeModifier { - CYExpression *test_; - CYStatement *true_; - CYStatement *false_; - - CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false) : - test_(test), - true_(_true), - false_(_false) + CYTypePointerTo(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYDoWhile : - CYStatement +struct CYTypeVolatile : + CYTypeModifier { - CYExpression *test_; - CYStatement *code_; - - CYDoWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) + CYTypeVolatile(CYTypeModifier *next = NULL) : + CYTypeModifier(next) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYWhile : - CYStatement +struct CYTypedIdentifier : + CYNext<CYTypedIdentifier>, + CYThing { - CYExpression *test_; - CYStatement *code_; + CYIdentifier *identifier_; + CYTypeSpecifier *specifier_; + CYTypeModifier *modifier_; - CYWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) + CYTypedIdentifier(CYIdentifier *identifier = NULL) : + identifier_(identifier), + specifier_(NULL), + modifier_(NULL) + { + } + + CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) : + identifier_(NULL), + specifier_(specifier), + modifier_(modifier) { } - virtual void Output(std::ostream &out) const; + inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) { + CYSetLast(modifier_) = modifier; + return this; + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; }; -struct CYLambda : +struct CYEncodedType : CYExpression { - CYIdentifier *name_; - CYParameter *parameters_; - CYSource *body_; + CYTypedIdentifier *typed_; - CYLambda(CYIdentifier *name, CYParameter *parameters, CYSource *body) : - name_(name), - parameters_(parameters), - body_(body) + CYEncodedType(CYTypedIdentifier *typed) : + typed_(typed) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(1) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; -struct CYFunction : - CYLambda, - CYSource +struct CYTypedParameter : + CYNext<CYTypedParameter>, + CYThing { - CYFunction(CYIdentifier *name, CYParameter *parameters, CYSource *body) : - CYLambda(name, parameters, body) + CYTypedIdentifier *typed_; + + CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) : + CYNext<CYTypedParameter>(next), + typed_(typed) { } - virtual void Output(std::ostream &out) const; + CYArgument *Argument(CYContext &context); + CYFunctionParameter *Parameters(CYContext &context); + CYExpression *TypeSignature(CYContext &context, CYExpression *prefix); + + virtual void Output(CYOutput &out) const; }; -struct CYExpress : - CYStatement +struct CYLambda : + CYExpression { - CYExpression *expression_; + CYTypedIdentifier *typed_; + CYTypedParameter *parameters_; + CYStatement *statements_; - CYExpress(CYExpression *expression) : - expression_(expression) + CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) : + typed_(typed), + parameters_(parameters), + statements_(statements) { } - virtual void Output(std::ostream &out) const; + CYPrecedence(1) + + virtual CYExpression *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 void Output(std::ostream &out) const; + 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(std::ostream &out) 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(std::ostream &out) const; + CYPrecedence(1) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; }; -struct CYEmpty : - CYStatement +namespace cy { +namespace Syntax { + +struct Catch : + CYThing { - virtual void Output(std::ostream &out) const; - virtual void Output(std::ostream &out, bool block) const; + CYIdentifier *name_; + CYBlock 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 *try_; - CYCatch *catch_; - CYStatement *finally_; + CYBlock code_; + Catch *catch_; + CYFinally *finally_; - CYTry(CYStatement *_try, CYCatch *_catch, CYStatement *finally) : - try_(_try), + Try(CYStatement *statements, Catch *_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 : +struct Throw : CYStatement { CYExpression *value_; - CYThrow(CYExpression *value) : + Throw(CYExpression *value = NULL) : value_(value) { } - virtual void Output(std::ostream &out) const; + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; }; +} } + struct CYWith : CYStatement { @@ -747,7 +1964,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 : @@ -762,7 +1980,19 @@ struct CYSwitch : { } - virtual void Output(std::ostream &out) const; + 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; }; struct CYCondition : @@ -773,12 +2003,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 : @@ -793,7 +2027,9 @@ struct CYAddressOf : return "&"; } - virtual void Output(std::ostream &out) const; + CYAlphabetic(false) + + virtual CYExpression *Replace(CYContext &context); }; struct CYIndirect : @@ -808,13 +2044,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) \ { \ @@ -825,38 +2066,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) \ { \ @@ -870,38 +2116,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, CYReplace) +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) @@ -916,4 +2163,4 @@ CYAssignment_("&=", BitwiseAnd) CYAssignment_("^=", BitwiseXOr) CYAssignment_("|=", BitwiseOr) -#endif/*CYPARSER_HPP*/ +#endif/*CYCRIPT_PARSER_HPP*/