X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/478d4ed0925f2e61fbcdc4672104620342c52c4c..51b2dc6b0c969f9297c8464cb91e93d65819e0ae:/Output.cpp diff --git a/Output.cpp b/Output.cpp index 5e0d6ef..e43d038 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,575 +1,956 @@ -#include "Parser.hpp" +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) +*/ + +/* GNU Affero General Public License, Version 3 {{{ */ +/* + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. +**/ +/* }}} */ + +#include "cycript.hpp" + +#include <sstream> + +#include "Syntax.hpp" + +void CYOutput::Terminate() { + operator ()(';'); + mode_ = NoMode; +} + +CYOutput &CYOutput::operator <<(char rhs) { + if (rhs == ' ' || rhs == '\n') + if (pretty_) + operator ()(rhs); + else goto done; + else if (rhs == '\t') + if (pretty_) + for (unsigned i(0); i != indent_; ++i) + operator ()(" ", 4); + else goto done; + else if (rhs == '\r') { + if (right_) { + operator ()('\n'); + right_ = false; + } goto done; + } else goto work; + + right_ = true; + mode_ = NoMode; + goto done; + + work: + if (mode_ == Terminated && rhs != '}') { + right_ = true; + operator ()(';'); + } -#include <iostream> -#include <iomanip> + if (rhs == ';') { + if (pretty_) + goto none; + else { + mode_ = Terminated; + goto done; + } + } else if (rhs == '+') { + if (mode_ == NoPlus) + operator ()(' '); + mode_ = NoPlus; + } else if (rhs == '-') { + if (mode_ == NoHyphen) + operator ()(' '); + mode_ = NoHyphen; + } else if (WordEndRange_[rhs]) { + if (mode_ == NoLetter) + operator ()(' '); + mode_ = NoLetter; + } else none: + mode_ = NoMode; + + right_ = true; + operator ()(rhs); + done: + return *this; +} + +CYOutput &CYOutput::operator <<(const char *rhs) { + size_t size(strlen(rhs)); + + if (size == 1) + return *this << *rhs; + + if (mode_ == Terminated) + operator ()(';'); + else if ( + mode_ == NoPlus && *rhs == '+' || + mode_ == NoHyphen && *rhs == '-' || + mode_ == NoLetter && WordEndRange_[*rhs] + ) + operator ()(' '); + + char last(rhs[size - 1]); + if (WordEndRange_[last] || last == '/') + mode_ = NoLetter; + else + mode_ = NoMode; -_finline CYFlags operator ~(CYFlags rhs) { - return static_cast<CYFlags>(~static_cast<unsigned>(rhs)); + right_ = true; + operator ()(rhs, size); + return *this; } -_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { - return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); +void CYArgument::Output(CYOutput &out) const { + if (name_ != NULL) { + out << *name_; + if (value_ != NULL) + out << ':' << ' '; + } + if (value_ != NULL) + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + if (next_ != NULL) { + out << ','; + out << ' ' << *next_; + } } -_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { - return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); +void CYArray::Output(CYOutput &out, CYFlags flags) const { + out << '[' << elements_ << ']'; } -_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { - return lhs = lhs | rhs; +void CYArrayComprehension::Output(CYOutput &out, CYFlags flags) const { + out << '[' << *expression_ << ' ' << *comprehensions_ << ']'; } -_finline CYFlags CYLeft(CYFlags flags) { - return flags & ~CYNoTrailer; +void CYAssignment::Output(CYOutput &out, CYFlags flags) const { + lhs_->Output(out, Precedence() - 1, CYLeft(flags) | CYNoRightHand); + out << ' ' << Operator() << ' '; + rhs_->Output(out, Precedence(), CYRight(flags)); } -_finline CYFlags CYCenter(CYFlags flags) { - return flags & CYNoIn; +void CYBlock::Output(CYOutput &out, CYFlags flags) const { + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } -_finline CYFlags CYRight(CYFlags flags) { - return flags & (CYNoIn | CYNoTrailer); +void CYBoolean::Output(CYOutput &out, CYFlags flags) const { + out << '!' << (Value() ? "0" : "1"); + if ((flags & CYNoInteger) != 0) + out << '.'; } -bool CYFalse::Value() const { - return false; +void CYBreak::Output(CYOutput &out, CYFlags flags) const { + out << "break"; + if (label_ != NULL) + out << ' ' << *label_; + out << ';'; } -bool CYTrue::Value() const { - return true; +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 << ')'; } -#define CYPA 16 +namespace cy { +namespace Syntax { -void CYAddressOf::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$()"; +void Catch::Output(CYOutput &out) const { + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } -void CYArgument::Output(std::ostream &out) const { - if (name_ != NULL) { - out << *name_; - if (value_ != NULL) - out << ":"; - } - if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); - if (next_ != NULL) { - if (next_->name_ == NULL) - out << ','; - else - out << ' '; - next_->Output(out); - } -} +} } -void CYArray::Output(std::ostream &out, CYFlags flags) const { - out << '['; - if (elements_ != NULL) - elements_->Output(out); - out << ']'; +void CYClassExpression::Output(CYOutput &out, CYFlags flags) const { + bool protect((flags & CYNoClass) != 0); + if (protect) + out << '('; + out << "class"; + if (name_ != NULL) + out << ' ' << *name_; + out << *tail_;; + if (protect) + out << ')'; } -void CYAssignment::Output(std::ostream &out, CYFlags flags) const { - lhs_->Output(out, Precedence() - 1, CYLeft(flags)); - out << Operator(); - rhs_->Output(out, Precedence(), CYRight(flags)); +void CYClassStatement::Output(CYOutput &out, CYFlags flags) const { + out << "class" << ' ' << *name_ << *tail_; } -void CYBoolean::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << (Value() ? "true" : "false"); - if ((flags & CYNoTrailer) != 0) +void CYClassTail::Output(CYOutput &out) const { + if (extends_ == NULL) out << ' '; -} + else { + out << '\n'; + ++out.indent_; + out << "extends" << ' '; + extends_->Output(out, CYAssign::Precedence_ - 1, CYNoFlags); + out << '\n'; + --out.indent_; + } -void CYBreak::Output(std::ostream &out) const { - out << "break"; - if (label_ != NULL) - out << ' ' << *label_; - out << ';'; -} + out << '{' << '\n'; + ++out.indent_; -void CYCall::Output(std::ostream &out, CYFlags flags) const { - function_->Output(out, Precedence(), CYLeft(flags)); - out << '('; - if (arguments_ != NULL) - arguments_->Output(out); - out << ')'; + --out.indent_; + out << '}'; } -void CYCatch::Output(std::ostream &out) const { - out << "catch(" << *name_ << ')'; - code_->Output(out, true); +void CYCompound::Output(CYOutput &out, CYFlags flags) const { + if (next_ == NULL) + expression_->Output(out, flags); + else { + expression_->Output(out, CYLeft(flags)); + out << ',' << ' '; + next_->Output(out, CYRight(flags)); + } } -void CYClass::Output(std::ostream &out) const { - out << "(function($cys,$cyc,$cym,$cyn,$cyt){"; - out << "$cyc=objc_allocateClassPair($cys,\"" << *name_ << "\",0);"; - out << "$cym=object_getClass($cyc);"; - if (fields_ != NULL) - fields_->Output(out); - if (messages_ != NULL) - messages_->Output(out); - out << "objc_registerClassPair($cyc);"; - out << "})("; - if (super_ != NULL) - super_->Output(out, CYPA, CYNoFlags); - else - out << "null"; - out << ");"; +void CYComputed::PropertyName(CYOutput &out) const { + out << '['; + expression_->Output(out, CYAssign::Precedence_, CYNoFlags); + out << ']'; } -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 { + out << '\t'; + if (case_ != NULL) + out << "case" << ' ' << *case_; + else out << "default"; - out << ':'; - if (code_ != NULL) - code_->Output(out, false); - out << *next_; + out << ':' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << next_; } -// XXX: deal with NoIn -void CYDeclaration::Part(std::ostream &out) const { - out << "var "; - Output(out); +void CYDebugger::Output(CYOutput &out, CYFlags flags) const { + out << "debugger" << ';'; } -void CYDeclaration::Output(std::ostream &out) const { +void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { + out << "var" << ' '; + Output(out, CYRight(flags)); +} + +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 CYForDeclarations::Output(CYOutput &out, CYFlags flags) const { + out << "var" << ' '; + declarations_->Output(out, CYRight(flags)); +} + +void CYDeclarations::Output(CYOutput &out) const { + Output(out, CYNoFlags); +} +void CYDeclarations::Output(CYOutput &out, CYFlags flags) const { const CYDeclarations *declaration(this); - output: - out << *declaration->declaration_; - declaration = declaration->next_; + bool first(true); - if (declaration != NULL) { - out << ','; - goto output; + for (;;) { + 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) + break; + + out << ',' << ' '; + declaration = next; } } -void CYDeclarations::Output(std::ostream &out) const { - Part(out); - out << ';'; +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_ << ']'; } -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"; + + unsigned line(out.position_.line); + unsigned indent(out.indent_); + code_->Single(out, CYCenter(flags), CYCompactLong); + + if (out.position_.line != line && out.recent_ == indent) + out << ' '; + else + out << '\n' << '\t'; + + out << "while" << ' ' << '(' << *test_ << ')'; } -void CYElement::Output(std::ostream &out) const { +void CYElementSpread::Output(CYOutput &out) const { + out << "..." << value_; +} + +void CYElementValue::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_->Elision()) + out << ' '; + } if (next_ != NULL) next_->Output(out); } -void CYEmpty::Output(std::ostream &out) const { +void CYEmpty::Output(CYOutput &out, CYFlags flags) const { + out.Terminate(); +} + +void CYExpress::Output(CYOutput &out, CYFlags flags) const { + expression_->Output(out, flags | CYNoBFC); out << ';'; } -void CYEmpty::Output(std::ostream &out, bool block) const { - if (next_ != NULL) - CYSource::Output(out, block); - else - out << "{}"; +void CYExpression::ForIn(CYOutput &out, CYFlags flags) const { + Output(out, flags | CYNoRightHand); } -void CYExpress::Output(std::ostream &out) const { - expression_->Output(out, CYNoFunction | CYNoBrace); - out << ';'; +void CYExpression::Output(CYOutput &out) const { + Output(out, CYNoFlags); } -void CYExpression::Part(std::ostream &out) const { - // XXX: this should handle LeftHandSideExpression - Output(out, CYNoIn); +void CYExpression::Output(CYOutput &out, int precedence, CYFlags flags) const { + if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand()) + out << '(' << *this << ')'; + else + Output(out, flags); } -void CYCompound::Output(std::ostream &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 << ','; - next = expression->next_; - CYFlags right(next != NULL ? center : CYRight(flags)); - expression->Output(out, right); - } - } else - expression->Output(out, flags); +void CYExternal::Output(CYOutput &out, CYFlags flags) const { + out << "extern" << abi_ << typed_ << ';'; } -void CYExpression::Output(std::ostream &out, unsigned precedence, CYFlags flags) const { - if (precedence < Precedence()) { - out << '('; - Output(out, CYNoFlags); - out << ')'; - } else - Output(out, flags); +void CYFatArrow::Output(CYOutput &out, CYFlags flags) const { + out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << '{' << code_ << '}'; } -void CYField::Output(std::ostream &out) const { - // XXX: implement! +void CYFinally::Output(CYOutput &out) const { + out << ' ' << "finally" << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } -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_->Output(out, CYNoIn); + 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), CYCompactShort); } -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 CYForOf::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << "each" << ' ' << '('; + initialiser_->ForIn(out, CYNoIn); + out << ' ' << "in" << ' ' << *set_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYFunction::Output(std::ostream &out) const { - CYLambda::Output(out, CYNoFlags); +void CYForOfComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << "each" << ' ' << '('; + declaration_->Output(out, CYNoIn); + out << ' ' << "in" << ' ' << *set_ << ')' << next_; } -void CYFunctionParameter::Output(std::ostream &out) const { - out << *name_; - if (next_ != NULL) { - out << ','; - out << *next_; - } +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), CYCompactShort); } -void CYIf::Output(std::ostream &out) const { - out << "if("; - test_->Output(out, CYNoFlags); - out << ')'; - true_->Output(out, true); +void CYForInComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << '('; + declaration_->Output(out, CYNoIn); + out << ' ' << "in" << ' ' << *set_ << ')'; +} + +void CYFunction::Output(CYOutput &out) const { + out << '(' << parameters_ << ')' << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; +} + +void CYFunctionExpression::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_; + CYFunction::Output(out); + if (protect) + out << ')'; +} + +void CYFunctionStatement::Output(CYOutput &out, CYFlags flags) const { + out << "function" << ' ' << *name_; + CYFunction::Output(out); +} + +void CYFunctionParameter::Output(CYOutput &out) const { + initialiser_->Output(out, CYNoFlags); + if (next_ != NULL) + out << ',' << ' ' << *next_; +} + +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); + + unsigned line(out.position_.line); + unsigned indent(out.indent_); + true_->Single(out, jacks, CYCompactShort); + if (false_ != NULL) { - out << "else "; - false_->Output(out, false); + if (out.position_.line != line && out.recent_ == indent) + out << ' '; + else + out << '\n' << '\t'; + + out << "else"; + false_->Single(out, right, CYCompactLong); } + + if (protect) + out << '}'; +} + +void CYIfComprehension::Output(CYOutput &out) const { + out << "if" << ' ' << '(' << *test_ << ')' << next_; } -void CYIndirect::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << "[0]"; +void CYImport::Output(CYOutput &out, CYFlags flags) const { + out << "@import"; } -void CYInfix::Output(std::ostream &out, CYFlags flags) const { +void CYIndirectMember::Output(CYOutput &out, CYFlags flags) const { + object_->Output(out, Precedence(), CYLeft(flags)); + if (const char *word = property_->Word()) + out << "->" << word; + else + out << "->" << '[' << *property_ << ']'; +} + +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; rhs_->Output(out, Precedence() - 1, right); if (protect) out << ')'; } -void CYLambda::Output(std::ostream &out, CYFlags flags) const { - bool protect((flags & CYNoFunction) != 0); +void CYLabel::Output(CYOutput &out, CYFlags flags) const { + out << *name_ << ':'; + statement_->Single(out, CYRight(flags), CYCompactShort); +} + +void CYParenthetical::Output(CYOutput &out, CYFlags flags) const { + out << '('; + expression_->Output(out, CYCompound::Precedence_, CYNoFlags); + out << ')'; +} + +void CYStatement::Output(CYOutput &out) const { + Multiple(out); +} + +void CYTemplate::Output(CYOutput &out, CYFlags flags) const { + _assert(false); +} + +void CYTypeArrayOf::Output(CYOutput &out, CYIdentifier *identifier) const { + next_->Output(out, Precedence(), identifier); + out << '['; + out << size_; + out << ']'; +} + +void CYTypeBlockWith::Output(CYOutput &out, CYIdentifier *identifier) const { + out << '(' << '^'; + next_->Output(out, Precedence(), identifier); + out << ')' << '(' << parameters_ << ')'; +} + +void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const { + out << "const" << ' '; + next_->Output(out, Precedence(), identifier); +} + +void CYTypeFunctionWith::Output(CYOutput &out, CYIdentifier *identifier) const { + next_->Output(out, Precedence(), identifier); + out << '(' << parameters_ << ')'; +} + +void CYTypePointerTo::Output(CYOutput &out, CYIdentifier *identifier) const { + out << '*'; + next_->Output(out, Precedence(), identifier); +} + +void CYTypeVolatile::Output(CYOutput &out, CYIdentifier *identifier) const { + out << "volatile"; + next_->Output(out, Precedence(), identifier); +} + +void CYTypeModifier::Output(CYOutput &out, int precedence, CYIdentifier *identifier) const { + if (this == NULL) { + out << identifier; + return; + } + + bool protect(precedence > Precedence()); + if (protect) out << '('; - out << "function"; - if (name_ != NULL) - out << ' ' << *name_; - out << '('; - if (parameters_ != NULL) - out << *parameters_; - out << "){"; - if (body_ != NULL) - body_->Show(out); - out << '}'; + Output(out, identifier); if (protect) out << ')'; } -void CYMember::Output(std::ostream &out, CYFlags flags) const { - object_->Output(out, Precedence(), CYLeft(flags)); - if (const char *word = property_->Word()) - out << '.' << word; - else { - out << '['; - property_->Output(out, CYNoFlags); - out << ']'; - } +void CYTypedIdentifier::Output(CYOutput &out) const { + specifier_->Output(out); + modifier_->Output(out, 0, identifier_); } -void CYMessage::Output(std::ostream &out) const { - 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($cys," << (instance_ ? "true" : "false") << ");"; - out << "class_addMethod($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 { - out << "new"; - constructor_->Output(out, Precedence(), CYCenter(flags) | CYNoLeader); - out << '('; +void CYEncodedType::Output(CYOutput &out, CYFlags flags) const { + out << "@encode(" << typed_ << ")"; +} + +void CYTypedParameter::Output(CYOutput &out) const { + out << typed_; + if (next_ != NULL) + out << ',' << ' ' << next_; +} + +void CYLambda::Output(CYOutput &out, CYFlags flags) const { + // XXX: this is seriously wrong + out << "[]("; + out << ")->"; + out << "{"; + out << "}"; +} + +void CYTypeDefinition::Output(CYOutput &out, CYFlags flags) const { + out << "typedef" << ' ' << *typed_; +} + +void CYLet::Output(CYOutput &out, CYFlags flags) const { + out << "let" << ' '; + declarations_->Output(out, flags); // XXX: flags + out << ';'; +} + +void CYModule::Output(CYOutput &out) const { + out << part_; + if (next_ != NULL) + out << '.' << next_; +} + +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 << ' '; - CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; +} } + +void CYNull::Output(CYOutput &out, CYFlags flags) const { + out << "null"; } -void CYNumber::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - // XXX: this is not a useful formatting - out << 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 CYObject::Output(std::ostream &out, CYFlags flags) const { +void CYNumber::PropertyName(CYOutput &out) const { + Output(out, CYNoFlags); +} + +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 CYPostfix::Output(CYOutput &out, CYFlags flags) const { lhs_->Output(out, Precedence(), CYLeft(flags)); out << Operator(); } -void CYPrefix::Output(std::ostream &out, CYFlags flags) const { - bool alphabetic(Alphabetic()); - out << Operator(); - CYFlags right(CYRight(flags)); - if (alphabetic) - right |= CYNoLeader; - rhs_->Output(out, Precedence(), right); +void CYPrefix::Output(CYOutput &out, CYFlags flags) const { + const char *name(Operator()); + out << name; + if (Alphabetic()) + out << ' '; + rhs_->Output(out, Precedence(), CYRight(flags)); } -void CYProperty::Output(std::ostream &out) const { - out << *name_ << ':'; - value_->Output(out, CYPA, CYNoFlags); - if (next_ != NULL) { +void CYScript::Output(CYOutput &out) const { + out << code_; +} + +void CYProperty::Output(CYOutput &out) const { + if (next_ != NULL || out.pretty_) out << ','; - next_->Output(out); - } + out << '\n' << next_; } -void CYReturn::Output(std::ostream &out) const { +void CYPropertyGetter::Output(CYOutput &out) const { + out << "get" << ' '; + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(out); +} + +void CYPropertyMethod::Output(CYOutput &out) const { + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(out); +} + +void CYPropertySetter::Output(CYOutput &out) const { + out << "set" << ' '; + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(out); +} + +void CYPropertyValue::Output(CYOutput &out) const { + out << '\t'; + name_->PropertyName(out); + out << ':' << ' '; + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + CYProperty::Output(out); +} + +void CYRegEx::Output(CYOutput &out, CYFlags flags) const { + out << Value(); +} + +void CYReturn::Output(CYOutput &out, CYFlags flags) const { out << "return"; if (value_ != NULL) - value_->Output(out, CYNoLeader); + out << ' ' << *value_; out << ';'; } -void CYSelector::Output(std::ostream &out, CYFlags flags) const { - out << "new Selector(\""; - if (name_ != NULL) - name_->Output(out); - out << "\")"; +void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const { + call_->Output(out, CYLeft(flags)); + out << ' '; + proc_->Output(out, CYRight(flags)); +} + +void CYRubyProc::Output(CYOutput &out, CYFlags flags) const { + out << '{' << ' ' << '|' << parameters_ << '|' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; +} + +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 CYSelectorPart::Output(std::ostream &out) const { - if (name_ != NULL) - out << *name_; - if (value_) - out << ':'; - if (next_ != NULL) - next_->Output(out); +void CYStatement::Single(CYOutput &out, CYFlags flags, CYCompactType request) const { + if (this == NULL) + return out.Terminate(); + + _assert(next_ == NULL); + + CYCompactType compact(Compact()); + + if (compact >= request) + out << ' '; + else { + out << '\n'; + ++out.indent_; + out << '\t'; + } + + Output(out, flags); + + if (compact < request) + --out.indent_; } -void CYSend::Output(std::ostream &out, CYFlags flags) const { - out << "objc_msgSend("; - self_->Output(out, CYPA, CYNoFlags); - out << ",\""; - for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_) - if (argument->name_ != NULL) { - out << *argument->name_; - if (argument->value_ != NULL) - out << ':'; - } - out << "\""; - for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_) - if (argument->value_ != NULL) { - out << ","; - argument->value_->Output(out, CYPA, CYNoFlags); - } - out << ')'; +void CYString::Output(CYOutput &out, CYFlags flags) const { + std::ostringstream str; + CYStringify(str, value_, size_); + out << str.str().c_str(); } -void CYSource::Show(std::ostream &out) const { - for (const CYSource *next(this); next != NULL; next = next->next_) - next->Output(out); +void CYString::PropertyName(CYOutput &out) const { + if (const char *word = Word()) + out << word; + else + out << *this; } -void CYSource::Output(std::ostream &out, bool block) const { - if (!block && next_ == NULL) - Output(out); - else { - out << '{'; - Show(out); - out << '}'; - } +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 CYString::Output(std::ostream &out, CYFlags flags) const { - out << '\"'; - for (const char *value(value_), *end(value_ + size_); value != end; ++value) - switch (*value) { - case '"': out << "\\\""; break; - 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; - - default: - if (*value < 0x20 || *value >= 0x7f) - out << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value); - else - out << *value; - } - out << '\"'; +void CYSuperAccess::Output(CYOutput &out, CYFlags flags) const { + out << "super"; + if (const char *word = property_->Word()) + out << '.' << word; + else + out << '[' << *property_ << ']'; } -void CYSwitch::Output(std::ostream &out) const { - out << "switch("; - value_->Output(out, CYNoFlags); - out << "){"; - if (clauses_ != NULL) - out << *clauses_; - out << '}'; +void CYSuperCall::Output(CYOutput &out, CYFlags flags) const { + out << "super" << '(' << arguments_ << ')'; } -void CYThis::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; +void CYSwitch::Output(CYOutput &out, CYFlags flags) const { + out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{' << '\n'; + ++out.indent_; + out << clauses_; + --out.indent_; + out << '\t' << '}'; +} + +void CYThis::Output(CYOutput &out, CYFlags flags) const { + out << "this"; } -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) - out << catch_; - if (finally_ != NULL) { - out << "finally"; - finally_->Output(out, true); - } +void Try::Output(CYOutput &out, CYFlags flags) const { + out << "try" << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; + out << catch_ << finally_; } -void CYVariable::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +} } + +void CYTypeError::Output(CYOutput &out) const { + out << "@error"; +} + +void CYTypeLong::Output(CYOutput &out) const { + out << "long" << specifier_; +} + +void CYTypeShort::Output(CYOutput &out) const { + out << "short" << specifier_; +} + +void CYTypeSigned::Output(CYOutput &out) const { + out << "signed" << specifier_; +} + +void CYTypeUnsigned::Output(CYOutput &out) const { + out << "unsigned" << specifier_; +} + +void CYTypeVariable::Output(CYOutput &out) 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 CYTypeVoid::Output(CYOutput &out) const { + out << "void"; } -void CYWith::Output(std::ostream &out) const { - out << "with("; - scope_->Output(out, CYNoFlags); - out << ')'; - code_->Output(out, false); +void CYVar::Output(CYOutput &out, CYFlags flags) const { + out << "var" << ' '; + declarations_->Output(out, flags); // XXX: flags + out << ';'; } -void CYWord::Output(std::ostream &out) const { - out << Value(); +void CYVariable::Output(CYOutput &out, CYFlags flags) const { + out << *name_; +} + +void CYWhile::Output(CYOutput &out, CYFlags flags) const { + out << "while" << ' ' << '(' << *test_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); +} + +void CYWith::Output(CYOutput &out, CYFlags flags) const { + out << "with" << ' ' << '(' << *scope_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); +} + +void CYWord::Output(CYOutput &out) const { + out << Word(); + if (out.options_.verbose_) { + out('@'); + char number[32]; + sprintf(number, "%p", this); + out(number); + } +} + +void CYWord::PropertyName(CYOutput &out) const { + Output(out); +} + +const char *CYWord::Word() const { + return word_; }