toolbox 0.2.0 → 0.3.0

data/data/toolbox/debugger/__init__.py

@@ -70,6 +70,7 @@ read_cstring = _backend.read_cstring
 create_value = _backend.create_value
 create_value_from_int = _backend.create_value_from_int
 create_value_from_address = _backend.create_value_from_address
+register = _backend.register
 
 # Constants
 COMMAND_DATA = _backend.COMMAND_DATA
@@ -94,6 +95,7 @@ __all__ = [
 	'create_value',
 	'create_value_from_int',
 	'create_value_from_address',
+	'register',
 	'COMMAND_DATA',
 	'COMMAND_USER',
 ]

data/data/toolbox/debugger/gdb_backend.py

@@ -3,6 +3,7 @@ GDB backend implementation for unified debugger interface.
 """
 
 import gdb
+import format
 
 # Command categories
 COMMAND_DATA = gdb.COMMAND_DATA
@@ -311,7 +312,7 @@ class Command:
 		"""Initialize and register a command.
 		
 		Args:
-			name: Command name (e.g., "rb-object-print")
+			name: Command name (e.g., "rb-print")
 			category: Command category (COMMAND_DATA or COMMAND_USER)
 		"""
 		self.name = name
@@ -589,6 +590,74 @@ def create_value_from_address(address, value_type):
 	return Value(addr_val.dereference())
 
 
+def register(name, handler_class, usage=None, category=COMMAND_USER):
+	"""Register a command with GDB using a handler class.
+	
+	This creates a wrapper Command that handles parsing, terminal setup,
+	and delegates to the handler class for actual command logic.
+	
+	Args:
+		name: Command name (e.g., "rb-print")
+		handler_class: Class to instantiate for handling the command
+		usage: Optional command.Usage specification for validation/help
+		category: Command category (COMMAND_USER, etc.)
+	
+	Example:
+		class PrintHandler:
+			def invoke(self, arguments, terminal):
+				depth = arguments.get_option('depth', 1)
+				print(f"Depth: {depth}")
+		
+		usage = command.Usage(
+			summary="Print something",
+			options={'depth': (int, 1)},
+			flags=['debug']
+		)
+		debugger.register("my-print", PrintHandler, usage=usage)
+	
+	Returns:
+		The registered Command instance
+	"""
+	class RegisteredCommand(Command):
+		def __init__(self):
+			super(RegisteredCommand, self).__init__(name, category)
+			self.usage_spec = usage
+			self.handler_class = handler_class
+		
+		def invoke(self, arg, from_tty):
+			"""GDB entry point - parses arguments and delegates to handler."""
+			# Create terminal first (needed for help text)
+			import format
+			terminal = format.create_terminal(from_tty)
+			
+			try:
+				# Parse and validate arguments
+				if self.usage_spec:
+					arguments = self.usage_spec.parse(arg if arg else "")
+				else:
+					# Fallback to basic parsing without validation
+					import command
+					arguments = command.parse_arguments(arg if arg else "")
+				
+				# Instantiate handler and invoke
+				handler = self.handler_class()
+				handler.invoke(arguments, terminal)
+				
+			except ValueError as e:
+				# Validation error - show colored help
+				print(f"Error: {e}")
+				if self.usage_spec:
+					print()
+					self.usage_spec.print_to(terminal, name)
+			except Exception as e:
+				print(f"Error: {e}")
+				import traceback
+				traceback.print_exc()
+	
+	# Instantiate and register the command with GDB
+	return RegisteredCommand()
+
+
 
 
 

data/data/toolbox/debugger/lldb_backend.py

@@ -6,6 +6,7 @@ would require more extensive testing and edge case handling.
 """
 
 import lldb
+import format
 
 # Command categories (LLDB doesn't have exact equivalents, using symbolic constants)
 COMMAND_DATA = 0
@@ -427,7 +428,7 @@ class Command:
 		"""Initialize and register a command.
 		
 		Args:
-			name: Command name (e.g., "rb-object-print")
+			name: Command name (e.g., "rb-print")
 			category: Command category (not used in LLDB)
 		"""
 		self.name = name
@@ -515,10 +516,13 @@ def lookup_type(type_name):
 	
 	Returns:
 		Type object
+	
+	Raises:
+		Error: If type cannot be found in debug symbols
 	"""
 	target = lldb.debugger.GetSelectedTarget()
 	
-	# LLDB's FindFirstType searches the type system
+	# LLDB's FindFirstType searches loaded debug symbols
 	lldb_type = target.FindFirstType(type_name)
 	
 	if not lldb_type.IsValid():
@@ -534,8 +538,8 @@ def set_convenience_variable(name, value):
 		name: Variable name (without $ prefix)
 		value: Value to set (can be Value wrapper or native value)
 	
-	Note: LLDB doesn't have direct convenience variables like GDB.
-	This implementation uses expression evaluation to set variables.
+	Note: LLDB convenience variables are created using expression evaluation.
+	The variable name will be prefixed with $ automatically.
 	"""
 	if isinstance(value, Value):
 		native_value = value._value
@@ -545,16 +549,45 @@ def set_convenience_variable(name, value):
 	# LLDB approach: use expression to create a persistent variable
 	# Variables in LLDB are prefixed with $
 	target = lldb.debugger.GetSelectedTarget()
-	frame = target.GetProcess().GetSelectedThread().GetSelectedFrame()
+	if not target:
+		return
+	
+	process = target.GetProcess()
+	if not process:
+		return
+	
+	thread = process.GetSelectedThread()
+	if not thread:
+		return
+	
+	frame = thread.GetSelectedFrame()
+	if not frame:
+		return
 	
-	# Create a persistent variable by evaluating an expression
+	# Create a persistent variable by evaluating an assignment expression
 	if hasattr(native_value, 'GetValue'):
 		# It's an SBValue
 		addr = native_value.GetValueAsUnsigned()
 		type_name = native_value.GetType().GetName()
-		frame.EvaluateExpression(f"({type_name})0x{addr:x}", lldb.SBExpressionOptions())
-	# For now, simplified implementation
-	# Full implementation would require more complex value handling
+		
+		# Use expr command to create persistent variable
+		# Format: expr <type> $varname = (<type>)address
+		expr = f"{type_name} ${name} = ({type_name})0x{addr:x}"
+		
+		options = lldb.SBExpressionOptions()
+		options.SetIgnoreBreakpoints(True)
+		options.SetFetchDynamicValue(lldb.eNoDynamicValues)
+		options.SetTimeoutInMicroSeconds(100000)  # 0.1 second timeout
+		options.SetTryAllThreads(False)
+		
+		# Evaluate the expression to create the persistent variable
+		result = frame.EvaluateExpression(expr, options)
+		
+		# Check for errors
+		if result.GetError().Fail():
+			error_msg = result.GetError().GetCString()
+			# Silently ignore errors for now - convenience variables are optional
+			pass
 
 
 def execute(command, from_tty=False, to_string=False):
@@ -883,3 +916,71 @@ def create_value_from_int(int_value, value_type):
 	return Value(result)
 
 
+def register(name, handler_class, usage=None, category=COMMAND_USER):
+	"""Register a command with LLDB using a handler class.
+	
+	This creates a wrapper Command that handles parsing, terminal setup,
+	and delegates to the handler class for actual command logic.
+	
+	Args:
+		name: Command name (e.g., "rb-print")
+		handler_class: Class to instantiate for handling the command
+		usage: Optional command.Usage specification for validation/help
+		category: Command category (COMMAND_USER, etc.)
+	
+	Example:
+		class PrintHandler:
+			def invoke(self, arguments, terminal):
+				depth = arguments.get_option('depth', 1)
+				print(f"Depth: {depth}")
+		
+		usage = command.Usage(
+			summary="Print something",
+			options={'depth': (int, 1)},
+			flags=['debug']
+		)
+		debugger.register("my-print", PrintHandler, usage=usage)
+	
+	Returns:
+		The registered Command instance
+	"""
+	class RegisteredCommand(Command):
+		def __init__(self):
+			super(RegisteredCommand, self).__init__(name, category)
+			self.usage_spec = usage
+			self.handler_class = handler_class
+		
+		def invoke(self, arg, from_tty):
+			"""LLDB entry point - parses arguments and delegates to handler."""
+			# Create terminal first (needed for help text)
+			import format
+			terminal = format.create_terminal(from_tty)
+			
+			try:
+				# Parse and validate arguments
+				if self.usage_spec:
+					arguments = self.usage_spec.parse(arg if arg else "")
+				else:
+					# Fallback to basic parsing without validation
+					import command
+					arguments = command.parse_arguments(arg if arg else "")
+				
+				# Instantiate handler and invoke
+				handler = self.handler_class()
+				handler.invoke(arguments, terminal)
+				
+			except ValueError as e:
+				# Validation error - show colored help
+				print(f"Error: {e}")
+				if self.usage_spec:
+					print()
+					self.usage_spec.print_to(terminal, name)
+			except Exception as e:
+				print(f"Error: {e}")
+				import traceback
+				traceback.print_exc()
+	
+	# Instantiate and register the command with LLDB
+	return RegisteredCommand()
+
+