c2ffi4rb 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44d6bb3e8733edaee85ce7b13ed2a564d85b4cca68feda25659c85d4c42c5e92
-  data.tar.gz: e8d280a236be2c87a96808e18476a9d44cf3722a548bf03e52aab209e4665686
+  metadata.gz: 4573994a71db281f73abc92ea251ef6e9eb9a5911fbce28a41d75f6eeb73ecb6
+  data.tar.gz: 0eadc89a07d1d35cc9bb80a9f512146e30a5ce14586f7604ded6b5b18bbd15e7
 SHA512:
-  metadata.gz: fa28e2eefaeab88bdbda8730cfef082f9b69b3d169397ee1485333d20f9154b7525340c8e97008ca9342d5fe3e83fd32d2cce3d983cd216573b22bb6c50c60df
-  data.tar.gz: 8066189cba149c945267ffba5bd6608b7e863b314547a6c4f9aa0518b8292582df9669a6f600e62771a6c88f13f788f36ff2e0d6557eef5fd23d9864fe7e0671
+  metadata.gz: 72adc5c1ee2742339d5009b0af8053993194125414e1d1c9a26b64d326e074a8db2fbc6f7801ef16795a5119d9fa093b9be4ba9c43f4584bdc5f177930c892fa
+  data.tar.gz: 5a3ecb8bb976ffcb7427eed61c4285edaec9a8d9c4514be0bfc5f82578d9eb6c68984a1c22e92299f97cb7a9cae5c277488f29281b58a20b99b9af4724e832d3

data/README.md

@@ -2,6 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/c2ffi4rb.svg)](https://badge.fury.io/rb/c2ffi4rb)
 [![test](https://github.com/kojix2/c2ffi4rb/actions/workflows/ci.yml/badge.svg)](https://github.com/kojix2/c2ffi4rb/actions/workflows/ci.yml)
+[![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Fc2ffi4rb%2Flines)](https://tokei.kojix2.net/github/kojix2/c2ffi4rb)
 
 [c2ffi](https://github.com/rpav/c2ffi) - FFI binding generator - for Ruby
 
@@ -23,11 +24,19 @@ c2ffi -o macros.json example.h macros.h
 Next, use c2ffi4rb to generate ruby code.
 
 ```sh
-c2ffi4rb example.json macro.json > simple.rb
+c2ffi4rb example.json macros.json > simple.rb
 ```
 
 Finally, improve simple.rb manually to complete the binding.
 
+### Options
+
+```sh
+c2ffi4rb -h                    # Show help
+c2ffi4rb -v                    # Show version
+c2ffi4rb -t table.tsv file.json macros.json > output.rb  # Use type conversion table
+```
+
 ## Development
 
 To run tests, install [c2ffi][c2ffi], [Cairo][cairo], and [pkg-config][pkg-config] in advance.

data/exe/c2ffi4rb

@@ -40,10 +40,13 @@ end
 spec = []
 ARGV.each do |file|
   File.open(file) do |io|
-    spec += JSON.parse(io.read, Hash[:symbolize_names, true])
+    spec += JSON.parse(io.read, symbolize_names: true)
   end
 end
 
-spec += JSON.parse($stdin.read, Hash[:symbolize_names, true]) unless $stdin.tty?
+unless $stdin.tty?
+  stdin_content = $stdin.read
+  spec += JSON.parse(stdin_content, symbolize_names: true) if stdin_content && !stdin_content.strip.empty?
+end
 
 C2FFI4RB::BindGen.new(type_table).generate_bindings(spec)

data/lib/c2ffi4rb/bind_gen.rb

@@ -17,13 +17,17 @@ module C2FFI4RB
       ':signed-long' => ':long',
       ':unsigned-long' => ':ulong',
       ':unsigned-long-long' => ':ulong_long',
-      ':function-pointer' => ':pointer'
+      ':function-pointer' => ':pointer',
+      ':function' => ':pointer',
+      ':_Bool' => ':bool'
     }
 
+    # Class method to create instance and generate bindings
     def self.generate_bindings(arr)
       new.generate_bindings(arr)
     end
 
+    # Initialize with optional type conversion table
     def initialize(type_table = {})
       @type_table = DEFAULT_TYPE_TABLE.merge(type_table)
       @struct_type = []
@@ -33,6 +37,7 @@ module C2FFI4RB
       @typedefs = {}
     end
 
+    # Main entry point: process all forms and output Ruby FFI code
     def generate_bindings(arr)
       arr.each { |form| process_toplevel(form) }
       puts @toplevels.join("\n\n")
@@ -40,12 +45,16 @@ module C2FFI4RB
 
     private
 
+    # Process a single top-level form and add to output
     def process_toplevel(form)
       lines = parse_form(form)
       @toplevels << lines
     end
 
+    # Parse a form based on its tag and generate appropriate Ruby code
     def parse_form(form)
+      validate_form(form)
+
       case form[:tag]
       when 'typedef'         then generate_typedef(form)
       when 'const'           then generate_const(form)
@@ -54,44 +63,100 @@ module C2FFI4RB
       when 'struct', 'union' then generate_struct_or_union(form)
       when 'enum'            then generate_enum(form)
       else
-        raise "Unknown form: #{form[:tag]}"
+        raise ArgumentError,
+              "Unknown form tag: '#{form[:tag]}'. Expected one of: typedef, const, extern, function, struct, union, enum"
+      end
+    rescue StandardError => e
+      warn "[c2ffi4rb] Error processing form #{form.inspect}: #{e.message}"
+      "# [c2ffi4rb] Error: #{e.message}"
+    end
+
+    # Validate form structure before processing
+    def validate_form(form)
+      raise ArgumentError, 'Form must be a Hash' unless form.is_a?(Hash)
+      raise ArgumentError, 'Form must have a :tag key' unless form.key?(:tag)
+      raise ArgumentError, 'Form :tag cannot be nil or empty' if form[:tag].nil? || form[:tag].empty?
+
+      # Additional validation based on form type
+      case form[:tag]
+      when 'typedef', 'const', 'extern'
+        raise ArgumentError, "Form '#{form[:tag]}' must have a :name key" unless form.key?(:name)
+        raise ArgumentError, "Form '#{form[:tag]}' :name cannot be empty" if form[:name].nil? || form[:name].empty?
+      when 'function'
+        raise ArgumentError, "Form 'function' must have a :name key" unless form.key?(:name)
+
+        unless form.key?(:parameters) && form[:parameters].is_a?(Array)
+          raise ArgumentError,
+                "Form 'function' must have :parameters array"
+        end
+      when 'struct', 'union'
+        unless form.key?(:fields) && form[:fields].is_a?(Array)
+          raise ArgumentError,
+                "Form '#{form[:tag]}' must have :fields array"
+        end
+      when 'enum'
+        unless form.key?(:fields) && form[:fields].is_a?(Array)
+          raise ArgumentError,
+                "Form 'enum' must have :fields array"
+        end
+        raise ArgumentError, "Form 'enum' must have :id" unless form.key?(:id)
       end
     end
 
+    # Generate typedef declaration, handling different typedef types
     def generate_typedef(form)
       type = resolve_type(form[:type])
-      if @struct_type.include?(type)
-        name = define_struct(form[:name])
-        if name == type
-          "# #{name} = #{type}"
-        else
-          "#{name} = #{type}"
-        end
-      elsif type == ":{#{form[:name]}}"
-        warn "Ignoring self-referential typedef #{form[:name]}"
-      else
-        if @typedefs.has_key?(form[:name])
-          return "# typedef already defined? #{form[:name]}" if @typedefs[form[:name]] == type
 
-          warn "# Redefinition of #{form[:name]} from #{@typedefs[form[:name]]} to #{type}"
+      return handle_struct_typedef(form, type) if @struct_type.include?(type)
+      return handle_self_referential_typedef(form[:name]) if type == ":{#{form[:name]}}"
 
-        end
-        "typedef :pointer, :#{form[:name]} # #{type}" if form[:type][:tag] == ':array'
-        @typedefs[form[:name]] = type
-        "typedef #{type}, :#{form[:name]}"
+      handle_regular_typedef(form, type)
+    end
+
+    # Handle typedef for struct types
+    def handle_struct_typedef(form, type)
+      name = define_struct(form[:name])
+      name == type ? "# #{name} = #{type}" : "#{name} = #{type}"
+    end
+
+    # Handle self-referential typedef (ignore with warning)
+    def handle_self_referential_typedef(name)
+      warn "[c2ffi4rb] Ignoring self-referential typedef #{name}"
+      "# [c2ffi4rb] Ignoring self-referential typedef #{name}"
+    end
+
+    # Handle regular typedef declarations
+    def handle_regular_typedef(form, type)
+      name = form[:name]
+
+      if @typedefs.key?(name)
+        return "# [c2ffi4rb] typedef already defined? #{name}" if @typedefs[name] == type
+
+        warn "[c2ffi4rb] Redefinition of #{name} from #{@typedefs[name]} to #{type}"
+      end
+
+      @typedefs[name] = type
+
+      if form[:type][:tag] == ':array'
+        "typedef :pointer, :#{name} # #{type}"
+      else
+        "typedef #{type}, :#{name}"
       end
     end
 
+    # Generate constant definition
     def generate_const(form)
       type = resolve_type(form[:type])
       value = type == ':string' ? "\"#{form[:value]}\"" : form[:value]
       "#{form[:name].upcase} = #{value}"
     end
 
+    # Generate external variable attachment
     def generate_extern(form)
       "attach_variable :#{form[:name]}, :#{form[:name]}, #{resolve_type(form[:type])}"
     end
 
+    # Generate function attachment with parameters
     def generate_function(form)
       params = form[:parameters].map do |f|
         f[:type][:tag] == ':array' ? "  :pointer, # #{resolve_type(f[:type])}" : "  #{resolve_type(f[:type])},"
@@ -103,10 +168,12 @@ module C2FFI4RB
       FUNCTION
     end
 
+    # Generate struct or union definition
     def generate_struct_or_union(form)
       create_struct_definition(form)
     end
 
+    # Generate enum definition with fields
     def generate_enum(form)
       id = form[:id]
       if form[:name].empty?
@@ -123,6 +190,7 @@ module C2FFI4RB
       ENUM
     end
 
+    # Normalize struct name: handle anonymous structs and convert to CamelCase
     def normalize_struct_name(name)
       # Anonymous structs are given a name
       if name.empty?
@@ -142,6 +210,7 @@ module C2FFI4RB
       name
     end
 
+    # Register struct name to avoid redefinition
     def register_struct(name)
       if @struct_type.include? name
         false
@@ -150,6 +219,7 @@ module C2FFI4RB
       end
     end
 
+    # Normalize enum name: handle anonymous enums and add colon prefix
     def normalize_enum_name(name, id)
       # Anonymous enums are given a name
       name = "anon_enum_#{id}" if name.empty?
@@ -159,41 +229,56 @@ module C2FFI4RB
       name
     end
 
+    # Define struct name and register it
     def define_struct(name)
       name = normalize_struct_name(name)
       register_struct(name)
       name
     end
 
+    # Create complete struct/union definition with fields
     def create_struct_definition(form)
       name = normalize_struct_name(form[:name])
-      # FIXME: This is a hack to avoid redefining structs
-      return "# Already defined? #{name}" if @struct_type.include?(name)
+
+      if @struct_type.include?(name)
+        warn "[c2ffi4rb] Struct '#{name}' already defined, skipping redefinition"
+        return "# [c2ffi4rb] Already defined: #{name} (#{form[:tag]})"
+      end
 
       register_struct(name)
 
-      # FIXME: :FFI::Struct or FFI::Struct
-      type = form[:tag] == 'struct' ? '::FFI::Struct' : '::FFI::Union'
+      lines = build_struct_class_definition(form, name)
+      lines.join("\n")
+    end
 
-      lines = ["class #{name} < #{type}"]
+    # Build struct class definition with inheritance
+    def build_struct_class_definition(form, name)
+      base_class = form[:tag] == 'struct' ? '::FFI::Struct' : '::FFI::Union'
+      lines = ["class #{name} < #{base_class}"]
 
-      if form[:fields].any?
-        lines << '  layout \\'
-        anon_field_counter = 0
+      lines.concat(build_struct_layout(form[:fields])) if form[:fields].any?
 
-        form[:fields].each_with_index do |f, i|
-          field_name = f[:name].empty? ? "anon_field_#{anon_field_counter}" : f[:name]
-          anon_field_counter += 1 if f[:name].empty?
+      lines << 'end'
+      lines
+    end
 
-          sep = i == form[:fields].size - 1 ? '' : ','
-          lines << "    :#{field_name}, #{resolve_type(f[:type])}#{sep}"
-        end
+    # Build layout definition for struct fields
+    def build_struct_layout(fields)
+      lines = ['  layout \\']
+      anon_field_counter = 0
+
+      fields.each_with_index do |field, index|
+        field_name = field[:name].empty? ? "anon_field_#{anon_field_counter}" : field[:name]
+        anon_field_counter += 1 if field[:name].empty?
+
+        separator = index == fields.size - 1 ? '' : ','
+        lines << "    :#{field_name}, #{resolve_type(field[:type])}#{separator}"
       end
 
-      lines << 'end'
-      lines.join("\n")
+      lines
     end
 
+    # Resolve C type to Ruby FFI type
     def resolve_type(form)
       @type_table.fetch(form[:tag]) do
         case form[:tag]
@@ -208,6 +293,7 @@ module C2FFI4RB
       end
     end
 
+    # Resolve pointer type: handle char* as string, struct pointers
     def resolve_pointer_type(form)
       pointee = resolve_type(form[:type])
       if [':char', ':uchar'].include?(pointee)
@@ -219,28 +305,40 @@ module C2FFI4RB
       end
     end
 
+    # Resolve array type to FFI array format
     def resolve_array_type(form)
       "[#{resolve_type(form[:type])}, #{form[:size]}]"
     end
 
+    # Process enum type and return normalized name
     def normalize_enum_name_type(form)
       form[:name] = normalize_enum_name(form[:name], form[:id])
       process_toplevel(form)
       form[:name]
     end
 
+    # Process struct/union type and return normalized name
     def define_struct_or_union_type(form)
       form[:name] = normalize_struct_name(form[:name])
       process_toplevel(form)
       form[:name]
     end
 
+    # Resolve default/unknown types
     def resolve_default_type(form)
-      ## FIXME
-      st_name = normalize_struct_name(form[:tag])
+      tag = form[:tag]
+
+      # Check if it's a known struct type
+      st_name = normalize_struct_name(tag)
       return st_name if @struct_type.include?(st_name)
 
-      form[:tag].start_with?(':') ? form[:tag] : ":#{form[:tag]}"
+      # Handle primitive types and unknown types
+      if tag.start_with?(':')
+        tag
+      else
+        warn "[c2ffi4rb] Unknown type '#{tag}', treating as primitive type"
+        ":#{tag}"
+      end
     end
   end
 end

data/lib/c2ffi4rb/version.rb

@@ -1,3 +1,3 @@
 module C2FFI4RB
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: c2ffi4rb
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - kojix2
 - Ryan Pavlik
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,7 +70,6 @@ homepage: https://github.com/kojix2/c2ffi4rb
 licenses:
 - LGPL-2
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: C2FFI for Ruby-FFI
 test_files: []