toolbox 0.2.0 → 0.3.0

data/data/toolbox/format.py

@@ -6,6 +6,7 @@ less prominent and values more readable.
 """
 
 import sys
+import rvalue
 
 class Style:
 	"""Sentinel object representing a style."""
@@ -28,66 +29,60 @@ method = Style('method')  # Alias for symbol (method names)
 error = Style('error')
 bold = Style('bold')
 dim = Style('dim')
+title = Style('title')  # For section headers in help text
+placeholder = Style('placeholder')  # For help text placeholders (parameters, options)
+example = Style('example')  # For example commands in help text
 
 class Text:
 	"""Plain text output without any formatting."""
 	
-	def print(self, *args):
-		"""Print arguments, skipping style sentinels."""
-		result = []
-		for arg in args:
-			# Skip Style sentinels
-			if not isinstance(arg, Style):
-				# If arg has a print_to method, use it
-				if hasattr(arg, 'print_to'):
-					result.append(arg.print_to(self))
-				else:
-					result.append(str(arg))
-		return "".join(result)
-	
-	def print_type_tag(self, type_name, address_val=None, details=None):
+	def __init__(self, output=None):
+		"""Initialize text terminal.
+		
+		Args:
+			output: Output stream (default: sys.stdout)
+		"""
+		self.output = output or sys.stdout
+	
+	def print(self, *args, end='\n'):
+		"""Print arguments to output stream.
+		
+		Args:
+			*args: Arguments to print (strings, Style sentinels, or objects with print_to)
+			end: String appended after the last arg (default: newline)
 		"""
-		Format a type tag like <T_ARRAY@0xABCD embedded length=3>.
+		for arg in args:
+			if isinstance(arg, Style):
+				# Skip style sentinels in plain text mode
+				continue
+			elif hasattr(arg, 'print_to'):
+				# Let object print itself
+				arg.print_to(self)
+			else:
+				self.output.write(str(arg))
+		self.output.write(end)
+	
+	def print_type_tag(self, type_name, addr=None, details=None):
+		"""Print a type tag like <T_ARRAY@0xABCD embedded length=3>.
 		
 		Arguments:
 			type_name: Type name (e.g., "T_ARRAY", "void *")
-			address_val: Optional hex address (as integer or hex string without 0x)
+			addr: Optional hex address (as integer or hex string without 0x)
 			details: Optional details string (e.g., "embedded length=3")
-		
-		Returns:
-			Formatted string with appropriate styling
 		"""
-		if isinstance(address_val, int):
-			address_val = f"{address_val:x}"
+		if isinstance(addr, int):
+			addr = f"{addr:x}"
 		
-		parts = [metadata, '<', type, type_name]
+		self.print(metadata, '<', reset, type, type_name, reset, end='')
 		
-		if address_val:
-			parts.extend([metadata, f'@0x{address_val}'])
+		if addr:
+			# @ symbol in dim, address in magenta
+			self.print(metadata, '@', reset, address, f'0x{addr}', reset, end='')
 		
 		if details:
-			parts.extend([f' {details}'])
-		
-		parts.extend([metadata, '>', reset])
+			self.print(metadata, f' {details}', reset, end='')
 		
-		return self.print(*parts)
-	
-	def print_value_with_tag(self, type_tag, val=None, value_style=value):
-		"""
-		Format a complete value with type tag and optional value.
-		
-		Arguments:
-			type_tag: Formatted type tag string
-			val: Optional value to display
-			value_style: Style sentinel to use for the value
-		
-		Returns:
-			Complete formatted string
-		"""
-		if val is not None:
-			return f"{type_tag} {self.print(value_style, str(val), reset)}"
-		else:
-			return type_tag
+		self.print(metadata, '>', reset, end='')
 
 class XTerm(Text):
 	"""ANSI color/style output for terminal."""
@@ -112,36 +107,48 @@ class XTerm(Text):
 	BRIGHT_MAGENTA = '\033[95m'
 	BRIGHT_CYAN = '\033[96m'
 	
-	def __init__(self):
+	def __init__(self, output=None):
+		"""Initialize ANSI terminal.
+		
+		Args:
+			output: Output stream (default: sys.stdout)
+		"""
+		super().__init__(output)
 		# Map style sentinels to ANSI codes
 		self.style_map = {
 			reset: self.RESET,
-			metadata: self.DIM,
-			address: self.DIM,
-			type: '',
-			value: '',
+			metadata: self.DIM,         # Type tag brackets <>
+			address: self.MAGENTA,      # Memory addresses in type tags
+			type: self.CYAN,            # Type names (T_ARRAY, VALUE, etc.)
 			string: self.GREEN,
 			number: self.CYAN,
 			symbol: self.YELLOW,
-			method: self.YELLOW,  # Same as symbol
+			method: self.YELLOW,        # Same as symbol
 			error: self.RED,
 			bold: self.BOLD,
 			dim: self.DIM,
+			title: self.BOLD,           # Section headers in help text
+			placeholder: self.BLUE,     # Help text placeholders
+			example: self.GREEN,        # Example commands in help text
 		}
 	
-	def print(self, *args):
-		"""Print arguments, replacing style sentinels with ANSI codes."""
-		result = []
+	def print(self, *args, end='\n'):
+		"""Print arguments to output stream with ANSI formatting.
+		
+		Args:
+			*args: Arguments to print (strings, Style sentinels, or objects with print_to)
+			end: String appended after the last arg (default: newline)
+		"""
 		for arg in args:
 			if isinstance(arg, Style):
-				result.append(self.style_map.get(arg, ''))
+				# Print ANSI code for style
+				self.output.write(self.style_map.get(arg, ''))
+			elif hasattr(arg, 'print_to'):
+				# Let object print itself
+				arg.print_to(self)
 			else:
-				# If arg has a print_to method, use it
-				if hasattr(arg, 'print_to'):
-					result.append(arg.print_to(self))
-				else:
-					result.append(str(arg))
-		return "".join(result)
+				self.output.write(str(arg))
+		self.output.write(end)
 
 # Helper for creating the appropriate terminal based on TTY status
 def create_terminal(from_tty):
@@ -166,7 +173,7 @@ class Printer:
 	
 	def print(self, *args):
 		"""Print arguments using the terminal's formatting."""
-		print(self.terminal.print(*args))
+		self.terminal.print(*args)
 	
 	def print_indent(self, depth):
 		"""Print indentation based on depth."""
@@ -194,7 +201,5 @@ class Printer:
 		value_int = int(ruby_value)
 		self.debug(f"print_value: value=0x{value_int:x}, depth={depth}")
 		
-		# Use interpret to get the appropriate wrapper and let it print itself
-		import value
-		ruby_object = value.interpret(ruby_value)
+		ruby_object = rvalue.interpret(ruby_value)
 		ruby_object.print_recursive(self, depth)

data/data/toolbox/heap.py

@@ -1,5 +1,9 @@
 import debugger
 import sys
+import command
+import constants
+import format
+import rvalue
 
 # Constants
 RBASIC_FLAGS_TYPE_MASK = 0x1f
@@ -66,15 +70,15 @@ class RubyHeap:
 				return False
 
 			# Cache commonly used type lookups
-			self._rbasic_type = debugger.lookup_type('struct RBasic').pointer()
-			self._value_type = debugger.lookup_type('VALUE')
-			self._char_ptr_type = debugger.lookup_type('char').pointer()
+			self._rbasic_type = constants.type_struct('struct RBasic').pointer()
+			self._value_type = constants.type_struct('VALUE')
+			self._char_ptr_type = constants.type_struct('char').pointer()
 			
 			# Cache flags field offset for fast memory access
 			# This is critical for LLDB performance where field lookup is expensive
 			try:
 				# Get a dummy RBasic to find the flags offset
-				rbasic_struct = debugger.lookup_type('struct RBasic')
+				rbasic_struct = constants.type_struct('struct RBasic')
 				# In RBasic, 'flags' is the first field (offset 0)
 				# We need to find its offset programmatically for portability
 				fields = rbasic_struct.fields()
@@ -277,9 +281,9 @@ class RubyHeap:
 			return
 
 		# Cache types for pointer arithmetic and casting
-		rbasic_type = debugger.lookup_type('struct RBasic')
+		rbasic_type = constants.type_struct('struct RBasic')
 		rbasic_ptr_type = rbasic_type.pointer()
-		char_ptr_type = debugger.lookup_type('char').pointer()
+		char_ptr_type = constants.type_struct('char').pointer()
 
 		for i in range(start_page, allocated_pages):
 			page = self._get_page(i)
@@ -400,7 +404,7 @@ class RubyHeap:
 		T_DATA = 0x0c
 		
 		# Get RTypedData type for casting
-		rtypeddata_type = debugger.lookup_type('struct RTypedData').pointer()
+		rtypeddata_type = constants.type_struct('struct RTypedData').pointer()
 		
 		try:
 			if progress:
@@ -431,9 +435,29 @@ class RubyHeap:
 			# Cast to RTypedData and check type
 			try:
 				typed_data = obj.cast(rtypeddata_type)
+				type_field = typed_data['type']
 				
-				# Compare values directly using __eq__
-				if typed_data['type'] == data_type:
+				# Check if field access failed (returns None when type is incomplete)
+				if type_field is None:
+					# On first failure, print a helpful error message once
+					if not hasattr(self, '_incomplete_type_warning_shown'):
+						self._incomplete_type_warning_shown = True
+						print("\nError: struct RTypedData debug symbols are incomplete", file=sys.stderr)
+						print("Cannot access RTypedData fields with this Ruby version.", file=sys.stderr)
+						print("\nThis is a known issue with Ruby 3.4.x on macOS:", file=sys.stderr)
+						print("  • A dsymutil bug drops RTypedData from debug symbols", file=sys.stderr)
+						print("  • Caused by complex 'const T *const' type in the struct", file=sys.stderr)
+						print("  • Fixed in Ruby head (commit ce51ef30df)", file=sys.stderr)
+						print("\nWorkarounds:", file=sys.stderr)
+						print("  • Use Ruby head: ruby-install ruby-head -- CFLAGS=\"-g -O0\"", file=sys.stderr)
+						print("  • Or use GDB on Linux (works with Ruby 3.4.x)", file=sys.stderr)
+						print("\nSee: https://socketry.github.io/toolbox/guides/getting-started/", file=sys.stderr)
+						print(file=sys.stderr)
+					# Can't scan without complete type info
+					break
+				
+				# Compare type pointers
+				if type_field == data_type:
 					# Return the VALUE, not the extracted data pointer
 					objects.append(obj)
 					if progress:
@@ -450,7 +474,7 @@ class RubyHeap:
 		return objects
 
 
-class RubyHeapScanCommand(debugger.Command):
+class RubyHeapScanHandler:
 	"""Scan the Ruby heap for objects, optionally filtered by type.
 	
 	Usage: rb-heap-scan [--type TYPE] [--limit N] [--from $heap]
@@ -480,23 +504,21 @@ class RubyHeapScanCommand(debugger.Command):
 	  rb-heap-scan --from $heap         # Continue from last scan
 	"""
 	
-	def __init__(self):
-		super(RubyHeapScanCommand, self).__init__("rb-heap-scan", debugger.COMMAND_USER)
-	
-	def usage(self):
-		"""Print usage information."""
-		print("Usage: rb-heap-scan [--type TYPE] [--limit N] [--from $heap]")
-		print("Examples:")
-		print("  rb-heap-scan --type RUBY_T_STRING              # Find up to 10 strings")
-		print("  rb-heap-scan --type RUBY_T_ARRAY --limit 5     # Find up to 5 arrays")
-		print("  rb-heap-scan --type 0x05 --limit 100           # Find up to 100 T_STRING objects")
-		print("  rb-heap-scan --limit 20                        # Scan 20 objects (any type)")
-		print("  rb-heap-scan --type RUBY_T_STRING --from $heap # Continue from last scan")
-		print()
-		print("Pagination:")
-		print("  The address of the last object is saved to $heap for pagination:")
-		print("    rb-heap-scan --type RUBY_T_STRING --limit 10        # First page")
-		print("    rb-heap-scan --type RUBY_T_STRING --from $heap      # Next page")
+	USAGE = command.Usage(
+		summary="Scan the Ruby heap for objects, optionally filtered by type",
+		parameters=[],
+		options={
+			'type': (str, None, 'Filter by Ruby type (e.g., RUBY_T_STRING, RUBY_T_ARRAY, or 0x05)'),
+			'limit': (int, 10, 'Maximum objects to find'),
+			'from': (str, None, 'Start address for pagination (use $heap)')
+		},
+		flags=[],
+		examples=[
+			("rb-heap-scan --type RUBY_T_STRING", "Find up to 10 strings"),
+			("rb-heap-scan --type RUBY_T_ARRAY --limit 20", "Find first 20 arrays"),
+			("rb-heap-scan --from $heap", "Continue from last scan (pagination)")
+		]
+	)
 	
 	def _parse_type(self, type_arg):
 		"""Parse a type argument and return the type value.
@@ -530,13 +552,9 @@ class RubyHeapScanCommand(debugger.Command):
 		
 		return type_value
 	
-	def invoke(self, arg, from_tty):
+	def invoke(self, arguments, terminal):
 		"""Execute the heap scan command."""
 		try:
-			# Parse arguments
-			import command
-			arguments = command.parse_arguments(arg if arg else "")
-			
 			# Check if we're continuing from a previous scan
 			from_option = arguments.get_option('from')
 			if from_option is not None:
@@ -595,69 +613,61 @@ class RubyHeapScanCommand(debugger.Command):
 					print("(You may have reached the end of the heap)")
 				return
 			
-			# Import format for terminal output
-			import format
-			terminal = format.create_terminal(from_tty)
-			
-			# Import value module for interpretation
-			import value as value_module
-			
 			print(f"Found {len(objects)} object(s):")
 			print()
 			
 			for i, obj in enumerate(objects):
-				obj_int = int(obj)
-				
 				# Set as convenience variable
+				obj_int = int(obj)
 				var_name = f"heap{i}"
 				debugger.set_convenience_variable(var_name, obj)
 				
 				# Try to interpret and display the object
 				try:
-					interpreted = value_module.interpret(obj)
+					interpreted = rvalue.interpret(obj)
 					
-					print(terminal.print(
+					terminal.print(
 						format.metadata, f"  [{i}] ",
 						format.dim, f"${var_name} = ",
 						format.reset, interpreted
-					))
+					)
 				except Exception as e:
-					print(terminal.print(
+					terminal.print(
 						format.metadata, f"  [{i}] ",
 						format.dim, f"${var_name} = ",
 						format.error, f"<error: {e}>"
-					))
+					)
 			
 			print()
-			print(terminal.print(
+			terminal.print(
 				format.dim, 
 				f"Objects saved in $heap0 through $heap{len(objects)-1}",
 				format.reset
-			))
+			)
 			
 			# Save next address to $heap for pagination
 			if next_address is not None:
 				# Save the next address to continue from
-				void_ptr_type = debugger.lookup_type('void').pointer()
+				void_ptr_type = constants.type_struct('void').pointer()
 				debugger.set_convenience_variable('heap', debugger.create_value(next_address, void_ptr_type))
-				print(terminal.print(
+				terminal.print(
 					format.dim,
 					f"Next scan address saved to $heap: 0x{next_address:016x}",
 					format.reset
-				))
-				print(terminal.print(
+				)
+				terminal.print(
 					format.dim,
 					f"Run 'rb-heap-scan --type {type_option if type_option else '...'} --from $heap' for next page",
 					format.reset
-				))
+				)
 			else:
 				# Reached the end of the heap - unset $heap so next scan starts fresh
 				debugger.set_convenience_variable('heap', None)
-				print(terminal.print(
+				terminal.print(
 					format.dim,
 					f"Reached end of heap (no more objects to scan)",
 					format.reset
-				))
+				)
 			
 		except Exception as e:
 			print(f"Error: {e}")
@@ -666,4 +676,4 @@ class RubyHeapScanCommand(debugger.Command):
 
 
 # Register commands
-RubyHeapScanCommand()
+debugger.register("rb-heap-scan", RubyHeapScanHandler, usage=RubyHeapScanHandler.USAGE)

data/data/toolbox/init.py

@@ -24,8 +24,8 @@ failed_extensions = []
 
 # Try to load each extension individually
 extensions_to_load = [
-	('object', 'rb-object-print'),
-	('context', 'rb-context'),
+	('print', 'rb-print'),
+	('context', 'rb-context, rb-context-storage'),
 	('fiber', 'rb-fiber-scan-heap, rb-fiber-switch'),
 	('stack', 'rb-stack-trace'),
 	('heap', 'rb-heap-scan'),
@@ -33,8 +33,8 @@ extensions_to_load = [
 
 for module_name, commands in extensions_to_load:
 	try:
-		if module_name == 'object':
-			import object
+		if module_name == 'print':
+			import print as print_module
 		elif module_name == 'context':
 			import context
 		elif module_name == 'fiber':
@@ -44,8 +44,12 @@ for module_name, commands in extensions_to_load:
 		elif module_name == 'heap':
 			import heap
 		loaded_extensions.append((module_name, commands))
-	except ImportError as e:
+	except Exception as e:
+		# Catch all exceptions during module load
 		failed_extensions.append((module_name, str(e)))
+		import traceback
+		print(f"Failed to load {module_name}: {e}", file=sys.stderr)
+		traceback.print_exc(file=sys.stderr)
 
 # Silently load - no status messages printed by default
 # Users can run 'help' to see available commands

data/data/toolbox/print.py

@@ -0,0 +1,79 @@
+"""Print command for Ruby values."""
+
+import debugger
+import sys
+
+# Import utilities
+import command
+import constants
+import rvalue
+import rstring
+import rarray
+import rhash
+import rsymbol
+import rstruct
+import rfloat
+import rbignum
+import rbasic
+import format
+
+
+class RubyObjectPrinter:
+	"""Print Ruby objects with recursive descent into nested structures."""
+	
+	USAGE = command.Usage(
+		summary="Print Ruby objects with recursive inspection",
+		parameters=[('value', 'VALUE or expression to print')],
+		options={
+			'depth': (int, 1, 'Maximum recursion depth for nested objects')
+		},
+		flags=[
+			('debug', 'Show internal structure and debug information')
+		],
+		examples=[
+			("rb-print $errinfo", "Print exception object"),
+			("rb-print $ec->storage --depth 3", "Print fiber storage with depth 3"),
+			("rb-print $ec->cfp->sp[-1] --debug", "Print top of stack with debug info")
+		]
+	)
+	
+	def invoke(self, arguments, terminal):
+		"""Execute the print command.
+		
+		Args:
+			arguments: Parsed Arguments object
+			terminal: Terminal formatter (already configured for TTY/non-TTY)
+		"""
+		# Get options
+		max_depth = arguments.get_option('depth', 1)
+		debug_mode = arguments.has_flag('debug')
+		
+		# Validate depth
+		if max_depth < 1:
+			print("Error: --depth must be >= 1")
+			return
+		
+		# Create printer
+		printer = format.Printer(terminal, max_depth, debug_mode)
+		
+		# Process each expression
+		for expression in arguments.expressions:
+			try:
+				# Evaluate the expression
+				ruby_value = debugger.parse_and_eval(expression)
+				
+				# Interpret the value and let it print itself recursively
+				ruby_object = rvalue.interpret(ruby_value)
+				ruby_object.print_recursive(printer, max_depth)
+			except debugger.Error as e:
+				print(f"Error evaluating expression '{expression}': {e}")
+			except Exception as e:
+				print(f"Error processing '{expression}': {type(e).__name__}: {e}")
+				if debug_mode:
+					import traceback
+					traceback.print_exc(file=sys.stderr)
+
+
+# Register command using new interface
+debugger.register("rb-print", RubyObjectPrinter, usage=RubyObjectPrinter.USAGE)
+

data/data/toolbox/rarray.py

@@ -77,12 +77,8 @@ class RArrayEmbedded(RArrayBase):
 	def print_to(self, terminal):
 		"""Print this array with formatting."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_ARRAY',
-			format.metadata, f'@0x{addr:x} embedded length={len(self)}>',
-			format.reset
-		)
+		details = f"embedded length={len(self)}"
+		terminal.print_type_tag('T_ARRAY', addr, details)
 
 class RArrayHeap(RArrayBase):
 	"""Heap array (larger arrays with separate memory allocation)."""
@@ -101,12 +97,8 @@ class RArrayHeap(RArrayBase):
 	def print_to(self, terminal):
 		"""Print this array with formatting."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_ARRAY',
-			format.metadata, f'@0x{addr:x} heap length={len(self)}>',
-			format.reset
-		)
+		details = f"heap length={len(self)}"
+		terminal.print_type_tag('T_ARRAY', addr, details)
 
 def RArray(value):
 	"""Factory function that returns the appropriate RArray variant.

data/data/toolbox/rbasic.py

@@ -29,39 +29,39 @@ def is_type(value, ruby_type_constant):
 
 # Map of type constants to their names for display
 TYPE_NAMES = {
-	'RUBY_T_NONE': 'None',
-	'RUBY_T_OBJECT': 'Object',
-	'RUBY_T_CLASS': 'Class',
-	'RUBY_T_MODULE': 'Module',
-	'RUBY_T_FLOAT': 'Float',
-	'RUBY_T_STRING': 'String',
-	'RUBY_T_REGEXP': 'Regexp',
-	'RUBY_T_ARRAY': 'Array',
-	'RUBY_T_HASH': 'Hash',
-	'RUBY_T_STRUCT': 'Struct',
-	'RUBY_T_BIGNUM': 'Bignum',
-	'RUBY_T_FILE': 'File',
-	'RUBY_T_DATA': 'Data',
-	'RUBY_T_MATCH': 'Match',
-	'RUBY_T_COMPLEX': 'Complex',
-	'RUBY_T_RATIONAL': 'Rational',
-	'RUBY_T_NIL': 'Nil',
-	'RUBY_T_TRUE': 'True',
-	'RUBY_T_FALSE': 'False',
-	'RUBY_T_SYMBOL': 'Symbol',
-	'RUBY_T_FIXNUM': 'Fixnum',
-	'RUBY_T_UNDEF': 'Undef',
-	'RUBY_T_IMEMO': 'IMemo',
-	'RUBY_T_NODE': 'Node',
-	'RUBY_T_ICLASS': 'IClass',
-	'RUBY_T_ZOMBIE': 'Zombie',
+	'RUBY_T_NONE': 'T_NONE',
+	'RUBY_T_OBJECT': 'T_OBJECT',
+	'RUBY_T_CLASS': 'T_CLASS',
+	'RUBY_T_MODULE': 'T_MODULE',
+	'RUBY_T_FLOAT': 'T_FLOAT',
+	'RUBY_T_STRING': 'T_STRING',
+	'RUBY_T_REGEXP': 'T_REGEXP',
+	'RUBY_T_ARRAY': 'T_ARRAY',
+	'RUBY_T_HASH': 'T_HASH',
+	'RUBY_T_STRUCT': 'T_STRUCT',
+	'RUBY_T_BIGNUM': 'T_BIGNUM',
+	'RUBY_T_FILE': 'T_FILE',
+	'RUBY_T_DATA': 'T_DATA',
+	'RUBY_T_MATCH': 'T_MATCH',
+	'RUBY_T_COMPLEX': 'T_COMPLEX',
+	'RUBY_T_RATIONAL': 'T_RATIONAL',
+	'RUBY_T_NIL': 'T_NIL',
+	'RUBY_T_TRUE': 'T_TRUE',
+	'RUBY_T_FALSE': 'T_FALSE',
+	'RUBY_T_SYMBOL': 'T_SYMBOL',
+	'RUBY_T_FIXNUM': 'T_FIXNUM',
+	'RUBY_T_UNDEF': 'T_UNDEF',
+	'RUBY_T_IMEMO': 'T_IMEMO',
+	'RUBY_T_NODE': 'T_NODE',
+	'RUBY_T_ICLASS': 'T_ICLASS',
+	'RUBY_T_ZOMBIE': 'T_ZOMBIE',
 }
 
 def type_name(value):
 	"""Get the human-readable type name for a VALUE.
 	
 	Returns:
-		String like 'String', 'Array', 'Hash', etc., or 'Unknown'
+		String like 'T_STRING', 'T_ARRAY', 'T_HASH', etc., or 'Unknown(0x...)'
 	"""
 	type_flag = type_of(value)
 	
@@ -85,18 +85,14 @@ class RBasic:
 	
 	def __str__(self):
 		type_str = type_name(self.value)
-		return f"<{type_str}:0x{int(self.value):x}>"
+		return f"<{type_str}@0x{int(self.value):x}>"
 	
 	def print_to(self, terminal):
-		"""Return formatted basic object representation."""
+		"""Print formatted basic object representation."""
 		type_str = type_name(self.value)
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, type_str,
-			format.metadata, f':0x{addr:x}>',
-			format.reset
-		)
+		# Use print_type_tag for consistency with other types
+		terminal.print_type_tag(type_str, addr)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this basic object (no recursion)."""