jolt-ruby 1.0.0

data/generator/generate.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "ffi/clang"
+
+class BindingGenerator
+  ROOT = File.expand_path("..", __dir__)
+  HEADER = File.join(ROOT, "ext", "joltc", "include", "joltc.h")
+  RUBY_OUTPUT = File.join(ROOT, "lib", "jolt", "native", "generated.rb")
+  PROBE_OUTPUT = File.join(__dir__, "layout_probe.cpp")
+
+  INTEGER_TYPES = {
+    type_char_s: :int8,
+    type_schar: :int8,
+    type_uchar: :uint8,
+    type_short: :int16,
+    type_ushort: :uint16,
+    type_int: :int32,
+    type_uint: :uint32,
+    type_long: :long,
+    type_ulong: :ulong,
+    type_longlong: :int64,
+    type_ulonglong: :uint64
+  }.freeze
+
+  def initialize
+    @translation_unit = FFI::Clang::Index.new.parse_translation_unit(
+      HEADER, %w[-x c++ -std=c++17]
+    )
+    errors = @translation_unit.diagnostics.select { |diagnostic| diagnostic.severity >= 3 }
+    abort errors.map(&:spelling).join("\n") unless errors.empty?
+  end
+
+  def run(check: false)
+    outputs = {
+      RUBY_OUTPUT => render_ruby,
+      PROBE_OUTPUT => render_probe
+    }
+    if check
+      stale = outputs.filter_map { |path, content| path unless File.binread(path) == content }
+      abort "generated bindings are stale: #{stale.join(", ")}" unless stale.empty?
+    else
+      outputs.each { |path, content| File.binwrite(path, content) }
+    end
+  end
+
+  private
+
+  def declarations(kind)
+    @translation_unit.cursor.each.filter_map do |cursor, _parent|
+      cursor if cursor.kind == kind && cursor.location.file.to_s == HEADER
+    end
+  end
+
+  def records
+    declarations(:cursor_struct)
+      .select { |cursor| cursor.definition? && !cursor.spelling.empty? }
+      .uniq(&:spelling)
+  end
+
+  def functions
+    declarations(:cursor_function).uniq(&:spelling)
+  end
+
+  def fields(record)
+    record.each(false).filter_map do |cursor, _parent|
+      cursor if cursor.kind == :cursor_field_decl
+    end
+  end
+
+  def sorted_records
+    remaining = records.to_h { |record| [record.spelling, record] }
+    sorted = []
+    until remaining.empty?
+      ready = remaining.values.select do |record|
+        record_dependencies(record).none? { |name| remaining.key?(name) }
+      end
+      abort "cyclic struct dependency: #{remaining.keys.join(", ")}" if ready.empty?
+
+      ready.sort_by(&:spelling).each do |record|
+        sorted << record
+        remaining.delete(record.spelling)
+      end
+    end
+    sorted
+  end
+
+  def record_dependencies(record)
+    fields(record).filter_map do |field|
+      type = field.type.canonical
+      type = type.element_type.canonical if type.kind == :type_constant_array
+      type.spelling if type.kind == :type_record && type.spelling != record.spelling
+    end.uniq
+  end
+
+  def render_ruby
+    lines = [
+      "# frozen_string_literal: true",
+      "",
+      "# Generated from ext/joltc/include/joltc.h by generator/generate.rb.",
+      "# Do not edit this file directly.",
+      "",
+      "require \"ffi\"",
+      "",
+      "module Jolt",
+      "  module Native",
+      "    module Generated"
+    ]
+    sorted_records.each { |record| render_record(lines, record) }
+    render_function_table(lines)
+    render_layout_table(lines)
+    lines.concat [
+      "",
+      "      BLOCKING_FUNCTIONS = %i[JPH_PhysicsSystem_Update].freeze",
+      "",
+      "      module_function",
+      "",
+      "      def attach(native, names: FUNCTIONS.keys)",
+      "        missing = []",
+      "        names.each do |name|",
+      "          arguments, result = FUNCTIONS.fetch(name)",
+      "          options = BLOCKING_FUNCTIONS.include?(name) ? { blocking: true } : {}",
+      "          begin",
+      "            native.attach_function(name, arguments, result, **options)",
+      "          rescue FFI::NotFoundError",
+      "            missing << name",
+      "          end",
+      "        end",
+      "        @missing_functions = missing.freeze",
+      "      end",
+      "",
+      "      def missing_functions",
+      "        @missing_functions || [].freeze",
+      "      end",
+      "    end",
+      "  end",
+      "end",
+      ""
+    ]
+    lines.join("\n")
+  end
+
+  def render_record(lines, record)
+    lines << ""
+    lines << "      class #{ruby_class_name(record.spelling)} < FFI::Struct"
+    layout = fields(record).flat_map do |field|
+      [":#{snake_case(field.spelling)}", ruby_type(field.type, field: true)]
+    end
+    if layout.empty?
+      lines << "      end"
+      return
+    end
+
+    lines << "        layout #{layout.each_slice(2).map { |pair| pair.join(", ") }.join(",\n               ")}"
+    lines << "      end"
+  end
+
+  def render_function_table(lines)
+    lines << ""
+    lines << "      FUNCTIONS = {"
+    functions.sort_by(&:spelling).each do |function|
+      arguments = function.num_arguments.times.map do |index|
+        ruby_type(function.argument(index).type, argument: true)
+      end
+      result = ruby_type(function.result_type)
+      lines << "        #{function.spelling}: [[#{arguments.join(", ")}], #{result}],"
+    end
+    lines << "      }.freeze"
+  end
+
+  def render_layout_table(lines)
+    lines << ""
+    lines << "      HEADER_LAYOUTS = {"
+    sorted_records.each do |record|
+      offsets = fields(record).map do |field|
+        "#{snake_case(field.spelling)}: #{field.offset_of_field / 8}"
+      end
+      lines << "        #{record.spelling.inspect} => [#{record.type.sizeof}, { #{offsets.join(", ")} }],"
+    end
+    lines << "      }.freeze"
+  end
+
+  def render_probe
+    lines = [
+      "// Generated from ext/joltc/include/joltc.h by generator/generate.rb.",
+      "// Do not edit this file directly.",
+      "#include <cstddef>",
+      "#include <cstdio>",
+      "#include <joltc.h>",
+      "",
+      "int main() {"
+    ]
+    sorted_records.each do |record|
+      lines << %(  std::printf("S\\t#{record.spelling}\\t%zu\\n", sizeof(#{record.spelling}));)
+      fields(record).each do |field|
+        lines << %(  std::printf("F\\t#{record.spelling}\\t#{snake_case(field.spelling)}\\t%zu\\n", offsetof(#{record.spelling}, #{field.spelling}));)
+      end
+    end
+    lines.concat ["  return 0;", "}", ""]
+    lines.join("\n")
+  end
+
+  def ruby_type(type, field: false, argument: false)
+    canonical = type.canonical
+    kind = canonical.kind
+    return ":pointer" if argument && kind == :type_constant_array
+    return ":pointer" if kind == :type_pointer
+    return ":void" if kind == :type_void
+    return ":bool" if kind == :type_bool
+    return ":float" if kind == :type_float
+    return ":double" if kind == :type_double
+    return ":int" if kind == :type_enum
+    return INTEGER_TYPES.fetch(kind).inspect if INTEGER_TYPES.key?(kind)
+    if kind == :type_record
+      suffix = field || argument ? ".by_value" : ".by_value"
+      return "#{ruby_class_name(canonical.spelling)}#{suffix}"
+    end
+    if kind == :type_constant_array
+      return "[#{ruby_type(canonical.element_type, field: true)}, #{canonical.size}]"
+    end
+
+    abort "unsupported C type: #{type.spelling} (#{kind})"
+  end
+
+  def ruby_class_name(c_name)
+    c_name.delete_prefix("JPH_")
+  end
+
+  def snake_case(name)
+    name
+      .sub(/\A_+/, "")
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .downcase
+  end
+end
+
+BindingGenerator.new.run(check: ARGV.delete("--check"))