eric: comparison DebugClients/Python/coverage/pytracer.py

-:bedab77d0fa3
+:d6c795b5ce33
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
 """Raw data collector for coverage.py."""
+import atexit
 import dis
 import sys
 from coverage import env
 self.should_trace_cache = None
 self.warn = None
 # The threading module to use, if any.
 self.threading = None
-self.cur_file_dict = []
+self.cur_file_dict = None
-self.last_line = [0]
+self.last_line = 0          # int, but uninitialized.
+self.cur_file_name = None
 self.data_stack = []
 self.last_exc_back = None
 self.last_exc_firstlineno = 0
 self.thread = None
 self.stopped = False
+self._activity = False
+self.in_atexit = False
+# On exit, self.in_atexit = True
+atexit.register(setattr, self, 'in_atexit', True)
 def __repr__(self):
-return "<PyTracer at 0x{0:0x}: {1} lines in {2} files>".format(
+return "<PyTracer at {0}: {1} lines in {2} files>".format(
 id(self),
 sum(len(v) for v in self.data.values()),
 len(self.data),
 )
+def log(self, marker, *args):
+"""For hard-core logging of what this tracer is doing."""
+with open("/tmp/debug_trace.txt", "a") as f:
+f.write("{} {:x}.{:x}[{}] {:x} {}\n".format(
+marker,
+id(self),
+self.thread.ident,
+len(self.data_stack),
+self.threading.currentThread().ident,
+" ".join(map(str, args))
+))
 def _trace(self, frame, event, arg_unused):
 """The trace function passed to sys.settrace."""
-if self.stopped:
+#self.log(":", frame.f_code.co_filename, frame.f_lineno, event)
-return
+if (self.stopped and sys.gettrace() == self._trace):
+# The PyTrace.stop() method has been called, possibly by another
+# thread, let's deactivate ourselves now.
+#self.log("X", frame.f_code.co_filename, frame.f_lineno)
+sys.settrace(None)
+return None
 if self.last_exc_back:
 if frame == self.last_exc_back:
 # Someone forgot a return event.
 if self.trace_arcs and self.cur_file_dict:
 pair = (self.last_line, -self.last_exc_firstlineno)
 self.cur_file_dict[pair] = None
-self.cur_file_dict, self.last_line = self.data_stack.pop()
+self.cur_file_dict, self.cur_file_name, self.last_line = self.data_stack.pop()
 self.last_exc_back = None
 if event == 'call':
 # Entering a new function context.  Decide if we should trace
 # in this file.
-self.data_stack.append((self.cur_file_dict, self.last_line))
+self._activity = True
+self.data_stack.append((self.cur_file_dict, self.cur_file_name, self.last_line))
 filename = frame.f_code.co_filename
+self.cur_file_name = filename
 disp = self.should_trace_cache.get(filename)
 if disp is None:
 disp = self.should_trace(filename, frame)
 self.should_trace_cache[filename] = disp
 self.cur_file_dict = self.data[tracename]
 # The call event is really a "start frame" event, and happens for
 # function calls and re-entering generators.  The f_lasti field is
 # -1 for calls, and a real offset for generators.  Use <0 as the
 # line number for calls, and the real line number for generators.
-if frame.f_lasti < 0:
+if getattr(frame, 'f_lasti', -1) < 0:
 self.last_line = -frame.f_code.co_firstlineno
 else:
 self.last_line = frame.f_lineno
 elif event == 'line':
 # Record an executed line.
 if self.cur_file_dict is not None:
 lineno = frame.f_lineno
+#if frame.f_code.co_filename != self.cur_file_name:
+#    self.log("*", frame.f_code.co_filename, self.cur_file_name, lineno)
 if self.trace_arcs:
 self.cur_file_dict[(self.last_line, lineno)] = None
 else:
 self.cur_file_dict[lineno] = None
 self.last_line = lineno
 elif event == 'return':
 if self.trace_arcs and self.cur_file_dict:
 # Record an arc leaving the function, but beware that a
 # "return" event might just mean yielding from a generator.
-bytecode = frame.f_code.co_code[frame.f_lasti]
+# Jython seems to have an empty co_code, so just assume return.
-if bytecode != YIELD_VALUE:
+code = frame.f_code.co_code
+if (not code) or code[frame.f_lasti] != YIELD_VALUE:
 first = frame.f_code.co_firstlineno
 self.cur_file_dict[(self.last_line, -first)] = None
 # Leaving this function, pop the filename stack.
-self.cur_file_dict, self.last_line = self.data_stack.pop()
+self.cur_file_dict, self.cur_file_name, self.last_line = self.data_stack.pop()
 elif event == 'exception':
 self.last_exc_back = frame.f_back
 self.last_exc_firstlineno = frame.f_code.co_firstlineno
 return self._trace
 """Start this Tracer.
 Return a Python function suitable for use with sys.settrace().
 """
+self.stopped = False
 if self.threading:
-self.thread = self.threading.currentThread()
+if self.thread is None:
+self.thread = self.threading.currentThread()
+else:
+if self.thread.ident != self.threading.currentThread().ident:
+# Re-starting from a different thread!? Don't set the trace
+# function, but we are marked as running again, so maybe it
+# will be ok?
+#self.log("~", "starting on different threads")
+return self._trace
 sys.settrace(self._trace)
-self.stopped = False
 return self._trace
 def stop(self):
 """Stop this Tracer."""
+# Get the activate tracer callback before setting the stop flag to be
+# able to detect if the tracer was changed prior to stopping it.
+tf = sys.gettrace()
+# Set the stop flag. The actual call to sys.settrace(None) will happen
+# in the self._trace callback itself to make sure to call it from the
+# right thread.
 self.stopped = True
 if self.threading and self.thread.ident != self.threading.currentThread().ident:
 # Called on a different thread than started us: we can't unhook
 # ourselves, but we've set the flag that we should stop, so we
 # won't do any more tracing.
+#self.log("~", "stopping on different threads")
 return
 if self.warn:
-if sys.gettrace() != self._trace:
+# PyPy clears the trace function before running atexit functions,
-msg = "Trace function changed, measurement is likely wrong: %r"
+# so don't warn if we are in atexit on PyPy and the trace function
-self.warn(msg % (sys.gettrace(),))
+# has changed to None.
+dont_warn = (env.PYPY and env.PYPYVERSION >= (5, 4) and self.in_atexit and tf is None)
-sys.settrace(None)
+if (not dont_warn) and tf != self._trace:
+self.warn(
+"Trace function changed, measurement is likely wrong: %r" % (tf,),
+slug="trace-changed",
+)
+def activity(self):
+"""Has there been any activity?"""
+return self._activity
+def reset_activity(self):
+"""Reset the activity() flag."""
+self._activity = False
 def get_stats(self):
 """Return a dictionary of statistics, or None."""
 return None

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/pytracer.py

DebugClients/Python/coverage/pytracer.py