1346 lines
50 KiB
Python
Executable file
1346 lines
50 KiB
Python
Executable file
# encoding: utf-8
|
|
# vim: tabstop=2 shiftwidth=2 softtabstop=2 expandtab
|
|
# -*- c--oding: ko_KR.UTF-8 -*-
|
|
# remote PHP debugger : remote debugger interface to DBGp protocol
|
|
#
|
|
# Copyright (c) 2012-2013 Brook Hong
|
|
#
|
|
# The MIT License
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
# a copy of this software and associated documentation files
|
|
# (the "Software"), to deal in the Software without restriction,
|
|
# including without limitation the rights to use, copy, modify,
|
|
# merge, publish, distribute, sublicense, and/or sell copies of the
|
|
# Software, and to permit persons to whom the Software is furnished
|
|
# to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included
|
|
# in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
#
|
|
#
|
|
# Authors:
|
|
# Brook Hong <hzgmaxwell <at> hotmail.com>
|
|
# The plugin was originally writen by --
|
|
# Seung Woo Shin <segv <at> sayclub.com>
|
|
# I rewrote it with a new debugger engine, please diff this file to find code change.
|
|
|
|
import os
|
|
import sys
|
|
import vim
|
|
import socket
|
|
import base64
|
|
import traceback
|
|
import xml.etree.ElementTree as ET
|
|
|
|
import string
|
|
import time, subprocess
|
|
from threading import Thread,Lock
|
|
|
|
def getFilePath(s):
|
|
if s[:7] == "file://":
|
|
fn = s[7:]
|
|
else:
|
|
fn = s
|
|
win = 0
|
|
if fn[2] == ':':
|
|
fn = fn[1:]
|
|
win = 1
|
|
return [fn, win]
|
|
|
|
tracelog = open(os.getenv("HOME").replace("\\","/")+"/.dbgpavim.trace",'w')
|
|
def DBGPavimTrace(log):
|
|
tracelog.write("\n"+log+"\n")
|
|
tracelog.flush()
|
|
|
|
class VimWindow:
|
|
""" wrapper class of window of vim """
|
|
def __init__(self, name = 'DEBUG_WINDOW'):
|
|
""" initialize """
|
|
self.name = name
|
|
self.method = "new"
|
|
self.buffer = None
|
|
self.firstwrite = 1
|
|
def isprepared(self):
|
|
""" check window is OK """
|
|
if self.buffer == None or len(dir(self.buffer)) == 0 or self.getwinnr() == -1:
|
|
return 0
|
|
return 1
|
|
def prepare(self):
|
|
""" check window is OK, if not then create """
|
|
if not self.isprepared():
|
|
self.create(self.method)
|
|
def before_create(self):
|
|
vim.command("1wincmd w")
|
|
def on_create(self):
|
|
pass
|
|
def getwinnr(self):
|
|
return int(vim.eval("bufwinnr('"+self.name+"')"))
|
|
def focus(self):
|
|
winnr = self.getwinnr()
|
|
vim.command(str(winnr) + 'wincmd w')
|
|
def getWidth(self):
|
|
return int(vim.eval("winwidth(bufwinnr('"+self.name+"'))"))
|
|
def getHeight(self):
|
|
return int(vim.eval("winheight(bufwinnr('"+self.name+"'))"))
|
|
def write(self, msg, lineno = 0):
|
|
""" append last """
|
|
self.prepare()
|
|
if self.firstwrite == 1:
|
|
self.firstwrite = 0
|
|
self.buffer[:] = str(msg).split('\n')
|
|
else:
|
|
if lineno == 0:
|
|
self.buffer.append(str(msg).split('\n'))
|
|
self.command('normal G')
|
|
else:
|
|
self.buffer.append(str(msg).split('\n'), lineno)
|
|
self.command("normal %dG" % (lineno+1))
|
|
#self.window.cursor = (len(self.buffer), 1)
|
|
def create(self, method = 'new'):
|
|
""" create window """
|
|
self.method = method
|
|
self.before_create()
|
|
vim.command('silent ' + method + ' ' + self.name)
|
|
#if self.name != 'LOG___WINDOW':
|
|
vim.command("setlocal buftype=nofile")
|
|
self.buffer = vim.current.buffer
|
|
self.width = int( vim.eval("winwidth(0)") )
|
|
self.height = int( vim.eval("winheight(0)") )
|
|
self.on_create()
|
|
def destroy(self):
|
|
""" destroy window """
|
|
if self.buffer == None or len(dir(self.buffer)) == 0:
|
|
return
|
|
#if self.name == 'LOG___WINDOW':
|
|
# self.command('hide')
|
|
#else:
|
|
self.command('bdelete ' + self.name)
|
|
self.firstwrite = 1
|
|
def clean(self):
|
|
""" clean all datas in buffer """
|
|
self.prepare()
|
|
self.buffer[:] = []
|
|
self.firstwrite = 1
|
|
def command(self, cmd):
|
|
""" go to my window & execute command """
|
|
self.prepare()
|
|
winnr = self.getwinnr()
|
|
if winnr != int(vim.eval("winnr()")):
|
|
vim.command(str(winnr) + 'wincmd w')
|
|
vim.command(cmd)
|
|
def render(self, xml):
|
|
self.write(ET.tostring(xml))
|
|
|
|
class StackWindow(VimWindow):
|
|
def __init__(self, name = 'STACK_WINDOW'):
|
|
VimWindow.__init__(self, name)
|
|
def render(self, xml):
|
|
lines = ""
|
|
for node in xml:
|
|
wr = node.get('where')
|
|
if wr == None:
|
|
wr = "{main}"
|
|
if node.tag != '{urn:debugger_protocol_v1}stack':
|
|
return VimWindow.render(self, node)
|
|
else:
|
|
if wr != '{main}':
|
|
fmark = '()'
|
|
else:
|
|
fmark = ''
|
|
[fn, win] = getFilePath(node.get('filename'))
|
|
fn = dbgPavim.localPathOf(fn)
|
|
lines += str('%-2s %-15s %s:%s\n' % (node.get('level'), wr+fmark, fn, node.get('lineno')))
|
|
self.write(lines)
|
|
def on_create(self):
|
|
self.command('highlight CurStack term=reverse ctermfg=White ctermbg=Red gui=reverse')
|
|
self.highlight_stack(0)
|
|
def highlight_stack(self, no):
|
|
self.command('syntax clear')
|
|
self.command('syntax region CurStack start="^' +str(no)+ ' " end="$"')
|
|
|
|
class WatchWindow(VimWindow):
|
|
def __init__(self, name = 'WATCH_WINDOW'):
|
|
VimWindow.__init__(self, name)
|
|
def decode_string(self, msg, encoding):
|
|
if encoding == 'base64':
|
|
value = base64.decodestring(msg)
|
|
elif encoding == '' or encoding == None or encoding == 'None':
|
|
value = msg
|
|
else:
|
|
value = "(e:%s) %s" % (encoding, msg)
|
|
return value
|
|
def parseNode1(self, p):
|
|
fullname = p.get('fullname')
|
|
if fullname == None:
|
|
fullname = p.get('name')
|
|
val = None
|
|
if p.text != None:
|
|
val = self.decode_string(p.text, p.get('encoding'))
|
|
return (fullname, val)
|
|
def parseNode2(self, p):
|
|
fullname_node = p.find('{urn:debugger_protocol_v1}fullname')
|
|
fullname = self.decode_string(fullname_node.text, fullname_node.get('encoding'))
|
|
value_node = p.find('{urn:debugger_protocol_v1}value')
|
|
val = None
|
|
if value_node != None and value_node.text != None:
|
|
val = self.decode_string(value_node.text, value_node.get('encoding'))
|
|
return (fullname, val)
|
|
def parseProperty(self, p, level, parser, command = None):
|
|
(fullname, val) = parser(p)
|
|
if command == 'eval':
|
|
if dbgPavim.fileType == 'php':
|
|
fullname = "$evalResult" if (fullname == None) else ('$evalResult->%s'%(fullname))
|
|
else:
|
|
fullname = "evalResult" if (fullname == None) else ('evalResult->%s'%(fullname))
|
|
else:
|
|
fullname = "" if (fullname == None) else fullname
|
|
tp = p.get('type')
|
|
children = p.get('children')
|
|
properties = p.findall('{urn:debugger_protocol_v1}property')
|
|
size = p.get('size')
|
|
if size == None:
|
|
size = p.get('numchildren')
|
|
size = ('[%s]' % (size)) if size != None else ""
|
|
if val != None:
|
|
value = "(%s%s) '%s'" % (tp, size, val)
|
|
elif tp == "null":
|
|
value = "(null)"
|
|
else:
|
|
if tp == "object":
|
|
tp = tp+"|"+p.get('classname')
|
|
if children == "1" and len(properties) == 0:
|
|
value = "(%s%s)+" % (tp, size)
|
|
else:
|
|
value = "(%s%s)" % (tp, size)
|
|
out = ('%s%s = %s;' % (" "*level, fullname.ljust(32-level), value))
|
|
for pp in properties:
|
|
out += '\n'+self.parseProperty(pp, level+2, parser, command)
|
|
return out
|
|
def render(self, xml, lineno = 0):
|
|
command = xml.get('command')
|
|
level = 0
|
|
out = ""
|
|
if lineno > 0:
|
|
line = self.buffer[lineno-1]
|
|
del self.buffer[lineno-1]
|
|
lineno -= 1
|
|
level = len(line)-len(line.lstrip())
|
|
elif command != None and command != 'eval':
|
|
out += ("\n%sby %s\n" % (self.commenter, xml.get('command')))
|
|
properties = xml.findall('{urn:debugger_protocol_v1}property')
|
|
if properties[0].find('{urn:debugger_protocol_v1}fullname') != None:
|
|
parser = getattr(self, 'parseNode2')
|
|
else:
|
|
parser = getattr(self, 'parseNode1')
|
|
for p in properties:
|
|
out += self.parseProperty(p, level, parser, command)
|
|
if lineno == 0:
|
|
out += "\n"
|
|
self.write(out, lineno)
|
|
def on_create(self):
|
|
self.commenter = '// '
|
|
if dbgPavim.fileType == 'php':
|
|
self.write('<?')
|
|
elif dbgPavim.fileType == 'python':
|
|
self.commenter = '## '
|
|
self.command('inoremap <buffer> <cr> <esc>:python dbgPavim.debugSession.watch_execute()<cr>')
|
|
self.command('set noai nocin')
|
|
self.command('set wrap fdm=manual fmr={{{,}}} ft=%s fdl=1' % (dbgPavim.fileType))
|
|
def input(self, mode, arg = ''):
|
|
if arg == '%v%':
|
|
arg = vim.eval('@v')
|
|
self.prepare()
|
|
line = self.buffer[-1]
|
|
if line[:len(mode)+1] == self.commenter+'=> '+mode+':':
|
|
self.buffer[-1] = line + arg
|
|
else:
|
|
self.buffer.append(self.commenter+'=> '+mode+': '+arg)
|
|
self.command('normal G')
|
|
def get_command(self):
|
|
line = self.buffer[-1]
|
|
if line[0:11] == self.commenter+'=> exec:':
|
|
print "exec does not supported by xdebug now."
|
|
return ('none', '')
|
|
#return ('exec', line[11:].strip(' '))
|
|
elif line[0:11] == self.commenter+'=> eval:':
|
|
return ('eval', line[11:].strip(' '))
|
|
else:
|
|
return ('none', '')
|
|
|
|
class HelpWindow(VimWindow):
|
|
def __init__(self, name = 'HELP__WINDOW'):
|
|
VimWindow.__init__(self, name)
|
|
def before_create(self):
|
|
pass
|
|
def on_create(self):
|
|
if vim.eval('g:dbgPavimLang') == 'cn' :
|
|
self.write( \
|
|
'[ Function Keys ] | [ Command Mode ] \n' + \
|
|
' <F1> 打开帮助窗口 | :Bp [arg] 切换断点[中断条件] \n' + \
|
|
' <F2> 逐语句调试 | :Up 切换至上一个文件 \n' + \
|
|
' <F3> 逐过程调试 | :Dn 切换至下一个文件 \n' + \
|
|
' <F4> 运行至断点 | :Bl 查看所有断点 \n' + \
|
|
' <F5> 开始调试 | :Pg 输出当前变量 \n' + \
|
|
' <F6> 退出调试 | :Bc 清除所有断点 \n' + \
|
|
' <F7> 监视变量 | :Bu 恢复Bc清除的所有断点 \n' + \
|
|
' <F8> 切换自动调试模式 | \n' + \
|
|
' <F9> 切换监视窗口 | \n' + \
|
|
' <F10> 切换断点 | \n' + \
|
|
' <F11> 输出所有变量 | \n' + \
|
|
' <F12> 输出当前变量 | \n' + \
|
|
' 获取帮助和最新版本,请访问 https://github.com/brookhong/DBGPavim \n' + \
|
|
'')
|
|
else :
|
|
self.write( \
|
|
'[ Function Keys ] | [ Command Mode ] \n' + \
|
|
' <F1> toggle help window | :Bp toggle breakpoint \n' + \
|
|
' <F2> step into | :Up stack up \n' + \
|
|
' <F3> step over | :Dn stack down \n' + \
|
|
' <F4> step out | :Bl list breakpoints \n' + \
|
|
' <F5> run | :Pg property get \n' + \
|
|
' <F6> quit debugging | :Bc disable all breakpoints \n' + \
|
|
' <F7> eval | :Bu enabled all breakpoints \n' + \
|
|
' <F8> toggle dbgPavimBreakAtEntry | \n' + \
|
|
' <F9> toggle layout | \n' + \
|
|
' <F10> toggle breakpoint | \n' + \
|
|
' <F11> get all context | \n' + \
|
|
' <F12> get property at cursor | \n' + \
|
|
' \n' + \
|
|
' For more instructions and latest version, \n' + \
|
|
' pleae refer to https://github.com/brookhong/DBGPavim \n' + \
|
|
'')
|
|
self.command('1')
|
|
|
|
class ConsoleWindow(VimWindow):
|
|
def __init__(self, name = 'CONSOLE__WINDOW'):
|
|
VimWindow.__init__(self, name)
|
|
def before_create(self):
|
|
pass
|
|
def on_create(self):
|
|
vim.command('setlocal autoread')
|
|
|
|
class DebugUI:
|
|
""" DEBUGUI class """
|
|
(NORMAL, DEBUG) = (0,1)
|
|
def __init__(self, stackwinRatio, watchwinRatio):
|
|
""" initialize object """
|
|
self.watchwin = WatchWindow()
|
|
self.stackwin = StackWindow()
|
|
self.stackwinRatio = stackwinRatio
|
|
self.watchwinRatio = watchwinRatio
|
|
self.stackwinHeight = 1
|
|
self.watchwinWidth = 1
|
|
self.helpwin = None
|
|
self.mode = DebugUI.NORMAL
|
|
self.file = None
|
|
self.line = None
|
|
self.winbuf = {}
|
|
self.cursign = None
|
|
self.sessfile = os.getenv("HOME").replace("\\","/")+"/.dbgpavim.session"
|
|
self.clilog = os.getenv("HOME").replace("\\","/")+"/.dbgpavim.cli"
|
|
self.cliwin = None
|
|
self.backup_ssop = vim.eval('&ssop')
|
|
|
|
def debug_mode(self):
|
|
""" change mode to debug """
|
|
if self.mode == DebugUI.DEBUG:
|
|
return
|
|
dbgPavim.fileType = vim.eval('&ft')
|
|
vim.command('let g:dbgPavimTab=tabpagenr()')
|
|
self.mode = DebugUI.DEBUG
|
|
# save session
|
|
vim.command('set ssop-=tabpages')
|
|
vim.command('mksession! ' + self.sessfile)
|
|
for i in range(1, len(vim.windows)+1):
|
|
vim.command(str(i)+'wincmd w')
|
|
self.winbuf[i] = vim.eval('bufnr("%")') # save buffer number, mksession does not do job perfectly
|
|
# when buffer is not saved at all.
|
|
|
|
vim.command('silent topleft new') # create srcview window (winnr=1)
|
|
for i in range(2, len(vim.windows)+1):
|
|
vim.command(str(i)+'wincmd w')
|
|
vim.command('hide')
|
|
self.create()
|
|
vim.command('1wincmd w') # goto srcview window(nr=1, top-left)
|
|
self.cursign = '1'
|
|
|
|
self.set_highlight()
|
|
|
|
def normal_mode(self):
|
|
""" restore mode to normal """
|
|
if self.mode == DebugUI.NORMAL:
|
|
return
|
|
|
|
vim.command('exec "normal ".g:dbgPavimTab."gt"')
|
|
vim.command('unlet g:dbgPavimTab')
|
|
vim.command('sign unplace 1')
|
|
vim.command('sign unplace 2')
|
|
|
|
# destory all created windows
|
|
self.destroy()
|
|
|
|
# restore session
|
|
vim.command('source ' + self.sessfile)
|
|
vim.command("let &ssop=\""+self.backup_ssop+"\"")
|
|
os.remove(self.sessfile)
|
|
|
|
self.set_highlight()
|
|
|
|
self.winbuf.clear()
|
|
self.file = None
|
|
self.line = None
|
|
self.mode = DebugUI.NORMAL
|
|
self.cursign = None
|
|
self.cliwin = None
|
|
def create(self):
|
|
""" create windows """
|
|
self.totalW = int(vim.eval('winwidth(0)'))
|
|
self.totalH = int(vim.eval('winheight(0)'))
|
|
self.stackwinHeight = int(self.totalH*self.stackwinRatio)
|
|
self.watchwinWidth = int(self.totalW*self.watchwinRatio)
|
|
self.stackwin.create('botright '+str(self.stackwinHeight)+' new')
|
|
if self.cliwin:
|
|
self.cliwin.create('vertical new')
|
|
self.watchwin.create('vertical belowright '+str(self.watchwinWidth)+' new')
|
|
def reLayout(self):
|
|
if self.stackwin.getHeight() != self.stackwinHeight or self.watchwin.getWidth() != self.watchwinWidth:
|
|
self.stackwin.command("resize "+str(self.stackwinHeight))
|
|
self.watchwin.command("vertical resize "+str(self.watchwinWidth))
|
|
else:
|
|
vim.command("wincmd _")
|
|
vim.command("wincmd |")
|
|
|
|
def set_highlight(self):
|
|
""" set vim highlight of debugger sign """
|
|
vim.command("highlight DbgCurrent term=reverse ctermfg=White ctermbg=Red gui=reverse")
|
|
vim.command("highlight DbgBreakPt term=reverse ctermfg=White ctermbg=Green gui=reverse")
|
|
|
|
def help(self):
|
|
if self.helpwin:
|
|
self.helpwin.destroy()
|
|
self.helpwin = None
|
|
else:
|
|
self.helpwin = HelpWindow('HELP__WINDOW')
|
|
self.stackwin.focus()
|
|
self.helpwin.create('vertical new')
|
|
|
|
def update_cli(self):
|
|
self.cliwin.focus()
|
|
vim.command('e')
|
|
vim.command('normal G')
|
|
|
|
def destroy(self):
|
|
""" destroy windows """
|
|
self.watchwin.destroy()
|
|
self.stackwin.destroy()
|
|
if self.cliwin:
|
|
self.cliwin.destroy()
|
|
def go_srcview(self):
|
|
vim.command('1wincmd w')
|
|
def next_sign(self):
|
|
if self.cursign == '1':
|
|
return '2'
|
|
else:
|
|
return '1'
|
|
def set_srcview(self, file, line):
|
|
""" set srcview windows to file:line and replace current sign """
|
|
|
|
if file == self.file and self.line == line:
|
|
return
|
|
|
|
if file != self.file:
|
|
self.file = file
|
|
self.go_srcview()
|
|
vim.command('silent edit ' + file)
|
|
|
|
if self.mode == DebugUI.DEBUG:
|
|
if line == 0:
|
|
line = 1
|
|
nextsign = self.next_sign()
|
|
vim.command('sign place ' + nextsign + ' name=current line='+str(line)+' file='+file)
|
|
vim.command('sign unplace ' + self.cursign)
|
|
vim.command('sign jump ' + nextsign + ' file='+file)
|
|
self.cursign = nextsign
|
|
if self.cliwin:
|
|
self.update_cli()
|
|
else:
|
|
vim.command(': ' + str(line))
|
|
|
|
self.line = line
|
|
|
|
class DbgSession:
|
|
def __init__(self, sock, address):
|
|
self.latestRes = None
|
|
self.msgid = 0
|
|
self.sock = sock
|
|
self.isWinServer = 0
|
|
self.bptsetlst = {}
|
|
self.bptsetids = {}
|
|
self.last_command = 'None'
|
|
self.address = address
|
|
self.retries = 0
|
|
def jump(self, fn, line):
|
|
vim.command("e +"+str(line)+" "+str(fn))
|
|
def handle_response_breakpoint_set(self, res):
|
|
"""handle <response command=breakpoint_set> tag
|
|
<responsponse command="breakpoint_set" id="110180001" transaction_id="1"/>"""
|
|
tid = res.get('transaction_id')
|
|
if tid != None:
|
|
tid = int(tid)
|
|
bno = self.bptsetlst[tid]
|
|
del self.bptsetlst[tid]
|
|
self.bptsetids[bno] = res.get('id')
|
|
def getbid(self, bno):
|
|
""" get Debug Server's breakpoint numbered with bno """
|
|
if bno in self.bptsetids:
|
|
return self.bptsetids[bno]
|
|
return None
|
|
def recv_data(self,len):
|
|
c = self.sock.recv(len)
|
|
if c == '':
|
|
# LINUX come here
|
|
raise EOFError, 'Socket Closed'
|
|
return c
|
|
def recv_length(self):
|
|
#print '* recv len'
|
|
length = ''
|
|
while 1:
|
|
c = self.recv_data(1)
|
|
#print ' GET(',c, ':', ord(c), ') : length=', len(c)
|
|
if c == '\0':
|
|
return int(length)
|
|
if c.isdigit():
|
|
length = length + c
|
|
def recv_null(self):
|
|
while 1:
|
|
c = self.recv_data(1)
|
|
if c == '\0':
|
|
return
|
|
def recv_body(self, to_recv):
|
|
body = ''
|
|
while to_recv > 0:
|
|
buf = self.recv_data(to_recv)
|
|
to_recv -= len(buf)
|
|
body = body + buf
|
|
return body
|
|
def recv_msg(self):
|
|
length = self.recv_length()
|
|
body = self.recv_body(length)
|
|
self.recv_null()
|
|
return body
|
|
def send_msg(self, cmd):
|
|
DBGPavimTrace(str(self.msgid)+">"*16+self.address+"\n"+cmd)
|
|
self.sock.send(cmd + '\0')
|
|
def handle_recvd_msg(self, res):
|
|
DBGPavimTrace(str(self.msgid)+"<"*16+self.address+"\n"+res)
|
|
resDom = ET.fromstring(res)
|
|
if resDom.tag == "{urn:debugger_protocol_v1}response":
|
|
if resDom.get('command') == "breakpoint_set":
|
|
self.handle_response_breakpoint_set(resDom)
|
|
if resDom.get('command') == "stop":
|
|
self.close()
|
|
elif resDom.tag == "{urn:debugger_protocol_v1}init":
|
|
[fn, self.isWinServer] = getFilePath(resDom.get('fileuri'))
|
|
return resDom
|
|
def send_command(self, cmd, arg1 = '', arg2 = ''):
|
|
self.msgid = self.msgid + 1
|
|
self.retries = 0
|
|
line = cmd + ' -i ' + str(self.msgid)
|
|
if arg1 != '':
|
|
line = line + ' ' + arg1
|
|
if arg2 != '':
|
|
line = line + ' -- ' + base64.encodestring(arg2)[0:-1]
|
|
self.send_msg(line)
|
|
return self.msgid
|
|
def ack_command(self):
|
|
try:
|
|
self.latestRes = self.recv_msg()
|
|
resDom = self.handle_recvd_msg(self.latestRes)
|
|
tid = resDom.get('transaction_id')
|
|
if tid != None and int(tid) != int(self.msgid):
|
|
DBGPavimTrace("Unexpected msg %s when waiting for msg %d from %s" % (tid, self.msgid, self.address) )
|
|
if self.retries:
|
|
DBGPavimTrace("Retried %d times for msg %d from %s" % (self.retries, self.msgid, self.address) )
|
|
return resDom
|
|
except socket.timeout, e:
|
|
self.retries = self.retries+1
|
|
return None
|
|
except socket.error, e:
|
|
DBGPavimTrace("Exception when recv_msg %d from %s: %s" % (self.msgid, self.address, e[0]) )
|
|
return None
|
|
def command(self, cmd, arg1 = '', arg2 = '', extra = '0'):
|
|
if cmd == 'eval':
|
|
if dbgPavim.fileType == 'php':
|
|
arg2 = '$evalResult=(%s)' %(arg2)
|
|
else:
|
|
arg2 = 'evalResult=(%s)' %(arg2)
|
|
self.send_command(cmd, arg1, arg2)
|
|
self.last_command = cmd+'('+arg1+','+arg2+','+extra+')'
|
|
return self.ack_command()
|
|
def getExtra(self):
|
|
extra = ""
|
|
if self.last_command != None:
|
|
t = self.last_command.split(',')
|
|
extra = t[-1][:-1]
|
|
return extra
|
|
def close(self):
|
|
if self.sock:
|
|
self.sock.close()
|
|
self.sock = None
|
|
def init(self):
|
|
if self.latestRes != None:
|
|
return
|
|
self.ack_command()
|
|
for bno in dbgPavim.breakpt.list():
|
|
fn = dbgPavim.remotePathOf(dbgPavim.breakpt.getfile(bno))
|
|
msgid = self.send_command('breakpoint_set', \
|
|
'-t line -f ' + fn + ' -n ' + str(dbgPavim.breakpt.getline(bno)) + ' -s enabled', \
|
|
dbgPavim.breakpt.getexp(bno))
|
|
self.bptsetlst[msgid] = bno
|
|
self.ack_command()
|
|
|
|
class DbgSessionWithUI(DbgSession):
|
|
def __init__(self, sock, address):
|
|
self.status = None
|
|
self.ui = dbgPavim.ui
|
|
|
|
self.msgid = 0
|
|
self.stacks = []
|
|
self.curstack = 0
|
|
self.laststack = 0
|
|
DbgSession.__init__(self,sock,address)
|
|
def copyFromParent(self, ss):
|
|
self.latestRes = ss.latestRes
|
|
self.msgid = ss.msgid
|
|
self.isWinServer = ss.isWinServer
|
|
self.sock = ss.sock
|
|
self.address = ss.address
|
|
self.bptsetlst = ss.bptsetlst
|
|
self.bptsetids = ss.bptsetids
|
|
def init(self):
|
|
self.command('feature_set', '-n max_children -v ' + dbgPavim.maxChildren)
|
|
self.command('feature_set', '-n max_data -v ' + dbgPavim.maxData)
|
|
self.command('feature_set', '-n max_depth -v ' + dbgPavim.maxDepth)
|
|
def start(self):
|
|
self.sock.settimeout(30)
|
|
dbgPavim.updateStatusLine()
|
|
self.ui.debug_mode()
|
|
|
|
if self.latestRes != None:
|
|
self.handle_recvd_msg(self.latestRes)
|
|
self.init()
|
|
self.command('stack_get')
|
|
else:
|
|
DbgSession.init(self)
|
|
self.init()
|
|
self.command('step_into')
|
|
if dbgPavim.fileType == 'php':
|
|
self.command('property_get', "-d %d -n $_SERVER['REQUEST_URI']" % (self.laststack))
|
|
self.ui.go_srcview()
|
|
def send_msg(self, cmd):
|
|
""" send message """
|
|
self.sock.send(cmd + '\0')
|
|
# log message
|
|
DBGPavimTrace(str(self.msgid)+">"*16+self.address+"\n"+cmd)
|
|
def handle_recvd_msg(self, txt):
|
|
# log messages
|
|
txt = txt.replace('\n','')
|
|
DBGPavimTrace(str(self.msgid)+"<"*16+self.address+"\n"+txt)
|
|
resDom = ET.fromstring(txt)
|
|
tag = resDom.tag.replace("{urn:debugger_protocol_v1}","")
|
|
""" call appropraite message handler member function, handle_XXX() """
|
|
try:
|
|
handler = getattr(self, 'handle_' + tag)
|
|
handler(resDom)
|
|
except AttributeError:
|
|
print 'Exception when DBGPavim.handle_'+tag+'()'
|
|
DBGPavimTrace(str(sys.exc_info()[1]))
|
|
DBGPavimTrace("".join(traceback.format_tb( sys.exc_info()[2])))
|
|
self.ui.go_srcview()
|
|
return resDom
|
|
def handle_response(self, res):
|
|
""" call appropraite response message handler member function, handle_response_XXX() """
|
|
errors = res.find('{urn:debugger_protocol_v1}error')
|
|
if errors != None:
|
|
self.handle_response_error(res)
|
|
return
|
|
|
|
command = res.get('command')
|
|
try:
|
|
handler = getattr(self, 'handle_response_' + command)
|
|
except AttributeError:
|
|
print 'Exception when DBGPavim.handle_response_'+command+'()'
|
|
DBGPavimTrace(str(sys.exc_info()[1]))
|
|
DBGPavimTrace("".join(traceback.format_tb( sys.exc_info()[2])))
|
|
return
|
|
handler(res)
|
|
return
|
|
def handle_response_stop(self, res):
|
|
dbgPavim.handle_exception()
|
|
|
|
def handle_init(self, res):
|
|
"""handle <init> tag
|
|
<init appid="7035" fileuri="file:///home/segv/htdocs/index.php" language="PHP" protocol_version="1.0">
|
|
<engine version="2.0.0beta1">
|
|
Xdebug
|
|
</engine>
|
|
<author>
|
|
Derick Rethans
|
|
</author>
|
|
<url>
|
|
http://xdebug.org
|
|
</url>
|
|
<copyright>
|
|
Copyright (c) 2002-2004 by Derick Rethans
|
|
</copyright>
|
|
</init>"""
|
|
|
|
[fn, self.isWinServer] = getFilePath(res.get('fileuri'))
|
|
fn = dbgPavim.localPathOf(fn)
|
|
self.ui.set_srcview(fn, 1)
|
|
|
|
def handle_response_error(self, res):
|
|
""" handle <error> tag """
|
|
DBGPavimTrace(ET.tostring(res))
|
|
errors = res.findall('{urn:debugger_protocol_v1}error')
|
|
for e in errors:
|
|
error_msg = e.find('{urn:debugger_protocol_v1}message')
|
|
self.ui.watchwin.write(self.ui.watchwin.commenter+'Error when '+self.last_command+': '+error_msg.text)
|
|
|
|
def handle_response_stack_get(self, res):
|
|
"""handle <response command=stack_get> tag
|
|
<response command="stack_get" transaction_id="1 ">
|
|
<stack filename="file:///home/segv/htdocs/index.php" level="0" lineno="41" where="{main}"/>
|
|
</response>
|
|
|
|
for windows
|
|
<response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="http://xdebug.org/dbgp/xdebug" command="stack_get" transaction_id="12">
|
|
<stack where="{main}" level="0" type="file" filename="file:///D:/works/scriptbundle/php/playpen.php" lineno="16">
|
|
</stack>
|
|
</response>
|
|
"""
|
|
stacks = res.findall('{urn:debugger_protocol_v1}stack')
|
|
if len(stacks)>0:
|
|
self.curstack = 0
|
|
self.laststack = len(stacks) - 1
|
|
|
|
self.stacks = []
|
|
for s in stacks:
|
|
[fn, win] = getFilePath(s.get('filename'))
|
|
fn = dbgPavim.localPathOf(fn)
|
|
wr = s.get('where')
|
|
if wr == None:
|
|
wr = "{main}"
|
|
self.stacks.append( {'file': fn, \
|
|
'line': int(s.get('lineno')), \
|
|
'where': wr, \
|
|
'level': int(s.get('level'))
|
|
} )
|
|
|
|
self.ui.stackwin.clean()
|
|
self.ui.stackwin.highlight_stack(self.curstack)
|
|
self.ui.stackwin.render(stacks)
|
|
self.ui.set_srcview( self.stacks[self.curstack]['file'], self.stacks[self.curstack]['line'] )
|
|
|
|
def handle_response_step_out(self, res):
|
|
"""handle <response command=step_out> tag
|
|
<response command="step_out" reason="ok" status="break" transaction_id="1 "/>"""
|
|
if res.get('reason') == 'ok':
|
|
self.status = res.get('status')
|
|
return
|
|
else:
|
|
print res.toprettyxml()
|
|
def handle_response_step_over(self, res):
|
|
"""handle <response command=step_over> tag
|
|
<response command="step_over" reason="ok" status="break" transaction_id="1 "/>"""
|
|
if res.get('reason') == 'ok':
|
|
self.status = res.get('status')
|
|
return
|
|
else:
|
|
print res.toprettyxml()
|
|
def handle_response_step_into(self, res):
|
|
"""handle <response command=step_into> tag
|
|
<response command="step_into" reason="ok" status="break" transaction_id="1 "/>"""
|
|
if res.get('reason') == 'ok':
|
|
self.status = res.get('status')
|
|
return
|
|
else:
|
|
print res.toprettyxml()
|
|
def handle_response_run(self, res):
|
|
"""handle <response command=run> tag
|
|
<response command="step_over" reason="ok" status="break" transaction_id="1 "/>"""
|
|
self.status = res.get('status')
|
|
def handle_response_eval(self, res):
|
|
"""handle <response command=eval> tag """
|
|
self.ui.watchwin.render(res)
|
|
def handle_response_property_get(self, res):
|
|
"""handle <response command=property_get> tag """
|
|
lineno = self.getExtra()
|
|
self.ui.watchwin.render(res, int(lineno))
|
|
def handle_response_context_get(self, res):
|
|
"""handle <response command=context_get> tag """
|
|
self.ui.watchwin.render(res)
|
|
def handle_response_feature_set(self, res):
|
|
"""handle <response command=feature_set> tag """
|
|
#self.ui.watchwin.render(res)
|
|
def handle_response_default(self, res):
|
|
"""handle <response command=context_get> tag """
|
|
print res.toprettyxml()
|
|
def handle_response_breakpoint_remove(self, res):
|
|
"""handle <response command=feature_set> tag """
|
|
|
|
def go(self, stack):
|
|
if stack >= 0 and stack <= self.laststack:
|
|
self.curstack = stack
|
|
self.ui.stackwin.highlight_stack(self.curstack)
|
|
self.ui.set_srcview(self.stacks[self.curstack]['file'], self.stacks[self.curstack]['line'])
|
|
|
|
def jump(self, fn, line):
|
|
self.ui.set_srcview(fn, line)
|
|
|
|
def up(self):
|
|
if self.curstack > 0:
|
|
self.curstack -= 1
|
|
self.ui.stackwin.highlight_stack(self.curstack)
|
|
self.ui.set_srcview(self.stacks[self.curstack]['file'], self.stacks[self.curstack]['line'])
|
|
|
|
def down(self):
|
|
if self.curstack < self.laststack:
|
|
self.curstack += 1
|
|
self.ui.stackwin.highlight_stack(self.curstack)
|
|
self.ui.set_srcview(self.stacks[self.curstack]['file'], self.stacks[self.curstack]['line'])
|
|
|
|
def property_get(self, name):
|
|
if string.find(name,' ') != -1:
|
|
name = "\"" + name +"\""
|
|
self.command('property_get', '-d %d -n %s' % (self.curstack, name))
|
|
|
|
def expandVar(self, name):
|
|
(row, col) = vim.current.window.cursor
|
|
if string.find(name,' ') != -1:
|
|
name = "\"" + name +"\""
|
|
self.command('property_get', '-d %d -n %s' % (self.curstack, name), '', str(row))
|
|
|
|
def watch_execute(self):
|
|
""" execute command in watch window """
|
|
(cmd, expr) = self.ui.watchwin.get_command()
|
|
if cmd == 'exec':
|
|
self.command('exec', '', expr)
|
|
print cmd, '--', expr
|
|
elif cmd == 'eval':
|
|
self.command('eval', '', expr)
|
|
print cmd, '--', expr
|
|
else:
|
|
print "no commands", cmd, expr
|
|
|
|
class DbgSilentClient(Thread):
|
|
def __init__(self, ss):
|
|
self.session = ss
|
|
Thread.__init__(self)
|
|
def run(self):
|
|
self.session.init()
|
|
self.session.sock.settimeout(1)
|
|
|
|
self.session.send_command('run')
|
|
count = 600
|
|
while dbgPavim.running and count > 0:
|
|
resDom = self.session.ack_command()
|
|
if resDom != None:
|
|
status = resDom.get('status')
|
|
if status == "stopping":
|
|
self.session.command("stop")
|
|
elif status == "break":
|
|
dbgPavim.debugListener.newSession(self.session)
|
|
break
|
|
count = count-1
|
|
|
|
class DbgListener(Thread):
|
|
(LISTEN,CLOSED) = (0,1)
|
|
""" DBGp Procotol class """
|
|
def __init__(self, port):
|
|
self.port = port
|
|
self.session_queue = []
|
|
self._status = self.CLOSED
|
|
self.lock = Lock()
|
|
Thread.__init__(self)
|
|
def start(self):
|
|
Thread.start(self)
|
|
time.sleep(0.1)
|
|
dbgPavim.updateStatusLine()
|
|
def pendingCount(self):
|
|
self.lock.acquire()
|
|
c = len(self.session_queue)
|
|
self.lock.release()
|
|
return c
|
|
def newSession(self, ss):
|
|
if not isinstance(ss, DbgSessionWithUI):
|
|
s = DbgSessionWithUI(None,"")
|
|
s.copyFromParent(ss)
|
|
ss = s
|
|
self.lock.acquire()
|
|
self.session_queue.append(ss)
|
|
c = str(len(self.session_queue))
|
|
self.lock.release()
|
|
dbgPavim.updateStatusLine()
|
|
if dbgPavim.dbgPavimOnce:
|
|
self.stop(False)
|
|
print c+" pending connection(s) to be debug, press "+dbgPavim.dbgPavimKeyRun+" to continue."
|
|
def nextSession(self):
|
|
session = None
|
|
self.lock.acquire()
|
|
if len(self.session_queue) > 0:
|
|
session = self.session_queue.pop(0)
|
|
self.lock.release()
|
|
dbgPavim.updateStatusLine()
|
|
print ""
|
|
return session
|
|
def stop(self, closeConnection = True):
|
|
self.lock.acquire()
|
|
try:
|
|
if self._status == self.LISTEN:
|
|
client = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
|
|
client.connect ( ( '127.0.0.1', self.port ) )
|
|
client.close()
|
|
finally:
|
|
if closeConnection:
|
|
for s in self.session_queue:
|
|
s.send_command('detach')
|
|
s.sock.close()
|
|
del self.session_queue[:]
|
|
self._status = self.CLOSED
|
|
self.lock.release()
|
|
dbgPavim.updateStatusLine()
|
|
def status(self):
|
|
self.lock.acquire()
|
|
s = self._status
|
|
self.lock.release()
|
|
return s
|
|
def run(self):
|
|
global dbgPavim
|
|
self.lock.acquire()
|
|
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
serv.settimeout(None)
|
|
try:
|
|
serv.bind(('', self.port))
|
|
except socket.error, e:
|
|
print "Can not bind to port "+str(self.port)+', Socket Error '+str(e[0])
|
|
self.lock.release()
|
|
return
|
|
print ""
|
|
serv.listen(5)
|
|
self._status = self.LISTEN
|
|
self.lock.release()
|
|
while 1:
|
|
(sock, address) = serv.accept()
|
|
adr = '%s:%d' % (address[0], address[1])
|
|
DBGPavimTrace('# Connection from %s\n' % adr)
|
|
s = self.status()
|
|
if s == self.LISTEN:
|
|
if dbgPavim.breakAtEntry:
|
|
self.newSession(DbgSessionWithUI(sock, adr))
|
|
else:
|
|
client = DbgSilentClient(DbgSession(sock, adr))
|
|
client.start()
|
|
else:
|
|
break
|
|
serv.close()
|
|
|
|
class BreakPoint:
|
|
""" Breakpoint class """
|
|
def __init__(self):
|
|
""" initalize """
|
|
self.dictionaries = {}
|
|
self.startbno = 10000
|
|
self.maxbno = self.startbno
|
|
def clear(self):
|
|
""" clear of breakpoint number """
|
|
self.dictionaries.clear()
|
|
self.maxbno = self.startbno
|
|
def add(self, file, line, exp = ''):
|
|
""" add break point at file:line """
|
|
self.maxbno = self.maxbno + 1
|
|
self.dictionaries[self.maxbno] = { 'file':file, 'line':line, 'exp':exp }
|
|
return self.maxbno
|
|
def remove(self, bno):
|
|
""" remove break point numbered with bno """
|
|
del self.dictionaries[bno]
|
|
def find(self, file, line):
|
|
""" find break point and return bno(breakpoint number) """
|
|
signs = vim.eval('Signs()')
|
|
for k in signs.keys():
|
|
if signs[k][0] == file and signs[k][1] == line:
|
|
bno = int(k)
|
|
self.dictionaries[bno]['file'] = file
|
|
self.dictionaries[bno]['line'] = line
|
|
return bno
|
|
return None
|
|
def getfile(self, bno):
|
|
""" get file name of breakpoint numbered with bno """
|
|
return self.dictionaries[bno]['file']
|
|
def getline(self, bno):
|
|
""" get line number of breakpoint numbered with bno """
|
|
return self.dictionaries[bno]['line']
|
|
def getexp(self, bno):
|
|
""" get expression of breakpoint numbered with bno """
|
|
return self.dictionaries[bno]['exp']
|
|
def list(self):
|
|
""" return list of breakpoint number """
|
|
return self.dictionaries.keys()
|
|
|
|
class AsyncRunner(Thread):
|
|
def __init__(self, cmd, logfile):
|
|
self.cmd = cmd
|
|
self.logfile = logfile
|
|
Thread.__init__(self)
|
|
def run(self):
|
|
log = open(self.logfile, "w")
|
|
subprocess.check_call(self.cmd, stdin=None, stdout=log, stderr=log, shell=True)
|
|
log.close()
|
|
os.remove(self.logfile)
|
|
|
|
class DBGPavim:
|
|
""" Main DBGPavim class """
|
|
def __init__(self):
|
|
""" initialize DBGPavim """
|
|
self.loadSettings()
|
|
self.debugListener = DbgListener(self.port)
|
|
self.debugSession = DbgSession(None,"")
|
|
vim.command('sign unplace *')
|
|
|
|
self.normal_statusline = vim.eval('&statusline')
|
|
self.statusline="%<%f\ %h%m%r\ %=%-10.(%l,%c%V%)\ %P\ %=%{(g:dbgPavimBreakAtEntry==1)?'bae':'bap'}"
|
|
self.breakpt = BreakPoint()
|
|
self.breakold = BreakPoint()
|
|
self.ui = DebugUI(0.3, 0.4)
|
|
self.watchList = []
|
|
self.evalList = []
|
|
self.running = True
|
|
|
|
def updateStatusLine(self):
|
|
status = self.debugListener.status()
|
|
c = self.debugListener.pendingCount()
|
|
if c > 0:
|
|
sl = self.statusline+"%{'-PEND-"+str(c)+"'}"
|
|
elif self.debugSession.sock != None:
|
|
sl = self.statusline+"%{'-CONN'}"
|
|
elif status == DbgListener.LISTEN:
|
|
sl = self.statusline+"%{'-LISN-"+str(self.port)+"'}"
|
|
else:
|
|
sl = self.normal_statusline
|
|
vim.command("let &statusline=\""+sl+"\"")
|
|
|
|
def loadSettings(self):
|
|
self.port = int(vim.eval('g:dbgPavimPort'))
|
|
self.dbgPavimKeyRun = vim.eval('g:dbgPavimKeyRun')
|
|
self.maxChildren = vim.eval('g:dbgPavimMaxChildren')
|
|
self.maxData = vim.eval('g:dbgPavimMaxData')
|
|
self.maxDepth = vim.eval('g:dbgPavimMaxDepth')
|
|
self.breakAtEntry = int(vim.eval('g:dbgPavimBreakAtEntry'))
|
|
self.showContext = int(vim.eval('g:dbgPavimShowContext'))
|
|
self.pathMap = vim.eval('g:dbgPavimPathMap')
|
|
self.dbgPavimOnce = int(vim.eval('g:dbgPavimOnce'))
|
|
for m in self.pathMap:
|
|
m[0] = m[0].replace("\\","/")
|
|
m[1] = m[1].replace("\\","/")
|
|
def remotePathOf(self,lpath):
|
|
for m in self.pathMap:
|
|
l = len(m[0])
|
|
if l and lpath[0:l] == m[0]:
|
|
return m[1]+lpath[l:]
|
|
fn = lpath
|
|
if fn[:7] != "file://":
|
|
fn = fn.replace("\\","/")
|
|
if fn[1] == ':':
|
|
fn = "file:///"+fn
|
|
else:
|
|
fn = "file://"+fn
|
|
lpath = fn
|
|
return lpath
|
|
def localPathOf(self,rpath):
|
|
for m in self.pathMap:
|
|
l = len(m[1])
|
|
if l and rpath[0:l] == m[1]:
|
|
return m[0]+rpath[l:]
|
|
return rpath
|
|
def setMaxChildren(self):
|
|
self.maxChildren = vim.eval('g:dbgPavimMaxChildren')
|
|
if self.debugSession.sock != None:
|
|
self.debugSession.command('feature_set', '-n max_children -v ' + self.maxChildren)
|
|
def setMaxDepth(self):
|
|
self.maxDepth = vim.eval('g:dbgPavimMaxDepth')
|
|
if self.debugSession.sock != None:
|
|
self.debugSession.command('feature_set', '-n max_depth -v ' + self.maxDepth)
|
|
def setMaxData(self):
|
|
self.maxData = vim.eval('g:dbgPavimMaxData')
|
|
if self.debugSession.sock != None:
|
|
self.debugSession.command('feature_set', '-n max_data -v ' + self.maxData)
|
|
def handle_exception(self):
|
|
DBGPavimTrace(str(sys.exc_info()[1]))
|
|
DBGPavimTrace("".join(traceback.format_tb( sys.exc_info()[2])))
|
|
errno = sys.exc_info()[0]
|
|
|
|
session = self.debugListener.nextSession()
|
|
if errno == socket.timeout:
|
|
if session != None:
|
|
print "socket timeout, switch to another session."
|
|
ss = DbgSession(self.debugSession.sock, self.debugSession.address)
|
|
ss.latestRes = self.debugSession.latestRes
|
|
client = DbgSilentClient(ss)
|
|
client.start()
|
|
self.debugSession = session
|
|
self.debugSession.start()
|
|
else:
|
|
print "socket timeout, try again or press F6 to stop debugging."
|
|
else: #errno == socket.error:
|
|
self.debugSession.close()
|
|
if session != None:
|
|
self.debugSession = session
|
|
self.debugSession.start()
|
|
else:
|
|
self.ui.normal_mode()
|
|
self.updateStatusLine()
|
|
def step(self):
|
|
self.debugSession.command('stack_get')
|
|
if self.showContext:
|
|
self.debugSession.command('context_get', ('-d %d' % self.debugSession.curstack))
|
|
for var in self.watchList:
|
|
self.debugSession.command('property_get', "-d %d -n %s" % (self.debugSession.curstack, var))
|
|
for expr in self.evalList:
|
|
self.debugSession.command('eval', '', expr)
|
|
def command(self, msg, arg1 = '', arg2 = ''):
|
|
try:
|
|
if self.debugSession.sock == None:
|
|
print 'No debug session started.'
|
|
else:
|
|
self.debugSession.command(msg, arg1, arg2)
|
|
if self.debugSession.status != 'stopping':
|
|
self.step()
|
|
else:
|
|
self.debugSession.command('stop')
|
|
except:
|
|
self.handle_exception()
|
|
def context(self):
|
|
self.debugSession.command('context_get', ('-d %d' % self.debugSession.curstack))
|
|
def watch_input(self, cmd, arg = ''):
|
|
self.debugSession.ui.watchwin.input(cmd, arg)
|
|
def watch(self, name = ''):
|
|
if name == '':
|
|
self.showContext = not self.showContext
|
|
else:
|
|
if name in self.watchList:
|
|
self.watchList.remove(name)
|
|
else:
|
|
self.watchList.append(name)
|
|
def eval(self, name = ''):
|
|
if name == '':
|
|
print "Please follow an expression that you'd like to be evaluated automatically after each step."
|
|
else:
|
|
if name in self.evalList:
|
|
self.evalList.remove(name)
|
|
else:
|
|
self.evalList.append(name)
|
|
def listWatch(self):
|
|
if self.showContext:
|
|
print '*CONTEXT*'
|
|
for var in self.watchList:
|
|
print var
|
|
for exp in self.evalList:
|
|
print exp+'(eval)'
|
|
def property(self, name = ''):
|
|
try:
|
|
if self.debugSession.sock == None:
|
|
print 'No debug session started.'
|
|
else:
|
|
if name == '':
|
|
name = vim.eval('expand("<cword>")')
|
|
elif name == '%v%':
|
|
name = vim.eval('@v')
|
|
name = string.replace(name,'"','\'')
|
|
if self.fileType == 'php' and name[0] != '$':
|
|
name = '$'+name
|
|
self.debugSession.property_get(name)
|
|
except:
|
|
self.handle_exception()
|
|
def up(self):
|
|
try:
|
|
if self.debugSession.sock == None:
|
|
print 'No debug session started.'
|
|
else:
|
|
self.debugSession.up()
|
|
except:
|
|
self.handle_exception()
|
|
|
|
def down(self):
|
|
try:
|
|
if self.debugSession.sock == None:
|
|
print 'No debug session started.'
|
|
else:
|
|
self.debugSession.down()
|
|
except:
|
|
self.handle_exception()
|
|
|
|
def run(self):
|
|
""" start debugger or continue """
|
|
try:
|
|
status = self.debugListener.status()
|
|
session = self.debugListener.nextSession()
|
|
if session != None:
|
|
self.debugSession = session
|
|
self.debugSession.start()
|
|
else:
|
|
if self.debugSession.sock != None:
|
|
self.debugSession.command('run')
|
|
if self.debugSession.status == 'stopping':
|
|
self.debugSession.command("stop")
|
|
elif self.debugSession.status != 'stopped':
|
|
self.step()
|
|
elif status == DbgListener.CLOSED:
|
|
self.running = True
|
|
self.loadSettings()
|
|
self.debugListener = DbgListener(self.port)
|
|
self.debugListener.start()
|
|
except:
|
|
self.handle_exception()
|
|
|
|
def cli(self, args):
|
|
vim.command("let g:dbgPavimBreakAtEntry=1")
|
|
self.ui.cliwin = ConsoleWindow(self.ui.clilog)
|
|
filetype = vim.eval('&filetype')
|
|
filename = vim.eval('expand("%")')
|
|
if filename:
|
|
cmd = ' '+filename+' '+args
|
|
if filetype == 'php':
|
|
if vim.eval('CheckXdebug()') == '0':
|
|
cmd = 'php -dxdebug.remote_autostart=1 -dxdebug.remote_port='+str(self.port)+cmd
|
|
elif filetype == 'python':
|
|
if vim.eval('CheckPydbgp()') == '0':
|
|
cmd = 'pydbgp -u -d '+str(self.port)+cmd
|
|
if cmd[0] != ' ':
|
|
self.run()
|
|
ar = AsyncRunner(cmd, self.ui.clilog)
|
|
ar.start()
|
|
time.sleep(0.4)
|
|
#vim.eval('feedkeys("\\'+self.dbgPavimKeyRun+'")')
|
|
else:
|
|
print "Only python and php file debugging are integrated for now."
|
|
else:
|
|
print "You need open one python or php file first."
|
|
|
|
def list(self):
|
|
vim.command("lgetexpr []")
|
|
inCount = 0
|
|
for bno in self.breakpt.list():
|
|
inCount = inCount + 1
|
|
if self.breakpt.getexp(bno) != '':
|
|
vim.command("lad '"+"\|condition: "+self.breakpt.getexp(bno)+" \| "+self.breakpt.getfile(bno)+":"+str(self.breakpt.getline(bno))+":1'")
|
|
else:
|
|
vim.command("lad '"+self.breakpt.getfile(bno)+":"+str(self.breakpt.getline(bno))+":1'")
|
|
vim.command("lw")
|
|
if inCount > 0 :
|
|
vim.command("wincmd j")
|
|
vim.command("resize 10")
|
|
|
|
def clear(self):
|
|
for bno in self.breakpt.list():
|
|
self.breakold.add(self.breakpt.getfile(bno), self.breakpt.getline(bno), self.breakpt.getexp(bno))
|
|
vim.command('sign unplace ' + str(bno))
|
|
id = self.debugSession.getbid(bno)
|
|
if self.debugSession.sock != None and id != None:
|
|
self.debugSession.command('breakpoint_remove', '-d ' + str(id))
|
|
self.breakpt.remove(bno)
|
|
|
|
def unclear(self):
|
|
for bno in self.breakold.list():
|
|
row = self.breakold.getline(bno)
|
|
file = self.breakold.getfile(bno)
|
|
exp = self.breakold.getexp(bno)
|
|
self.breakold.remove(bno)
|
|
inbno = self.breakpt.find(file, str(row))
|
|
if inbno == None:
|
|
inbno = self.breakpt.add(file, row, exp)
|
|
vim.command('sign place ' + str(inbno) + ' name=breakpt line=' + str(row) + ' file=' + file)
|
|
if self.debugSession.sock != None:
|
|
fn = dbgPavim.remotePathOf(self.breakpt.getfile(inbno))
|
|
msgid = self.debugSession.send_command('breakpoint_set', \
|
|
'-t line -f ' + fn + ' -n ' + str(self.breakpt.getline(inbno)), \
|
|
self.breakpt.getexp(inbno))
|
|
self.debugSession.bptsetlst[msgid] = inbno
|
|
self.debugSession.ack_command()
|
|
|
|
def mark(self, exp = ''):
|
|
(row, col) = vim.current.window.cursor
|
|
file = vim.current.buffer.name
|
|
|
|
bno = self.breakpt.find(file, str(row))
|
|
if bno != None:
|
|
self.breakpt.remove(bno)
|
|
vim.command('sign unplace ' + str(bno))
|
|
id = self.debugSession.getbid(bno)
|
|
if self.debugSession.sock != None and id != None:
|
|
self.debugSession.command('breakpoint_remove', '-d ' + str(id))
|
|
else:
|
|
bno = self.breakpt.add(file, row, exp)
|
|
vim.command('sign place ' + str(bno) + ' name=breakpt line=' + str(row) + ' file=' + file)
|
|
if self.debugSession.sock != None:
|
|
fn = dbgPavim.remotePathOf(self.breakpt.getfile(bno))
|
|
msgid = self.debugSession.send_command('breakpoint_set', \
|
|
'-t line -f ' + fn + ' -n ' + str(self.breakpt.getline(bno)), \
|
|
self.breakpt.getexp(bno))
|
|
self.debugSession.bptsetlst[msgid] = bno
|
|
self.debugSession.ack_command()
|
|
|
|
def quit(self):
|
|
self.running = False
|
|
if self.debugSession.sock:
|
|
self.debugSession.send_command('detach')
|
|
self.ui.normal_mode()
|
|
self.debugSession.close()
|
|
self.debugListener.stop()
|
|
|
|
def dbgPavim_init():
|
|
global dbgPavim
|
|
dbgPavim = DBGPavim()
|
|
|
|
error_msg = { \
|
|
# 000 Command parsing errors
|
|
0 : """no error""", \
|
|
1 : """parse error in command""", \
|
|
2 : """duplicate arguments in command""", \
|
|
3 : """invalid options (ie, missing a required option)""", \
|
|
4 : """Unimplemented command""", \
|
|
5 : """Command not available (Is used for async commands. For instance if the engine is in state "run" than only "break" and "status" are available). """, \
|
|
# 100 : File related errors
|
|
100 : """can not open file (as a reply to a "source" command if the requested source file can't be opened)""", \
|
|
101 : """stream redirect failed """, \
|
|
# 200 Breakpoint, or code flow errors
|
|
200 : """breakpoint could not be set (for some reason the breakpoint could not be set due to problems registering it)""", \
|
|
201 : """breakpoint type not supported (for example I don't support 'watch' yet and thus return this error)""", \
|
|
202 : """invalid breakpoint (the IDE tried to set a breakpoint on a line that does not exist in the file (ie "line 0" or lines past the end of the file)""", \
|
|
203 : """no code on breakpoint line (the IDE tried to set a breakpoint on a line which does not have any executable code. The debugger engine is NOT required to """ + \
|
|
"""return this type if it is impossible to determine if there is code on a given location. (For example, in the PHP debugger backend this will only be """ + \
|
|
"""returned in some special cases where the current scope falls into the scope of the breakpoint to be set)).""", \
|
|
204 : """Invalid breakpoint state (using an unsupported breakpoint state was attempted)""", \
|
|
205 : """No such breakpoint (used in breakpoint_get etc. to show that there is no breakpoint with the given ID)""", \
|
|
206 : """Error evaluating code (use from eval() (or perhaps property_get for a full name get))""", \
|
|
207 : """Invalid expression (the expression used for a non-eval() was invalid) """, \
|
|
# 300 Data errors
|
|
300 : """Can not get property (when the requested property to get did not exist, this is NOT used for an existing but uninitialized property, which just gets the """ + \
|
|
"""type "uninitialised" (See: PreferredTypeNames)).""", \
|
|
301 : """Stack depth invalid (the -d stack depth parameter did not exist (ie, there were less stack elements than the number requested) or the parameter was < 0)""", \
|
|
302 : """Context invalid (an non existing context was requested) """, \
|
|
# 900 Protocol errors
|
|
900 : """Encoding not supported""", \
|
|
998 : """An internal exception in the debugger occurred""", \
|
|
999 : """Unknown error """ \
|
|
}
|