unibuf 0.1.0 → 0.1.2

data/lib/unibuf/parsers/capnproto/list_reader.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "segment_reader"
+require_relative "pointer_decoder"
+require_relative "struct_reader"
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Reader for Cap'n Proto list data
+      # Lists can contain primitives, pointers, or structs
+      class ListReader
+        attr_reader :segment_reader, :segment_id, :word_offset, :element_size,
+                    :element_count
+
+        # Initialize list reader
+        # @param segment_reader [SegmentReader] Segment reader
+        # @param segment_id [Integer] Segment containing the list
+        # @param word_offset [Integer] Word offset of list start
+        # @param element_size [Integer] Element size code
+        # @param element_count [Integer] Number of elements
+        def initialize(segment_reader, segment_id, word_offset, element_size,
+element_count)
+          @segment_reader = segment_reader
+          @segment_id = segment_id
+          @word_offset = word_offset
+          @element_size = element_size
+          @element_count = element_count
+        end
+
+        # Get list length
+        # @return [Integer]
+        def length
+          @element_count
+        end
+        alias size length
+
+        # Read an element as a primitive value
+        # @param index [Integer] Element index
+        # @return [Object] Element value
+        def read_primitive(index, type = :uint64)
+          raise ArgumentError, "Index out of bounds" if index >= @element_count
+
+          case @element_size
+          when PointerDecoder::ELEMENT_SIZE_VOID
+            nil
+          when PointerDecoder::ELEMENT_SIZE_BIT
+            read_bit(index)
+          when PointerDecoder::ELEMENT_SIZE_BYTE
+            read_byte(index, type)
+          when PointerDecoder::ELEMENT_SIZE_TWO_BYTES
+            read_two_bytes(index, type)
+          when PointerDecoder::ELEMENT_SIZE_FOUR_BYTES
+            read_four_bytes(index, type)
+          when PointerDecoder::ELEMENT_SIZE_EIGHT_BYTES
+            read_eight_bytes(index, type)
+          else
+            raise "Cannot read primitive from this list type"
+          end
+        end
+
+        # Read an element as a pointer
+        # @param index [Integer] Element index
+        # @return [Hash, nil] Decoded pointer
+        def read_pointer(index)
+          raise ArgumentError, "Index out of bounds" if index >= @element_count
+          raise "List elements are not pointers" unless @element_size == PointerDecoder::ELEMENT_SIZE_POINTER
+
+          pointer_word = @segment_reader.read_word(@segment_id,
+                                                   @word_offset + index)
+          return nil if pointer_word.zero?
+
+          PointerDecoder.decode(pointer_word)
+        end
+
+        # Read an element as a struct
+        # @param index [Integer] Element index
+        # @return [StructReader] Struct reader
+        def read_struct(index)
+          raise ArgumentError, "Index out of bounds" if index >= @element_count
+
+          if @element_size == PointerDecoder::ELEMENT_SIZE_INLINE_COMPOSITE
+            read_inline_composite_struct(index)
+          else
+            raise "List elements are not structs"
+          end
+        end
+
+        # Read text (UTF-8 string)
+        # @return [String]
+        def read_text
+          raise "Not a text list" unless @element_size == PointerDecoder::ELEMENT_SIZE_BYTE
+
+          # Text is a byte list with null terminator
+          bytes = (0...@element_count).map { |i| read_byte(i, :uint8) }
+          # Remove null terminator
+          bytes.pop if bytes.last.zero?
+          bytes.pack("C*").force_encoding("UTF-8")
+        end
+
+        # Read data (binary blob)
+        # @return [String]
+        def read_data
+          raise "Not a data list" unless @element_size == PointerDecoder::ELEMENT_SIZE_BYTE
+
+          bytes = (0...@element_count).map { |i| read_byte(i, :uint8) }
+          bytes.pack("C*")
+        end
+
+        private
+
+        def read_bit(index)
+          word_index = index / 64
+          bit_index = index % 64
+          word = @segment_reader.read_word(@segment_id,
+                                           @word_offset + word_index)
+          (word >> bit_index).allbits?(1)
+        end
+
+        def read_byte(index, type)
+          word_index = index / 8
+          byte_index = index % 8
+          word = @segment_reader.read_word(@segment_id,
+                                           @word_offset + word_index)
+
+          value = (word >> (byte_index * 8)) & 0xFF
+
+          # Convert to signed if  needed
+          if type == :int8
+            value >= 128 ? value - 256 : value
+          else
+            value
+          end
+        end
+
+        def read_two_bytes(index, type)
+          word_index = index / 4
+          half_word_index = index % 4
+          word = @segment_reader.read_word(@segment_id,
+                                           @word_offset + word_index)
+
+          value = (word >> (half_word_index * 16)) & 0xFFFF
+
+          # Convert to signed if needed
+          if type == :int16
+            value >= 32768 ? value - 65536 : value
+          else
+            value
+          end
+        end
+
+        def read_four_bytes(index, type)
+          word_index = index / 2
+          dword_index = index % 2
+          word = @segment_reader.read_word(@segment_id,
+                                           @word_offset + word_index)
+
+          value = (word >> (dword_index * 32)) & 0xFFFFFFFF
+
+          case type
+          when :int32
+            value >= 2147483648 ? value - 4294967296 : value
+          when :float32
+            [value].pack("L").unpack1("f")
+          else
+            value
+          end
+        end
+
+        def read_eight_bytes(index, type)
+          word = @segment_reader.read_word(@segment_id, @word_offset + index)
+
+          case type
+          when :int64
+            word >= 9223372036854775808 ? word - 18446744073709551616 : word
+          when :float64
+            [word].pack("Q").unpack1("d")
+          else
+            word
+          end
+        end
+
+        def read_inline_composite_struct(index)
+          # For inline composite, first word is a tag describing struct size
+          tag_word = @segment_reader.read_word(@segment_id, @word_offset)
+          tag = PointerDecoder.decode(tag_word)
+
+          raise "Invalid inline composite tag" unless tag[:type] == :struct
+
+          data_words = tag[:data_words]
+          pointer_words = tag[:pointer_words]
+          struct_size = data_words + pointer_words
+
+          # Structs start after the tag
+          struct_offset = @word_offset + 1 + (index * struct_size)
+
+          StructReader.new(
+            @segment_reader,
+            @segment_id,
+            struct_offset,
+            data_words,
+            pointer_words,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/parsers/capnproto/pointer_decoder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Decoder for Cap'n Proto pointer words
+      # Pointers are 64-bit words that encode type, offset, and size information
+      class PointerDecoder
+        # Pointer type constants (bits 0-1)
+        POINTER_TYPE_STRUCT = 0
+        POINTER_TYPE_LIST = 1
+        POINTER_TYPE_FAR = 2
+        POINTER_TYPE_OTHER = 3
+
+        # List element size constants (bits 32-34 for list pointers)
+        ELEMENT_SIZE_VOID = 0
+        ELEMENT_SIZE_BIT = 1
+        ELEMENT_SIZE_BYTE = 2
+        ELEMENT_SIZE_TWO_BYTES = 3
+        ELEMENT_SIZE_FOUR_BYTES = 4
+        ELEMENT_SIZE_EIGHT_BYTES = 5
+        ELEMENT_SIZE_POINTER = 6
+        ELEMENT_SIZE_INLINE_COMPOSITE = 7
+
+        # Decode a pointer word
+        # @param word [Integer] 64-bit pointer word
+        # @return [Hash] Decoded pointer information
+        def self.decode(word)
+          return null_pointer if word.zero?
+
+          pointer_type = word & 0x3
+
+          case pointer_type
+          when POINTER_TYPE_STRUCT
+            decode_struct_pointer(word)
+          when POINTER_TYPE_LIST
+            decode_list_pointer(word)
+          when POINTER_TYPE_FAR
+            decode_far_pointer(word)
+          when POINTER_TYPE_OTHER
+            decode_other_pointer(word)
+          end
+        end
+
+        # Check if pointer is null
+        # @param word [Integer] 64-bit pointer word
+        # @return [Boolean]
+        def self.null_pointer?(word)
+          word.zero?
+        end
+
+        private_class_method def self.null_pointer
+          {
+            type: :null,
+            null: true,
+          }
+        end
+
+        # Decode struct pointer
+        # Bits:
+        # 0-1: Type = 0 (struct)
+        # 2-31: Signed offset in words (30 bits)
+        # 32-47: Data section size in words (16 bits)
+        # 48-63: Pointer section size in words (16 bits)
+        private_class_method def self.decode_struct_pointer(word)
+          # Extract offset (bits 2-31, signed)
+          offset_raw = (word >> 2) & 0x3FFFFFFF
+          # Convert to signed 30-bit integer
+          offset = offset_raw >= 0x20000000 ? offset_raw - 0x40000000 : offset_raw
+
+          # Extract data section size (bits 32-47)
+          data_size = (word >> 32) & 0xFFFF
+
+          # Extract pointer section size (bits 48-63)
+          pointer_size = (word >> 48) & 0xFFFF
+
+          {
+            type: :struct,
+            offset: offset,
+            data_words: data_size,
+            pointer_words: pointer_size,
+          }
+        end
+
+        # Decode list pointer
+        # Bits:
+        # 0-1: Type = 1 (list)
+        # 2-31: Signed offset in words (30 bits)
+        # 32-34: Element size (3 bits)
+        # 35-63: Element count (29 bits)
+        private_class_method def self.decode_list_pointer(word)
+          # Extract offset (bits 2-31, signed)
+          offset_raw = (word >> 2) & 0x3FFFFFFF
+          offset = offset_raw >= 0x20000000 ? offset_raw - 0x40000000 : offset_raw
+
+          # Extract element size (bits 32-34)
+          element_size = (word >> 32) & 0x7
+
+          # Extract element count (bits 35-63)
+          element_count = (word >> 35) & 0x1FFFFFFF
+
+          {
+            type: :list,
+            offset: offset,
+            element_size: element_size,
+            element_count: element_count,
+            element_size_name: element_size_name(element_size),
+          }
+        end
+
+        # Decode far pointer
+        # Bits:
+        # 0-1: Type = 2 (far)
+        # 2: Landing pad flag (0 = normal, 1 = double-far)
+        # 3-31: Offset in words within target segment (29 bits)
+        # 32-63: Target segment ID (32 bits)
+        private_class_method def self.decode_far_pointer(word)
+          # Extract landing pad flag (bit 2)
+          double_far = (word >> 2).allbits?(0x1)
+
+          # Extract offset (bits 3-31)
+          offset = (word >> 3) & 0x1FFFFFFF
+
+          # Extract segment ID (bits 32-63)
+          segment_id = (word >> 32) & 0xFFFFFFFF
+
+          {
+            type: :far,
+            offset: offset,
+            segment_id: segment_id,
+            double_far: double_far,
+          }
+        end
+
+        # Decode other pointer (capability)
+        private_class_method def self.decode_other_pointer(word)
+          # Extract capability index (bits 32-63)
+          capability_index = (word >> 32) & 0xFFFFFFFF
+
+          {
+            type: :capability,
+            index: capability_index,
+          }
+        end
+
+        # Get element size name
+        private_class_method def self.element_size_name(size)
+          case size
+          when ELEMENT_SIZE_VOID then :void
+          when ELEMENT_SIZE_BIT then :bit
+          when ELEMENT_SIZE_BYTE then :byte
+          when ELEMENT_SIZE_TWO_BYTES then :two_bytes
+          when ELEMENT_SIZE_FOUR_BYTES then :four_bytes
+          when ELEMENT_SIZE_EIGHT_BYTES then :eight_bytes
+          when ELEMENT_SIZE_POINTER then :pointer
+          when ELEMENT_SIZE_INLINE_COMPOSITE then :inline_composite
+          else :unknown
+          end
+        end
+      end
+    end
+  end
+end