mt-lang 0.2.0

data/lib/milk_tea/bindings/bindgen.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "tempfile"
+require_relative "../tooling/formatter"
+require_relative "../core/token"
+require_relative "../core/types/types"
+require_relative "bindgen/ast_parser"
+require_relative "bindgen/declaration"
+require_relative "bindgen/type_mapper"
+require_relative "bindgen/emitter"
+require_relative "bindgen/overrides"
+
+module MilkTea
+  module Bindgen
+    MACRO_CONST_PREFIX = "__mt_bindgen_macro_"
+    QUALIFIERS = %w[const volatile restrict].freeze
+    NULLABILITY_QUALIFIERS = %w[_Nullable _Nonnull _Null_unspecified _Nullable_result].freeze
+    NON_VALUE_MACRO_TOKENS = %w[
+      extern static inline typedef struct union enum do if else for while return sizeof
+      __attribute__ __attribute __declspec
+    ].freeze
+    PRIMITIVE_TYPE_MAP = {
+      "_Bool" => "bool",
+      "bool" => "bool",
+      "void" => "void",
+      "char" => "char",
+      "signed char" => "byte",
+      "unsigned char" => "ubyte",
+      "short" => "short",
+      "short int" => "short",
+      "signed short" => "short",
+      "signed short int" => "short",
+      "unsigned short" => "ushort",
+      "unsigned short int" => "ushort",
+      "int" => "int",
+      "signed" => "int",
+      "signed int" => "int",
+      "unsigned" => "uint",
+      "unsigned int" => "uint",
+      "long" => "ptr_int",
+      "long int" => "ptr_int",
+      "signed long" => "ptr_int",
+      "signed long int" => "ptr_int",
+      "unsigned long" => "ptr_uint",
+      "unsigned long int" => "ptr_uint",
+      "long long" => "long",
+      "long long int" => "long",
+      "signed long long" => "long",
+      "signed long long int" => "long",
+      "unsigned long long" => "ulong",
+      "unsigned long long int" => "ulong",
+      "float" => "float",
+      "double" => "double",
+    }.freeze
+
+    def self.generate(module_name:, header_path:, tracked_header_paths: [], tracked_header_prefixes: [], declaration_name_prefixes: [], excluded_declaration_names: [], link_libraries: [], include_directives: nil, bindgen_defines: [], bindgen_include_directives: [], module_imports: [], clang: ENV.fetch("CLANG", "clang"), clang_args: [], type_name_overrides: {}, type_overrides: {}, function_param_type_overrides: {}, function_return_type_overrides: {}, field_type_overrides: {}, allow_static_inline_functions: false, strip_leading_underscores: false)
+      generate_with_report(
+        module_name:,
+        header_path:,
+        tracked_header_paths:,
+        tracked_header_prefixes:,
+        declaration_name_prefixes:,
+        excluded_declaration_names:,
+        link_libraries:,
+        include_directives:,
+        bindgen_defines:,
+        bindgen_include_directives:,
+        module_imports:,
+        clang:,
+        clang_args:,
+        type_name_overrides:,
+        type_overrides:,
+        function_param_type_overrides:,
+        function_return_type_overrides:,
+        field_type_overrides:,
+        allow_static_inline_functions:,
+        strip_leading_underscores:,
+      ).fetch(:source)
+    end
+
+    def self.generate_with_report(module_name:, header_path:, tracked_header_paths: [], tracked_header_prefixes: [], declaration_name_prefixes: [], excluded_declaration_names: [], link_libraries: [], include_directives: nil, bindgen_defines: [], bindgen_include_directives: [], module_imports: [], clang: ENV.fetch("CLANG", "clang"), clang_args: [], type_name_overrides: {}, type_overrides: {}, function_param_type_overrides: {}, function_return_type_overrides: {}, field_type_overrides: {}, allow_static_inline_functions: false, strip_leading_underscores: false)
+      Generator.new(
+        module_name:,
+        header_path:,
+        tracked_header_paths:,
+        tracked_header_prefixes:,
+        declaration_name_prefixes:,
+        excluded_declaration_names:,
+        link_libraries:,
+        include_directives:,
+        bindgen_defines:,
+        bindgen_include_directives:,
+        module_imports:,
+        clang:,
+        clang_args:,
+        type_name_overrides:,
+        type_overrides:,
+        function_param_type_overrides:,
+        function_return_type_overrides:,
+        field_type_overrides:,
+        allow_static_inline_functions:,
+        strip_leading_underscores:,
+      ).generate_with_report
+    end
+
+    class Generator
+      def initialize(module_name:, header_path:, tracked_header_paths:, tracked_header_prefixes:, declaration_name_prefixes:, excluded_declaration_names:, link_libraries:, include_directives:, bindgen_defines:, bindgen_include_directives:, module_imports:, clang:, clang_args:, type_name_overrides:, type_overrides:, function_param_type_overrides:, function_return_type_overrides:, field_type_overrides:, allow_static_inline_functions:, strip_leading_underscores: false)
+        @module_name = module_name
+        @header_path = File.expand_path(header_path)
+        @tracked_header_paths = ([header_path] + tracked_header_paths).map { |path| File.expand_path(path) }.uniq.freeze
+        @tracked_header_prefixes = tracked_header_prefixes.map { |path| File.expand_path(path) }.uniq.freeze
+        @declaration_name_prefixes = declaration_name_prefixes.dup.freeze
+        @excluded_declaration_names = excluded_declaration_names.map(&:to_s).freeze
+        @link_libraries = link_libraries.dup
+        @include_directives = include_directives&.dup
+        @bindgen_defines = bindgen_defines.dup.freeze
+        @bindgen_include_directives = bindgen_include_directives.dup.freeze
+        @module_imports = normalize_module_imports(module_imports)
+        @clang = clang
+        @clang_args = clang_args.dup
+        @type_name_overrides = normalize_type_name_overrides(type_name_overrides)
+        @type_overrides = normalize_type_overrides(type_overrides)
+        @function_param_type_overrides = normalize_function_param_type_overrides(function_param_type_overrides)
+        @function_return_type_overrides = normalize_function_return_type_overrides(function_return_type_overrides)
+        @field_type_overrides = normalize_field_type_overrides(field_type_overrides)
+        @allow_static_inline_functions = allow_static_inline_functions
+        @strip_leading_underscores = strip_leading_underscores
+        @record_aliases = {}
+        @record_aliases_by_tag_name = {}
+        @enum_aliases = {}
+        @record_visible_names = {}
+        @enum_visible_names = {}
+        @referenceable_record_declarations = {}
+        @referenceable_record_declarations_by_id = {}
+        @aggregate_declarations = {}
+        @synthetic_declarations = []
+        @manual_nullable_param_overrides = []
+        @manual_nullable_return_overrides = []
+      end
+
+      def generate
+        ast = dump_ast
+        index_referenceable_record_declarations(ast)
+        top_level_nodes = extract_top_level_header_nodes(ast)
+        @visible_typedef_names = top_level_nodes.filter_map do |node|
+          node["name"] if node["kind"] == "TypedefDecl" && allowed_declaration_name?(node["name"])
+        end
+        build_alias_maps(top_level_nodes)
+
+        declarations = []
+        declarations.concat(select_record_declarations(top_level_nodes))
+        validate_field_type_overrides!(declarations)
+        discover_synthetic_aggregate_dependencies(declarations)
+        discover_synthetic_field_type_dependencies(declarations)
+        declarations.concat(select_enum_declarations(top_level_nodes))
+        declarations.concat(select_type_alias_declarations(top_level_nodes))
+        declarations.concat(select_constant_declarations(top_level_nodes))
+        function_declarations = select_function_declarations(top_level_nodes)
+        validate_function_param_type_overrides!(function_declarations)
+        validate_function_return_type_overrides!(function_declarations)
+        declarations.concat(function_declarations)
+        declarations.sort_by! { |declaration| declaration[:index] }
+
+        emit_module(declarations)
+      end
+
+      def generate_with_report
+        source = generate
+        {
+          source:,
+          nullable_policy_report: nullable_policy_report,
+        }
+      end
+
+      private
+
+      def nullable_policy_report
+        parameter_entries = @manual_nullable_param_overrides.sort_by { |entry| [entry[:function], entry[:parameter]] }
+        return_entries = @manual_nullable_return_overrides.sort_by { |entry| entry[:function] }
+
+        {
+          module_name: @module_name,
+          header_path: @header_path,
+          summary: {
+            parameters: parameter_entries.length,
+            return_types: return_entries.length,
+            total: parameter_entries.length + return_entries.length,
+          },
+          manual_nullable_policy: {
+            parameters: parameter_entries,
+            return_types: return_entries,
+          },
+        }
+      end
+
+      include GeneratorAstParser
+      include GeneratorDeclaration
+      include GeneratorTypeMapper
+      include GeneratorEmitter
+      include GeneratorOverrides
+    end
+  end
+
+  class BindgenError < StandardError; end
+end

data/lib/milk_tea/bindings/cli.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class BindgenCLI
+    def self.start(argv = ARGV, out:, err:, help_printer:)
+      new(argv, out:, err:, help_printer:).start
+    end
+
+    def initialize(argv, out:, err:, help_printer:)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @help_printer = help_printer
+    end
+
+    def start
+      module_name = @argv.shift
+      header_path = @argv.shift
+      unless module_name && header_path
+        @err.puts("missing module name or header path")
+        print_help
+        return 1
+      end
+
+      require_relative "../bindings"
+
+      options = parse_options
+      return 1 unless options
+
+      output_path = options.delete(:output_path)
+      nullable_report_path = options.delete(:nullable_report_path)
+      if nullable_report_path
+        require "json"
+        result = Bindgen.generate_with_report(module_name:, header_path:, **options)
+        source = result.fetch(:source)
+        report_path = File.expand_path(nullable_report_path)
+        FileUtils.mkdir_p(File.dirname(report_path))
+        File.write(report_path, JSON.pretty_generate(result.fetch(:nullable_policy_report)))
+      else
+        source = Bindgen.generate(module_name:, header_path:, **options)
+      end
+
+      if output_path
+        FileUtils.mkdir_p(File.dirname(File.expand_path(output_path)))
+        File.write(output_path, source)
+        @out.puts("generated #{header_path} -> #{output_path}")
+        @out.puts("nullable report #{header_path} -> #{report_path}") if nullable_report_path
+      else
+        @out.write(source)
+        @err.puts("wrote nullable report #{report_path}") if nullable_report_path
+      end
+      0
+    end
+
+    private
+
+    def print_help
+      @help_printer.call(@err)
+    end
+
+    def parse_options
+      options = {
+        output_path: nil,
+        nullable_report_path: nil,
+        link_libraries: [],
+        include_directives: [],
+        clang: ENV.fetch("CLANG", "clang"),
+        clang_args: [],
+      }
+
+      until @argv.empty?
+        option = @argv.shift
+        case option
+        when "-o", "--output"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:output_path] = value
+        when "--link"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:link_libraries] << value
+        when "--include"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:include_directives] << value
+        when "--clang"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:clang] = value
+        when "--clang-arg"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:clang_args] << value
+        when "--nullable-report"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:nullable_report_path] = value
+        else
+          @err.puts("unknown bindgen option #{option}")
+          print_help
+          return nil
+        end
+      end
+
+      options[:include_directives] = nil if options[:include_directives].empty?
+      options
+    end
+
+    def missing_option_value(option)
+      @err.puts("missing value for #{option}")
+      print_help
+      nil
+    end
+  end
+end

data/lib/milk_tea/bindings/imported_bindings/defaults.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module ImportedBindings
+    def self.default_bindings(root: MilkTea.root)
+      [
+        Binding.new(
+          name: "raymath",
+          module_name: "std.raymath",
+          binding_path: root.join("std/raymath.mt"),
+          raw_module_name: "std.c.raymath",
+          policy_path: root.join("bindings/imported/raymath.binding.json"),
+        ),
+        Binding.new(
+          name: "raylib",
+          module_name: "std.raylib",
+          binding_path: root.join("std/raylib.mt"),
+          raw_module_name: "std.c.raylib",
+          policy_path: root.join("bindings/imported/raylib.binding.json"),
+        ),
+        Binding.new(
+          name: "rlgl",
+          module_name: "std.rlgl",
+          binding_path: root.join("std/rlgl.mt"),
+          raw_module_name: "std.c.rlgl",
+          policy_path: root.join("bindings/imported/rlgl.binding.json"),
+        ),
+        Binding.new(
+          name: "raygui",
+          module_name: "std.raygui",
+          binding_path: root.join("std/raygui.mt"),
+          raw_module_name: "std.c.raygui",
+          policy_path: root.join("bindings/imported/raygui.binding.json"),
+        ),
+        Binding.new(
+          name: "sdl3",
+          module_name: "std.sdl3",
+          binding_path: root.join("std/sdl3.mt"),
+          raw_module_name: "std.c.sdl3",
+          policy_path: root.join("bindings/imported/sdl3.binding.json"),
+        ),
+        Binding.new(
+          name: "gl",
+          module_name: "std.gl",
+          binding_path: root.join("std/gl.mt"),
+          raw_module_name: "std.c.gl",
+          policy_path: root.join("bindings/imported/gl.binding.json"),
+        ),
+        Binding.new(
+          name: "glfw",
+          module_name: "std.glfw",
+          binding_path: root.join("std/glfw.mt"),
+          raw_module_name: "std.c.glfw",
+          policy_path: root.join("bindings/imported/glfw.binding.json"),
+        ),
+        Binding.new(
+          name: "box2d",
+          module_name: "std.box2d",
+          binding_path: root.join("std/box2d.mt"),
+          raw_module_name: "std.c.box2d",
+          policy_path: root.join("bindings/imported/box2d.binding.json"),
+        ),
+        Binding.new(
+          name: "cjson",
+          module_name: "std.cjson",
+          binding_path: root.join("std/cjson.mt"),
+          raw_module_name: "std.c.cjson",
+          policy_path: root.join("bindings/imported/cjson.binding.json"),
+        ),
+        Binding.new(
+          name: "flecs",
+          module_name: "std.flecs",
+          binding_path: root.join("std/flecs.mt"),
+          raw_module_name: "std.c.flecs",
+          policy_path: root.join("bindings/imported/flecs.binding.json"),
+        ),
+        Binding.new(
+          name: "libuv",
+          module_name: "std.libuv",
+          binding_path: root.join("std/libuv.mt"),
+          raw_module_name: "std.c.libuv",
+          policy_path: root.join("bindings/imported/libuv.binding.json"),
+        ),
+        Binding.new(
+          name: "enet",
+          module_name: "std.enet",
+          binding_path: root.join("std/enet.mt"),
+          raw_module_name: "std.c.enet",
+          policy_path: root.join("bindings/imported/enet.binding.json"),
+        ),
+        Binding.new(
+          name: "zstd",
+          module_name: "std.zstd",
+          binding_path: root.join("std/zstd.mt"),
+          raw_module_name: "std.c.zstd",
+          policy_path: root.join("bindings/imported/zstd.binding.json"),
+        ),
+        Binding.new(
+          name: "sqlite3",
+          module_name: "std.sqlite3",
+          binding_path: root.join("std/sqlite3.mt"),
+          raw_module_name: "std.c.sqlite3",
+          policy_path: root.join("bindings/imported/sqlite3.binding.json"),
+        ),
+        Binding.new(
+          name: "curl",
+          module_name: "std.curl",
+          binding_path: root.join("std/curl.mt"),
+          raw_module_name: "std.c.curl",
+          policy_path: root.join("bindings/imported/curl.binding.json"),
+        ),
+        Binding.new(
+          name: "pcre2",
+          module_name: "std.pcre2",
+          binding_path: root.join("std/pcre2.mt"),
+          raw_module_name: "std.c.pcre2",
+          policy_path: root.join("bindings/imported/pcre2.binding.json"),
+        ),
+        Binding.new(
+          name: "steamworks",
+          module_name: "std.steamworks",
+          binding_path: root.join("std/steamworks.mt"),
+          raw_module_name: "std.c.steamworks",
+          policy_path: root.join("bindings/imported/steamworks.binding.json"),
+        ),
+        Binding.new(
+          name: "miniaudio",
+          module_name: "std.miniaudio",
+          binding_path: root.join("std/miniaudio.mt"),
+          raw_module_name: "std.c.miniaudio",
+          policy_path: root.join("bindings/imported/miniaudio.binding.json"),
+        ),
+        Binding.new(
+          name: "tracy",
+          module_name: "std.tracy",
+          binding_path: root.join("std/tracy.mt"),
+          raw_module_name: "std.c.tracy",
+          policy_path: root.join("bindings/imported/tracy.binding.json"),
+        ),
+        Binding.new(
+          name: "rres",
+          module_name: "std.rres",
+          binding_path: root.join("std/rres.mt"),
+          raw_module_name: "std.c.rres",
+          policy_path: root.join("bindings/imported/rres.binding.json"),
+        ),
+        Binding.new(
+          name: "rpng",
+          module_name: "std.rpng",
+          binding_path: root.join("std/rpng.mt"),
+          raw_module_name: "std.c.rpng",
+          policy_path: root.join("bindings/imported/rpng.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_image",
+          module_name: "std.stb_image",
+          binding_path: root.join("std/stb_image.mt"),
+          raw_module_name: "std.c.stb_image",
+          policy_path: root.join("bindings/imported/stb_image.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_truetype",
+          module_name: "std.stb_truetype",
+          binding_path: root.join("std/stb_truetype.mt"),
+          raw_module_name: "std.c.stb_truetype",
+          policy_path: root.join("bindings/imported/stb_truetype.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_image_write",
+          module_name: "std.stb_image_write",
+          binding_path: root.join("std/stb_image_write.mt"),
+          raw_module_name: "std.c.stb_image_write",
+          policy_path: root.join("bindings/imported/stb_image_write.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_image_resize2",
+          module_name: "std.stb_image_resize2",
+          binding_path: root.join("std/stb_image_resize2.mt"),
+          raw_module_name: "std.c.stb_image_resize2",
+          policy_path: root.join("bindings/imported/stb_image_resize2.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_rect_pack",
+          module_name: "std.stb_rect_pack",
+          binding_path: root.join("std/stb_rect_pack.mt"),
+          raw_module_name: "std.c.stb_rect_pack",
+          policy_path: root.join("bindings/imported/stb_rect_pack.binding.json"),
+        ),
+        Binding.new(
+          name: "stb_vorbis",
+          module_name: "std.stb_vorbis",
+          binding_path: root.join("std/stb_vorbis.mt"),
+          raw_module_name: "std.c.stb_vorbis",
+          policy_path: root.join("bindings/imported/stb_vorbis.binding.json"),
+        ),
+        Binding.new(
+          name: "cgltf",
+          module_name: "std.cgltf",
+          binding_path: root.join("std/cgltf.mt"),
+          raw_module_name: "std.c.cgltf",
+          policy_path: root.join("bindings/imported/cgltf.binding.json"),
+        ),
+      ]
+    end
+
+    def self.default_registry(root: MilkTea.root)
+      Registry.new(default_bindings(root:))
+    end
+  end
+end