More useful result pretty printing for d8

src/d8.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * 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
@@ skipping 2176 matching lines @@
       json += NumberToJSON_(elem);
     } else if (typeof(elem) === 'string')  {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
 }
+
+
+// A more universal stringify that supports more types than JSON.
+// Used by the d8 shell to output results.
+var stringifyDepthLimit = 12;  // To avoid crashing on cyclic objects

[Yang, 2013/03/12 12:56:41]

You could also use a stack to detect cycles.

[rossberg, 2013/03/18 14:03:07]

I'd need an object set to do it properly, which I want to avoid relying on for
the time being. Future work.

+
+function Stringify(x, depth) {
+  if (depth === undefined)
+    depth = stringifyDepthLimit;
+  else if (depth === 0)
+    return "*";
+  switch (typeof x) {
+    case "undefined":
+      return "undefined";
+    case "boolean":
+    case "number":
+    case "function":
+      return x.toString();
+    case "string":
+      return "\"" + x.toString() + "\"";
+    case "object":
+      if (x === null) return "null";
+      if (x.constructor.name === "Array") {
+        var elems = [];
+        for (var i = 0; i < x.length; ++i) {
+          elems.push(x.hasOwnProperty(i) ? Stringify(x[i], depth - 1) : "");

[Yang, 2013/03/12 12:56:41]

Would it make sense to try to avoid monkey-patched methods? %ArrayPush probably
works. Or use InternalArray.

[rossberg, 2013/03/18 14:03:07]

There are many ways in which this code could break if you monkey patch
inproperly. I don't feel an urge to protect against all of it. I did, however,
replace x.hasOwnProperty with {}.hasOwnProperty.call, so that it works on
objects with strange prototypes.

+        }
+        return "[" + elems.join(", ") + "]";
+      }
+      if (String(x) !== "[object Object]") return String(x);
+      var props = [];
+      for (var name in x) {
+        var desc = Object.getOwnPropertyDescriptor(x, name);
+        if (desc === undefined) continue;
+        if ("value" in desc) {
+          props.push(name + ": " + Stringify(desc.value, depth - 1));
+        }
+        if ("get" in desc) {
+          var getter = desc.get.toString();
+          props.push("get " + name + getter.slice(getter.indexOf('(')));
+        }
+        if ("set" in desc) {
+          var setter = desc.set.toString();
+          props.push("set " + name + setter.slice(setter.indexOf('(')));
+        }
+      }
+      return "{" + props.join(", ") + "}";
+    default:
+      return "[crazy non-standard shit]";
+  }
+}