ruby-debug 0.1.2 → 0.1.3

data/lib/ruby-debug.rb

@@ -19,8 +19,8 @@ module Debugger
       return if Thread.critical
       return if @locker == Thread.current
       while (Thread.critical = true; @locked)
-	@waiting.push Thread.current
-	Thread.stop
+        @waiting.push Thread.current
+        Thread.stop
       end
       @locked = true
       @locker = Thread.current
@@ -32,7 +32,7 @@ module Debugger
       return if Thread.critical
       return unless @locked
       unless @locker == Thread.current
-	raise RuntimeError, "unlocked by other"
+        raise RuntimeError, "unlocked by other"
       end
       Thread.critical = true
       t = @waiting.shift
@@ -56,16 +56,16 @@ module Debugger
     begin
       require 'readline'
       def readline(prompt, hist)
-	Readline::readline(prompt, hist)
+        Readline::readline(prompt, hist)
       end
     rescue LoadError
       def readline(prompt, hist)
-	STDOUT.print prompt
-	STDOUT.flush
-	line = STDIN.gets
-	exit unless line
-	line.chomp!
-	line
+        STDOUT.print prompt
+        STDOUT.flush
+        line = STDIN.gets
+        exit unless line
+        line.chomp!
+        line
       end
       USE_READLINE = false
     end
@@ -85,17 +85,17 @@ module Debugger
       fs = frames.size
       tb = caller(0)[-fs..-1]
       if tb
-	for i in tb
-	  stdout.printf "\tfrom %s\n", i
-	end
+        for i in tb
+          stdout.printf "\tfrom %s\n", i
+        end
       end
     end
-    
+
     def at_tracing(file, line)
       if Debugger.trace_proc
-	Debugger.trace_proc.call(self.thnum, file, line)
+        Debugger.trace_proc.call(self.thnum, file, line)
       else
-	stdout.puts sprintf("Tracing(%d):%s:%s", self.thnum, file, line)
+        stdout.puts sprintf("Tracing(%d):%s:%s %s", self.thnum, file, line, line_at(file, line))
       end
     end
 
@@ -105,213 +105,228 @@ module Debugger
       binding_file = file
       binding_line = line
       previous_line = nil
-      stdout.printf "%s:%d:%s", binding_file, binding_line, line_at(binding_file, binding_line)
+      stdout.printf "%s:%d: %s", binding_file, binding_line, line_at(binding_file, binding_line)
       display_expressions(binding)
       prompt = true
       while prompt and input = readline("(rdb:%d) " % Debugger.thnum, true)
-	catch(:debug_error) do
-	  next if input == ''
-
-	  case input
-	  when /^\s*s(?:tep)?(?:\s+(\d+))?$/
-	    self.stop_next = $1 ? $1.to_i : 1
-	    prompt = false
-
-	  when /^\s*c(?:ont)?$|^\s*r(?:un)?$/
-	    prompt = false
-
-	  when /^\s*v(?:ar)?\s+/
-	    debug_variable_info($', binding)
-
-	  when /^\s*w(?:here)?$/, /^\s*f(?:rame)?$/
-	    display_frames(frame_pos)
-
-	  when /^\s*l(?:ist)?(?:\s+(.+))?$/
-	    if not $1
-	      b = previous_line ? previous_line + 10 : binding_line - 5
-	      e = b + 9
-	    elsif $1 == '-'
-	      b = previous_line ? previous_line - 10 : binding_line - 5
-	      e = b + 9
-	    else
-	      b, e = $1.split(/[-,]/)
-	      if e
-		b = b.to_i
-		e = e.to_i
-	      else
-		b = b.to_i - 5
-		e = b + 9
-	      end
-	    end
-	  previous_line = b
-	  display_list(b, e, binding_file, binding_line)
-
-	  when /^\s*n(?:ext)?(?:\s+(\d+))?$/
-	    steps = $1 ? $1.to_i : 1
-	    self.step_over steps, self.frames.size - frame_pos
-	    prompt = false
-
-	  when /^\s*up(?:\s+(\d+))?$/
-	    previous_line = nil
-	    frame_pos += $1 ? $1.to_i : 1
-	    if frame_pos >= self.frames.size
-	      frame_pos = self.frames.size - 1
-	      stdout.puts "At toplevel"
-	    end
-	    frame = self.frames[frame_pos]
-	    binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-	    stdout.print format_frame(frame, frame_pos)
-
-	  when /^\s*down(?:\s+(\d+))?$/
-	    previous_line = nil
-	    frame_pos -= $1 ? $1.to_i : 1
-	    if frame_pos < 0
-	      frame_pos = 0
-	      stdout.print "At stack bottom\n"
-	    end
-	    frame = self.frames[frame_pos]
-	    binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-	    stdout.print format_frame(frame, frame_pos)
-
-	  when /^\s*fin(?:ish)?$/
-	    if frame_pos == self.frames.size
-	      stdout.print "\"finish\" not meaningful in the outermost frame.\n"
-	    else
-	      self.stop_frame = self.frames.size - frame_pos
-	      frame_pos = 0
-	      prompt = false
-	    end
-
-	  when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:]+)$/
-	    pos = $2
-	    if $1
-	      klass = debug_silent_eval($1, binding)
-	      file = $1
-	    end
-	    if pos =~ /^\d+$/
-	      pname = pos
-	      pos = pos.to_i
-	    else
-	      pname = pos = pos.intern.id2name
-	    end
-	    Debugger.add_breakpoint klass || file, pos
-	    stdout.printf "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, klass || file, pname
-
-	  when /^\s*b(?:reak)?\s+(.+)[#.]([^.:]+)$/
-	    pos = $2.intern.id2name
-	    klass = debug_eval($1, binding)
-	    Debugger.add_breakpoint klass, pos
-	    stdout.printf "Set breakpoint %d at %s.%s\n", Debugger.breakpoints.size, klass, pos
-
-	  when /^\s*b(?:reak)?$/
-	    unless Debugger.breakpoints.empty?
-	      stdout.print "Breakpoints:\n"
-	      Debugger.breakpoints.each_with_index do |b, n|
-		stdout.printf "  %d %s:%s\n", n+1, b.source, b.pos
-	      end
-	      stdout.puts
-	    else
-	      stdout.print "No breakpoints\n"
-	    end
-	  when /^\s*del(?:ete)?(?:\s+(\d+))?$/
-	    pos = $1
-	    unless pos
-	      input = readline("Clear all breakpoints? (y/n) ", false)
-	      if input == "y"
-		Debugger.breakpoints.clear
-	      end
-	    else
-	      pos = pos.to_i
-	      unless Debugger.breakpoints.delete_at(pos-1)
-		stdout.printf "Breakpoint %d is not defined\n", pos
-	      end
-	    end
-
-	  when /^\s*th(?:read)?\s+/
-	    if Debugger.debug_thread_info($') == :cont
-	      prompt = false
-	    end
-
-	  when /^\s*m(?:ethod)?\s+/
-	    debug_method_info($', binding)
-
-	  when /^\s*pp\s+/
-	    PP.pp(debug_eval($', binding), stdout)
-
-	  when /^\s*p\s+/
-	    stdout.printf "%s\n", debug_eval($', binding).inspect
-
-	  when /^\s*h(?:elp)?$/
-	    debug_print_help()
-
-	  when /^\s*q(?:uit)?$/
-	    input = readline("Really quit? (y/n) ", false)
-	    if input == "y"
-	      exit!	# exit -> exit!: No graceful way to stop threads...
-	    end
-
-	  when /^\s*disp(?:lay)?\s+(.+)$/
-	    exp = $1
-	    display.push [true, exp]
-	    stdout.printf "%d: ", display.size
-	    display_expression(exp, binding)
-
-	  when /^\s*disp(?:lay)?$/
-	    display_expressions(binding)
-
-	  when /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
-	    pos = $1
-	    unless pos
-	      input = readline("Clear all expressions? (y/n) ", false)
-	      if input == "y"
-		for d in display
-		  d[0] = false
-		end
-	      end
-	    else
-	      pos = pos.to_i
-	      if display[pos-1]
-		display[pos-1][0] = false
-	      else
-		stdout.printf "Display expression %d is not defined\n", pos
-	      end
-	    end
-
-	  when /^\s*cat(?:ch)?(?:\s+(.+))?$/
-	    if $1
-	      excn = $1
-	      if excn == 'off'
-		Debugger.catchpoint = nil
-		stdout.print "Clear catchpoint.\n"
-	      else
-		Debugger.catchpoint = excn
-		stdout.printf "Set catchpoint %s.\n", excn
-	      end
-	    else
-	      if Debugger.catchpoint
-		stdout.printf "Catchpoint %s.\n", Debugger.catchpoint
-	      else
-		stdout.print "No catchpoint.\n"
-	      end
-	    end
-
-	  when /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/
-	    if defined?( $2 )
-	      Debugger.tracing = $1 == 'on'
-	    elsif defined?( $1 )
-	      self.tracing = $1 == 'on'
-	    end
-	  if Debugger.tracing || self.tracing
-	    stdout.print "Trace on.\n"
-	  else
-	    stdout.print "Trace off.\n"
-	  end
-
-	  else
-	    v = debug_eval(input, binding)
-	    stdout.printf "%s\n", v.inspect
-	  end
-	end
+        catch(:debug_error) do
+          next if input == ''
+
+          case input
+          when /^\s*s(?:tep)?(?:\s+(\d+))?$/
+            self.stop_next = $1 ? $1.to_i : 1
+            prompt = false
+
+          when /^\s*c(?:ont)?$|^\s*r(?:un)?$/
+            prompt = false
+
+          when /^\s*v(?:ar)?\s+/
+            debug_variable_info($', binding)
+
+          when /^\s*w(?:here)?$/, /^\s*f(?:rame)?$/
+            display_frames(frame_pos)
+
+          when /^\s*l(?:ist)?(?:\s+(.+))?$/
+            if not $1
+              b = previous_line ? previous_line + 10 : binding_line - 5
+              e = b + 9
+            elsif $1 == '-'
+              b = previous_line ? previous_line - 10 : binding_line - 5
+              e = b + 9
+            else
+              b, e = $1.split(/[-,]/)
+              if e
+                b = b.to_i
+                e = e.to_i
+              else
+                b = b.to_i - 5
+                e = b + 9
+              end
+            end
+            previous_line = b
+            display_list(b, e, binding_file, binding_line)
+
+          when /^\s*n(?:ext)?(?:\s+(\d+))?$/
+            steps = $1 ? $1.to_i : 1
+            self.step_over steps, self.frames.size - frame_pos
+            prompt = false
+
+          when /^\s*up(?:\s+(\d+))?$/
+            previous_line = nil
+            frame_pos += $1 ? $1.to_i : 1
+            if frame_pos >= self.frames.size
+              frame_pos = self.frames.size - 1
+              stdout.puts "At toplevel"
+            end
+            frame = self.frames[frame_pos]
+            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
+            stdout.print format_frame(frame, frame_pos)
+
+          when /^\s*down(?:\s+(\d+))?$/
+            previous_line = nil
+            frame_pos -= $1 ? $1.to_i : 1
+            if frame_pos < 0
+              frame_pos = 0
+              stdout.print "At stack bottom\n"
+            end
+            frame = self.frames[frame_pos]
+            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
+            stdout.print format_frame(frame, frame_pos)
+
+          when /^\s*fin(?:ish)?$/
+            if frame_pos == self.frames.size
+              stdout.print "\"finish\" not meaningful in the outermost frame.\n"
+            else
+              self.stop_frame = self.frames.size - frame_pos
+              frame_pos = 0
+              prompt = false
+            end
+
+          when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:\s]+)\s*(?:\sif\s+(.+))?$/
+            pos = $2
+            expr = $3
+            if $1
+              klass = debug_silent_eval($1, binding)
+              if klass && !klass.kind_of?(Module)
+                stdout.puts "Unknown class #$1"
+                throw :debug_error
+              end
+              klass = klass.name if klass
+              file = $1
+            end
+            if pos =~ /^\d+$/
+              pname = pos
+              pos = pos.to_i
+            else
+              pname = pos = pos.intern.id2name
+            end
+            Debugger.add_breakpoint klass || file, pos, expr
+            stdout.printf "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, klass || file, pname
+
+          when /^\s*b(?:reak)?\s+(.+)[#.]([^.:\s]+)(?:\s+if\s+(.+))?$/
+            pos = $2.intern.id2name
+            expr = $3
+            klass = debug_eval($1, binding)
+            if klass.nil? || !klass.kind_of?(Module)
+              stdout.puts "Unknown class #$1"
+              throw :debug_error
+            end
+            Debugger.add_breakpoint klass.name, pos, expr
+            stdout.printf "Set breakpoint %d at %s.%s\n", Debugger.breakpoints.size, klass, pos
+
+          when /^\s*b(?:reak)?$/
+            unless Debugger.breakpoints.empty?
+              stdout.print "Breakpoints:\n"
+              Debugger.breakpoints.each_with_index do |b, n|
+                if b.expr.nil?
+                  stdout.printf "  %d %s:%s\n", n+1, b.source, b.pos
+                else
+                  stdout.printf "  %d %s:%s if %s\n", n+1, b.source, b.pos, b.expr
+                end
+              end
+              stdout.puts
+            else
+              stdout.print "No breakpoints\n"
+            end
+          when /^\s*del(?:ete)?(?:\s+(\d+))?$/
+            pos = $1
+            unless pos
+              input = readline("Clear all breakpoints? (y/n) ", false)
+              if input == "y"
+                Debugger.breakpoints.clear
+              end
+            else
+              pos = pos.to_i
+              unless Debugger.breakpoints.delete_at(pos-1)
+                stdout.printf "Breakpoint %d is not defined\n", pos
+              end
+            end
+
+          when /^\s*th(?:read)?\s+/
+            if Debugger.debug_thread_info($') == :cont
+              prompt = false
+            end
+
+          when /^\s*m(?:ethod)?\s+/
+            debug_method_info($', binding)
+
+          when /^\s*pp\s+/
+            PP.pp(debug_eval($', binding), stdout) rescue stdout.puts $!.message
+
+          when /^\s*p\s+/
+            stdout.printf "%s\n", debug_eval($', binding).inspect
+
+          when /^\s*h(?:elp)?$/
+            debug_print_help()
+
+          when /^\s*q(?:uit)?$/
+            input = readline("Really quit? (y/n) ", false)
+            if input == "y"
+              exit! # exit -> exit!: No graceful way to stop threads...
+            end
+
+          when /^\s*disp(?:lay)?\s+(.+)$/
+            exp = $1
+            display.push [true, exp]
+            stdout.printf "%d: ", display.size
+            display_expression(exp, binding)
+
+          when /^\s*disp(?:lay)?$/
+            display_expressions(binding)
+
+          when /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
+            pos = $1
+            unless pos
+              input = readline("Clear all expressions? (y/n) ", false)
+              if input == "y"
+                for d in display
+                  d[0] = false
+                end
+              end
+            else
+              pos = pos.to_i
+              if display[pos-1]
+                display[pos-1][0] = false
+              else
+                stdout.printf "Display expression %d is not defined\n", pos
+              end
+            end
+
+          when /^\s*cat(?:ch)?(?:\s+(.+))?$/
+            if $1
+              excn = $1
+              if excn == 'off'
+                Debugger.catchpoint = nil
+                stdout.print "Clear catchpoint.\n"
+              else
+                Debugger.catchpoint = excn
+                stdout.printf "Set catchpoint %s.\n", excn
+              end
+            else
+              if Debugger.catchpoint
+                stdout.printf "Catchpoint %s.\n", Debugger.catchpoint
+              else
+                stdout.print "No catchpoint.\n"
+              end
+            end
+
+          when /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/
+            if defined?( $2 )
+              Debugger.tracing = $1 == 'on'
+            elsif defined?( $1 )
+              self.tracing = $1 == 'on'
+            end
+            if Debugger.tracing || self.tracing
+              stdout.print "Trace on.\n"
+            else
+              stdout.print "Trace off.\n"
+            end
+
+          else
+            v = debug_eval(input, binding)
+            stdout.printf "%s\n", v.inspect
+          end
+        end
       end
       MUTEX.unlock
       Debugger.resume
@@ -319,54 +334,55 @@ module Debugger
 
     def debug_print_help
       stdout.print <<EOHELP
-Debugger help v.-0.002b
+ruby-debug help v.#{Debugger::VERSION}
 Commands
-  b[reak] [file|class:]<line|method>
-  b[reak] [class.]<line|method>
-				 set breakpoint to some position
-  cat[ch] <an Exception>     set catchpoint to an exception
-  disp[lay] <expression>     add expression into display expression list
-  undisp[lay][ nnn]          delete one particular or all display expressions
-  b[reak]                    list breakpoints
-  cat[ch]                    show catchpoint
-  del[ete][ nnn]             delete some or all breakpoints
-  c[ont]                     run until program ends or hit breakpoint
-  s[tep][ nnn]               step (into methods) one line or till line nnn
-  n[ext][ nnn]               go over one line or till line nnn
-  w[here]                    display frames
-  f[rame]                    alias for where
-  l[ist][ (-|nn-mm)]         list program, - lists backwards
-				 nn-mm lists given lines
-  up[ nn]                    move to higher frame
-  down[ nn]                  move to lower frame
-  fin[ish]                   return to outer frame
-  q[uit]                     exit from debugger
-  v[ar] g[lobal]             show global variables
-  v[ar] l[ocal]              show local variables
-  v[ar] i[nstance] <object>  show instance variables of object
-  v[ar] c[onst] <object>     show constants of object
-  m[ethod] i[nstance] <obj>  show methods of object
-  m[ethod] <class|module>    show instance methods of class or module
-  th[read] l[ist]            list all threads
-  th[read] c[ur[rent]]       show current thread
-  th[read] [sw[itch]] <nnn>  switch thread context to nnn
-  th[read] stop <nnn>        stop thread nnn
-  th[read] resume <nnn>      resume thread nnn
-  p expression               evaluate expression and print its value
-  pp expression              evaluate expression and print its value
-  h[elp]                     print this help
-  <everything else>          evaluate
+b[reak] [file|class:]<line|method> [if expr]
+b[reak] [class.]<line|method> [if expr]
+                           set breakpoint to some position,
+                           optionally if expr == true
+cat[ch] <an Exception>     set catchpoint to an exception
+cat[ch]                    show catchpoint
+disp[lay] <expression>     add expression into display expression list
+undisp[lay][ nnn]          delete one particular or all display expressions
+b[reak]                    list breakpoints
+del[ete][ nnn]             delete some or all breakpoints
+c[ont]                     run until program ends or hit breakpoint
+r[un]                      alias for cont
+s[tep][ nnn]               step (into methods) one line or till line nnn
+n[ext][ nnn]               go over one line or till line nnn
+w[here]                    display frames
+f[rame]                    alias for where
+l[ist][ (-|nn-mm)]         list program, - list backwards, nn-mm list given lines
+up[ nn]                    move to higher frame
+down[ nn]                  move to lower frame
+fin[ish]                   return to outer frame
+q[uit]                     exit from debugger
+v[ar] g[lobal]             show global variables
+v[ar] l[ocal]              show local variables
+v[ar] i[nstance] <object>  show instance variables of object
+v[ar] c[onst] <object>     show constants of object
+m[ethod] i[nstance] <obj>  show methods of object
+m[ethod] <class|module>    show instance methods of class or module
+th[read] l[ist]            list all threads
+th[read] c[ur[rent]]       show current thread
+th[read] [sw[itch]] <nnn>  switch thread context to nnn
+th[read] stop <nnn>        stop thread nnn
+th[read] resume <nnn>      resume thread nnn
+p expression               evaluate expression and print its value
+pp expression              evaluate expression and print its value
+h[elp]                     print this help
+<everything else>          evaluate
 EOHELP
     end
 
     def display_expressions(binding)
       n = 1
       for d in display
-	if d[0]
-	  stdout.printf "%d: ", n
-	  display_expression(d[1], binding)
-	end
-	n += 1
+        if d[0]
+          stdout.printf "%d: ", n
+          display_expression(d[1], binding)
+        end
+        n += 1
       end
     end
 
@@ -376,96 +392,96 @@ EOHELP
 
     def debug_eval(str, binding)
       begin
-	val = eval(str, binding)
+        val = eval(str, binding)
       rescue StandardError, ScriptError => e
-	at = eval("caller(1)", binding)
-	stdout.printf "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
-	for i in at
-	  stdout.printf "\tfrom %s\n", i
-	end
-	throw :debug_error
+        at = eval("caller(1)", binding)
+        stdout.printf "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
+        for i in at
+          stdout.printf "\tfrom %s\n", i
+        end
+        throw :debug_error
       end
     end
 
     def debug_silent_eval(str, binding)
       begin
-	eval(str, binding)
+        eval(str, binding)
       rescue StandardError, ScriptError
-	nil
+        nil
       end
     end
 
     def debug_variable_info(input, binding)
       case input
       when /^\s*g(?:lobal)?\s*$/
-	var_list(global_variables, binding)
+        var_list(global_variables, binding)
 
       when /^\s*l(?:ocal)?\s*$/
-	var_list(eval("local_variables", binding), binding)
+        var_list(eval("local_variables", binding), binding)
 
       when /^\s*i(?:nstance)?\s+/
-	obj = debug_eval($', binding)
-	var_list(obj.instance_variables, obj.instance_eval{binding()})
+        obj = debug_eval($', binding)
+        var_list(obj.instance_variables, obj.instance_eval{binding()})
 
       when /^\s*c(?:onst(?:ant)?)?\s+/
-	obj = debug_eval($', binding)
-	unless obj.kind_of? Module
-	  stdout.print "Should be Class/Module: ", $', "\n"
-	else
-	  var_list(obj.constants, obj.module_eval{binding()})
-	end
+        obj = debug_eval($', binding)
+        unless obj.kind_of? Module
+          stdout.print "Should be Class/Module: ", $', "\n"
+        else
+          var_list(obj.constants, obj.module_eval{binding()})
+        end
       end
     end
 
     def display_frames(pos)
       self.frames.each_with_index do |frame, idx|
-	if idx == pos
-	  stdout.print "--> "
-	else
-	  stdout.print "    "
-	end
-	stdout.print format_frame(frame, idx)
+        if idx == pos
+          stdout.print "--> "
+        else
+          stdout.print "    "
+        end
+        stdout.print format_frame(frame, idx)
       end
     end
 
     def format_frame(frame, pos)
       bind, file, line, id = frame.binding, frame.file, frame.line, frame.id
       sprintf "#%d %s:%s%s\n", pos + 1, file, line,
-	(id ? ":in `#{id.id2name}'" : "")
+      (id ? ":in `#{id.id2name}'" : "")
     end
 
     def var_list(ary, binding)
       ary.sort!
       for v in ary
-	stdout.printf "  %s => %s\n", v, eval(v, binding).inspect
+        stdout.printf "  %s => %s\n", v, eval(v, binding).inspect
       end
     end
 
     def display_list(b, e, file, line)
       stdout.printf "[%d, %d] in %s\n", b, e, file
       if lines = SCRIPT_LINES__[file] and lines != true
-	n = 0
-	b.upto(e) do |n|
-	  if n > 0 && lines[n-1]
-	    if n == line
-	      stdout.printf "=> %d  %s\n", n, lines[n-1].chomp
-	    else
-	      stdout.printf "   %d  %s\n", n, lines[n-1].chomp
-	    end
-	  end
-	end
+        n = 0
+        b.upto(e) do |n|
+          if n > 0 && lines[n-1]
+            if n == line
+              stdout.printf "=> %d  %s\n", n, lines[n-1].chomp
+            else
+              stdout.printf "   %d  %s\n", n, lines[n-1].chomp
+            end
+          end
+        end
       else
-	stdout.printf "No sourcefile available for %s\n", file
+        stdout.printf "No sourcefile available for %s\n", file
       end
     end
 
     def line_at(file, line)
       lines = SCRIPT_LINES__[file]
       if lines
-	return "\n" if lines == true
-	line = lines[line-1]
-	return "\n" unless line
-	return line
+        return "\n" if lines == true
+        line = lines[line-1]
+        return "\n" unless line
+        return line.gsub(/^\s+/, '')
       end
       return "\n"
     end
@@ -499,56 +515,56 @@ EOHELP
     def debug_method_info(input, binding)
       case input
       when /^i(:?nstance)?\s+/
-	obj = debug_eval($', binding)
-
-	len = 0
-	for v in obj.methods.sort
-	  len += v.size + 1
-	  if len > 70
-	    len = v.size + 1
-	    stdout.print "\n"
-	  end
-	  stdout.print v, " "
-	end
-	stdout.print "\n"
+        obj = debug_eval($', binding)
+
+        len = 0
+        for v in obj.methods.sort
+          len += v.size + 1
+          if len > 70
+            len = v.size + 1
+            stdout.print "\n"
+          end
+          stdout.print v, " "
+        end
+        stdout.print "\n"
 
       else
-	obj = debug_eval(input, binding)
-	unless obj.kind_of? Module
-	  stdout.print "Should be Class/Module: ", input, "\n"
-	else
-	  len = 0
-	  for v in obj.instance_methods(false).sort
-	    len += v.size + 1
-	    if len > 70
-	      len = v.size + 1
-	      stdout.print "\n"
-	    end
-	    stdout.print v, " "
-	  end
-	  stdout.print "\n"
-	end
+        obj = debug_eval(input, binding)
+        unless obj.kind_of? Module
+          stdout.print "Should be Class/Module: ", input, "\n"
+        else
+          len = 0
+          for v in obj.instance_methods(false).sort
+            len += v.size + 1
+            if len > 70
+              len = v.size + 1
+              stdout.print "\n"
+            end
+            stdout.print v, " "
+          end
+          stdout.print "\n"
+        end
       end
     end
 
     def display_context(c)
       if c.thread == Thread.current
-	stdout.print "+"
+        stdout.print "+"
       else
-	stdout.print " "
+        stdout.print " "
       end
       stdout.printf "%d ", c.thnum
       stdout.print c.thread.inspect, "\t"
       last_frame = c.frames.first
       if last_frame
-	@stdout.print last_frame.file,":",last_frame.line
+        @stdout.print last_frame.file,":",last_frame.line
       end
       @stdout.print "\n"
     end
 
     def display_all_contexts
       threads = contexts.sort_by{|c| c.thnum}.each do |c|
-	display_context(c)
+        display_context(c)
       end
     end
 
@@ -559,43 +575,43 @@ EOHELP
     def debug_thread_info(input)
       case input
       when /^l(?:ist)?/
-	display_all_contexts
+        display_all_contexts
 
       when /^c(?:ur(?:rent)?)?$/
-	display_context(current_context)
+        display_context(current_context)
 
       when /^(?:sw(?:itch)?\s+)?(\d+)/
-	c = get_context($1.to_i)
-	if c == current_context
-	  stdout.print "It's the current thread.\n"
-	else
-	  display_context(c)
-	  c.stop_next = 1
-	  c.thread.run
-	  return :cont
-	end
+        c = get_context($1.to_i)
+        if c == current_context
+          stdout.print "It's the current thread.\n"
+        else
+          display_context(c)
+          c.stop_next = 1
+          c.thread.run
+          return :cont
+        end
 
       when /^stop\s+(\d+)/
-	c = get_context($1.to_i)
-	if c == current_context
-	  stdout.print "It's the current thread.\n"
-	elsif c.thread.stop?
-	  stdout.print "Already stopped.\n"
-	else
-	  display_context(c)
-	  c.set_suspend
-	end
+        c = get_context($1.to_i)
+        if c == current_context
+          stdout.print "It's the current thread.\n"
+        elsif c.thread.stop?
+          stdout.print "Already stopped.\n"
+        else
+          display_context(c)
+          c.set_suspend
+        end
 
       when /^resume\s+(\d+)/
-	c = get_context($1.to_i)
-	if c == current_context
-	  stdout.print "It's the current thread.\n"
-	elsif !c.thread.stop?
-	  stdout.print "Already running."
-	else
-	  display_context(c)
-	  c.thread.run
-	end
+        c = get_context($1.to_i)
+        if c == current_context
+          stdout.print "It's the current thread.\n"
+        elsif !c.thread.stop?
+          stdout.print "Already running."
+        else
+          display_context(c)
+          c.thread.run
+        end
       end
     end
   end