Quick output fix for optional arguments (CYPA and spacing).

[cycript.git] / Output.cpp

diff --git a/Output.cpp b/Output.cpp
index 9ac31e5f893b1655dc360a0c1d1413cc5660bcee..989781ab575380ceff675b6897656c399e9c01cb 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -1,4 +1,4 @@
-/* Cycript - Remove Execution Server and Disassembler
+/* Cycript - Inlining/Optimizing JavaScript Compiler

  * Copyright (C) 2009  Jay Freeman (saurik)
 */
 
  * Copyright (C) 2009  Jay Freeman (saurik)
 */
 


@@ -37,9 +37,9 @@
 */
 /* }}} */
 
 */
 /* }}} */
 

+#include "cycript.hpp"

 #include "Parser.hpp"
 
 #include "Parser.hpp"
 

-#include <iomanip>

 #include <sstream>
 
 _finline CYFlags operator ~(CYFlags rhs) {
 #include <sstream>
 
 _finline CYFlags operator ~(CYFlags rhs) {


@@ -59,7 +59,7 @@ _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
 }
 
 _finline CYFlags CYLeft(CYFlags flags) {
 }
 
 _finline CYFlags CYLeft(CYFlags flags) {

-    return flags & ~CYNoDangle;
+    return flags & ~(CYNoDangle | CYNoInteger);

 }
 
 _finline CYFlags CYRight(CYFlags flags) {
 }
 
 _finline CYFlags CYRight(CYFlags flags) {


@@ -85,14 +85,22 @@ CYOutput &CYOutput::operator <<(char rhs) {
             for (unsigned i(0); i != indent_; ++i)
                 out_ << "    ";
         else goto done;
             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:
     mode_ = NoMode;
     goto done;
 
   work:

-    if (mode_ == Terminated && rhs != '}')
+    if (mode_ == Terminated && rhs != '}') {
+        right_ = true;

         out_ << ';';
         out_ << ';';

+    }

 
     if (rhs == ';') {
         if (pretty_)
 
     if (rhs == ';') {
         if (pretty_)


@@ -116,6 +124,7 @@ CYOutput &CYOutput::operator <<(char rhs) {
     } else none:
         mode_ = NoMode;
 
     } else none:
         mode_ = NoMode;
 

+    right_ = true;

     out_ << rhs;
   done:
     return *this;
     out_ << rhs;
   done:
     return *this;


@@ -141,6 +150,7 @@ CYOutput &CYOutput::operator <<(const char *rhs) {
     else
         mode_ = NoMode;
 
     else
         mode_ = NoMode;
 

+    right_ = true;

     out_ << rhs;
     return *this;
 }
     out_ << rhs;
     return *this;
 }


@@ -213,10 +223,22 @@ void CYCall::Output(CYOutput &out, CYFlags flags) const {
         out << ')';
 }
 
         out << ')';
 }
 

-void CYCatch::Output(CYOutput &out) const {
+namespace cy {
+namespace Syntax {
+
+void Catch::Output(CYOutput &out) const {

     out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_;
 }
 
     out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_;
 }
 

+} }
+
+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_) {
 void CYCompound::Output(CYOutput &out, CYFlags flags) const {
     if (CYExpression *expression = expressions_)
         if (CYExpression *next = expression->next_) {


@@ -261,7 +283,7 @@ void CYClause::Output(CYOutput &out) const {
 }
 
 const char *CYDeclaration::ForEachIn() const {
 }
 
 const char *CYDeclaration::ForEachIn() const {

-    return identifier_->Value();
+    return identifier_->Word();

 }
 
 void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {
 }
 
 void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {


@@ -271,6 +293,7 @@ void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {
 
 void CYDeclaration::Output(CYOutput &out, CYFlags flags) 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));
     if (initialiser_ != NULL) {
         out << ' ' << '=' << ' ';
         initialiser_->Output(out, CYPA, CYRight(flags));


@@ -303,7 +326,7 @@ void CYDeclarations::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYDirectMember::Output(CYOutput &out, CYFlags flags) const {
 }
 
 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
     if (const char *word = property_->Word())
         out << '.' << word;
     else


@@ -393,7 +416,8 @@ void CYForEachInComprehension::Output(CYOutput &out) const {
 
 void CYForIn::Output(CYOutput &out, CYFlags flags) const {
     out << "for" << ' ' << '(';
 
 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));
 }
     out << "in" << *set_ << ')';
     code_->Single(out, CYRight(flags));
 }


@@ -430,6 +454,10 @@ void CYFunctionParameter::Output(CYOutput &out) const {
         out << ',' << ' ' << *next_;
 }
 
         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) {
 void CYIf::Output(CYOutput &out, CYFlags flags) const {
     bool protect(false);
     if (false_ == NULL && (flags & CYNoDangle) != 0) {


@@ -506,10 +534,13 @@ void CYNull::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYNumber::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYNumber::Output(CYOutput &out, CYFlags flags) const {

-    char value[32];
-    // XXX: I want this to print 1e3 rather than 1000
-    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 {
 }
 
 void CYNumber::PropertyName(CYOutput &out) const {


@@ -529,6 +560,13 @@ void CYObject::Output(CYOutput &out, CYFlags flags) const {
         out << ')';
 }
 
         out << ')';
 }
 

+void CYOptionalFunctionParameter::Output(CYOutput &out) const {
+    out << *name_ << ' ' << '=' << ' ';
+    initializer_->Output(out, CYPA, CYNoFlags);
+    if (next_ != NULL)
+        out << ',' << ' ' << *next_;
+}
+

 void CYPostfix::Output(CYOutput &out, CYFlags flags) const {
     lhs_->Output(out, Precedence(), CYLeft(flags));
     out << Operator();
 void CYPostfix::Output(CYOutput &out, CYFlags flags) const {
     lhs_->Output(out, Precedence(), CYLeft(flags));
     out << Operator();


@@ -592,48 +630,8 @@ void CYStatement::Single(CYOutput &out, CYFlags flags) const {
 }
 
 void CYString::Output(CYOutput &out, CYFlags flags) const {
 }
 
 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;
     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();
 }
 
     out << str.str().c_str();
 }
 


@@ -663,8 +661,6 @@ static const char *Reserved_[] = {
 
     "let", "yield",
 
 
     "let", "yield",
 

-    "each",
-

     NULL
 };
 
     NULL
 };
 


@@ -691,17 +687,22 @@ void CYThis::Output(CYOutput &out, CYFlags flags) const {
     CYWord::Output(out);
 }
 
     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 << ';';
 }
 
     out << "throw";
     if (value_ != NULL)
         out << ' ' << *value_;
     out << ';';
 }
 

-void CYTry::Output(CYOutput &out, CYFlags flags) const {
+void Try::Output(CYOutput &out, CYFlags flags) const {

     out << "try" << ' ' << code_ << catch_ << finally_;
 }
 
     out << "try" << ' ' << code_ << catch_ << finally_;
 }
 

+} }
+

 void CYVar::Output(CYOutput &out, CYFlags flags) const {
     out << "var";
     declarations_->Output(out, flags);
 void CYVar::Output(CYOutput &out, CYFlags flags) const {
     out << "var";
     declarations_->Output(out, flags);


@@ -725,15 +726,21 @@ void CYWith::Output(CYOutput &out, CYFlags flags) const {
 void CYWord::ClassName(CYOutput &out, bool object) const {
     if (object)
         out << "objc_getClass(";
 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 {
     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);
 }
 }
 
 void CYWord::PropertyName(CYOutput &out) const {
     Output(out);
 }

+
+const char *CYWord::Word() const {
+    return word_;
+}