Ejemplo n.º 1
0
    def _get_step_info(self, watches, step_index):
        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),
                    watches):
                state_frame.watches[expr.expression] = expr
            state_frames.append(state_frame)

        return StepIR(step_index=step_index,
                      frames=dex_frames,
                      stop_reason=StopReason.STEP,
                      program_state=ProgramState(state_frames))
Ejemplo n.º 2
0
 def _new_step(self, paths):
     frames = [
         FrameIR(function=None,
                 is_inlined=False,
                 loc=LocIR(path=path, lineno=0, column=0)) for path in paths
     ]
     return StepIR(step_index=0, stop_reason=None, frames=frames)
Ejemplo n.º 3
0
    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))
Ejemplo n.º 4
0
    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)
Ejemplo n.º 5
0
    def get_step_info(self):
        frames = self.step_info

        # For now assume the base function is the... function, ignoring
        # inlining.
        dex_frames = []
        for x in 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)

        return StepIR(step_index=self.step_index,
                      frames=dex_frames,
                      stop_reason=StopReason.STEP)