fix of throwing exceptions in exec_with_allocation_control

Author: viuginick1

lib/ruby-debug-ide/xml_printer.rb

@@ -15,20 +15,24 @@ module OverflowMessageType
 
   class MemoryLimitError < StandardError
     attr_reader :message
+    attr_reader :trace_point
     attr_reader :backtrace
 
-    def initialize(message, backtrace = [])
+    def initialize(message, trace_point, backtrace = [])
       @message = message
+      @trace_point = trace_point
       @backtrace = backtrace
     end
   end
 
   class TimeLimitError < StandardError
     attr_reader :message
+    attr_reader :trace_point
     attr_reader :backtrace
 
-    def initialize(message, backtrace = [])
+    def initialize(message, trace_point, backtrace = [])
       @message = message
+      @trace_point = trace_point
       @backtrace = backtrace
     end
   end
@@ -168,47 +172,45 @@ def print_string(string)
     end
 
     def exec_with_allocation_control(value, memory_limit, time_limit, exec_method, overflow_message_type)
-      check_memory_limit = true
-      if (defined?(JRUBY_VERSION) || ENV['DEBUGGER_MEMORY_LIMIT'].to_i <= 0)
-        check_memory_limit = false
-      end
+      check_memory_limit = !defined?(JRUBY_VERSION) && ENV['DEBUGGER_MEMORY_LIMIT'].to_i > 0
       curr_thread = Thread.current
-      result = nil
-      inspect_thread = DebugThread.start {
 
+      result = nil
+      inspect_thread = DebugThread.start do
         start_alloc_size = ObjectSpace.memsize_of_all if (check_memory_limit)
         start_time = Time.now.to_f
 
-        trace = TracePoint.new(:c_call, :call) do |tp|
+        trace_point = TracePoint.new(:c_call, :call) do | |
+          next unless Thread.current == inspect_thread
+          next unless rand > 0.75
 
-          if (rand > 0.75)
-            curr_time = Time.now.to_f
+          curr_time = Time.now.to_f
 
-            if ((curr_time - start_time) * 1e3 > time_limit)
-              curr_thread.raise TimeLimitError.new("Timeout: evaluation of #{exec_method} took longer than #{time_limit}ms.", caller.to_a)
-              inspect_thread.kill
-            end
+          if (curr_time - start_time) * 1e3 > time_limit
+            curr_thread.raise TimeLimitError.new("Timeout: evaluation of #{exec_method} took longer than #{time_limit}ms.", caller.to_a, trace_point)
+          end
 
-            if (check_memory_limit)
-              curr_alloc_size = ObjectSpace.memsize_of_all
-              start_alloc_size = curr_alloc_size if (curr_alloc_size < start_alloc_size)
+          if check_memory_limit
+            curr_alloc_size = ObjectSpace.memsize_of_all
+            start_alloc_size = curr_alloc_size if (curr_alloc_size < start_alloc_size)
 
-              if (curr_alloc_size - start_alloc_size > 1e6 * memory_limit)
-                curr_thread.raise MemoryLimitError.new("Out of memory: evaluation of #{exec_method} took more than #{memory_limit}mb.", caller.to_a)
-                inspect_thread.kill
-              end
+            if curr_alloc_size - start_alloc_size > 1e6 * memory_limit
+              curr_thread.raise MemoryLimitError.new("Out of memory: evaluation of #{exec_method} took more than #{memory_limit}mb.", caller.to_a, trace_point)
             end
           end
-        end.enable {
-          result = value.send exec_method
-        }
-      }
+        end
+        trace_point.enable
+        result = value.send exec_method
+        trace_point.disable
+      end
       inspect_thread.join
-      inspect_thread.kill
       return result
     rescue MemoryLimitError, TimeLimitError => e
-      print_debug(e.message + "\n" + e.backtrace.map{|l| "\t#{l}"}.join("\n"))
+      e.trace_point.disable
+      print_debug(e.message + "\n" + e.backtrace.map {|l| "\t#{l}"}.join("\n"))
       return overflow_message_type.call(e)
+    ensure
+      inspect_thread.kill if inspect_thread && inspect_thread.alive?
     end
 
     def print_variable(name, value, kind)
@@ -512,4 +514,4 @@ def build_value_attr(escaped_value_str)
 
   end
 
-end
+end