c2ffi4rb 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86a593339fb44c53b753ecbae5120b0d3cd67363f8899b8122fa100f800d1fcc
-  data.tar.gz: c2a2c0ab90ce7e1307d706b268778267237691a56ce71491bfe2503b27b3f8c8
+  metadata.gz: 9471bfff4cabf71daa4a888c294218eb8b74200168b35584cb166771a062fe4a
+  data.tar.gz: f84570b4abbae4fd1eba8e1ee76554da81aa621a92be31014748ac5e5aa5e20e
 SHA512:
-  metadata.gz: 42260432b9a7267183c23e4ab79303257e25445c5ea5be46bcf61d7d27b43e8283144741bcf6eb95a9fd66ac7e3094067e68165648fa6fe13594459b588670f4
-  data.tar.gz: '08281db0ccbaedba8fb39908f343c69dbe348da5e8e49071ded01c382468962b84b308b59c6a57c707586a94dba6b5fb86937d48e0c3a1f37486ae1b52b29bdd'
+  metadata.gz: a2443c99c551de4a8c42a977604c4654e75a0f9f9c754395fb894bdcf488d388e1523aac2a0862126baf17b7cda86966e902f71bbf0ecd2db54f8a68df1e2da8
+  data.tar.gz: ce7450668d888f8fc575e56a8a9be650ea2862044feac2e49e0a94f5f50834576cb3a3a46c4f6ac05ea056942e6b9924401342b87876941ebfe97dddd45c5e02

data/README.md

@@ -1,8 +1,11 @@
 # c2ffi4rb
 
+[![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
+## installation
 
 ```sh
 gem install c2ffi4rb
@@ -10,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

@@ -6,19 +6,18 @@
 ## your build system.  But this is how you can use it.
 
 require 'optparse'
-require 'json'
 require 'c2ffi4rb'
 
-options = {}
-
-Version = C2FFI4RB::VERSION # Fixme
-
 opts = OptionParser.new
 opts.banner = 'Usage: c2ffi4rb [options] [file1, file2, ...]'
 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?
@@ -33,4 +32,4 @@ ARGV.each do |file|
   end
 end
 
-C2FFI4RB::Parser.parse(spec)
+C2FFI4RB::BindGen.generate_bindings(spec)

data/lib/c2ffi4rb/bind_gen.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module C2FFI4RB
+  class BindGen
+    TYPE_TABLE = {
+      ':unsigned-int' => ':uint',
+      ':unsigned-char' => ':uchar',
+      ':unsigned-short' => ':ushort',
+      ':long-long' => ':long_long',
+      ':unsigned-long' => ':ulong',
+      ':unsigned-long-long' => ':ulong_long',
+      ':function-pointer' => ':pointer'
+    }.freeze
+
+    def self.generate_bindings(arr)
+      new.generate_bindings(arr)
+    end
+
+    def initialize
+      @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])
+        "#{name} = #{type}"
+      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
+        @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 { |f| "  #{resolve_type(f[:type])}," }.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])
+      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)
+      # Anonymous enums are given a name
+      if name.empty?
+        @anon_counter += 1
+        name = "anon_type_#{@anon_counter}"
+      end
+
+      # 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)
+
+      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])
+        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])
+      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)
+      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.0'
+  VERSION = '0.0.2'
 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,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: c2ffi4rb
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.2
 platform: ruby
 authors:
 - kojix2
 - Ryan Pavlik
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2024-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,13 +65,13 @@ 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:
 - LGPL-2
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +86,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: C2FFI for Ruby-FFI
 test_files: []

data/lib/c2ffi4rb/parser.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-module C2FFI4RB
-  class Parser
-    TYPE_TABLE = {
-      "unsigned-int": :uint,
-      "unsigned-char": :uchar,
-      "unsigned-long": :ulong,
-      "function-pointer": :pointer
-    }.freeze
-
-    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|
-        s = parse_toplevel(form)
-        @toplevels << s if s
-      end
-
-      @toplevels.each do |t|
-        puts
-        case t
-        when String
-          puts "#{t}"
-        when Array
-          t.each do |l|
-            puts "#{l}"
-          end
-        end
-      end
-    end
-
-    private
-
-    def parse_toplevel(form)
-      case form[:tag]
-      when 'typedef'
-        type = parse_type(form[:type])
-
-        # I don't think typedef works right with structs, so assign
-        if @struct_type[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'
-        s = []
-        s << "attach_function '#{form[:name]}', ["
-        form[:parameters].each do |f|
-          s << "  #{parse_type(f[:type])},"
-        end
-        s << "], #{parse_type(form['return-type'.intern])}"
-      # emacs doesn't like :"foo" ---^
-
-      when 'struct', 'union'
-        name = add_struct(form[:name])
-        make_struct(form)
-
-      when 'enum'
-        name = add_enum(form[:name])
-        s = []
-        s << "enum #{name}, ["
-        form[:fields].each do |f|
-          s << "  :#{f[:name]}, #{f[:value]},"
-        end
-        s << ']'
-      end
-    end
-
-    def add_struct(name)
-      if name == ''
-        @anon_counter += 1
-        name = 'Anon_Type_' + @anon_counter.to_s
-        return name
-      end
-
-      name = 'C' + name if name.start_with? '_'
-
-      name = name.capitalize.gsub!(/_([a-z])/) { |m| "_#{m[1].upcase}" }
-      @struct_type[name] = true
-      name
-    end
-
-    def add_enum(name)
-      if name == ''
-        @anon_counter += 1
-        name = ':anon_type_' + @anon_counter.to_s
-        return name
-      end
-
-      if name[0] != ':'
-        ":#{name}"
-      else
-        name
-      end
-    end
-
-    def make_struct(form)
-      name = add_struct(form[:name])
-
-      type = if form[:tag] == ':struct'
-               'FFI::Struct'
-             else
-               'FFI::Union'
-             end
-
-      s = []
-      s << "class #{name} < #{type}"
-
-      if form[:fields].length.positive?
-        s << '  layout \\'
-        size = form[:fields].length
-        sep = ','
-        form[:fields].each_with_index do |f, i|
-          sep = '' if i >= (size - 1)
-          s << "    :#{f[:name]}, #{parse_type(f[:type])}#{sep}"
-        end
-      end
-      s << 'end'
-    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[pointee]
-          "#{@struct_type[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