libcall 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39da3018356d7d6e8287d59bb0ca8ccc24f5a8b211d974b51d526d21347ac0f5
-  data.tar.gz: 6d55af828e7e621226bab1efff15174f00e1c542af390cf8e5886f1bbd8369c1
+  metadata.gz: db2f2234f00412d76e307fc12179b0a829953a08bd6aefa83d59bbab866e85f3
+  data.tar.gz: bb2cd9b42fb09fc6b6e5201ed98c16dae47258e9a1fb23ef76fc6a49efe17ab3
 SHA512:
-  metadata.gz: bda1f14c0ae9d52f1b8edff83a8c949df3742f12e280ba87c562c1dc958507d329b934c3a87a96d3b14975a2751852bc3498e3c4e99fab3963e32888e81c4e57
-  data.tar.gz: 3621dad8e6ad6d5e3ea3ba52970d87457f4fb3dcb03824f75bd88148424a150ff6e6d4565fe1780c859ffc3787750f78905c8afa4fb24e87341b8a90ab3edd74
+  metadata.gz: 12bc58798f6130a316ba87e53a66d2806035a7fd8abbb6ba2fc71654d82e0f2210149152cf9876ca818a5241808a2c871021eca2c7264a2110cfe37199da2872
+  data.tar.gz: bb6f252e8a7a9aec0a353abec0ed9674b346bb1af3471768ca51fad040234024c6fc77b18a25d42c396a389a0063ac44c5675f54fa8bd66eed3b0c9055da8e34

data/README.md

@@ -23,13 +23,11 @@ libcall [OPTIONS] <LIBRARY> <FUNCTION> (TYPE VALUE)...
 ### Quick Examples
 
 ```sh
-# TYPE VALUE pairs
-libcall -lm -r f64 sqrt double 16
-# => 4.0
+libcall -lm sqrt double 16 -r double # => 4.0
+```
 
-# Custom library
-libcall ./mylib.so add_i32 int 10 int 20 -r i32
-# => 30
+```sh
+libcall -lc strlen string "hello" -r usize # => 5
 ```
 
 ### Argument Syntax
@@ -63,7 +61,6 @@ libcall -lc getenv string -- -r -r cstr
 - `-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
@@ -77,42 +74,68 @@ Library search:
 
 ### More Examples
 
+TYPE/VALUE pairs with `-r` before function
+
+```sh
+libcall -lm  -r double fabs double -5.5 # => 5.5
+```
+
+Output parameter with libm
+
+```sh
+libcall -lm modf double -3.14 out:double -r f64
+# Result: -0.14000000000000012
+# Output parameters:
+#   [1] double = -3.0
+```
+
+JSON output
+
 ```sh
-# JSON output
 libcall --json -lm sqrt double 9.0 -r f64
+# {
+#   "library": "/lib/x86_64-linux-gnu/libm.so",
+#   "function": "sqrt",
+#   "return_type": "double",
+#   "result": 3.0
+# }
+```
 
-# Dry run
-libcall --dry-run ./mylib.so test u64 42 -r void
+Dry run
 
-# Using -L and -l (like gcc)
-libcall -lmylib -L./build add_i32 int 10 int 20 -r i32
+```sh
+libcall --dry-run -lc getpid -r int
+# Library:  /lib/x86_64-linux-gnu/libc.so
+# Function: getpid
+# Return:   int
+```
 
-# TYPE/VALUE pairs with -r after function
-libcall -lm fabs double -5.5 -r f64
-# => 5.5
+Windows: calling C runtime functions
+
+```powershell
+libcall msvcrt.dll sqrt double 16.0 -r f64 # => 4.0
+```
 
-# Windows: calling C runtime functions
-libcall msvcrt.dll sqrt double 16.0 -r f64
-# => 4.0
+Windows: accessing environment variables
 
-# Windows: accessing environment variables
+```powershell
 libcall msvcrt.dll getenv string "PATH" -r cstr
 ```
 
 ## Type Reference
 
-| Suffix | Type            | Range/Note         |
-| ------ | --------------- | ------------------ |
-| `i8`   | signed 8-bit    | -128 to 127        |
-| `u8`   | unsigned 8-bit  | 0 to 255           |
-| `i16`  | signed 16-bit   | -32768 to 32767    |
-| `u16`  | unsigned 16-bit | 0 to 65535         |
-| `i32`  | signed 32-bit   | standard int       |
-| `u32`  | unsigned 32-bit | unsigned int       |
-| `i64`  | signed 64-bit   | long long          |
-| `u64`  | unsigned 64-bit | unsigned long long |
-| `f32`  | 32-bit float    | single precision   |
-| `f64`  | 64-bit float    | double precision   |
+| Short (suffix) | Formal (C)                          | Note/Range         |
+| -------------- | ----------------------------------- | ------------------ |
+| `i8`           | `char` (≈ `int8_t`)                 | -128 to 127        |
+| `u8`           | `unsigned char` (≈ `uint8_t`)       | 0 to 255           |
+| `i16`          | `short` (≈ `int16_t`)               | -32768 to 32767    |
+| `u16`          | `unsigned short` (≈ `uint16_t`)     | 0 to 65535         |
+| `i32`          | `int` (≈ `int32_t`)                 | typical 32-bit int |
+| `u32`          | `unsigned int` (≈ `uint32_t`)       | unsigned 32-bit    |
+| `i64`          | `long long` (≈ `int64_t`)           | 64-bit             |
+| `u64`          | `unsigned long long` (≈ `uint64_t`) | 64-bit             |
+| `f32`          | `float`                             | single precision   |
+| `f64`          | `double`                            | double precision   |
 
 Also supported:
 
@@ -120,6 +143,8 @@ Also supported:
 - `cstr`: C string return (char\*)
 - `ptr`/`pointer`: void\* pointer
 
+See [type_map.rb](lib/libcall/type_map.rb) for all available type mappings.
+
 ## pkg-config Support
 
 Set `PKG_CONFIG_PATH` and use package names with `-l`:
@@ -133,13 +158,70 @@ PKG_CONFIG_PATH=/path/to/pkgconfig libcall -lmypackage func i32 42 -r i32
 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
+# double frexp(double x, int* exp)
+libcall -lm frexp double 8.0 out:int -r f64
 
 # JSON includes an "outputs" array
-libcall --json -ltest -L ./test/fixtures/libtest/build get_version out:int out:int -r void
+libcall --json -lm frexp double 8.0 out:int -r f64
 ```
 
+## Arrays
+
+- Input arrays: `TYPE[]` takes a comma-separated value list.
+
+```sh
+# zlib (Linux/macOS): uLong crc32(uLong crc, const Bytef* buf, uInt len)
+libcall -lz crc32 uint 0 uchar[] 104,101,108,108,111 uint 5 -r uint
+```
+
+- Output arrays: `out:TYPE[N]` allocates N elements and prints them after the call.
+
+```sh
+# Linux (libc): ssize_t getrandom(void* buf, size_t buflen, unsigned int flags)
+libcall -lc getrandom out:uchar[16] size_t 16 uint 0 -r long
+```
+
+```sh
+# macOS (libSystem): void arc4random_buf(void* buf, size_t nbytes)
+libcall -lSystem arc4random_buf out:uchar[16] size_t 16 -r void
+```
+
+## Callbacks (experimental)
+
+Pass a C function pointer via a Ruby callback. Use `func` or `callback` with a quoted spec:
+
+- Syntax: `func 'RET(ARG,ARG,...){|a, b, ...| ruby_code }'` (alias: `callback ...`)
+- Inside the block, helper methods from `Libcall::Fiddley::DSL` are available:
+  - `int(ptr)`, `double(ptr)`, `cstr(ptr)` read values from pointers
+  - `read(:type, ptr)` reads any supported type; `ptr(addr)` makes a pointer
+
+Quick examples
+
+```sh
+# Fixture function: int32_t apply_i32(int32_t, int32_t, int32_t (*)(int32_t,int32_t))
+libcall -ltest -L test/fixtures/libtest/build apply_i32 \
+	int 3 int 5 \
+	func 'int(int,int){|a,b| a + b}' \
+	-r i32
+# => 8
+```
+
+```sh
+# libc qsort: sort 4 ints ascending; use out:int[4] with an initializer so the result prints
+libcall -lc qsort \
+	out:int[4] 4,2,3,1 \
+	size_t 4 \
+	size_t 4 \
+	callback 'int(void*,void*){|pa,pb| int(pa) <=> int(pb) }' \
+	-r void
+# Output parameters:
+#   [0] int[4] = [1, 2, 3, 4]
+```
+
+Notes
+
+- Match the C signature exactly (types and arity). Blocks run in-process; exceptions abort the call.
+
 ## Warning
 
 FFI calls are inherently unsafe. You must:

data/lib/libcall/caller.rb

@@ -18,21 +18,75 @@ module Libcall
       arg_types = []
       arg_values = []
       out_refs = []
+      closures = []
 
       arg_pairs.each_with_index do |(type_sym, value), idx|
-        arg_types << Parser.fiddle_type(type_sym)
-
-        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
+        arg_types << TypeMap.to_fiddle_type(type_sym)
+
+        if type_sym.is_a?(Array)
+          case type_sym.first
+          when :out
+            inner = type_sym[1]
+            ptr = TypeMap.allocate_output_pointer(inner)
+            out_refs << { index: idx, kind: :out, type: inner, ptr: ptr }
+            arg_values << ptr.to_i
+          when :array
+            base = type_sym[1]
+            values = Array(value)
+            ptr = TypeMap.allocate_array(base, values.length)
+            TypeMap.write_array(ptr, base, values)
+            arg_values << ptr.to_i
+          when :out_array
+            base = type_sym[1]
+            count = type_sym[2]
+            ptr = TypeMap.allocate_array(base, count)
+            # Optional initializer values
+            if value
+              vals = Array(value)
+              raise Error, "Initializer length #{vals.length} does not match out array size #{count}" unless vals.length == count
+              TypeMap.write_array(ptr, base, vals)
+            end
+            out_refs << { index: idx, kind: :out_array, base: base, count: count, ptr: ptr }
+            arg_values << ptr.to_i
+          else
+            raise Error, "Unknown array/output form: #{type_sym.inspect}"
+          end
+        elsif type_sym == :callback
+          spec = value
+          unless spec.is_a?(Hash) && spec[:kind] == :callback
+            raise Error, 'Invalid callback value; expected func signature and block'
+          end
+
+          ret_ty = TypeMap.to_fiddle_type(spec[:ret])
+          arg_tys = spec[:args].map { |a| TypeMap.to_fiddle_type(a) }
+          # Build Ruby proc from block source, e.g., "{|a,b| a+b}"
+          # Evaluate proc in a helper context so DSL methods are available
+          ctx = Object.new.extend(Libcall::Fiddley::DSL)
+          begin
+            ruby_proc = ctx.instance_eval("proc #{spec[:block]}", __FILE__, __LINE__)
+          rescue SyntaxError => e
+            raise Error, "Invalid Ruby block for callback: #{e.message}"
+          end
+          closure = Fiddle::Closure::BlockCaller.new(ret_ty, arg_tys) do |*cb_args|
+            # Convert pointer-typed args to Fiddle::Pointer for convenience
+            cooked = cb_args.each_with_index.map do |v, i|
+              at = spec[:args][i]
+              if at == :voidp
+                Fiddle::Pointer.new(v)
+              else
+                v
+              end
+            end
+            ruby_proc.call(*cooked)
+          end
+          closures << closure # keep alive during call
+          arg_values << closure
         else
           arg_values << value
         end
       end
 
-      ret_type = Parser.fiddle_type(return_type)
+      ret_type = TypeMap.to_fiddle_type(return_type)
 
       handle = Fiddle.dlopen(lib_path)
       func_ptr = handle[func_name]
@@ -74,43 +128,20 @@ module Libcall
       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 }
+        case ref[:kind]
+        when :out
+          value = TypeMap.read_output_pointer(ref[:ptr], ref[:type])
+          { index: ref[:index], type: ref[:type].to_s, value: value }
+        when :out_array
+          base = ref[:base]
+          count = ref[:count]
+          values = TypeMap.read_array(ref[:ptr], base, count)
+          { index: ref[:index], type: "#{base}[#{count}]", value: values }
+        else
+          raise Error, "Unknown out reference kind: #{ref[:kind]}"
+        end
       end
     end
   end

data/lib/libcall/cli.rb

@@ -1,10 +1,29 @@
 # frozen_string_literal: true
 
 require 'json'
+require_relative 'platform'
 
 module Libcall
   # Command-line interface for calling C functions from shared libraries
   class CLI
+    PLATFORM_EXAMPLES = {
+      windows: <<~EXAMPLES.chomp,
+        libcall -lmsvcrt puts string "Hello from libcall" -r int
+        libcall -lKernel32 GetTickCount -r uint32
+        libcall -lmsvcrt getenv string "PATH" -r string
+      EXAMPLES
+      darwin: <<~EXAMPLES.chomp,
+        libcall -lSystem getpid -r int
+        libcall -lSystem puts string "Hello from libcall" -r int
+        libcall -lSystem getenv string "PATH" -r string
+      EXAMPLES
+      unix: <<~EXAMPLES.chomp
+        libcall -lm sqrt double 16 -r double
+        libcall -lc getpid -r int
+        libcall -lc getenv string "PATH" -r string
+      EXAMPLES
+    }.freeze
+
     def initialize(argv)
       @argv = argv
       @options = {
@@ -57,19 +76,33 @@ module Libcall
     private
 
     def parse_options_banner
+      examples = if Platform.windows?
+                   PLATFORM_EXAMPLES[:windows]
+                 elsif Platform.darwin?
+                   PLATFORM_EXAMPLES[:darwin]
+                 else
+                   PLATFORM_EXAMPLES[:unix]
+                 end
+
       <<~BANNER
         Usage: libcall [OPTIONS] <LIBRARY> <FUNCTION> (TYPE VALUE)...
 
         Call C functions in shared libraries from the command line.
 
-        Pass arguments as TYPE VALUE pairs only.
+        Arguments are passed as TYPE VALUE pairs.
 
         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
+          #{examples.lines.map { |line| line.chomp }.join("\n  ")}
 
         Options:
+          -l, --lib LIBRARY        Library name to search for (e.g., -lm for libm)
+          -L, --lib-path PATH      Add directory to library search path
+          -r, --ret TYPE           Return type (default: void)
+              --dry-run            Show what would be executed without calling
+              --json               Output result in JSON format
+              --verbose            Show detailed information
+          -h, --help               Show this help message
+          -v, --version            Show version information
       BANNER
     end
 
@@ -122,9 +155,18 @@ module Libcall
 
         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]
+        # TYPE that represents an output pointer/array does not require a value
+        # For out:TYPE[N], allow an optional comma-separated initializer list right after the type.
+        if type_sym.is_a?(Array) && %i[out out_array].include?(type_sym.first)
+          if type_sym.first == :out_array && i < argv.length && argv[i].include?(',')
+            init_tok = argv[i]
+            i += 1
+            base = type_sym[1]
+            values = Parser.coerce_value([:array, base], init_tok)
+            arg_pairs << [type_sym, values]
+          else
+            arg_pairs << [type_sym, nil]
+          end
           next
         end
 
@@ -256,18 +298,16 @@ module Libcall
         end
 
         puts JSON.pretty_generate(output, allow_nan: true)
-      else
-        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
+      elsif 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
-        else
-          puts result unless result.nil?
         end
+      else
+        puts result unless result.nil?
       end
     end
   end

data/lib/libcall/fiddley.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# A tiny helper layer inspired by fiddley (BSD-2-Clause) to offer
+# convenient, DSL-friendly utilities on top of Ruby's Fiddle.
+# This is intentionally small and tailored for libcall use-cases.
+
+require 'fiddle'
+
+module Libcall
+  module Fiddley
+    # Small helper methods intended for use inside callback blocks
+    module DSL
+      module_function
+
+      def ptr(x)
+        Fiddle::Pointer.new(Integer(x))
+      end
+
+      def read(type, p)
+        t = type.is_a?(Symbol) ? type : type.to_s
+        t_sym = Libcall::TypeMap.lookup(t) || (type.is_a?(Symbol) ? type : nil)
+        raise Libcall::Error, "unknown read type: #{type}" unless t_sym
+
+        pp = p.is_a?(Fiddle::Pointer) ? p : Fiddle::Pointer.new(Integer(p))
+        Libcall::TypeMap.read_output_pointer(pp, t_sym)
+      end
+
+      # Typed short-hands
+      def char(p) = read(:char, p)
+      def uchar(p) = read(:uchar, p)
+      def short(p) = read(:short, p)
+      def ushort(p) = read(:ushort, p)
+      def int(p) = read(:int, p)
+      def uint(p) = read(:uint, p)
+      def long(p) = read(:long, p)
+      def ulong(p) = read(:ulong, p)
+      def long_long(p) = read(:long_long, p)
+      def ulong_long(p) = read(:ulong_long, p)
+      def float(p) = read(:float, p)
+      def double(p) = read(:double, p)
+      def cstr(p) = read(:string, p)
+    end
+
+    module Utils
+      module_function
+
+      # Native size_t pack template and size
+      SIZET_PACK = (Fiddle::SIZEOF_VOIDP == Fiddle::SIZEOF_LONG ? 'L!' : 'Q')
+
+      # Return size in bytes for a given type symbol.
+      # Falls back to pointer size for :pointer and :voidp.
+      def sizeof(type)
+        return Fiddle::SIZEOF_SIZE_T if type == :size_t
+        return Fiddle::SIZEOF_VOIDP if %i[pointer voidp].include?(type)
+
+        # Delegate to Libcall::TypeMap when possible
+        Libcall::TypeMap.sizeof(type)
+      rescue StandardError
+        raise Libcall::Error, "unknown type for sizeof: #{type}"
+      end
+
+      # Convert a type symbol to a Fiddle type constant.
+      def to_fiddle_type(type)
+        return Fiddle::TYPE_SIZE_T if type == :size_t
+        return Fiddle::TYPE_VOIDP if %i[pointer voidp].include?(type)
+
+        Libcall::TypeMap.to_fiddle_type(type)
+      rescue StandardError
+        raise Libcall::Error, "unknown type for to_fiddle_type: #{type}"
+      end
+
+      # Pack template for array values of given base type.
+      def array_pack_template(type)
+        return SIZET_PACK if type == :size_t
+
+        # Use TypeMap's packing for standard types
+        Libcall::TypeMap.pack_template(type)
+      rescue StandardError
+        # For generic pointers/addresses, use native unsigned pointer width
+        return 'J' if %i[pointer voidp].include?(type)
+
+        raise Libcall::Error, "Unsupported array base type: #{type}"
+      end
+
+      # Convert Ruby array of numbers to a binary string for the given type
+      def array2str(type, array)
+        array.pack("#{array_pack_template(type)}*")
+      end
+
+      # Convert binary string to Ruby array of the given type
+      def str2array(type, str)
+        str.unpack("#{array_pack_template(type)}*")
+      end
+    end
+
+    # Minimal memory buffer wrapper to make building args/arrays convenient
+    class MemoryPointer
+      attr_reader :size
+
+      def initialize(type, count = 1)
+        @type = type
+        @size = Utils.sizeof(type) * count
+        @ptr = Fiddle::Pointer.malloc(@size)
+      end
+
+      def to_ptr
+        @ptr
+      end
+
+      def address
+        @ptr.to_i
+      end
+
+      def write_array(type, values)
+        data = Utils.array2str(type, Array(values))
+        @ptr[0, data.bytesize] = data
+        self
+      end
+
+      def read_array(type, count)
+        bytes = Utils.sizeof(type) * count
+        Utils.str2array(type, @ptr[0, bytes])
+      end
+
+      def put_bytes(offset, str)
+        @ptr[offset, str.bytesize] = str
+      end
+
+      def write_bytes(str)
+        put_bytes(0, str)
+      end
+
+      def get_bytes(offset, len)
+        @ptr[offset, len]
+      end
+
+      def read_bytes(len)
+        get_bytes(0, len)
+      end
+
+      # Return Fiddle::Pointer stored at this pointer (read void*)
+      def read_pointer
+        to_ptr.ptr
+      end
+    end
+
+    # Wrap Fiddle::Closure::BlockCaller with friendlier type mapping
+    class Function < Fiddle::Closure::BlockCaller
+      def initialize(ret, params, &blk)
+        r = Utils.to_fiddle_type(ret)
+        p = Array(params).map { |t| Utils.to_fiddle_type(t) }
+        super(r, p, &blk)
+      end
+    end
+  end
+end

data/lib/libcall/library_finder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fiddle'
+require_relative 'platform'
 
 begin
   require 'pkg-config'
@@ -19,29 +20,23 @@ module Libcall
     # Find library by name (e.g., "m" -> "/lib/x86_64-linux-gnu/libm.so.6")
     def find(lib_name)
       # If it's a path, return as-is
-      return File.expand_path(lib_name) if lib_name.include?('/') || lib_name.include?('\\')
-      return File.expand_path(lib_name) if File.file?(lib_name)
+      return File.expand_path(lib_name) if path_like?(lib_name)
 
       search_paths = @lib_paths + @default_paths
 
       if defined?(PKGConfig)
-        pkg_exists = if PKGConfig.respond_to?(:exist?)
-                       PKGConfig.exist?(lib_name)
-                     else
-                       PKGConfig.respond_to?(:have_package) ? PKGConfig.have_package(lib_name) : false
-                     end
+        pkg_exists = begin
+          PKGConfig.public_send(
+            PKGConfig.respond_to?(:exist?) ? :exist? : :have_package,
+            lib_name
+          )
+        rescue StandardError
+          false
+        end
 
         if pkg_exists
-          lib_dirs = if PKGConfig.respond_to?(:libs_only_L)
-                       PKGConfig.libs_only_L(lib_name).to_s.split.map { |p| p.start_with?('-L') ? p[2..] : p }
-                     else
-                       PKGConfig.libs(lib_name).to_s.split.select { |t| t.start_with?('-L') }.map { |t| t[2..] }
-                     end
-          lib_names = if PKGConfig.respond_to?(:libs_only_l)
-                        PKGConfig.libs_only_l(lib_name).to_s.split.map { |l| l.start_with?('-l') ? l[2..] : l }
-                      else
-                        PKGConfig.libs(lib_name).to_s.split.select { |t| t.start_with?('-l') }.map { |t| t[2..] }
-                      end
+          lib_dirs = extract_pkg_config_flags(lib_name, 'L')
+          lib_names = extract_pkg_config_flags(lib_name, 'l')
 
           search_paths = lib_dirs + search_paths
 
@@ -62,53 +57,65 @@ module Libcall
 
     private
 
+    def path_like?(name)
+      name.include?('/') || name.include?('\\') || File.file?(name)
+    end
+
+    # Extract -L or -l flags from pkg-config output, normalized without the dash prefix
+    def extract_pkg_config_flags(lib_name, flag_char)
+      base = if flag_char == 'L' && PKGConfig.respond_to?(:libs_only_L)
+               PKGConfig.libs_only_L(lib_name)
+             elsif flag_char == 'l' && PKGConfig.respond_to?(:libs_only_l)
+               PKGConfig.libs_only_l(lib_name)
+             else
+               PKGConfig.libs(lib_name)
+             end
+
+      base.to_s.split
+          .select { |t| t.start_with?("-#{flag_char}") }
+          .map { |t| t[2..] }
+    end
+
     def default_library_paths
-      paths = []
-
-      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
+      (Platform.windows? ? windows_library_paths : unix_library_paths)
+        .select { |p| Dir.exist?(p) }
+    end
 
-        # 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'
-
-        # 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
+    def windows_library_paths
+      paths = %w[C:/Windows/System32 C:/Windows/SysWOW64]
 
-        # macOS paths
-        if RUBY_PLATFORM =~ /darwin/
-          paths << '/usr/local/lib'
-          paths << '/opt/homebrew/lib'
-        end
+      # MSYS2/MinGW paths
+      if ENV['MSYSTEM']
+        msys_prefix = ENV['MINGW_PREFIX'] || 'C:/msys64/mingw64'
+        paths.concat(["#{msys_prefix}/bin", "#{msys_prefix}/lib"])
+      end
 
-        # LD_LIBRARY_PATH
-        paths.concat(ENV['LD_LIBRARY_PATH'].split(':')) if ENV['LD_LIBRARY_PATH']
+      # Add PATH directories on Windows
+      paths.concat(ENV['PATH'].split(';').map { |p| p.tr('\\', '/') }) if ENV['PATH']
 
-        # DYLD_LIBRARY_PATH (macOS)
-        paths.concat(ENV['DYLD_LIBRARY_PATH'].split(':')) if ENV['DYLD_LIBRARY_PATH']
+      paths
+    end
+
+    def unix_library_paths
+      # Standard library paths
+      paths = %w[/lib /usr/lib /usr/local/lib]
+
+      # Architecture-specific paths (Linux)
+      case Platform.architecture
+      when 'x86_64'
+        paths.concat(%w[/lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu])
+      when 'aarch64'
+        paths.concat(%w[/lib/aarch64-linux-gnu /usr/lib/aarch64-linux-gnu])
       end
 
-      paths.select { |p| Dir.exist?(p) }
+      # macOS paths
+      paths.concat(%w[/usr/local/lib /opt/homebrew/lib]) if Platform.darwin?
+
+      # Environment-based paths
+      paths.concat(ENV.fetch('LD_LIBRARY_PATH', '').split(':'))
+      paths.concat(ENV.fetch('DYLD_LIBRARY_PATH', '').split(':'))
+
+      paths
     end
 
     def resolve_by_name_in_paths(lib_name, search_paths)
@@ -119,31 +126,19 @@ module Libcall
       end
 
       # Try with lib prefix and common extensions
-      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', '']
+      extensions = Platform.library_extensions
 
-      prefixes.each do |prefix|
-        extensions.each do |ext|
-          name = "#{prefix}#{lib_name}#{ext}"
-          search_paths.each do |path|
-            full_path = File.join(path, name)
-            return File.expand_path(full_path) if File.file?(full_path)
+      prefixes.product(extensions, search_paths).each do |prefix, ext, path|
+        name = "#{prefix}#{lib_name}#{ext}"
+        full_path = File.join(path, name)
+        return File.expand_path(full_path) if File.file?(full_path)
 
-            # Check for versioned libraries (libm.so.6, etc.)
-            next if ext.empty?
+        # Check for versioned libraries (libm.so.6, etc.)
+        next if ext.empty?
 
-            pattern = File.join(path, "#{name}.*")
-            matches = Dir.glob(pattern).select { |f| File.file?(f) }
-            return File.expand_path(matches.first) unless matches.empty?
-          end
-        end
+        matches = Dir.glob(File.join(path, "#{name}.*")).select { |f| File.file?(f) }
+        return File.expand_path(matches.first) unless matches.empty?
       end
 
       nil

data/lib/libcall/parser.rb

@@ -1,51 +1,44 @@
 # frozen_string_literal: true
 
+require_relative 'type_map'
+
 module Libcall
   # Parse and coerce TYPE VALUE argument pairs for FFI calls
   class Parser
-    TYPE_MAP = {
-      'i8' => :char,
-      'u8' => :uchar,
-      'i16' => :short,
-      'u16' => :ushort,
-      'i32' => :int,
-      'u32' => :uint,
-      'i64' => :long_long,
-      'u64' => :ulong_long,
-      'isize' => :long,
-      'usize' => :ulong,
-      'f32' => :float,
-      'f64' => :double,
-      'cstr' => :string,
-      'ptr' => :voidp,
-      'pointer' => :voidp,
-      'void' => :void,
-      # Common aliases
-      'int' => :int,
-      'uint' => :uint,
-      'long' => :long,
-      'ulong' => :ulong,
-      'float' => :float,
-      'double' => :double,
-      'char' => :char,
-      'str' => :string,
-      'string' => :string
-    }.freeze
-
-    INTEGER_TYPES = %i[int uint long ulong long_long ulong_long char uchar short ushort].freeze
-    FLOAT_TYPES = %i[float double].freeze
-
     # Pair-only API helpers
     def self.parse_type(type_str)
+      # Callback function pointer: func/callback 'ret(arg,...) { |...| ... }'
+      return :callback if %w[func callback].include?(type_str)
+
+      # Output array spec: out:TYPE[N]
+      if type_str.start_with?('out:') && type_str.match(/^out:(.+)\[(\d+)\]$/)
+        base = Regexp.last_match(1)
+        count = Regexp.last_match(2).to_i
+        base_sym = TypeMap.lookup(base)
+        raise Error, "Unknown output array type: #{base}" unless base_sym
+
+        return [:out_array, base_sym, count]
+      end
+
+      # Input array spec: TYPE[] (value as comma-separated list)
+      if type_str.end_with?('[]')
+        base = type_str[0..-3]
+        base_sym = TypeMap.lookup(base)
+        raise Error, "Unknown array base type: #{base}" unless base_sym
+
+        return [:array, base_sym]
+      end
+
       # 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]
+        inner_sym = TypeMap.lookup(inner)
         raise Error, "Unknown type in out: #{inner}" unless inner_sym
+
         return [:out, inner_sym]
       end
 
-      type_sym = TYPE_MAP[type_str]
+      type_sym = TypeMap.lookup(type_str)
       raise Error, "Unknown type: #{type_str}" unless type_sym
 
       type_sym
@@ -54,17 +47,51 @@ module Libcall
     def self.parse_return_type(type_str)
       return :void if type_str.nil? || type_str.empty? || type_str == 'void'
 
-      type_sym = TYPE_MAP[type_str]
+      type_sym = TypeMap.lookup(type_str)
       raise Error, "Unknown return type: #{type_str}" unless type_sym
 
       type_sym
     end
 
     def self.coerce_value(type_sym, token)
+      # Callback value: signature + Ruby block
+      if type_sym == :callback
+        src = strip_quotes(token.to_s)
+        m = src.match(/\A\s*([^(\s]+)\s*\(([^)]*)\)\s*(\{.*\})\s*\z/m)
+        raise Error, "Invalid callback spec: #{src}" unless m
+
+        ret_s = m[1].strip
+        args_s = m[2].strip
+        block_src = m[3]
+
+        ret_sym = TypeMap.lookup(ret_s)
+        raise Error, "Unknown callback return type: #{ret_s}" unless ret_sym
+
+        arg_syms = if args_s.empty?
+                     []
+                   else
+                     args_s.split(',').map(&:strip).map do |a|
+                       sym = TypeMap.lookup(a)
+                       raise Error, "Unknown callback arg type: #{a}" unless sym
+
+                       sym
+                     end
+                   end
+
+        return { kind: :callback, ret: ret_sym, args: arg_syms, block: block_src }
+      end
+      # Input array values: comma-separated
+      if type_sym.is_a?(Array) && type_sym.first == :array
+        base = type_sym[1]
+        return [] if token.nil? || token.empty?
+
+        return token.split(',').map { |t| coerce_single_value(base, t.strip) }
+      end
+
       case type_sym
-      when *FLOAT_TYPES
+      when *TypeMap::FLOAT_TYPES
         Float(token)
-      when *INTEGER_TYPES
+      when *TypeMap::INTEGER_TYPES
         Integer(token)
       when :voidp
         # Accept common null tokens for pointer types
@@ -80,32 +107,24 @@ module Libcall
       end
     end
 
-    def self.strip_quotes(token)
-      if (token.start_with?('"') && token.end_with?('"')) || (token.start_with?("'") && token.end_with?("'"))
-        token[1...-1]
+    def self.coerce_single_value(type_sym, token)
+      case type_sym
+      when *TypeMap::FLOAT_TYPES
+        Float(token)
+      when *TypeMap::INTEGER_TYPES
+        Integer(token)
+      when :string
+        strip_quotes(token)
       else
-        token
+        raise Error, "Unknown element type for coercion: #{type_sym}"
       end
     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
-      when :uchar then Fiddle::TYPE_UCHAR
-      when :short then Fiddle::TYPE_SHORT
-      when :ushort then Fiddle::TYPE_USHORT
-      when :int, :uint then Fiddle::TYPE_INT
-      when :long, :ulong then Fiddle::TYPE_LONG
-      when :long_long, :ulong_long then Fiddle::TYPE_LONG_LONG
-      when :float then Fiddle::TYPE_FLOAT
-      when :double then Fiddle::TYPE_DOUBLE
-      when :voidp, :string then Fiddle::TYPE_VOIDP
+    def self.strip_quotes(token)
+      if (token.start_with?('"') && token.end_with?('"')) || (token.start_with?("'") && token.end_with?("'"))
+        token[1...-1]
       else
-        raise Error, "Unknown Fiddle type: #{type_sym}"
+        token
       end
     end
   end

data/lib/libcall/platform.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Libcall
+  # Platform detection utilities
+  module Platform
+    # Check if running on Windows
+    def self.windows?
+      RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+    end
+
+    # Check if running on macOS
+    def self.darwin?
+      RUBY_PLATFORM =~ /darwin/
+    end
+
+    # Check if running on Unix-like system (Linux, BSD, etc.)
+    def self.unix?
+      !windows?
+    end
+
+    # Get platform-specific library extensions
+    def self.library_extensions
+      if windows?
+        ['', '.dll', '.so', '.a']
+      elsif darwin?
+        ['', '.dylib', '.so', '.a']
+      else
+        ['', '.so', '.a']
+      end
+    end
+
+    # Get architecture string
+    def self.architecture
+      if RUBY_PLATFORM =~ /x86_64/
+        'x86_64'
+      elsif RUBY_PLATFORM =~ /aarch64|arm64/
+        'aarch64'
+      else
+        'unknown'
+      end
+    end
+  end
+end

data/lib/libcall/type_map.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+
+module Libcall
+  # Type mapping for FFI calls
+  module TypeMap
+    # Map from string type names to FFI type symbols
+    MAP = {
+      # Short type names (Rust-like)
+      'i8' => :char,
+      'u8' => :uchar,
+      'i16' => :short,
+      'u16' => :ushort,
+      'i32' => :int,
+      'u32' => :uint,
+      'i64' => :long_long,
+      'u64' => :ulong_long,
+      'isize' => :long,
+      'usize' => :ulong,
+      'f32' => :float,
+      'f64' => :double,
+      # Pointer types
+      'cstr' => :string,
+      'ptr' => :voidp,
+      'pointer' => :voidp,
+      'void' => :void,
+      # Common C type names
+      'char' => :char,
+      'uchar' => :uchar,
+      'short' => :short,
+      'ushort' => :ushort,
+      'int' => :int,
+      'uint' => :uint,
+      'long' => :long,
+      'ulong' => :ulong,
+      'float' => :float,
+      'double' => :double,
+      # C-style pointer aliases
+      'void*' => :voidp,
+      'const void*' => :voidp,
+      'const_void*' => :voidp,
+      'const_voidp' => :voidp,
+      # Underscored variants
+      'unsigned_char' => :uchar,
+      'unsigned_short' => :ushort,
+      'unsigned_int' => :uint,
+      'unsigned_long' => :ulong,
+      'long_long' => :long_long,
+      'unsigned_long_long' => :ulong_long,
+      # Short aliases
+      'unsigned' => :uint,
+      'signed' => :int,
+      # Extended type names (stdint-like)
+      'int8' => :char,
+      'uint8' => :uchar,
+      'int16' => :short,
+      'uint16' => :ushort,
+      'int32' => :int,
+      'uint32' => :uint,
+      'int64' => :long_long,
+      'uint64' => :ulong_long,
+      'float32' => :float,
+      'float64' => :double,
+      # C99/C11 standard types with _t suffix
+      'int8_t' => :char,
+      'uint8_t' => :uchar,
+      'int16_t' => :short,
+      'uint16_t' => :ushort,
+      'int32_t' => :int,
+      'uint32_t' => :uint,
+      'int64_t' => :long_long,
+      'uint64_t' => :ulong_long,
+      # Size and pointer-sized integers
+      'size_t' => :ulong,
+      'ssize_t' => :long,
+      'intptr' => :long,
+      'uintptr' => :ulong,
+      'intptr_t' => :long,
+      'uintptr_t' => :ulong,
+      'ptrdiff_t' => :long,
+      # Boolean
+      'bool' => :int,
+      # String aliases
+      'str' => :string,
+      'string' => :string
+    }.freeze
+
+    # Integer type symbols
+    INTEGER_TYPES = %i[
+      int uint
+      long ulong
+      long_long ulong_long
+      char uchar
+      short ushort
+    ].freeze
+
+    # Floating point type symbols
+    FLOAT_TYPES = %i[float double].freeze
+
+    # Look up FFI type symbol from string
+    def self.lookup(type_str)
+      MAP[type_str]
+    end
+
+    # Check if type symbol is an integer type
+    def self.integer_type?(type_sym)
+      INTEGER_TYPES.include?(type_sym)
+    end
+
+    # Check if type symbol is a floating point type
+    def self.float_type?(type_sym)
+      FLOAT_TYPES.include?(type_sym)
+    end
+
+    # Convert type symbol to Fiddle type constant
+    def self.to_fiddle_type(type_sym)
+      # Array and output parameters are passed as pointers
+      if type_sym.is_a?(Array)
+        tag = type_sym.first
+        return Fiddle::TYPE_VOIDP if %i[out array out_array].include?(tag)
+      end
+
+      # Callback function pointers are passed as void*
+      return Fiddle::TYPE_VOIDP if type_sym == :callback
+
+      case type_sym
+      when :void then Fiddle::TYPE_VOID
+      when :char then Fiddle::TYPE_CHAR
+      when :uchar then Fiddle::TYPE_UCHAR
+      when :short then Fiddle::TYPE_SHORT
+      when :ushort then Fiddle::TYPE_USHORT
+      when :int, :uint then Fiddle::TYPE_INT
+      when :long, :ulong then Fiddle::TYPE_LONG
+      when :long_long, :ulong_long then Fiddle::TYPE_LONG_LONG
+      when :float then Fiddle::TYPE_FLOAT
+      when :double then Fiddle::TYPE_DOUBLE
+      when :voidp, :string then Fiddle::TYPE_VOIDP
+      else
+        raise Error, "Unknown Fiddle type: #{type_sym}"
+      end
+    end
+
+    # Get the size in bytes for a type symbol
+    def self.sizeof(type_sym)
+      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, :string then Fiddle::SIZEOF_VOIDP
+      else
+        raise Error, "Cannot get size for type: #{type_sym}"
+      end
+    end
+
+    # Allocate a pointer for output parameter
+    def self.allocate_output_pointer(type_sym)
+      ptr = Fiddle::Pointer.malloc(sizeof(type_sym))
+      # For out:string, we pass char**. Initialize inner pointer to NULL for safety.
+      ptr[0, Fiddle::SIZEOF_VOIDP] = [0].pack('J') if type_sym == :string
+      ptr
+    end
+
+    # Read value from output pointer
+    def self.read_output_pointer(ptr, type_sym)
+      case type_sym
+      when :char then ptr[0, Fiddle::SIZEOF_CHAR].unpack1('c')
+      when :uchar then ptr[0, Fiddle::SIZEOF_CHAR].unpack1('C')
+      when :short then ptr[0, Fiddle::SIZEOF_SHORT].unpack1('s')
+      when :ushort then ptr[0, Fiddle::SIZEOF_SHORT].unpack1('S')
+      when :int then ptr[0, Fiddle::SIZEOF_INT].unpack1('i')
+      when :uint then ptr[0, Fiddle::SIZEOF_INT].unpack1('I')
+      when :long then ptr[0, Fiddle::SIZEOF_LONG].unpack1('l!')
+      when :ulong then ptr[0, Fiddle::SIZEOF_LONG].unpack1('L!')
+      when :long_long then ptr[0, Fiddle::SIZEOF_LONG_LONG].unpack1('q')
+      when :ulong_long then ptr[0, Fiddle::SIZEOF_LONG_LONG].unpack1('Q')
+      when :float then ptr[0, Fiddle::SIZEOF_FLOAT].unpack1('f')
+      when :double then ptr[0, Fiddle::SIZEOF_DOUBLE].unpack1('d')
+      when :string
+        addr = ptr[0, Fiddle::SIZEOF_VOIDP].unpack1('J')
+        return '(null)' if addr.zero?
+
+        begin
+          Fiddle::Pointer.new(addr).to_s
+        rescue StandardError
+          format('0x%x', addr)
+        end
+      when :voidp then format('0x%x', ptr[0, Fiddle::SIZEOF_VOIDP].unpack1('J'))
+      else
+        raise Error, "Cannot read output value for type: #{type_sym}"
+      end
+    end
+
+    # Read a single scalar value at address (helper for callbacks)
+    def self.read_scalar(ptr, type_sym)
+      read_output_pointer(ptr, type_sym)
+    end
+
+    # Allocate memory for an array of base type and count elements
+    def self.allocate_array(base_type, count)
+      Fiddle::Pointer.malloc(sizeof(base_type) * count)
+    end
+
+    def self.write_array(ptr, base_type, values)
+      return if values.nil? || values.empty?
+
+      bytes = sizeof(base_type) * values.length
+      ptr[0, bytes] = values.pack(pack_template(base_type) + values.length.to_s)
+    end
+
+    def self.read_array(ptr, base_type, count)
+      return [] if count <= 0
+
+      bytes = sizeof(base_type) * count
+      raw = ptr[0, bytes]
+      raw.unpack(pack_template(base_type) + count.to_s)
+    end
+
+    def self.pack_template(base_type)
+      case base_type
+      when :char then 'c'
+      when :uchar then 'C'
+      when :short then 's'
+      when :ushort then 'S'
+      when :int then 'i'
+      when :uint then 'I'
+      when :long then 'l!'
+      when :ulong then 'L!'
+      when :long_long then 'q'
+      when :ulong_long then 'Q'
+      when :float then 'f'
+      when :double then 'd'
+      else
+        raise Error, "Unsupported array base type: #{base_type}"
+      end
+    end
+  end
+end

data/lib/libcall/version.rb

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

data/lib/libcall.rb

@@ -5,6 +5,7 @@ require_relative 'libcall/parser'
 require_relative 'libcall/library_finder'
 require_relative 'libcall/caller'
 require_relative 'libcall/cli'
+require_relative 'libcall/fiddley'
 
 module Libcall
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libcall
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - kojix2
@@ -49,8 +49,11 @@ files:
 - lib/libcall.rb
 - lib/libcall/caller.rb
 - lib/libcall/cli.rb
+- lib/libcall/fiddley.rb
 - lib/libcall/library_finder.rb
 - lib/libcall/parser.rb
+- lib/libcall/platform.rb
+- lib/libcall/type_map.rb
 - lib/libcall/version.rb
 homepage: https://github.com/kojix2/libcall
 licenses:
@@ -70,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Call functions in shared libraries directly from the CLI
 test_files: []