]> git.saurik.com Git - cycript.git/blobdiff - Output.cpp
projects / cycript.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
The grammar and lexer should not share a filename.
[cycript.git] / Output.cpp
diff --git a/Output.cpp b/Output.cpp
index 4c4376a7fd549f0d03281f7aa7235fb2b96b544c..c8205e5c05ebd106b1f222d0abbe876741d0395c 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -1,5 +1,5 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2014  Jay Freeman (saurik)
+ * Copyright (C) 2009-2015  Jay Freeman (saurik)
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
@@ -20,28 +20,29 @@
 /* }}} */
 
 #include "cycript.hpp"
 /* }}} */
 
 #include "cycript.hpp"
-#include "Parser.hpp"
 
 #include <sstream>
 
 
 #include <sstream>
 
+#include "Syntax.hpp"
+
 void CYOutput::Terminate() {
 void CYOutput::Terminate() {
-    out_ << ';';
+    operator ()(';');
     mode_ = NoMode;
 }
 
 CYOutput &CYOutput::operator <<(char rhs) {
     if (rhs == ' ' || rhs == '\n')
         if (pretty_)
     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)
         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_) {
         else goto done;
     else if (rhs == '\r') {
         if (right_) {
-            out_ << '\n';
+            operator ()('\n');
             right_ = false;
         } goto done;
     } else goto work;
             right_ = false;
         } goto done;
     } else goto work;
@@ -53,7 +54,7 @@ CYOutput &CYOutput::operator <<(char rhs) {
   work:
     if (mode_ == Terminated && rhs != '}') {
         right_ = true;
   work:
     if (mode_ == Terminated && rhs != '}') {
         right_ = true;
-        out_ << ';';
+        operator ()(';');
     }
 
     if (rhs == ';') {
     }
 
     if (rhs == ';') {
@@ -65,21 +66,21 @@ CYOutput &CYOutput::operator <<(char rhs) {
         }
     } else if (rhs == '+') {
         if (mode_ == NoPlus)
         }
     } else if (rhs == '+') {
         if (mode_ == NoPlus)
-            out_ << ' ';
+            operator ()(' ');
         mode_ = NoPlus;
     } else if (rhs == '-') {
         if (mode_ == NoHyphen)
         mode_ = NoPlus;
     } else if (rhs == '-') {
         if (mode_ == NoHyphen)
-            out_ << ' ';
+            operator ()(' ');
         mode_ = NoHyphen;
     } else if (WordEndRange_[rhs]) {
         if (mode_ == NoLetter)
         mode_ = NoHyphen;
     } else if (WordEndRange_[rhs]) {
         if (mode_ == NoLetter)
-            out_ << ' ';
+            operator ()(' ');
         mode_ = NoLetter;
     } else none:
         mode_ = NoMode;
 
     right_ = true;
         mode_ = NoLetter;
     } else none:
         mode_ = NoMode;
 
     right_ = true;
-    out_ << rhs;
+    operator ()(rhs);
   done:
     return *this;
 }
   done:
     return *this;
 }
@@ -91,21 +92,22 @@ CYOutput &CYOutput::operator <<(const char *rhs) {
         return *this << *rhs;
 
     if (mode_ == Terminated)
         return *this << *rhs;
 
     if (mode_ == Terminated)
-        out_ << ';';
+        operator ()(';');
     else if (
         mode_ == NoPlus && *rhs == '+' ||
         mode_ == NoHyphen && *rhs == '-' ||
         mode_ == NoLetter && WordEndRange_[*rhs]
     )
     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;
         mode_ = NoLetter;
     else
         mode_ = NoMode;
 
     right_ = true;
-    out_ << rhs;
+    operator ()(rhs, size);
     return *this;
 }
 
     return *this;
 }
 
@@ -137,26 +139,18 @@ void CYAssignment::Output(CYOutput &out, CYFlags flags) const {
     rhs_->Output(out, Precedence(), CYRight(flags));
 }
 
     rhs_->Output(out, Precedence(), CYRight(flags));
 }
 
-void CYBlock::Output(CYOutput &out) const {
+void CYBlock::Output(CYOutput &out, CYFlags flags) const {
     out << '{' << '\n';
     ++out.indent_;
     out << '{' << '\n';
     ++out.indent_;
-    if (statements_ != NULL)
-        statements_->Multiple(out);
+    out << code_;
     --out.indent_;
     out << '\t' << '}';
 }
 
     --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 {
 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 {
 }
 
 void CYBreak::Output(CYOutput &out, CYFlags flags) const {
@@ -180,18 +174,16 @@ namespace cy {
 namespace Syntax {
 
 void Catch::Output(CYOutput &out) const {
 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 (next_ == NULL)
         expression_->Output(out, flags);
 void CYCompound::Output(CYOutput &out, CYFlags flags) const {
     if (next_ == NULL)
         expression_->Output(out, flags);
@@ -219,13 +211,15 @@ void CYContinue::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYClause::Output(CYOutput &out) const {
 }
 
 void CYClause::Output(CYOutput &out) const {
+    out << '\t';
     if (case_ != NULL)
         out << "case" << ' ' << *case_;
     else
         out << "default";
     out << ':' << '\n';
     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_;
 }
 
     out << next_;
 }
 
@@ -234,7 +228,7 @@ void CYDebugger::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {
 }
 
 void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {
-    out << "var";
+    out << "var" << ' ';
     Output(out, CYRight(flags));
 }
 
     Output(out, CYRight(flags));
 }
 
@@ -248,8 +242,8 @@ void CYDeclaration::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYForDeclarations::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYForDeclarations::Output(CYOutput &out, CYFlags flags) const {
-    out << "var";
-    Output(out, CYRight(flags));
+    out << "var" << ' ';
+    declarations_->Output(out, CYRight(flags));
 }
 
 void CYDeclarations::Output(CYOutput &out) const {
 }
 
 void CYDeclarations::Output(CYOutput &out) const {
@@ -285,16 +279,29 @@ void CYDirectMember::Output(CYOutput &out, CYFlags flags) const {
 
 void CYDoWhile::Output(CYOutput &out, CYFlags flags) const {
     out << "do";
 
 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_ << ')';
 }
 
     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, CYAssign::Precedence_, CYNoFlags);
     if (next_ != NULL || value_ == NULL) {
         out << ',';
     if (value_ != NULL)
         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)
             out << ' ';
     }
     if (next_ != NULL)
@@ -329,12 +336,21 @@ void CYExpression::Output(CYOutput &out, int precedence, CYFlags flags) const {
         Output(out, flags);
 }
 
         Output(out, flags);
 }
 
+void CYExternal::Output(CYOutput &out, CYFlags flags) const {
+    out << "extern" << abi_ << typed_ << ';';
+}
+
 void CYFatArrow::Output(CYOutput &out, CYFlags flags) const {
 void CYFatArrow::Output(CYOutput &out, CYFlags flags) const {
-    out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << code_;
+    out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << '{' << code_ << '}';
 }
 
 void CYFinally::Output(CYOutput &out) const {
 }
 
 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 {
 }
 
 void CYFor::Output(CYOutput &out, CYFlags flags) const {
@@ -350,14 +366,14 @@ void CYFor::Output(CYOutput &out, CYFlags flags) const {
         out << ' ';
     out << increment_;
     out << ')';
         out << ' ';
     out << increment_;
     out << ')';
-    code_->Single(out, CYRight(flags));
+    code_->Single(out, CYRight(flags), CYCompactShort);
 }
 
 void CYForOf::Output(CYOutput &out, CYFlags flags) const {
     out << "for" << ' ' << "each" << ' ' << '(';
     initialiser_->ForIn(out, CYNoIn);
 }
 
 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 CYForOfComprehension::Output(CYOutput &out) const {
 }
 
 void CYForOfComprehension::Output(CYOutput &out) const {
@@ -368,8 +384,8 @@ void CYForIn::Output(CYOutput &out, CYFlags flags) const {
     out << "for" << ' ' << '(';
     if (initialiser_ != NULL)
         initialiser_->ForIn(out, CYNoIn);
     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 {
 }
 
 void CYForInComprehension::Output(CYOutput &out) const {
@@ -384,8 +400,12 @@ void CYFunction::Output(CYOutput &out, CYFlags flags) const {
     out << "function";
     if (name_ != NULL)
         out << ' ' << *name_;
     out << "function";
     if (name_ != NULL)
         out << ' ' << *name_;
-    out << '(' << parameters_ << ')';
-    out << ' ' << code_;
+    out << '(' << parameters_ << ')' << ' ';
+    out << '{' << '\n';
+    ++out.indent_;
+    out << code_;
+    --out.indent_;
+    out << '\t' << '}';
     if (protect)
         out << ')';
 }
     if (protect)
         out << ')';
 }
@@ -425,11 +445,18 @@ void CYIf::Output(CYOutput &out, CYFlags flags) const {
     else
         jacks |= protect ? CYNoFlags : CYCenter(flags);
 
     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 (false_ != NULL) {
-        out << '\t' << "else";
-        false_->Single(out, right);
+        if (out.position_.line != line && out.recent_ == indent)
+            out << ' ';
+        else
+            out << '\n' << '\t';
+
+        out << "else";
+        false_->Single(out, right, CYCompactLong);
     }
 
     if (protect)
     }
 
     if (protect)
@@ -467,8 +494,22 @@ void CYInfix::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYLabel::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 {
 }
 
 void CYTypeArrayOf::Output(CYOutput &out, CYIdentifier *identifier) const {
@@ -485,7 +526,7 @@ void CYTypeBlockWith::Output(CYOutput &out, CYIdentifier *identifier) const {
 }
 
 void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const {
 }
 
 void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const {
-    out << "const";
+    out << "const" << ' ';
     next_->Output(out, Precedence(), identifier);
 }
 
     next_->Output(out, Precedence(), identifier);
 }
 
@@ -543,12 +584,12 @@ void CYLambda::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYTypeDefinition::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYTypeDefinition::Output(CYOutput &out, CYFlags flags) const {
-    out << "typedef" << *typed_;
+    out << "typedef" << ' ' << *typed_;
 }
 
 void CYLetStatement::Output(CYOutput &out, CYFlags flags) const {
     out << "let" << ' ' << '(' << *declarations_ << ')';
 }
 
 void CYLetStatement::Output(CYOutput &out, CYFlags flags) const {
     out << "let" << ' ' << '(' << *declarations_ << ')';
-    code_->Single(out, CYRight(flags));
+    code_->Single(out, CYRight(flags), CYCompactShort);
 }
 
 void CYModule::Output(CYOutput &out) const {
 }
 
 void CYModule::Output(CYOutput &out) const {
@@ -571,7 +612,7 @@ void New::Output(CYOutput &out, CYFlags flags) const {
 } }
 
 void CYNull::Output(CYOutput &out, CYFlags flags) const {
 } }
 
 void CYNull::Output(CYOutput &out, CYFlags flags) const {
-    CYWord::Output(out);
+    out << "null";
 }
 
 void CYNumber::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYNumber::Output(CYOutput &out, CYFlags flags) const {
@@ -614,9 +655,8 @@ void CYPrefix::Output(CYOutput &out, CYFlags flags) const {
     rhs_->Output(out, Precedence(), CYRight(flags));
 }
 
     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 {
 }
 
 void CYProperty::Output(CYOutput &out) const {
@@ -648,8 +688,11 @@ void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYRubyProc::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYRubyProc::Output(CYOutput &out, CYFlags flags) const {
-    // XXX: this is not outputting the parameters
+    out << '{' << ' ' << '|' << parameters_ << '|' << '\n';
+    ++out.indent_;
     out << code_;
     out << code_;
+    --out.indent_;
+    out << '\t' << '}';
 }
 
 void CYStatement::Multiple(CYOutput &out, CYFlags flags) const {
 }
 
 void CYStatement::Multiple(CYOutput &out, CYFlags flags) const {
@@ -664,17 +707,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);
     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);
     Output(out, flags);
-    out << '\n';
-    --out.indent_;
+
+    if (compact < request)
+        --out.indent_;
 }
 
 void CYString::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYString::Output(CYOutput &out, CYFlags flags) const {
@@ -726,13 +778,15 @@ const char *CYString::Word() const {
 }
 
 void CYSwitch::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYSwitch::Output(CYOutput &out, CYFlags flags) const {
-    out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{';
+    out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{' << '\n';
+    ++out.indent_;
     out << clauses_;
     out << clauses_;
-    out << '}';
+    --out.indent_;
+    out << '\t' << '}';
 }
 
 void CYThis::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYThis::Output(CYOutput &out, CYFlags flags) const {
-    CYWord::Output(out);
+    out << "this";
 }
 
 namespace cy {
 }
 
 namespace cy {
@@ -746,7 +800,13 @@ void Throw::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void Try::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_;
 }
 
 } }
 }
 
 } }
@@ -780,7 +840,7 @@ void CYTypeVoid::Output(CYOutput &out) const {
 }
 
 void CYVar::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYVar::Output(CYOutput &out, CYFlags flags) const {
-    out << "var";
+    out << "var" << ' ';
     declarations_->Output(out, flags);
     out << ';';
 }
     declarations_->Output(out, flags);
     out << ';';
 }
@@ -790,13 +850,13 @@ void CYVariable::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYWhile::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 {
 }
 
 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 {
 }
 
 void CYWord::ClassName(CYOutput &out, bool object) const {
@@ -809,8 +869,12 @@ void CYWord::ClassName(CYOutput &out, bool object) const {
 
 void CYWord::Output(CYOutput &out) const {
     out << Word();
 
 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 {
 }
 
 void CYWord::PropertyName(CYOutput &out) const {
Cycript