libcall 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d33e4ff88ea0b7f5200165a946f7a146cf0a1d4781d6fd5583d4ccdf3ec17dcf
-  data.tar.gz: 24d91124d8f8207fca38aabadab15cced21106e649755130180d248491e03eb0
+  metadata.gz: 39da3018356d7d6e8287d59bb0ca8ccc24f5a8b211d974b51d526d21347ac0f5
+  data.tar.gz: 6d55af828e7e621226bab1efff15174f00e1c542af390cf8e5886f1bbd8369c1
 SHA512:
-  metadata.gz: b79e721348b381ca177f8662ced2a942f7a34b65102a9dc3e8e852ad726c3501e48fadc311f63b7a86eab3113b2081e20c78de1dbbe4b58f2b6249d8541329fc
-  data.tar.gz: 9924983519f2f36b5930edab9ae607419eba0199ad6c3aa7a0707ea06006be7512a3d2b1087985e711eeefc928f4d287f23159ba80df240b130acd16cffcfa12
+  metadata.gz: bda1f14c0ae9d52f1b8edff83a8c949df3742f12e280ba87c562c1dc958507d329b934c3a87a96d3b14975a2751852bc3498e3c4e99fab3963e32888e81c4e57
+  data.tar.gz: 3621dad8e6ad6d5e3ea3ba52970d87457f4fb3dcb03824f75bd88148424a150ff6e6d4565fe1780c859ffc3787750f78905c8afa4fb24e87341b8a90ab3edd74

data/README.md

@@ -1,6 +1,7 @@
 # libcall
 
 [![test](https://github.com/kojix2/libcall/actions/workflows/main.yml/badge.svg)](https://github.com/kojix2/libcall/actions/workflows/main.yml)
+[![Gem Version](https://badge.fury.io/rb/libcall.svg)](https://badge.fury.io/rb/libcall)
 [![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Flibcall%2Flines)](https://tokei.kojix2.net/github/kojix2/libcall)
 
 Call C functions in shared libraries from the command line.
@@ -11,54 +12,91 @@ Call C functions in shared libraries from the command line.
 gem install libcall
 ```
 
+**Windows**: Supports DLLs (e.g., `msvcrt.dll`, `kernel32.dll`). Searches in System32, PATH, and MSYS2/MinGW directories. For building custom DLLs, RubyInstaller with DevKit is recommended.
+
 ## Usage
 
 ```sh
-libcall [OPTIONS] <LIBRARY> <FUNCTION> [ARGS...]
+libcall [OPTIONS] <LIBRARY> <FUNCTION> (TYPE VALUE)...
 ```
 
 ### Quick Examples
 
 ```sh
-# Math function with type suffix
-libcall -lm sqrt 16.0f64 -r f64
+# TYPE VALUE pairs
+libcall -lm -r f64 sqrt double 16
 # => 4.0
 
 # Custom library
-libcall ./mylib.so add 10i32 20i32 -r i32
+libcall ./mylib.so add_i32 int 10 int 20 -r i32
 # => 30
 ```
 
-### Type Syntax
+### Argument Syntax
+
+Pass arguments as TYPE VALUE pairs (single-token suffix style has been removed):
+
+- Examples: `int 10`, `double -3.14`, `string "hello"`
+- Negative values are safe (not treated as options): `int -23`
+
+Pointers and null:
 
-Use Rust-style type suffixes:
+- Use `ptr` (or `pointer`) to pass raw addresses as integers
+- Use `null`, `nil`, `NULL`, or `0` to pass a null pointer
+
+```sh
+# Pass a null pointer to a function taking const char*
+libcall -ltest str_length ptr null -r i32
+# => 0
+```
 
-- Integers: `42i32`, `100u64`, `255u8`
-- Floats: `3.14f64`, `2.5f32`
-- Strings: `"hello"`
+End of options `--`:
+
+- Use `--` to stop option parsing if a value starts with `-`
+
+```sh
+libcall -lc getenv string -- -r -r cstr
+```
 
 ### Options
 
 - `-l LIBRARY` - library name (searches standard paths)
 - `-L PATH` - add library search path
 - `-r TYPE` - return type (void, i32, f64, cstr, ptr)
+- Options may appear before or after the function name.
 - `--dry-run` - validate without executing
 - `--json` - JSON output
 - `--verbose` - detailed info
 - `-h, --help` - show help
 - `-v, --version` - show version
 
+Library search:
+
+- `-L` adds search paths; `-l` resolves by name
+- On Linux and macOS, `LD_LIBRARY_PATH` / `DYLD_LIBRARY_PATH` are honored
+
 ### More Examples
 
 ```sh
 # JSON output
-libcall --json -lm sqrt 9.0f64 -r f64
+libcall --json -lm sqrt double 9.0 -r f64
 
 # Dry run
-libcall --dry-run ./mylib.so test 42i32 -r void
+libcall --dry-run ./mylib.so test u64 42 -r void
 
 # Using -L and -l (like gcc)
-libcall -lmylib -L./build add 10i32 20i32 -r i32
+libcall -lmylib -L./build add_i32 int 10 int 20 -r i32
+
+# TYPE/VALUE pairs with -r after function
+libcall -lm fabs double -5.5 -r f64
+# => 5.5
+
+# Windows: calling C runtime functions
+libcall msvcrt.dll sqrt double 16.0 -r f64
+# => 4.0
+
+# Windows: accessing environment variables
+libcall msvcrt.dll getenv string "PATH" -r cstr
 ```
 
 ## Type Reference
@@ -76,12 +114,30 @@ libcall -lmylib -L./build add 10i32 20i32 -r i32
 | `f32`  | 32-bit float    | single precision   |
 | `f64`  | 64-bit float    | double precision   |
 
+Also supported:
+
+- `string`: C string argument (char\*)
+- `cstr`: C string return (char\*)
+- `ptr`/`pointer`: void\* pointer
+
 ## pkg-config Support
 
 Set `PKG_CONFIG_PATH` and use package names with `-l`:
 
 ```sh
-PKG_CONFIG_PATH=/path/to/pkgconfig libcall -lmypackage func 42i32 -r i32
+PKG_CONFIG_PATH=/path/to/pkgconfig libcall -lmypackage func i32 42 -r i32
+```
+
+## Output parameters (out:TYPE)
+
+You can pass output pointers by specifying `out:TYPE`. The pointer is allocated automatically, passed to the function, and printed after the call.
+
+```sh
+# void get_version(int* major, int* minor)
+libcall -ltest -L ./test/fixtures/libtest/build get_version out:int out:int -r void
+
+# JSON includes an "outputs" array
+libcall --json -ltest -L ./test/fixtures/libtest/build get_version out:int out:int -r void
 ```
 
 ## Warning

data/lib/libcall/caller.rb

@@ -3,24 +3,33 @@
 require 'fiddle'
 
 module Libcall
+  # Execute C function calls via Fiddle FFI
   class Caller
-    attr_reader :lib_path, :func_name, :return_type, :args
+    attr_reader :lib_path, :func_name, :return_type, :arg_pairs
 
-    def initialize(lib_path, func_name, args: [], return_type: :void)
+    def initialize(lib_path, func_name, arg_pairs: [], return_type: :void)
       @lib_path = lib_path
       @func_name = func_name
       @return_type = return_type
-      @args = args
+      @arg_pairs = arg_pairs
     end
 
     def call
       arg_types = []
       arg_values = []
+      out_refs = []
 
-      args.each do |arg|
-        type_sym, value = Parser.parse_arg(arg)
+      arg_pairs.each_with_index do |(type_sym, value), idx|
         arg_types << Parser.fiddle_type(type_sym)
-        arg_values << value
+
+        if type_sym.is_a?(Array) && type_sym.first == :out
+          inner = type_sym[1]
+          ptr = allocate_output_pointer(inner)
+          out_refs << { index: idx, type: inner, ptr: ptr }
+          arg_values << ptr.to_i
+        else
+          arg_values << value
+        end
       end
 
       ret_type = Parser.fiddle_type(return_type)
@@ -29,9 +38,14 @@ module Libcall
       func_ptr = handle[func_name]
       func = Fiddle::Function.new(func_ptr, arg_types, ret_type)
 
-      result = func.call(*arg_values)
+      raw_result = func.call(*arg_values)
+      formatted_result = format_result(raw_result, return_type)
 
-      format_result(result, return_type)
+      if out_refs.empty?
+        formatted_result
+      else
+        { result: formatted_result, outputs: read_output_values(out_refs) }
+      end
     rescue Fiddle::DLError => e
       raise Error, "Failed to load library or function: #{e.message}"
     end
@@ -59,5 +73,45 @@ module Libcall
         result
       end
     end
+
+    def allocate_output_pointer(type_sym)
+      size = case type_sym
+             when :char, :uchar then Fiddle::SIZEOF_CHAR
+             when :short, :ushort then Fiddle::SIZEOF_SHORT
+             when :int, :uint then Fiddle::SIZEOF_INT
+             when :long, :ulong then Fiddle::SIZEOF_LONG
+             when :long_long, :ulong_long then Fiddle::SIZEOF_LONG_LONG
+             when :float then Fiddle::SIZEOF_FLOAT
+             when :double then Fiddle::SIZEOF_DOUBLE
+             when :voidp then Fiddle::SIZEOF_VOIDP
+             else
+               raise Error, "Cannot allocate output pointer for type: #{type_sym}"
+             end
+      Fiddle::Pointer.malloc(size)
+    end
+
+    def read_output_values(out_refs)
+      out_refs.map do |ref|
+        value = case ref[:type]
+                when :char then ref[:ptr][0, Fiddle::SIZEOF_CHAR].unpack1('c')
+                when :uchar then ref[:ptr][0, Fiddle::SIZEOF_CHAR].unpack1('C')
+                when :short then ref[:ptr][0, Fiddle::SIZEOF_SHORT].unpack1('s')
+                when :ushort then ref[:ptr][0, Fiddle::SIZEOF_SHORT].unpack1('S')
+                when :int then ref[:ptr][0, Fiddle::SIZEOF_INT].unpack1('i')
+                when :uint then ref[:ptr][0, Fiddle::SIZEOF_INT].unpack1('I')
+                when :long then ref[:ptr][0, Fiddle::SIZEOF_LONG].unpack1('l!')
+                when :ulong then ref[:ptr][0, Fiddle::SIZEOF_LONG].unpack1('L!')
+                when :long_long then ref[:ptr][0, Fiddle::SIZEOF_LONG_LONG].unpack1('q')
+                when :ulong_long then ref[:ptr][0, Fiddle::SIZEOF_LONG_LONG].unpack1('Q')
+                when :float then ref[:ptr][0, Fiddle::SIZEOF_FLOAT].unpack1('f')
+                when :double then ref[:ptr][0, Fiddle::SIZEOF_DOUBLE].unpack1('d')
+                when :voidp then format('0x%x', ref[:ptr][0, Fiddle::SIZEOF_VOIDP].unpack1('J'))
+                else
+                  raise Error, "Cannot read output value for type: #{ref[:type]}"
+                end
+
+        { index: ref[:index], type: ref[:type].to_s, value: value }
+      end
+    end
   end
 end

data/lib/libcall/cli.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'optparse'
 require 'json'
 
 module Libcall
+  # Command-line interface for calling C functions from shared libraries
   class CLI
     def initialize(argv)
       @argv = argv
@@ -19,41 +19,31 @@ module Libcall
     end
 
     def run
-      parse_options!
+      lib_path, func_name, arg_pairs = scan_argv!(@argv)
 
-      if @argv.empty?
-        puts @parser.help
-        exit 1
-      end
-
-      # Resolve library path
+      # Resolve library path if a library name (-l) was given
       if @options[:lib_name]
         finder = LibraryFinder.new(lib_paths: @options[:lib_paths])
         lib_path = finder.find(@options[:lib_name])
-      else
-        lib_path = @options[:lib] || @argv.shift
       end
 
-      func_name = @argv.shift
-      args = @argv
-
       if lib_path.nil? || func_name.nil?
         warn 'Error: Missing required arguments'
-        warn 'Usage: libcall <LIBRARY> <FUNCTION> [ARGS...]'
+        warn 'Usage: libcall [OPTIONS] <LIBRARY> <FUNCTION> (TYPE VALUE)...'
         exit 1
       end
 
       if @options[:verbose]
         warn "Library: #{lib_path}"
         warn "Function: #{func_name}"
-        warn "Arguments: #{args.inspect}"
+        warn "Arguments: #{arg_pairs.inspect}"
         warn "Return type: #{@options[:return_type]}"
       end
 
       if @options[:dry_run]
-        dry_run_info(lib_path, func_name, args)
+        dry_run_info(lib_path, func_name, arg_pairs)
       else
-        execute_call(lib_path, func_name, args)
+        execute_call(lib_path, func_name, arg_pairs)
       end
     rescue Error => e
       warn "Error: #{e.message}"
@@ -66,113 +56,218 @@ module Libcall
 
     private
 
-    def parse_options!
-      @parser = OptionParser.new do |opts|
-        opts.banner = <<~BANNER
-          Usage: libcall [OPTIONS] <LIBRARY> <FUNCTION> [ARGS...]
+    def parse_options_banner
+      <<~BANNER
+        Usage: libcall [OPTIONS] <LIBRARY> <FUNCTION> (TYPE VALUE)...
 
-          Call C functions in shared libraries from the command line.
+        Call C functions in shared libraries from the command line.
 
-          Examples:
-            libcall /lib/libm.so.6 sqrt 16.0f64 -r f64
-            libcall -lm sqrt 16.0f64 -r f64
-            libcall -lsum -L. add 10i32 20i32 -r i32
-            libcall --dry-run ./mylib.so test 42u64 -r void
+        Pass arguments as TYPE VALUE pairs only.
 
-          Options:
-        BANNER
+        Examples:
+          libcall -lm -r f64 sqrt double 16
+          libcall -ltest -L ./build add_i32 int 10 int -23 -r int
+          libcall --dry-run ./mylib.so test u64 42 -r void
 
-        opts.on('--dry-run', 'Validate arguments without executing') do
-          @options[:dry_run] = true
-        end
+        Options:
+      BANNER
+    end
 
-        opts.on('--json', 'Output result as JSON') do
-          @options[:json] = true
-        end
+    # Custom scanner that supports:
+    # - Known flags anywhere (before/after function name)
+    # - Negative numbers as values (not mistaken for options)
+    # - TYPE VALUE pairs
+    def scan_argv!(argv)
+      lib_path = nil
+      func_name = nil
+      arg_pairs = []
+
+      positional_only = false
+      i = 0
+      while i < argv.length
+        tok = argv[i]
 
-        opts.on('--verbose', 'Show detailed information') do
-          @options[:verbose] = true
+        # End-of-options marker: switch to positional-only mode
+        if tok == '--'
+          positional_only = true
+          i += 1
+          next
         end
 
-        opts.on('-l', '--lib LIBRARY', 'Library name (searches in standard paths)') do |lib|
-          @options[:lib_name] = lib
+        # Try to handle as a known option (only if not in positional-only mode)
+        unless positional_only
+          option_consumed = handle_option!(tok, argv, i)
+          if option_consumed > 0
+            i += option_consumed
+            next
+          end
         end
 
-        opts.on('-L', '--lib-path PATH', 'Add library search path') do |path|
-          @options[:lib_paths] << path
+        # Positional resolution for <LIBRARY> and <FUNCTION>
+        if lib_path.nil? && @options[:lib_name].nil?
+          lib_path = tok
+          i += 1
+          next
         end
 
-        opts.on('-r', '--ret TYPE', 'Return type (void, i32, f64, cstr, etc.)') do |type|
-          @options[:return_type] = Parser.parse_return_type(type)
+        if func_name.nil?
+          func_name = tok
+          i += 1
+          next
         end
 
-        opts.on('-h', '--help', 'Show help') do
-          puts opts
-          exit
+        # After function name: parse TYPE VALUE pairs (or TYPE-only for out:TYPE)
+        type_tok = tok
+        i += 1
+
+        type_sym = Parser.parse_type(type_tok)
+
+        # TYPE that represents an output pointer does not require a value
+        if type_sym.is_a?(Array) && type_sym.first == :out
+          arg_pairs << [type_sym, nil]
+          next
         end
 
-        opts.on('-v', '--version', 'Show version') do
-          puts "libcall #{Libcall::VERSION}"
-          exit
+        # Allow `--` between TYPE and VALUE to switch to positional-only
+        while i < argv.length && argv[i] == '--'
+          positional_only = true
+          i += 1
         end
+
+        raise Error, "Missing value for argument of type #{type_tok}" if i >= argv.length
+
+        value_tok = argv[i]
+        value = Parser.coerce_value(type_sym, value_tok)
+        arg_pairs << [type_sym, value]
+        i += 1
       end
 
-      @parser.permute!(@argv)
+      [lib_path, func_name, arg_pairs]
     end
 
-    def dry_run_info(lib_path, func_name, args)
-      info = {
-        library: lib_path,
-        function: func_name,
-        arguments: [],
-        return_type: @options[:return_type].to_s
-      }
+    # Handle known option flags and return number of consumed tokens (0 if not an option)
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+    def handle_option!(tok, argv, i)
+      case tok
+      when '--dry-run'
+        @options[:dry_run] = true
+        1
+      when '--json'
+        @options[:json] = true
+        1
+      when '--verbose'
+        @options[:verbose] = true
+        1
+      when '-h', '--help'
+        puts parse_options_banner
+        exit 0
+      when '-v', '--version'
+        puts "libcall #{Libcall::VERSION}"
+        exit 0
+      when '-l', '--lib'
+        raise Error, 'Missing value for -l/--lib' if i + 1 >= argv.length
 
-      args.each_with_index do |arg, i|
-        type_sym, value = Parser.parse_arg(arg)
-        info[:arguments] << {
-          index: i,
-          raw: arg,
-          type: type_sym.to_s,
-          value: value
-        }
+        @options[:lib_name] = argv[i + 1]
+        2
+      when /\A-l(.+)\z/
+        @options[:lib_name] = ::Regexp.last_match(1)
+        1
+      when '-L', '--lib-path'
+        raise Error, 'Missing value for -L/--lib-path' if i + 1 >= argv.length
+
+        @options[:lib_paths] << argv[i + 1]
+        2
+      when '-r', '--ret'
+        raise Error, 'Missing value for -r/--ret' if i + 1 >= argv.length
+
+        @options[:return_type] = Parser.parse_return_type(argv[i + 1])
+        2
+      when /\A-r(.+)\z/
+        @options[:return_type] = Parser.parse_return_type(::Regexp.last_match(1))
+        1
+      else
+        0 # Not an option
       end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+
+    def dry_run_info(lib_path, func_name, arg_pairs)
+      info = build_info_hash(lib_path, func_name, arg_pairs)
 
       if @options[:json]
         puts JSON.pretty_generate(info)
       else
-        puts "Library:  #{info[:library]}"
-        puts "Function: #{info[:function]}"
-        puts "Return:   #{info[:return_type]}"
-        unless info[:arguments].empty?
-          puts 'Arguments:'
-          info[:arguments].each do |arg|
-            puts "  [#{arg[:index]}] #{arg[:raw]} => #{arg[:type]} (#{arg[:value].inspect})"
-          end
-        end
+        print_info(info)
       end
     end
 
-    def execute_call(lib_path, func_name, args)
+    def build_info_hash(lib_path, func_name, arg_pairs)
+      {
+        library: lib_path,
+        function: func_name,
+        arguments: arg_pairs.map.with_index do |(type_sym, value), i|
+          {
+            index: i,
+            type: type_sym.to_s,
+            value: value
+          }
+        end,
+        return_type: @options[:return_type].to_s
+      }
+    end
+
+    def print_info(info)
+      puts "Library:  #{info[:library]}"
+      puts "Function: #{info[:function]}"
+      puts "Return:   #{info[:return_type]}"
+      return if info[:arguments].empty?
+
+      puts 'Arguments:'
+      info[:arguments].each do |arg|
+        puts "  [#{arg[:index]}] #{arg[:type]} = #{arg[:value].inspect}"
+      end
+    end
+
+    def execute_call(lib_path, func_name, arg_pairs)
       caller = Caller.new(
         lib_path,
         func_name,
-        args: args,
+        arg_pairs: arg_pairs,
         return_type: @options[:return_type]
       )
 
       result = caller.call
+      output_result(lib_path, func_name, result)
+    end
 
+    def output_result(lib_path, func_name, result)
       if @options[:json]
         output = {
           library: lib_path,
           function: func_name,
-          return_type: @options[:return_type].to_s,
-          result: result
+          return_type: @options[:return_type].to_s
         }
+
+        if result.is_a?(Hash) && result.key?(:outputs)
+          output[:result] = result[:result]
+          output[:outputs] = result[:outputs]
+        else
+          output[:result] = result
+        end
+
         puts JSON.pretty_generate(output, allow_nan: true)
       else
-        puts result unless result.nil?
+        if result.is_a?(Hash) && result.key?(:outputs)
+          puts "Result: #{result[:result]}" unless result[:result].nil?
+          unless result[:outputs].empty?
+            puts 'Output parameters:'
+            result[:outputs].each do |out|
+              puts "  [#{out[:index]}] #{out[:type]} = #{out[:value]}"
+            end
+          end
+        else
+          puts result unless result.nil?
+        end
       end
     end
   end

data/lib/libcall/library_finder.rb

@@ -9,6 +9,7 @@ rescue LoadError
 end
 
 module Libcall
+  # Find shared libraries by name using standard search paths and pkg-config
   class LibraryFinder
     def initialize(lib_paths: [])
       @lib_paths = lib_paths
@@ -64,31 +65,48 @@ module Libcall
     def default_library_paths
       paths = []
 
-      # Standard library paths
-      paths << '/lib'
-      paths << '/usr/lib'
-      paths << '/usr/local/lib'
-
-      # Architecture-specific paths
-      if RUBY_PLATFORM =~ /x86_64/
-        paths << '/lib/x86_64-linux-gnu'
-        paths << '/usr/lib/x86_64-linux-gnu'
-      elsif RUBY_PLATFORM =~ /aarch64|arm64/
-        paths << '/lib/aarch64-linux-gnu'
-        paths << '/usr/lib/aarch64-linux-gnu'
-      end
+      if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+        # Windows paths
+        paths << 'C:/Windows/System32'
+        paths << 'C:/Windows/SysWOW64'
+
+        # MSYS2/MinGW paths
+        if ENV['MSYSTEM']
+          msys_prefix = ENV['MINGW_PREFIX'] || 'C:/msys64/mingw64'
+          paths << "#{msys_prefix}/bin"
+          paths << "#{msys_prefix}/lib"
+        end
 
-      # macOS paths
-      if RUBY_PLATFORM =~ /darwin/
+        # Add PATH directories on Windows
+        paths.concat(ENV['PATH'].split(';').map { |p| p.tr('\\', '/') }) if ENV['PATH']
+      else
+        # Unix-like systems (Linux, macOS)
+        # Standard library paths
+        paths << '/lib'
+        paths << '/usr/lib'
         paths << '/usr/local/lib'
-        paths << '/opt/homebrew/lib'
-      end
 
-      # LD_LIBRARY_PATH
-      paths.concat(ENV['LD_LIBRARY_PATH'].split(':')) if ENV['LD_LIBRARY_PATH']
+        # Architecture-specific paths
+        if RUBY_PLATFORM =~ /x86_64/
+          paths << '/lib/x86_64-linux-gnu'
+          paths << '/usr/lib/x86_64-linux-gnu'
+        elsif RUBY_PLATFORM =~ /aarch64|arm64/
+          paths << '/lib/aarch64-linux-gnu'
+          paths << '/usr/lib/aarch64-linux-gnu'
+        end
 
-      # DYLD_LIBRARY_PATH (macOS)
-      paths.concat(ENV['DYLD_LIBRARY_PATH'].split(':')) if ENV['DYLD_LIBRARY_PATH']
+        # macOS paths
+        if RUBY_PLATFORM =~ /darwin/
+          paths << '/usr/local/lib'
+          paths << '/opt/homebrew/lib'
+        end
+
+        # LD_LIBRARY_PATH
+        paths.concat(ENV['LD_LIBRARY_PATH'].split(':')) if ENV['LD_LIBRARY_PATH']
+
+        # DYLD_LIBRARY_PATH (macOS)
+        paths.concat(ENV['DYLD_LIBRARY_PATH'].split(':')) if ENV['DYLD_LIBRARY_PATH']
+      end
 
       paths.select { |p| Dir.exist?(p) }
     end
@@ -101,8 +119,15 @@ module Libcall
       end
 
       # Try with lib prefix and common extensions
-      extensions = ['', '.so', '.dylib', '.dll']
-      prefixes = lib_name.start_with?('lib') ? [''] : ['lib']
+      extensions = if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+                     ['', '.dll', '.so', '.a']
+                   elsif RUBY_PLATFORM =~ /darwin/
+                     ['', '.dylib', '.so', '.a']
+                   else
+                     ['', '.so', '.a']
+                   end
+
+      prefixes = lib_name.start_with?('lib') ? [''] : ['lib', '']
 
       prefixes.each do |prefix|
         extensions.each do |ext|

data/lib/libcall/parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Libcall
+  # Parse and coerce TYPE VALUE argument pairs for FFI calls
   class Parser
     TYPE_MAP = {
       'i8' => :char,
@@ -17,7 +18,9 @@ module Libcall
       'f64' => :double,
       'cstr' => :string,
       'ptr' => :voidp,
+      'pointer' => :voidp,
       'void' => :void,
+      # Common aliases
       'int' => :int,
       'uint' => :uint,
       'long' => :long,
@@ -25,40 +28,27 @@ module Libcall
       'float' => :float,
       'double' => :double,
       'char' => :char,
-      'str' => :string
+      'str' => :string,
+      'string' => :string
     }.freeze
 
-    def self.parse_arg(arg)
-      return [:string, ''] if arg.empty?
+    INTEGER_TYPES = %i[int uint long ulong long_long ulong_long char uchar short ushort].freeze
+    FLOAT_TYPES = %i[float double].freeze
 
-      if (arg.start_with?('"') && arg.end_with?('"')) ||
-         (arg.start_with?("'") && arg.end_with?("'"))
-        return [:string, arg[1...-1]]
+    # Pair-only API helpers
+    def self.parse_type(type_str)
+      # Output pointer spec: out:TYPE (e.g., out:int, out:f64)
+      if type_str.start_with?('out:')
+        inner = type_str.sub(/^out:/, '')
+        inner_sym = TYPE_MAP[inner]
+        raise Error, "Unknown type in out: #{inner}" unless inner_sym
+        return [:out, inner_sym]
       end
 
-      if arg =~ /^([-+]?(?:\d+\.?\d*|\d*\.\d+))([a-z]\d+|[a-z]+)$/i
-        value_str = ::Regexp.last_match(1)
-        type_str = ::Regexp.last_match(2)
-
-        type_sym = TYPE_MAP[type_str]
-        raise Error, "Unknown type suffix: #{type_str}" unless type_sym
-
-        value = if %i[float double].include?(type_sym)
-                  value_str.to_f
-                else
-                  value_str.to_i
-                end
-
-        return [type_sym, value]
-      end
+      type_sym = TYPE_MAP[type_str]
+      raise Error, "Unknown type: #{type_str}" unless type_sym
 
-      if arg =~ /^[-+]?\d+$/
-        [:int, arg.to_i]
-      elsif arg =~ /^[-+]?(?:\d+\.\d*|\d*\.\d+)$/
-        [:double, arg.to_f]
-      else
-        raise Error, "Cannot parse argument: #{arg}"
-      end
+      type_sym
     end
 
     def self.parse_return_type(type_str)
@@ -70,17 +60,38 @@ module Libcall
       type_sym
     end
 
-    def self.parse_signature(sig)
-      raise Error, "Invalid signature format: #{sig}" unless sig =~ /^([a-z]\w*)\((.*)\)$/i
+    def self.coerce_value(type_sym, token)
+      case type_sym
+      when *FLOAT_TYPES
+        Float(token)
+      when *INTEGER_TYPES
+        Integer(token)
+      when :voidp
+        # Accept common null tokens for pointer types
+        return 0 if token =~ /\A(null|nil|NULL|0)\z/
 
-      ret_type = parse_return_type(::Regexp.last_match(1))
-      arg_types = ::Regexp.last_match(2).split(',').map(&:strip).reject(&:empty?).map do |t|
-        TYPE_MAP[t] or raise Error, "Unknown type in signature: #{t}"
+        Integer(token)
+      when :string
+        strip_quotes(token)
+      when :void
+        raise Error, 'void cannot be used as an argument type'
+      else
+        raise Error, "Unknown type for coercion: #{type_sym}"
+      end
+    end
+
+    def self.strip_quotes(token)
+      if (token.start_with?('"') && token.end_with?('"')) || (token.start_with?("'") && token.end_with?("'"))
+        token[1...-1]
+      else
+        token
       end
-      [ret_type, arg_types]
     end
 
     def self.fiddle_type(type_sym)
+      # Output parameters are passed as pointers
+      return Fiddle::TYPE_VOIDP if type_sym.is_a?(Array) && type_sym.first == :out
+
       case type_sym
       when :void then Fiddle::TYPE_VOID
       when :char then Fiddle::TYPE_CHAR

data/lib/libcall/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Libcall
-  VERSION = '0.0.0'
+  VERSION = '0.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libcall
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - kojix2