Handle -m parsing better

We ignore options after -m module name and preserve that to for
module argument parsing.

Beef up options.

Author: rocky

test/unit/test_options.py

@@ -44,18 +44,31 @@ def test_options():
     dbg, _ = setup_unit_test_debugger()
     dbg_opts_set = {"proc_opts", "from_ipython"}
 
+    print("\n1: no options: trepan3k")
+
     # Test with no options. See that we have the some expected
     # keys getting set.
-    opts, dbg_opts, sys_argv = process_options("1.0", [__file__])
+    opts, dbg_opts, sys_argv = process_options("1", ["trepan3k"])
     diff_set = option_key_set - set(vars(opts).keys())
     assert diff_set == set(), "expecting at least these options keys set"
     assert (
         dbg_opts_set - set(dbg_opts.keys())
     ) == set(), "expecting at least these processor keys set"
+    assert sys.argv == [], "expecting all of sys.argv to be consumed"
+
+    print("2: trepan3k with program and argument")
+
+    opts, dbg_opts, sys_argv = process_options("2", ["trepan3k foo bar"])
+    assert diff_set == set(), "expecting at least these options keys set"
+    assert (
+        dbg_opts_set - set(dbg_opts.keys())
+    ) == set(), "expecting at least these processor keys set"
+    assert sys.argv == [], "expecting all of sys.argv to be consumed"
+
+    print("3: trepan3k more one option. A boolean option option with string argument")
 
-    # Try with more than one option, a boolean option and a string option.
-    arg_str = f"{__file__} --fntrace --cd=/tmp"
-    opts, dbg_opts, sys_argv = process_options("1.1", arg_str.split())
+    arg_str = "trepan3k --fntrace --cd=/tmp"
+    opts, dbg_opts, sys_argv = process_options("3", arg_str.split())
     assert opts.cd == "/tmp"
     postprocess_options(dbg, opts)
     assert dbg.settings["printset"] == frozenset(
@@ -64,7 +77,15 @@ def test_options():
 
     # Try with an invalid style option and see that it is
     # rejected in postprocess option
-    arg_str = f"{__file__} --style=fafdsaXYZZY"
-    opts, dbg_opts, sys_argv = process_options("1.3", arg_str.split())
+    print("4: trepan3k with invalid style")
+    arg_str = "trepan3k --style=fafdsaXYZZY"
+    opts, dbg_opts, sys_argv = process_options("4", arg_str.split())
     postprocess_options(dbg, opts)
+
     # FIXME figure out a reasonable test for postprocess_options()
+
+    print("5: trepan3k with -m (module) and arguments to module")
+    arg_str = "trepan3k --trace -m dis --host 0.0.0.0"
+    opts, dbg_opts, sys_argv = process_options("5", arg_str.split())
+    assert sys_argv == ['--host', '0.0.0.0']
+    assert opts.module == "dis", "should have found module name"

trepan/__main__.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: iso-8859-1 -*-
-#   Copyright (C) 2008-2010, 2013-2018, 2020-2025 Rocky Bernstein
+#   Copyright (C) 2008-2010, 2013-2018, 2020-2026 Rocky Bernstein
 #   <[email protected]>
 #
 #   This program is free software: you can redistribute it and/or modify
@@ -80,13 +80,20 @@ def main(dbg=None, sys_argv=list(sys.argv)):
     # options that belong to this debugger. The original options to
     # invoke the debugger and script are in global sys_argv
 
+    if opts.module is not None:
+        mainpyfile = opts.module
+        if len(sys_argv) == 0:
+            sys_argv.append(mainpyfile)
+        else:
+            sys_argv[0] = mainpyfile
+
     if len(sys_argv) == 0:
         # No program given to debug. Set to go into a command loop
         # anyway
         mainpyfile = None
     else:
         mainpyfile = sys_argv[0]  # Get script filename.
-        if not osp.isfile(mainpyfile):
+        if not osp.isfile(mainpyfile) and opts.module is None:
             mainpyfile = whence_file(mainpyfile)
             is_readable = readable(mainpyfile)
             if is_readable is None:
@@ -264,8 +271,10 @@ def write_wrapper(*args, **kwargs):
         # use non-optimized alternative.
         mainpyfile_noopt = pyficache.resolve_name_to_path(mainpyfile)
         if mainpyfile != mainpyfile_noopt and readable(mainpyfile_noopt):
-            print(f"{__title__}: Compiled Python script given and we can't use that.")
-            print(f"{__title__}: Substituting non-compiled name: {mainpyfile_noopt}")
+            if opts.module is None:
+                # We are not debugging module.
+                print(f"{__title__}: Compiled Python script given and we can't use that.")
+                print(f"{__title__}: Substituting non-compiled name: {mainpyfile_noopt}")
             mainpyfile = mainpyfile_noopt
             pass
 
@@ -287,7 +296,7 @@ def write_wrapper(*args, **kwargs):
         # right.
 
         try:
-            if dbg.program_sys_argv and mainpyfile:
+            if (dbg.program_sys_argv or opts.module) and mainpyfile:
                 normal_termination = dbg.run_script(mainpyfile)
                 if not normal_termination:
                     break

trepan/options.py

@@ -1,5 +1,5 @@
 # -*- coding: iso-8859-1 -*-
-#   Copyright (C) 2013-2015, 2023-2025 Rocky Bernstein <[email protected]>
+#   Copyright (C) 2013-2015, 2023-2026 Rocky Bernstein <[email protected]>
 #
 #   This program is free software: you can redistribute it and/or modify
 #   it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import codecs
+import importlib
 import os
 import sys
 from optparse import OptionParser
@@ -208,6 +209,14 @@ def process_options(pkg_version: str, sys_argv: list, option_list=None):
         help="Don't register this as a global debugger.",
     )
 
+    optparser.add_option(
+        "-m",
+        dest="module",
+        action="store",
+        type="string",
+        metavar="module",
+        help="Run library module as a script.",
+    )
     optparser.add_option(
         "--main",
         dest="main",
@@ -353,8 +362,17 @@ def process_options(pkg_version: str, sys_argv: list, option_list=None):
 
     sys.argv = sys_argv
 
-    # Here is where we *parse* arguments
-    (opts, sys.argv) = optparser.parse_args(sys_argv[1:])
+    # If the -m option is present, only parse options before it and
+    # leave -m and the following module/args alone.
+    if "-m" in sys_argv[1:]:
+        m_index_end = sys_argv.index("-m") + 2
+        # Parse only the arguments before '-m mod'
+        (opts, _) = optparser.parse_args(sys_argv[1:m_index_end])
+        # Preserve the -m and everything after as the script/module args
+        sys.argv = sys_argv[m_index_end :]
+    else:
+        # Here is where we *parse* arguments
+        (opts, sys.argv) = optparser.parse_args(sys_argv[1:])
 
     if opts.edit_mode not in ("vi", "emacs"):
         sys.stderr.write(
@@ -410,6 +428,21 @@ def process_options(pkg_version: str, sys_argv: list, option_list=None):
             sys.exit(2)
         pass
 
+    if opts.module:
+        try:
+            module = importlib.import_module(opts.module)
+            if module.__file__.endswith("__init__.py"):
+                main_module = f"{opts.module}.__main__"
+                importlib.import_module(main_module)
+                opts.module = main_module
+        except ImportError:
+            print(f"No module named {opts.module}")
+            sys.exit(3)
+        except Exception as e:
+            print(f"Unexpected exception importing {opts.module}:\n\t{e}")
+            sys.exit(4)
+        pass
+
     return opts, dbg_opts, sys.argv
 
 
@@ -483,19 +516,39 @@ def postprocess_options(dbg, opts):
     import pprint
 
     def doit(version, arg_str):
-        print(f"options '{arg_str}'")
+        print(f"Test {version}")
+        print(f"options: '{arg_str}':")
         args = arg_str.split()
         opts, _, _ = process_options(version, args)
         pp.pprint(vars(opts))
+        print(f"sys.argv: {sys.argv})")
         print("")
         return
 
     pp = pprint.PrettyPrinter(indent=4)
-    doit("1.1", "__file__")
-    doit("1.2", f"{__file__} foo bar")
-    doit("1.3", f"{__file__} --server")
-    doit("1.3", f"{__file__} --command {__file__} bar baz")
-    doit("1.4", f"{__file__} --server --client")
-    doit("1.5", f"{__file__} --style=emacs")
-    doit("1.6", f"{__file__} --help")  # exits, so must be last
+
+    doit("1: no options.",
+         "trepan3k")
+    doit("2; program and argument",
+         "trepan3k foo bar")
+    doit("3: one trepan3k option",
+         "trepan3k --server")
+
+    doit("4: --command option",
+         f"trepan3k --command {__file__} bar baz")
+
+    doit("5", "trepan3k --server --client")
+    doit("6", "trepan3k --style=emacs")
+
+    # -F bytes foo.pyc should be passed to pydisasm
+    doit("7: trepan3k option with program having its own options",
+         "trepan3k --trace pydisasm -F bytes foo.pyc")
+
+    # Options after -m pydebug should be passed to pydebug
+    doit("8: -m option with arguments to module",
+         "trepan3k --trace -m dis --host 0.0.0.0")
+
+    # --help exits, so must be last
+    doit("9: show help",
+         "trepan3k --help")
     pass