Split out print routines from cmdproc

Author: rocky

trepan/lib/core.py

@@ -289,7 +289,10 @@ def is_break_here(self, frame):
                 if not isinstance(fn, str):
                     fn = fn.__name__
                 if fn == find_name:
-                    self.current_bp = bp = self.bpmgr.fnlist[fn][0]
+                    bp_fn = self.bpmgr.fnlist.get(fn)
+                    if not bp_fn:
+                        return False
+                    self.current_bp = bp = bp_fn[0]
                     if bp.temporary:
                         msg = "temporary "
                         self.bpmgr.delete_breakpoint(bp)

trepan/processor/cmdproc.py

@@ -15,14 +15,14 @@
 #
 #   You should have received a copy of the GNU General Public License
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 import importlib
 import inspect
 import linecache
 import os.path as osp
 import re
 import shlex
 import sys
-import tempfile
 import traceback
 
 # Note: the module name pre 3.2 is repr
@@ -36,25 +36,13 @@
 import trepan.exception as Mexcept
 import trepan.lib.display as Mdisplay
 import trepan.lib.file as Mfile
-import trepan.lib.stack as Mstack
 import trepan.lib.thred as Mthread
 import trepan.misc as Mmisc
-import trepan.processor.complete as Mcomplete
 from trepan.lib.bytecode import is_class_def, is_def_stmt
-from trepan.processor import cmdfns
-from trepan.processor.cmdfns import deparse_fn
+from trepan.processor.complete import completer
+from trepan.processor.print import print_location
 from trepan.vprocessor import Processor
 
-try:
-    from trepan.lib.deparse import deparse_and_cache
-
-    have_deparse_and_cache = True
-except ImportError:
-    have_deparse_and_cache = False
-    pass
-
-warned_file_mismatches = set()
-
 
 def get_srcdir() -> str:
     filename = osp.normcase(osp.dirname(osp.abspath(__file__)))
@@ -152,245 +140,6 @@ def resolve_name(obj, command_name) -> Optional[str]:
     return
 
 
-def print_source_line(msg, lineno, line, event_str=None):
-    """Print out a source line of text , e.g. the second
-    line in:
-        (/tmp.py:2):  <module>
-        L -- 2 import sys,os
-        (trepan3k)
-
-    We define this method
-    specifically so it can be customized for such applications
-    like ipython."""
-
-    # We don't use the filename normally. ipython and other applications
-    # however might.
-    return msg("%s %d %s" % (event_str, lineno, line))
-
-
-def print_source_location_info(
-    print_fn, filename, lineno, fn_name=None, f_lasti=None, remapped_file=None
-):
-    """Print out a source location , e.g. the first line in
-    line in:
-        (/tmp.py:2 @21):  <module>
-        L -- 2 import sys,os
-        (trepan3k)
-    """
-    if remapped_file and filename != remapped_file:
-        mess = f"({remapped_file}:{lineno} remapped {filename}"
-    else:
-        mess = f"({filename}:{lineno}"
-    if f_lasti and f_lasti != -1:
-        mess += " @%d" % f_lasti
-        pass
-    mess += "):"
-    if fn_name and fn_name != "?":
-        mess += f" {fn_name}"
-        pass
-    print_fn(mess)
-    return
-
-
-def print_location(proc_obj):
-    """Show where we are. GUI's and front-end interfaces often
-    use this to update displays. So it is helpful to make sure
-    we give at least some place that's located in a file.
-    """
-    i_stack = proc_obj.curindex
-    if i_stack is None or proc_obj.stack is None:
-        return False
-    core_obj = proc_obj.core
-    dbgr_obj = proc_obj.debugger
-    intf_obj = dbgr_obj.intf[-1]
-
-    # Evaluation routines like "exec" don't show useful location
-    # info. In these cases, we will use the position before that in
-    # the stack.  Hence the looping below which in practices loops
-    # once and sometimes twice.
-    remapped_file = None
-    source_text = None
-    while i_stack >= 0 and len(proc_obj.stack) > 0:
-        frame, lineno = proc_obj.stack[i_stack]
-
-        # Before starting a program a location for a module with
-        # line number 0 may be reported. Treat that as though
-        # we were on the first line.
-        if frame.f_code.co_name == "<module>" and lineno == 0:
-            lineno = 1
-
-        i_stack -= 1
-
-        #         # Next check to see that local variable breadcrumb exists and
-        #         # has the magic dynamic value.
-        #         # If so, it's us and we don't normally show this.a
-        #         if 'breadcrumb' in frame.f_locals:
-        #             if self.run == frame.f_locals['breadcrumb']:
-        #                 break
-
-        filename = Mstack.frame2file(core_obj, frame, canonic=False)
-        if "<string>" == filename and dbgr_obj.eval_string:
-            remapped_file = filename
-            filename = pyficache.unmap_file(filename)
-            if "<string>" == filename:
-                remapped = cmdfns.source_tempfile_remap(
-                    "eval_string",
-                    dbgr_obj.eval_string,
-                    tempdir=proc_obj.settings("tempdir"),
-                )
-                pyficache.remap_file(filename, remapped)
-                filename, lineno = pyficache.unmap_file_line(filename, lineno)
-                pass
-            pass
-        elif "<string>" == filename:
-            source_text = deparse_fn(frame.f_code)
-            filename = f"<string: '{source_text}'>"
-            pass
-        else:
-            m = re.search("^<frozen (.*)>", filename)
-            if m and m.group(1) in pyficache.file2file_remap:
-                remapped_file = pyficache.file2file_remap[m.group(1)]
-                pass
-            elif filename in pyficache.file2file_remap:
-                remapped_file = pyficache.file2file_remap[filename]
-                filename = remapped_file
-                pass
-            elif pyficache.main.remap_re_hash:
-                remapped_file = pyficache.remap_file_pat(
-                    filename, pyficache.main.remap_re_hash
-                )
-            elif m and m.group(1) in sys.modules:
-                remapped_file = m.group(1)
-                pyficache.remap_file(filename, remapped_file)
-            pass
-
-        opts = {
-            "reload_on_change": proc_obj.settings("reload"),
-            "output": proc_obj.settings("highlight"),
-        }
-
-        if proc_obj.debugger.settings.get("highlight", "plain") == "plain":
-            opts["style"] = "plain"
-        elif "style" in proc_obj.debugger.settings:
-            opts["style"] = proc_obj.settings("style")
-
-        pyficache.update_cache(filename)
-        line = pyficache.getline(filename, lineno, opts)
-        if not line:
-            if (
-                not source_text
-                and filename.startswith("<string: ")
-                and proc_obj.curframe.f_code
-                and have_deparse_and_cache
-            ):
-                # Deparse the code object into a temp file and remap the line from code
-                # into the corresponding line of the tempfile
-                co = proc_obj.curframe.f_code
-                tempdir = proc_obj.settings("tempdir")
-                temp_filename, name_for_code = deparse_and_cache(
-                    co, proc_obj.errmsg, tempdir=tempdir
-                )
-                lineno = 1
-                # _, lineno = pyficache.unmap_file_line(temp_filename, lineno, True)
-                if temp_filename:
-                    filename = temp_filename
-                pass
-
-            else:
-                # FIXME:
-                if source_text:
-                    lines = source_text.split("\n")
-                    temp_name = "string-"
-                else:
-                    # try with good ol linecache and consider fixing pyficache
-                    lines = linecache.getlines(filename)
-                    temp_name = filename
-                if lines:
-                    # FIXME: DRY code with version in cmdproc.py print_location
-                    prefix = osp.basename(temp_name).split(".")[0]
-                    fd = tempfile.NamedTemporaryFile(
-                        suffix=".py",
-                        prefix=prefix,
-                        delete=False,
-                        dir=proc_obj.settings("tempdir"),
-                    )
-                    with fd:
-                        fd.write("".join(lines).encode("utf-8"))
-                        remapped_file = fd.name
-                        pyficache.remap_file(remapped_file, filename)
-                    fd.close()
-                    intf_obj.msg(f"remapped file {filename} to {remapped_file}")
-
-                    pass
-            line = linecache.getline(filename, lineno, proc_obj.curframe.f_globals)
-            if not line:
-                m = re.search("^<frozen (.*)>", filename)
-                if m and m.group(1):
-                    remapped_file = m.group(1)
-                    try_module = sys.modules.get(remapped_file)
-                    if (
-                        try_module
-                        and inspect.ismodule(try_module)
-                        and hasattr(try_module, "__file__")
-                    ):
-                        remapped_file = sys.modules[remapped_file].__file__
-                        pyficache.remap_file(filename, remapped_file)
-                        line = linecache.getline(
-                            remapped_file, lineno, proc_obj.curframe.f_globals
-                        )
-                    else:
-                        remapped_file = m.group(1)
-                        code = proc_obj.curframe.f_code
-                        filename, line = cmdfns.deparse_getline(
-                            code, remapped_file, lineno, opts
-                        )
-                    pass
-            pass
-
-        try:
-            match, reason = Mstack.check_path_with_frame(frame, filename)
-            if not match:
-                if filename not in warned_file_mismatches:
-                    proc_obj.errmsg(reason)
-                    warned_file_mismatches.add(filename)
-        except Exception:
-            pass
-
-        fn_name = frame.f_code.co_name
-        last_i = frame.f_lasti
-        print_source_location_info(
-            intf_obj.msg,
-            filename,
-            lineno,
-            fn_name,
-            remapped_file=remapped_file,
-            f_lasti=last_i,
-        )
-        if line and len(line.strip()) != 0:
-            if proc_obj.event:
-                print_source_line(
-                    intf_obj.msg, lineno, line, proc_obj.event2short[proc_obj.event]
-                )
-            pass
-        if "<string>" != filename:
-            break
-        pass
-
-    if proc_obj.event in ["return", "exception"]:
-        val = proc_obj.event_arg
-        intf_obj.msg(f"R=> {proc_obj._saferepr(val)}")
-        pass
-    elif (
-        proc_obj.event == "call"
-        and proc_obj.curframe.f_locals.get("__name__", "") != "__main__"
-    ):
-        try:
-            proc_obj.commands["info"].run(["info", "locals"])
-        except Exception:
-            pass
-    return True
-
-
 # Default settings for command processor method call
 DEFAULT_PROC_OPTS = {
     # A list of debugger initialization files to read on first command
@@ -432,7 +181,7 @@ def get_option_fn(key):
         # command name before alias or macro resolution
         self.cmd_name = ""
         self.cmd_queue = []  # Queued debugger commands
-        self.completer = lambda text, state: Mcomplete.completer(self, text, state)
+        self.completer = lambda text, state: completer(self, text, state)
         self.current_command = ""  # Current command getting run
         self.debug_nest = 1
         self.display_mgr = Mdisplay.DisplayMgr()