X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/83b5afe296f2ce1b9e6482144668d72f88db1185..fb726fc55e2a79b03564be97d5057e28805d84f0:/Output.cpp diff --git a/Output.cpp b/Output.cpp index a73b9c9..c974744 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,166 +1,206 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2010 Jay Freeman (saurik) +*/ + +/* GNU Lesser General Public License, Version 3 {{{ */ +/* + * Cycript is free software: you can redistribute it and/or modify it under + * the terms of the GNU Lesser 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 Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Cycript. If not, see . +**/ +/* }}} */ + +#include "cycript.hpp" #include "Parser.hpp" -#include -#include - -#include #include -_finline CYFlags operator ~(CYFlags rhs) { - return static_cast(~static_cast(rhs)); -} - -_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { - return static_cast(static_cast(lhs) & static_cast(rhs)); -} - -_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { - return static_cast(static_cast(lhs) | static_cast(rhs)); -} - -_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { - return lhs = lhs | rhs; -} - -_finline CYFlags CYLeft(CYFlags flags) { - return flags & ~CYNoTrailer; -} - -_finline CYFlags CYCenter(CYFlags flags) { - return flags & CYNoIn; -} - -_finline CYFlags CYRight(CYFlags flags) { - return flags & (CYNoIn | CYNoTrailer); -} - -bool CYFalse::Value() const { - return false; -} - -bool CYTrue::Value() const { - return true; -} +void CYOutput::Terminate() { + out_ << ';'; + mode_ = NoMode; +} + +CYOutput &CYOutput::operator <<(char rhs) { + if (rhs == ' ' || rhs == '\n') + if (pretty_) + out_ << rhs; + else goto done; + else if (rhs == '\t') + if (pretty_) + for (unsigned i(0); i != indent_; ++i) + out_ << " "; + else goto done; + else if (rhs == '\r') { + if (right_) { + out_ << '\n'; + right_ = false; + } goto done; + } else goto work; + + right_ = true; + mode_ = NoMode; + goto done; + + work: + if (mode_ == Terminated && rhs != '}') { + right_ = true; + out_ << ';'; + } -#define CYPA 16 + if (rhs == ';') { + if (pretty_) + goto none; + else { + mode_ = Terminated; + goto done; + } + } else if (rhs == '+') { + if (mode_ == NoPlus) + out_ << ' '; + mode_ = NoPlus; + } else if (rhs == '-') { + if (mode_ == NoHyphen) + out_ << ' '; + mode_ = NoHyphen; + } else if (WordEndRange_[rhs]) { + if (mode_ == NoLetter) + out_ << ' '; + mode_ = NoLetter; + } else none: + mode_ = NoMode; + + right_ = true; + out_ << rhs; + done: + return *this; +} + +CYOutput &CYOutput::operator <<(const char *rhs) { + size_t size(strlen(rhs)); + + if (size == 1) + return *this << *rhs; + + if (mode_ == Terminated) + out_ << ';'; + else if ( + mode_ == NoPlus && *rhs == '+' || + mode_ == NoHyphen && *rhs == '-' || + mode_ == NoLetter && WordEndRange_[*rhs] + ) + out_ << ' '; + + if (WordEndRange_[rhs[size - 1]]) + mode_ = NoLetter; + else + mode_ = NoMode; -void CYAddressOf::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cya()"; + right_ = true; + out_ << rhs; + return *this; } -void CYArgument::Output(std::ostream &out) const { +void CYArgument::Output(CYOutput &out) const { if (name_ != NULL) { out << *name_; if (value_ != NULL) - out << ":"; + out << ':' << ' '; } if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); + value_->Output(out, CYAssign::Precedence_, CYNoFlags); if (next_ != NULL) { if (next_->name_ == NULL) out << ','; - else - out << ' '; - next_->Output(out); + out << ' ' << *next_; } } -void CYArray::Output(std::ostream &out, CYFlags flags) const { - out << '['; - if (elements_ != NULL) - elements_->Output(out); - out << ']'; +void CYArray::Output(CYOutput &out, CYFlags flags) const { + out << '[' << elements_ << ']'; } -void CYAssignment::Output(std::ostream &out, CYFlags flags) const { - lhs_->Output(out, Precedence() - 1, CYLeft(flags)); - out << Operator(); +void CYArrayComprehension::Output(CYOutput &out, CYFlags flags) const { + out << '[' << *expression_ << ' ' << *comprehensions_ << ']'; +} + +void CYAssignment::Output(CYOutput &out, CYFlags flags) const { + lhs_->Output(out, Precedence() - 1, CYLeft(flags) | CYNoRightHand); + out << ' ' << Operator() << ' '; rhs_->Output(out, Precedence(), CYRight(flags)); } -void CYBlock::Output(std::ostream &out) const { - for (CYSource *statement(statements_); statement != NULL; statement = statement->next_) - statement->Output(out); +void CYBlock::Output(CYOutput &out) const { + out << '{' << '\n'; + ++out.indent_; + if (statements_ != NULL) + statements_->Multiple(out); + --out.indent_; + out << '\t' << '}'; } -void CYBoolean::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +void CYBlock::Output(CYOutput &out, CYFlags flags) const { + if (statements_ == NULL) + out.Terminate(); + else if (statements_->next_ == NULL) + statements_->Single(out, flags); + else + Output(out); +} + +void CYBoolean::Output(CYOutput &out, CYFlags flags) const { out << (Value() ? "true" : "false"); - if ((flags & CYNoTrailer) != 0) - out << ' '; } -void CYBreak::Output(std::ostream &out) const { +void CYBreak::Output(CYOutput &out, CYFlags flags) const { out << "break"; if (label_ != NULL) out << ' ' << *label_; out << ';'; } -void CYCall::Output(std::ostream &out, CYFlags flags) const { - function_->Output(out, Precedence(), CYLeft(flags)); - out << '('; - if (arguments_ != NULL) - arguments_->Output(out); - out << ')'; +void CYCall::Output(CYOutput &out, CYFlags flags) const { + bool protect((flags & CYNoCall) != 0); + if (protect) + out << '('; + function_->Output(out, Precedence(), protect ? CYNoFlags : flags); + out << '(' << arguments_ << ')'; + if (protect) + out << ')'; } -void CYCatch::Output(std::ostream &out) const { - out << "catch(" << *name_ << ')'; - code_->Output(out, true); -} +namespace cy { +namespace Syntax { -void CYCategory::Output(std::ostream &out) const { - out << "(function($cys,$cyp,$cyc,$cyn,$cyt){"; - out << "$cyp=object_getClass($cys);"; - out << "$cyc=$cys;"; - if (messages_ != NULL) - messages_->Output(out, true); - out << "})("; - name_->ClassName(out, true); - out << ");"; +void Catch::Output(CYOutput &out) const { + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_; } -void CYClass::Output(std::ostream &out) const { - Output(out, CYNoBF); - out << ";"; -} +} } -void CYClass::Output(std::ostream &out, CYFlags flags) const { - // XXX: I don't necc. need the ()s - out << "(function($cys,$cyp,$cyc,$cyn,$cyt,$cym){"; - out << "$cyp=object_getClass($cys);"; - out << "$cyc=objc_allocateClassPair($cys,"; - if (name_ != NULL) - name_->ClassName(out, false); - else - out << "$cyq(\"CY$\")"; - out << ",0);"; - out << "$cym=object_getClass($cyc);"; - if (fields_ != NULL) - fields_->Output(out); - if (messages_ != NULL) - messages_->Output(out, false); - out << "objc_registerClassPair($cyc);"; - out << "return $cyc;"; - out << "}("; - if (super_ != NULL) - super_->Output(out, CYPA, CYNoFlags); - else - out << "null"; - out << "))"; +void CYComment::Output(CYOutput &out, CYFlags flags) const { + out << '\r'; + out.out_ << value_; + out.right_ = true; + out << '\r'; } -void CYCompound::Output(std::ostream &out, CYFlags flags) const { +void CYCompound::Output(CYOutput &out, CYFlags flags) const { if (CYExpression *expression = expressions_) if (CYExpression *next = expression->next_) { expression->Output(out, CYLeft(flags)); CYFlags center(CYCenter(flags)); while (next != NULL) { expression = next; - out << ','; + out << ',' << ' '; next = expression->next_; CYFlags right(next != NULL ? center : CYRight(flags)); expression->Output(out, right); @@ -169,526 +209,512 @@ void CYCompound::Output(std::ostream &out, CYFlags flags) const { expression->Output(out, flags); } -void CYCondition::Output(std::ostream &out, CYFlags flags) const { +void CYCondition::Output(CYOutput &out, CYFlags flags) const { test_->Output(out, Precedence() - 1, CYLeft(flags)); - out << '?'; + out << ' ' << '?' << ' '; if (true_ != NULL) - true_->Output(out, CYPA, CYNoFlags); - out << ':'; - false_->Output(out, CYPA, CYRight(flags)); + true_->Output(out, CYAssign::Precedence_, CYNoFlags); + out << ' ' << ':' << ' '; + false_->Output(out, CYAssign::Precedence_, CYRight(flags)); } -void CYContinue::Output(std::ostream &out) const { +void CYContinue::Output(CYOutput &out, CYFlags flags) const { out << "continue"; if (label_ != NULL) out << ' ' << *label_; out << ';'; } -void CYClause::Output(std::ostream &out) const { - if (case_ != NULL) { - out << "case"; - case_->Output(out, CYNoFlags); - } else +void CYClause::Output(CYOutput &out) const { + if (case_ != NULL) + out << "case" << ' ' << *case_; + else out << "default"; - out << ':'; - if (code_ != NULL) - code_->Output(out, false); - out << *next_; + out << ':' << '\n'; + if (statements_ != NULL) + statements_->Multiple(out); + out << next_; } -// XXX: deal with NoIn -void CYDeclaration::Part(std::ostream &out) const { - out << "var "; - Output(out); +const char *CYDeclaration::ForEachIn() const { + return identifier_->Word(); +} + +void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { + out << "var"; + Output(out, CYRight(flags)); } -void CYDeclaration::Output(std::ostream &out) const { +void CYDeclaration::Output(CYOutput &out, CYFlags flags) const { out << *identifier_; + //out.out_ << ':' << identifier_->usage_ << '#' << identifier_->offset_; if (initialiser_ != NULL) { - out << '='; - initialiser_->Output(out, CYPA, CYNoFlags); + out << ' ' << '=' << ' '; + initialiser_->Output(out, CYAssign::Precedence_, CYRight(flags)); } } -// XXX: deal with NoIn -void CYDeclarations::Part(std::ostream &out) const { - out << "var "; +void CYDeclarations::For(CYOutput &out) const { + out << "var"; + Output(out, CYNoIn); +} + +void CYDeclarations::Output(CYOutput &out) const { + Output(out, CYNoFlags); +} +void CYDeclarations::Output(CYOutput &out, CYFlags flags) const { const CYDeclarations *declaration(this); + bool first(true); output: - out << *declaration->declaration_; - declaration = declaration->next_; - - if (declaration != NULL) { - out << ','; + CYDeclarations *next(declaration->next_); + CYFlags jacks(first ? CYLeft(flags) : next == NULL ? CYRight(flags) : CYCenter(flags)); + first = false; + declaration->declaration_->Output(out, jacks); + + if (next != NULL) { + out << ',' << ' '; + declaration = next; goto output; } } -void CYDeclarations::Output(std::ostream &out) const { - Part(out); - out << ';'; -} - -void CYDirectMember::Output(std::ostream &out, CYFlags flags) const { - object_->Output(out, Precedence(), CYLeft(flags)); +void CYDirectMember::Output(CYOutput &out, CYFlags flags) const { + object_->Output(out, Precedence(), CYLeft(flags) | CYNoInteger); if (const char *word = property_->Word()) out << '.' << word; - else { - out << '['; - property_->Output(out, CYNoFlags); - out << ']'; - } + else + out << '[' << *property_ << ']'; } -void CYDoWhile::Output(std::ostream &out) const { - // XXX: extra space character! - out << "do "; - code_->Output(out, false); - out << "while("; - test_->Output(out, CYNoFlags); - out << ')'; +void CYDoWhile::Output(CYOutput &out, CYFlags flags) const { + out << "do"; + code_->Single(out, CYCenter(flags)); + out << "while" << ' ' << '(' << *test_ << ')'; } -void CYElement::Output(std::ostream &out) const { +void CYElement::Output(CYOutput &out) const { if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); - if (next_ != NULL || value_ == NULL) + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + if (next_ != NULL || value_ == NULL) { out << ','; + if (next_ != NULL && next_->value_ != NULL) + out << ' '; + } if (next_ != NULL) next_->Output(out); } -void CYEmpty::Output(std::ostream &out) const { - out << ';'; +void CYEmpty::Output(CYOutput &out, CYFlags flags) const { + out.Terminate(); } -void CYEmpty::Output(std::ostream &out, bool block) const { - if (next_ != NULL) - CYSource::Output(out, block); - else - out << "{}"; +void CYExpress::Output(CYOutput &out, CYFlags flags) const { + expression_->Output(out, flags | CYNoBF); + out << ';'; } -void CYExpress::Output(std::ostream &out) const { - expression_->Output(out, CYNoBF); - out << ';'; +void CYExpression::ClassName(CYOutput &out, bool object) const { + Output(out, CYAssign::Precedence_, CYNoFlags); } -void CYExpression::ClassName(std::ostream &out, bool object) const { - Output(out, CYPA, CYNoFlags); +const char *CYExpression::ForEachIn() const { + return NULL; } -void CYExpression::Part(std::ostream &out) const { - // XXX: this should handle LeftHandSideExpression +void CYExpression::For(CYOutput &out) const { Output(out, CYNoIn); } -void CYExpression::Output(std::ostream &out, unsigned precedence, CYFlags flags) const { - if (precedence < Precedence()) { - out << '('; - Output(out, CYNoFlags); - out << ')'; - } else +void CYExpression::ForIn(CYOutput &out, CYFlags flags) const { + Output(out, flags | CYNoRightHand); +} + +void CYExpression::Output(CYOutput &out) const { + Output(out, CYNoFlags); +} + +void CYExpression::Output(CYOutput &out, unsigned precedence, CYFlags flags) const { + if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand()) + out << '(' << *this << ')'; + else Output(out, flags); } -void CYField::Output(std::ostream &out) const { - // XXX: implement! +void CYFinally::Output(CYOutput &out) const { + out << ' ' << "finally" << ' ' << code_; } -void CYFor::Output(std::ostream &out) const { - out << "for("; +void CYFor::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '('; if (initialiser_ != NULL) - initialiser_->Part(out); - out << ';'; + initialiser_->For(out); + out.Terminate(); if (test_ != NULL) - test_->Output(out, CYNoFlags); - out << ';'; + out << ' '; + out << test_; + out.Terminate(); if (increment_ != NULL) - increment_->Output(out, CYNoFlags); + out << ' '; + out << increment_; out << ')'; - code_->Output(out, false); + code_->Single(out, CYRight(flags)); } -void CYForIn::Output(std::ostream &out) const { - out << "for("; - initialiser_->Part(out); - // XXX: deal with this space character! - out << ' '; - out << "in"; - set_->Output(out, CYNoLeader); - out << ')'; - code_->Output(out, false); +void CYForEachIn::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << "each" << ' ' << '('; + initialiser_->ForIn(out, CYNoIn); + out << "in" << *set_ << ')'; + code_->Single(out, CYRight(flags)); } -void CYFunction::Output(std::ostream &out) const { - CYLambda::Output(out, CYNoFlags); +void CYForEachInComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << "each" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')' << next_; } -void CYFunctionParameter::Output(std::ostream &out) const { +void CYForIn::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '('; + if (initialiser_ != NULL) + initialiser_->ForIn(out, CYNoIn); + out << "in" << *set_ << ')'; + code_->Single(out, CYRight(flags)); +} + +void CYForInComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')'; +} + +void CYFunction::Output(CYOutput &out, CYFlags flags) const { + // XXX: one could imagine using + here to save a byte + bool protect((flags & CYNoFunction) != 0); + if (protect) + out << '('; + out << "function"; + if (name_ != NULL) + out << ' ' << *name_; + out << '(' << parameters_ << ')'; + out << ' ' << code_; + if (protect) + out << ')'; +} + +void CYFunctionExpression::Output(CYOutput &out, CYFlags flags) const { + CYFunction::Output(out, flags); +} + +void CYFunctionStatement::Output(CYOutput &out, CYFlags flags) const { + CYFunction::Output(out, flags); +} + +void CYFunctionParameter::Output(CYOutput &out) const { out << *name_; - if (next_ != NULL) { - out << ','; - out << *next_; - } + if (next_ != NULL) + out << ',' << ' ' << *next_; } -void CYIf::Output(std::ostream &out) const { - out << "if("; - test_->Output(out, CYNoFlags); - out << ')'; - true_->Output(out, true); +const char *CYIdentifier::Word() const { + return replace_ == NULL || replace_ == this ? CYWord::Word() : replace_->Word(); +} + +void CYIf::Output(CYOutput &out, CYFlags flags) const { + bool protect(false); + if (false_ == NULL && (flags & CYNoDangle) != 0) { + protect = true; + out << '{'; + } + + out << "if" << ' ' << '(' << *test_ << ')'; + + CYFlags right(protect ? CYNoFlags : CYRight(flags)); + + CYFlags jacks(CYNoDangle); + if (false_ == NULL) + jacks |= right; + else + jacks |= protect ? CYNoFlags : CYCenter(flags); + + true_->Single(out, jacks); + if (false_ != NULL) { - out << "else "; - false_->Output(out, false); + out << '\t' << "else"; + false_->Single(out, right); } + + if (protect) + out << '}'; } -void CYIndirect::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cyi"; +void CYIfComprehension::Output(CYOutput &out) const { + out << "if" << ' ' << '(' << *test_ << ')' << next_; } -void CYIndirectMember::Output(std::ostream &out, CYFlags flags) const { +void CYIndirectMember::Output(CYOutput &out, CYFlags flags) const { object_->Output(out, Precedence(), CYLeft(flags)); - out << ".$cyi"; if (const char *word = property_->Word()) - out << '.' << word; - else { - out << '['; - property_->Output(out, CYNoFlags); - out << ']'; - } + out << "->" << word; + else + out << "->" << '[' << *property_ << ']'; } -void CYInfix::Output(std::ostream &out, CYFlags flags) const { +void CYInfix::Output(CYOutput &out, CYFlags flags) const { const char *name(Operator()); - bool protect((flags & CYNoIn) != 0 && strcmp(name, "in")); + bool protect((flags & CYNoIn) != 0 && strcmp(name, "in") == 0); if (protect) out << '('; - bool alphabetic(Alphabetic()); CYFlags left(protect ? CYNoFlags : CYLeft(flags)); - if (alphabetic) - left |= CYNoTrailer; lhs_->Output(out, Precedence(), left); - out << name; + out << ' ' << name << ' '; CYFlags right(protect ? CYNoFlags : CYRight(flags)); - if (alphabetic) - right |= CYNoLeader; - if (strcmp(name, "-") == 0) - right |= CYNoHyphen; rhs_->Output(out, Precedence() - 1, right); if (protect) out << ')'; } -void CYLambda::Output(std::ostream &out, CYFlags flags) const { - bool protect((flags & CYNoFunction) != 0); - if (protect) - out << '('; - else if ((flags & CYNoLeader) != 0) - out << ' '; - out << "function"; - if (name_ != NULL) - out << ' ' << *name_; - out << '('; - if (parameters_ != NULL) - out << *parameters_; - out << "){"; - if (body_ != NULL) - body_->Show(out); - out << '}'; - if (protect) - out << ')'; +void CYLabel::Output(CYOutput &out, CYFlags flags) const { + out << *name_ << ':' << ' '; + statement_->Single(out, CYRight(flags)); } -void CYMessage::Output(std::ostream &out, bool replace) const { - if (next_ != NULL) - next_->Output(out, replace); - out << "$cyn=new Selector(\""; - for (CYMessageParameter *parameter(parameter_); parameter != NULL; parameter = parameter->next_) - if (parameter->tag_ != NULL) { - out << *parameter->tag_; - if (parameter->name_ != NULL) - out << ':'; - } - out << "\");"; - out << "$cyt=$cyn.type($cy" << (instance_ ? 's' : 'p') << ");"; - out << "class_" << (replace ? "replace" : "add") << "Method($cy" << (instance_ ? 'c' : 'm') << ",$cyn,"; - out << "new Functor(function(self,_cmd"; - for (CYMessageParameter *parameter(parameter_); parameter != NULL; parameter = parameter->next_) - if (parameter->name_ != NULL) - out << ',' << *parameter->name_; - out << "){return function(){"; - if (body_ != NULL) - body_->Show(out); - out << "}.call(self);},$cyt),$cyt);"; -} - -void CYNew::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "new"; - constructor_->Output(out, Precedence(), CYCenter(flags) | CYNoLeader); - out << '('; +void CYLet::Output(CYOutput &out, CYFlags flags) const { + out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << code_; +} + +namespace cy { +namespace Syntax { + +void New::Output(CYOutput &out, CYFlags flags) const { + out << "new" << ' '; + CYFlags jacks(CYNoCall | CYCenter(flags)); + constructor_->Output(out, Precedence(), jacks); if (arguments_ != NULL) - arguments_->Output(out); - out << ')'; + out << '(' << *arguments_ << ')'; } -void CYNull::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +} } + +void CYNull::Output(CYOutput &out, CYFlags flags) const { CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; } -void CYNumber::Output(std::ostream &out, CYFlags flags) const { - double value(Value()); - if ((flags & CYNoLeader) != 0 || value < 0 && (flags & CYNoHyphen) != 0) - out << ' '; - // XXX: decide on correct precision - out << std::setprecision(9) << value; - if ((flags & CYNoTrailer) != 0) - out << ' '; +void CYNumber::Output(CYOutput &out, CYFlags flags) const { + std::ostringstream str; + CYNumerify(str, Value()); + std::string value(str.str()); + out << value.c_str(); + // XXX: this should probably also handle hex conversions and exponents + if ((flags & CYNoInteger) != 0 && value.find('.') == std::string::npos) + out << '.'; } -void CYNumber::PropertyName(std::ostream &out) const { - Output(out); +void CYNumber::PropertyName(CYOutput &out) const { + Output(out, CYNoFlags); } -void CYObject::Output(std::ostream &out, CYFlags flags) const { +void CYObject::Output(CYOutput &out, CYFlags flags) const { bool protect((flags & CYNoBrace) != 0); if (protect) out << '('; - out << '{'; - if (property_ != NULL) - property_->Output(out); - out << '}'; + out << '{' << '\n'; + ++out.indent_; + out << properties_; + --out.indent_; + out << '\t' << '}'; if (protect) out << ')'; } -void CYPostfix::Output(std::ostream &out, CYFlags flags) const { +void CYOptionalFunctionParameter::Output(CYOutput &out) const { + out << *name_ << '='; + initializer_->Output(out, CYAssign::Precedence_, CYNoFlags); + if (next_ != NULL) + out << ',' << ' ' << *next_; +} + +void CYPostfix::Output(CYOutput &out, CYFlags flags) const { lhs_->Output(out, Precedence(), CYLeft(flags)); out << Operator(); } -void CYPrefix::Output(std::ostream &out, CYFlags flags) const { +void CYPrefix::Output(CYOutput &out, CYFlags flags) const { const char *name(Operator()); - bool alphabetic(Alphabetic()); - if (alphabetic && (flags & CYNoLeader) != 0 || name[0] == '-' && (flags & CYNoHyphen) != 0) - out << ' '; out << name; - CYFlags right(CYRight(flags)); - if (alphabetic) - right |= CYNoLeader; - rhs_->Output(out, Precedence(), right); + if (Alphabetic()) + out << ' '; + rhs_->Output(out, Precedence(), CYRight(flags)); } -void CYProperty::Output(std::ostream &out) const { - name_->PropertyName(out); - out << ':'; - value_->Output(out, CYPA, CYNoFlags); - if (next_ != NULL) { - out << ','; - next_->Output(out); - } +void CYProgram::Output(CYOutput &out) const { + if (statements_ != NULL) + statements_->Multiple(out); } -void CYReturn::Output(std::ostream &out) const { - out << "return"; - if (value_ != NULL) - value_->Output(out, CYNoLeader); - out << ';'; +void CYProperty::Output(CYOutput &out) const { + out << '\t'; + name_->PropertyName(out); + out << ':' << ' '; + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + if (next_ != NULL) + out << ',' << '\n' << *next_; + else + out << '\n'; } -void CYSelector::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "new Selector(\""; - if (name_ != NULL) - name_->Output(out); - out << "\")"; +void CYRegEx::Output(CYOutput &out, CYFlags flags) const { + out << Value(); } -void CYSelectorPart::Output(std::ostream &out) const { - if (name_ != NULL) - out << *name_; - if (value_) - out << ':'; - if (next_ != NULL) - next_->Output(out); +void CYReturn::Output(CYOutput &out, CYFlags flags) const { + out << "return"; + if (value_ != NULL) + out << ' ' << *value_; + out << ';'; } -void CYSend::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "objc_msgSend("; - self_->Output(out, CYPA, CYNoFlags); - out << ","; - std::ostringstream name; - for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_) - if (argument->name_ != NULL) { - name << *argument->name_; - if (argument->value_ != NULL) - name << ':'; - } - out << reinterpret_cast(sel_registerName(name.str().c_str())); - for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_) - if (argument->value_ != NULL) { - out << ","; - argument->value_->Output(out, CYPA, CYNoFlags); - } - out << ')'; +void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const { + call_->Output(out, CYLeft(flags)); + out << ' '; + proc_->Output(out, CYRight(flags)); } -void CYSource::Show(std::ostream &out) const { - for (const CYSource *next(this); next != NULL; next = next->next_) - next->Output_(out); +void CYRubyProc::Output(CYOutput &out, CYFlags flags) const { + // XXX: this is not outputting the parameters + out << code_; } -void CYSource::Output(std::ostream &out, bool block) const { - if (!block && !IsBlock()) - Output(out); - else { - out << '{'; - Show(out); - out << '}'; +void CYStatement::Multiple(CYOutput &out, CYFlags flags) const { + bool first(true); + CYForEach (next, this) { + bool last(next->next_ == NULL); + CYFlags jacks(first ? last ? flags : CYLeft(flags) : last ? CYRight(flags) : CYCenter(flags)); + first = false; + out << '\t'; + next->Output(out, jacks); + out << '\n'; } } -void CYSource::Output_(std::ostream &out) const { - Output(out); -} - -void CYStatement::Output_(std::ostream &out) const { - for (CYLabel *label(labels_); label != NULL; label = label->next_) - out << *label->name_ << ':'; - Output(out); +void CYStatement::Single(CYOutput &out, CYFlags flags) const { + _assert(next_ == NULL); + out << '\n'; + ++out.indent_; + out << '\t'; + Output(out, flags); + out << '\n'; + --out.indent_; } -void CYString::Output(std::ostream &out, CYFlags flags) const { - unsigned quot(0), apos(0); - for (const char *value(value_), *end(value_ + size_); value != end; ++value) - if (*value == '"') - ++quot; - else if (*value == '\'') - ++apos; - - bool single(quot > apos); - - out << (single ? '\'' : '"'); - for (const char *value(value_), *end(value_ + size_); value != end; ++value) - switch (*value) { - case '\\': out << "\\\\"; break; - case '\b': out << "\\b"; break; - case '\f': out << "\\f"; break; - case '\n': out << "\\n"; break; - case '\r': out << "\\r"; break; - case '\t': out << "\\t"; break; - case '\v': out << "\\v"; break; - - case '"': - if (!single) - out << "\\\""; - else goto simple; - break; - - case '\'': - if (single) - out << "\\'"; - else goto simple; - break; - - default: - if (*value < 0x20 || *value >= 0x7f) - out << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value); - else simple: - out << *value; - } - out << (single ? '\'' : '"'); +void CYString::Output(CYOutput &out, CYFlags flags) const { + std::ostringstream str; + CYStringify(str, value_, size_); + out << str.str().c_str(); } -void CYString::PropertyName(std::ostream &out) const { +void CYString::PropertyName(CYOutput &out) const { if (const char *word = Word()) out << word; else - Output(out); + out << *this; } -void CYSwitch::Output(std::ostream &out) const { - out << "switch("; - value_->Output(out, CYNoFlags); - out << "){"; - if (clauses_ != NULL) - out << *clauses_; +static const char *Reserved_[] = { + "false", "null", "true", + + "break", "case", "catch", "continue", "default", + "delete", "do", "else", "finally", "for", "function", + "if", "in", "instanceof", "new", "return", "switch", + "this", "throw", "try", "typeof", "var", "void", + "while", "with", + + "debugger", "const", + + "class", "enum", "export", "extends", "import", "super", + + "abstract", "boolean", "byte", "char", "double", "final", + "float", "goto", "int", "long", "native", "short", + "synchronized", "throws", "transient", "volatile", + + "let", "yield", + + NULL +}; + +const char *CYString::Word() const { + if (size_ == 0 || !WordStartRange_[value_[0]]) + return NULL; + for (size_t i(1); i != size_; ++i) + if (!WordEndRange_[value_[i]]) + return NULL; + const char *value(Value()); + for (const char **reserved(Reserved_); *reserved != NULL; ++reserved) + if (strcmp(*reserved, value) == 0) + return NULL; + return value; +} + +void CYSwitch::Output(CYOutput &out, CYFlags flags) const { + out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{'; + out << clauses_; out << '}'; } -void CYThis::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +void CYThis::Output(CYOutput &out, CYFlags flags) const { CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; } -void CYThrow::Output(std::ostream &out) const { +namespace cy { +namespace Syntax { + +void Throw::Output(CYOutput &out, CYFlags flags) const { out << "throw"; if (value_ != NULL) - value_->Output(out, CYNoLeader); + out << ' ' << *value_; out << ';'; } -void CYTry::Output(std::ostream &out) const { - out << "try"; - try_->Output(out, true); - if (catch_ != NULL) - catch_->Output(out); - if (finally_ != NULL) { - out << "finally"; - finally_->Output(out, true); - } +void Try::Output(CYOutput &out, CYFlags flags) const { + out << "try" << ' ' << code_ << catch_ << finally_; } -void CYVariable::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +} } + +void CYVar::Output(CYOutput &out, CYFlags flags) const { + out << "var"; + declarations_->Output(out, flags); + out << ';'; +} + +void CYVariable::Output(CYOutput &out, CYFlags flags) const { out << *name_; - if ((flags & CYNoTrailer) != 0) - out << ' '; } -void CYWhile::Output(std::ostream &out) const { - out << "while("; - test_->Output(out, CYNoFlags); - out << ')'; - code_->Output(out, false); +void CYWhile::Output(CYOutput &out, CYFlags flags) const { + out << "while" << '(' << *test_ << ')'; + code_->Single(out, CYRight(flags)); } -void CYWith::Output(std::ostream &out) const { - out << "with("; - scope_->Output(out, CYNoFlags); - out << ')'; - code_->Output(out, false); +void CYWith::Output(CYOutput &out, CYFlags flags) const { + out << "with" << '(' << *scope_ << ')'; + code_->Single(out, CYRight(flags)); } -void CYWord::ClassName(std::ostream &out, bool object) const { +void CYWord::ClassName(CYOutput &out, bool object) const { if (object) out << "objc_getClass("; - out << '"' << Value() << '"'; + out << '"' << Word() << '"'; if (object) out << ')'; } -void CYWord::Output(std::ostream &out) const { - out << Value(); +void CYWord::Output(CYOutput &out) const { + out << Word(); + if (out.options_.verbose_) + out.out_ << '@' << this; } -void CYWord::PropertyName(std::ostream &out) const { +void CYWord::PropertyName(CYOutput &out) const { Output(out); } + +const char *CYWord::Word() const { + return word_; +}