def get_step_info(self):
frames = self.step_info
state_frames = []
# For now assume the base function is the... function, ignoring
# inlining.
dex_frames = []
for i, x in enumerate(frames):
# XXX Might be able to get columns out through
# GetSourceEntriesByOffset, not a priority now
loc = LocIR(path=x.source_file, lineno=x.line_no, column=0)
new_frame = FrameIR(function=x.function_name, is_inlined=False, loc=loc)
dex_frames.append(new_frame)
state_frame = StackFrame(function=new_frame.function,
is_inlined=new_frame.is_inlined,
location=SourceLocation(path=x.source_file,
lineno=x.line_no,
column=0),
watches={})
for expr in map(
lambda watch, idx=i: self.evaluate_expression(watch, idx),
self.watches):
state_frame.watches[expr.expression] = expr
state_frames.append(state_frame)
return StepIR(
step_index=self.step_index, frames=dex_frames,
stop_reason=StopReason.STEP,
program_state=ProgramState(state_frames))
def _get_step_info(self, watches, step_index):
frames = []
state_frames = []
for i in range(0, self._thread.GetNumFrames()):
sb_frame = self._thread.GetFrameAtIndex(i)
sb_line = sb_frame.GetLineEntry()
sb_filespec = sb_line.GetFileSpec()
try:
path = os.path.join(sb_filespec.GetDirectory(),
sb_filespec.GetFilename())
except (AttributeError, TypeError):
path = None
function = self._sanitize_function_name(sb_frame.GetFunctionName())
loc_dict = {
'path': path,
'lineno': sb_line.GetLine(),
'column': sb_line.GetColumn()
}
loc = LocIR(**loc_dict)
frame = FrameIR(function=function,
is_inlined=sb_frame.IsInlined(),
loc=loc)
if any(name in (frame.function or '') # pylint: disable=no-member
for name in self.frames_below_main):
break
frames.append(frame)
state_frame = StackFrame(function=frame.function,
is_inlined=frame.is_inlined,
location=SourceLocation(**loc_dict),
watches={})
for expr in map(
lambda watch, idx=i: self.evaluate_expression(watch, idx),
watches):
state_frame.watches[expr.expression] = expr
state_frames.append(state_frame)
if len(frames) == 1 and frames[0].function is None:
frames = []
state_frames = []
reason = self._translate_stop_reason(self._thread.GetStopReason())
return StepIR(step_index=step_index,
frames=frames,
stop_reason=reason,
program_state=ProgramState(state_frames))
def _get_step_info(self, watches, step_index):
thread = self._debugger.CurrentThread
stackframes = thread.StackFrames
frames = []
state_frames = []
loc = LocIR(**self._location)
valid_loc_for_watch = loc.path and os.path.exists(loc.path)
for idx, sf in enumerate(stackframes):
frame = FrameIR(
function=self._sanitize_function_name(sf.FunctionName),
is_inlined=sf.FunctionName.startswith('[Inline Frame]'),
loc=LocIR(path=None, lineno=None, column=None))
fname = frame.function or '' # pylint: disable=no-member
if any(name in fname for name in self.frames_below_main):
break
state_frame = StackFrame(function=frame.function,
is_inlined=frame.is_inlined,
watches={})
if valid_loc_for_watch and idx == 0:
for watch_info in watches:
if watch_is_active(watch_info, loc.path, idx, loc.lineno):
watch_expr = watch_info.expression
state_frame.watches[
watch_expr] = self.evaluate_expression(
watch_expr, idx)
state_frames.append(state_frame)
frames.append(frame)
if frames:
frames[0].loc = loc
state_frames[0].location = SourceLocation(**self._location)
reason = StopReason.BREAKPOINT
if loc.path is None: # pylint: disable=no-member
reason = StopReason.STEP
program_state = ProgramState(frames=state_frames)
return StepIR(step_index=step_index,
frames=frames,
stop_reason=reason,
program_state=program_state)
def frame_from_dict(source: dict) -> StackFrame:
if 'location' in source:
assert isinstance(source['location'], dict)
source['location'] = SourceLocation(**source['location'])
return StackFrame(**source)