sublimegdb.py

"""
Copyright (c) 2012 Fredrik Ehnbom

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

   1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

   3. This notice may not be removed or altered from any source
   distribution.
"""
import sublime
import sublime_plugin
import subprocess
import struct
import tempfile
import threading
import time
import traceback
import os
import sys
import re
from datetime import datetime
from functools import partial
try:
    import Queue
    from resultparser import parse_result_line

    def sencode(s):
        return s.encode("utf-8")

    def sdecode(s):
        return s

    def bencode(s):
        return s
    def bdecode(s):
        return s
except:
    def sencode(s):
        return s

    def sdecode(s):
        return s

    def bencode(s):
        return s.encode("utf-8")

    def bdecode(s):
        return s.decode("utf-8")

    import queue as Queue
    from SublimeGDB.resultparser import parse_result_line

exec_settings = {}

def get_setting(key, default=None, view=None):
    try:
        if view is None:
            view = sublime.active_window().active_view()
        s = view.settings()

        # Try executable specific settings first
        if exec_settings and key in exec_settings:
            return exec_settings[key]
        # Then try user settings
        if s.has("sublimegdb_%s" % key):
            return s.get("sublimegdb_%s" % key)
    except:
        pass

    # Default settings
    return sublime.load_settings("SublimeGDB.sublime-settings").get(key, default)


def expand_path(value, window):
    if window is None:
        # Views can apparently be window less, in most instances getting
        # the active_window will be the right choice (for example when
        # previewing a file), but the one instance this is incorrect
        # is during Sublime Text 2 session restore. Apparently it's
        # possible for views to be windowless then too and since it's
        # possible that multiple windows are to be restored, the
        # "wrong" one for this view might be the active one and thus
        # ${project_path} will not be expanded correctly.
        #
        # This will have to remain a known documented issue unless
        # someone can think of something that should be done plugin
        # side to fix this.
        window = sublime.active_window()

    get_existing_files = \
        lambda m: [ path \
            for f in window.folders() \
            for path in [os.path.join(f, m.group('file'))] \
            if os.path.exists(path) \
        ]
    view = window.active_view()
    file_name = view.file_name();
    # replace variable with values
    if file_name:
        value = re.sub(r'\${file}', lambda m: file_name, value)
        value = re.sub(r'\${file_base_name}', lambda m: os.path.splitext(os.path.basename(file_name))[0], value)
    if os.getenv("HOME"):
        value = re.sub(r'\${home}', re.escape(os.getenv('HOME')), value)
    value = re.sub(r'\${env:(?P<variable>.*)}', lambda m: os.getenv(m.group('variable')), value)
    # search in projekt for path and get folder from path
    value = re.sub(r'\${project_path:(?P<file>[^}]+)}', lambda m: len(get_existing_files(m)) > 0 and get_existing_files(m)[0] or m.group('file'), value)
    value = re.sub(r'\${folder:(?P<file>.*)}', lambda m: os.path.dirname(m.group('file')), value)
    value = value.replace('\\', os.sep)
    value = value.replace('/', os.sep)

    return value


DEBUG = None
DEBUG_FILE = None
__debug_file_handle = None

gdb_lastresult = ""
gdb_lastline = ""
gdb_last_console_line = ""
gdb_cursor = ""
gdb_cursor_position = 0
gdb_last_cursor_view = None
gdb_bkp_layout = {}
gdb_bkp_window = None
gdb_bkp_view = None

gdb_python_command_running = False
gdb_shutting_down = False
gdb_process = None
gdb_server_process = None
gdb_threads = []
gdb_stack_frame = None
gdb_stack_index = 0

gdb_nonstop = False

if os.name == 'nt':
    gdb_nonstop = False

gdb_run_status = None
result_regex = re.compile("(?<=\^)[^,\"]*")
collapse_regex = re.compile("{.*}", re.DOTALL)


def normalize(filename):
    if filename is None:
        return None
    return os.path.abspath(os.path.normcase(filename))


def log_debug(line):
    global __debug_file_handle
    global DEBUG
    if DEBUG:
        try:
            if __debug_file_handle is None:
                if DEBUG_FILE == "stdout":
                    __debug_file_handle = sys.stdout
                else:
                    __debug_file_handle = open(DEBUG_FILE, 'a')
            __debug_file_handle.write(line)
        except:
            sublime.error_message("Couldn't write to the debug file. Debug writes will be disabled for this session.\n\nDebug file name used:\n%s\n\nError message\n:%s" % (DEBUG_FILE, traceback.format_exc()))
            DEBUG = False


class GDBView(object):
    def __init__(self, name, s=True, settingsprefix=None):
        self.queue = Queue.Queue()
        self.name = name
        self.closed = True
        self.doScroll = s
        self.view = None
        self.settingsprefix = settingsprefix
        self.timer = None
        self.lines = ""
        self.lock = threading.RLock()

    def is_open(self):
        return not self.closed

    def open_at_start(self):
        if self.settingsprefix is not None:
            return get_setting("%s_open" % self.settingsprefix, False)
        return False

    def open(self):
        if self.view is None or self.view.window() is None:
            if self.settingsprefix is not None:
                sublime.active_window().focus_group(get_setting("%s_group" % self.settingsprefix, 0))
            self.create_view()

    def close(self):
        if self.view is not None:
            if self.settingsprefix is not None:
                sublime.active_window().focus_group(get_setting("%s_group" % self.settingsprefix, 0))
            self.destroy_view()

    def should_update(self):
        return self.is_open() and is_running() and gdb_run_status == "stopped"

    def set_syntax(self, syntax):
        if self.is_open():
            self.get_view().set_syntax_file(syntax)


    def timed_add(self):
        try:
            self.lock.acquire()
            lines = self.lines
            self.lines = ""
            self.timer = None
            self.queue.put((self.do_add_line, lines))
            sublime.set_timeout(self.update, 0)
        finally:
            self.lock.release()


    def add_line(self, line, now=True):
        if self.is_open():
            try:
                self.lock.acquire()
                self.lines += line
                if self.timer:
                    self.timer.cancel()
                if self.lines.count("\n") > 10 or now:
                    self.timed_add()
                else:
                    self.timer = threading.Timer(0.1, self.timed_add)
                    self.timer.start()
            finally:
                self.lock.release()

    def scroll(self, line):
        if self.is_open():
            self.queue.put((self.do_scroll, line))
            sublime.set_timeout(self.update, 0)

    def set_viewport_position(self, pos):
        if self.is_open():
            self.queue.put((self.do_set_viewport_position, pos))
            sublime.set_timeout(self.update, 0)

    def clear(self, now=False):
        if self.is_open():
            if not now:
                self.queue.put((self.do_clear, None))
                sublime.set_timeout(self.update, 0)
            else:
                self.do_clear(None)

    def create_view(self):
        self.view = sublime.active_window().new_file()
        self.view.set_name(self.name)
        self.view.set_scratch(True)
        self.view.set_read_only(True)
        self.view.settings().set("scroll_past_end", False)
        # Setting command_mode to false so that vintage
        # does not eat the "enter" keybinding
        self.view.settings().set('command_mode', False)
        self.closed = False

    def destroy_view(self):
        sublime.active_window().focus_view(self.view)
        sublime.active_window().run_command("close")
        self.view = None
        self.closed = True

    def is_closed(self):
        return self.closed

    def was_closed(self):
        self.closed = True

    def fold_all(self):
        if self.is_open():
            self.queue.put((self.do_fold_all, None))

    def get_view(self):
        return self.view

    def do_add_line(self, line):
        self.view.run_command("gdb_view_add_line", {"line": line, "doScroll": self.doScroll})

    def do_fold_all(self, data):
        self.view.run_command("fold_all")

    def do_clear(self, data):
        self.view.run_command("gdb_view_clear")

    def do_scroll(self, data):
        self.view.run_command("goto_line", {"line": data + 1})

    def do_move_to_eof(self):
        if self.view:
            self.view.run_command("move_to", { "to": "eof", "extend": False })

    def do_set_viewport_position(self, data):
        # Shouldn't have to call viewport_extent, but it
        # seems to flush whatever value is stale so that
        # the following set_viewport_position works.
        # Keeping it around as a WAR until it's fixed
        # in Sublime Text 2.
        self.view.viewport_extent()
        self.view.set_viewport_position(data, False)

    def update(self):
        if not self.is_open():
            return
        try:
            while not self.queue.empty():
                cmd, data = self.queue.get()
                try:
                    cmd(data)
                finally:
                    self.queue.task_done()
        except:
            traceback.print_exc()

    def on_activated(self):
        # scroll to the end of the view on first activation
        if self.doScroll and self.view.visible_region().empty():
            # need a timeout because apparently a view can't be scrolled until
            # it has been fully activated once
            sublime.set_timeout(self.do_move_to_eof, 20)

    def on_session_ended(self):
        if get_setting("%s_clear_on_end" % self.settingsprefix, True):
            self.clear()


class GdbViewClear(sublime_plugin.TextCommand):
    def run(self, edit):
        self.view.set_read_only(False)
        self.view.erase(edit, sublime.Region(0, self.view.size()))
        self.view.set_read_only(True)

class GdbViewAddLine(sublime_plugin.TextCommand):
    def run(self, edit, line, doScroll):
        # force a scroll to the end if the last line is currently visible
        force_scroll = False
        if doScroll and self.view.visible_region().contains(self.view.size()):
            force_scroll = True

        self.view.run_command("append", { "characters": line, "force": True })

        if force_scroll:
            self.view.run_command("move_to", { "to": "eof", "extend": False })

class GDBVariable:
    def __init__(self, vp=None, parent=None):
        self.parent = parent
        self.valuepair = vp
        self.children = []
        self.line = 0
        self.is_expanded = False
        if "value" not in vp:
            self.update_value()
        self.dirty = False
        self.deleted = False

    def delete(self):
        run_cmd("-var-delete %s" % self.get_name())
        self.deleted = True

    def update_value(self):
        line = run_cmd("-var-evaluate-expression %s" % self["name"], True)
        if get_result(line) == "done":
            self['value'] = parse_result_line(line)["value"]

    def update(self, d):
        for key in d:
            if key.startswith("new_"):
                if key == "new_num_children":
                    self["numchild"] = d[key]
                else:
                    self[key[4:]] = d[key]
            else:
                self[key] = d[key]
        if (('dynamic' in self) and ('dynamic' not in d)):
            del self['dynamic']

    def is_existing(self):
        # if there is a parent this variable should be existing
        if self.parent:
            return True

        # try to find the line where this variable was declared
        output = run_python_cmd("python print(gdb.lookup_symbol(\"%s\")[0].line)" % self["exp"], True)
        try:
            line = int(output)

            # if the cursor is after this position the variable should be
            # existing
            if gdb_cursor_position > line:
                return True
        except:
            pass

        return False

    def get_expression(self):
        expression = ""
        parent = self.parent
        while parent is not None:
            ispointer = "typecode" in parent and parent["typecode"] == "PTR"
            expression = "%s%s%s" % (parent["exp"], "->" if ispointer else ".", expression)
            parent = parent.parent
        expression += self["exp"]
        return expression

    def add_children(self, name):
        children = listify(parse_result_line(run_cmd("-var-list-children 1 \"%s\"" % name, True))["children"]["child"])
        for child in children:
            child = GDBVariable(child, parent=self)
            if child.get_name().endswith(".private") or \
                    child.get_name().endswith(".protected") or \
                    child.get_name().endswith(".public"):
                if child.has_children():
                    self.add_children(child.get_name())
            else:
                self.children.append(child)

    def is_editable(self):
        line = run_cmd("-var-show-attributes %s" % (self.get_name()), True)
        return "editable" in re.findall("(?<=attr=\")[a-z]+(?=\")", line)

    def edit_on_done(self, val):
        line = run_cmd("-var-assign %s \"%s\"" % (self.get_name(), val), True)
        if get_result(line) == "done":
            self.valuepair["value"] = parse_result_line(line)["value"]
            gdb_variables_view.update_variables(True)
        else:
            err = line[line.find("msg=") + 4:]
            sublime.status_message("Error: %s" % err)

    def find(self, name):
        if self.deleted:
            return None
        if name == self.get_name():
            return self
        elif name.startswith(self.get_name()):
            for child in self.children:
                ret = child.find(name)
                if ret is not None:
                    return ret
        return None

    def edit(self):
        sublime.active_window().show_input_panel("%s =" % self["exp"], self.valuepair["value"], self.edit_on_done, None, None)

    def get_name(self):
        return self.valuepair["name"]

    def expand(self):
        if not self.is_existing():
            return

        self.is_expanded = True
        if ((not self.children) and self.has_children()):
            self.add_children(self.get_name())

    def has_children(self):
        if (int(self["numchild"]) > 0 or
                (self.is_dynamic and int(self.valuepair.get("has_more", 0)) > 0)):
            return True

        # for dynamic child variables the has_more field is not available so we
        # have to actually list the children to find out if there are any
        if self.is_dynamic and self.is_existing():
            children = parse_result_line(run_cmd("-var-list-children \"%s\"" % self.get_name(), True))
            return int(children["numchild"]) > 0

        return False

    def collapse(self):
        self.is_expanded = False

    def __str__(self):
        # apply the user-defined filters to the type
        type = self.filter_type(self['type'])

        if not "dynamic_type" in self or len(self['dynamic_type']) == 0 or self['dynamic_type'] == self['type']:
            return "%s %s = %s" % (type, self['exp'], self['value'])
        else:
            return "%s %s = (%s) %s" % (type, self['exp'], self['dynamic_type'], self['value'])

    def __iter__(self):
        return self.valuepair.__iter__()

    def __getitem__(self, key):
        return self.valuepair[key]

    def __setitem__(self, key, value):
        self.valuepair[key] = value
        if key == "value":
            self.dirty = True

    @property
    def is_dynamic(self):
        return ('dynamic' in self)

    def update_from(self, var):
        if (var.is_expanded):
            self.expand()
            for child in self.children:
                otherChild = var.find_child_expression(child["exp"])
                if (otherChild):
                    child.update_from(otherChild)
                else:
                    child.dirty = True
        self.dirty = (self["value"] != var["value"])

    def find_child_expression(self, exp):
        for child in self.children:
            if (child["exp"] == exp):
                return child
        return None

    def clear_dirty(self):
        self.dirty = False
        for child in self.children:
            child.clear_dirty()

    def is_dirty(self):
        dirt = self.dirty
        if not dirt and not self.is_expanded:
            for child in self.children:
                if child.is_dirty():
                    dirt = True
                    break
        return dirt

    def format(self, indent="", output="", line=0, dirty=[]):
        icon = " "
        if self.has_children():
            if self.is_expanded:
                icon = "-"
            else:
                icon = "+"

        output += "%s%s%s\n" % (indent, icon, self)
        self.line = line
        line = line + 1
        indent += "    "
        if self.is_expanded:
            for child in self.children:
                output, line = child.format(indent, output, line, dirty)
        if self.is_dirty():
            dirty.append(self)
        return (output, line)

    @staticmethod
    def filter_type(type):
        # use the regex module instead of re if available
        sub = re.sub
        try:
            import regex
            sub = regex.sub
        except:
            pass

        # apply all user-defined filters
        filters = get_setting("type_filters", [], gdb_variables_view)
        for f in filters:
            type = sub(f["pattern"], f["replace"], type)

        return type

def qtod(q):
    val = struct.pack("Q", q)
    return struct.unpack("d", val)[0]

def itof(i):
    val = struct.pack("I", i)
    return struct.unpack("f", val)[0]

class GDBRegister:
    def __init__(self, name, index, val):
        self.name = name
        self.index = index
        self.value = val
        self.line = 0
        self.lines = 0

    def format(self, line=0):
        val = self.value
        if  "{" not in val and re.match(r"[\da-yA-Fx]+", val):
            valh = int(val, 16)&0xffffffffffffffffffffffffffffffff
            six4 = False
            if valh > 0xffffffff:
                six4 = True
            val = struct.pack("Q" if six4 else "I", valh)
            valf = struct.unpack("d" if six4 else "f", val)[0]
            valI = struct.unpack("Q" if six4 else "I", val)[0]
            vali = struct.unpack("q" if six4 else "i", val)[0]

            val = "0x%016x %16.8f %020d %020d" % (valh, valf, valI, vali)
        elif "{" in val:
            match = re.search(r"(.*v4_float\s*=\s*\{)([^}]+)(\}.*v4_int32\s*=\s*\{([^\}]+)\}.*)", val)
            if match:
                floats = re.findall(r"0x[^,\}]+", match.group(4))
                if len(floats) == 4:
                    floats = [str(itof(int(f, 16))) for f in floats]
                    val = match.expand(r"\g<1>%s\g<3>" % ", ".join(floats))
            match = re.search(r"(.*v2_double\s*=\s*\{)([^}]+)(\}.*v2_int64\s*=\s*\{([^\}]+)\}.*)", val)
            if match:
                doubles = re.findall(r"0x[^,\}]+", match.group(4))
                if len(doubles) == 2:
                    doubles = [str(qtod(int(f, 16))) for f in doubles]
                    val = match.expand(r"\g<1>%s\g<3>" % ", ".join(doubles))

        output = "%8s: %s\n" % (self.name, val)
        self.line = line
        line += output.count("\n")
        self.lines = line - self.line
        return (output, line)

    def set_value(self, val):
        self.value = val

    def set_gdb_value(self, val):
        if "." in val:
            if val.endswith("f"):
                val = struct.unpack("I", struct.pack("f", float(val[:-1])))[0]
            else:
                val = struct.unpack("Q", struct.pack("d", float(val)))[0]

        run_cmd("-data-evaluate-expression $%s=%s" % (self.name, val))

    def edit_on_done(self, val):
        self.set_gdb_value(val)
        gdb_register_view.update_values()

    def edit(self):
        sublime.active_window().show_input_panel("$%s =" % self.name, self.value, self.edit_on_done, None, None)


class GDBRegisterView(GDBView):
    def __init__(self):
        super(GDBRegisterView, self).__init__("GDB Registers", s=False, settingsprefix="registers")
        self.values = None

    def open(self):
        super(GDBRegisterView, self).open()
        self.set_syntax("Packages/SublimeGDB/gdb_registers.tmLanguage")
        self.get_view().settings().set("word_wrap", False)
        if self.is_open() and gdb_run_status == "stopped":
            self.update_values()

    def get_names(self):
        line = run_cmd("-data-list-register-names", True)
        return parse_result_line(line)["register-names"]

    def get_values(self):
        line = run_cmd("-data-list-register-values x", True)
        if get_result(line) != "done":
            return []
        return parse_result_line(line)["register-values"]

    def update_values(self):
        if not self.should_update():
            return
        dirtylist = []
        if self.values is None:
            names = self.get_names()
            vals = self.get_values()
            self.values = []

            for i in range(len(vals)):
                idx = int(vals[i]["number"])
                self.values.append(GDBRegister(names[idx], idx, vals[i]["value"]))
        else:
            dirtylist = regs = parse_result_line(run_cmd("-data-list-changed-registers", True))["changed-registers"]
            regvals = parse_result_line(run_cmd("-data-list-register-values x %s" % " ".join(regs), True))["register-values"]
            for i in range(len(regs)):
                reg = int(regvals[i]["number"])
                if reg < len(self.values):
                    self.values[reg].set_value(regvals[i]["value"])
        pos = self.get_view().viewport_position()
        self.clear()
        line = 0
        for item in self.values:
            output, line = item.format(line)
            self.add_line(output)
        self.set_viewport_position(pos)
        self.update()
        regions = []
        v = self.get_view()
        for dirty in dirtylist:
            i = int(dirty)
            if i >= len(self.values):
                continue
            region = v.full_line(v.text_point(self.values[i].line, 0))
            if self.values[i].lines > 1:
                region = region.cover(v.full_line(v.text_point(self.values[i].line + self.values[i].lines - 1, 0)))

            regions.append(region)
        v.add_regions("sublimegdb.dirtyregisters", regions,
                        get_setting("changed_variable_scope", "entity.name.class"),
                        get_setting("changed_variable_icon", ""),
                        sublime.DRAW_OUTLINED)

    def get_register_at_line(self, line):
        if self.values is None:
            return None
        for i in range(len(self.values)):
            if self.values[i].line == line:
                return self.values[i]
            elif self.values[i].line > line:
                return self.values[i - 1]
        return None


class GDBVariablesView(GDBView):
    def __init__(self):
        super(GDBVariablesView, self).__init__("GDB Variables", False, settingsprefix="variables")
        self.variables = []

    def open(self):
        super(GDBVariablesView, self).open()
        self.set_syntax("Packages/C++/C++.tmLanguage")
        if self.is_open() and gdb_run_status == "stopped":
            self.update_variables(False)

    def update_view(self):
        self.clear()
        output = ""
        line = 0
        dirtylist = []
        for local in self.variables:
            output, line = local.format(line=line, dirty=dirtylist)
            self.add_line(output)
        self.update()
        regions = []
        v = self.get_view()
        for dirty in dirtylist:
            regions.append(v.full_line(v.text_point(dirty.line, 0)))
        v.add_regions("sublimegdb.dirtyvariables", regions,
                        get_setting("changed_variable_scope", "entity.name.class"),
                        get_setting("changed_variable_icon", ""),
                        sublime.DRAW_OUTLINED)

    def extract_varnames(self, res):
        if "name" in res:
            return listify(res["name"])
        elif len(res) > 0 and isinstance(res, list):
            if "name" in res[0]:
                return [x["name"] for x in res]
        return []

    def add_variable(self, exp):
        v = self.create_variable(exp)
        if v:
            self.variables.append(v)

    def create_variable(self, exp, show_error = True):
        line = run_cmd("-var-create - * %s" % exp, True)
        if get_result(line, False) == "error" and "&" in exp:
            line = run_cmd("-var-create - * %s" % exp.replace("&", ""), True)
        if get_result(line, show_error) == "error":
            return None
        var = parse_result_line(line)
        var['exp'] = exp
        return GDBVariable(var)

    def update_variables(self, sameFrame):
        if not self.should_update():
            return
        if sameFrame:
            variables = []
            for var in self.variables:    # completely replace dynamic variables because we don't always get proper update notifications
                if (var.is_dynamic):
                    var.delete()
                    newVar = self.create_variable(var['exp'], False)
                    if (newVar):    # may have gone out of scope without notification
                        newVar.update_from(var)
                        variables.append(newVar)
                else:
                    var.clear_dirty()
                    variables.append(var)
            self.variables = variables
            ret = parse_result_line(run_cmd("-var-update --all-values *", True))["changelist"]
            if "varobj" in ret:
                ret = listify(ret["varobj"])
            dellist = []
            for value in ret:
                name = value["name"]
                for var in self.variables:
                    real = var.find(name)
                    if (real is not None):
                        if  "in_scope" in value and value["in_scope"] == "false":
                            real.delete()
                            dellist.append(real)
                            continue
                        if (not real.is_dynamic):
                            real.update(value)
                            if not "value" in value and not "new_value" in value:
                                real.update_value()
                        break
            for item in dellist:
                self.variables.remove(item)
            if len(self.variables) == 0:
                # Is it really the same frame? Seems everything was removed, so might as well pull all data again
                sameFrame = False
            else:
                loc = self.extract_varnames(parse_result_line(run_cmd("-stack-list-locals 0", True))["locals"])
                tracked = []
                for var in loc:
                    create = True
                    for var2 in self.variables:
                        if var2['exp'] == var and var2 not in tracked:
                            tracked.append(var2)
                            create = False
                            break
                    if create:
                        self.add_variable(var)

        if not sameFrame:
            for var in self.variables:
                var.delete()
            args = self.extract_varnames(parse_result_line(run_cmd("-stack-list-arguments 0 %d %d" % (gdb_stack_index, gdb_stack_index), True))["stack-args"]["frame"]["args"])
            self.variables = []
            for arg in args:
                self.add_variable(arg)
            loc = self.extract_varnames(parse_result_line(run_cmd("-stack-list-locals 0", True))["locals"])
            for var in loc:
                self.add_variable(var)
        self.update_view()

    def get_variable_at_line(self, line, var_list=None):
        if var_list is None:
            var_list = self.variables
        if len(var_list) == 0:
            return None

        for i in range(len(var_list)):
            if var_list[i].line == line:
                return var_list[i]
            elif var_list[i].line > line:
                return self.get_variable_at_line(line, var_list[i - 1].children)
        return self.get_variable_at_line(line, var_list[len(var_list) - 1].children)

    def expand_collapse_variable(self, view, expand=True, toggle=False):
        row, col = view.rowcol(view.sel()[0].a)
        if self.is_open() and view.id() == self.get_view().id():
            var = self.get_variable_at_line(row)
            if var and var.has_children():
                if toggle:
                    if var.is_expanded:
                        var.collapse()
                    else:
                        var.expand()
                elif expand:
                    var.expand()
                else:
                    var.collapse()
                pos = view.viewport_position()
                self.update_view()
                self.set_viewport_position(pos)
                self.update()


class GDBCallstackFrame:
    def __init__(self, func, args):
        self.func = func
        self.args = args
        self.lines = 0

    def format(self):
        output = "%s(" % self.func
        for arg in self.args:
            if "name" in arg:
                output += arg["name"]
            if "value" in arg:
                val = arg["value"]
                val = collapse_regex.sub("{...}", val)
                output += " = %s" % val
            output += ","
        output += ");\n"
        self.lines = output.count("\n")
        return output


class GDBCallstackView(GDBView):
    def __init__(self):
        super(GDBCallstackView, self).__init__("GDB Callstack", settingsprefix="callstack")
        self.frames = []

    def open(self):
        super(GDBCallstackView, self).open()
        self.set_syntax("Packages/C++/C++.tmLanguage")
        if self.is_open() and gdb_run_status == "stopped":
            self.update_callstack()

    def update_callstack(self):
        if not self.should_update():
            return
        global gdb_cursor_position
        line = run_cmd("-stack-list-frames", True)
        if get_result(line) == "error":
            gdb_cursor_position = 0
            update_view_markers()
            return
        frames = listify(parse_result_line(line)["stack"]["frame"])
        args = listify(parse_result_line(run_cmd("-stack-list-arguments 1", True))["stack-args"]["frame"])
        pos = self.get_view().viewport_position()
        self.clear()

        self.frames = []
        for i in range(len(frames)):
            arg = {}
            if len(args) > i:
                arg = args[i]["args"]
            f = GDBCallstackFrame(frames[i]["func"], arg)
            self.frames.append(f)
            self.add_line(f.format())
        self.set_viewport_position(pos)
        self.update()

    def update_marker(self, pos_scope, pos_icon):
        if self.is_open():
            view = self.get_view()
            if gdb_stack_index != -1:
                line = 0
                for i in range(gdb_stack_index):
                    line += self.frames[i].lines

                view.add_regions("sublimegdb.stackframe",
                                    [view.line(view.text_point(line, 0))],
                                    pos_scope, pos_icon, sublime.HIDDEN)
            else:
                view.erase_regions("sublimegdb.stackframe")

    def select(self, row):
        line = 0
        for i in range(len(self.frames)):
            fl = self.frames[i].lines
            if row <= line + fl - 1:
                run_cmd("-stack-select-frame %d" % i)
                update_cursor()
                break
            line += fl


class GDBThread:
    def __init__(self, id, state="UNKNOWN", func="???()", details=None):
        self.id = id
        self.state = state
        self.func = func
        self.details = details

    def format(self):
        if self.details:
            return "%03d - %10s - %s - %s\n" % (self.id, self.state, self.details, self.func)
        else:
            return "%03d - %10s - %s\n" % (self.id, self.state, self.func)


class GDBThreadsView(GDBView):
    def __init__(self):
        super(GDBThreadsView, self).__init__("GDB Threads", s=False, settingsprefix="threads")
        self.threads = []
        self.current_thread = 0

    def open(self):
        super(GDBThreadsView, self).open()
        self.set_syntax("Packages/C++/C++.tmLanguage")
        if self.is_open() and gdb_run_status == "stopped":
            self.update_threads()

    def update_threads(self):
        if not self.should_update():
            return
        res = run_cmd("-thread-info", True)
        ids = parse_result_line(run_cmd("-thread-list-ids", True))
        if get_result(res) == "error":
            if "thread-ids" in ids and "thread-id" in ids["thread-ids"]:
                self.threads = [GDBThread(int(id)) for id in ids["thread-ids"]["thread-id"]]
                if "threads" in ids and "thread" in ids["threads"]:
                    for thread in ids["threads"]["thread"]:
                        if "thread-id" in thread and "state" in thread:
                            tid = int(thread["thread-id"])
                            for t2 in self.threads:
                                if t2.id == tid:
                                    t2.state = thread["state"]
                                    break
                else:
                    l = parse_result_line(run_cmd("-thread-info", True))
            else:
                self.threads = []
        else:
            l = parse_result_line(res)
            self.threads = []
            for thread in l["threads"]:
                func = "???"
                if "frame" in thread and "func" in thread["frame"]:
                    func = thread["frame"]["func"]
                    args = ""
                    if "args" in thread["frame"]:
                        for arg in thread["frame"]["args"]:
                            if len(args) > 0:
                                args += ", "
                            if "name" in arg:
                                args += arg["name"]
                            if "value" in arg:
                                args += " = " + arg["value"]
                    func = "%s(%s);" % (func, args)
                log_debug("thread %s" % thread)
                self.threads.append(GDBThread(int(thread["id"]), thread["state"], func, thread.get("details")))

        if "current-thread-id" in ids:
            self.current_thread = int(ids["current-thread-id"])
        pos = self.get_view().viewport_position()
        self.clear()
        self.threads.sort(key=lambda t: t.id)
        for thread in self.threads:
            self.add_line(thread.format())
        self.set_viewport_position(pos)
        self.update()

    def update_marker(self, pos_scope, pos_icon):
        if self.is_open():
            view = self.get_view()
            line = -1
            for i in range(len(self.threads)):
                if self.threads[i].id == self.current_thread:
                    line = i
                    break

            if line != -1:
                view.add_regions("sublimegdb.currentthread",
                                    [view.line(view.text_point(line, 0))],
                                    pos_scope, pos_icon, sublime.HIDDEN)
            else:
                view.erase_regions("sublimegdb.currentthread")

    def select_thread(self, thread):
        run_cmd("-thread-select %d" % thread)
        self.current_thread = thread

    def select(self, row):
        if row >= len(self.threads):
            return
        self.select_thread(self.threads[row].id)


class GDBDisassemblyView(GDBView):
    def __init__(self):
        super(GDBDisassemblyView, self).__init__("GDB Disassembly", s=False, settingsprefix="disassembly")
        self.start = -1
        self.end = -1

    def open(self):
        super(GDBDisassemblyView, self).open()
        self.set_syntax("Packages/SublimeGDB/gdb_disasm.tmLanguage")
        self.get_view().settings().set("word_wrap", False)
        if self.is_open() and gdb_run_status == "stopped":
            self.update_disassembly()

    def clear(self):
        super(GDBDisassemblyView, self).clear()
        self.start = -1
        self.end = -1

    def add_insns(self, src_asm):
        for asm in src_asm:
            line = "%s: %s" % (asm["address"], asm["inst"])
            if "func-name" in asm:
                self.add_line("%-80s # %s+%s\n" % (line, asm["func-name"], asm["offset"]))
            else:
                self.add_line("%s\n" % line)
            addr = int(asm["address"], 16)
            if self.start == -1 or addr < self.start:
                self.start = addr
            self.end = addr

    def update_disassembly(self):
        if not self.should_update():
            return
        pc = parse_result_line(run_cmd("-data-evaluate-expression $pc", True))["value"]
        if " " in pc:
            pc = pc[:pc.find(" ")]
        pc = int(pc, 16)
        if not (pc >= self.start and pc <= self.end):
            l = run_cmd("-data-disassemble -s \"$pc-32\" -e \"$pc+200\" -- 1", True)
            asms = parse_result_line(l)
            self.clear()
            if get_result(l) != "error":
                asms = asms["asm_insns"]
                if "src_and_asm_line" in asms:
                    l = listify(asms["src_and_asm_line"])
                    for src_asm in l:
                        line = src_asm["line"]
                        file = src_asm["file"]
                        self.add_line("%s:%s\n" % (file, line))
                        self.add_insns(src_asm["line_asm_insn"])
                else:
                    self.add_insns(asms)
            self.update()
        view = self.get_view()
        reg = view.find("^0x[0]*%x:" % pc, 0)
        if reg is None:
            view.erase_regions("sublimegdb.programcounter")
        else:
            pos_scope = get_setting("position_scope", "entity.name.class")
            pos_icon = get_setting("position_icon", "bookmark")
            view.add_regions("sublimegdb.programcounter",
                            [reg],
                            pos_scope, pos_icon, sublime.HIDDEN)


class GDBBreakpoint(object):
    def __init__(self, filename="", line=0, addr=""):
        self.original_filename = normalize(filename)
        self.original_line = line
        self.addr = addr
        self.modified_line = None
        self.clear()
        self.add()

    @property
    def line(self):
        if self.modified_line:
            return self.modified_line
        if self.number != -1:
            return self.resolved_line
        return self.original_line

    @property
    def filename(self):
        if self.number != -1:
            return normalize(self.resolved_filename)
        return normalize(self.original_filename)

    def clear(self):
        self.resolved_filename = ""
        self.resolved_line = 0
        self.number = -1

        if self.modified_line and not is_running():
            # the next GDB runs we will use the modified line
            self.original_line = self.modified_line
            self.modified_line = None

    def breakpoint_added(self, res):
        if "bkpt" not in res:
            return
        bp = res["bkpt"]
        if isinstance(bp, list): # choose the last of multiple entries
            bp = bp[-1]
        if "fullname" in bp:
            self.resolved_filename = bp["fullname"]
        elif "file" in bp:
            self.resolved_filename = bp["file"]
        elif "original-location" in bp and self.addr == 0:
            self.resolved_filename = bp["original-location"].split(":", 1)[0]
            self.resolved_line = int(bp["original-location"].split(":", 1)[1])

        if self.resolved_line == 0 and "line" in bp:
            self.resolved_line = int(bp["line"])

        if not "/" in self.resolved_filename and not "\\" in self.resolved_filename:
            self.resolved_filename = self.original_filename
        self.number = int(bp["number"].split(".")[0])

    def insert(self):
        # TODO: does removing the unicode-escape break things? what's the proper way to handle this in python3?
        # cmd = "-break-insert \"\\\"%s\\\":%d\"" % (self.original_filename.encode("unicode-escape"), self.original_line)
        break_cmd = "-break-insert"
        if get_setting("debug_ext") == True:
            break_cmd += " -f"
        if self.addr != "":
            cmd = "%s *%s" % (break_cmd, self.addr)
        else:
            cmd = "%s \"\\\"%s\\\":%d\"" % (break_cmd, self.original_filename.replace("\\", "/"), self.original_line)
        out = run_cmd(cmd, True)
        if get_result(out) == "error":
            return
        res = parse_result_line(out)
        if "bkpt" not in res and "matches" in res:
            for match in res["matches"]["b"]:
                cmd = "%s *%s" % (break_cmd, match["addr"])
                out = run_cmd(cmd, True)
                if get_result(out) == "error":
                    return
                res = parse_result_line(out)
                self.breakpoint_added(res)
        else:
            self.breakpoint_added(res)

    def add(self):
        if is_running():
            res = wait_until_stopped()
            self.insert()
            if res:
                resume()

    def remove(self):
        if is_running():
            res = wait_until_stopped()
            run_cmd("-break-delete %s" % self.number)
            if res:
                resume()

    def format(self):
        return "%d - %s:%d\n" % (self.number, self.filename, self.line)


class GDBWatch(GDBBreakpoint):
    def __init__(self, exp):
        self.exp = exp
        super(GDBWatch, self).__init__(None, -1)

    def insert(self):
        out = run_cmd("-break-watch %s" % self.exp, True)
        res = parse_result_line(out)
        if get_result(out) == "error":
            return

        self.number = int(res["wpt"]["number"])

    def format(self):
        return "%d - watch: %s\n" % (self.number, self.exp)


class GDBBreakpointView(GDBView):
    def __init__(self):
        super(GDBBreakpointView, self).__init__("GDB Breakpoints", s=False, settingsprefix="breakpoints")
        self.breakpoints = []

    def open(self):
        super(GDBBreakpointView, self).open()
        # self.set_syntax("Packages/SublimeGDB/gdb_disasm.tmLanguage")
        self.get_view().settings().set("word_wrap", False)
        if self.is_open():
            self.update_view()

    def on_session_ended(self):
        # Intentionally not calling super
        for bkpt in self.breakpoints:
            bkpt.clear()

    def on_view_modified(self, view):
        if not self.breakpoints:
            return

        fn = view.file_name()
        if fn is None:
            return
        fn = normalize(fn)

        # use the modified regions to update the breakpoint locations
        cur_regions = view.get_regions("sublimegdb.breakpoints")

        # list of breakpoints with a line for this view
        bkpts = []
        for bkpt in self.breakpoints:
            if bkpt.filename == fn and bkpt.addr == "":
                bkpts.append(bkpt)

        # sorting the breakpoints by their last region brings them into the same
        # order as the current regions
        cur_regions.sort()
        bkpts.sort(key=lambda bkpt: bkpt.last_region)

        need_update = False
        for region, bkpt in zip(cur_regions, bkpts):
            # if the current region's line and the breakpoint's differ we need
            # to update it
            new_line = view.rowcol(region.begin())[0] + 1
            if new_line != bkpt.original_line:
                if not is_running():
                    bkpt.original_line = new_line
                else:
                    # this will only update the visible location of the
                    # breakpoint but GDB will still stop at the original
                    # location
                    bkpt.modified_line = new_line

                need_update = True

        if need_update:
            self.update_marker(view)
            self.update_view()

    def update_marker(self, view):
        bps = []
        fn = view.file_name()
        if fn is None:
            return
        fn = normalize(fn)
        for bkpt in self.breakpoints:
            # also add one for the current cursor position to allow updating the
            # breakpoints when the view is modified
            if bkpt.filename == fn:
                region = view.full_line(view.text_point(bkpt.line - 1, 0))

                # save this region  so that we can determine if it moved
                bkpt.last_region = region

                bps.append(region)

        view.add_regions("sublimegdb.breakpoints", bps,
                            get_setting("breakpoint_scope", "keyword.gdb"),
                            get_setting("breakpoint_icon", "circle"),
                            sublime.HIDDEN)

    def find_breakpoint(self, filename, line):
        filename = normalize(filename)
        for bkpt in self.breakpoints:
            if bkpt.filename == filename and bkpt.line == line:
                return bkpt
        return None

    def find_breakpoint_addr(self, addr):
        for bkpt in self.breakpoints:
            if bkpt.addr == addr:
                return bkpt
        return None

    def toggle_watch(self, exp):
        add = True
        for bkpt in self.breakpoints:
            if isinstance(bkpt, GDBWatch) and bkpt.exp == exp:
                add = False
                bkpt.remove()
                self.breakpoints.remove(bkpt)
                break

        if add:
            self.breakpoints.append(GDBWatch(exp))
        self.update_view()

    def toggle_breakpoint_addr(self, addr):
        bkpt = self.find_breakpoint_addr(addr)
        if bkpt:
            bkpt.remove()
            self.breakpoints.remove(bkpt)
        else:
            self.breakpoints.append(GDBBreakpoint(addr=addr))
        self.update_view()

    def toggle_breakpoint(self, filename, line):
        bkpt = self.find_breakpoint(filename, line)
        if bkpt:
            bkpt.remove()
            self.breakpoints.remove(bkpt)
        else:
            self.breakpoints.append(GDBBreakpoint(filename, line))
        self.update_view()

    def sync_breakpoints(self):
        global breakpoints
        for bkpt in self.breakpoints:
            bkpt.add()
        update_view_markers()
        self.update_view()

    def update_view(self):
        if not self.is_open():
            return
        pos = self.get_view().viewport_position()
        self.clear()
        self.breakpoints.sort(key=lambda b: (b.number, b.filename or "", b.line))
        for bkpt in self.breakpoints:
            self.add_line(bkpt.format())
        self.set_viewport_position(pos)
        self.update()


class GDBSessionView(GDBView):
    def __init__(self):
        super(GDBSessionView, self).__init__("GDB Session", s=True, settingsprefix="session")

    def open(self):
        super(GDBSessionView, self).open()
        self.set_syntax("Packages/SublimeGDB/gdb_session.tmLanguage")


gdb_session_view = GDBSessionView()
gdb_console_view = GDBView("GDB Console", s=True, settingsprefix="console")
gdb_variables_view = GDBVariablesView()
gdb_callstack_view = GDBCallstackView()
gdb_register_view = GDBRegisterView()
gdb_disassembly_view = GDBDisassemblyView()
gdb_threads_view = GDBThreadsView()
gdb_breakpoint_view = GDBBreakpointView()
gdb_views = [gdb_session_view, gdb_console_view, gdb_variables_view, gdb_callstack_view, gdb_register_view, gdb_disassembly_view, gdb_threads_view, gdb_breakpoint_view]

def update_view_markers(view=None):
    if view is None:
        view = sublime.active_window().active_view()

    fn = view.file_name()
    if fn is not None:
        fn = normalize(fn)
    pos_scope = get_setting("position_scope", "entity.name.class")
    pos_icon = get_setting("position_icon", "bookmark")

    cursor = []
    if fn == gdb_cursor and gdb_cursor_position != 0:
        cursor.append(view.full_line(view.text_point(gdb_cursor_position - 1, 0)))
    global gdb_last_cursor_view
    if gdb_last_cursor_view is not None:
        gdb_last_cursor_view.erase_regions("sublimegdb.position")
    gdb_last_cursor_view = view
    view.add_regions("sublimegdb.position", cursor, pos_scope, pos_icon, sublime.HIDDEN)

    gdb_callstack_view.update_marker(pos_scope, pos_icon)
    gdb_threads_view.update_marker(pos_scope, pos_icon)
    gdb_breakpoint_view.update_marker(view)

count = 0


def run_cmd(cmd, block=False, mimode=True, timeout=None):
    global count
    if not is_running():
        return "0^error,msg=\"no session running\""

    timeout = timeout or get_setting("gdb_command_timeout", 10)

    ### handle a list of commands by recursively calling run_cmd
    if isinstance(cmd, list):
        for c in cmd:
            run_cmd(c, block, mimode, timeout)
        return count

    if mimode:
        count = count + 1
        cmd = "%d%s\n" % (count, cmd)
    else:
        cmd = "%s\n\n" % cmd
    log_debug(cmd)

    start = datetime.now()
    if gdb_session_view is not None:
        gdb_session_view.add_line(cmd, False)
    gdb_process.stdin.write(cmd.encode(sys.getdefaultencoding()))
    gdb_process.stdin.flush()
    if block:
        countstr = "%d^" % count
        while not gdb_lastresult.startswith(countstr) and \
                (datetime.now() - start).total_seconds() <= timeout:
            time.sleep(0.001)
        if (datetime.now() - start).total_seconds() > timeout:
            raise ValueError("Command \"%s\" took longer than %d seconds to perform?" % (cmd, timeout))
        return gdb_lastresult
    return count


def run_python_cmd(cmd, block=False, timeout=None):
    global count
    global gdb_python_command_running
    global gdb_last_console_line
    if not is_running():
        return "0^error,msg=\"no session running\""

    timeout = timeout or get_setting("gdb_command_timeout", 10)

    count = count + 1
    cmd = "%d%s\n" % (count, cmd)
    log_debug(cmd)

    start = datetime.now()
    if gdb_session_view is not None:
        gdb_session_view.add_line(cmd, False)
    gdb_last_console_line = ""
    gdb_process.stdin.write(cmd.encode(sys.getdefaultencoding()))
    gdb_process.stdin.flush()
    if block:
        gdb_python_command_running = True
        try:
            countstr = "%d^" % count
            while not gdb_lastresult.startswith(countstr) and \
                    (datetime.now() - start).total_seconds() <= timeout:
                time.sleep(0.001)
            if (datetime.now() - start).total_seconds() > timeout:
                raise ValueError("Command \"%s\" took longer than %d seconds to perform?" % (cmd, timeout))
            return gdb_last_console_line
        finally:
            gdb_python_command_running = False
    return count


def wait_until_stopped():
    if gdb_run_status == "running":
        result = run_cmd("-exec-interrupt --all", True)
        if "^done" in result:
            i = 0
            while not "stopped" in gdb_run_status and i < 100:
                i = i + 1
                time.sleep(0.1)
            if i >= 100:
                log_debug("I'm confused... I think status is %s, but it seems it wasn't..." % gdb_run_status)
                return False
            return True
    return False


def resume():
    global gdb_run_status
    gdb_run_status = "running"
    run_cmd("-exec-continue", True)


def get_result(line, show_error = True):
    res = result_regex.search(line).group(0)
    if show_error and res == "error" and not get_setting("i_know_how_to_use_gdb_thank_you_very_much", False):
        sublime.error_message("%s\n\n%s" % (line, "\n".join(traceback.format_stack())))
    return res


def listify(var):
    if not isinstance(var, list):
        return [var]
    return var


def update_cursor():
    global gdb_cursor
    global gdb_cursor_position
    global gdb_stack_index
    global gdb_stack_frame

    if not get_setting("update_while_running", True) and gdb_run_status == "running":
        return

    res = run_cmd("-stack-info-frame", True)
    if get_result(res) == "error":
        if gdb_run_status != "running":
            log_debug("run_status is %s, but got error: %s" % (gdb_run_status, res))
            return
    currFrame = parse_result_line(res)["frame"]
    gdb_stack_index = int(currFrame["level"])

    if "fullname" in currFrame:
        gdb_cursor = currFrame["fullname"]
        gdb_cursor_position = int(currFrame["line"])
        sublime.active_window().focus_group(get_setting("file_group", 0))

        # If gdb_cursor is not the exact name of an already opened file, Sublime
        # Text will open a new view. To prevent that, look through all views to
        # find the file name to use.
        file_to_open = gdb_cursor
        try:
            for view in sublime.active_window().views():
                if view.file_name():
                    if os.path.samefile(gdb_cursor, view.file_name()):
                        file_to_open = view.file_name()
        except Exception:
            pass

        sublime.active_window().open_file("%s:%d" % (file_to_open, gdb_cursor_position), sublime.ENCODED_POSITION)
    else:
        gdb_cursor_position = 0

    sameFrame = gdb_stack_frame is not None and \
                gdb_stack_frame["func"] == currFrame["func"]
    if sameFrame and "shlibname" in currFrame and "shlibname" in gdb_stack_frame:
        sameFrame = currFrame["shlibname"] == gdb_stack_frame["shlibname"]
    if sameFrame and "fullname" in currFrame and "fullname" in gdb_stack_frame:
        sameFrame = currFrame["fullname"] == gdb_stack_frame["fullname"]

    gdb_stack_frame = currFrame
    # Always need to update the callstack since it's possible to
    # end up in the current function from many different call stacks
    gdb_callstack_view.update_callstack()
    gdb_threads_view.update_threads()

    update_view_markers()
    gdb_variables_view.update_variables(sameFrame)
    gdb_register_view.update_values()
    gdb_disassembly_view.update_disassembly()


def session_ended_status_message():
    sublime.status_message("GDB session ended")


def gdboutput(pipe):
    global gdb_process
    global gdb_lastresult
    global gdb_lastline
    global gdb_last_console_line
    global gdb_stack_frame
    global gdb_run_status
    global gdb_stack_index
    command_result_regex = re.compile("^\d+\^")
    run_status_regex = re.compile("(^\d*\*)([^,]+)")

    while True:
        try:
            raw = pipe.readline()
            if len(raw) == 0:
                log_debug("gdb_%s: broken pipe\n" % ("stdout" if pipe == gdb_process.stdout else "stderr"))
                break
            line = raw.strip().decode(sys.getdefaultencoding())
            log_debug("gdb_%s: %s\n" % ("stdout" if pipe == gdb_process.stdout else "stderr", line))
            gdb_session_view.add_line("%s\n" % line, False)

            if pipe != gdb_process.stdout:
                continue

            run_status = run_status_regex.match(line)
            if run_status is not None:
                gdb_run_status = run_status.group(2)
                reason = re.search("(?<=reason=\")[a-zA-Z0-9\-]+(?=\")", line)
                if reason is not None and reason.group(0).startswith("exited"):
                    log_debug("gdb: exiting %s" % line)
                    run_cmd("-gdb-exit")
                elif not "running" in gdb_run_status and not gdb_shutting_down:
                    thread_id = re.search('thread-id="(\d+)"', line)
                    if thread_id is not None:
                        gdb_threads_view.select_thread(int(thread_id.group(1)))
                    sublime.set_timeout(update_cursor, 0)
            if not line.startswith("(gdb)"):
                gdb_lastline = line
            if command_result_regex.match(line) is not None:
                gdb_lastresult = line

            if line.startswith("~"):
                console_line = line[2:-1].replace("\\n", "\n").replace("\\\"", "\"").replace("\\t", "\t")
                if not gdb_python_command_running:
                    gdb_console_view.add_line(console_line, False)

                # save the output (without the newline at the end)
                gdb_last_console_line = console_line[:-1]

            # filter out the program output and print it on the console view
            if not (line.startswith("(gdb)") or line.startswith("~") or
                    line.startswith("=") or line.startswith("&\"") or
                    command_result_regex.match(line) or
                    run_status_regex.match(line)):
                # use the raw output to show exactly what the program printed
                console_line = raw.decode(sys.getdefaultencoding())

                # correct the line endings
                console_line = "\n".join(console_line.splitlines())

                gdb_console_view.add_line("%s\n" % console_line, False)

        except:
            traceback.print_exc()
    if pipe == gdb_process.stdout:
        log_debug("GDB session ended\n")
        gdb_session_view.add_line("GDB session ended\n")
        sublime.set_timeout(session_ended_status_message, 0)
        gdb_stack_frame = None
    global gdb_cursor_position
    gdb_stack_index = -1
    gdb_cursor_position = 0
    gdb_run_status = None
    sublime.set_timeout(update_view_markers, 0)

    for view in gdb_views:
        sublime.set_timeout(view.on_session_ended, 0)
    sublime.set_timeout(cleanup, 0)

def cleanup():
    global __debug_file_handle
    global gdb_process
    global gdb_threads

    # make sure all our threads are done
    for t in gdb_threads:
        t.join(get_setting("gdb_timeout", 20))
    gdb_threads = []

    # unset the process variable to make sure all pipes and other OS objects are
    # released (this fixes different freezes when gdb is started multiple times)
    gdb_process = None

    if get_setting("close_views", True):
        for view in gdb_views:
            view.close()
    if get_setting("push_pop_layout", True):
        gdb_bkp_window.set_layout(gdb_bkp_layout)
        gdb_bkp_window.focus_view(gdb_bkp_view)
    if __debug_file_handle is not None:
        if __debug_file_handle != sys.stdout:
            __debug_file_handle.close()
            __debug_file_handle = None


def programio(pty, tty):
    global gdb_process
    exception_count = 0
    class MyFD(object):
        def __init__(self, pty, tty):
            self.pty = pty
            self.tty = tty
            self.off = 0
            self.queue = Queue.Queue()

        def on_done(self, s):
            log_debug("programinput: %s\n" % s)
            log_debug("Wrote: %d bytes\n" % os.write(self.pty, bencode("%s\n" % s)))
            os.fsync(self.pty)
            self.queue.put(None)

        def get_input(self):
            sublime.active_window().show_input_panel("stdin input expected: ", "input", self.on_done, None, lambda: self.queue.put(None))

        def readline(self):
            ret = bytes()
            while True:
                if not os.isatty(self.pty):
                    s = os.fstat(self.pty)
                    if self.off >= s.st_size and len(ret) == 0:
                        return bdecode(ret)
                else:
                    import select
                    r, w, x = select.select([self.pty], [self.pty], [], 5.0)
                    if len(r) == 0 and len(w) != 0:
                        log_debug("Ready for input\n")
                        sublime.set_timeout(self.get_input, 0)
                        self.queue.get()
                        continue
                    elif len(r) == 0:
                        log_debug("timed out\n")
                        break
                read = os.read(self.pty, 1)
                self.off += len(read)
                ret += read
                if len(read) == 0 or ret[-1] == ord('\n'):
                    break
            return bdecode(ret)

        def close(self):
            os.close(self.pty)
            if self.tty:
                os.close(self.tty)

    pipe = MyFD(pty, tty)

    while exception_count < 100:
        try:
            line = pipe.readline()
            if len(line) > 0:
                log_debug("programoutput: %s" % line)
                gdb_console_view.add_line(line, False)
            else:
                if gdb_process.poll() is not None:
                    break
                time.sleep(0.1)
        except:
            traceback.print_exc()
            exception_count = exception_count + 1
    if pipe is not None:
        pipe.close()


gdb_input_view = None
gdb_command_history = []
gdb_command_history_pos = 0


def set_input(edit, text):
    gdb_input_view.erase(edit, sublime.Region(0, gdb_input_view.size()))
    gdb_input_view.insert(edit, 0, text)


class GdbPrevCmd(sublime_plugin.TextCommand):
    def run(self, edit):
        global gdb_command_history_pos
        if gdb_command_history_pos > 0:
            gdb_command_history_pos -= 1
        if gdb_command_history_pos < len(gdb_command_history):
            set_input(edit, gdb_command_history[gdb_command_history_pos])


class GdbNextCmd(sublime_plugin.TextCommand):
    def run(self, edit):
        global gdb_command_history_pos
        if gdb_command_history_pos < len(gdb_command_history):
            gdb_command_history_pos += 1
        if gdb_command_history_pos < len(gdb_command_history):
            set_input(edit, gdb_command_history[gdb_command_history_pos])
        else:
            set_input(edit, "")


def show_input(raw=False):
    global gdb_input_view
    global gdb_command_history_pos
    gdb_command_history_pos = len(gdb_command_history)

    title = "GDB"
    if raw:
        title += " Raw"

    gdb_input_view = sublime.active_window().show_input_panel(
        title, "",
        partial(input_on_done, raw=raw),
        input_on_change,
        input_on_cancel)


def input_on_done(s, raw=False):
    if s.strip() != "quit":
        gdb_command_history.append(s)
        show_input(raw=raw)

    mimode = not raw
    run_cmd(s, mimode=mimode)


def input_on_cancel():
    pass


def input_on_change(s):
    pass


def is_running():
    return gdb_process is not None and gdb_process.poll() is None


class GdbInput(sublime_plugin.WindowCommand):
    def run(self):
        show_input(raw=False)


class GdbRawInput(sublime_plugin.WindowCommand):
    def run(self):
        show_input(raw=True)


class GdbLaunch(sublime_plugin.WindowCommand):
    def run(self):
        global exec_settings
        s = self.window.active_view().settings()
        exec_choices = s.get("sublimegdb_executables")

        if exec_choices is None or type(exec_choices) != dict:
            # No executable specific settings, go ahead and launch
            exec_settings = {}
            self.launch()
            return

        def on_choose(index):
            global exec_settings
            if index == -1:
                # User cancelled the panel, abort launch
                return
            exec_name = list(exec_choices)[index]
            exec_settings = exec_choices[exec_name]
            self.launch()

        self.window.show_quick_panel(list(exec_choices), on_choose)

    def launch(self):
        global gdb_process
        global gdb_server_process
        global gdb_threads
        global gdb_run_status
        global gdb_bkp_window
        global gdb_bkp_view
        global gdb_bkp_layout
        global gdb_shutting_down
        global DEBUG
        global DEBUG_FILE
        view = self.window.active_view()
        DEBUG = get_setting("debug", False, view)
        DEBUG_FILE = expand_path(get_setting("debug_file", "stdout", view), self.window)
        if DEBUG:
            log_debug("Will write debug info to file: %s" % DEBUG_FILE)
        if gdb_process is None or gdb_process.poll() is not None:
            commandline = get_setting("commandline", view=view)
            if isinstance(commandline, list):
                # backwards compatibility for when the commandline was a list
                commandline = " ".join(commandline)
            # note path expanding happens before add/switch view
            commandline = expand_path(commandline, self.window)
            path = expand_path(get_setting("workingdir", "/tmp", view), self.window)
            arguments = expand_path(get_setting("arguments", ""), self.window)
            log_debug("Running: %s\n" % commandline)
            log_debug("In directory: %s\n" % path)
            if commandline == "notset" or path == "notset":
                sublime.error_message("You have not configured the plugin correctly, the default configuration file and your user configuration file will open in a new window")
                sublime.run_command("new_window")
                wnd = sublime.active_window()
                wnd.set_layout({
                    "cols": [0.0, 0.5, 1.0],
                    "rows": [0, 1.0],
                    "cells": [[0,0,1,1], [1,0,2,1]],
                })
                v = wnd.open_file("%s/User/SublimeGDB.sublime-settings" % sublime.packages_path())
                v2 = wnd.open_file("%s/SublimeGDB/SublimeGDB.sublime-settings" % sublime.packages_path())
                wnd.set_view_index(v2, 1, 0)
                return
            if not os.path.exists(path):
                sublime.error_message("The directory given does not exist: %s" % path)
                return

            # get env settings
            gdb_env = get_setting("env", "notset")
            if gdb_env == "notset":
                gdb_env = None
            else:
                env_copy = os.environ.copy()
                env_copy.update(gdb_env)
                gdb_env = env_copy

            # Optionally Launch the GDB Server
            gdb_server_cmd = get_setting("server_commandline", "notset")
            gdb_server_dir = get_setting("server_workingdir", "notset")
            if (gdb_server_cmd != "notset") and (gdb_server_dir != "notset"):

                gdb_server_cmd = expand_path(gdb_server_cmd, self.window)
                gdb_server_dir = expand_path(gdb_server_dir, self.window)
                gdb_server_shell = get_setting("server_shell", False)
                log_debug("gdb_server_cmd: %s" % gdb_server_cmd)
                log_debug("gdb_server_dir: %s" % gdb_server_dir)
                log_debug("gdb_server_dir: %s" % gdb_server_shell)
                gdb_server_process = subprocess.Popen(gdb_server_cmd, shell=gdb_server_shell, cwd=gdb_server_dir, env=gdb_env)


            gdb_process = subprocess.Popen(commandline, shell=True, cwd=path, env=gdb_env,
                            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            log_debug("Process: %s\n" % gdb_process)
            gdb_bkp_window = sublime.active_window()
            #back up current layout before opening the debug one
            #it will be restored when debug is finished
            gdb_bkp_layout = gdb_bkp_window.get_layout()
            gdb_bkp_view = gdb_bkp_window.active_view()
            gdb_bkp_window.set_layout(
                get_setting("layout",
                    {
                        "cols": [0.0, 0.5, 1.0],
                        "rows": [0.0, 0.75, 1.0],
                        "cells": [[0, 0, 2, 1], [0, 1, 1, 2], [1, 1, 2, 2]]
                    }
                )
            )

            for view in gdb_views:
                if view.is_closed() and view.open_at_start():
                    view.open()
                view.clear()

            gdb_shutting_down = False

            t = threading.Thread(target=gdboutput, args=(gdb_process.stdout,))
            t.start()
            gdb_threads.append(t)
            t = threading.Thread(target=gdboutput, args=(gdb_process.stderr,))
            t.start()
            gdb_threads.append(t)

            try:
                raise Exception("Nope")
                pty, tty = os.openpty()
                name = os.ttyname(tty)
            except:
                pipe, name = tempfile.mkstemp()
                pty, tty = pipe, None
            log_debug("pty: %s, tty: %s, name: %s" % (pty, tty, name))
            t = threading.Thread(target=programio, args=(pty,tty))
            t.start()
            gdb_threads.append(t)
            try:
                run_cmd("-gdb-show interpreter", True, timeout=get_setting("gdb_timeout", 20))
            except:
                sublime.error_message("""\
It seems you're not running gdb with the "mi" interpreter. Please add
"--interpreter=mi" to your gdb command line""")
                gdb_process.stdin.write("quit\n")
                return
            run_cmd("-inferior-tty-set %s" % name, True)

            run_cmd("-enable-pretty-printing")
            run_cmd("-gdb-set target-async 1")
            run_cmd("-gdb-set pagination off")
            dis_asm_flavor = get_setting("disassembly_flavor", "att", view)
            if dis_asm_flavor == "intel":
                run_cmd("-gdb-set disassembly-flavor intel")
            else:
                run_cmd("-gdb-set disassembly-flavor att")
            # if gdb_nonstop:
            #     run_cmd("-gdb-set non-stop on")
            attach_cmd = get_setting("attach_cmd","notset")
            if(attach_cmd != "notset"):
                run_cmd(attach_cmd)
            gdb_breakpoint_view.sync_breakpoints()

            if(get_setting("run_after_init", True)):
                gdb_run_status = "running"
                if arguments:
                    run_cmd("-exec-arguments " + arguments)

                run_cmd(get_setting("exec_cmd", "-exec-run"), True)
            else:
                gdb_run_status = "stopped"


            show_input()
        else:
            sublime.status_message("GDB is already running!")

    def is_enabled(self):
        return not is_running()

    def is_visible(self):
        return not is_running()


class GdbContinue(sublime_plugin.WindowCommand):
    def run(self):
        global gdb_cursor_position
        gdb_cursor_position = 0
        update_view_markers()
        resume()

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running()


class GdbExit(sublime_plugin.WindowCommand):
    def run(self):
        global gdb_shutting_down
        gdb_shutting_down = True
        wait_until_stopped()
        run_cmd("-gdb-exit", True)
        if gdb_server_process:
            gdb_server_process.terminate()

    def is_enabled(self):
        return is_running()

    def is_visible(self):
        return is_running()

class GdbLoad(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd(get_setting("load_cmd", "-target-download"))

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running() and gdb_run_status != "running"

class GdbPause(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd("-exec-interrupt")

    def is_enabled(self):
        return is_running() and gdb_run_status != "stopped"

    def is_visible(self):
        return is_running() and gdb_run_status != "stopped"


class GdbStepOver(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd("-exec-next")

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running()


class GdbStepInto(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd("-exec-step")

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running()


class GdbNextInstruction(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd("-exec-next-instruction")

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running()


class GdbStepOut(sublime_plugin.WindowCommand):
    def run(self):
        run_cmd("-exec-finish")

    def is_enabled(self):
        return is_running() and gdb_run_status != "running"

    def is_visible(self):
        return is_running()


class GdbAddWatch(sublime_plugin.TextCommand):
    def run(self, edit):
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            var = gdb_variables_view.get_variable_at_line(self.view.rowcol(self.view.sel()[0].begin())[0])
            if var is not None:
                gdb_breakpoint_view.toggle_watch(var.get_expression())
            else:
                sublime.status_message("Don't know how to watch that variable")
        else:
            exp = self.view.substr(self.view.word(self.view.sel()[0].begin()))
            gdb_breakpoint_view.toggle_watch(exp)


class GdbToggleBreakpoint(sublime_plugin.TextCommand):
    def run(self, edit):
        fn = self.view.file_name()

        if gdb_breakpoint_view.is_open() and self.view.id() == gdb_breakpoint_view.get_view().id():
            row = self.view.rowcol(self.view.sel()[0].begin())[0]
            if row < len(gdb_breakpoint_view.breakpoints):
                gdb_breakpoint_view.breakpoints[row].remove()
                gdb_breakpoint_view.breakpoints.pop(row)
                gdb_breakpoint_view.update_view()
        elif gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            var = gdb_variables_view.get_variable_at_line(self.view.rowcol(self.view.sel()[0].begin())[0])
            if var is not None:
                gdb_breakpoint_view.toggle_watch(var.get_expression())
        elif gdb_disassembly_view.is_open() and self.view.id() == gdb_disassembly_view.get_view().id():
           for sel in self.view.sel():
                line = self.view.substr(self.view.line(sel))
                addr = re.match(r"^[^:]+", line)
                if addr:
                   gdb_breakpoint_view.toggle_breakpoint_addr(addr.group(0))
        elif fn is not None:
            for sel in self.view.sel():
                line, col = self.view.rowcol(sel.a)
                gdb_breakpoint_view.toggle_breakpoint(fn, line + 1)
        update_view_markers(self.view)


class GdbClick(sublime_plugin.TextCommand):
    def run(self, edit):
        if not is_running():
            return

        row, col = self.view.rowcol(self.view.sel()[0].a)
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            gdb_variables_view.expand_collapse_variable(self.view, toggle=True)
        elif gdb_callstack_view.is_open() and self.view.id() == gdb_callstack_view.get_view().id():
            gdb_callstack_view.select(row)
        elif gdb_threads_view.is_open() and self.view.id() == gdb_threads_view.get_view().id():
            gdb_threads_view.select(row)
            update_cursor()

    def is_enabled(self):
        return is_running()


class GdbDoubleClick(sublime_plugin.TextCommand):
    def run(self, edit):
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            self.view.run_command("gdb_edit_variable")
        else:
            self.view.run_command("gdb_edit_register")

    def is_enabled(self):
        return is_running() and \
                ((gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id()) or \
                 (gdb_register_view.is_open() and self.view.id() == gdb_register_view.get_view().id()))


class GdbCollapseVariable(sublime_plugin.TextCommand):
    def run(self, edit):
        gdb_variables_view.expand_collapse_variable(self.view, expand=False)

    def is_enabled(self):
        if not is_running():
            return False
        row, col = self.view.rowcol(self.view.sel()[0].a)
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            return True
        return False


class GdbExpandVariable(sublime_plugin.TextCommand):
    def run(self, edit):
        gdb_variables_view.expand_collapse_variable(self.view)

    def is_enabled(self):
        if not is_running():
            return False
        row, col = self.view.rowcol(self.view.sel()[0].a)
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            return True
        return False


class GdbEditVariable(sublime_plugin.TextCommand):
    def run(self, edit):
        row, col = self.view.rowcol(self.view.sel()[0].a)
        var = gdb_variables_view.get_variable_at_line(row)
        if var.is_editable():
            var.edit()
        else:
            sublime.status_message("Variable isn't editable")

    def is_enabled(self):
        if not is_running():
            return False
        if gdb_variables_view.is_open() and self.view.id() == gdb_variables_view.get_view().id():
            return True
        return False


class GdbEditRegister(sublime_plugin.TextCommand):
    def run(self, edit):
        row, col = self.view.rowcol(self.view.sel()[0].a)
        reg = gdb_register_view.get_register_at_line(row)
        if not reg is None:
            reg.edit()

    def is_enabled(self):
        if not is_running():
            return False
        if gdb_register_view.is_open() and self.view.id() == gdb_register_view.get_view().id():
            return True
        return False


class GdbEventListener(sublime_plugin.EventListener):
    def on_query_context(self, view, key, operator, operand, match_all):
        if key == "gdb_running":
            return is_running() == operand
        elif key == "gdb_input_view":
            return gdb_input_view is not None and view.id() == gdb_input_view.id()
        elif key.startswith("gdb_"):
            v = gdb_variables_view
            if key.startswith("gdb_register_view"):
                v = gdb_register_view
            elif key.startswith("gdb_disassembly_view"):
                v = gdb_disassembly_view
            if key.endswith("open"):
                return v.is_open() == operand
            else:
                if v.get_view() is None:
                    return False == operand
                return (view.id() == v.get_view().id()) == operand
        return None

    def on_activated(self, view):
        if view.file_name() is not None:
            update_view_markers(view)

        # forward this event to GDBView
        if view.name():
            for gdb_view in gdb_views:
                if view.name() == gdb_view.name:
                    gdb_view.on_activated()
                    break

    def on_modified(self, view):
        # update the current breakpoint locations
        gdb_breakpoint_view.on_view_modified(view)

    def on_load(self, view):
        if view.file_name() is not None:
            update_view_markers(view)

    def on_close(self, view):
        for v in gdb_views:
            if v.is_open() and view.id() == v.get_view().id():
                v.was_closed()
                break


class GdbOpenSessionView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_session_view.open()

    def is_enabled(self):
        return not gdb_session_view.is_open()

    def is_visible(self):
        return not gdb_session_view.is_open()


class GdbOpenConsoleView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_console_view.open()

    def is_enabled(self):
        return not gdb_console_view.is_open()

    def is_visible(self):
        return not gdb_console_view.is_open()


class GdbOpenVariablesView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_variables_view.open()

    def is_enabled(self):
        return not gdb_variables_view.is_open()

    def is_visible(self):
        return not gdb_variables_view.is_open()


class GdbOpenCallstackView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_callstack_view.open()

    def is_enabled(self):
        return not gdb_callstack_view.is_open()

    def is_visible(self):
        return not gdb_callstack_view.is_open()


class GdbOpenRegisterView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_register_view.open()

    def is_enabled(self):
        return not gdb_register_view.is_open()

    def is_visible(self):
        return not gdb_register_view.is_open()


class GdbOpenDisassemblyView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_disassembly_view.open()

    def is_enabled(self):
        return not gdb_disassembly_view.is_open()

    def is_visible(self):
        return not gdb_disassembly_view.is_open()


class GdbOpenBreakpointView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_breakpoint_view.open()

    def is_enabled(self):
        return not gdb_breakpoint_view.is_open()

    def is_visible(self):
        return not gdb_breakpoint_view.is_open()


class GdbOpenThreadsView(sublime_plugin.WindowCommand):
    def run(self):
        gdb_threads_view.open()

    def is_enabled(self):
        return not gdb_threads_view.is_open()

    def is_visible(self):
        return not gdb_threads_view.is_open()