| ##===-- sourcewin.py -----------------------------------------*- Python -*-===## |
| ## |
| # The LLVM Compiler Infrastructure |
| ## |
| # This file is distributed under the University of Illinois Open Source |
| # License. See LICENSE.TXT for details. |
| ## |
| ##===----------------------------------------------------------------------===## |
| |
| import cui |
| import curses |
| import lldb |
| import lldbutil |
| import re |
| import os |
| |
| |
| class SourceWin(cui.TitledWin): |
| |
| def __init__(self, driver, x, y, w, h): |
| super(SourceWin, self).__init__(x, y, w, h, "Source") |
| self.sourceman = driver.getSourceManager() |
| self.sources = {} |
| |
| self.filename = None |
| self.pc_line = None |
| self.viewline = 0 |
| |
| self.breakpoints = {} |
| |
| self.win.scrollok(1) |
| |
| self.markerPC = ":) " |
| self.markerBP = "B> " |
| self.markerNone = " " |
| |
| try: |
| from pygments.formatters import TerminalFormatter |
| self.formatter = TerminalFormatter() |
| except ImportError: |
| #self.win.addstr("\nWarning: no 'pygments' library found. Syntax highlighting is disabled.") |
| self.lexer = None |
| self.formatter = None |
| pass |
| |
| # FIXME: syntax highlight broken |
| self.formatter = None |
| self.lexer = None |
| |
| def handleEvent(self, event): |
| if isinstance(event, int): |
| self.handleKey(event) |
| return |
| |
| if isinstance(event, lldb.SBEvent): |
| if lldb.SBBreakpoint.EventIsBreakpointEvent(event): |
| self.handleBPEvent(event) |
| |
| if lldb.SBProcess.EventIsProcessEvent(event) and \ |
| not lldb.SBProcess.GetRestartedFromEvent(event): |
| process = lldb.SBProcess.GetProcessFromEvent(event) |
| if not process.IsValid(): |
| return |
| if process.GetState() == lldb.eStateStopped: |
| self.refreshSource(process) |
| elif process.GetState() == lldb.eStateExited: |
| self.notifyExited(process) |
| |
| def notifyExited(self, process): |
| self.win.erase() |
| target = lldbutil.get_description(process.GetTarget()) |
| pid = process.GetProcessID() |
| ec = process.GetExitStatus() |
| self.win.addstr( |
| "\nProcess %s [%d] has exited with exit-code %d" % |
| (target, pid, ec)) |
| |
| def pageUp(self): |
| if self.viewline > 0: |
| self.viewline = self.viewline - 1 |
| self.refreshSource() |
| |
| def pageDown(self): |
| if self.viewline < len(self.content) - self.height + 1: |
| self.viewline = self.viewline + 1 |
| self.refreshSource() |
| pass |
| |
| def handleKey(self, key): |
| if key == curses.KEY_DOWN: |
| self.pageDown() |
| elif key == curses.KEY_UP: |
| self.pageUp() |
| |
| def updateViewline(self): |
| half = self.height / 2 |
| if self.pc_line < half: |
| self.viewline = 0 |
| else: |
| self.viewline = self.pc_line - half + 1 |
| |
| if self.viewline < 0: |
| raise Exception( |
| "negative viewline: pc=%d viewline=%d" % |
| (self.pc_line, self.viewline)) |
| |
| def refreshSource(self, process=None): |
| (self.height, self.width) = self.win.getmaxyx() |
| |
| if process is not None: |
| loc = process.GetSelectedThread().GetSelectedFrame().GetLineEntry() |
| f = loc.GetFileSpec() |
| self.pc_line = loc.GetLine() |
| |
| if not f.IsValid(): |
| self.win.addstr(0, 0, "Invalid source file") |
| return |
| |
| self.filename = f.GetFilename() |
| path = os.path.join(f.GetDirectory(), self.filename) |
| self.setTitle(path) |
| self.content = self.getContent(path) |
| self.updateViewline() |
| |
| if self.filename is None: |
| return |
| |
| if self.formatter is not None: |
| from pygments.lexers import get_lexer_for_filename |
| self.lexer = get_lexer_for_filename(self.filename) |
| |
| bps = [] if not self.filename in self.breakpoints else self.breakpoints[self.filename] |
| self.win.erase() |
| if self.content: |
| self.formatContent(self.content, self.pc_line, bps) |
| |
| def getContent(self, path): |
| content = [] |
| if path in self.sources: |
| content = self.sources[path] |
| else: |
| if os.path.exists(path): |
| with open(path) as x: |
| content = x.readlines() |
| self.sources[path] = content |
| return content |
| |
| def formatContent(self, content, pc_line, breakpoints): |
| source = "" |
| count = 1 |
| self.win.erase() |
| end = min(len(content), self.viewline + self.height) |
| for i in range(self.viewline, end): |
| line_num = i + 1 |
| marker = self.markerNone |
| attr = curses.A_NORMAL |
| if line_num == pc_line: |
| attr = curses.A_REVERSE |
| if line_num in breakpoints: |
| marker = self.markerBP |
| line = "%s%3d %s" % (marker, line_num, self.highlight(content[i])) |
| if len(line) >= self.width: |
| line = line[0:self.width - 1] + "\n" |
| self.win.addstr(line, attr) |
| source += line |
| count = count + 1 |
| return source |
| |
| def highlight(self, source): |
| if self.lexer and self.formatter: |
| from pygments import highlight |
| return highlight(source, self.lexer, self.formatter) |
| else: |
| return source |
| |
| def addBPLocations(self, locations): |
| for path in locations: |
| lines = locations[path] |
| if path in self.breakpoints: |
| self.breakpoints[path].update(lines) |
| else: |
| self.breakpoints[path] = lines |
| |
| def removeBPLocations(self, locations): |
| for path in locations: |
| lines = locations[path] |
| if path in self.breakpoints: |
| self.breakpoints[path].difference_update(lines) |
| else: |
| raise "Removing locations that were never added...no good" |
| |
| def handleBPEvent(self, event): |
| def getLocations(event): |
| locs = {} |
| |
| bp = lldb.SBBreakpoint.GetBreakpointFromEvent(event) |
| |
| if bp.IsInternal(): |
| # don't show anything for internal breakpoints |
| return |
| |
| for location in bp: |
| # hack! getting the LineEntry via SBBreakpointLocation.GetAddress.GetLineEntry does not work good for |
| # inlined frames, so we get the description (which does take |
| # into account inlined functions) and parse it. |
| desc = lldbutil.get_description( |
| location, lldb.eDescriptionLevelFull) |
| match = re.search('at\ ([^:]+):([\d]+)', desc) |
| try: |
| path = match.group(1) |
| line = int(match.group(2).strip()) |
| except ValueError as e: |
| # bp loc unparsable |
| continue |
| |
| if path in locs: |
| locs[path].add(line) |
| else: |
| locs[path] = set([line]) |
| return locs |
| |
| event_type = lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event) |
| if event_type == lldb.eBreakpointEventTypeEnabled \ |
| or event_type == lldb.eBreakpointEventTypeAdded \ |
| or event_type == lldb.eBreakpointEventTypeLocationsResolved \ |
| or event_type == lldb.eBreakpointEventTypeLocationsAdded: |
| self.addBPLocations(getLocations(event)) |
| elif event_type == lldb.eBreakpointEventTypeRemoved \ |
| or event_type == lldb.eBreakpointEventTypeLocationsRemoved \ |
| or event_type == lldb.eBreakpointEventTypeDisabled: |
| self.removeBPLocations(getLocations(event)) |
| elif event_type == lldb.eBreakpointEventTypeCommandChanged \ |
| or event_type == lldb.eBreakpointEventTypeConditionChanged \ |
| or event_type == lldb.eBreakpointEventTypeIgnoreChanged \ |
| or event_type == lldb.eBreakpointEventTypeThreadChanged \ |
| or event_type == lldb.eBreakpointEventTypeInvalidType: |
| # no-op |
| pass |
| self.refreshSource() |
