This repository has been archived by the owner on Nov 15, 2021. It is now read-only.
forked from mark-moseley/ruby-debug
/
rdebug
executable file
·397 lines (377 loc) · 11.6 KB
/
rdebug
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
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
#!/usr/bin/env ruby
#=== Summary
#
#A command-line front-end to the Ruby debugger, <tt>ruby-debug</tt>, the
#Fast Ruby Debugger.
#
#Command invocation:
#
# rdebug [options] [--] [script-options] ruby-script-to-debug
# rdebug [options] [script-options] [--client]
# rdebug [--version | --help]
#
#=== Options
#
#<tt>-A | --annotate</tt> <i>level</i>::
# Set gdb-style annotation to <i>level</i>, a number. Additional
# information is output automatically when program state is
# changed. This can be used by front-ends such as GNU Emacs to post
# this updated information without having to poll for it.
#
#<tt>--client</tt>::
# Connect to a remote debugger. Used with another rdebug invocation
# using <tt>--server</tt>. See also <tt>--host</tt> and
# <tt>--cport</tt> options
#
#<tt>--cport=</tt><i>port</i>::
# Use port <i>port</i> for access to debugger control.
#
#<tt>-d | --debug</tt>::
# Set $DEBUG true.
#
#<tt>--emacs</tt>::
# Activates full GNU Emacs mode. Is the equivalent of setting the
# options <tt>--emacs-basic --annotate=3 --no-stop --no-control
# --post-mortem</tt>.
#
#<tt>--emacs-basic</tt>::
# Activates GNU Emacs mode. Debugger prompts are prefaced with two
# octal 032 characters.
#
#<tt>-h | --host=</tt><i>host</i>::
# Use host name <i>host</i> for remote debugging.
#
#<tt>-I | --include</tt> <i>path</i>
# Add <i>path</i> to <tt>$LOAD_PATH</tt>
#
#<tt>-m | --post-mortem</tt>::
# Activate post-mortem mode.
#
#<tt>--no-control</tt>::
# Do not automatically start control thread.
#
#<tt>--no-stop</tt>::
# Do not stop when script is loaded.
#
#<tt>-p | --port=PORT</tt>::
# Host name used for remote debugging.
#
#<tt>-r | --require</tt><i>script</i>::
# Require the library, before executing your script.
#
#<tt>--script</tt> <i>file</i>::
# Run debugger script file <i>file</i>
#
#<tt>-x | --trace</tt>::
# Show lines before executing them.
#
#<tt>--no-quit</tt>::
# Do not quit when script terminates. Instead rerun the
# program.
#
#<tt>--version</tt>::
# Show the version number and exit.
#
#<tt>--verbose</tt>::
# Turn on verbose mode.
#
#<tt>--v</tt>::
# Print the version number, then turn on verbose mode if
# a script name is given. If no script name is given
# just exit after printing the version number.
#
#<tt>--nx</tt>::
# Don’t execute commands found in any initialization
# files, e.g. <tt>.rdebugrc</tt>.
#
#<tt>--keep-frame-binding</tt>::
# Keep frame bindings.
#
#<tt>--script=</tt><i>file</i>::
# Name of the script file to run
#
#<tt>-s | --server</tt>::
# Listen for remote connections. Another rdebug session
# accesses using the <tt>--client</tt> option. See also the
# <tt>--host</tt>, <tt>--port</tt> and <tt>--cport</tt> options
#
#<tt>-w | --wait</tt>::
# Wait for a client connection; implies <tt>-s</tt> option.
#
#<tt>--help</tt>::
# Show invocation help and exit.
require 'optparse'
require 'ostruct'
require 'ruby-debug'
def debug_program(options)
# Make sure Ruby script syntax checks okay.
# Otherwise we get a load message that looks like rdebug has
# a problem.
output = `ruby -c "#{Debugger::PROG_SCRIPT}" 2>&1`
if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
puts output
exit $?.exitstatus
end
print "\032\032starting\n" if Debugger.annotate and Debugger.annotate > 2
# Record where we are we can know if the call stack has been
# truncated or not.
Debugger.start_sentinal=caller(0)[1]
bt = Debugger.debug_load(Debugger::PROG_SCRIPT, options.stop, false)
if bt
print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
print "Uncaught exception: #{bt}\n"
end
end
# Do a shell-like path lookup for prog_script and return the results.
# If we can't find anything return prog_script.
def whence_file(prog_script)
if prog_script.index(File::SEPARATOR)
# Don't search since this name has path separator components
return prog_script
end
for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
prog_script_try = File.join(dirname, prog_script)
return prog_script_try if File.exist?(prog_script_try)
end
# Failure
return prog_script
end
options = OpenStruct.new(
'annotate' => Debugger.annotate,
'client' => false,
'control' => true,
'cport' => Debugger::PORT + 1,
'host' => nil,
'quit' => true,
'no_rewrite_program' => false,
'stop' => true,
'nx' => false,
'port' => Debugger::PORT,
'restart_script' => nil,
'script' => nil,
'server' => false,
'tracing' => false,
'verbose_long' => false,
'wait' => false
)
def process_options(options)
program = File.basename($0)
opts = OptionParser.new do |opts|
opts.banner = <<EOB
#{program} #{Debugger::VERSION}
Usage: #{program} [options] <script.rb> -- <script.rb parameters>
EOB
opts.separator ""
opts.separator "Options:"
opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do
|annotate|
Debugger.annotate = annotate
end
opts.on("-c", "--client", "Connect to remote debugger") do
options.client = true
end
opts.on("--cport PORT", Integer, "Port used for control commands") do
|cport|
options.cport = cport
end
opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
opts.on("--emacs LEVEL", Integer,
"Activates full Emacs support at annotation level LEVEL") do
|level|
Debugger.annotate = level.to_i
ENV['EMACS'] = '1'
ENV['COLUMNS'] = '120' if ENV['COLUMNS'].to_i < 120
options.control = false
options.quit = false
end
opts.on('--emacs-basic', 'Activates basic Emacs mode') do
ENV['EMACS'] = '1'
end
opts.on('-h', '--host HOST', 'Host name used for remote debugging') do
|host|
options.host = host
end
opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') do |path|
$LOAD_PATH.unshift(path)
end
opts.on('--no-control', 'Do not automatically start control thread') do
options.control = false
end
opts.on('--no-quit', 'Do not quit when script finishes') do
options.quit = false
end
opts.on('--no-rewrite-program',
'Do not set $0 to the program being debugged') do
options.no_rewrite_program = true
end
opts.on('--no-stop', 'Do not stop when script is loaded') do
options.stop = false
end
opts.on('-nx', 'Not run debugger initialization files (e.g. .rdebugrc') do
options.nx = true
end
opts.on('-p', '--port PORT', Integer, 'Port used for remote debugging') do
|port|
options.port = port
end
opts.on('-r', '--require SCRIPT', String,
'Require the library, before executing your script') do |name|
if name == 'debug'
puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
else
require name
end
end
opts.on('--restart-script FILE', String,
'Name of the script file to run. Erased after read') do
|restart_script|
options.restart_script = restart_script
unless File.exists?(options.restart_script)
puts "Script file '#{options.restart_script}' is not found"
exit
end
end
opts.on('--script FILE', String, 'Name of the script file to run') do
|script|
options.script = script
unless File.exists?(options.script)
puts "Script file '#{options.script}' is not found"
exit
end
end
opts.on('-s', '--server', 'Listen for remote connections') do
options.server = true
end
opts.on('-w', '--wait', 'Wait for a client connection, implies -s option') do
options.wait = true
end
opts.on('-x', '--trace', 'Turn on line tracing') {options.tracing = true}
opts.separator ''
opts.separator 'Common options:'
opts.on_tail('--help', 'Show this message') do
puts opts
exit
end
opts.on_tail('--version',
'Print the version') do
puts "ruby-debug #{Debugger::VERSION}"
exit
end
opts.on('--verbose', 'Turn on verbose mode') do
$VERBOSE = true
options.verbose_long = true
end
opts.on_tail('-v',
'Print version number, then turn on verbose mode') do
puts "ruby-debug #{Debugger::VERSION}"
$VERBOSE = true
end
end
return opts
end
# What file is used for debugger startup commands.
unless defined?(OPTS_INITFILE)
if RUBY_PLATFORM =~ /mswin/
# Of course MS Windows has to be different
OPTS_INITFILE = 'rdbopt.ini'
HOME_DIR = (ENV['HOME'] ||
ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
else
OPTS_INITFILE = '.rdboptrc'
HOME_DIR = ENV['HOME'].to_s
end
end
begin
initfile = File.join(HOME_DIR, OPTS_INITFILE)
eval(File.read(initfile)) if
File.exist?(initfile)
rescue
end
opts = process_options(options)
begin
if not defined? Debugger::ARGV
Debugger::ARGV = ARGV.clone
end
rdebug_path = File.expand_path($0)
if RUBY_PLATFORM =~ /mswin/
rdebug_path += '.cmd' unless rdebug_path =~ /\.cmd$/i
end
Debugger::RDEBUG_SCRIPT = rdebug_path
Debugger::RDEBUG_FILE = __FILE__
Debugger::INITIAL_DIR = Dir.pwd
opts.parse! ARGV
rescue StandardError => e
puts opts
puts
puts e.message
exit(-1)
end
if options.client
Debugger.start_client(options.host, options.port)
else
if ARGV.empty?
exit if $VERBOSE and not options.verbose_long
puts opts
puts
puts 'Must specify a script to run'
exit(-1)
end
# save script name
prog_script = ARGV.shift
prog_script = whence_file(prog_script) unless File.exist?(prog_script)
Debugger::PROG_SCRIPT = File.expand_path prog_script
# install interruption handler
trap('INT') { Debugger.interrupt_last }
# set options
Debugger.wait_connection = options.wait
if options.server
# start remote mode
Debugger.start_remote(options.host, [options.port, options.cport]) do
# load initrc script
Debugger.run_init_script(StringIO.new) unless options.nx
end
debug_program(options)
else
# Set up trace hook for debugger
Debugger.start
# start control thread
Debugger.start_control(options.host, options.cport) if options.control
# load initrc script (e.g. .rdebugrc)
Debugger.run_init_script(StringIO.new) unless options.nx
# run restore-settings startup script if specified
if options.restart_script
require 'fileutils'
Debugger.run_script(options.restart_script)
FileUtils.rm(options.restart_script)
end
# run startup script if specified
if options.script
Debugger.run_script(options.script)
end
options.stop = false if options.tracing
Debugger.tracing = options.tracing
if !options.quit
if Debugger.started?
until Debugger.stop do end
end
begin
debug_program(options)
rescue SyntaxError
puts $!.backtrace.map{|l| "\t#{l}"}.join("\n")
puts "Uncaught Syntax Error\n"
rescue
print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
print "Uncaught exception: #{$!}\n"
end
print "The program finished.\n" unless
Debugger.annotate.to_i > 1 # annotate has its own way
interface = Debugger::LocalInterface.new
# Not sure if ControlCommandProcessor is really the right
# thing to use. CommandProcessor requires a state.
processor = Debugger::ControlCommandProcessor.new(interface)
processor.process_commands
else
debug_program(options)
end
end
end