Revise breakpoint handling (#73)

* Track down code in breakpoint command WARNING -- needs a new filecache API for this.
* Fix up list command range parsing
* Use github for pyficache in CI

Author: rocky

.circleci/config.yml

@@ -20,7 +20,7 @@ jobs:
       # - run: pip install --local -e git+https://github.com/rocky/pytracer.git#egg=tracer
       # Until the next pyficache release
       # - run: pip install pyficache
-      # - run: pip install --local -e git+https://github.com/rocky/python-filecache.git#egg=pyficache
+      - run: pip install --local -e git+https://github.com/rocky/python-filecache.git#egg=pyficache
       - run: pip install uncompyle6
       # - run: pip install --local -e git+https://github.com/rocky/python-decompile3.git#egg=decompyle3
       - run: pip install --local -e .

.github/workflows/ubuntu-prompt-toolkit.yml

@@ -26,7 +26,7 @@ jobs:
         # Until the next pytracer release
         # pip install git+https://github.com/rocky/pytracer#egg=tracer
         # Until the next pyficache release
-        # pip install git+https://github.com/rocky/python-filecache#egg=pyficache
+        pip install git+https://github.com/rocky/python-filecache#egg=pyficache
         pip install -e .[dev,full]
     - name: Test trepan3k
       run: |

.github/workflows/ubuntu.yml

@@ -26,7 +26,7 @@ jobs:
         # Until the next pytracer release
         # pip install git+https://github.com/rocky/pytracer#egg=tracer
         # Until the next pyficache release
-        # pip install git+https://github.com/rocky/python-filecache#egg=pyficache
+        pip install git+https://github.com/rocky/python-filecache#egg=pyficache
         pip install -e .[dev]
     - name: Test trepan3k
       run: |

test/unit/lib/test_lib_brkpt.py

@@ -20,7 +20,7 @@ def bar():
     bpmgr = BreakpointManager()
     assert 0 == bpmgr.last()
     line_number = foo.__code__.co_firstlineno
-    bp = bpmgr.add_breakpoint(__file__, line_number, 0, func=foo)
+    bp = bpmgr.add_breakpoint(__file__, line_number, 0, func_or_code=foo)
 
     assert re.search(r"1\s+breakpoint\s+keep\s+yes .*0 at.*%d" % line_number, str(bp)), str(bp)
     assert "B" == bp.icon_char()
@@ -41,14 +41,14 @@ def bar():
         "Breakpoint 1 previously deleted.",
     )
     line_number = test_breakpoint.__code__.co_firstlineno
-    bp2 = bpmgr.add_breakpoint(__file__, line_number, 0, func=test_breakpoint, temporary=True)
+    bp2 = bpmgr.add_breakpoint(__file__, line_number, 0, func_or_code=test_breakpoint, temporary=True)
     assert "t" == bp2.icon_char()
     assert ["2"] == bpmgr.bpnumbers(), "Extracting breakpoint-numbers"
 
     count = 3
     line_number = bar.__code__.co_firstlineno
     for _ in range(count):
-        bp = bpmgr.add_breakpoint(__file__, line_number, 0, func=bar)
+        bp = bpmgr.add_breakpoint(__file__, line_number, 0, func_or_code=bar)
     filename = bp.filename
     assert count == len(
         bpmgr.delete_breakpoints_by_lineno(os.path.realpath(filename), line_number)
@@ -64,7 +64,7 @@ def test_checkfuncname():
 
     bpmgr = BreakpointManager()
     frame = inspect.currentframe()
-    bp = bpmgr.add_breakpoint(__file__, frame.f_lineno + 1, -1, func=test_checkfuncname)
+    bp = bpmgr.add_breakpoint(__file__, frame.f_lineno + 1, -1, func_or_code=test_checkfuncname)
     assert checkfuncname(bp, frame)
 
     def foo(brkpt, bpmgr):
@@ -73,12 +73,12 @@ def foo(brkpt, bpmgr):
         # current_frame.f_lineno is constantly updated. So adjust for line
         # the difference between the add_breakpoint and the check.
         bp3 = bpmgr.add_breakpoint(
-            os.path.realpath(__file__), current_frame.f_lineno + 2, -1, False, func=foo
+            os.path.realpath(__file__), current_frame.f_lineno + 2, -1, False, func_or_code=foo
         )
         assert checkfuncname(bp3, current_frame), str(bp3)
         assert not checkfuncname(bp3, current_frame)
         return
 
-    bp2 = bpmgr.add_breakpoint(__file__, None, -1, False, None, func=foo)
+    bp2 = bpmgr.add_breakpoint(__file__, None, -1, False, None, func_or_code=foo)
     foo(bp2, bpmgr)
     return

test/unit/lib/test_lib_complete.py

@@ -61,7 +61,7 @@ def test_next_token():
 def test_complete_brkpts():
     bpmgr = BreakpointManager()
     frame = inspect.currentframe()
-    bp = bpmgr.add_breakpoint(__file__, frame.f_lineno, 10, func=test_complete_brkpts)
+    bp = bpmgr.add_breakpoint(__file__, frame.f_lineno, 10, func_or_code=test_complete_brkpts)
     assert bp
     for find in "1":
         assert complete_brkpts(bpmgr, find) == [

test/unit/processor/command/test_cmd_break.py

@@ -1,10 +1,9 @@
 """Unit test for trepan.processor.command.break"""
 
 import os
-import platform
 from test.unit.cmdhelper import errmsg, msg, reset_output, setup_unit_test_debugger
 
-from trepan.processor.cmdbreak import parse_break_cmd
+from trepan.processor.cmdbreak import INVALID_PARSE_BREAK, parse_break_cmd
 
 # We have to use this subterfuge because "break" is Python reserved word,
 # so it can't be used as a module-name component.
@@ -37,17 +36,13 @@ def test_parse_break_cmd():
     assert (expected_code, None, True, True) == (code, cond, li > 1, offset > 0)
     assert fi.endswith(__file__)
 
-    code, fi, li, cond, offset = parse_break_cmd_wrapper(proc, "break 11")
-    assert isinstance(fi, str)
-    assert (expected_code, None, 11, None) == (code, cond, li, offset)
+    result = parse_break_cmd_wrapper(proc, "break 2")
+    assert result == INVALID_PARSE_BREAK
 
-    if platform.system() == "Windows":
-        brk_cmd = f'b """{__file__}""":8'
-    else:
-        brk_cmd = f"b {__file__}:8"
+    brk_cmd = f'b """{__file__}""":1'
 
     code, fi, li, cond, offset = parse_break_cmd_wrapper(proc, brk_cmd)
-    assert (True, 8) == (isinstance(fi, str), li)
+    assert (__file__, 1) == (fi, li)
     # FIXME: This varies. Why?
     # assert "<module>" == code
 

trepan/lib/breakpoint.py

@@ -7,6 +7,7 @@
 __all__ = ["BreakpointManager", "Breakpoint"]
 
 import os.path as osp
+from collections import defaultdict
 from types import CodeType, ModuleType
 from typing import Optional
 from xdis import load_module
@@ -138,8 +139,8 @@ def __init__(self):
         # class unless it is put inside __init__
 
         self.bpbynumber: list = [None]
-        self.bplist = {}
-        self.code_list = {}
+        self.bplist = defaultdict(list)
+        self.code_list = defaultdict(list)
         return
 
     def bpnumbers(self):
@@ -174,7 +175,7 @@ def add_breakpoint(
         offset: int = -1,
         temporary: bool = False,
         condition: Optional[str] = None,
-        func = None,
+        func_or_code = None,
     ):
         """
         Add a breakpoint in ``filename`` at line number ``lineno``.
@@ -188,41 +189,33 @@ def add_breakpoint(
             filename = osp.realpath(filename)
 
         assert (
-            isinstance(filename, str) or func is not None
+            isinstance(filename, str) or func_or_code is not None
         ), "You must either supply a filename or give a line number"
 
-        if isinstance(func, CodeType):
-            code = func
-        elif isinstance(func, ModuleType):
-            if hasattr(func, "__cached__"):
+        if isinstance(func_or_code, CodeType):
+            code = func_or_code
+        elif isinstance(func_or_code, ModuleType):
+            if hasattr(func_or_code, "__cached__"):
                 # FIXME: we can probably do better hooking into importlib
                 # or something lower-level
-                _, _, _, code, _, _, _ = load_module(func.__cached__, fast_load=True, get_code=True)
+                _, _, _, code, _, _, _ = load_module(func_or_code.__cached__, fast_load=True, get_code=True)
             else:
-                print(f"Don't know what to do with frozen module {func}")
+                print(f"Don't know what to do with frozen module {func_or_code}")
                 return
-        elif hasattr(func, "__code__"):
-            code = func.__code__
-        elif hasattr(func, "f_code"):
-            code = func.f_code
+        elif hasattr(func_or_code, "__code__"):
+            code = func_or_code.__code__
+        elif hasattr(func_or_code, "f_code"):
+            code = func_or_code.f_code
         else:
-            print(f"Don't know what to do with {func}, {type(func)}")
+            print(f"Don't know what to do with {func_or_code}, {type(func_or_code)}")
             return
         brkpt = Breakpoint(bpnum, filename, lineno, temporary, condition, code, offset)
 
         # Build the internal lists of breakpoints
         self.bpbynumber.append(brkpt)
-        if (filename, lineno) in self.bplist:
-            self.bplist[filename, lineno].append(brkpt)
-        else:
-            self.bplist[filename, lineno] = [brkpt]
-            pass
-        if func and offset in [None, -1]:
-            if code in self.code_list:
-                self.code_list[code].append(brkpt)
-            else:
-                self.code_list[code] = [brkpt]
-                pass
+        self.bplist[filename, lineno].append(brkpt)
+        if func_or_code and offset in [None, -1]:
+            self.code_list[code].append(brkpt)
         return brkpt
 
     def delete_all_breakpoints(self) -> str:

trepan/misc.py

@@ -15,8 +15,10 @@
 #   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 inspect
 import os
 from glob import glob
+from types import CodeType
 from typing import Any
 
 
@@ -55,7 +57,11 @@ def wrapped_lines(msg_part1: str, msg_part2: str, width: int) -> str:
 
 
 def pretty_modfunc_name(s) -> str:
-    if s == "<module>":
+    if isinstance(s, CodeType):
+        return f"{s.co_name}()"
+    elif inspect.isfunction(s):
+        return f"{s.__name__}()"
+    elif str(s).startswith("<"):
         # FIXME:
         # Pick replace with something more custom to modname?
         return str(s)
@@ -91,4 +97,6 @@ def get_option(key):
     print(wrapped_lines("hi", "there", 80))
     print(wrapped_lines("hi", "there", 5))
     print(pyfiles(__file__))
+    print(pretty_modfunc_name(pretty_modfunc_name.__code__))
+    print(pretty_modfunc_name(pyfiles))
     pass

trepan/processor/cmdbreak.py

@@ -26,7 +26,7 @@
 
 def set_break(
     cmd_obj,
-    func,
+    func_or_code,
     filename,
     lineno,
     condition,
@@ -48,7 +48,9 @@ def set_break(
         pass
 
     if lineno:
-        line_info = code_line_info(filename, lineno)
+        code_map, line_info = code_line_info(filename, lineno)
+        if isinstance(func_or_code, str):
+            func_or_code = code_map.get(func_or_code, func_or_code)
         if not line_info:
             linestarts = dict(findlinestarts(cmd_obj.proc.curframe.f_code))
             if lineno not in linestarts.values():
@@ -87,23 +89,30 @@ def set_break(
         offset=offset,
         temporary=temporary,
         condition=condition,
-        func=func,
+        func_or_code=func_or_code,
     )
-    if func and inspect.isfunction(func):
-        cmd_obj.msg(f"Breakpoint {bp.number} set on calling function {func.__name__}()")
+    if func_or_code and inspect.isfunction(func_or_code):
+        cmd_obj.msg(f"Breakpoint {bp.number} set on calling function {func_or_code.__name__}()")
         part1 = f"Currently this is line {lineno} of file"
         msg = wrapped_lines(
             part1, cmd_obj.core.filename(filename), cmd_obj.settings["width"]
         )
         cmd_obj.msg(msg)
     else:
-        part1 = f"Breakpoint {bp.number} set at line {lineno} of file"
+        if hasattr(func_or_code, "co_name"):
+            code_name = func_or_code.co_name
+            if not code_name.startswith("<"):
+                code_name += "()"
+            func_str = f" in {code_name}"
+        else:
+            func_str = ""
+        part1 = f"Breakpoint {bp.number} set at line {lineno}{func_str} of file"
         msg = wrapped_lines(
             part1, cmd_obj.core.filename(filename), cmd_obj.settings["width"]
         )
         cmd_obj.msg(msg)
-        if func:
-            func_str = f" of {pretty_modfunc_name(func)}"
+        if func_or_code:
+            func_str = f" of {pretty_modfunc_name(func_or_code)}"
         else:
             func_str = ""
         if offset is not None and offset >= 0:
@@ -175,18 +184,27 @@ def parse_break_cmd(proc, args):
     # print '-' * 10
     cmdproc.frame = sys._getframe()
     cmdproc.setup()
+    # FIXME: we should not need ot set setting
+    cmdproc.settings = d.settings
+    set_break(cmdproc, "set_break", __file__, 50, True, False, [])
     for cmd in (
         "break '''c:\\tmp\\foo.bat''':1",
         'break """/Users/My Documents/foo.py""":2',
         "break",
         "break 10",
         "break if True",
-        "break cmdproc.py:5",
+        f"break {__file__}:5",
+        f"break {__file__}:{cmdproc.frame.f_lineno}",
         "break set_break()",
         "break 4 if i==5",
-        # "break cmdproc.setup()",
+        "break cmdproc.setup()",
     ):
         args = cmd.split(" ")
         cmdproc.current_command = cmd
-        print(parse_break_cmd(cmdproc, args))
+        print(f"cmd: {cmd}")
+        break_info = parse_break_cmd(cmdproc, args)
+        print(break_info)
+        if break_info != INVALID_PARSE_BREAK:
+            code, filename, line_number, condition, offset = break_info
+            set_break(cmdproc, code, filename, line_number, condition, False, [], offset=offset)
     pass

trepan/processor/cmdlist.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from trepan.lib.stack import frame2file
 from trepan.processor.location import resolve_location
 from trepan.processor.parse.parser import LocationError
 from trepan.processor.parse.scanner import ScannerError
@@ -90,10 +91,20 @@ def parse_list_cmd(proc, args, listsize=10):
         else:
             # First is location. Last may be empty or a number
             assert isinstance(list_range.first, Location)
-            location = resolve_location(proc, list_range.first)
-            if not location:
-                return INVALID_PARSE_LIST
-            first = location.line_number
+            first = list_range.first.line_number
+            if list_range.first.path is None:
+                if list_range.first.method is None:
+                    filename = frame2file(proc.core, proc.curframe, canonic=False)
+                else:
+                    location = resolve_location(proc, list_range.first)
+                    if location is None or location == INVALID_PARSE_LOCATION:
+                        return INVALID_PARSE_LIST
+                    filename = location.path
+                    if first is None:
+                        first = location.line_number
+            else:
+                filename = list_range.first.path
+
             last = list_range.last
             # if location.method:
             #     first -= listsize // 2
@@ -109,7 +120,7 @@ def parse_list_cmd(proc, args, listsize=10):
                 # Treat as a count rather than an absolute location
                 last = first + last
 
-            return location.path, first, last
+            return filename, first, last
         pass
     return