X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/e013809d7a06e37dcbf21c340febecda46ba0caf..63db22e50caddb75792b67534547cb3ac7ccff61:/Output.cpp diff --git a/Output.cpp b/Output.cpp index 552768b..2ff5ad7 100644 --- a/Output.cpp +++ b/Output.cpp @@ -1,40 +1,22 @@ -/* Cycript - Inlining/Optimizing JavaScript Compiler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * 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 . +**/ /* }}} */ #include "cycript.hpp" @@ -42,52 +24,24 @@ #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 | CYNoInteger); -} - -_finline CYFlags CYRight(CYFlags flags) { - return flags & ~CYNoBF; -} - -_finline CYFlags CYCenter(CYFlags flags) { - return CYLeft(CYRight(flags)); -} - void CYOutput::Terminate() { - out_ << ';'; + operator ()(';'); mode_ = NoMode; } CYOutput &CYOutput::operator <<(char rhs) { if (rhs == ' ' || rhs == '\n') if (pretty_) - out_ << rhs; + operator ()(rhs); else goto done; else if (rhs == '\t') if (pretty_) for (unsigned i(0); i != indent_; ++i) - out_ << " "; + operator ()(" ", 4); else goto done; else if (rhs == '\r') { if (right_) { - out_ << '\n'; + operator ()('\n'); right_ = false; } goto done; } else goto work; @@ -99,7 +53,7 @@ CYOutput &CYOutput::operator <<(char rhs) { work: if (mode_ == Terminated && rhs != '}') { right_ = true; - out_ << ';'; + operator ()(';'); } if (rhs == ';') { @@ -111,21 +65,21 @@ CYOutput &CYOutput::operator <<(char rhs) { } } else if (rhs == '+') { if (mode_ == NoPlus) - out_ << ' '; + operator ()(' '); mode_ = NoPlus; } else if (rhs == '-') { if (mode_ == NoHyphen) - out_ << ' '; + operator ()(' '); mode_ = NoHyphen; } else if (WordEndRange_[rhs]) { if (mode_ == NoLetter) - out_ << ' '; + operator ()(' '); mode_ = NoLetter; } else none: mode_ = NoMode; right_ = true; - out_ << rhs; + operator ()(rhs); done: return *this; } @@ -137,21 +91,22 @@ CYOutput &CYOutput::operator <<(const char *rhs) { return *this << *rhs; if (mode_ == Terminated) - out_ << ';'; + operator ()(';'); else if ( mode_ == NoPlus && *rhs == '+' || mode_ == NoHyphen && *rhs == '-' || mode_ == NoLetter && WordEndRange_[*rhs] ) - out_ << ' '; + operator ()(' '); - if (WordEndRange_[rhs[size - 1]]) + char last(rhs[size - 1]); + if (WordEndRange_[last] || last == '/') mode_ = NoLetter; else mode_ = NoMode; right_ = true; - out_ << rhs; + operator ()(rhs, size); return *this; } @@ -162,10 +117,9 @@ 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 << ','; + out << ','; out << ' ' << *next_; } } @@ -184,26 +138,18 @@ void CYAssignment::Output(CYOutput &out, CYFlags flags) const { rhs_->Output(out, Precedence(), CYRight(flags)); } -void CYBlock::Output(CYOutput &out) const { +void CYBlock::Output(CYOutput &out, CYFlags flags) const { out << '{' << '\n'; ++out.indent_; - if (statements_ != NULL) - statements_->Multiple(out); + out << code_; --out.indent_; out << '\t' << '}'; } -void CYBlock::Output(CYOutput &out, CYFlags flags) const { - if (statements_ == NULL) - out.Terminate(); - else if (statements_->next_ == NULL) - statements_->Single(out, flags); - else - Output(out); -} - void CYBoolean::Output(CYOutput &out, CYFlags flags) const { - out << (Value() ? "true" : "false"); + out << '!' << (Value() ? "0" : "1"); + if ((flags & CYNoInteger) != 0) + out << '.'; } void CYBreak::Output(CYOutput &out, CYFlags flags) const { @@ -227,41 +173,33 @@ namespace cy { namespace Syntax { void Catch::Output(CYOutput &out) const { - out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_; + out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } } } -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 { - 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); + if (next_ == NULL) + expression_->Output(out, flags); + else { + expression_->Output(out, CYLeft(flags)); + out << ',' << ' '; + next_->Output(out, CYRight(flags)); + } } 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 { @@ -272,22 +210,24 @@ void CYContinue::Output(CYOutput &out, CYFlags flags) const { } void CYClause::Output(CYOutput &out) const { + out << '\t'; if (case_ != NULL) out << "case" << ' ' << *case_; else out << "default"; out << ':' << '\n'; - if (statements_ != NULL) - statements_->Multiple(out); + ++out.indent_; + out << code_; + --out.indent_; out << next_; } -const char *CYDeclaration::ForEachIn() const { - return identifier_->Word(); +void CYDebugger::Output(CYOutput &out, CYFlags flags) const { + out << "debugger" << ';'; } void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const { - out << "var"; + out << "var" << ' '; Output(out, CYRight(flags)); } @@ -296,13 +236,13 @@ void CYDeclaration::Output(CYOutput &out, CYFlags flags) const { //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 { - out << "var"; - Output(out, CYNoIn); +void CYForDeclarations::Output(CYOutput &out, CYFlags flags) const { + out << "var" << ' '; + declarations_->Output(out, CYRight(flags)); } void CYDeclarations::Output(CYOutput &out) const { @@ -312,21 +252,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 @@ -335,16 +278,29 @@ void CYDirectMember::Output(CYOutput &out, CYFlags flags) const { void CYDoWhile::Output(CYOutput &out, CYFlags flags) const { out << "do"; - code_->Single(out, CYCenter(flags)); + + unsigned line(out.position_.line); + unsigned indent(out.indent_); + code_->Single(out, CYCenter(flags), CYCompactLong); + + if (out.position_.line != line && out.recent_ == indent) + out << ' '; + else + out << '\n' << '\t'; + out << "while" << ' ' << '(' << *test_ << ')'; } -void CYElement::Output(CYOutput &out) const { +void CYElementSpread::Output(CYOutput &out) const { + out << "..." << value_; +} + +void CYElementValue::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) + if (next_ != NULL && !next_->Elision()) out << ' '; } if (next_ != NULL) @@ -361,15 +317,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); + Output(out, CYAssign::Precedence_, CYNoFlags); } void CYExpression::ForIn(CYOutput &out, CYFlags flags) const { @@ -380,37 +328,54 @@ 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 CYExternal::Output(CYOutput &out, CYFlags flags) const { + out << "extern" << abi_ << typed_ << ';'; +} + +void CYFatArrow::Output(CYOutput &out, CYFlags flags) const { + out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << '{' << code_ << '}'; +} + void CYFinally::Output(CYOutput &out) const { - out << ' ' << "finally" << ' ' << code_; + out << ' ' << "finally" << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; } 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)); + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYForEachIn::Output(CYOutput &out, CYFlags flags) const { +void CYForOf::Output(CYOutput &out, CYFlags flags) const { out << "for" << ' ' << "each" << ' ' << '('; initialiser_->ForIn(out, CYNoIn); - out << "in" << *set_ << ')'; - code_->Single(out, CYRight(flags)); + out << ' ' << "in" << ' ' << *set_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } -void CYForEachInComprehension::Output(CYOutput &out) const { +void CYForOfComprehension::Output(CYOutput &out) const { out << "for" << ' ' << "each" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')' << next_; } @@ -418,8 +383,8 @@ void CYForIn::Output(CYOutput &out, CYFlags flags) const { out << "for" << ' ' << '('; if (initialiser_ != NULL) initialiser_->ForIn(out, CYNoIn); - out << "in" << *set_ << ')'; - code_->Single(out, CYRight(flags)); + out << ' ' << "in" << ' ' << *set_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } void CYForInComprehension::Output(CYOutput &out) const { @@ -432,12 +397,14 @@ void CYFunction::Output(CYOutput &out, CYFlags flags) const { if (protect) out << '('; out << "function"; - if (out.options_.verbose_) - out.out_ << ':' << static_cast(this); if (name_ != NULL) out << ' ' << *name_; - out << '(' << parameters_ << ')'; - out << ' ' << code_; + out << '(' << parameters_ << ')' << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; if (protect) out << ')'; } @@ -451,7 +418,7 @@ 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_; } @@ -477,11 +444,18 @@ void CYIf::Output(CYOutput &out, CYFlags flags) const { else jacks |= protect ? CYNoFlags : CYCenter(flags); - true_->Single(out, jacks); + unsigned line(out.position_.line); + unsigned indent(out.indent_); + true_->Single(out, jacks, CYCompactShort); if (false_ != NULL) { + if (out.position_.line != line && out.recent_ == indent) + out << ' '; + else + out << '\n' << '\t'; + out << "else"; - false_->Single(out, right); + false_->Single(out, right, CYCompactLong); } if (protect) @@ -492,6 +466,10 @@ void CYIfComprehension::Output(CYOutput &out) const { out << "if" << ' ' << '(' << *test_ << ')' << next_; } +void CYImport::Output(CYOutput &out, CYFlags flags) const { + out << "@import"; +} + void CYIndirectMember::Output(CYOutput &out, CYFlags flags) const { object_->Output(out, Precedence(), CYLeft(flags)); if (const char *word = property_->Word()) @@ -515,15 +493,114 @@ void CYInfix::Output(CYOutput &out, CYFlags flags) const { } void CYLabel::Output(CYOutput &out, CYFlags flags) const { - out << *name_ << ':' << ' '; - statement_->Single(out, CYRight(flags)); + 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 CYLet::Output(CYOutput &out, CYFlags flags) const { - out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << code_; +void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const { + out << "const" << ' '; + next_->Output(out, Precedence(), identifier); } -void CYNew::Output(CYOutput &out, CYFlags flags) const { +void CYTypeFunctionWith::Output(CYOutput &out, CYIdentifier *identifier) const { + next_->Output(out, Precedence(), identifier); + out << '(' << parameters_ << ')'; +} + +void CYTypePointerTo::Output(CYOutput &out, CYIdentifier *identifier) const { + out << '*'; + next_->Output(out, Precedence(), identifier); +} + +void CYTypeVolatile::Output(CYOutput &out, CYIdentifier *identifier) const { + out << "volatile"; + next_->Output(out, Precedence(), identifier); +} + +void CYTypeModifier::Output(CYOutput &out, int precedence, CYIdentifier *identifier) const { + if (this == NULL) { + out << identifier; + return; + } + + bool protect(precedence > Precedence()); + + if (protect) + out << '('; + Output(out, identifier); + if (protect) + 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 CYTypedParameter::Output(CYOutput &out) const { + out << typed_; + if (next_ != NULL) + out << ',' << ' ' << next_; +} + +void CYLambda::Output(CYOutput &out, CYFlags flags) const { + // XXX: this is seriously wrong + out << "[]("; + out << ")->"; + out << "{"; + out << "}"; +} + +void CYTypeDefinition::Output(CYOutput &out, CYFlags flags) const { + out << "typedef" << ' ' << *typed_; +} + +void CYLetStatement::Output(CYOutput &out, CYFlags flags) const { + out << "let" << ' ' << '(' << *declarations_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); +} + +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); @@ -531,8 +608,10 @@ void CYNew::Output(CYOutput &out, CYFlags flags) const { out << '(' << *arguments_ << ')'; } +} } + void CYNull::Output(CYOutput &out, CYFlags flags) const { - CYWord::Output(out); + out << "null"; } void CYNumber::Output(CYOutput &out, CYFlags flags) const { @@ -575,16 +654,15 @@ 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 CYScript::Output(CYOutput &out) const { + out << code_; } 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 @@ -602,11 +680,25 @@ void CYReturn::Output(CYOutput &out, CYFlags flags) const { 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); - 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); @@ -614,14 +706,26 @@ void CYStatement::Multiple(CYOutput &out, CYFlags flags) const { } } -void CYStatement::Single(CYOutput &out, CYFlags flags) const { +void CYStatement::Single(CYOutput &out, CYFlags flags, CYCompactType request) const { + if (this == NULL) + return out.Terminate(); + _assert(next_ == NULL); - out << '\n'; - ++out.indent_; - out << '\t'; + + CYCompactType compact(Compact()); + + if (compact >= request) + out << ' '; + else { + out << '\n'; + ++out.indent_; + out << '\t'; + } + Output(out, flags); - out << '\n'; - --out.indent_; + + if (compact < request) + --out.indent_; } void CYString::Output(CYOutput &out, CYFlags flags) const { @@ -673,13 +777,15 @@ const char *CYString::Word() const { } void CYSwitch::Output(CYOutput &out, CYFlags flags) const { - out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{'; + out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{' << '\n'; + ++out.indent_; out << clauses_; - out << '}'; + --out.indent_; + out << '\t' << '}'; } void CYThis::Output(CYOutput &out, CYFlags flags) const { - CYWord::Output(out); + out << "this"; } namespace cy { @@ -693,13 +799,47 @@ void Throw::Output(CYOutput &out, CYFlags flags) const { } void Try::Output(CYOutput &out, CYFlags flags) const { - out << "try" << ' ' << code_ << catch_ << finally_; + out << "try" << ' '; + out << '{' << '\n'; + ++out.indent_; + out << code_; + --out.indent_; + out << '\t' << '}'; + out << catch_ << finally_; } } } +void CYTypeError::Output(CYOutput &out) const { + out << "@error"; +} + +void CYTypeLong::Output(CYOutput &out) const { + out << "long" << specifier_; +} + +void CYTypeShort::Output(CYOutput &out) const { + out << "short" << specifier_; +} + +void CYTypeSigned::Output(CYOutput &out) const { + out << "signed" << specifier_; +} + +void CYTypeUnsigned::Output(CYOutput &out) const { + out << "unsigned" << specifier_; +} + +void CYTypeVariable::Output(CYOutput &out) const { + out << *name_; +} + +void CYTypeVoid::Output(CYOutput &out) const { + out << "void"; +} + void CYVar::Output(CYOutput &out, CYFlags flags) const { - out << "var"; + out << "var" << ' '; declarations_->Output(out, flags); out << ';'; } @@ -709,13 +849,13 @@ void CYVariable::Output(CYOutput &out, CYFlags flags) const { } void CYWhile::Output(CYOutput &out, CYFlags flags) const { - out << "while" << '(' << *test_ << ')'; - code_->Single(out, CYRight(flags)); + out << "while" << ' ' << '(' << *test_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } void CYWith::Output(CYOutput &out, CYFlags flags) const { - out << "with" << '(' << *scope_ << ')'; - code_->Single(out, CYRight(flags)); + out << "with" << ' ' << '(' << *scope_ << ')'; + code_->Single(out, CYRight(flags), CYCompactShort); } void CYWord::ClassName(CYOutput &out, bool object) const { @@ -728,8 +868,12 @@ void CYWord::ClassName(CYOutput &out, bool object) const { void CYWord::Output(CYOutput &out) const { out << Word(); - if (out.options_.verbose_) - out.out_ << '@' << this; + if (out.options_.verbose_) { + out('@'); + char number[32]; + sprintf(number, "%p", this); + out(number); + } } void CYWord::PropertyName(CYOutput &out) const {