c2ffi4rb 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a7511b48117f836d65991de99d5aeaf1a4dc5f4c9a9b99e4a9577fe415c941a
-  data.tar.gz: 3ee454048f080abae9a07ab3a11293d1af7a8f57518d6ae1ae12eaac6fd7d2ab
+  metadata.gz: 06ea739a36f2f4a6485ba3e65b6e91724eafed7f7440df1d26e7dfb5d5290897
+  data.tar.gz: 2eaf74991d02fd8b6e5beae79150cc1b40f5178c4bb27cf1277bf1bae0c744f2
 SHA512:
-  metadata.gz: b75a019a77528b7ceac118bc3108991c0cae5aba439ef330a1480fe6dd7390ce04e5780f7263dfab9dd626f98bf754166a9780272277267098e5e1871625d9fe
-  data.tar.gz: 3aa7cf6cf49094f75d9ff220c90e66edda3b80092fe96d087c1471b22f71d9d9c5b56a3f5bab914ec0db908222f90c7d0be26f2c9e6eac0a406b806b82f56936
+  metadata.gz: cdc2f8439c2722a83b3a82aac50821d4bf4f9be35efa52e30202e44417ab29b3a203896ddc955e0046637667d50751a354902955df92560c22a4b74a9939fc61
+  data.tar.gz: 5bb0f1ba5929c3ba8dbc4ca176701fddc05a3fb836ac218a1606b935335af035972354cfb4ba0950f5a19daf04457486801fca9ea868685070c1134b90e6938b

data/README.md

@@ -3,7 +3,6 @@
 [![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)
 
-
 [c2ffi](https://github.com/rpav/c2ffi) - FFI binding generator - for Ruby
 
 ## installation
@@ -14,21 +13,29 @@ gem install c2ffi4rb
 
 ## Usage
 
-First, produce a `spec` file using `c2ffi`:
+First, produce a `spec` file using `c2ffi`.
 
 ```sh
 c2ffi -M macros.h -o example.json example.h
-c2ffi -o macros.json macros.h
+c2ffi -o macros.json example.h macros.h
 ```
 
-Now you can generate a file manually with the included tool,
-`c2ffi-ruby`, as follows:
+Next, use c2ffi4rb to generate ruby code.
 
 ```sh
 c2ffi4rb example.json macro.json > simple.rb
 ```
 
-This produces the `simple.rb` file, as included.
+Finally, improve simple.rb manually to complete the binding.
+
+## Development
+
+To run tests, install [c2ffi][c2ffi], [Cairo][cairo], and [pkg-config][pkg-config] in advance.
+Then execute `rake test`.
+
+[cairo]: https://www.cairographics.org/ "Cairo"
+[pkg-config]: https://www.freedesktop.org/wiki/Software/pkg-config/ "freedesktop.org"
+[c2ffi]: https://github.com/rpav/c2ffi "GitHub"
 
 ## Licence
 

data/exe/c2ffi4rb

@@ -8,16 +8,28 @@
 require 'optparse'
 require 'c2ffi4rb'
 
-options = {}
-
-Version = C2FFI4RB::VERSION # Fixme
+type_table = {}
 
 opts = OptionParser.new
 opts.banner = 'Usage: c2ffi4rb [options] [file1, file2, ...]'
+opts.on('-t FILE', '--table FILE', 'Type conversion table TSV') do |file|
+  File.open(file) do |io|
+    io.each_line do |line|
+      next if line =~ /^#/
+
+      from, to = line.chomp.split("\t")
+      type_table[from] = to
+    end
+  end
+end
 opts.on('-h', '--help', 'Show this message') do
   puts opts
   exit
 end
+opts.on('-v', '--version', 'Show version') do
+  puts C2FFI4RB::VERSION
+  exit
+end
 opts.parse!
 
 if ARGV.empty?
@@ -32,4 +44,4 @@ ARGV.each do |file|
   end
 end
 
-C2FFI4RB::Parser.parse(spec)
+C2FFI4RB::BindGen.new(type_table).generate_bindings(spec)

data/lib/c2ffi4rb/bind_gen.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module C2FFI4RB
+  class BindGen
+    DEFAULT_TYPE_TABLE = {
+      ':signed-int' => ':int',
+      ':unsigned-int' => ':uint',
+      ':signed-char' => ':char',
+      ':unsigned-char' => ':uchar',
+      ':signed-short' => ':short',
+      ':unsigned-short' => ':ushort',
+      ':long-long' => ':long_long',
+      ':ulong-long' => ':ulong_long',
+      ':long-double' => ':long_double',
+      ':signed-long' => ':long',
+      ':unsigned-long' => ':ulong',
+      ':unsigned-long-long' => ':ulong_long',
+      ':function-pointer' => ':pointer'
+    }
+
+    def self.generate_bindings(arr)
+      new.generate_bindings(arr)
+    end
+
+    def initialize(type_table = {})
+      @type_table = DEFAULT_TYPE_TABLE.merge(type_table)
+      @struct_type = []
+      @toplevels = []
+      @anon_counter = 0
+      @anon_enum_ids = []
+      @typedefs = {}
+    end
+
+    def generate_bindings(arr)
+      arr.each { |form| process_toplevel(form) }
+      puts @toplevels.join("\n\n")
+    end
+
+    private
+
+    def process_toplevel(form)
+      lines = parse_form(form)
+      @toplevels << lines
+    end
+
+    def parse_form(form)
+      case form[:tag]
+      when 'typedef'         then generate_typedef(form)
+      when 'const'           then generate_const(form)
+      when 'extern'          then generate_extern(form)
+      when 'function'        then generate_function(form)
+      when 'struct', 'union' then generate_struct_or_union(form)
+      when 'enum'            then generate_enum(form)
+      else
+        raise "Unknown form: #{form[:tag]}"
+      end
+    end
+
+    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}"
+
+        end
+        "typedef :pointer, :#{form[:name]} # #{type}" if form[:type][:tag] == ':array'
+        @typedefs[form[:name]] = type
+        "typedef #{type}, :#{form[:name]}"
+      end
+    end
+
+    def generate_const(form)
+      type = resolve_type(form[:type])
+      value = type == ':string' ? "\"#{form[:value]}\"" : form[:value]
+      "#{form[:name].upcase} = #{value}"
+    end
+
+    def generate_extern(form)
+      "attach_variable :#{form[:name]}, :#{form[:name]}, #{resolve_type(form[:type])}"
+    end
+
+    def generate_function(form)
+      params = form[:parameters].map do |f|
+        f[:type][:tag] == ':array' ? "  :pointer, # #{resolve_type(f[:type])}" : "  #{resolve_type(f[:type])},"
+      end.join("\n")
+      <<~FUNCTION
+        attach_function '#{form[:name]}', [
+        #{params}
+        ], #{resolve_type(form[:'return-type'])}
+      FUNCTION
+    end
+
+    def generate_struct_or_union(form)
+      create_struct_definition(form)
+    end
+
+    def generate_enum(form)
+      id = form[:id]
+      if form[:name].empty?
+        return "# Already defined? anon_type_#{id}" if @anon_enum_ids.include?(id)
+
+        @anon_enum_ids << id
+      end
+      name = normalize_enum_name(form[:name], form[:id])
+      fields = form[:fields].map { |f| "  :#{f[:name]}, #{f[:value]}," }.join("\n")
+      <<~ENUM
+        enum #{name}, [
+        #{fields}
+        ]
+      ENUM
+    end
+
+    def normalize_struct_name(name)
+      # Anonymous structs are given a name
+      if name.empty?
+        @anon_counter += 1
+        name = "Anon_Type_#{@anon_counter}"
+        return name
+      end
+
+      # Do not allow names that start with an underscore
+      name = 'C' + name if name.start_with?('_')
+
+      # Convert snake_case to CamelCase
+      name = name[0].upcase + name[1..-1]
+
+      name.gsub!(/_([a-z])/) { |m| "#{m[1].upcase}" }
+
+      name
+    end
+
+    def register_struct(name)
+      if @struct_type.include? name
+        false
+      else
+        @struct_type << name
+      end
+    end
+
+    def normalize_enum_name(name, id)
+      # Anonymous enums are given a name
+      name = "anon_enum_#{id}" if name.empty?
+
+      # All enums are prefixed with a colon
+      name = ":#{name}" unless name.start_with?(':')
+      name
+    end
+
+    def define_struct(name)
+      name = normalize_struct_name(name)
+      register_struct(name)
+      name
+    end
+
+    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)
+
+      register_struct(name)
+
+      # FIXME: :FFI::Struct or FFI::Struct
+      type = form[:tag] == 'struct' ? '::FFI::Struct' : '::FFI::Union'
+
+      lines = ["class #{name} < #{type}"]
+
+      if form[:fields].any?
+        lines << '  layout \\'
+        anon_field_counter = 0
+
+        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?
+
+          sep = i == form[:fields].size - 1 ? '' : ','
+          lines << "    :#{field_name}, #{resolve_type(f[:type])}#{sep}"
+        end
+      end
+
+      lines << 'end'
+      lines.join("\n")
+    end
+
+    def resolve_type(form)
+      @type_table.fetch(form[:tag]) do
+        case form[:tag]
+        when ':pointer'          then resolve_pointer_type(form)
+        when ':array'            then resolve_array_type(form)
+        when ':struct', ':union' then define_struct(form[:name])
+        when ':enum'             then normalize_enum_name(form[:name], form[:id])
+        when 'struct', 'union'   then define_struct_or_union_type(form)
+        when 'enum'              then normalize_enum_name_type(form)
+        else resolve_default_type(form)
+        end
+      end
+    end
+
+    def resolve_pointer_type(form)
+      pointee = resolve_type(form[:type])
+      if [':char', ':uchar'].include?(pointee)
+        ':string'
+      elsif @struct_type.include?(pointee)
+        "#{pointee}.ptr"
+      else
+        ':pointer'
+      end
+    end
+
+    def resolve_array_type(form)
+      "[#{resolve_type(form[:type])}, #{form[:size]}]"
+    end
+
+    def normalize_enum_name_type(form)
+      form[:name] = normalize_enum_name(form[:name], form[:id])
+      process_toplevel(form)
+      form[:name]
+    end
+
+    def define_struct_or_union_type(form)
+      form[:name] = normalize_struct_name(form[:name])
+      process_toplevel(form)
+      form[:name]
+    end
+
+    def resolve_default_type(form)
+      ## FIXME
+      st_name = normalize_struct_name(form[:tag])
+      return st_name if @struct_type.include?(st_name)
+
+      form[:tag].start_with?(':') ? form[:tag] : ":#{form[:tag]}"
+    end
+  end
+end

data/lib/c2ffi4rb/version.rb

@@ -1,3 +1,3 @@
 module C2FFI4RB
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/lib/c2ffi4rb.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'c2ffi4rb/version'
-require_relative 'c2ffi4rb/parser'
+require_relative 'c2ffi4rb/bind_gen'
 
 module C2FFI4RB
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: c2ffi4rb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - kojix2
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-18 00:00:00.000000000 Z
+date: 2024-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,7 +65,7 @@ files:
 - README.md
 - exe/c2ffi4rb
 - lib/c2ffi4rb.rb
-- lib/c2ffi4rb/parser.rb
+- lib/c2ffi4rb/bind_gen.rb
 - lib/c2ffi4rb/version.rb
 homepage: https://github.com/kojix2/c2ffi4rb
 licenses:
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: C2FFI for Ruby-FFI

data/lib/c2ffi4rb/parser.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module C2FFI4RB
-  class Parser
-    TYPE_TABLE = {
-      ':unsigned-int' => ':uint',
-      ':unsigned-char' => ':uchar',
-      ':unsigned-long' => ':ulong',
-      ':function-pointer' => ':pointer'
-    }
-
-    def self.parse(arr)
-      Parser.new.parse(arr)
-    end
-
-    def initialize
-      @struct_type = []
-      @toplevels = []
-      @anon_counter = 0
-    end
-
-    def parse(arr)
-      arr.each do |form|
-        parse_toplevel(form)
-      end
-
-      puts @toplevels.join("\n\n")
-    end
-
-    private
-
-    def parse_toplevel(form)
-      lines = \
-        case form[:tag]
-        when 'typedef'
-          type = parse_type(form[:type])
-
-          # I don't think typedef works right with structs, so assign
-          if @struct_type.include?(type)
-            name = add_struct(form[:name])
-            "#{name} = #{type}"
-          else
-            "typedef #{type}, :#{form[:name]}"
-          end
-
-        when 'const'
-          type = parse_type(form[:type])
-          if type == ':string'
-            "#{form[:name].upcase} = \"#{form[:value]}\""
-          else
-            "#{form[:name].upcase} = #{form[:value]}"
-          end
-
-        when 'extern'
-          'attach_variable ' \
-              ":#{form[:name]}, :#{form[:name]}, #{parse_type(form[:type])}"
-
-        when 'function'
-          l = []
-          l << "attach_function '#{form[:name]}', ["
-          form[:parameters].each do |f|
-            l << "  #{parse_type(f[:type])},"
-          end
-          l << "], #{parse_type(form['return-type'.intern])}"
-          #          emacs doesn't like :"foo" ---^
-          l.join("\n")
-
-        when 'struct', 'union'
-          make_struct(form)
-
-        when 'enum'
-          name = add_enum(form[:name])
-          l = []
-          l << "enum #{name}, ["
-          form[:fields].each do |f|
-            l << "  :#{f[:name]}, #{f[:value]},"
-          end
-          l << ']'
-          l.join("\n")
-        end
-
-      @toplevels << lines
-      nil
-    end
-
-    def add_struct(name)
-      # Anonymous structs are given a name
-      if name == ''
-        @anon_counter += 1
-        name = "Anon_Type_#{@anon_counter}"
-        return name
-      end
-
-      # Do not allow names that start with an underscore
-      name = 'C' + name if name.start_with? '_'
-
-      # Convert snake_case to CamelCase
-      name = name.capitalize.gsub!(/_([a-z])/) { |m| "_#{m[1].upcase}" }
-
-      @struct_type << name unless @struct_type.include? name
-      name
-    end
-
-    def add_enum(name)
-      # Anonymous enums are given a name
-      if name == ''
-        @anon_counter += 1
-        name = ':anon_type_' + @anon_counter.to_s
-        return name
-      end
-
-      # All enums are prefixed with a colon
-      name = ":#{name}" unless name.start_with? ':'
-      name
-    end
-
-    def make_struct(form)
-      name = add_struct(form[:name])
-
-      type = if form[:tag] == ':struct'
-               'FFI::Struct'
-             else
-               'FFI::Union'
-             end
-
-      l = []
-      l << "class #{name} < #{type}"
-
-      if form[:fields].length.positive?
-        l << '  layout \\'
-        size = form[:fields].length
-        form[:fields].each_with_index do |f, i|
-          sep = i >= (size - 1) ? '' : ','
-          l << "    :#{f[:name]}, #{parse_type(f[:type])}#{sep}"
-        end
-      end
-      l << 'end'
-      l.join("\n")
-    end
-
-    def parse_type(form)
-      tt = TYPE_TABLE[form[:tag]]
-      return tt if tt
-
-      case form[:tag]
-      when ':pointer'
-        pointee = parse_type(form[:type])
-        if [':char', ':uchar'].include?(pointee)
-          ':string'
-        elsif @struct_type.include?(pointee)
-          "#{pointee}.ptr"
-        else
-          ':pointer'
-        end
-
-      when ':array'
-        "[#{parse_type(form[:type])}, #{form[:size]}]"
-
-      when ':struct', ':union'
-        add_struct(form[:name])
-
-      when ':enum'
-        add_enum(form[:name])
-
-      when 'enum'
-        form[:name] = add_enum(form[:name])
-        parse_toplevel(form)
-        form[:name]
-
-      when 'struct', 'union'
-        form[:name] = add_struct(form[:name])
-        parse_toplevel(form)
-        form[:name]
-
-      else
-        # All non-Classy types are :-prefixed?
-        if form[:tag][0] != ':'
-          ":#{form[:tag]}"
-        else
-          form[:tag]
-        end
-      end
-    end
-  end
-end