added a mode to render all objects on the heap

pgbovine · pgbovine · commit 905cf7660d4f · 2013-01-05T21:41:06.000-08:00
diff --git a/v3/js/opt-frontend.js b/v3/js/opt-frontend.js
@@ -197,7 +197,8 @@ $(document).ready(function() {
                                                      dataFromBackend,
                                                      {startingInstruction:  startingInstruction,
                                                       updateOutputCallback: function() {$('#urlOutput,#embedCodeOutput').val('');},
-                                                      disableHeapNesting: $('#heapPrimitivesSelector').val(),
+                                                      // tricky: it's a string!
+                                                      disableHeapNesting: ($('#heapPrimitivesSelector').val() == 'true'),
                                                       //allowEditAnnotations: true,
                                                      });
 
diff --git a/v3/js/pytutor.js b/v3/js/pytutor.js
@@ -1430,13 +1430,16 @@ ExecutionVisualizer.prototype.precomputeCurTraceLayouts = function() {
 
 
     function recurseIntoObject(id, curRow, newRow) {
+      //console.log('recurseIntoObject', id,
+      //            $.extend(true /* make a deep copy */ , [], curRow),
+      //            $.extend(true /* make a deep copy */ , [], newRow));
 
       // heuristic for laying out 1-D linked data structures: check for enclosing elements that are
       // structurally identical and then lay them out as siblings in the same "row"
       var heapObj = curEntry.heap[id];
       assert(heapObj);
 
-      if (heapObj[0] == 'LIST' || heapObj[0] == 'TUPLE') {
+      if (heapObj[0] == 'LIST' || heapObj[0] == 'TUPLE' || heapObj[0] == 'SET') {
         $.each(heapObj, function(ind, child) {
           if (ind < 1) return; // skip type tag
 
@@ -1445,28 +1448,48 @@ ExecutionVisualizer.prototype.precomputeCurTraceLayouts = function() {
             if (structurallyEquivalent(heapObj, curEntry.heap[childID])) {
               updateCurLayout(childID, curRow, newRow);
             }
+            else if (myViz.disableHeapNesting) {
+              updateCurLayout(childID, curRow, []);
+            }
           }
         });
       }
       else if (heapObj[0] == 'DICT') {
         $.each(heapObj, function(ind, child) {
           if (ind < 1) return; // skip type tag
 
+          if (myViz.disableHeapNesting) {
+            var dictKey = child[0];
+            if (!isPrimitiveType(dictKey)) {
+              var keyChildID = getRefID(dictKey);
+              updateCurLayout(keyChildID, curRow, []);
+            }
+          }
+
           var dictVal = child[1];
           if (!isPrimitiveType(dictVal)) {
             var childID = getRefID(dictVal);
             if (structurallyEquivalent(heapObj, curEntry.heap[childID])) {
               updateCurLayout(childID, curRow, newRow);
             }
+            else if (myViz.disableHeapNesting) {
+              updateCurLayout(childID, curRow, []);
+            }
           }
         });
       }
-      else if (heapObj[0] == 'INSTANCE') {
+      else if (heapObj[0] == 'INSTANCE' || heapObj[0] == 'CLASS') {
         jQuery.each(heapObj, function(ind, child) {
-          if (ind < 2) return; // skip type tag and class name
-
-          // instance keys are always strings, so no need to recurse
-          assert(typeof child[0] == "string");
+          var headerLength = (heapObj[0] == 'INSTANCE') ? 2 : 3;
+          if (ind < headerLength) return;
+
+          if (myViz.disableHeapNesting) {
+            var instKey = child[0];
+            if (!isPrimitiveType(instKey)) {
+              var keyChildID = getRefID(instKey);
+              updateCurLayout(keyChildID, curRow, []);
+            }
+          }
 
           var instVal = child[1];
           if (!isPrimitiveType(instVal)) {
@@ -2010,9 +2033,16 @@ ExecutionVisualizer.prototype.renderDataStructures = function() {
           var valTd = newRow.find('td:last');
 
           // the keys should always be strings, so render them directly (and without quotes):
-          assert(typeof kvPair[0] == "string");
-          var attrnameStr = htmlspecialchars(kvPair[0]);
-          keyTd.append('<span class="keyObj">' + attrnameStr + '</span>');
+          // (actually this isn't the case when strings are rendered on the heap)
+          if (typeof kvPair[0] == "string") {
+            // common case ...
+            var attrnameStr = htmlspecialchars(kvPair[0]);
+            keyTd.append('<span class="keyObj">' + attrnameStr + '</span>');
+          }
+          else {
+            // when strings are rendered as heap objects ...
+            renderNestedObject(kvPair[0], keyTd);
+          }
 
           // values can be arbitrary objects, so recurse:
           renderNestedObject(kvPair[1], valTd);
@@ -2567,7 +2597,7 @@ function structurallyEquivalent(obj1, obj2) {
       startingInd = 3;
     }
     else {
-      return false;
+      return false; // punt on all other types
     }
 
     var obj1fields = d3.map();
diff --git a/v3/visualize.html b/v3/visualize.html
@@ -78,11 +78,11 @@
   </select>,
   <select id="cumulativeModeSelector">
     <option value="false">hide frames of exited functions</option>
-    <option value="true">display frames of exited functions</option>
+    <option value="true">show frames of exited functions</option>
   </select>, and
   <select id="heapPrimitivesSelector">
-    <option value="false">render primitives in stack</option>
-    <option value="true">render primitives on heap</option>
+    <option value="false">inline primitives and nested objects</option>
+    <option value="true">render all objects on the heap</option>
   </select>.
 </p>
 
