bdb: Add initial micropython support. Requires MICROPY_PY_SYS_SETTRACE.

Author: pi-anl

python-stdlib/bdb/bdb.py

@@ -1,13 +1,19 @@
 """Debugger basics"""
 
+# This is originally from cpython 3.10: https://raw.githubusercontent.com/python/cpython/3.10/Lib/bdb.py
+# Patches for micropython have been commented as such.
+
 import fnmatch
 import sys
 import os
-from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
+
+## MPY: no inspect module avaialble
+# from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
 
 __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
 
-GENERATOR_AND_COROUTINE_FLAGS = CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR
+## MPY: These flags currently don't exist
+# GENERATOR_AND_COROUTINE_FLAGS = CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR
 
 
 class BdbQuit(Exception):
@@ -46,17 +52,21 @@ def canonic(self, filename):
         """
         if filename == "<" + filename[1:-1] + ">":
             return filename
-        canonic = self.fncache.get(filename)
-        if not canonic:
-            canonic = os.path.abspath(filename)
-            canonic = os.path.normcase(canonic)
-            self.fncache[filename] = canonic
-        return canonic
+
+        ## MPY: os.path module difficult to add as dependency
+        # canonic = self.fncache.get(filename)
+        # if not canonic:
+        #     canonic = os.path.abspath(filename)
+        #     canonic = os.path.normcase(canonic)
+        # self.fncache[filename] = canonic
+        # return canonic
+        return filename
 
     def reset(self):
         """Set values of attributes as ready to start debugging."""
-        import linecache
-        linecache.checkcache()
+        ## MPY: linecache not yet available
+        # import linecache
+        # linecache.checkcache()
         self.botframe = None
         self._set_stopinfo(None, None)
 
@@ -115,6 +125,12 @@ def dispatch_line(self, frame):
             if self.quitting: raise BdbQuit
         return self.trace_dispatch
 
+    def is_coroutine(self, frame):
+        ## MPY: co_flags attrib not available, compatible method of detecting coroutine TBD 
+        # return frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
+        return False
+
+    
     def dispatch_call(self, frame, arg):
         """Invoke user function and return trace function for call event.
 
@@ -131,7 +147,7 @@ def dispatch_call(self, frame, arg):
             # No need to trace this function
             return # None
         # Ignore call events in generator except when stepping.
-        if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
+        if self.stopframe and self.is_coroutine(frame):
             return self.trace_dispatch
         self.user_call(frame, arg)
         if self.quitting: raise BdbQuit
@@ -146,7 +162,7 @@ def dispatch_return(self, frame, arg):
         """
         if self.stop_here(frame) or frame == self.returnframe:
             # Ignore return events in generator except when stepping.
-            if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
+            if self.stopframe and self.is_coroutine(frame):
                 return self.trace_dispatch
             try:
                 self.frame_returning = frame
@@ -170,7 +186,7 @@ def dispatch_exception(self, frame, arg):
             # When stepping with next/until/return in a generator frame, skip
             # the internal StopIteration exception (with no traceback)
             # triggered by a subiterator run with the 'yield from' statement.
-            if not (frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
+            if not (self.is_coroutine(frame)
                     and arg[0] is StopIteration and arg[2] is None):
                 self.user_exception(frame, arg)
                 if self.quitting: raise BdbQuit
@@ -179,7 +195,7 @@ def dispatch_exception(self, frame, arg):
         # next/until command at the last statement in the generator before the
         # exception.
         elif (self.stopframe and frame is not self.stopframe
-                and self.stopframe.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
+                and self.is_coroutine(self.stopframe)
                 and arg[0] in (StopIteration, GeneratorExit)):
             self.user_exception(frame, arg)
             if self.quitting: raise BdbQuit
@@ -305,8 +321,9 @@ def set_step(self):
         # for performance reasons) when returning from the current frame.
         if self.frame_returning:
             caller_frame = self.frame_returning.f_back
-            if caller_frame and not caller_frame.f_trace:
-                caller_frame.f_trace = self.trace_dispatch
+            ## MPY: f_trace attrib not yet available
+            # if caller_frame and not caller_frame.f_trace:
+            #     caller_frame.f_trace = self.trace_dispatch
         self._set_stopinfo(None, None)
 
     def set_next(self, frame):
@@ -315,7 +332,7 @@ def set_next(self, frame):
 
     def set_return(self, frame):
         """Stop when returning from the given frame."""
-        if frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
+        if self.is_coroutine(frame):
             self._set_stopinfo(frame, None, -1)
         else:
             self._set_stopinfo(frame.f_back, frame)
@@ -326,12 +343,13 @@ def set_trace(self, frame=None):
         If frame is not specified, debugging starts from caller's frame.
         """
         if frame is None:
-            frame = sys._getframe().f_back
+            frame = sys._getframe(1)
         self.reset()
-        while frame:
-            frame.f_trace = self.trace_dispatch
-            self.botframe = frame
-            frame = frame.f_back
+        ## MPY: f_trace attrib not yet available
+        # while frame:
+            # frame.f_trace = self.trace_dispatch
+            # self.botframe = frame
+            # frame = frame.f_back
         self.set_step()
         sys.settrace(self.trace_dispatch)
 
@@ -345,10 +363,12 @@ def set_continue(self):
         if not self.breaks:
             # no breakpoints; run without debugger overhead
             sys.settrace(None)
-            frame = sys._getframe().f_back
-            while frame and frame is not self.botframe:
-                del frame.f_trace
-                frame = frame.f_back
+            ## MPY: was sys._getframe().f_back but f_back missing when inside trace dispatch functions
+            frame = sys._getframe(1)
+            ## MPY: f_trace attrib not yet available
+            # while frame and frame is not self.botframe:
+            #     del frame.f_trace
+            #     frame = frame.f_back
 
     def set_quit(self):
         """Set quitting attribute to True.
@@ -381,10 +401,11 @@ def set_break(self, filename, lineno, temporary=False, cond=None,
         The filename should be in canonical form.
         """
         filename = self.canonic(filename)
-        import linecache # Import as late as possible
-        line = linecache.getline(filename, lineno)
-        if not line:
-            return 'Line %s:%d does not exist' % (filename, lineno)
+        ## MPY: linecache not yet available
+        # import linecache # Import as late as possible
+        # line = linecache.getline(filename, lineno)
+        # if not line:
+        #     return 'Line %s:%d does not exist' % (filename, lineno)
         self._add_to_breaks(filename, lineno)
         bp = Breakpoint(filename, lineno, temporary, cond, funcname)
         return None
@@ -557,23 +578,26 @@ def format_stack_entry(self, frame_lineno, lprefix=': '):
         line of code (if it exists).
 
         """
-        import linecache, reprlib
         frame, lineno = frame_lineno
-        filename = self.canonic(frame.f_code.co_filename)
-        s = '%s(%r)' % (filename, lineno)
-        if frame.f_code.co_name:
-            s += frame.f_code.co_name
-        else:
-            s += "<lambda>"
-        s += '()'
-        if '__return__' in frame.f_locals:
-            rv = frame.f_locals['__return__']
-            s += '->'
-            s += reprlib.repr(rv)
-        line = linecache.getline(filename, lineno, frame.f_globals)
-        if line:
-            s += lprefix + line.strip()
-        return s
+        return repr(frame.f_code)
+        ## MPY: linecache, reprlib, f_locals not yet available
+        # import linecache, reprlib
+        # frame, lineno = frame_lineno
+        # filename = self.canonic(frame.f_code.co_filename)
+        # s = '%s(%r)' % (filename, lineno)
+        # if frame.f_code.co_name:
+        #     s += frame.f_code.co_name
+        # else:
+        #     s += "<lambda>"
+        # s += '()'
+        # if '__return__' in frame.f_locals:
+        #     rv = frame.f_locals['__return__']
+        #     s += '->'
+        #     s += reprlib.repr(rv)
+        # line = linecache.getline(filename, lineno, frame.f_globals)
+        # if line:
+        #     s += lprefix + line.strip()
+        # return s
 
     # The following methods can be called by clients to use
     # a debugger to debug a statement or an expression.
@@ -628,7 +652,7 @@ def runctx(self, cmd, globals, locals):
 
     # This method is more useful to debug a single function call.
 
-    def runcall(self, func, /, *args, **kwds):
+    def runcall(self, func, *args, **kwds):
         """Debug a single function call.
 
         Return the result of the function call.