def parse_position(errmsg, arg):
"""parse_position(errmsg, arg)->(fn, name, lineno)
Parse arg as [filename|module:]lineno
Make sure it works for C:\foo\bar.py:12
"""
colon = arg.rfind(":")
if colon >= 0:
filename = arg[:colon].rstrip()
m, f = lookupmodule(filename)
if not f:
errmsg("'%s' not found using sys.path" % filename)
return (None, None, None)
else:
filename = pyficache.resolve_name_to_path(f)
arg = arg[colon + 1:].lstrip()
pass
try:
lineno = int(arg)
except TypeError:
errmsg("Bad line number: %s", str(arg))
return (None, filename, None)
return (None, filename, lineno)
return (None, None, None)
def main(dbg=None, sys_argv=list(sys.argv)):
"""Routine which gets run if we were invoked directly"""
# Save the original just for use in the restart that works via exec.
orig_sys_argv = list(sys_argv)
opts, dbg_opts, sys_argv = Moptions.process_options(
__title__, __version__, sys_argv)
if opts.server:
connection_opts = {"IO": "TCP", "PORT": opts.port}
intf = Mserver.ServerInterface(connection_opts=connection_opts)
dbg_opts["interface"] = intf
if "FIFO" == intf.server_type:
print("Starting FIFO server for process %s." % os.getpid())
elif "TCP" == intf.server_type:
print("Starting TCP server listening on port %s." %
intf.inout.PORT)
pass
elif opts.client:
Mclient.main(opts, sys_argv)
return
dbg_opts["orig_sys_argv"] = orig_sys_argv
if dbg is None:
dbg = Mdebugger.Debugger(dbg_opts)
dbg.core.add_ignore(main)
pass
Moptions._postprocess_options(dbg, opts)
# process_options has munged sys.argv to remove any options that
# options that belong to this debugger. The original options to
# invoke the debugger and script are in global sys_argv
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):
mainpyfile = Mclifns.whence_file(mainpyfile)
is_readable = Mfile.readable(mainpyfile)
if is_readable is None:
sys.stderr.write(
"%s: Python script file '%s' does not exist\n" %
(__title__, mainpyfile))
sys.exit(1)
elif not is_readable:
sys.stderr.write("%s: Can't read Python script file '%s'\n" % (
__title__,
mainpyfile,
))
sys.exit(1)
return
if Mfile.is_compiled_py(mainpyfile):
try:
from xdis import load_module
from xdis_version import load_module, PYTHON_VERSION_TRIPLE, IS_PYPY, version_tuple_to_str
(
python_version,
timestamp,
magic_int,
co,
is_pypy,
source_size,
) = load_module(mainpyfile, code_objects=None, fast_load=True)
assert is_pypy == IS_PYPY
assert (
python_version == PYTHON_VERSION_TRIPLE
), "bytecode is for version %s but we are version %s" % (
python_version,
version_tuple_to_str(),
)
# We should we check version magic_int
py_file = co.co_filename
if osp.isabs(py_file):
try_file = py_file
else:
mainpydir = osp.dirname(mainpyfile)
dirnames = ([mainpydir] +
os.environ["PATH"].split(os.pathsep) + ["."])
try_file = Mclifns.whence_file(py_file, dirnames)
if osp.isfile(try_file):
mainpyfile = try_file
pass
else:
# Move onto the except branch
raise IOError(
"Python file name embedded in code %s not found" %
try_file)
except:
try:
from uncompyle6 import decompile_file
except ImportError:
sys.stderr.write(
"%s: Compiled python file '%s', but uncompyle6 not found\n"
% (__title__, mainpyfile))
sys.exit(1)
return
short_name = osp.basename(mainpyfile).strip(".pyc")
fd = tempfile.NamedTemporaryFile(
suffix=".py",
prefix=short_name + "_",
dir=dbg.settings["tempdir"],
delete=False,
)
try:
decompile_file(mainpyfile, outstream=fd)
mainpyfile = fd.name
fd.close()
except:
sys.stderr.write("%s: error uncompyling '%s'\n" %
(__title__, mainpyfile))
sys.exit(1)
pass
# If mainpyfile is an optimized Python script try to find and
# use non-optimized alternative.
mainpyfile_noopt = pyficache.resolve_name_to_path(mainpyfile)
if mainpyfile != mainpyfile_noopt \
and Mfile.readable(mainpyfile_noopt):
sys.stderr.write(
"%s: Compiled Python script given and we can't use that.\n" %
__title__)
sys.stderr.write("%s: Substituting non-compiled name: %s\n" %
(__title__, mainpyfile_noopt))
mainpyfile = mainpyfile_noopt
pass
# Replace trepan's dir with script's dir in front of
# module search path.
sys.path[0] = dbg.main_dirname = osp.dirname(mainpyfile)
# XXX If a signal has been received we continue in the loop, otherwise
# the loop exits for some reason.
dbg.sig_received = False
# if not mainpyfile:
# print('For now, you need to specify a Python script name!')
# sys.exit(2)
# pass
while True:
# Run the debugged script over and over again until we get it
# right.
try:
if dbg.program_sys_argv and mainpyfile:
normal_termination = dbg.run_script(mainpyfile)
if not normal_termination:
break
else:
dbg.core.execution_status = "No program"
dbg.core.processor.process_commands()
pass
dbg.core.execution_status = "Terminated"
dbg.intf[-1].msg("The program finished - quit or restart")
dbg.core.processor.process_commands()
except Mexcept.DebuggerQuit:
break
except Mexcept.DebuggerRestart:
dbg.core.execution_status = "Restart requested"
if dbg.program_sys_argv:
sys.argv = list(dbg.program_sys_argv)
part1 = "Restarting %s with arguments:" % dbg.core.filename(
mainpyfile)
args = " ".join(dbg.program_sys_argv[1:])
dbg.intf[-1].msg(
Mmisc.wrapped_lines(part1, args, dbg.settings["width"]))
else:
break
except SystemExit:
# In most cases SystemExit does not warrant a post-mortem session.
break
except:
# FIXME: Should be handled above without this mess
exception_name = str(sys.exc_info()[0])
if exception_name == str(Mexcept.DebuggerQuit):
break
elif exception_name == str(Mexcept.DebuggerRestart):
dbg.core.execution_status = "Restart requested"
if dbg.program_sys_argv:
sys.argv = list(dbg.program_sys_argv)
part1 = "Restarting %s with arguments:" % dbg.core.filename(
mainpyfile)
args = " ".join(dbg.program_sys_argv[1:])
dbg.intf[-1].msg(
Mmisc.wrapped_lines(part1, args,
dbg.settings["width"]))
pass
else:
raise
pass
# Restore old sys.argv
sys.argv = orig_sys_argv
return
def run(self, args):
proc = self.proc
dbg_obj = self.core.debugger
listsize = dbg_obj.settings['listsize']
filename, first, last = parse_list_cmd(proc, args, listsize)
curframe = proc.curframe
if filename is None: return
# Sometimes such as due to decompilation we might not really
# have an idea based on the listing where we really are.
# Setting "show_marks" to false will disable marking breakpoint
# and current line numbers.
show_marks = True
filename = pyficache.unmap_file(pyficache.resolve_name_to_path(filename))
if filename == "<string>" and proc.curframe.f_code:
# Deparse the code object into a temp file and remap the line from code
# into the corresponding line of the tempfile
co = proc.curframe.f_code
temp_filename, name_for_code = deparse_and_cache(co, proc.errmsg, tempdir=self.settings["tempdir"])
if temp_filename:
filename = temp_filename
show_marks = False
pass
# We now have range information. Do the listing.
max_line = pyficache.size(filename)
if max_line is None:
self.errmsg('No file %s found; using "deparse" command instead to show source' %
filename)
proc.commands['deparse'].run(['deparse'])
return
canonic_filename = os.path.realpath(os.path.normcase(filename))
if first > max_line:
self.errmsg('Bad start line %d - file "%s" has only %d lines'
% (first, filename, max_line))
return
if last > max_line:
self.msg('End position changed to last line %d ' % max_line)
last = max_line
bplist = self.core.bpmgr.bplist
opts = {
'reload_on_change' : self.settings['reload'],
'output' : self.settings['highlight'],
'strip_nl' : False,
}
if 'style' in self.settings:
opts['style'] = self.settings['style']
if first <= 0:
first = 1
try:
for lineno in range(first, last+1):
line = pyficache.getline(filename, lineno, opts)
if line is None:
line = linecache.getline(filename, lineno,
proc.frame.f_globals)
pass
if line is None:
self.msg('[EOF]')
break
else:
line = line.rstrip('\n')
s = proc._saferepr(lineno).rjust(3)
if len(s) < 5: s += ' '
if (show_marks and
(canonic_filename, lineno,) in list(bplist.keys())):
bp = bplist[(canonic_filename, lineno,)][0]
a_pad = '%02d' % bp.number
s += bp.icon_char()
else:
s += ' '
a_pad = ' '
pass
if (curframe and lineno == inspect.getlineno(curframe)
and show_marks):
s += '->'
if 'plain' != self.settings['highlight']:
s = colorize('bold', s)
else:
s += a_pad
pass
self.msg(s + '\t' + line)
proc.list_lineno = lineno
pass
pass
pass
except KeyboardInterrupt:
pass
return False
def main(dbg=None, sys_argv=list(sys.argv)):
"""Routine which gets run if we were invoked directly"""
global __title__
# Save the original just for use in the restart that works via exec.
orig_sys_argv = list(sys_argv)
opts, dbg_opts, sys_argv = Moptions.process_options(
__title__, __version__, sys_argv
)
if opts.server is not None:
if opts.server == "tcp":
connection_opts = {"IO": "TCP", "PORT": opts.port}
else:
connection_opts = {"IO": "FIFO"}
intf = Mserver.ServerInterface(connection_opts=connection_opts)
dbg_opts["interface"] = intf
if "FIFO" == intf.server_type:
print("Starting FIFO server for process %s." % os.getpid())
elif "TCP" == intf.server_type:
print("Starting TCP server listening on port %s." % intf.inout.PORT)
pass
elif opts.client:
Mclient.run(opts, sys_argv)
return
dbg_opts["orig_sys_argv"] = orig_sys_argv
if dbg is None:
dbg = Mdebugger.Trepan(dbg_opts)
dbg.core.add_ignore(main)
pass
Moptions._postprocess_options(dbg, opts)
# process_options has munged sys.argv to remove any options that
# options that belong to this debugger. The original options to
# invoke the debugger and script are in global sys_argv
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):
mainpyfile = Mclifns.whence_file(mainpyfile)
is_readable = Mfile.readable(mainpyfile)
if is_readable is None:
print(
"%s: Python script file '%s' does not exist"
% (
__title__,
mainpyfile,
)
)
sys.exit(1)
elif not is_readable:
print(
"%s: Can't read Python script file '%s'"
% (
__title__,
mainpyfile,
)
)
sys.exit(1)
return
if Mfile.is_compiled_py(mainpyfile):
try:
from xdis import (
load_module,
PYTHON_VERSION_TRIPLE,
IS_PYPY,
version_tuple_to_str,
)
(
python_version,
timestamp,
magic_int,
co,
is_pypy,
source_size,
sip_hash,
) = load_module(mainpyfile, code_objects=None, fast_load=False)
if is_pypy != IS_PYPY:
print("Bytecode is pypy %s, but we are %s." % (is_pypy, IS_PYPY))
print("For a cross-version debugger, use trepan-xpy with x-python.")
sys.exit(2)
if python_version[:2] != PYTHON_VERSION_TRIPLE[:2]:
print(
"Bytecode is for version %s but we are version %s."
% (python_version, version_tuple_to_str())
)
print("For a cross-version debugger, use trepan-xpy with x-python.")
sys.exit(2)
py_file = co.co_filename
if osp.isabs(py_file):
try_file = py_file
else:
mainpydir = osp.dirname(mainpyfile)
tag = sys.implementation.cache_tag
dirnames = (
[osp.join(mainpydir, tag), mainpydir]
+ os.environ["PATH"].split(osp.pathsep)
+ ["."]
)
try_file = Mclifns.whence_file(py_file, dirnames)
if osp.isfile(try_file):
mainpyfile = try_file
pass
else:
# Move onto the except branch
raise IOError(
"Python file name embedded in code %s not found" % try_file
)
except IOError:
decompiler = "uncompyle6"
try:
if (3, 7) <= PYTHON_VERSION_TRIPLE <= (3, 8):
from uncompyle6 import decompile_file
else:
from decompyle3 import decompile_file
decompiler = "decompyle3"
except ImportError:
print(
"%s: Compiled python file '%s', but %s not found"
% (__title__, mainpyfile, decompiler),
file=sys.stderr,
)
sys.exit(1)
return
short_name = osp.basename(mainpyfile).strip(".pyc")
fd = tempfile.NamedTemporaryFile(
suffix=".py",
prefix=short_name + "_",
delete=False,
dir=dbg.settings["tempdir"],
)
old_write = fd.file.write
def write_wrapper(*args, **kwargs):
if isinstance(args[0], str):
new_args = list(args)
new_args[0] = args[0].encode("utf-8")
old_write(*new_args, **kwargs)
else:
old_write(*args, **kwargs)
fd.file.write = write_wrapper
# from io import StringIO
# linemap_io = StringIO()
try:
decompile_file(mainpyfile, fd.file, mapstream=fd)
except:
print(
"%s: error decompiling '%s'" % (__title__, mainpyfile),
file=sys.stderr,
)
sys.exit(1)
return
# # Get the line associations between the original and
# # decompiled program
# mapline = linemap_io.getvalue()
# fd.write(mapline + "\n\n")
# linemap = eval(mapline[3:])
mainpyfile = fd.name
fd.close()
# Since we are actually running the recreated source,
# there is little no need to remap line numbers.
# The mapping is given at the end of the file.
# However we should consider adding this information
# and original file name.
print(
"%s: couldn't find Python source so we recreated it at '%s'"
% (__title__, mainpyfile),
file=sys.stderr,
)
pass
# If mainpyfile is an optimized Python script try to find and
# use non-optimized alternative.
mainpyfile_noopt = pyficache.resolve_name_to_path(mainpyfile)
if mainpyfile != mainpyfile_noopt and Mfile.readable(mainpyfile_noopt):
print("%s: Compiled Python script given and we can't use that." % __title__)
print(
"%s: Substituting non-compiled name: %s"
% (
__title__,
mainpyfile_noopt,
)
)
mainpyfile = mainpyfile_noopt
pass
# Replace trepan's dir with script's dir in front of
# module search path.
sys.path[0] = dbg.main_dirname = osp.dirname(mainpyfile)
# XXX If a signal has been received we continue in the loop, otherwise
# the loop exits for some reason.
dbg.sig_received = False
# if not mainpyfile:
# print('For now, you need to specify a Python script name!')
# sys.exit(2)
# pass
while True:
# Run the debugged script over and over again until we get it
# right.
try:
if dbg.program_sys_argv and mainpyfile:
normal_termination = dbg.run_script(mainpyfile)
if not normal_termination:
break
else:
dbg.core.execution_status = "No program"
dbg.core.processor.process_commands()
pass
dbg.core.execution_status = "Terminated"
dbg.intf[-1].msg("The program finished - quit or restart")
dbg.core.processor.process_commands()
except Mexcept.DebuggerQuit:
break
except Mexcept.DebuggerRestart:
dbg.core.execution_status = "Restart requested"
if dbg.program_sys_argv:
sys.argv = list(dbg.program_sys_argv)
part1 = "Restarting %s with arguments:" % dbg.core.filename(mainpyfile)
args = " ".join(dbg.program_sys_argv[1:])
dbg.intf[-1].msg(
Mmisc.wrapped_lines(part1, args, dbg.settings["width"])
)
else:
break
except SystemExit:
# In most cases SystemExit does not warrant a post-mortem session.
break
pass
# Restore old sys.argv
sys.argv = orig_sys_argv
return
def run(self, args):
proc = self.proc
dbg_obj = self.core.debugger
listsize = dbg_obj.settings["listsize"]
filename, first, last = parse_list_cmd(proc, args, listsize)
curframe = proc.curframe
if filename is None:
return
filename = pyficache.unmap_file(
pyficache.resolve_name_to_path(filename))
# We now have range information. Do the listing.
max_line = pyficache.size(filename)
if max_line is None:
bytecode = curframe.f_code
if bytecode not in deparse_cache.keys():
self.errmsg(
'No file %s found; using "deparse" command instead to show source'
% filename)
proc.commands["deparse"].run(["deparse"])
return
canonic_filename = osp.realpath(osp.normcase(filename))
if first > max_line:
self.errmsg('Bad start line %d - file "%s" has only %d lines' %
(first, filename, max_line))
return
if last > max_line:
self.msg("End position changed to last line %d " % max_line)
last = max_line
bplist = self.core.bpmgr.bplist
opts = {
"reload_on_change": self.settings["reload"],
"output": self.settings["highlight"],
"strip_nl": False,
}
if "style" in self.settings:
opts["style"] = self.settings["style"]
if first <= 0:
first = 1
try:
for lineno in range(first, last + 1):
line = pyficache.getline(filename, lineno, opts)
if line is None:
line = linecache.getline(filename, lineno,
proc.frame.f_globals)
pass
if line is None:
self.msg("[EOF]")
break
else:
line = line.rstrip("\n")
s = proc._saferepr(lineno).rjust(3)
if len(s) < 5:
s += " "
if (
canonic_filename,
lineno,
) in list(bplist.keys()):
bp = bplist[(
canonic_filename,
lineno,
)][0]
a_pad = "%02d" % bp.number
s += bp.icon_char()
else:
s += " "
a_pad = " "
pass
if curframe and lineno == inspect.getlineno(curframe):
s += "->"
if "plain" != self.settings["highlight"]:
s = colorize("bold", s)
else:
s += a_pad
pass
self.msg(s + "\t" + line)
proc.list_lineno = lineno
pass
pass
pass
except KeyboardInterrupt:
pass
return False
def main(dbg=None, sys_argv=list(sys.argv)):
"""Routine which gets run if we were invoked directly"""
global __title__
# Save the original just for use in the restart that works via exec.
orig_sys_argv = list(sys_argv)
opts, dbg_opts, sys_argv = process_options(__title__, __version__,
sys_argv)
dbg_opts['orig_sys_argv'] = sys_argv
dbg_opts['interface'] = Mbullwinkle.BWInterface()
dbg_opts['processor'] = 'bullwinkle'
if dbg is None:
dbg = Mdebugger.Debugger(dbg_opts)
dbg.core.add_ignore(main)
pass
_postprocess_options(dbg, opts)
# process_options has munged sys.argv to remove any options that
# options that belong to this debugger. The original options to
# invoke the debugger and script are in global sys_argv
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 os.path.isfile(mainpyfile):
mainpyfile = Mclifns.whence_file(mainpyfile)
is_readable = Mfile.readable(mainpyfile)
if is_readable is None:
print("%s: Python script file '%s' does not exist" % (
__title__,
mainpyfile,
))
sys.exit(1)
elif not is_readable:
print("%s: Can't read Python script file '%s'" % (
__title__,
mainpyfile,
))
sys.exit(1)
return
# If mainpyfile is an optimized Python script try to find and
# use non-optimized alternative.
mainpyfile_noopt = pyficache.resolve_name_to_path(mainpyfile)
if mainpyfile != mainpyfile_noopt \
and Mfile.readable(mainpyfile_noopt):
print("%s: Compiled Python script given and we can't use that." %
__title__)
print("%s: Substituting non-compiled name: %s" % (
__title__,
mainpyfile_noopt,
))
mainpyfile = mainpyfile_noopt
pass
# Replace trepan's dir with script's dir in front of
# module search path.
sys.path[0] = dbg.main_dirname = os.path.dirname(mainpyfile)
# XXX If a signal has been received we continue in the loop, otherwise
# the loop exits for some reason.
dbg.sig_received = False
# if not mainpyfile:
# print('For now, you need to specify a Python script name!')
# sys.exit(2)
# pass
while True:
# Run the debugged script over and over again until we get it
# right.
try:
if dbg.program_sys_argv and mainpyfile:
normal_termination = dbg.run_script(mainpyfile)
if not normal_termination: break
else:
dbg.core.execution_status = 'No program'
dbg.core.processor.process_commands()
pass
dbg.core.execution_status = 'Terminated'
dbg.intf[-1].msg("The program finished - quit or restart")
dbg.core.processor.process_commands()
except Mexcept.DebuggerQuit:
break
except Mexcept.DebuggerRestart:
dbg.core.execution_status = 'Restart requested'
if dbg.program_sys_argv:
sys.argv = list(dbg.program_sys_argv)
part1 = ('Restarting %s with arguments:' %
dbg.core.filename(mainpyfile))
args = ' '.join(dbg.program_sys_argv[1:])
dbg.intf[-1].msg(
Mmisc.wrapped_lines(part1, args, dbg.settings['width']))
else:
break
except SystemExit:
# In most cases SystemExit does not warrant a post-mortem session.
break
pass
# Restore old sys.argv
sys.argv = orig_sys_argv
return
def resolve_location(proc, location):
"""Expand fields in Location namedtuple. If:
'.': get fields from stack
function/module: get fields from evaluation/introspection
location file and line number: use that
"""
curframe = proc.curframe
offset = None
if location == ".":
if not curframe:
proc.errmsg("Don't have a stack to get location from")
return INVALID_LOCATION
filename = frame2file(proc.core, curframe, canonic=False)
lineno = inspect.getlineno(curframe)
offset = curframe.f_lasti
return Location(filename, lineno, False, None, offset)
assert isinstance(location, Location)
is_address = location.is_address
if proc.curframe:
g = curframe.f_globals
l = curframe.f_locals
else:
g = globals()
l = locals()
pass
if location.method:
# Validate arguments that can't be done in parsing
filename = lineno = None
msg = "Object %s is not known yet as a function, " % location.method
try:
modfunc = eval(location.method, g, l)
except:
proc.errmsg(msg)
return INVALID_LOCATION
try:
# Check if the converted string is a function or instance
# method. We don't want to test on attributes and not use
# `inspect.isfunction()` so that we can accomadate
# trepan-xpy() which has it's own type of compatible
# Function, that would fail an `inspect.isfunction()`
# test.
if hasattr(modfunc, "__code__") or hasattr(modfunc, "im_func"):
offset = -1
else:
proc.errmsg(msg)
return INVALID_LOCATION
except:
proc.errmsg(msg)
return INVALID_LOCATION
filename = proc.core.canonic(modfunc.__code__.co_filename)
# FIXME: we may want to check lineno and
# respect that in the future
lineno = modfunc.__code__.co_firstlineno
elif location.path:
filename = proc.core.canonic(location.path)
lineno = location.line_number
modfunc = None
msg = "%s is not known as a file" % location.path
if not osp.isfile(filename):
# See if argument is a module
try:
modfunc = eval(location.path, g, l)
except:
msg = ("Don't see '%s' as a existing file or as an module" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
pass
is_address = location.is_address
if inspect.ismodule(modfunc):
if hasattr(modfunc, "__file__"):
filename = pyficache.resolve_name_to_path(modfunc.__file__)
filename = proc.core.canonic(filename)
if not lineno:
# use first line of module file
lineno = 1
offset = 0
is_address = False
return Location(filename, lineno, is_address, modfunc,
offset)
else:
msg = (
"module '%s' doesn't have a file associated with it" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
maxline = pyficache.maxline(filename)
if maxline and lineno > maxline:
# NB: we use the gdb wording here
proc.errmsg("Line number %d out of range; %s has %d lines." %
(lineno, filename, maxline))
return INVALID_LOCATION
offset = location.offset
if offset is None:
lineinfo = pyficache.code_line_info(filename, lineno)
if lineinfo:
offset = lineinfo[0].offsets[0]
modfunc = lineinfo[0].name
else:
print("No offset found for %s %s" % (filename, lineno))
elif location.line_number:
filename = frame2file(proc.core, curframe, canonic=False)
lineno = location.line_number
is_address = location.is_address
modfunc = None
if offset is None:
lineinfo = pyficache.code_line_info(filename,
lineno,
include_offsets=True)
if lineinfo:
offset = lineinfo[0].offsets[0]
modfunc = lineinfo[0].name
elif location.offset is not None:
filename = frame2file(proc.core, curframe, canonic=False)
is_address = True
lineno = None
modfunc = None
offset = location.offset
return Location(filename, lineno, is_address, modfunc, offset)
def resolve_address_location(proc, location):
"""Expand fields in Location namedtuple. If:
'.': get fields from stack
function/module: get fields from evaluation/introspection
location file and line number: use that
"""
curframe = proc.curframe
if location == ".":
filename = frame2file(proc.core, curframe, canonic=False)
offset = curframe.f_lasti
is_address = True
return Location(filename, offset, False, None, offset)
assert isinstance(location, Location)
is_address = True
if proc.curframe:
g = curframe.f_globals
l = curframe.f_locals
else:
g = globals()
l = locals()
pass
if location.method:
# Validate arguments that can't be done in parsing
filename = offset = None
msg = "Object %s is not known yet as a function, " % location.method
try:
modfunc = eval(location.method, g, l)
except:
proc.errmsg(msg)
return INVALID_LOCATION
try:
# Check if the converted string is a function or instance method
if inspect.isfunction(modfunc) or hasattr(modfunc, "im_func"):
pass
else:
proc.errmsg(msg)
return INVALID_LOCATION
except:
proc.errmsg(msg)
return INVALID_LOCATION
filename = proc.core.canonic(modfunc.func_code.co_filename)
# FIXME: we may want to check offset and
# respect that in the future
offset = 0
elif location.path:
filename = proc.core.canonic(location.path)
offset = location.line_number
is_address = location.is_address
modfunc = None
msg = "%s is not known as a file" % location.path
if not osp.isfile(filename):
# See if argument is a module
try:
modfunc = eval(location.path, g, l)
except:
msg = ("Don't see '%s' as a existing file or as an module" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
pass
is_address = location.is_address
if inspect.ismodule(modfunc):
if hasattr(modfunc, "__file__"):
filename = pyficache.resolve_name_to_path(modfunc.__file__)
filename = proc.core.canonic(filename)
if not offset:
# use first offset of module file
offset = 0
is_address = True
return Location(filename, offset, is_address, modfunc,
offset)
else:
msg = (
"module '%s' doesn't have a file associated with it" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
maxline = pyficache.maxline(filename)
if maxline and offset > maxline:
# NB: we use the gdb wording here
proc.errmsg("Line number %d out of range; %s has %d lines." %
(offset, filename, maxline))
return INVALID_LOCATION
elif location.line_number is not None:
filename = frame2file(proc.core, curframe, canonic=False)
offset = location.line_number
is_address = location.is_address
modfunc = proc.list_object
else:
proc.errmsg(
f"Location {location} doesn't have enough information for a location."
)
return INVALID_LOCATION
return Location(filename, offset, is_address, modfunc, offset)
def resolve_location(proc, location, canonic=True):
"""Expand fields in Location namedtuple. If:
'.': get fields from stack
function/module: get fields from evaluation/introspection
location file and line number: use that
"""
curframe = proc.curframe
if location == '.':
if not curframe:
proc.errmsg("Don't have a stack to get location from")
return INVALID_LOCATION
filename = Mstack.frame2file(proc.core, curframe, canonic=canonic)
lineno = inspect.getlineno(curframe)
return Location(filename, lineno, False, None)
assert isinstance(location, Location)
is_address = location.is_address
if proc.curframe:
g = curframe.f_globals
l = curframe.f_locals
else:
g = globals()
l = locals()
pass
if location.method:
# Validate arguments that can't be done in parsing
filename = lineno = None
msg = ('Object %s is not known yet as a function, ' % location.method)
try:
modfunc = eval(location.method, g, l)
except:
proc.errmsg(msg)
return INVALID_LOCATION
try:
# Check if the converted string is a function or instance method
if inspect.isfunction(modfunc) or hasattr(modfunc, 'im_func'):
pass
else:
proc.errmsg(msg)
return INVALID_LOCATION
except:
proc.errmsg(msg)
return INVALID_LOCATION
filename = proc.core.canonic(modfunc.func_code.co_filename)
# FIXME: we may want to check lineno and
# respect that in the future
lineno = modfunc.func_code.co_firstlineno
elif location.path:
filename = proc.core.canonic(location.path)
lineno = location.line_number
modfunc = None
msg = "%s is not known as a file" % location.path
if not osp.isfile(filename):
# See if argument is a module
try:
modfunc = eval(location.path, g, l)
except:
msg = ("Don't see '%s' as a existing file or as an module" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
pass
is_address = location.is_address
if inspect.ismodule(modfunc):
if hasattr(modfunc, '__file__'):
filename = pyficache.resolve_name_to_path(modfunc.__file__)
filename = proc.core.canonic(filename)
if not lineno:
# use first line of module file
lineno = 1
is_address = False
return Location(filename, lineno, is_address, modfunc)
else:
msg = (
"module '%s' doesn't have a file associated with it" %
location.path)
proc.errmsg(msg)
return INVALID_LOCATION
maxline = pyficache.maxline(filename)
if maxline and lineno > maxline:
# NB: we use the gdb wording here
proc.errmsg("Line number %d out of range; %s has %d lines." %
(lineno, filename, maxline))
return INVALID_LOCATION
elif location.line_number:
filename = Mstack.frame2file(proc.core, curframe, canonic=canonic)
lineno = location.line_number
is_address = location.is_address
modfunc = None
return Location(filename, lineno, is_address, modfunc)