sync'ed display with frontend

Philip Guo · Philip Guo · commit eec35c38174c · 2012-08-15T09:33:44.000-07:00
diff --git a/PyTutorGAE/js/pytutor.js b/PyTutorGAE/js/pytutor.js
@@ -1660,9 +1660,9 @@ ExecutionVisualizer.prototype.renderDataStructures = function() {
       var funcName = htmlspecialchars(frame.func_name); // might contain '<' or '>' for weird names like <genexpr>
       var headerLabel = funcName + '()';
 
-      var frameID = frame.frame_id; // optional (btw, this isn't a CSS id)
-      if (frameID) {
-        headerLabel = 'f' + frameID + ': ' + headerLabel;
+      // only display if you're someone's parent
+      if (frame.is_parent) {
+        headerLabel = 'f' + frame.frame_id + ': ' + headerLabel;
       }
 
       // optional (btw, this isn't a CSS id)
diff --git a/PyTutorGAE/pg_logger.py b/PyTutorGAE/pg_logger.py
@@ -91,7 +91,6 @@ def __init__(self, finalizer_func, cumulative_display=False):
         # rather than only those currently on the stack (and their
         # lexical parents)
         self.cumulative_display = cumulative_display
-        self.cumulative_display = True
 
         # each entry contains a dict with the information for a single
         # executed line
@@ -104,7 +103,7 @@ def __init__(self, finalizer_func, cumulative_display=False):
         # Value: parent frame
         self.closures = {}
 
-        # Key: id() of frame object
+        # Key: frame object
         # Value: monotonically increasing small ID, based on call order
         self.frame_ordered_ids = {}
         self.cur_frame_id = 1
@@ -115,6 +114,10 @@ def __init__(self, finalizer_func, cumulative_display=False):
         # nested functions were defined within them.
         self.zombie_frames = []
 
+        # set of elements within zombie_frames that are also
+        # LEXICAL PARENTS of other frames
+        self.parent_frames_set = set()
+
         # all globals that ever appeared in the program, in the order in
         # which they appeared. note that this might be a superset of all
         # the globals that exist at any particular execution point,
@@ -129,7 +132,7 @@ def __init__(self, finalizer_func, cumulative_display=False):
 
 
     def get_frame_id(self, cur_frame):
-      return self.frame_ordered_ids[id(cur_frame)]
+      return self.frame_ordered_ids[cur_frame]
 
 
     # Returns the (lexical) parent frame of the function that was called
@@ -237,9 +240,8 @@ def interaction(self, frame, traceback, event_type):
                                   # or else we won't properly capture heap object mutations in the trace!
 
         if event_type == 'call':
-          tfid = id(top_frame)
-          assert tfid not in self.frame_ordered_ids
-          self.frame_ordered_ids[tfid] = self.cur_frame_id
+          assert top_frame not in self.frame_ordered_ids
+          self.frame_ordered_ids[top_frame] = self.cur_frame_id
           self.cur_frame_id += 1
 
           if self.cumulative_display:
@@ -356,8 +358,8 @@ def create_encoded_stack_entry(cur_frame):
             assert e in encoded_locals
 
           return dict(func_name=cur_name,
+                      is_parent=(cur_frame in self.parent_frames_set),
                       frame_id=self.get_frame_id(cur_frame),
-                      # TODO: fixme
                       parent_frame_id_list=parent_frame_id_list,
                       encoded_locals=encoded_locals,
                       ordered_varnames=ordered_varnames)
@@ -372,6 +374,7 @@ def create_encoded_stack_entry(cur_frame):
             if (type(v) in (types.FunctionType, types.MethodType) and \
                 v not in self.closures):
               self.closures[v] = top_frame
+              self.parent_frames_set.add(top_frame) # unequivocally add to this set!!!
               if not top_frame in self.zombie_frames:
                 self.zombie_frames.append(top_frame)
 
@@ -456,16 +459,17 @@ def create_encoded_stack_entry(cur_frame):
         # frontend can uniquely identify it when doing incremental
         # rendering. the strategy is to use a frankenstein-like mix of the
         # relevant fields to properly disambiguate closures and recursive
-        # calls to the same function (stack_index is key for
-        # disambiguating recursion!)
-        for (stack_index, e) in enumerate(stack_to_render):
+        # calls to the same function
+        for e in stack_to_render:
           hash_str = e['func_name']
+          # frame_id is UNIQUE, so it can disambiguate recursive calls
           hash_str += '_f' + str(e['frame_id'])
-          if e['parent_frame_id_list']:
-            hash_str += '_p' + '_'.join([str(i) for i in e['parent_frame_id_list']])
+
+          # TODO: this is no longer needed, right? (since frame_id is unique)
+          #if e['parent_frame_id_list']:
+          #  hash_str += '_p' + '_'.join([str(i) for i in e['parent_frame_id_list']])
           if e['is_zombie']:
             hash_str += '_z'
-          hash_str += '_i' + str(stack_index)
 
           e['unique_hash'] = hash_str
 
@@ -475,8 +479,6 @@ def create_encoded_stack_entry(cur_frame):
                            func_name=tos[0].f_code.co_name,
                            globals=encoded_globals,
                            ordered_globals=ordered_globals,
-                           #stack_locals=encoded_stack_locals,               # DEPRECATED in favor of stack_to_render
-                           #zombie_stack_locals=zombie_encoded_stack_locals, # DEPRECATED in favor of stack_to_render
                            stack_to_render=stack_to_render,
                            heap=self.encoder.get_heap(),
                            stdout=get_user_stdout(tos[0]))
