Better output formatting.

Author: ioquatix

data/ruby/gdb/fiber.py

@@ -4,9 +4,12 @@
 import struct
 import json
 import os
+import sys
 
 # Import command parser
 import command
+import value
+import format
 
 # Global cache of fibers
 _fiber_cache = []
@@ -74,7 +77,13 @@ def initialize(self):
                 print("Make sure Ruby is fully initialized and the process is running.")
                 return False
 
-            self.objspace = self.vm_ptr['gc']['objspace']
+            # Ruby 3.3+ moved objspace into a gc struct
+            try:
+                self.objspace = self.vm_ptr['gc']['objspace']
+            except (gdb.error, KeyError):
+                # Ruby 3.2 and earlier have objspace directly in VM
+                self.objspace = self.vm_ptr['objspace']
+            
             if int(self.objspace) == 0:
                 print("Error: objspace is NULL")
                 print("Make sure the Ruby GC has been initialized.")
@@ -118,8 +127,13 @@ def iterate_heap(self):
 
         for i in range(allocated_pages):
             try:
-                # rb_darray is a struct with 'meta' and 'data[]' fields
-                page = self.objspace['heap_pages']['sorted']['data'][i]
+                # Ruby 3.3+ uses rb_darray with 'data' field, Ruby 3.2- uses direct pointer
+                try:
+                    page = self.objspace['heap_pages']['sorted']['data'][i]
+                except (gdb.error, KeyError):
+                    # Ruby 3.2 and earlier: sorted is a direct pointer array
+                    page = self.objspace['heap_pages']['sorted'][i]
+                
                 start = int(page['start'])
                 total_slots = int(page['total_slots'])
                 slot_size = int(page['slot_size'])
@@ -165,7 +179,7 @@ def find_all_fibers(self, limit=None):
 
         try:
             allocated_pages = int(self.objspace['heap_pages']['allocated_pages'])
-            print(f"Scanning {allocated_pages} heap pages...")
+            print(f"Scanning {allocated_pages} heap pages...", file=sys.stderr)
         except (gdb.MemoryError, gdb.error) as e:
             print(f"Error accessing heap pages: {e}")
             return fibers
@@ -183,7 +197,7 @@ def find_all_fibers(self, limit=None):
 
             # Print progress every 10000 objects
             if objects_checked % 10000 == 0:
-                print(f"  Checked {objects_checked} objects, found {len(fibers)} fiber(s)...")
+                print(f"  Checked {objects_checked} objects, found {len(fibers)} fiber(s)...", file=sys.stderr)
 
             # Check if it's T_DATA
             if (flags & 0x1f) != self.T_DATA:
@@ -196,14 +210,14 @@ def find_all_fibers(self, limit=None):
                 if typed_data['type'] == self.fiber_data_type:
                     fiber_ptr = typed_data['data'].cast(self._rb_fiber_struct_type)
                     fibers.append(fiber_ptr)
-                    print(f"  Found fiber #{len(fibers)} at {fiber_ptr}")
+                    print(f"  Found fiber #{len(fibers)} at {fiber_ptr}", file=sys.stderr)
             except (gdb.error, RuntimeError):
                 continue
 
         if limit and len(fibers) >= limit:
-            print(f"Scan complete: checked {objects_checked} objects (stopped at limit)")
+            print(f"Scan complete: checked {objects_checked} objects (stopped at limit)", file=sys.stderr)
         else:
-            print(f"Scan complete: checked {objects_checked} objects")
+            print(f"Scan complete: checked {objects_checked} objects", file=sys.stderr)
         return fibers
 
     def find_fiber_by_stack(self, stack_base):
@@ -235,18 +249,9 @@ def get_fiber_info(self, fiber):
         errinfo_str = None
         try:
             errinfo_val = ec['errinfo']
-            errinfo_int = int(errinfo_val)
-
-            # Check if errinfo is a real object (not a special constant)
-            # Special constants: Qfalse(0x0/0x0), Qnil(0x2/0x4/0x8), Qtrue(0x6/0x14), fixnums, etc.
-            # RB_SPECIAL_CONST_P checks: (obj == Qfalse) || RB_IMMEDIATE_P(obj)
-            # RB_IMMEDIATE_P checks: obj & 0x03 (fixnum or special)
-
-            # Simple check: if low bits indicate immediate/special, skip
-            # If it's a real object, low bits should be 0 (aligned pointer)
-            is_special = (errinfo_int & 0x03) != 0 or errinfo_int == 0
-
-            if not is_special:
+            
+            # Only process if it's a real object (not nil or other immediate value)
+            if value.is_object(errinfo_val) and not value.is_nil(errinfo_val):
                 errinfo = errinfo_val
                 # Try to get exception class and message
                 try:
@@ -256,9 +261,10 @@ def get_fiber_info(self, fiber):
                         errinfo_str = f"{exc_class}: {exc_msg}"
                     else:
                         errinfo_str = exc_class
-                except:
-                    errinfo_str = f"<exception:0x{errinfo_int:x}>"
-        except:
+                except Exception:
+                    # If we can't decode the exception, don't show it
+                    pass
+        except Exception:
             pass
 
         return {
@@ -301,8 +307,9 @@ def get_exception_class(self, exc_value):
                 pass
 
             return f"Exception(klass=0x{int(klass):x})"
-        except:
-            return "Exception"
+        except Exception:
+            # Don't return a fallback - let the caller handle it
+            raise
 
     def get_exception_message(self, exc_value):
         """Get the message from an exception object.
@@ -597,7 +604,7 @@ def value_to_string(self, value):
             return f"<error:{e}>"
 
 
-class RubyScanFibersCommand(gdb.Command):
+class RubyFiberScanHeapCommand(gdb.Command):
     """Scan heap and list all Ruby fibers.
 
     Usage: rb-fiber-scan-heap [limit] [--cache [filename]]
@@ -608,7 +615,7 @@ class RubyScanFibersCommand(gdb.Command):
     """
 
     def __init__(self):
-        super(RubyScanFibersCommand, self).__init__("rb-fiber-scan-heap", gdb.COMMAND_USER)
+        super(RubyFiberScanHeapCommand, self).__init__("rb-fiber-scan-heap", gdb.COMMAND_USER)
         self.debug = RubyFiberDebug()
 
     def save_cache(self, fibers, filename):
@@ -664,6 +671,9 @@ def load_cache(self, filename):
     def invoke(self, arg, from_tty):
         global _fiber_cache
 
+        # Create terminal for formatting
+        terminal = format.create_terminal(from_tty)
+
         # Parse arguments using the robust parser
         arguments = command.parse_arguments(arg if arg else "")
 
@@ -696,14 +706,11 @@ def invoke(self, arg, from_tty):
                 for i, fiber in enumerate(loaded_fibers):
                     try:
                         info = self.debug.get_fiber_info(fiber)
-                        print(f"Fiber #{i}: {info['address']}")
-                        print(f"  Status: {info['status']}")
-                        print(f"  Stack: base={info['stack_base']}, size={info['stack_size']}")
-                        print(f"  VM Stack: {info['vm_stack']}, size={info['vm_stack_size']}")
-                        print(f"  CFP: {info['cfp']}")
-                        print()
+                        self._print_fiber_info(terminal, i, info)
                     except:
-                        print(f"Fiber #{i}: 0x{int(fiber):x} (error reading info)")
+                        print(f"Fiber #{i}: ", end='')
+                        print(terminal.print(format.metadata, '<', format.type, '0x', format.metadata, f'{int(fiber):x}>', format.reset))
+                        print(f"  (error reading info)")
                         print()
 
                 print(f"Fibers cached. Use 'rb-fiber <index>' to inspect a specific fiber.")
@@ -716,9 +723,9 @@ def invoke(self, arg, from_tty):
             return
 
         if limit:
-            print(f"Scanning heap for first {limit} Fiber object(s)...")
+            print(f"Scanning heap for first {limit} Fiber object(s)...", file=sys.stderr)
         else:
-            print("Scanning heap for Fiber objects...")
+            print("Scanning heap for Fiber objects...", file=sys.stderr)
 
         fibers = self.debug.find_all_fibers(limit=limit)
 
@@ -732,14 +739,7 @@ def invoke(self, arg, from_tty):
 
         for i, fiber in enumerate(fibers):
             info = self.debug.get_fiber_info(fiber)
-            print(f"Fiber #{i}: {info['address']}")
-            print(f"  Status: {info['status']}")
-            if info.get('errinfo_str'):
-                print(f"  Exception: {info['errinfo_str']}")
-            print(f"  Stack: base={info['stack_base']}, size={info['stack_size']}")
-            print(f"  VM Stack: {info['vm_stack']}, size={info['vm_stack_size']}")
-            print(f"  CFP: {info['cfp']}")
-            print()
+            self._print_fiber_info(terminal, i, info)
 
         # Save to cache if requested
         if use_cache and fibers:
@@ -748,6 +748,36 @@ def invoke(self, arg, from_tty):
 
         print(f"Fibers cached. Use 'rb-fiber <index>' to inspect a specific fiber.")
 
+    def _print_fiber_info(self, terminal, index, info):
+        """Print formatted fiber information."""
+        # Print fiber index and address
+        print(f"Fiber #{index}: ", end='')
+        print(terminal.print(format.metadata, '<', format.type, '0x', format.metadata, f'{int(info["address"]):x}>', format.reset))
+        
+        # Print status
+        print(f"  Status: {info['status']}")
+        
+        # Print exception if present
+        if info.get('errinfo_str'):
+            print(f"  Exception: {info['errinfo_str']}")
+        
+        # Print Stack with formatted pointer
+        stack_base_val = info['stack_base']
+        stack_type = str(stack_base_val.type)
+        print(f"  Stack: ", end='')
+        print(terminal.print_type_tag(stack_type, int(stack_base_val), f' size={info["stack_size"]}'))
+        
+        # Print VM Stack with formatted pointer
+        vm_stack_val = info['vm_stack']
+        vm_stack_type = str(vm_stack_val.type)
+        print(f"  VM Stack: ", end='')
+        print(terminal.print_type_tag(vm_stack_type, int(vm_stack_val), f' size={info["vm_stack_size"]}'))
+        
+        # Print CFP
+        print(f"  CFP: ", end='')
+        print(terminal.print(format.metadata, '<', format.type, '0x', format.metadata, f'{int(info["cfp"]):x}>', format.reset))
+        print()
+
 
 class RubyFiberBacktraceCommand(gdb.Command):
     """Print backtrace for a Ruby fiber.
@@ -1505,7 +1535,7 @@ def invoke(self, arg, from_tty):
         if not self.debug.initialize():
             return
 
-        print("Scanning heap for Fiber objects...")
+        print("Scanning heap for Fiber objects...", file=sys.stderr)
         fibers = self.debug.find_all_fibers()
 
         print(f"Found {len(fibers)} fiber(s)\n")
@@ -1602,7 +1632,7 @@ def invoke(self, arg, from_tty):
 
         print(f"VM Stack for Fiber #{index}:")
         print(f"  Base: {info['vm_stack']}")
-        print(f"  Size: {info['vm_stack_size']} VALUEs ({info['vm_stack_size'] * 8} bytes)")
+        print(f"  Size: <{info['vm_stack_size']}> VALUEs (<{info['vm_stack_size'] * 8}> bytes)")
         print(f"  CFP:  {info['cfp']}")
         print()
 
@@ -2108,7 +2138,7 @@ def invoke(self, arg, from_tty):
             search_addr = None
 
         matches = []
-        print(f"\nScanning {len(_fiber_cache)} fiber(s)...\n")
+        print(f"\nScanning {len(_fiber_cache)} fiber(s)...\n", file=sys.stderr)
 
         for i, fiber in enumerate(_fiber_cache):
             try:
@@ -2222,7 +2252,7 @@ def invoke(self, arg, from_tty):
         print(f"C/Machine Stack for Fiber #{index}:")
         print(f"  Fiber: {fiber}")
         print(f"  Stack Base:    {info['stack_base']}")
-        print(f"  Stack Size:    {info['stack_size']} bytes")
+        print(f"  Stack Size:    <{info['stack_size']}> bytes")
 
         try:
             stack_start = ec['machine']['stack_start']
@@ -2231,7 +2261,7 @@ def invoke(self, arg, from_tty):
 
             print(f"  Stack Start:   {stack_start}")
             print(f"  Stack End:     {stack_end}")
-            print(f"  Stack Maxsize: {stack_maxsize}")
+            print(f"  Stack Maxsize: <{stack_maxsize}>")
 
             if int(stack_start) > int(stack_end):
                 stack_used = int(stack_start) - int(stack_end)
@@ -2337,7 +2367,7 @@ def invoke(self, arg, from_tty):
 
 
 # Register commands
-RubyScanFibersCommand()
+RubyFiberScanHeapCommand()
 RubyFiberCommand()
 RubyFiberIndexBacktraceCommand()
 RubyFiberVMStackCommand()