toolbox 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 694d8c20e3efb7fad4c3ce738ab9784308fca74971e7198e627458349be2f316
-  data.tar.gz: 41e1fa7e7352ade3a28fdc90ec0db233f937dfef0ddb1a1ac819c052c9edb1f4
+  metadata.gz: f8bc49b89f83b1baa5270a63e16df4c63dfc3de61fa98e8c6da8fabbcde66e87
+  data.tar.gz: cd5b34b044e80e8aa2b278a67fa138cd5230829da83aa9710b04b8b77478b8ff
 SHA512:
-  metadata.gz: 65ebb449eadbcd6c92ba560aac7fd3216e9e50c2fdc2864eb2daf2c0169191d678c7cda7956e3a3ee359eab926bc08c13ff0d8fd1605509b999cb69516d8031a
-  data.tar.gz: '0806493639960770d85ff768e2ad985657b46b7db46327acdfb6248e44cf1cb6b39586273975ce7c7f2e5128307cfc0a667cc13e846d29023615e3b7f9c79068'
+  metadata.gz: 891326e75355c9a42cbed524b63345f7b47e6ee8ed29f5c08ee96a5c8a40cb495ad1913bfeb0043b2479f1e08ff4c763d93b4f8231a30f5b958a356eabc0ae46
+  data.tar.gz: c3edb1db9689d4b399c96a112876d8b8ba3f3b4754903d61e2fafb999d2913409509f4ee2a4964096a4ed5b30ccec0647deee5843a31d77b8700de0ef62ee9b9

data/context/fiber-debugging.md

@@ -161,7 +161,7 @@ After switching to a fiber with `rb-fiber-scan-switch`, you can use standard GDB
 (gdb) bt                    # Show C backtrace
 (gdb) frame <n>             # Switch to specific frame
 (gdb) info locals           # Show local variables
-(gdb) rb-object-print $errinfo  # Print exception if present
+(gdb) rb-print $errinfo  # Print exception if present
 ~~~
 
 The fiber switch command sets up several convenience variables:

data/context/getting-started.md

@@ -15,7 +15,7 @@ $ gem install toolbox
 Install the GDB extensions (automatically adds to `~/.gdbinit`):
 
 ~~~ bash
-$ bake toolbox:gdb:install
+$ bake -g toolbox toolbox:gdb:install
 ~~~
 
 This adds a single line to your `~/.gdbinit` that sources the extensions from the gem's data directory. The extensions will then load automatically every time you start GDB.
@@ -23,7 +23,7 @@ This adds a single line to your `~/.gdbinit` that sources the extensions from th
 To install to a custom `.gdbinit` location:
 
 ~~~ bash
-$ bake toolbox:gdb:install gdbinit=/path/to/custom/gdbinit
+$ bake -g toolbox toolbox:gdb:install gdbinit=/path/to/custom/gdbinit
 ~~~
 
 ### Installing LLDB Extensions
@@ -31,7 +31,7 @@ $ bake toolbox:gdb:install gdbinit=/path/to/custom/gdbinit
 Install the LLDB extensions (automatically adds to `~/.lldbinit`):
 
 ~~~ bash
-$ bake toolbox:lldb:install
+$ bake -g toolbox toolbox:lldb:install
 ~~~
 
 This adds a command script import line to your `~/.lldbinit` that loads the extensions from the gem's data directory. The extensions will then load automatically every time you start LLDB.
@@ -39,7 +39,7 @@ This adds a command script import line to your `~/.lldbinit` that loads the exte
 To install to a custom `.lldbinit` location:
 
 ~~~ bash
-$ bake toolbox:lldb:install lldbinit=/path/to/custom/lldbinit
+$ bake -g toolbox toolbox:lldb:install lldbinit=/path/to/custom/lldbinit
 ~~~
 
 ### Verifying Installation
@@ -47,7 +47,7 @@ $ bake toolbox:lldb:install lldbinit=/path/to/custom/lldbinit
 Check GDB installation status:
 
 ~~~ bash
-$ bake toolbox:gdb:info
+$ bake -g toolbox toolbox:gdb:info
 Ruby Toolbox GDB Extensions v0.1.0
 Status: ✓ Installed
 ~~~
@@ -55,7 +55,7 @@ Status: ✓ Installed
 Check LLDB installation status:
 
 ~~~ bash
-$ bake toolbox:lldb:info
+$ bake -g toolbox toolbox:lldb:info
 Ruby Toolbox LLDB Extensions v0.1.0
 Status: ✓ Installed
 ~~~
@@ -63,7 +63,7 @@ Status: ✓ Installed
 Test that extensions load automatically:
 
 ~~~ bash
-$ gdb --batch -ex "help rb-object-print"
+$ gdb --batch -ex "help rb-print"
 Recursively print Ruby hash and array structures...
 ~~~
 
@@ -72,23 +72,23 @@ Recursively print Ruby hash and array structures...
 To remove the GDB extensions:
 
 ~~~ bash
-$ bake toolbox:gdb:uninstall
+$ bake -g toolbox toolbox:gdb:uninstall
 ~~~
 
 To remove the LLDB extensions:
 
 ~~~ bash
-$ bake toolbox:lldb:uninstall
+$ bake -g toolbox toolbox:lldb:uninstall
 ~~~
 
-This removes the source line from your `~/.gdbinit`.
+This removes the source line from your `~/.gdbinit` or `~/.lldbinit`.
 
 ## Core Concepts
 
 Ruby GDB provides specialized commands for debugging Ruby at multiple levels:
 
 - **Context Setup** (`rb-context`) - Get current execution context and set up convenience variables
-- **Object Inspection** (`rb-object-print`) - View Ruby objects, hashes, arrays, and structs with proper formatting
+- **Object Inspection** (`rb-print`) - View Ruby objects, hashes, arrays, and structs with proper formatting
 - **Fiber Debugging** (`rb-fiber-*`) - Scan heap for fibers, inspect state, and switch contexts
 - **Stack Analysis** (`rb-stack-trace`) - Examine combined VM (Ruby) and C (native) stack frames
 - **Heap Navigation** (`rb-heap-scan`) - Scan the Ruby heap to find objects by type
@@ -132,7 +132,7 @@ Diagnose the issue (extensions load automatically if installed):
 (gdb) rb-fiber-scan-heap                 # Scan heap for all fibers
 (gdb) rb-fiber-scan-stack-trace-all      # Show backtraces for all fibers
 (gdb) rb-fiber-scan-switch 0             # Switch to main fiber
-(gdb) rb-object-print $errinfo --depth 2 # Print exception (now $errinfo is set)
+(gdb) rb-print $errinfo --depth 2 # Print exception (now $errinfo is set)
 (gdb) rb-heap-scan --type RUBY_T_HASH --limit 10  # Find hashes
 ~~~
 
@@ -146,7 +146,7 @@ When a Ruby exception occurs, you can inspect it in detail:
 (gdb) break rb_exc_raise
 (gdb) run
 (gdb) rb-context
-(gdb) rb-object-print $errinfo --depth 2
+(gdb) rb-print $errinfo --depth 2
 ~~~
 
 This shows the exception class, message, and any nested structures. The `rb-context` command displays the current execution context and sets up `$ec`, `$cfp`, and `$errinfo` convenience variables.
@@ -167,7 +167,7 @@ When working with fibers, you often need to see what each fiber is doing:
 Ruby hashes and arrays can contain nested structures:
 
 ~~~
-(gdb) rb-object-print $some_hash --depth 2
+(gdb) rb-print $some_hash --depth 2
 <T_HASH@...>
 [   0] K: <T_SYMBOL> :name
        V: <T_STRING@...> "Alice"
@@ -176,3 +176,25 @@ Ruby hashes and arrays can contain nested structures:
 ~~~
 
 The `--depth` flag controls how deep to recurse into nested objects.
+
+## Requirements
+
+- GDB with Python support (GDB 7.0+) or LLDB with Python support.
+- Ruby 3.3+ recommended.
+
+### Platform Support
+
+- **Linux**: Full support with all features (GDB or LLDB).
+- **macOS**: 
+  - Ruby head: Full support.
+  - Ruby 3.4.x: Limited support (see below).
+- **BSD**: Should work similar to Linux (untested).
+
+### macOS + Ruby 3.4.x Limitation
+
+On macOS with LLDB and Ruby <= 3.4.x, some commands including `rb-fiber-scan-heap` will not work due to a `dsymutil` bug that drops `struct RTypedData` from debug symbols. This appears fixed in `ruby-head`.
+
+**Workarounds:**
+- Use Ruby head: `ruby-install ruby-head -- CFLAGS="-g -O0"`
+- Use GDB instead of LLDB (works with Ruby 3.4.x)
+- Other commands like `rb-print`, `rb-stack-trace`, `rb-context` work fine

data/context/index.yaml

@@ -12,7 +12,7 @@ files:
     programs and core dumps with GDB or LLDB.
 - path: object-inspection.md
   title: Object Inspection
-  description: This guide explains how to use `rb-object-print` to inspect Ruby objects,
+  description: This guide explains how to use `rb-print` to inspect Ruby objects,
     hashes, arrays, and structs in GDB.
 - path: stack-inspection.md
   title: Stack Inspection

data/context/object-inspection.md

@@ -1,12 +1,12 @@
 # Object Inspection
 
-This guide explains how to use `rb-object-print` to inspect Ruby objects, hashes, arrays, and structs in GDB.
+This guide explains how to use `rb-print` to inspect Ruby objects, hashes, arrays, and structs in GDB.
 
 ## Why Object Inspection Matters
 
 When debugging Ruby programs or analyzing core dumps, you often need to inspect complex data structures that are difficult to read in their raw memory representation. Standard GDB commands show pointer addresses and raw memory, but not the logical structure of Ruby objects.
 
-Use `rb-object-print` when you need:
+Use `rb-print` when you need:
 
 - **Understand exception objects**: See the full exception hierarchy, message, and backtrace data
 - **Inspect fiber storage**: View thread-local data and fiber-specific variables
@@ -15,12 +15,12 @@ Use `rb-object-print` when you need:
 
 ## Basic Usage
 
-The `rb-object-print` command recursively prints Ruby objects in a human-readable format.
+The `rb-print` command recursively prints Ruby objects in a human-readable format.
 
 ### Syntax
 
 ~~~
-rb-object-print <expression> [--depth N] [--debug]
+rb-print <expression> [--depth N] [--debug]
 ~~~
 
 Where:
@@ -33,10 +33,10 @@ Where:
 Print immediate values and special constants:
 
 ~~~
-(gdb) rb-object-print 0        # <T_FALSE>
-(gdb) rb-object-print 8        # <T_NIL>
-(gdb) rb-object-print 20       # <T_TRUE>
-(gdb) rb-object-print 85       # <T_FIXNUM> 42
+(gdb) rb-print 0        # <T_FALSE>
+(gdb) rb-print 8        # <T_NIL>
+(gdb) rb-print 20       # <T_TRUE>
+(gdb) rb-print 85       # <T_FIXNUM> 42
 ~~~
 
 These work without any Ruby process running, making them useful for learning and testing.
@@ -46,10 +46,10 @@ These work without any Ruby process running, making them useful for learning and
 Use any valid GDB expression:
 
 ~~~
-(gdb) rb-object-print $ec->errinfo                    # Exception object
-(gdb) rb-object-print $ec->cfp->sp[-1]                # Top of VM stack
-(gdb) rb-object-print $ec->storage                    # Fiber storage hash
-(gdb) rb-object-print (VALUE)0x00007f8a12345678      # Object at specific address
+(gdb) rb-print $ec->errinfo                    # Exception object
+(gdb) rb-print $ec->cfp->sp[-1]                # Top of VM stack
+(gdb) rb-print $ec->storage                    # Fiber storage hash
+(gdb) rb-print (VALUE)0x00007f8a12345678      # Object at specific address
 ~~~
 
 ## Inspecting Hashes
@@ -61,7 +61,7 @@ Ruby hashes have two internal representations (ST table and AR table). The comma
 For hashes with fewer than 8 entries, Ruby uses an array-based implementation:
 
 ~~~
-(gdb) rb-object-print $some_hash
+(gdb) rb-print $some_hash
 <T_HASH@...>
 [   0] K: <T_SYMBOL> :name
        V: <T_STRING@...> "Alice"
@@ -76,7 +76,7 @@ For hashes with fewer than 8 entries, Ruby uses an array-based implementation:
 For larger hashes, Ruby uses a hash table (output format is similar):
 
 ~~~
-(gdb) rb-object-print $large_hash
+(gdb) rb-print $large_hash
 <T_HASH@...>
 [   0] K: <T_SYMBOL> :user_id
        V: <T_FIXNUM> 12345
@@ -90,12 +90,12 @@ For larger hashes, Ruby uses a hash table (output format is similar):
 Prevent overwhelming output from deeply nested structures:
 
 ~~~
-(gdb) rb-object-print $nested_hash --depth 1   # Only top level
+(gdb) rb-print $nested_hash --depth 1   # Only top level
 <T_HASH@...>
 [   0] K: <T_SYMBOL> :data
        V: <T_HASH@...>  # Nested hash not expanded
 
-(gdb) rb-object-print $nested_hash --depth 2   # Expand one level
+(gdb) rb-print $nested_hash --depth 2   # Expand one level
 <T_HASH@...>
 [   0] K: <T_SYMBOL> :data
        V: <T_HASH@...>
@@ -114,7 +114,7 @@ Arrays also have two representations based on size:
 Arrays display their elements with type information:
 
 ~~~
-(gdb) rb-object-print $array
+(gdb) rb-print $array
 <T_ARRAY@...>
 [   0] <T_FIXNUM> 1
 [   1] <T_FIXNUM> 2
@@ -124,7 +124,7 @@ Arrays display their elements with type information:
 For arrays with nested objects:
 
 ~~~
-(gdb) rb-object-print $array --depth 2
+(gdb) rb-print $array --depth 2
 <T_ARRAY@...>
 [   0] <T_STRING@...> "first item"
 [   1] <T_HASH@...>
@@ -138,7 +138,7 @@ For arrays with nested objects:
 Ruby Struct objects work similarly to arrays:
 
 ~~~
-(gdb) rb-object-print $struct_instance
+(gdb) rb-print $struct_instance
 <T_STRUCT@...>
 [   0] <T_STRING@...> "John"
 [   1] <T_FIXNUM> 25
@@ -155,7 +155,7 @@ When a fiber has an exception, inspect it:
 ~~~
 (gdb) rb-fiber-scan-heap
 (gdb) rb-fiber-scan-switch 5  # Switch to fiber #5
-(gdb) rb-object-print $errinfo --depth 3
+(gdb) rb-print $errinfo --depth 3
 ~~~
 
 This reveals the full exception structure including any nested causes. After switching to a fiber, `$errinfo` and `$ec` convenience variables are automatically set.
@@ -167,8 +167,8 @@ Break at a method and examine arguments on the stack:
 ~~~
 (gdb) break some_method
 (gdb) run
-(gdb) rb-object-print $ec->cfp->sp[-1]  # Last argument
-(gdb) rb-object-print $ec->cfp->sp[-2]  # Second-to-last argument
+(gdb) rb-print $ec->cfp->sp[-1]  # Last argument
+(gdb) rb-print $ec->cfp->sp[-2]  # Second-to-last argument
 ~~~
 
 ### Examining Fiber Storage
@@ -178,17 +178,17 @@ Thread-local variables are stored in fiber storage:
 ~~~
 (gdb) rb-fiber-scan-heap
 (gdb) rb-fiber-scan-switch 0
-(gdb) rb-object-print $ec->storage --depth 2
+(gdb) rb-print $ec->storage --depth 2
 ~~~
 
 This shows all thread-local variables and their values.
 
 ## Debugging with --debug Flag
 
-When `rb-object-print` doesn't show what you expect, use `--debug`:
+When `rb-print` doesn't show what you expect, use `--debug`:
 
 ~~~
-(gdb) rb-object-print $suspicious_value --debug
+(gdb) rb-print $suspicious_value --debug
 DEBUG: Evaluated '$suspicious_value' to 0x7f8a1c567890
 DEBUG: Loaded constant RUBY_T_MASK = 31
 DEBUG: Object at 0x7f8a1c567890 with flags=0x20040005, type=0x5

data/context/stack-inspection.md

@@ -140,9 +140,9 @@ See what values are on the current frame's stack:
 (gdb) set $sp = $ec->cfp->sp
 
 # Print values on stack
-(gdb) rb-object-print *(VALUE*)($sp - 1)  # Top of stack
-(gdb) rb-object-print *(VALUE*)($sp - 2)  # Second value
-(gdb) rb-object-print *(VALUE*)($sp - 3)  # Third value
+(gdb) rb-print *(VALUE*)($sp - 1)  # Top of stack
+(gdb) rb-print *(VALUE*)($sp - 2)  # Second value
+(gdb) rb-print *(VALUE*)($sp - 3)  # Third value
 ~~~
 
 ### Tracking Fiber Switches

data/data/toolbox/command.py

@@ -19,6 +19,231 @@ class Arguments:
 		"""Get an option value with optional default"""
 		return self.options.get(option_name, default)
 
+
+class Usage:
+	"""Command specification DSL for declarative command interfaces.
+	
+	Defines what parameters, options, and flags a command accepts,
+	enabling validation and help text generation.
+	
+	Example:
+		usage = Usage(
+			summary="Print Ruby objects with recursion",
+			parameters=['value'],
+			options={'depth': (int, 1), 'limit': (int, None)},
+			flags=['debug', 'verbose']
+		)
+		
+		arguments = usage.parse("$var --depth 3 --debug")
+		# arguments.expressions = ['$var']
+		# arguments.options = {'depth': 3}
+		# arguments.flags = {'debug'}
+	"""
+	
+	def __init__(self, summary, parameters=None, options=None, flags=None, examples=None):
+		"""Define command interface.
+		
+		Args:
+			summary: One-line command description
+			parameters: List of parameter names or tuples (name, description)
+			options: Dict of {name: (type, default, description)}
+			flags: List of flag names or tuples (name, description)
+			examples: List of example command strings with descriptions
+		
+		Example:
+			Usage(
+				summary="Scan heap for objects",
+				parameters=[('type_name', 'Ruby type to search for')],
+				options={
+					'limit': (int, None, 'Maximum objects to find'),
+					'depth': (int, 1, 'Recursion depth')
+				},
+				flags=[
+					('terminated', 'Include terminated fibers'),
+					('cache', 'Use cached results')
+				],
+				examples=[
+					("rb-heap-scan --type RUBY_T_STRING", "Find all strings"),
+					("rb-heap-scan --type RUBY_T_HASH --limit 10", "Find first 10 hashes")
+				]
+			)
+		"""
+		self.summary = summary
+		self.parameters = self._normalize_params(parameters or [])
+		self.options = options or {}
+		self.flags = self._normalize_flags(flags or [])
+		self.examples = examples or []
+	
+	def _normalize_params(self, params):
+		"""Normalize parameters to list of (name, description) tuples."""
+		normalized = []
+		for param in params:
+			if isinstance(param, tuple):
+				normalized.append(param)
+			else:
+				normalized.append((param, None))
+		return normalized
+	
+	def _normalize_flags(self, flags):
+		"""Normalize flags to list of (name, description) tuples."""
+		normalized = []
+		for flag in flags:
+			if isinstance(flag, tuple):
+				normalized.append(flag)
+			else:
+				normalized.append((flag, None))
+		return normalized
+	
+	def parse(self, argument_string):
+		"""Parse and validate command arguments.
+		
+		Args:
+			argument_string: Raw argument string from debugger
+		
+		Returns:
+			Arguments object with validated and type-converted values
+		
+		Raises:
+			ValueError: If validation fails (wrong parameter count, invalid types, etc.)
+		"""
+		# Use existing parser to extract raw arguments
+		arguments = parse_arguments(argument_string)
+		
+		# Validate parameter count
+		if len(arguments.expressions) != len(self.parameters):
+			if len(self.parameters) == 0 and len(arguments.expressions) > 0:
+				raise ValueError(f"Command takes no parameters, got {len(arguments.expressions)}")
+			elif len(self.parameters) == 1:
+				raise ValueError(f"Command requires 1 parameter, got {len(arguments.expressions)}")
+			else:
+				raise ValueError(f"Command requires {len(self.parameters)} parameters, got {len(arguments.expressions)}")
+		
+		# Validate and convert option types
+		converted_options = {}
+		for option_name, option_value in arguments.options.items():
+			if option_name not in self.options:
+				raise ValueError(f"Unknown option: --{option_name}")
+			
+			# Unpack option spec (handle 2-tuple or 3-tuple)
+			opt_spec = self.options[option_name]
+			option_type = opt_spec[0]
+			option_default = opt_spec[1]
+			
+			# Convert to specified type
+			try:
+				if option_type == int:
+					converted_options[option_name] = int(option_value)
+				elif option_type == str:
+					converted_options[option_name] = str(option_value)
+				elif option_type == bool:
+					converted_options[option_name] = bool(option_value)
+				else:
+					# Custom type converter
+					converted_options[option_name] = option_type(option_value)
+			except (ValueError, TypeError) as e:
+				raise ValueError(f"Invalid value for --{option_name}: {option_value} (expected {option_type.__name__})")
+		
+		# Add defaults for missing options
+		for option_name, opt_spec in self.options.items():
+			option_default = opt_spec[1]
+			if option_name not in converted_options and option_default is not None:
+				converted_options[option_name] = option_default
+		
+		# Validate flags
+		flag_names = {flag[0] for flag in self.flags}
+		for flag_name in arguments.flags:
+			if flag_name not in flag_names:
+				raise ValueError(f"Unknown flag: --{flag_name}")
+		
+		# Return new Arguments with converted options
+		return Arguments(arguments.expressions, arguments.flags, converted_options)
+	
+	def print_to(self, terminal, command_name):
+		"""Print help text from usage specification.
+		
+		Args:
+			terminal: Terminal for colored output
+			command_name: Name of the command (e.g., "rb-print")
+		"""
+		import format as fmt
+		
+		# Summary with color
+		terminal.print(fmt.bold, self.summary, fmt.reset)
+		terminal.print()
+		
+		# Print usage line
+		terminal.print("Usage: ", end='')
+		terminal.print(fmt.bold, command_name, fmt.reset, end='')
+		
+		for param_name, _ in self.parameters:
+			terminal.print(' ', end='')
+			terminal.print(fmt.placeholder, f"<{param_name}>", fmt.reset, end='')
+		
+		# Add option placeholders
+		for option_name in self.options.keys():
+			terminal.print(' ', end='')
+			terminal.print(fmt.placeholder, f"[--{option_name} N]", fmt.reset, end='')
+		
+		# Add flag placeholders
+		for flag_name, _ in self.flags:
+			terminal.print(' ', end='')
+			terminal.print(fmt.placeholder, f"[--{flag_name}]", fmt.reset, end='')
+		
+		terminal.print()
+		terminal.print()
+		
+		# Parameter descriptions
+		if self.parameters:
+			terminal.print(fmt.title, "Parameters:", fmt.reset)
+			
+			for param_name, param_desc in self.parameters:
+				terminal.print("  ", fmt.symbol, param_name, fmt.reset, end='')
+				if param_desc:
+					terminal.print(f" - {param_desc}")
+				else:
+					terminal.print()
+			terminal.print()
+		
+		# Option descriptions
+		if self.options:
+			terminal.print(fmt.title, "Options:", fmt.reset)
+			
+			for option_name, opt_spec in self.options.items():
+				opt_type, opt_default = opt_spec[0], opt_spec[1]
+				opt_desc = opt_spec[2] if len(opt_spec) > 2 else None
+				
+				type_str = opt_type.__name__ if hasattr(opt_type, '__name__') else str(opt_type)
+				default_str = f" (default: {opt_default})" if opt_default is not None else ""
+				
+				terminal.print("  ", fmt.symbol, f"--{option_name}", fmt.reset, end='')
+				terminal.print(fmt.placeholder, f" <{type_str}>", fmt.reset, end='')
+				terminal.print(default_str)
+				
+				if opt_desc:
+					terminal.print(f"      {opt_desc}")
+			terminal.print()
+		
+		# Flag descriptions
+		if self.flags:
+			terminal.print(fmt.title, "Flags:", fmt.reset)
+			
+			for flag_name, flag_desc in self.flags:
+				terminal.print("  ", fmt.symbol, f"--{flag_name}", fmt.reset, end='')
+				if flag_desc:
+					terminal.print(f" - {flag_desc}")
+				else:
+					terminal.print()
+			terminal.print()
+		
+		# Examples section
+		if self.examples:
+			terminal.print(fmt.title, "Examples:", fmt.reset)
+			
+			for example_cmd, example_desc in self.examples:
+				terminal.print(fmt.example, f"  {example_cmd}", fmt.reset)
+				if example_desc:
+					terminal.print(f"      {example_desc}")
+
 class ArgumentParser:
 	"""Parse GDB command arguments handling nested brackets, quotes, and flags.