| # |
| # This file contains implementations of the LLDB display panes in VIM |
| # |
| # The most generic way to define a new window is to inherit from VimPane |
| # and to implement: |
| # - get_content() - returns a string with the pane contents |
| # |
| # Optionally, to highlight text, implement: |
| # - get_highlights() - returns a map |
| # |
| # And call: |
| # - define_highlight(unique_name, colour) |
| # at some point in the constructor. |
| # |
| # |
| # If the pane shows some key-value data that is in the context of a |
| # single frame, inherit from FrameKeyValuePane and implement: |
| # - get_frame_content(self, SBFrame frame) |
| # |
| # |
| # If the pane presents some information that can be retrieved with |
| # a simple LLDB command while the subprocess is stopped, inherit |
| # from StoppedCommandPane and call: |
| # - self.setCommand(command, command_args) |
| # at some point in the constructor. |
| # |
| # Optionally, you can implement: |
| # - get_selected_line() |
| # to highlight a selected line and place the cursor there. |
| # |
| # |
| # FIXME: implement WatchlistPane to displayed watched expressions |
| # FIXME: define interface for interactive panes, like catching enter |
| # presses to change selected frame/thread... |
| # |
| |
| import lldb |
| import vim |
| |
| import sys |
| |
| # ============================================================== |
| # Get the description of an lldb object or None if not available |
| # ============================================================== |
| |
| # Shamelessly copy/pasted from lldbutil.py in the test suite |
| |
| |
| def get_description(obj, option=None): |
| """Calls lldb_obj.GetDescription() and returns a string, or None. |
| |
| For SBTarget, SBBreakpointLocation, and SBWatchpoint lldb objects, an extra |
| option can be passed in to describe the detailed level of description |
| desired: |
| o lldb.eDescriptionLevelBrief |
| o lldb.eDescriptionLevelFull |
| o lldb.eDescriptionLevelVerbose |
| """ |
| method = getattr(obj, 'GetDescription') |
| if not method: |
| return None |
| tuple = (lldb.SBTarget, lldb.SBBreakpointLocation, lldb.SBWatchpoint) |
| if isinstance(obj, tuple): |
| if option is None: |
| option = lldb.eDescriptionLevelBrief |
| |
| stream = lldb.SBStream() |
| if option is None: |
| success = method(stream) |
| else: |
| success = method(stream, option) |
| if not success: |
| return None |
| return stream.GetData() |
| |
| |
| def get_selected_thread(target): |
| """ Returns a tuple with (thread, error) where thread == None if error occurs """ |
| process = target.GetProcess() |
| if process is None or not process.IsValid(): |
| return (None, VimPane.MSG_NO_PROCESS) |
| |
| thread = process.GetSelectedThread() |
| if thread is None or not thread.IsValid(): |
| return (None, VimPane.MSG_NO_THREADS) |
| return (thread, "") |
| |
| |
| def get_selected_frame(target): |
| """ Returns a tuple with (frame, error) where frame == None if error occurs """ |
| (thread, error) = get_selected_thread(target) |
| if thread is None: |
| return (None, error) |
| |
| frame = thread.GetSelectedFrame() |
| if frame is None or not frame.IsValid(): |
| return (None, VimPane.MSG_NO_FRAME) |
| return (frame, "") |
| |
| |
| def _cmd(cmd): |
| vim.command("call confirm('%s')" % cmd) |
| vim.command(cmd) |
| |
| |
| def move_cursor(line, col=0): |
| """ moves cursor to specified line and col """ |
| cw = vim.current.window |
| if cw.cursor[0] != line: |
| vim.command("execute \"normal %dgg\"" % line) |
| |
| |
| def winnr(): |
| """ Returns currently selected window number """ |
| return int(vim.eval("winnr()")) |
| |
| |
| def bufwinnr(name): |
| """ Returns window number corresponding with buffer name """ |
| return int(vim.eval("bufwinnr('%s')" % name)) |
| |
| |
| def goto_window(nr): |
| """ go to window number nr""" |
| if nr != winnr(): |
| vim.command(str(nr) + ' wincmd w') |
| |
| |
| def goto_next_window(): |
| """ go to next window. """ |
| vim.command('wincmd w') |
| return (winnr(), vim.current.buffer.name) |
| |
| |
| def goto_previous_window(): |
| """ go to previously selected window """ |
| vim.command("execute \"normal \\<c-w>p\"") |
| |
| |
| def have_gui(): |
| """ Returns True if vim is in a gui (Gvim/MacVim), False otherwise. """ |
| return int(vim.eval("has('gui_running')")) == 1 |
| |
| |
| class PaneLayout(object): |
| """ A container for a (vertical) group layout of VimPanes """ |
| |
| def __init__(self): |
| self.panes = {} |
| |
| def havePane(self, name): |
| """ Returns true if name is a registered pane, False otherwise """ |
| return name in self.panes |
| |
| def prepare(self, panes=[]): |
| """ Draw panes on screen. If empty list is provided, show all. """ |
| |
| # If we can't select a window contained in the layout, we are doing a |
| # first draw |
| first_draw = not self.selectWindow(True) |
| did_first_draw = False |
| |
| # Prepare each registered pane |
| for name in self.panes: |
| if name in panes or len(panes) == 0: |
| if first_draw: |
| # First window in layout will be created with :vsp, and |
| # closed later |
| vim.command(":vsp") |
| first_draw = False |
| did_first_draw = True |
| self.panes[name].prepare() |
| |
| if did_first_draw: |
| # Close the split window |
| vim.command(":q") |
| |
| self.selectWindow(False) |
| |
| def contains(self, bufferName=None): |
| """ Returns True if window with name bufferName is contained in the layout, False otherwise. |
| If bufferName is None, the currently selected window is checked. |
| """ |
| if not bufferName: |
| bufferName = vim.current.buffer.name |
| |
| for p in self.panes: |
| if bufferName is not None and bufferName.endswith(p): |
| return True |
| return False |
| |
| def selectWindow(self, select_contained=True): |
| """ Selects a window contained in the layout (if select_contained = True) and returns True. |
| If select_contained = False, a window that is not contained is selected. Returns False |
| if no group windows can be selected. |
| """ |
| if select_contained == self.contains(): |
| # Simple case: we are already selected |
| return True |
| |
| # Otherwise, switch to next window until we find a contained window, or |
| # reach the first window again. |
| first = winnr() |
| (curnum, curname) = goto_next_window() |
| |
| while not select_contained == self.contains( |
| curname) and curnum != first: |
| (curnum, curname) = goto_next_window() |
| |
| return self.contains(curname) == select_contained |
| |
| def hide(self, panes=[]): |
| """ Hide panes specified. If empty list provided, hide all. """ |
| for name in self.panes: |
| if name in panes or len(panes) == 0: |
| self.panes[name].destroy() |
| |
| def registerForUpdates(self, p): |
| self.panes[p.name] = p |
| |
| def update(self, target, controller): |
| for name in self.panes: |
| self.panes[name].update(target, controller) |
| |
| |
| class VimPane(object): |
| """ A generic base class for a pane that displays stuff """ |
| CHANGED_VALUE_HIGHLIGHT_NAME_GUI = 'ColorColumn' |
| CHANGED_VALUE_HIGHLIGHT_NAME_TERM = 'lldb_changed' |
| CHANGED_VALUE_HIGHLIGHT_COLOUR_TERM = 'darkred' |
| |
| SELECTED_HIGHLIGHT_NAME_GUI = 'Cursor' |
| SELECTED_HIGHLIGHT_NAME_TERM = 'lldb_selected' |
| SELECTED_HIGHLIGHT_COLOUR_TERM = 'darkblue' |
| |
| MSG_NO_TARGET = "Target does not exist." |
| MSG_NO_PROCESS = "Process does not exist." |
| MSG_NO_THREADS = "No valid threads." |
| MSG_NO_FRAME = "No valid frame." |
| |
| # list of defined highlights, so we avoid re-defining them |
| highlightTypes = [] |
| |
| def __init__(self, owner, name, open_below=False, height=3): |
| self.owner = owner |
| self.name = name |
| self.buffer = None |
| self.maxHeight = 20 |
| self.openBelow = open_below |
| self.height = height |
| self.owner.registerForUpdates(self) |
| |
| def isPrepared(self): |
| """ check window is OK """ |
| if self.buffer is None or len( |
| dir(self.buffer)) == 0 or bufwinnr(self.name) == -1: |
| return False |
| return True |
| |
| def prepare(self, method='new'): |
| """ check window is OK, if not then create """ |
| if not self.isPrepared(): |
| self.create(method) |
| |
| def on_create(self): |
| pass |
| |
| def destroy(self): |
| """ destroy window """ |
| if self.buffer is None or len(dir(self.buffer)) == 0: |
| return |
| vim.command('bdelete ' + self.name) |
| |
| def create(self, method): |
| """ create window """ |
| |
| if method != 'edit': |
| belowcmd = "below" if self.openBelow else "" |
| vim.command('silent %s %s %s' % (belowcmd, method, self.name)) |
| else: |
| vim.command('silent %s %s' % (method, self.name)) |
| |
| self.window = vim.current.window |
| |
| # Set LLDB pane options |
| vim.command("setlocal buftype=nofile") # Don't try to open a file |
| vim.command("setlocal noswapfile") # Don't use a swap file |
| vim.command("set nonumber") # Don't display line numbers |
| # vim.command("set nowrap") # Don't wrap text |
| |
| # Save some parameters and reference to buffer |
| self.buffer = vim.current.buffer |
| self.width = int(vim.eval("winwidth(0)")) |
| self.height = int(vim.eval("winheight(0)")) |
| |
| self.on_create() |
| goto_previous_window() |
| |
| def update(self, target, controller): |
| """ updates buffer contents """ |
| self.target = target |
| if not self.isPrepared(): |
| # Window is hidden, or otherwise not ready for an update |
| return |
| |
| original_cursor = self.window.cursor |
| |
| # Select pane |
| goto_window(bufwinnr(self.name)) |
| |
| # Clean and update content, and apply any highlights. |
| self.clean() |
| |
| if self.write(self.get_content(target, controller)): |
| self.apply_highlights() |
| |
| cursor = self.get_selected_line() |
| if cursor is None: |
| # Place the cursor at its original position in the window |
| cursor_line = min(original_cursor[0], len(self.buffer)) |
| cursor_col = min( |
| original_cursor[1], len( |
| self.buffer[ |
| cursor_line - 1])) |
| else: |
| # Place the cursor at the location requested by a VimPane |
| # implementation |
| cursor_line = min(cursor, len(self.buffer)) |
| cursor_col = self.window.cursor[1] |
| |
| self.window.cursor = (cursor_line, cursor_col) |
| |
| goto_previous_window() |
| |
| def get_selected_line(self): |
| """ Returns the line number to move the cursor to, or None to leave |
| it where the user last left it. |
| Subclasses implement this to define custom behaviour. |
| """ |
| return None |
| |
| def apply_highlights(self): |
| """ Highlights each set of lines in each highlight group """ |
| highlights = self.get_highlights() |
| for highlightType in highlights: |
| lines = highlights[highlightType] |
| if len(lines) == 0: |
| continue |
| |
| cmd = 'match %s /' % highlightType |
| lines = ['\%' + '%d' % line + 'l' for line in lines] |
| cmd += '\\|'.join(lines) |
| cmd += '/' |
| vim.command(cmd) |
| |
| def define_highlight(self, name, colour): |
| """ Defines highlihght """ |
| if name in VimPane.highlightTypes: |
| # highlight already defined |
| return |
| |
| vim.command( |
| "highlight %s ctermbg=%s guibg=%s" % |
| (name, colour, colour)) |
| VimPane.highlightTypes.append(name) |
| |
| def write(self, msg): |
| """ replace buffer with msg""" |
| self.prepare() |
| |
| msg = str(msg.encode("utf-8", "replace")).split('\n') |
| try: |
| self.buffer.append(msg) |
| vim.command("execute \"normal ggdd\"") |
| except vim.error: |
| # cannot update window; happens when vim is exiting. |
| return False |
| |
| move_cursor(1, 0) |
| return True |
| |
| def clean(self): |
| """ clean all datas in buffer """ |
| self.prepare() |
| vim.command(':%d') |
| #self.buffer[:] = None |
| |
| def get_content(self, target, controller): |
| """ subclasses implement this to provide pane content """ |
| assert(0 and "pane subclass must implement this") |
| pass |
| |
| def get_highlights(self): |
| """ Subclasses implement this to provide pane highlights. |
| This function is expected to return a map of: |
| { highlight_name ==> [line_number, ...], ... } |
| """ |
| return {} |
| |
| |
| class FrameKeyValuePane(VimPane): |
| |
| def __init__(self, owner, name, open_below): |
| """ Initialize parent, define member variables, choose which highlight |
| to use based on whether or not we have a gui (MacVim/Gvim). |
| """ |
| |
| VimPane.__init__(self, owner, name, open_below) |
| |
| # Map-of-maps key/value history { frame --> { variable_name, |
| # variable_value } } |
| self.frameValues = {} |
| |
| if have_gui(): |
| self.changedHighlight = VimPane.CHANGED_VALUE_HIGHLIGHT_NAME_GUI |
| else: |
| self.changedHighlight = VimPane.CHANGED_VALUE_HIGHLIGHT_NAME_TERM |
| self.define_highlight(VimPane.CHANGED_VALUE_HIGHLIGHT_NAME_TERM, |
| VimPane.CHANGED_VALUE_HIGHLIGHT_COLOUR_TERM) |
| |
| def format_pair(self, key, value, changed=False): |
| """ Formats a key/value pair. Appends a '*' if changed == True """ |
| marker = '*' if changed else ' ' |
| return "%s %s = %s\n" % (marker, key, value) |
| |
| def get_content(self, target, controller): |
| """ Get content for a frame-aware pane. Also builds the list of lines that |
| need highlighting (i.e. changed values.) |
| """ |
| if target is None or not target.IsValid(): |
| return VimPane.MSG_NO_TARGET |
| |
| self.changedLines = [] |
| |
| (frame, err) = get_selected_frame(target) |
| if frame is None: |
| return err |
| |
| output = get_description(frame) |
| lineNum = 1 |
| |
| # Retrieve the last values displayed for this frame |
| frameId = get_description(frame.GetBlock()) |
| if frameId in self.frameValues: |
| frameOldValues = self.frameValues[frameId] |
| else: |
| frameOldValues = {} |
| |
| # Read the frame variables |
| vals = self.get_frame_content(frame) |
| for (key, value) in vals: |
| lineNum += 1 |
| if len(frameOldValues) == 0 or ( |
| key in frameOldValues and frameOldValues[key] == value): |
| output += self.format_pair(key, value) |
| else: |
| output += self.format_pair(key, value, True) |
| self.changedLines.append(lineNum) |
| |
| # Save values as oldValues |
| newValues = {} |
| for (key, value) in vals: |
| newValues[key] = value |
| self.frameValues[frameId] = newValues |
| |
| return output |
| |
| def get_highlights(self): |
| ret = {} |
| ret[self.changedHighlight] = self.changedLines |
| return ret |
| |
| |
| class LocalsPane(FrameKeyValuePane): |
| """ Pane that displays local variables """ |
| |
| def __init__(self, owner, name='locals'): |
| FrameKeyValuePane.__init__(self, owner, name, open_below=True) |
| |
| # FIXME: allow users to customize display of args/locals/statics/scope |
| self.arguments = True |
| self.show_locals = True |
| self.show_statics = True |
| self.show_in_scope_only = True |
| |
| def format_variable(self, var): |
| """ Returns a Tuple of strings "(Type) Name", "Value" for SBValue var """ |
| val = var.GetValue() |
| if val is None: |
| # If the value is too big, SBValue.GetValue() returns None; replace |
| # with ... |
| val = "..." |
| |
| return ("(%s) %s" % (var.GetTypeName(), var.GetName()), "%s" % val) |
| |
| def get_frame_content(self, frame): |
| """ Returns list of key-value pairs of local variables in frame """ |
| vals = frame.GetVariables(self.arguments, |
| self.show_locals, |
| self.show_statics, |
| self.show_in_scope_only) |
| return [self.format_variable(x) for x in vals] |
| |
| |
| class RegistersPane(FrameKeyValuePane): |
| """ Pane that displays the contents of registers """ |
| |
| def __init__(self, owner, name='registers'): |
| FrameKeyValuePane.__init__(self, owner, name, open_below=True) |
| |
| def format_register(self, reg): |
| """ Returns a tuple of strings ("name", "value") for SBRegister reg. """ |
| name = reg.GetName() |
| val = reg.GetValue() |
| if val is None: |
| val = "..." |
| return (name, val.strip()) |
| |
| def get_frame_content(self, frame): |
| """ Returns a list of key-value pairs ("name", "value") of registers in frame """ |
| |
| result = [] |
| for register_sets in frame.GetRegisters(): |
| # hack the register group name into the list of registers... |
| result.append((" = = %s =" % register_sets.GetName(), "")) |
| |
| for reg in register_sets: |
| result.append(self.format_register(reg)) |
| return result |
| |
| |
| class CommandPane(VimPane): |
| """ Pane that displays the output of an LLDB command """ |
| |
| def __init__(self, owner, name, open_below, process_required=True): |
| VimPane.__init__(self, owner, name, open_below) |
| self.process_required = process_required |
| |
| def setCommand(self, command, args=""): |
| self.command = command |
| self.args = args |
| |
| def get_content(self, target, controller): |
| output = "" |
| if not target: |
| output = VimPane.MSG_NO_TARGET |
| elif self.process_required and not target.GetProcess(): |
| output = VimPane.MSG_NO_PROCESS |
| else: |
| (success, output) = controller.getCommandOutput( |
| self.command, self.args) |
| return output |
| |
| |
| class StoppedCommandPane(CommandPane): |
| """ Pane that displays the output of an LLDB command when the process is |
| stopped; otherwise displays process status. This class also implements |
| highlighting for a single line (to show a single-line selected entity.) |
| """ |
| |
| def __init__(self, owner, name, open_below): |
| """ Initialize parent and define highlight to use for selected line. """ |
| CommandPane.__init__(self, owner, name, open_below) |
| if have_gui(): |
| self.selectedHighlight = VimPane.SELECTED_HIGHLIGHT_NAME_GUI |
| else: |
| self.selectedHighlight = VimPane.SELECTED_HIGHLIGHT_NAME_TERM |
| self.define_highlight(VimPane.SELECTED_HIGHLIGHT_NAME_TERM, |
| VimPane.SELECTED_HIGHLIGHT_COLOUR_TERM) |
| |
| def get_content(self, target, controller): |
| """ Returns the output of a command that relies on the process being stopped. |
| If the process is not in 'stopped' state, the process status is returned. |
| """ |
| output = "" |
| if not target or not target.IsValid(): |
| output = VimPane.MSG_NO_TARGET |
| elif not target.GetProcess() or not target.GetProcess().IsValid(): |
| output = VimPane.MSG_NO_PROCESS |
| elif target.GetProcess().GetState() == lldb.eStateStopped: |
| (success, output) = controller.getCommandOutput( |
| self.command, self.args) |
| else: |
| (success, output) = controller.getCommandOutput("process", "status") |
| return output |
| |
| def get_highlights(self): |
| """ Highlight the line under the cursor. Users moving the cursor has |
| no effect on the selected line. |
| """ |
| ret = {} |
| line = self.get_selected_line() |
| if line is not None: |
| ret[self.selectedHighlight] = [line] |
| return ret |
| return ret |
| |
| def get_selected_line(self): |
| """ Subclasses implement this to control where the cursor (and selected highlight) |
| is placed. |
| """ |
| return None |
| |
| |
| class DisassemblyPane(CommandPane): |
| """ Pane that displays disassembly around PC """ |
| |
| def __init__(self, owner, name='disassembly'): |
| CommandPane.__init__(self, owner, name, open_below=True) |
| |
| # FIXME: let users customize the number of instructions to disassemble |
| self.setCommand("disassemble", "-c %d -p" % self.maxHeight) |
| |
| |
| class ThreadPane(StoppedCommandPane): |
| """ Pane that displays threads list """ |
| |
| def __init__(self, owner, name='threads'): |
| StoppedCommandPane.__init__(self, owner, name, open_below=False) |
| self.setCommand("thread", "list") |
| |
| # FIXME: the function below assumes threads are listed in sequential order, |
| # which turns out to not be the case. Highlighting of selected thread |
| # will be disabled until this can be fixed. LLDB prints a '*' anyways |
| # beside the selected thread, so this is not too big of a problem. |
| # def get_selected_line(self): |
| # """ Place the cursor on the line with the selected entity. |
| # Subclasses should override this to customize selection. |
| # Formula: selected_line = selected_thread_id + 1 |
| # """ |
| # (thread, err) = get_selected_thread(self.target) |
| # if thread is None: |
| # return None |
| # else: |
| # return thread.GetIndexID() + 1 |
| |
| |
| class BacktracePane(StoppedCommandPane): |
| """ Pane that displays backtrace """ |
| |
| def __init__(self, owner, name='backtrace'): |
| StoppedCommandPane.__init__(self, owner, name, open_below=False) |
| self.setCommand("bt", "") |
| |
| def get_selected_line(self): |
| """ Returns the line number in the buffer with the selected frame. |
| Formula: selected_line = selected_frame_id + 2 |
| FIXME: the above formula hack does not work when the function return |
| value is printed in the bt window; the wrong line is highlighted. |
| """ |
| |
| (frame, err) = get_selected_frame(self.target) |
| if frame is None: |
| return None |
| else: |
| return frame.GetFrameID() + 2 |
| |
| |
| class BreakpointsPane(CommandPane): |
| |
| def __init__(self, owner, name='breakpoints'): |
| super( |
| BreakpointsPane, |
| self).__init__( |
| owner, |
| name, |
| open_below=False, |
| process_required=False) |
| self.setCommand("breakpoint", "list") |
