X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/11c1cc16b7cda02473081cc398195484a1ab82f2..fb726fc55e2a79b03564be97d5057e28805d84f0:/Output.cpp?ds=sidebyside diff --git a/Output.cpp b/Output.cpp index b878068..c974744 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,146 +1,170 @@ +/* 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 | CYNoTerminator); -} - -#define CYPA 16 - -void OutputBody(CYOutput &out, CYStatement *body) { - if (out.pretty_) - out << ' '; - out << '{'; - if (out.pretty_) - out << '\n'; - ++out.indent_; - if (body != NULL) - body->Multiple(out); - --out.indent_; - out.Indent(); - out << '}'; -} +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_ << ';'; + } -void CYOutput::Indent() { - if (pretty_) - for (unsigned i(0); i != indent_; ++i) - out_ << " "; -} + 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(CYOutput &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cya()"; + right_ = true; + out_ << rhs; + return *this; } void CYArgument::Output(CYOutput &out) const { if (name_ != NULL) { out << *name_; - if (value_ != NULL) { - out << ':'; - if (out.pretty_) - out << ' '; - } + if (value_ != NULL) + out << ':' << ' '; } if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); + value_->Output(out, CYAssign::Precedence_, CYNoFlags); if (next_ != NULL) { - if (next_->name_ != NULL) - out << ' '; - else { + if (next_->name_ == NULL) out << ','; - if (out.pretty_) - out << ' '; - } - next_->Output(out); + out << ' ' << *next_; } } void CYArray::Output(CYOutput &out, CYFlags flags) const { - out << '['; - if (elements_ != NULL) - elements_->Output(out); - out << ']'; + out << '[' << elements_ << ']'; } void CYArrayComprehension::Output(CYOutput &out, CYFlags flags) const { - // XXX: I don't necc. need the ()s - out << "(function($cyv"; - for (CYComprehension *comprehension(comprehensions_); comprehension != NULL; comprehension = comprehension->next_) - if (const char *name = comprehension->Name()) - out << ',' << name; - out << "){"; - out << "$cyv=[];"; - comprehensions_->Output(out); - out << "$cyv.push("; - expression_->Output(out, CYPA, CYNoFlags); - out << ");"; - for (CYComprehension *comprehension(comprehensions_); comprehension != NULL; comprehension = comprehension->next_) - comprehension->End_(out); - out << "return $cyv;"; - out << "}())"; + out << '[' << *expression_ << ' ' << *comprehensions_ << ']'; } void CYAssignment::Output(CYOutput &out, CYFlags flags) const { lhs_->Output(out, Precedence() - 1, CYLeft(flags) | CYNoRightHand); - if (out.pretty_) - out << ' '; - out << Operator(); - if (out.pretty_) - out << ' '; + out << ' ' << Operator() << ' '; rhs_->Output(out, Precedence(), CYRight(flags)); } +void CYBlock::Output(CYOutput &out) const { + out << '{' << '\n'; + ++out.indent_; + if (statements_ != NULL) + statements_->Multiple(out); + --out.indent_; + out << '\t' << '}'; +} + void CYBlock::Output(CYOutput &out, CYFlags flags) const { - statements_->Single(out, flags); + 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 { - if ((flags & CYNoLeader) != 0) - out << ' '; out << (Value() ? "true" : "false"); - if ((flags & CYNoTrailer) != 0) - out << ' '; } void CYBreak::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << "break"; if (label_ != NULL) out << ' ' << *label_; - if ((flags & CYNoTerminator) == 0) - out << ';'; - else if ((flags & CYNoTrailer) != 0) - out << ' '; + out << ';'; } void CYCall::Output(CYOutput &out, CYFlags flags) const { @@ -148,71 +172,25 @@ void CYCall::Output(CYOutput &out, CYFlags flags) const { if (protect) out << '('; function_->Output(out, Precedence(), protect ? CYNoFlags : flags); - out << '('; - if (arguments_ != NULL) - arguments_->Output(out); - out << ')'; + out << '(' << arguments_ << ')'; if (protect) out << ')'; } -void CYCatch::Output(CYOutput &out) const { - out << "catch"; - if (out.pretty_) - out << ' '; - out << '(' << *name_ << ')'; - if (out.pretty_) - out << ' '; - out << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; -} - -void CYCategory::Output(CYOutput &out, CYFlags flags) 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 << ')'; - if ((flags & CYNoTerminator) == 0) - out << ';'; -} +namespace cy { +namespace Syntax { -void CYClass::Output(CYOutput &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 Catch::Output(CYOutput &out) const { + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_; } -void CYClassExpression::Output(CYOutput &out, CYFlags flags) const { - CYClass::Output(out, flags); -} +} } -void CYClassStatement::Output(CYOutput &out, CYFlags flags) const { - CYClass::Output(out, flags); +void CYComment::Output(CYOutput &out, CYFlags flags) const { + out << '\r'; + out.out_ << value_; + out.right_ = true; + out << '\r'; } void CYCompound::Output(CYOutput &out, CYFlags flags) const { @@ -222,9 +200,7 @@ void CYCompound::Output(CYOutput &out, CYFlags flags) const { CYFlags center(CYCenter(flags)); while (next != NULL) { expression = next; - out << ','; - if (out.pretty_) - out << ' '; + out << ',' << ' '; next = expression->next_; CYFlags right(next != NULL ? center : CYRight(flags)); expression->Output(out, right); @@ -233,89 +209,58 @@ void CYCompound::Output(CYOutput &out, CYFlags flags) const { expression->Output(out, flags); } -void CYComprehension::Output(CYOutput &out) const { - Begin_(out); - if (next_ != NULL) - next_->Output(out); -} - void CYCondition::Output(CYOutput &out, CYFlags flags) const { test_->Output(out, Precedence() - 1, CYLeft(flags)); - if (out.pretty_) - out << ' '; - out << '?'; - if (out.pretty_) - out << ' '; + out << ' ' << '?' << ' '; if (true_ != NULL) - true_->Output(out, CYPA, CYNoFlags); - if (out.pretty_) - out << ' '; - out << ':'; - if (out.pretty_) - out << ' '; - false_->Output(out, CYPA, CYRight(flags)); + true_->Output(out, CYAssign::Precedence_, CYNoFlags); + out << ' ' << ':' << ' '; + false_->Output(out, CYAssign::Precedence_, CYRight(flags)); } void CYContinue::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << "continue"; if (label_ != NULL) out << ' ' << *label_; - if ((flags & CYNoTerminator) == 0) - out << ';'; - else if ((flags & CYNoTrailer) != 0) - out << ' '; + out << ';'; } void CYClause::Output(CYOutput &out) const { - if (case_ != NULL) { - out << "case"; - case_->Output(out, CYNoLeader); - } else + if (case_ != NULL) + out << "case" << ' ' << *case_; + else out << "default"; - out << ':'; - if (out.pretty_) - out << '\n'; - if (code_ != NULL) - code_->Multiple(out, next_ == NULL ? CYNoFlags : CYNoTrailer); - if (next_ != NULL) - out << *next_; + out << ':' << '\n'; + if (statements_ != NULL) + statements_->Multiple(out); + out << next_; } const char *CYDeclaration::ForEachIn() const { - return identifier_->Value(); + return identifier_->Word(); } void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << "var"; - Output(out, CYRight(flags) | CYNoLeader); -} - -void CYDeclaration::ForEachIn(CYOutput &out) const { - out << *identifier_; + Output(out, CYRight(flags)); } void CYDeclaration::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << *identifier_; + //out.out_ << ':' << identifier_->usage_ << '#' << identifier_->offset_; if (initialiser_ != NULL) { - if (out.pretty_) - out << ' '; - out << '='; - if (out.pretty_) - out << ' '; - initialiser_->Output(out, CYPA, CYRight(flags)); - } else if ((flags & CYNoTrailer) != 0) - out << ' '; + out << ' ' << '=' << ' '; + initialiser_->Output(out, CYAssign::Precedence_, CYRight(flags)); + } } void CYDeclarations::For(CYOutput &out) const { out << "var"; - Output(out, CYNoIn | CYNoLeader); + Output(out, CYNoIn); +} + +void CYDeclarations::Output(CYOutput &out) const { + Output(out, CYNoFlags); } void CYDeclarations::Output(CYOutput &out, CYFlags flags) const { @@ -328,44 +273,32 @@ void CYDeclarations::Output(CYOutput &out, CYFlags flags) const { declaration->declaration_->Output(out, jacks); if (next != NULL) { - out << ','; - if (out.pretty_) - out << ' '; + out << ',' << ' '; declaration = next; goto output; } } void CYDirectMember::Output(CYOutput &out, CYFlags flags) const { - object_->Output(out, Precedence(), CYLeft(flags)); + 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(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << "do"; - code_->Single(out, CYNoLeader | CYNoTrailer); - out << "while"; - if (out.pretty_) - out << ' '; - out << '('; - test_->Output(out, CYNoFlags); - out << ')'; + code_->Single(out, CYCenter(flags)); + out << "while" << ' ' << '(' << *test_ << ')'; } void CYElement::Output(CYOutput &out) const { if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); + value_->Output(out, CYAssign::Precedence_, CYNoFlags); if (next_ != NULL || value_ == NULL) { out << ','; - if (out.pretty_ && next_ != NULL && next_->value_ != NULL) + if (next_ != NULL && next_->value_ != NULL) out << ' '; } if (next_ != NULL) @@ -373,18 +306,16 @@ void CYElement::Output(CYOutput &out) const { } void CYEmpty::Output(CYOutput &out, CYFlags flags) const { - out << ';'; + out.Terminate(); } void CYExpress::Output(CYOutput &out, CYFlags flags) const { - bool terminator((flags & CYNoTerminator) == 0); - expression_->Output(out, (terminator ? CYLeft(flags) : flags) | CYNoBF); - if (terminator) - out << ';'; + expression_->Output(out, flags | CYNoBF); + out << ';'; } void CYExpression::ClassName(CYOutput &out, bool object) const { - Output(out, CYPA, CYNoFlags); + Output(out, CYAssign::Precedence_, CYNoFlags); } const char *CYExpression::ForEachIn() const { @@ -395,129 +326,74 @@ void CYExpression::For(CYOutput &out) const { Output(out, CYNoIn); } -void CYExpression::ForEachIn(CYOutput &out) const { - Output(out, CYPA, CYNoRightHand); -} - void CYExpression::ForIn(CYOutput &out, CYFlags flags) const { Output(out, flags | CYNoRightHand); } -void CYExpression::Output(CYOutput &out, unsigned precedence, CYFlags flags) const { - if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand()) { - out << '('; - Output(out, CYNoFlags); - out << ')'; - } else - Output(out, flags); +void CYExpression::Output(CYOutput &out) const { + Output(out, CYNoFlags); } -void CYField::Output(CYOutput &out) const { - // XXX: implement! +void CYExpression::Output(CYOutput &out, unsigned precedence, CYFlags flags) const { + if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand()) + out << '(' << *this << ')'; + else + Output(out, flags); } void CYFinally::Output(CYOutput &out) const { - out << "finally"; - if (out.pretty_) - out << ' '; - out << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; + out << ' ' << "finally" << ' ' << code_; } void CYFor::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "for"; - if (out.pretty_) - out << ' '; - out << '('; + out << "for" << ' ' << '('; if (initialiser_ != NULL) initialiser_->For(out); - 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_->Single(out, CYNoFlags); + code_->Single(out, CYRight(flags)); } void CYForEachIn::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - - out << "with({$cys:0,$cyt:0}){"; - - out << "$cys="; - set_->Output(out, CYPA, CYNoFlags); - out << ';'; - - out << "for($cyt in $cys){"; - - initialiser_->ForEachIn(out); - out << "=$cys[$cyt];"; - - code_->Multiple(out); - - out << '}'; - - out << '}'; -} - -void CYForEachInComprehension::Begin_(CYOutput &out) const { - out << "(function($cys){"; - out << "$cys="; - set_->Output(out, CYPA, CYNoFlags); - out << ';'; - - out << "for(" << *name_ << " in $cys){"; - out << *name_ << "=$cys[" << *name_ << "];"; + out << "for" << ' ' << "each" << ' ' << '('; + initialiser_->ForIn(out, CYNoIn); + out << "in" << *set_ << ')'; + code_->Single(out, CYRight(flags)); } -void CYForEachInComprehension::End_(CYOutput &out) const { - out << "}}());"; +void CYForEachInComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << "each" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')' << next_; } void CYForIn::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "for"; - if (out.pretty_) - out << ' '; - out << '('; - initialiser_->ForIn(out, CYNoIn | CYNoTrailer); - out << "in"; - set_->Output(out, CYNoLeader); - out << ')'; + out << "for" << ' ' << '('; + if (initialiser_ != NULL) + initialiser_->ForIn(out, CYNoIn); + out << "in" << *set_ << ')'; code_->Single(out, CYRight(flags)); } -void CYForInComprehension::Begin_(CYOutput &out) const { - out << "for"; - if (out.pretty_) - out << ' '; - out << '(' << *name_ << " in"; - set_->Output(out, CYNoLeader); - out << ')'; +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 << '('; - else if ((flags & CYNoLeader) != 0) - out << ' '; out << "function"; if (name_ != NULL) out << ' ' << *name_; - out << '('; - if (parameters_ != NULL) - out << *parameters_; - out << ')'; - OutputBody(out, body_); + out << '(' << parameters_ << ')'; + out << ' ' << code_; if (protect) out << ')'; } @@ -532,12 +408,12 @@ void CYFunctionStatement::Output(CYOutput &out, CYFlags flags) const { void CYFunctionParameter::Output(CYOutput &out) const { out << *name_; - if (next_ != NULL) { - out << ','; - if (out.pretty_) - out << ' '; - out << *next_; - } + 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 { @@ -545,151 +421,89 @@ void CYIf::Output(CYOutput &out, CYFlags flags) const { if (false_ == NULL && (flags & CYNoDangle) != 0) { protect = true; out << '{'; - } else if ((flags & CYNoLeader) != 0) - out << ' '; - out << "if"; - if (out.pretty_) - out << ' '; - out << '('; - test_->Output(out, CYNoFlags); - out << ')'; + } + + out << "if" << ' ' << '(' << *test_ << ')'; + CYFlags right(protect ? CYNoFlags : CYRight(flags)); + CYFlags jacks(CYNoDangle); - jacks |= false_ == NULL ? right : CYNoTrailer; + if (false_ == NULL) + jacks |= right; + else + jacks |= protect ? CYNoFlags : CYCenter(flags); + true_->Single(out, jacks); + if (false_ != NULL) { - out << "else"; - if (protect) - right |= CYNoTerminator; - false_->Single(out, CYNoLeader | right); + out << '\t' << "else"; + false_->Single(out, right); } + if (protect) out << '}'; } -void CYIfComprehension::Begin_(CYOutput &out) const { - out << "if("; - test_->Output(out, CYNoFlags); - out << ')'; -} - -void CYIndirect::Output(CYOutput &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cyi"; - if ((flags & CYNoTrailer) != 0) - out << ' '; +void CYIfComprehension::Output(CYOutput &out) const { + out << "if" << ' ' << '(' << *test_ << ')' << next_; } 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(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); - if (out.pretty_) - out << ' '; - out << name; - if (out.pretty_) - out << ' '; + 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 CYLabel::Output(CYOutput &out, CYFlags flags) const { + out << *name_ << ':' << ' '; + statement_->Single(out, CYRight(flags)); +} + void CYLet::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "let"; - if (out.pretty_) - out << ' '; - out << '('; - declarations_->Output(out, CYNoFlags); - out << ')'; - if (out.pretty_) - out << ' '; - out << '{'; - if (statements_ != NULL) - statements_->Multiple(out); - out << '}'; + out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << code_; } -void CYMessage::Output(CYOutput &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_->Multiple(out); - out << "}.call(self);},$cyt),$cyt);"; -} - -void CYNew::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "new"; - if (out.pretty_) - out << ' '; +namespace cy { +namespace Syntax { + +void New::Output(CYOutput &out, CYFlags flags) const { + out << "new" << ' '; CYFlags jacks(CYNoCall | CYCenter(flags)); - if (!out.pretty_) - jacks |= CYNoLeader; constructor_->Output(out, Precedence(), jacks); - if (arguments_ != NULL) { - out << '('; - arguments_->Output(out); - out << ')'; - } + if (arguments_ != NULL) + out << '(' << *arguments_ << ')'; } +} } + void CYNull::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; } void CYNumber::Output(CYOutput &out, CYFlags flags) const { - double value(Value()); - if ((flags & CYNoLeader) != 0 || value < 0 && (flags & CYNoHyphen) != 0) - out << ' '; - // XXX: decide on correct precision - out.out_ << std::setprecision(9) << value; - if ((flags & CYNoTrailer) != 0) - out << ' '; + 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(CYOutput &out) const { @@ -700,14 +514,22 @@ 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 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(); @@ -715,187 +537,107 @@ void CYPostfix::Output(CYOutput &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; - if (alphabetic && out.pretty_) + if (Alphabetic()) out << ' '; - CYFlags right(CYRight(flags)); - if (alphabetic) - right |= CYNoLeader; - rhs_->Output(out, Precedence(), right); + rhs_->Output(out, Precedence(), CYRight(flags)); +} + +void CYProgram::Output(CYOutput &out) const { + if (statements_ != NULL) + statements_->Multiple(out); } void CYProperty::Output(CYOutput &out) const { + out << '\t'; name_->PropertyName(out); - out << ':'; - if (out.pretty_) - out << ' '; - value_->Output(out, CYPA, CYNoFlags); - if (next_ != NULL) { - out << ','; - if (out.pretty_) - out << ' '; - next_->Output(out); - } + out << ':' << ' '; + value_->Output(out, CYAssign::Precedence_, CYNoFlags); + if (next_ != NULL) + out << ',' << '\n' << *next_; + else + out << '\n'; } void CYRegEx::Output(CYOutput &out, CYFlags flags) const { out << Value(); - if ((flags & CYNoTrailer) != 0) - out << ' '; } void CYReturn::Output(CYOutput &out, CYFlags flags) const { - bool terminator((flags & CYNoTerminator) == 0); - if ((flags & CYNoLeader) != 0) - out << ' '; out << "return"; if (value_ != NULL) - value_->Output(out, (terminator ? CYCenter(flags) : flags) | CYNoLeader); - if (terminator) - out << ';'; -} - -void CYSelector::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "new Selector(\""; - if (name_ != NULL) - name_->Output(out); - out << "\")"; + out << ' ' << *value_; + out << ';'; } -void CYSelectorPart::Output(CYOutput &out) const { - if (name_ != NULL) - out << *name_; - if (value_) - out << ':'; - if (next_ != NULL) - next_->Output(out); +void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const { + call_->Output(out, CYLeft(flags)); + out << ' '; + proc_->Output(out, CYRight(flags)); } -void CYSend::Output(CYOutput &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.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 CYRubyProc::Output(CYOutput &out, CYFlags flags) const { + // XXX: this is not outputting the parameters + out << code_; } void CYStatement::Multiple(CYOutput &out, CYFlags flags) const { bool first(true); - for (const CYStatement *next(this); next != NULL; next = next->next_) { + CYForEach (next, this) { bool last(next->next_ == NULL); - CYFlags jacks(first ? last ? flags : CYLeft(flags) : last ? CYCenter(flags) : CYRight(flags)); - if (last) - jacks |= CYNoTerminator; + CYFlags jacks(first ? last ? flags : CYLeft(flags) : last ? CYRight(flags) : CYCenter(flags)); first = false; - out.Indent(); + out << '\t'; next->Output(out, jacks); - if (out.pretty_) - out << '\n'; + out << '\n'; } } void CYStatement::Single(CYOutput &out, CYFlags flags) const { - if (next_ != NULL) { - if (out.pretty_) - out << ' '; - out << '{'; - if (out.pretty_) - out << '\n'; - ++out.indent_; - Multiple(out); - --out.indent_; - out.Indent(); - out << '}'; - } else { - if (out.pretty_) - out << '\n'; - bool protect(false); - if (labels_ != NULL && (flags & CYNoLeader) != 0) - protect = true; - if (protect) - out << ' '; - for (CYLabel *label(labels_); label != NULL; label = label->next_) { - out << *label->name_ << ':'; - if (out.pretty_) - out << ' '; - } - ++out.indent_; - out.Indent(); - Output(out, protect ? CYRight(flags) : flags); - --out.indent_; - if (out.pretty_) - out << '\n'; - } + _assert(next_ == NULL); + out << '\n'; + ++out.indent_; + out << '\t'; + Output(out, flags); + out << '\n'; + --out.indent_; } void CYString::Output(CYOutput &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.out_ << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value); - else simple: - out << *value; - } - out << (single ? '\'' : '"'); + 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, CYNoFlags); + out << *this; } +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; @@ -903,114 +645,76 @@ const char *CYString::Word() const { if (!WordEndRange_[value_[i]]) return NULL; const char *value(Value()); - // XXX: we should probably include the full ECMAScript3+5 list. - static const char *reserveds[] = {"class", "const", "enum", "export", "extends", "import", "super", NULL}; - for (const char **reserved(reserveds); *reserved != NULL; ++reserved) + 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 { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "switch"; - if (out.pretty_) - out << ' '; - out << '('; - value_->Output(out, CYNoFlags); - out << ')'; - if (out.pretty_) - out << ' '; - out << '{'; - if (clauses_ != NULL) - out << *clauses_; + out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{'; + out << clauses_; out << '}'; } void CYThis::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; CYWord::Output(out); - if ((flags & CYNoTrailer) != 0) - out << ' '; } -void CYThrow::Output(CYOutput &out, CYFlags flags) const { - bool terminator((flags & CYNoTerminator) == 0); - if ((flags & CYNoLeader) != 0) - out << ' '; +namespace cy { +namespace Syntax { + +void Throw::Output(CYOutput &out, CYFlags flags) const { out << "throw"; if (value_ != NULL) - value_->Output(out, (terminator ? CYCenter(flags) : flags) | CYNoLeader); - if (terminator) - out << ';'; + out << ' ' << *value_; + out << ';'; } -void CYTry::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "try"; - if (out.pretty_) - out << ' '; - out << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; - if (catch_ != NULL) - catch_->Output(out); - if (finally_ != NULL) - finally_->Output(out); +void Try::Output(CYOutput &out, CYFlags flags) const { + out << "try" << ' ' << code_ << catch_ << finally_; } +} } + void CYVar::Output(CYOutput &out, CYFlags flags) const { - bool terminator((flags & CYNoTerminator) == 0); - if ((flags & CYNoLeader) != 0) - out << ' '; out << "var"; - declarations_->Output(out, (terminator ? CYCenter(flags) : flags) | CYNoLeader); - if (terminator) - out << ';'; + declarations_->Output(out, flags); + out << ';'; } void CYVariable::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; out << *name_; - if ((flags & CYNoTrailer) != 0) - out << ' '; } void CYWhile::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "while("; - test_->Output(out, CYNoFlags); - out << ')'; + out << "while" << '(' << *test_ << ')'; code_->Single(out, CYRight(flags)); } void CYWith::Output(CYOutput &out, CYFlags flags) const { - if ((flags & CYNoLeader) != 0) - out << ' '; - out << "with("; - scope_->Output(out, CYNoFlags); - out << ')'; + out << "with" << '(' << *scope_ << ')'; code_->Single(out, CYRight(flags)); } void CYWord::ClassName(CYOutput &out, bool object) const { if (object) out << "objc_getClass("; - out << '"' << Value() << '"'; + out << '"' << Word() << '"'; if (object) out << ')'; } void CYWord::Output(CYOutput &out) const { - out << Value(); + out << Word(); + if (out.options_.verbose_) + out.out_ << '@' << this; } void CYWord::PropertyName(CYOutput &out) const { Output(out); } + +const char *CYWord::Word() const { + return word_; +}