X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/c239b9f8664af054c40d00c68ba4054a23b97735..197e361cb64ce8262bbc917fd93a22a0f65db27b:/Output.cpp diff --git a/Output.cpp b/Output.cpp index 3d11cc1..c436b3c 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,643 +1,1123 @@ -#include "Parser.hpp" - -#include <iostream> +/* 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 <cmath> #include <iomanip> - -#include <objc/runtime.h> #include <sstream> -_finline CYFlags operator ~(CYFlags rhs) { - return static_cast<CYFlags>(~static_cast<unsigned>(rhs)); -} +#include "Syntax.hpp" -_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { - return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); -} +void CYStringify(std::ostringstream &str, const char *data, size_t size, bool c) { + bool single; + if (c) + single = false; + else { + unsigned quot(0), apos(0); + for (const char *value(data), *end(data + size); value != end; ++value) + if (*value == '"') + ++quot; + else if (*value == '\'') + ++apos; + + single = quot > apos; + } -_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { - return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); -} + str << (single ? '\'' : '"'); -_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { - return lhs = lhs | rhs; -} + for (const char *value(data), *end(data + size); value != end; ++value) + switch (uint8_t next = *value) { + case '\\': str << "\\\\"; break; + case '\b': str << "\\b"; break; + case '\f': str << "\\f"; break; + case '\n': str << "\\n"; break; + case '\r': str << "\\r"; break; + case '\t': str << "\\t"; break; + case '\v': str << "\\v"; break; -_finline CYFlags CYLeft(CYFlags flags) { - return flags & ~CYNoTrailer; -} + case '"': + if (!single) + str << "\\\""; + else goto simple; + break; -_finline CYFlags CYCenter(CYFlags flags) { - return flags & CYNoIn; -} + case '\'': + if (single) + str << "\\'"; + else goto simple; + break; -_finline CYFlags CYRight(CYFlags flags) { - return flags & (CYNoIn | CYNoTrailer); -} + case '\0': + if (value[1] >= '0' && value[1] <= '9') + str << "\\x00"; + else + str << "\\0"; + break; -bool CYFalse::Value() const { - return false; -} + default: + if (next >= 0x20 && next < 0x7f) simple: + str << *value; + else { + unsigned levels(1); + if ((next & 0x80) != 0) + while ((next & 0x80 >> ++levels) != 0); + + unsigned point(next & 0xff >> levels); + while (--levels != 0) + point = point << 6 | uint8_t(*++value) & 0x3f; + + if (point < 0x100) + str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << point; + else if (point < 0x10000) + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << point; + else { + point -= 0x10000; + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xd800 | point >> 0x0a); + str << "\\u" << std::setbase(16) << std::setw(4) << std::setfill('0') << (0xdc00 | point & 0x3ff); + } + } + } -bool CYTrue::Value() const { - return true; + str << (single ? '\'' : '"'); } -#define CYPA 16 +void CYNumerify(std::ostringstream &str, double value) { + if (std::isinf(value)) { + if (value < 0) + str << '-'; + str << "Infinity"; + return; + } + + char string[32]; + // XXX: I want this to print 1e3 rather than 1000 + sprintf(string, "%.17g", value); + str << string; +} + +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 ()(';'); + } + + 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; -void CYAddressOf::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".addressOf()"; + right_ = true; + operator ()(rhs, size); + 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 << ','; + 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 CYBoolean::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << (Value() ? "true" : "false"); - if ((flags & CYNoTrailer) != 0) - out << ' '; +void CYBlock::Output(CYOutput &out, CYFlags flags) const { + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } -void CYBreak::Output(std::ostream &out) const { +void CYBoolean::Output(CYOutput &out, CYFlags flags) const { + out << '!' << (Value() ? "0" : "1"); + if ((flags & CYNoInteger) != 0) + out << '.'; +} + +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); -} - -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); - out << ");"; -} - -void CYClass::Output(std::ostream &out) const { - out << "(function($cys,$cyp,$cyc,$cyn,$cyt,$cym){"; - out << "$cyp=object_getClass($cys);"; - out << "$cyc=objc_allocateClassPair($cys,\"" << *name_ << "\",0);"; - out << "$cym=object_getClass($cyc);"; - if (fields_ != NULL) - fields_->Output(out); - if (messages_ != NULL) - messages_->Output(out, false); - out << "objc_registerClassPair($cyc);"; - out << "})("; - if (super_ != NULL) - super_->Output(out, CYPA, CYNoFlags); - else - out << "null"; - out << ");"; -} - -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 CYCondition::Output(std::ostream &out, CYFlags flags) const { +namespace cy { +namespace Syntax { + +void Catch::Output(CYOutput &out) const { + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; +} + +} } + +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 CYClassStatement::Output(CYOutput &out, CYFlags flags) const { + out << "class" << ' ' << *name_ << *tail_; +} + +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_; + } + + out << '{' << '\n'; + ++out.indent_; + + --out.indent_; + out << '}'; +} + +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 CYComputed::PropertyName(CYOutput &out) const { + out << '['; + expression_->Output(out, CYAssign::Precedence_, CYNoFlags); + out << ']'; +} + +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_, CYNoColon); + 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 (value_ == NULL) out << "default"; - out << ':'; - if (code_ != NULL) - code_->Output(out, false); - out << *next_; + else { + out << "case" << ' '; + value_->Output(out, CYNoColon); + } + 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 CYBinding::Output(CYOutput &out, CYFlags flags) const { out << *identifier_; - if (initialiser_ != NULL) { - out << '='; - initialiser_->Output(out, CYPA, CYNoFlags); + //out.out_ << ':' << identifier_->usage_ << '#' << identifier_->offset_; + if (initializer_ != NULL) { + out << ' ' << '=' << ' '; + initializer_->Output(out, CYAssign::Precedence_, CYRight(flags)); } } -// XXX: deal with NoIn -void CYDeclarations::Part(std::ostream &out) const { - out << "var "; +void CYBindings::Output(CYOutput &out) const { + Output(out, CYNoFlags); +} + +void CYBindings::Output(CYOutput &out, CYFlags flags) const { + const CYBindings *binding(this); + bool first(true); - const CYDeclarations *declaration(this); - output: - out << *declaration->declaration_; - declaration = declaration->next_; + for (;;) { + CYBindings *next(binding->next_); - if (declaration != NULL) { - out << ','; - goto output; + CYFlags jacks(first ? CYLeft(flags) : next == NULL ? CYRight(flags) : CYCenter(flags)); + first = false; + binding->binding_->Output(out, jacks); + + if (next == NULL) + break; + + out << ',' << ' '; + binding = 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 CYElementSpread::Output(CYOutput &out) const { + out << "..." << value_; } -void CYElement::Output(std::ostream &out) const { +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 { - 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 CYEval::Output(CYOutput &out, CYFlags flags) const { + _assert(false); } -void CYExpress::Output(std::ostream &out) const { - expression_->Output(out, CYNoFunction | CYNoBrace); +void CYExpress::Output(CYOutput &out, CYFlags flags) const { + expression_->Output(out, flags | CYNoBFC); out << ';'; } -void CYExpression::ClassName(std::ostream &out) const { - Output(out, CYPA, CYNoFlags); +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 CYExpression::Output(std::ostream &out, unsigned precedence, CYFlags flags) const { - if (precedence < Precedence()) { - out << '('; - Output(out, CYNoFlags); - out << ')'; - } else - Output(out, flags); +void CYExternal::Output(CYOutput &out, CYFlags flags) const { + out << "extern" << abi_ << typed_; + out.Terminate(); } -void CYField::Output(std::ostream &out) const { - // XXX: implement! +void CYFatArrow::Output(CYOutput &out, CYFlags flags) const { + out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << '{' << code_ << '}'; } -void CYFor::Output(std::ostream &out) const { - out << "for("; - if (initialiser_ != NULL) - initialiser_->Part(out); - out << ';'; +void CYFinally::Output(CYOutput &out) const { + out << ' ' << "finally" << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; +} + +void CYFor::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '('; + if (initializer_ != NULL) + initializer_->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 CYForLexical::Output(CYOutput &out, CYFlags flags) const { + out << (constant_ ? "const" : "let") << ' '; + binding_->Output(out, CYRight(flags)); } -void CYFunction::Output(std::ostream &out) const { - CYLambda::Output(out, CYNoFlags); +void CYForIn::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '('; + initializer_->Output(out, CYNoIn | CYNoRightHand); + out << ' ' << "in" << ' ' << *iterable_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYFunctionParameter::Output(std::ostream &out) const { - out << *name_; - if (next_ != NULL) { - out << ','; - out << *next_; - } +void CYForInitialized::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '(' << "var" << ' '; + binding_->Output(out, CYNoIn | CYNoRightHand); + out << ' ' << "in" << ' ' << *iterable_ << ')'; + 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" << ' ' << '('; + binding_->Output(out, CYNoIn | CYNoRightHand); + out << ' ' << "in" << ' ' << *iterable_ << ')'; +} + +void CYForOf::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << '('; + initializer_->Output(out, CYNoRightHand); + out << ' ' << "of" << ' ' << *iterable_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); +} + +void CYForOfComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << '('; + binding_->Output(out, CYNoRightHand); + out << ' ' << "of" << ' ' << *iterable_ << ')' << next_; +} + +void CYForVariable::Output(CYOutput &out, CYFlags flags) const { + out << "var" << ' '; + binding_->Output(out, CYRight(flags)); +} + +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 { + binding_->Output(out, CYNoFlags); + if (next_ != NULL) + out << ',' << ' ' << *next_; +} + +const char *CYIdentifier::Word() const { + return next_ == NULL || next_ == this ? CYWord::Word() : next_->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 CYImport::Output(CYOutput &out, CYFlags flags) const { + out << "@import"; +} + +void CYImportDeclaration::Output(CYOutput &out, CYFlags flags) const { + _assert(false); } -void CYIndirect::Output(std::ostream &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << "[0]"; +void CYIndirect::Output(CYOutput &out, CYFlags flags) const { + out << "*"; + rhs_->Output(out, Precedence(), CYRight(flags)); +} + +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(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; 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_; + if (variadic_) { + if (parameters_ != NULL) + out << ',' << ' '; + out << "..."; + } + out << ')'; +} + +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 CYEncodedType::Output(CYOutput &out, CYFlags flags) const { + out << "@encode(" << typed_ << ")"; } -void CYMessage::Output(std::ostream &out, bool replace) const { +void CYTypedParameter::Output(CYOutput &out) const { + out << typed_; 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 << '('; + 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_; + out.Terminate(); +} + +void CYTypeExpression::Output(CYOutput &out, CYFlags flags) const { + out << '(' << "typedef" << ' ' << *typed_ << ')'; +} + +void CYLexical::Output(CYOutput &out, CYFlags flags) const { + out << "let" << ' '; + bindings_->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: 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 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 { - name_->PropertyName(out); - out << ':'; - 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 { - out << "return"; - if (value_ != NULL) - value_->Output(out, CYNoLeader); - out << ';'; +void CYPropertyGetter::Output(CYOutput &out) const { + out << "get" << ' '; + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(out); } -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 CYPropertyMethod::Output(CYOutput &out) const { + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(out); } -void CYSelectorPart::Output(std::ostream &out) const { - if (name_ != NULL) - out << *name_; - if (value_) - out << ':'; - if (next_ != NULL) - next_->Output(out); +void CYPropertySetter::Output(CYOutput &out) const { + out << "set" << ' '; + name_->PropertyName(out); + CYFunction::Output(out); + CYProperty::Output(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<void *>(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 CYPropertyValue::Output(CYOutput &out) const { + out << '\t'; + name_->PropertyName(out); + out << ':' << ' '; + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + CYProperty::Output(out); } -void CYSource::Show(std::ostream &out) const { - for (const CYSource *next(this); next != NULL; next = next->next_) - next->Output(out); +void CYRegEx::Output(CYOutput &out, CYFlags flags) const { + out << Value(); } -void CYSource::Output(std::ostream &out, bool block) const { - if (!block && next_ == NULL) - Output(out); - else { - out << '{'; - Show(out); - out << '}'; +void CYResolveMember::Output(CYOutput &out, CYFlags flags) const { + object_->Output(out, Precedence(), CYLeft(flags)); + if (const char *word = property_->Word()) + out << "::" << word; + else + out << "::" << '[' << *property_ << ']'; +} + +void CYReturn::Output(CYOutput &out, CYFlags flags) const { + out << "return"; + if (value_ != NULL) + out << ' ' << *value_; + 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 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; +void CYStatement::Single(CYOutput &out, CYFlags flags, CYCompactType request) const { + if (this == NULL) + return out.Terminate(); - bool single(quot > apos); + _assert(next_ == NULL); - 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; + CYCompactType compact(Compact()); - case '"': - if (!single) - out << "\\\""; - else goto simple; - break; + if (compact >= request) + out << ' '; + else { + out << '\n'; + ++out.indent_; + out << '\t'; + } - case '\'': - if (single) - out << "\\'"; - else goto simple; - break; + Output(out, flags); - 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 ? '\'' : '"'); + if (compact < request) + --out.indent_; } -void CYString::PropertyName(std::ostream &out) const { +void CYString::Output(CYOutput &out, CYFlags flags) const { + std::ostringstream str; + CYStringify(str, value_, size_); + out << str.str().c_str(); +} + +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 CYStructDefinition::Output(CYOutput &out, CYFlags flags) const { + out << "struct" << ' ' << *name_ << *tail_; +} + +void CYStructTail::Output(CYOutput &out) const { + out << ' ' << '{' << '\n'; + ++out.indent_; + CYForEach (field, fields_) { + out << '\t' << *field->typed_; + out.Terminate(); + out << '\n'; + } + --out.indent_; out << '}'; } -void CYThis::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; +void CYSuperAccess::Output(CYOutput &out, CYFlags flags) const { + out << "super"; + if (const char *word = property_->Word()) + out << '.' << word; + else + out << '[' << *property_ << ']'; +} + +void CYSuperCall::Output(CYOutput &out, CYFlags flags) const { + out << "super" << '(' << arguments_ << ')'; +} + +void CYSwitch::Output(CYOutput &out, CYFlags flags) const { + out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{' << '\n'; + ++out.indent_; + out << clauses_; + --out.indent_; + out << '\t' << '}'; +} + +void CYSymbol::Output(CYOutput &out, CYFlags flags) const { + bool protect((flags & CYNoColon) != 0); + if (protect) + out << '('; + out << ':' << name_; + if (protect) + out << ')'; } -void CYThrow::Output(std::ostream &out) const { +void CYThis::Output(CYOutput &out, CYFlags flags) const { + out << "this"; +} + +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 CYTypeCharacter::Output(CYOutput &out) const { + switch (signing_) { + case CYTypeNeutral: break; + case CYTypeSigned: out << "signed" << ' '; break; + case CYTypeUnsigned: out << "unsigned" << ' '; break; } + + out << "char"; } -void CYVariable::Output(std::ostream &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; +void CYTypeError::Output(CYOutput &out) const { + out << "@error"; +} + +void CYTypeIntegral::Output(CYOutput &out) const { + if (signing_ == CYTypeUnsigned) + out << "unsigned" << ' '; + switch (length_) { + case 0: out << "short"; break; + case 1: out << "int"; break; + case 2: out << "long"; break; + case 3: out << "long" << ' ' << "long"; break; + default: _assert(false); + } +} + +void CYTypeStruct::Output(CYOutput &out) const { + out << "struct"; + if (name_ != NULL) + out << ' ' << *name_; + else + out << *tail_; +} + +void CYTypeReference::Output(CYOutput &out) const { + out << "struct" << ' ' << *name_; +} + +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" << ' '; + bindings_->Output(out, flags); // XXX: flags + out << ';'; +} + +void CYVariable::Output(CYOutput &out, CYFlags flags) const { + out << *name_; } -void CYWord::ClassName(std::ostream &out) const { - out << "objc_getClass(\"" << Value() << "\")"; +void CYWhile::Output(CYOutput &out, CYFlags flags) const { + out << "while" << ' ' << '(' << *test_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYWord::Output(std::ostream &out) const { - out << Value(); +void CYWith::Output(CYOutput &out, CYFlags flags) const { + out << "with" << ' ' << '(' << *scope_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYWord::PropertyName(std::ostream &out) const { +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_; +}