X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/d09e527c381abbc21b5ad603c3b55fe07c35d505..e7ff015817107dbac9373c19ce851178e4f3c791:/Output.cpp?ds=sidebyside diff --git a/Output.cpp b/Output.cpp index 1e4d437..51134c7 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,41 +1,29 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2013 Jay Freeman (saurik) +*/ + +/* GNU General Public License, Version 3 {{{ */ +/* + * Cycript is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. + * + * Cycript is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Cycript. If not, see . +**/ +/* }}} */ + +#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 & ~CYNoDangle; -} - -_finline CYFlags CYRight(CYFlags flags) { - return flags & ~CYNoBF; -} - -_finline CYFlags CYCenter(CYFlags flags) { - return CYLeft(CYRight(flags)); -} - -#define CYPA 16 - void CYOutput::Terminate() { out_ << ';'; mode_ = NoMode; @@ -51,14 +39,22 @@ CYOutput &CYOutput::operator <<(char rhs) { for (unsigned i(0); i != indent_; ++i) out_ << " "; else goto done; - else goto work; - + 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 != '}') + if (mode_ == Terminated && rhs != '}') { + right_ = true; out_ << ';'; + } if (rhs == ';') { if (pretty_) @@ -82,6 +78,7 @@ CYOutput &CYOutput::operator <<(char rhs) { } else none: mode_ = NoMode; + right_ = true; out_ << rhs; done: return *this; @@ -107,24 +104,11 @@ CYOutput &CYOutput::operator <<(const char *rhs) { else mode_ = NoMode; + right_ = true; out_ << rhs; return *this; } -void OutputBody(CYOutput &out, CYStatement *body) { - out << ' ' << '{' << '\n'; - ++out.indent_; - if (body != NULL) - body->Multiple(out); - --out.indent_; - out << '\t' << '}'; -} - -void CYAddressOf::Output(CYOutput &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cya()"; -} - void CYArgument::Output(CYOutput &out) const { if (name_ != NULL) { out << *name_; @@ -132,7 +116,7 @@ void CYArgument::Output(CYOutput &out) const { out << ':' << ' '; } if (value_ != NULL) - value_->Output(out, CYPA, CYNoFlags); + value_->Output(out, CYAssign::Precedence_, CYNoFlags); if (next_ != NULL) { if (next_->name_ == NULL) out << ','; @@ -145,21 +129,7 @@ void CYArray::Output(CYOutput &out, CYFlags flags) const { } 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 { @@ -168,8 +138,22 @@ void CYAssignment::Output(CYOutput &out, CYFlags flags) const { 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 { @@ -193,56 +177,20 @@ void CYCall::Output(CYOutput &out, CYFlags flags) const { out << ')'; } -void CYCatch::Output(CYOutput &out) const { - out << "catch" << ' ' << '(' << *name_ << ')' << ' ' << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; -} +namespace cy { +namespace Syntax { -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 << ')'; - out << ';'; +void Catch::Output(CYOutput &out) const { + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_; } -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 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 { @@ -261,18 +209,13 @@ void CYCompound::Output(CYOutput &out, CYFlags flags) const { expression->Output(out, flags); } -void CYComprehension::Output(CYOutput &out) const { - Begin_(out); - out << next_; -} - void CYCondition::Output(CYOutput &out, CYFlags flags) const { test_->Output(out, Precedence() - 1, CYLeft(flags)); out << ' ' << '?' << ' '; if (true_ != NULL) - true_->Output(out, CYPA, CYNoFlags); + true_->Output(out, CYAssign::Precedence_, CYNoFlags); out << ' ' << ':' << ' '; - false_->Output(out, CYPA, CYRight(flags)); + false_->Output(out, CYAssign::Precedence_, CYRight(flags)); } void CYContinue::Output(CYOutput &out, CYFlags flags) const { @@ -288,13 +231,13 @@ void CYClause::Output(CYOutput &out) const { else out << "default"; out << ':' << '\n'; - if (code_ != NULL) - code_->Multiple(out, CYNoFlags); + if (statements_ != NULL) + statements_->Multiple(out); out << next_; } -const char *CYDeclaration::ForEachIn() const { - return identifier_->Value(); +void CYDebugger::Output(CYOutput &out, CYFlags flags) const { + out << "debugger" << ';'; } void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { @@ -302,21 +245,18 @@ void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { Output(out, CYRight(flags)); } -void CYDeclaration::ForEachIn(CYOutput &out) const { - out << *identifier_; -} - void CYDeclaration::Output(CYOutput &out, CYFlags flags) const { out << *identifier_; + //out.out_ << ':' << identifier_->usage_ << '#' << identifier_->offset_; if (initialiser_ != NULL) { out << ' ' << '=' << ' '; - initialiser_->Output(out, CYPA, CYRight(flags)); + initialiser_->Output(out, CYAssign::Precedence_, CYRight(flags)); } } -void CYDeclarations::For(CYOutput &out) const { +void CYForDeclarations::Output(CYOutput &out, CYFlags flags) const { out << "var"; - Output(out, CYNoIn); + Output(out, CYRight(flags)); } void CYDeclarations::Output(CYOutput &out) const { @@ -326,21 +266,24 @@ void CYDeclarations::Output(CYOutput &out) const { void CYDeclarations::Output(CYOutput &out, CYFlags flags) const { const CYDeclarations *declaration(this); bool first(true); - output: - 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) { + 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; - 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 @@ -355,7 +298,7 @@ void CYDoWhile::Output(CYOutput &out, CYFlags flags) const { 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 (next_ != NULL && next_->value_ != NULL) @@ -375,19 +318,7 @@ void CYExpress::Output(CYOutput &out, CYFlags flags) const { } void CYExpression::ClassName(CYOutput &out, bool object) const { - Output(out, CYPA, CYNoFlags); -} - -const char *CYExpression::ForEachIn() const { - return NULL; -} - -void CYExpression::For(CYOutput &out) const { - Output(out, CYNoIn); -} - -void CYExpression::ForEachIn(CYOutput &out) const { - Output(out, CYPA, CYNoRightHand); + Output(out, CYAssign::Precedence_, CYNoFlags); } void CYExpression::ForIn(CYOutput &out, CYFlags flags) const { @@ -398,78 +329,58 @@ void CYExpression::Output(CYOutput &out) const { Output(out, CYNoFlags); } -void CYExpression::Output(CYOutput &out, unsigned precedence, CYFlags flags) const { +void CYExpression::Output(CYOutput &out, int precedence, CYFlags flags) const { if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand()) out << '(' << *this << ')'; else Output(out, flags); } -void CYField::Output(CYOutput &out) const { - // XXX: implement! +void CYFatArrow::Output(CYOutput &out, CYFlags flags) const { + out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << code_; } void CYFinally::Output(CYOutput &out) const { - out << "finally" << ' ' << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; + out << ' ' << "finally" << ' ' << code_; } void CYFor::Output(CYOutput &out, CYFlags flags) const { out << "for" << ' ' << '('; if (initialiser_ != NULL) - initialiser_->For(out); + initialiser_->Output(out, CYNoIn); out.Terminate(); + if (test_ != NULL) + out << ' '; out << test_; out.Terminate(); + if (increment_ != NULL) + out << ' '; out << increment_; out << ')'; code_->Single(out, CYRight(flags)); } -void CYForEachIn::Output(CYOutput &out, CYFlags flags) const { - 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_ << "];"; +void CYForOf::Output(CYOutput &out, CYFlags flags) const { + out << "for" << ' ' << "each" << ' ' << '('; + initialiser_->ForIn(out, CYNoIn); + out << "in" << *set_ << ')'; + code_->Single(out, CYRight(flags)); } -void CYForEachInComprehension::End_(CYOutput &out) const { - out << "}}());"; +void CYForOfComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << "each" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')' << next_; } void CYForIn::Output(CYOutput &out, CYFlags flags) const { out << "for" << ' ' << '('; - initialiser_->ForIn(out, CYNoIn); + if (initialiser_ != NULL) + initialiser_->ForIn(out, CYNoIn); out << "in" << *set_ << ')'; code_->Single(out, CYRight(flags)); } -void CYForInComprehension::Begin_(CYOutput &out) const { - out << "for" << ' ' << '(' << *name_ << "in" << *set_ << ')'; +void CYForInComprehension::Output(CYOutput &out) const { + out << "for" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')'; } void CYFunction::Output(CYOutput &out, CYFlags flags) const { @@ -481,7 +392,7 @@ void CYFunction::Output(CYOutput &out, CYFlags flags) const { if (name_ != NULL) out << ' ' << *name_; out << '(' << parameters_ << ')'; - OutputBody(out, body_); + out << ' ' << code_; if (protect) out << ')'; } @@ -495,11 +406,15 @@ void CYFunctionStatement::Output(CYOutput &out, CYFlags flags) const { } void CYFunctionParameter::Output(CYOutput &out) const { - out << *name_; + 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) { @@ -517,11 +432,10 @@ void CYIf::Output(CYOutput &out, CYFlags flags) const { else jacks |= protect ? CYNoFlags : CYCenter(flags); - bool single(true_->Single(out, jacks)); + true_->Single(out, jacks); if (false_ != NULL) { - out << (single ? '\t' : ' '); - out << "else"; + out << '\t' << "else"; false_->Single(out, right); } @@ -529,22 +443,16 @@ void CYIf::Output(CYOutput &out, CYFlags flags) const { out << '}'; } -void CYIfComprehension::Begin_(CYOutput &out) const { - out << "if" << '(' << *test_ << ')'; -} - -void CYIndirect::Output(CYOutput &out, CYFlags flags) const { - rhs_->Output(out, 1, CYLeft(flags)); - out << ".$cyi"; +void CYIfComprehension::Output(CYOutput &out) const { + out << "if" << ' ' << '(' << *test_ << ')' << next_; } void CYIndirectMember::Output(CYOutput &out, CYFlags flags) const { object_->Output(out, Precedence(), CYLeft(flags)); - out << ".$cyi"; if (const char *word = property_->Word()) - out << '.' << word; + out << "->" << word; else - out << '[' << *property_ << ']'; + out << "->" << '[' << *property_ << ']'; } void CYInfix::Output(CYOutput &out, CYFlags flags) const { @@ -561,37 +469,95 @@ void CYInfix::Output(CYOutput &out, CYFlags flags) const { out << ')'; } -void CYLet::Output(CYOutput &out, CYFlags flags) const { - out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << '{'; - if (statements_ != NULL) - statements_->Multiple(out); - out << '}'; +void CYLabel::Output(CYOutput &out, CYFlags flags) const { + out << *name_ << ':' << ' '; + statement_->Single(out, CYRight(flags)); +} + +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 CYMessage::Output(CYOutput &out, bool replace) const { +void CYTypeModifier::Output(CYOutput &out, int precedence, CYIdentifier *identifier) const { + if (this == NULL) { + out << identifier; + return; + } + + bool protect(precedence > Precedence()); + + if (protect) + out << '('; + Output(out, identifier); + if (protect) + out << ')'; +} + +void CYTypedIdentifier::Output(CYOutput &out) const { + type_->Output(out, 0, CYNoFlags); + modifier_->Output(out, 0, identifier_); +} + +void CYEncodedType::Output(CYOutput &out, CYFlags flags) const { + out << "@encode(" << typed_ << ")"; +} + +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_->Multiple(out); - out << "}.call(self);},$cyt),$cyt);"; -} - -void CYNew::Output(CYOutput &out, CYFlags flags) const { + 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 CYLetStatement::Output(CYOutput &out, CYFlags flags) const { + out << "let" << ' ' << '(' << *declarations_ << ')'; + code_->Single(out, CYRight(flags)); +} + +namespace cy { +namespace Syntax { + +void New::Output(CYOutput &out, CYFlags flags) const { out << "new" << ' '; CYFlags jacks(CYNoCall | CYCenter(flags)); constructor_->Output(out, Precedence(), jacks); @@ -599,14 +565,20 @@ void CYNew::Output(CYOutput &out, CYFlags flags) const { out << '(' << *arguments_ << ')'; } +} } + void CYNull::Output(CYOutput &out, CYFlags flags) const { CYWord::Output(out); } void CYNumber::Output(CYOutput &out, CYFlags flags) const { - char value[32]; - sprintf(value, "%.17g", Value()); - out << value; + 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 { @@ -619,7 +591,7 @@ void CYObject::Output(CYOutput &out, CYFlags flags) const { out << '('; out << '{' << '\n'; ++out.indent_; - out << property_; + out << properties_; --out.indent_; out << '\t' << '}'; if (protect) @@ -639,11 +611,16 @@ void CYPrefix::Output(CYOutput &out, CYFlags flags) const { 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 << ':' << ' '; - value_->Output(out, CYPA, CYNoFlags); + value_->Output(out, CYAssign::Precedence_, CYNoFlags); if (next_ != NULL) out << ',' << '\n' << *next_; else @@ -661,45 +638,22 @@ void CYReturn::Output(CYOutput &out, CYFlags flags) const { out << ';'; } -void CYSelector::Output(CYOutput &out, CYFlags flags) const { - out << "new Selector(\""; - if (name_ != NULL) - name_->Output(out); - out << "\")"; -} - -void CYSelectorPart::Output(CYOutput &out) const { - out << name_; - if (value_) - out << ':'; - out << next_; +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 { - 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)); + CYFlags jacks(first ? last ? flags : CYLeft(flags) : last ? CYRight(flags) : CYCenter(flags)); first = false; out << '\t'; next->Output(out, jacks); @@ -707,70 +661,22 @@ void CYStatement::Multiple(CYOutput &out, CYFlags flags) const { } } -bool CYStatement::Single(CYOutput &out, CYFlags flags) const { - if (next_ != NULL) { - out << ' ' << '{' << '\n'; - ++out.indent_; - Multiple(out); - --out.indent_; - out << '\t' << '}'; - return false; - } else { - for (CYLabel *label(labels_); label != NULL; label = label->next_) - out << ' ' << *label->name_ << ':'; - out << '\n'; - ++out.indent_; - out << '\t'; - Output(out, flags); - out << '\n'; - --out.indent_; - return true; - } +void CYStatement::Single(CYOutput &out, CYFlags flags) const { + if (this == NULL) + return out.Terminate(); + + _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); - std::ostringstream str; - - str << (single ? '\'' : '"'); - for (const char *value(value_), *end(value_ + size_); value != end; ++value) - switch (*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; - - case '"': - if (!single) - str << "\\\""; - else goto simple; - break; - - case '\'': - if (single) - str << "\\'"; - else goto simple; - break; - - default: - if (*value < 0x20 || *value >= 0x7f) - str << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value); - else simple: - str << *value; - } - str << (single ? '\'' : '"'); - + CYStringify(str, value_, size_); out << str.str().c_str(); } @@ -800,8 +706,6 @@ static const char *Reserved_[] = { "let", "yield", - "each", - NULL }; @@ -828,22 +732,22 @@ void CYThis::Output(CYOutput &out, CYFlags flags) const { CYWord::Output(out); } -void CYThrow::Output(CYOutput &out, CYFlags flags) const { +namespace cy { +namespace Syntax { + +void Throw::Output(CYOutput &out, CYFlags flags) const { out << "throw"; if (value_ != NULL) out << ' ' << *value_; out << ';'; } -void CYTry::Output(CYOutput &out, CYFlags flags) const { - out << "try" << ' ' << '{'; - if (code_ != NULL) - code_->Multiple(out); - out << '}'; - out << catch_; - out << finally_; +void Try::Output(CYOutput &out, CYFlags flags) const { + out << "try" << ' ' << code_ << catch_ << finally_; } +} } + void CYVar::Output(CYOutput &out, CYFlags flags) const { out << "var"; declarations_->Output(out, flags); @@ -867,15 +771,21 @@ void CYWith::Output(CYOutput &out, CYFlags flags) const { 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_; +}