-
Notifications
You must be signed in to change notification settings - Fork 156
/
runner.py
314 lines (275 loc) · 11.1 KB
/
runner.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
# coding=utf-8
import vdebug.dbgp
import vdebug.log
import vdebug.ui.vimui
import socket
import vim
import vdebug.breakpoint
import vdebug.opts
import vdebug.util
class Runner:
""" Class that stitches together all the debugger components.
This instantiates the connection and debugger vdebug.ui, and provides
an interface that Vim can use to send commands.
"""
def __init__(self):
self.api = None
vdebug.opts.Options.set(vim.eval('g:vdebug_options'))
self.breakpoints = vdebug.breakpoint.Store()
self.keymapper = vdebug.util.Keymapper()
self.ui = vdebug.ui.vimui.Ui(self.breakpoints)
def open(self):
""" Open the connection and debugging vdebug.ui.
If either of these are already open, the current
connection or vdebug.ui is used.
"""
vdebug.opts.Options.set(vim.eval('g:vdebug_options'))
if vdebug.opts.Options.isset('debug_file'):
vdebug.log.Log.set_logger(vdebug.log.FileLogger(\
vdebug.opts.Options.get('debug_file_level'),\
vdebug.opts.Options.get('debug_file')))
self.listen(\
vdebug.opts.Options.get('server'),\
vdebug.opts.Options.get('port',int),\
vdebug.opts.Options.get('timeout',int))
self.ui.open()
self.keymapper.map()
self.ui.set_listener_details(\
vdebug.opts.Options.get('server'),\
vdebug.opts.Options.get('port'),\
vdebug.opts.Options.get('ide_key'))
addr = self.api.conn.address
vdebug.log.Log("Found connection from " + str(addr),vdebug.log.Logger.INFO)
self.ui.set_conn_details(addr[0],addr[1])
self.breakpoints.link_api(self.api)
cn_res = self.api.context_names()
self.context_names = cn_res.names()
vdebug.log.Log("Available context names: %s" %\
str(self.context_names),vdebug.log.Logger.DEBUG)
if vdebug.opts.Options.get('break_on_open',int) == 1:
status = self.api.step_into()
else:
status = self.api.run()
self.refresh(status)
def refresh(self,status):
"""The main action performed after a deubugger step.
Updates the status window, current stack, source
file and line and watch window."""
if not self.is_alive():
self.ui.error("Cannot update: no connection")
else:
if str(status) == "interactive":
self.ui.error("Debugger engine says it is in interactive mode,"+\
"which is not supported: closing connection")
self.close_connection()
elif str(status) in ("stopping","stopped"):
self.ui.statuswin.set_status("stopped")
self.ui.say("Debugging session has ended")
self.close_connection(False)
if vdebug.opts.Options.get('continuous_mode', int) != 0:
self.open()
return
else:
vdebug.log.Log("Getting stack information")
self.ui.statuswin.set_status(status)
stack_res = self.update_stack()
stack = stack_res.get_stack()
self.cur_file = vdebug.util.FilePath(stack[0].get('filename'))
self.cur_lineno = stack[0].get('lineno')
vdebug.log.Log("Moving to current position in source window")
self.ui.set_source_position(\
self.cur_file,\
self.cur_lineno)
self.get_context(0)
def get_context(self,context_id = 0):
self.ui.watchwin.clean()
name = self.context_names[context_id]
vdebug.log.Log("Getting %s variables" % name)
context_res = self.api.context_get(context_id)
rend = vdebug.ui.vimui.ContextGetResponseRenderer(\
context_res,"%s at %s:%s" \
%(name,self.ui.sourcewin.file,self.cur_lineno),\
self.context_names, context_id)
self.ui.watchwin.accept_renderer(rend)
def toggle_breakpoint_window(self):
"""Open or close the breakpoint window.
The window appears as a horizontal split below the
currently selected window."""
if self.ui.breakpointwin.is_open:
self.ui.breakpointwin.destroy()
else:
self.ui.breakpointwin.create()
def is_alive(self):
"""Whether the connection is open."""
if self.api is not None and \
self.api.conn.isconnected():
return True
return False
def run(self):
"""Tell the debugger to run.
It will run until the end of the execution or until a
breakpoint is reached."""
if not self.is_alive():
self.open()
else:
vdebug.log.Log("Running")
self.ui.statuswin.set_status("running")
res = self.api.run()
self.refresh(res)
def step_over(self):
"""Step over to the next statement."""
if not self.is_alive():
self.open()
else:
vdebug.log.Log("Stepping over")
self.ui.statuswin.set_status("running")
res = self.api.step_over()
self.refresh(res)
def step_into(self):
"""Step into the next statement."""
if not self.is_alive():
self.open()
else:
vdebug.log.Log("Stepping into statement")
self.ui.statuswin.set_status("running")
res = self.api.step_into()
self.refresh(res)
def step_out(self):
"""Step out of the current context."""
if not self.is_alive():
self.open()
else:
vdebug.log.Log("Stepping out of statement")
self.ui.statuswin.set_status("running")
res = self.api.step_out()
self.refresh(res)
def remove_breakpoint(self,args):
"""Remove a breakpoint, by ID or "*"."""
if args is None:
args = ""
args = args.strip()
if len(args) == 0:
self.ui.error("ID or '*' required to remove a breakpoint: run "+\
"':breakpointWindow' to see breakpoints and their IDs")
return
if args == '*':
self.breakpoints.clear_breakpoints()
else:
arg_parts = args.split(" ")
for id in arg_parts:
self.breakpoints.remove_breakpoint_by_id(id)
def set_breakpoint(self,args):
bp = vdebug.breakpoint.Breakpoint.parse(self.ui,args)
if bp.type == "line":
id = self.breakpoints.find_breakpoint(\
bp.get_file(),\
bp.get_line())
if id is not None:
self.breakpoints.remove_breakpoint_by_id(id)
return
self.breakpoints.add_breakpoint(bp)
def eval(self,code):
"""Evaluate a snippet of code and show the response on the watch window.
"""
try:
vdebug.log.Log("Evaluating code: "+code)
context_res = self.api.eval(code)
rend = vdebug.ui.vimui.ContextGetResponseRenderer(\
context_res,"Eval of: '%s'" \
%context_res.get_code())
self.ui.watchwin.clean()
self.ui.watchwin.accept_renderer(rend)
except vdebug.dbgp.EvalError:
self.ui.error("Failed to evaluate invalid code, '%s'" % code)
def run_to_cursor(self):
"""Tell the debugger to run to the current cursor position.
This fails if the current window is not the source window.
"""
row = self.ui.get_current_row()
file = self.ui.get_current_file()
vdebug.log.Log(file)
vdebug.log.Log(self.ui.sourcewin.get_file())
if file != self.ui.sourcewin.get_file():
self.ui.error("Run to cursor only works in the source window!")
return
vdebug.log.Log("Running to position: line %s of %s" %(row,file))
bp = vdebug.breakpoint.TemporaryLineBreakpoint(self.ui,file,row)
self.api.breakpoint_set(bp.get_cmd())
self.run()
def listen(self,server,port,timeout):
"""Open the vdebug.dbgp API with connection.
Uses existing connection if possible.
"""
if self.is_alive():
vdebug.log.Log("Cannot open a new connection \
while one already exists",\
vdebug.log.Logger.ERROR)
return
else:
while True:
ide_key = vdebug.opts.Options.get('ide_key')
check_ide_key = True
if len(ide_key) == 0:
check_ide_key = False
connection = vdebug.dbgp.Connection(server,port,\
timeout,vdebug.util.InputStream())
self.api = vdebug.dbgp.Api(connection)
if check_ide_key and ide_key != self.api.idekey:
print "Ignoring debugger connection with IDE key '%s'" \
% self.api.idekey
self.api.detach()
else:
break
def update_stack(self):
"""Update the stack window with the current stack info.
"""
if not self.is_alive():
self.ui.error("Cannot update the stack: no debugger connection")
else:
self.ui.stackwin.clean()
res = self.api.stack_get()
renderer = vdebug.ui.vimui.StackGetResponseRenderer(res)
self.ui.stackwin.accept_renderer(renderer)
return res
def detach(self):
"""Detach the debugger engine, and allow it to continue execution.
"""
if not self.is_alive():
self.ui.error("Cannot detach: no debugger connection")
else:
self.ui.say("Detaching the debugger")
self.api.detach()
def close_connection(self,stop = True):
""" Close the connection to the debugger.
"""
self.breakpoints.unlink_api()
self.ui.mark_as_stopped()
try:
if self.is_alive():
vdebug.log.Log("Closing the connection")
if stop:
if vdebug.opts.Options.get('on_close') == 'detach':
try:
self.api.detach()
except vdebug.dbgp.CmdNotImplementedError:
self.ui.error('Detach is not supported by the debugger, stopping instead')
vdebug.opts.Options.overwrite('on_close','stop')
self.api.stop()
else:
self.api.stop()
self.api.conn.close()
self.api = None
else:
self.api = None
except EOFError:
self.api = None
self.ui.say("Connection has been closed")
except socket.error:
self.api = None
self.ui.say("Connection has been closed")
def close(self):
""" Close both the connection and vdebug.ui.
"""
self.close_connection()
self.ui.close()
self.keymapper.unmap()