c2ffi4rb 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f84bbae856ac0af2ff42f9f1da68092cd9f901d434583c832b697a9cb8f96a2
-  data.tar.gz: 2f3740e34e698dc85498622f17045170d6779f6f9252dbea4404b33b7cf9baf5
+  metadata.gz: 4cfce78845fc55372ded99151cccc949d8759e76e4e1a5bc081ca1175f8fde2e
+  data.tar.gz: 0bd91921a5f4a53cf7f9bdc5c4ac13390fd1d2797150b574ff6b84a092921f8e
 SHA512:
-  metadata.gz: '08d5bcec48ccd732ee87790d6eb1776321dc6023ba89896cc11dfa1ad85183c4a40d6213d8ed0eea6b5af417d8a419521133c6df9ac61ed99d52d67371d2791e'
-  data.tar.gz: a50a704ee9897de887565fe00fec384767ed100be5b400dea390c5c51b3023e8a0bcdd699b40a2cdd183155d11a044648ba72e9c5fd708d315a28b6824a8a0ce
+  metadata.gz: 3c93c4a27c799cd764a9be55c3cba58d54279fd4d56c0324ff92c6e155e394e94a9553f7f1f3b052436b8cbadeb96a4c513b7e009f5852b89c7c8a82147bb926
+  data.tar.gz: a2ddb54eed4af09b13df2a792f82e90c6d0ff6d798f4d48df19b889d0e14c43b66ef9deec3db9e50d2ea3b634b29346647b891067526e3dd02ab2e3385df5eb5

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

@@ -32,7 +32,7 @@ opts.on('-v', '--version', 'Show version') do
 end
 opts.parse!
 
-if ARGV.empty?
+if ARGV.empty? && $stdin.tty?
   warn opts
   exit 1
 end
@@ -44,6 +44,9 @@ ARGV.each do |file|
   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, Hash[: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

@@ -20,10 +20,12 @@ module C2FFI4RB
       ':function-pointer' => ':pointer'
     }
 
+    # 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 +35,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 +43,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 +61,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 +166,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 +188,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 +208,7 @@ module C2FFI4RB
       name
     end
 
+    # Register struct name to avoid redefinition
     def register_struct(name)
       if @struct_type.include? name
         false
@@ -150,6 +217,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 +227,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 +291,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 +303,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.4'
-end
+  VERSION = '0.0.6'
+end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: c2ffi4rb
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 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: 3.6.9
 specification_version: 4
 summary: C2FFI for Ruby-FFI
 test_files: []