lldb 0.2.0 → 0.3.0

data/lib/lldb/target.rb

@@ -4,19 +4,24 @@
 
 module LLDB
   class Target
+    prepend NativeLifecycle
+
     # @rbs return: Debugger
     attr_reader :debugger
 
     # @rbs ptr: FFI::Pointer
     # @rbs debugger: Debugger
     # @rbs return: void
-    def initialize(ptr, debugger:)
-      @ptr = ptr # : FFI::Pointer
+    def initialize(ptr, debugger:, context: debugger.context)
       @debugger = debugger
       @breakpoints = [] # : Array[Breakpoint]
       @watchpoints = [] # : Array[Watchpoint]
       @process = nil # : Process?
-      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_target_destroy(released) },
+        context: context
+      )
     end
 
     # @rbs ptr: FFI::Pointer
@@ -33,38 +38,16 @@ module LLDB
     # @rbs args: Array[String]?
     # @rbs env: Hash[String, String]?
     # @rbs working_dir: String?
+    # @rbs launch_flags: Integer?
     # @rbs return: Process
-    def launch(args: nil, env: nil, working_dir: nil)
+    def launch(args: nil, env: nil, working_dir: nil, launch_flags: nil)
       raise InvalidObjectError, 'Target is not valid' unless valid?
 
-      # Use LaunchInfo with STOP_AT_ENTRY flag for reliable cross-platform behavior
-      launch_info = LaunchInfo.new(args)
-      launch_info.launch_flags = LaunchFlags::STOP_AT_ENTRY
+      launch_info = LaunchInfo.new(args, context: context)
+      launch_info.launch_flags = launch_flags unless launch_flags.nil?
       launch_info.working_directory = working_dir if working_dir
       launch_info.set_environment(env) if env
-
-      error = Error.new
-      process_ptr = FFIBindings.lldb_target_launch(@ptr, launch_info.to_ptr, error.to_ptr)
-
-      error.raise_if_error!
-      raise LaunchError, 'Failed to launch process' if process_ptr.nil? || process_ptr.null?
-
-      @process = Process.new(process_ptr, target: self)
-
-      # Wait for process to stop when in synchronous mode
-      # On some platforms (Linux), the process may not be immediately stopped
-      unless @debugger.async?
-        wait_for_process_stop(@process)
-
-        # STOP_AT_ENTRY stops at the program entry point, not at breakpoints.
-        # If there are breakpoints set, continue to let the process run to the first breakpoint.
-        if num_breakpoints > 0 && @process.state == State::STOPPED && @process.valid?
-          @process.continue
-          wait_for_process_stop(@process)
-        end
-      end
-
-      @process
+      launch_with_info(launch_info)
     end
 
     # @rbs launch_info: LaunchInfo
@@ -76,10 +59,10 @@ module LLDB
       error = Error.new
       process_ptr = FFIBindings.lldb_target_launch(@ptr, launch_info.to_ptr, error.to_ptr)
 
-      error.raise_if_error!
+      error.raise_if_error!('target.launch')
       raise LaunchError, 'Failed to launch process' if process_ptr.nil? || process_ptr.null?
 
-      @process = Process.new(process_ptr, target: self)
+      @process = Process.new(process_ptr, target: self, context: context)
     end
 
     # @rbs pid: Integer
@@ -93,7 +76,22 @@ module LLDB
       error.raise_if_error!
       raise AttachError, "Failed to attach to process #{pid}" if process_ptr.nil? || process_ptr.null?
 
-      @process = Process.new(process_ptr, target: self)
+      @process = Process.new(process_ptr, target: self, context: context)
+    end
+
+    # @rbs attach_info: AttachInfo
+    # @rbs return: Process
+    def attach_with_info(attach_info)
+      raise InvalidObjectError, 'Target is not valid' unless valid?
+      raise ArgumentError, 'attach_info is required' unless attach_info.is_a?(AttachInfo)
+
+      error = Error.new
+      process_ptr = FFIBindings.lldb_target_attach_with_info(@ptr, attach_info.to_ptr, error.to_ptr)
+
+      error.raise_if_error!('target.attach')
+      raise AttachError, 'Failed to attach using attach info' if process_ptr.nil? || process_ptr.null?
+
+      @process = Process.new(process_ptr, target: self, context: context)
     end
 
     # @rbs symbol_name: String
@@ -105,7 +103,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_name(@ptr, symbol_name, module_name)
       raise BreakpointError, "Failed to create breakpoint for '#{symbol_name}'" if bp_ptr.nil? || bp_ptr.null?
 
-      bp = Breakpoint.new(bp_ptr, target: self)
+      bp = Breakpoint.new(bp_ptr, target: self, context: context)
       @breakpoints << bp
       bp
     end
@@ -119,7 +117,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_location(@ptr, file, line)
       raise BreakpointError, "Failed to create breakpoint at #{file}:#{line}" if bp_ptr.nil? || bp_ptr.null?
 
-      bp = Breakpoint.new(bp_ptr, target: self)
+      bp = Breakpoint.new(bp_ptr, target: self, context: context)
       @breakpoints << bp
       bp
     end
@@ -137,7 +135,7 @@ module LLDB
               "Failed to create breakpoint at address 0x#{address.to_s(16)}"
       end
 
-      bp = Breakpoint.new(bp_ptr, target: self)
+      bp = Breakpoint.new(bp_ptr, target: self, context: context)
       @breakpoints << bp
       bp
     end
@@ -160,7 +158,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_find_breakpoint_by_id(@ptr, id)
       return nil if bp_ptr.nil? || bp_ptr.null?
 
-      Breakpoint.new(bp_ptr, target: self)
+      Breakpoint.new(bp_ptr, target: self, context: context)
     end
 
     # @rbs return: Integer
@@ -178,7 +176,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_get_breakpoint_at_index(@ptr, index)
       return nil if bp_ptr.nil? || bp_ptr.null?
 
-      Breakpoint.new(bp_ptr, target: self)
+      Breakpoint.new(bp_ptr, target: self, context: context)
     end
 
     # @rbs return: Array[Breakpoint]
@@ -193,14 +191,24 @@ module LLDB
       process_ptr = FFIBindings.lldb_target_get_process(@ptr)
       return nil if process_ptr.nil? || process_ptr.null?
 
-      Process.new(process_ptr, target: self)
+      Process.new(process_ptr, target: self, context: context)
     end
 
     # @rbs return: String?
     def executable_path
       raise InvalidObjectError, 'Target is not valid' unless valid?
 
-      FFIBindings.lldb_target_get_executable_path(@ptr)
+      executable_file&.path
+    end
+
+    # @rbs return: FileSpec?
+    def executable_file
+      raise InvalidObjectError, 'Target is not valid' unless valid?
+
+      file_ptr = FFIBindings.lldb_target_get_executable_file(@ptr)
+      return nil if file_ptr.nil? || file_ptr.null?
+
+      FileSpec.from_ptr(file_ptr, context: context)
     end
 
     # @rbs return: Integer
@@ -218,7 +226,7 @@ module LLDB
       mod_ptr = FFIBindings.lldb_target_get_module_at_index(@ptr, index)
       return nil if mod_ptr.nil? || mod_ptr.null?
 
-      Module.new(mod_ptr, target: self)
+      Module.new(mod_ptr, target: self, context: context)
     end
 
     # @rbs return: Array[Module]
@@ -238,7 +246,7 @@ module LLDB
       error.raise_if_error!
       raise AttachError, "Failed to attach to process '#{name}'" if process_ptr.nil? || process_ptr.null?
 
-      @process = Process.new(process_ptr, target: self)
+      @process = Process.new(process_ptr, target: self, context: context)
     end
 
     # @rbs regex: String
@@ -252,7 +260,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_regex(@ptr, regex, module_name)
       raise BreakpointError, "Failed to create breakpoint for regex '#{regex}'" if bp_ptr.nil? || bp_ptr.null?
 
-      bp = Breakpoint.new(bp_ptr, target: self)
+      bp = Breakpoint.new(bp_ptr, target: self, context: context)
       @breakpoints << bp
       bp
     end
@@ -266,7 +274,7 @@ module LLDB
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_source_regex(@ptr, regex, source_file)
       raise BreakpointError, "Failed to create breakpoint for source regex '#{regex}'" if bp_ptr.nil? || bp_ptr.null?
 
-      bp = Breakpoint.new(bp_ptr, target: self)
+      bp = Breakpoint.new(bp_ptr, target: self, context: context)
       @breakpoints << bp
       bp
     end
@@ -295,14 +303,25 @@ module LLDB
     end
 
     # @rbs expression: String
+    # @rbs options: ExpressionOptions?
     # @rbs return: Value?
-    def evaluate_expression(expression)
+    def evaluate_expression(expression, options: nil)
       raise InvalidObjectError, 'Target is not valid' unless valid?
 
-      value_ptr = FFIBindings.lldb_target_evaluate_expression(@ptr, expression)
+      value_ptr = if options
+                    unless options.is_a?(ExpressionOptions)
+                      raise ArgumentError, 'options must be an ExpressionOptions'
+                    end
+
+                    FFIBindings.lldb_target_evaluate_expression_with_options(
+                      @ptr, expression, options.to_ptr
+                    )
+                  else
+                    FFIBindings.lldb_target_evaluate_expression(@ptr, expression)
+                  end
       return nil if value_ptr.nil? || value_ptr.null?
 
-      Value.new(value_ptr, parent: self)
+      Value.new(value_ptr, parent: self, context: context)
     end
 
     # @rbs address: Integer
@@ -347,7 +366,7 @@ module LLDB
       error.raise_if_error!
       raise LLDBError, "Failed to create watchpoint at address 0x#{address.to_s(16)}" if wp_ptr.nil? || wp_ptr.null?
 
-      wp = Watchpoint.new(wp_ptr, target: self)
+      wp = Watchpoint.new(wp_ptr, target: self, context: context)
       @watchpoints << wp
       wp
     end
@@ -379,7 +398,7 @@ module LLDB
       wp_ptr = FFIBindings.lldb_target_find_watchpoint_by_id(@ptr, id)
       return nil if wp_ptr.nil? || wp_ptr.null?
 
-      Watchpoint.new(wp_ptr, target: self)
+      Watchpoint.new(wp_ptr, target: self, context: context)
     end
 
     # @rbs return: Integer
@@ -397,7 +416,7 @@ module LLDB
       wp_ptr = FFIBindings.lldb_target_get_watchpoint_at_index(@ptr, index)
       return nil if wp_ptr.nil? || wp_ptr.null?
 
-      Watchpoint.new(wp_ptr, target: self)
+      Watchpoint.new(wp_ptr, target: self, context: context)
     end
 
     # @rbs return: Array[Watchpoint]
@@ -410,22 +429,5 @@ module LLDB
       @ptr
     end
 
-    private
-
-    # @rbs process: Process
-    # @rbs timeout: Float
-    # @rbs return: void
-    def wait_for_process_stop(process, timeout: 10.0)
-      require 'timeout'
-
-      Timeout.timeout(timeout, LaunchError, "Process failed to stop within #{timeout} seconds") do
-        loop do
-          state = process.state
-          break if state == State::STOPPED || state == State::EXITED || state == State::CRASHED
-
-          sleep(0.01)
-        end
-      end
-    end
   end
 end

data/lib/lldb/thread.rb

@@ -4,16 +4,21 @@
 
 module LLDB
   class Thread
+    prepend NativeLifecycle
+
     # @rbs return: Process
     attr_reader :process
 
     # @rbs ptr: FFI::Pointer
     # @rbs process: Process
     # @rbs return: void
-    def initialize(ptr, process:)
-      @ptr = ptr # : FFI::Pointer
+    def initialize(ptr, process:, context: process.context)
       @process = process
-      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_thread_destroy(released) },
+        context: context
+      )
     end
 
     # @rbs ptr: FFI::Pointer
@@ -27,37 +32,59 @@ module LLDB
       !@ptr.null? && FFIBindings.lldb_thread_is_valid(@ptr) != 0
     end
 
-    # @rbs return: bool
-    def step_over
+    # @rbs run_mode: Integer
+    # @rbs return: true
+    def step_over(run_mode: RunMode::ONLY_DURING_STEPPING)
       raise InvalidObjectError, 'Thread is not valid' unless valid?
       APISupport.require_method!(:lldb_thread_step_over, 'step_over')
 
-      FFIBindings.lldb_thread_step_over(@ptr) != 0
+      error = Error.new
+      status = FFIBindings.lldb_thread_step_over(@ptr, run_mode, error.to_ptr)
+      Native.check_status!(status, 'thread.step_over', error)
+      true
     end
 
-    # @rbs return: bool
-    def step_into
+    # @rbs target_name: String?
+    # @rbs end_line: Integer
+    # @rbs run_mode: Integer
+    # @rbs return: true
+    def step_into(target_name: nil, end_line: INVALID_LINE_NUMBER, run_mode: RunMode::ONLY_DURING_STEPPING)
       raise InvalidObjectError, 'Thread is not valid' unless valid?
       APISupport.require_method!(:lldb_thread_step_into, 'step_into')
 
-      FFIBindings.lldb_thread_step_into(@ptr) != 0
+      error = Error.new
+      status = FFIBindings.lldb_thread_step_into(
+        @ptr,
+        target_name,
+        end_line,
+        run_mode,
+        error.to_ptr
+      )
+      Native.check_status!(status, 'thread.step_into', error)
+      true
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def step_out
       raise InvalidObjectError, 'Thread is not valid' unless valid?
       APISupport.require_method!(:lldb_thread_step_out, 'step_out')
 
-      FFIBindings.lldb_thread_step_out(@ptr) != 0
+      error = Error.new
+      status = FFIBindings.lldb_thread_step_out(@ptr, error.to_ptr)
+      Native.check_status!(status, 'thread.step_out', error)
+      true
     end
 
     # @rbs step_over: bool
-    # @rbs return: bool
+    # @rbs return: true
     def step_instruction(step_over: false)
       raise InvalidObjectError, 'Thread is not valid' unless valid?
       APISupport.require_method!(:lldb_thread_step_instruction, 'step_instruction')
 
-      FFIBindings.lldb_thread_step_instruction(@ptr, step_over ? 1 : 0) != 0
+      error = Error.new
+      status = FFIBindings.lldb_thread_step_instruction(@ptr, step_over ? 1 : 0, error.to_ptr)
+      Native.check_status!(status, 'thread.step_instruction', error)
+      true
     end
 
     # @rbs return: Integer
@@ -75,7 +102,7 @@ module LLDB
       frame_ptr = FFIBindings.lldb_thread_get_frame_at_index(@ptr, index)
       return nil if frame_ptr.nil? || frame_ptr.null?
 
-      Frame.new(frame_ptr, thread: self)
+      Frame.new(frame_ptr, thread: self, context: context)
     end
 
     # @rbs return: Frame?
@@ -85,7 +112,7 @@ module LLDB
       frame_ptr = FFIBindings.lldb_thread_get_selected_frame(@ptr)
       return nil if frame_ptr.nil? || frame_ptr.null?
 
-      Frame.new(frame_ptr, thread: self)
+      Frame.new(frame_ptr, thread: self, context: context)
     end
 
     # @rbs index: Integer
@@ -159,7 +186,10 @@ module LLDB
     def run_to_address(address)
       raise InvalidObjectError, 'Thread is not valid' unless valid?
 
-      FFIBindings.lldb_thread_run_to_address(@ptr, address) != 0
+      error = Error.new
+      status = FFIBindings.lldb_thread_run_to_address(@ptr, address, error.to_ptr)
+      Native.check_status!(status, 'thread.run_to_address', error)
+      true
     end
 
     # @rbs return: Integer
@@ -180,8 +210,11 @@ module LLDB
     # @rbs return: String?
     def stop_description(max_size = 256)
       return nil unless valid?
+      return '' if max_size.zero?
 
-      FFIBindings.lldb_thread_get_stop_description(@ptr, max_size)
+      NativeBuffer.read_c_string(max_size: max_size) do |buffer, length|
+        FFIBindings.lldb_thread_get_stop_description(@ptr, buffer, length)
+      end
     end
 
     # @rbs return: bool
@@ -219,7 +252,7 @@ module LLDB
       process_ptr = FFIBindings.lldb_thread_get_process(@ptr)
       return nil if process_ptr.nil? || process_ptr.null?
 
-      Process.new(process_ptr, target: @process.target)
+      Process.new(process_ptr, target: @process.target, context: context)
     end
 
     # @rbs return: FFI::Pointer

data/lib/lldb/type.rb

@@ -4,11 +4,16 @@
 
 module LLDB
   class Type
+    prepend NativeLifecycle
+
     # @rbs ptr: FFI::Pointer
     # @rbs return: void
-    def initialize(ptr)
-      @ptr = ptr # : FFI::Pointer
-      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+    def initialize(ptr, context: nil)
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_type_destroy(released) },
+        context: context
+      )
     end
 
     # @rbs ptr: FFI::Pointer
@@ -190,6 +195,24 @@ module LLDB
       FFIBindings.lldb_type_get_num_virtual_base_classes(@ptr)
     end
 
+    # @rbs index: Integer
+    # @rbs return: TypeMember?
+    def field_at_index(index)
+      member_at(index, :lldb_type_get_field_at_index)
+    end
+
+    # @rbs index: Integer
+    # @rbs return: TypeMember?
+    def direct_base_class_at_index(index)
+      member_at(index, :lldb_type_get_direct_base_class_at_index)
+    end
+
+    # @rbs index: Integer
+    # @rbs return: TypeMember?
+    def virtual_base_class_at_index(index)
+      member_at(index, :lldb_type_get_virtual_base_class_at_index)
+    end
+
     # @rbs return: Integer
     def basic_type
       return BasicType::INVALID unless valid?
@@ -211,5 +234,19 @@ module LLDB
     def to_ptr
       @ptr
     end
+
+    private
+
+    # @rbs index: Integer
+    # @rbs method_name: ::Symbol
+    # @rbs return: TypeMember?
+    def member_at(index, method_name)
+      raise InvalidObjectError, 'Type is not valid' unless valid?
+
+      member_ptr = FFIBindings.public_send(method_name, @ptr, index)
+      return nil if member_ptr.nil? || member_ptr.null?
+
+      TypeMember.new(member_ptr, context: context)
+    end
   end
 end

data/lib/lldb/type_member.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  class TypeMember
+    prepend NativeLifecycle
+
+    # @rbs context: Context?
+    # @rbs return: void
+    def initialize(ptr, context: nil)
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_type_member_destroy(released) },
+        context: context
+      )
+    end
+
+    # @rbs return: bool
+    def valid?
+      !@ptr.null? && FFIBindings.lldb_type_member_is_valid(@ptr) != 0
+    end
+
+    # @rbs return: String?
+    def name
+      return nil unless valid?
+
+      FFIBindings.lldb_type_member_get_name(@ptr)
+    end
+
+    # @rbs return: Type?
+    def type
+      return nil unless valid?
+
+      ptr = FFIBindings.lldb_type_member_get_type(@ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      Type.new(ptr, context: context)
+    end
+
+    # @rbs return: Integer
+    def offset_in_bytes
+      return 0 unless valid?
+
+      FFIBindings.lldb_type_member_get_offset_in_bytes(@ptr)
+    end
+
+    # @rbs return: Integer
+    def offset_in_bits
+      return 0 unless valid?
+
+      FFIBindings.lldb_type_member_get_offset_in_bits(@ptr)
+    end
+
+    # @rbs return: Integer
+    def bitfield_size_in_bits
+      return 0 unless valid?
+
+      FFIBindings.lldb_type_member_get_bitfield_size_in_bits(@ptr)
+    end
+
+    # @rbs return: FFI::Pointer
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/lldb/types.rb

@@ -3,6 +3,21 @@
 # rbs_inline: enabled
 
 module LLDB
+  INVALID_ADDRESS = (1 << 64) - 1 # : Integer
+  INVALID_PROCESS_ID = 0 # : Integer
+  INVALID_THREAD_ID = 0 # : Integer
+  INVALID_BREAK_ID = 0 # : Integer
+  INVALID_LINE_NUMBER = 0xFFFFFFFF # : Integer
+
+  module NativeStatus
+    OK = 0 # : Integer
+    INVALID_ARGUMENT = 1 # : Integer
+    INVALID_HANDLE = 2 # : Integer
+    UNSUPPORTED = 3 # : Integer
+    LLDB_ERROR = 4 # : Integer
+    INTERNAL_ERROR = 5 # : Integer
+  end
+
   module State
     INVALID = 0 # : Integer
     UNLOADED = 1 # : Integer
@@ -51,6 +66,10 @@ module LLDB
     PLAN_COMPLETE = 8 # : Integer
     THREAD_EXITING = 9 # : Integer
     INSTRUMENTATION = 10 # : Integer
+    PROCESSOR_TRACE = 11 # : Integer
+    FORK = 12 # : Integer
+    VFORK = 13 # : Integer
+    VFORK_DONE = 14 # : Integer
 
     NAMES = { # : Hash[Integer, String]
       INVALID => 'invalid',
@@ -63,7 +82,11 @@ module LLDB
       EXEC => 'exec',
       PLAN_COMPLETE => 'plan complete',
       THREAD_EXITING => 'thread exiting',
-      INSTRUMENTATION => 'instrumentation'
+      INSTRUMENTATION => 'instrumentation',
+      PROCESSOR_TRACE => 'processor trace',
+      FORK => 'fork',
+      VFORK => 'vfork',
+      VFORK_DONE => 'vfork done'
     }.freeze
 
     # @rbs reason: Integer
@@ -81,7 +104,8 @@ module LLDB
     BLOCK = 1 << 4 # : Integer
     LINE_ENTRY = 1 << 5 # : Integer
     SYMBOL = 1 << 6 # : Integer
-    EVERYTHING = 0xFFFF # : Integer
+    VARIABLE = 1 << 7 # : Integer
+    EVERYTHING = 0x7F # : Integer
   end
 
   module ValueType
@@ -93,6 +117,7 @@ module LLDB
     REGISTER = 5 # : Integer
     REGISTER_SET = 6 # : Integer
     CONSTANT_RESULT = 7 # : Integer
+    VARIABLE_THREAD_LOCAL = 8 # : Integer
 
     NAMES = { # : Hash[Integer, String]
       INVALID => 'invalid',
@@ -102,7 +127,8 @@ module LLDB
       VARIABLE_LOCAL => 'local',
       REGISTER => 'register',
       REGISTER_SET => 'register set',
-      CONSTANT_RESULT => 'constant result'
+      CONSTANT_RESULT => 'constant result',
+      VARIABLE_THREAD_LOCAL => 'thread local'
     }.freeze
 
     # @rbs value_type: Integer
@@ -145,6 +171,9 @@ module LLDB
     OBJ_C_CLASS = 29 # : Integer
     OBJ_C_SEL = 30 # : Integer
     NULL_PTR = 31 # : Integer
+    # LLDB inserted eBasicTypeChar8 before SHORT in newer releases. The
+    # wrapper normalizes it to this value so the public Ruby enum is stable.
+    CHAR8 = 32 # : Integer
 
     NAMES = { # : Hash[Integer, String]
       INVALID => 'invalid',
@@ -178,7 +207,8 @@ module LLDB
       OBJ_C_ID => 'id',
       OBJ_C_CLASS => 'Class',
       OBJ_C_SEL => 'SEL',
-      NULL_PTR => 'nullptr_t'
+      NULL_PTR => 'nullptr_t',
+      CHAR8 => 'char8_t'
     }.freeze
 
     # @rbs basic_type: Integer
@@ -187,4 +217,39 @@ module LLDB
       NAMES[basic_type] || 'unknown'
     end
   end
+
+  module ErrorType
+    INVALID = 0 # : Integer
+    GENERIC = 1 # : Integer
+    MACH_KERNEL = 2 # : Integer
+    POSIX = 3 # : Integer
+    EXPRESSION = 4 # : Integer
+    WIN32 = 5 # : Integer
+
+    NAMES = { # : Hash[Integer, String]
+      INVALID => 'invalid',
+      GENERIC => 'generic',
+      MACH_KERNEL => 'mach kernel',
+      POSIX => 'POSIX',
+      EXPRESSION => 'expression',
+      WIN32 => 'Win32'
+    }.freeze
+  end
+
+  module ReturnStatus
+    INVALID = 0 # : Integer
+    SUCCESS_FINISH_NO_RESULT = 1 # : Integer
+    SUCCESS_FINISH_RESULT = 2 # : Integer
+    SUCCESS_CONTINUING_NO_RESULT = 3 # : Integer
+    SUCCESS_CONTINUING_RESULT = 4 # : Integer
+    STARTED = 5 # : Integer
+    FAILED = 6 # : Integer
+    QUIT = 7 # : Integer
+  end
+
+  module RunMode
+    ONLY_THIS_THREAD = 0 # : Integer
+    ALL_THREADS = 1 # : Integer
+    ONLY_DURING_STEPPING = 2 # : Integer
+  end
 end