tricu

ffi.php (4758B)

---

 <?php
 
 declare(strict_types=1);
 
 namespace Arboricx;
 
 /**
  * FFI wrapper around libarboricx.so.
  *
  * Loads the shared library and exposes typed wrappers for the C ABI.
  */
 final class ArboricxFFI
 {
     private static ?\FFI $ffi = null;
 
     public static function init(string $libPath): void
     {
         if (self::$ffi !== null) {
             return;
         }
 
         // Nix output layout first, then repo layout.
         $candidates = [
             __DIR__ . '/../arboricx.h',
             __DIR__ . '/../../zig/include/arboricx.h',
         ];
         $headerRaw = false;
         foreach ($candidates as $path) {
             if (!is_file($path)) continue;
             $headerRaw = file_get_contents($path);
             if ($headerRaw !== false) break;
         }
         if ($headerRaw === false) {
             throw new \RuntimeException('Cannot read arboricx.h');
         }
 
         // PHP FFI only parses plain C declarations.
         $header = $headerRaw;
         $header = preg_replace('/#.*\n/', "\n", $header);
         $header = preg_replace('/extern\s+"C"\s*\{/', '', $header);
         $header = preg_replace('/^\}\s*$/m', '', $header);
         $header = preg_replace('/\n\s*\n+/', "\n", $header);
 
         self::$ffi = \FFI::cdef($header, $libPath);
         if (self::$ffi->arb_abi_version() !== 2) {
             throw new \RuntimeException('Arboricx ABI v2 required');
         }
     }
 
     public static function ffi(): \FFI
     {
         if (self::$ffi === null) {
             throw new \RuntimeException('ArboricxFFI not initialized. Call ArboricxFFI::init($libPath) first.');
         }
         return self::$ffi;
     }
 }
 
 function ctx_init(string $libPath): \FFI\CData
 {
     ArboricxFFI::init($libPath);
     $ctx = ArboricxFFI::ffi()->arboricx_init();
     if ($ctx === null) {
         throw new \RuntimeException('arboricx_init failed');
     }
     return $ctx;
 }
 
 function ctx_free(\FFI\CData $ctx): void
 {
     ArboricxFFI::ffi()->arboricx_free($ctx);
 }
 
 function owned(string $name, mixed ...$args): int
 {
     $ffi = ArboricxFFI::ffi();
     $out = $ffi->new('arb_handle_t');
     $status = $ffi->$name(...[...$args, \FFI::addr($out)]);
     if ($status !== 0) throw new \RuntimeException("$name: status $status");
     return (int) $out->cdata;
 }
 
 function retain(\FFI\CData $ctx, int $handle): int
 {
     return owned('arb_retain', $ctx, $handle);
 }
 
 function release(\FFI\CData $ctx, int $handle): void
 {
     $status = ArboricxFFI::ffi()->arb_release($ctx, $handle);
     if ($status !== 0) throw new \RuntimeException("arb_release: status $status");
 }
 
 function collect(\FFI\CData $ctx): void
 {
     $status = ArboricxFFI::ffi()->arb_collect($ctx);
     if ($status !== 0) throw new \RuntimeException("arb_collect: status $status");
 }
 
 function app(\FFI\CData $ctx, int $func, int $arg): int
 {
     return owned('arb_app', $ctx, $func, $arg);
 }
 
 function reduce(\FFI\CData $ctx, int $root, int $fuel = 1_000_000_000): int
 {
     return owned('arb_reduce', $ctx, $root, $fuel);
 }
 
 function ofNumber(\FFI\CData $ctx, int $n): int
 {
     return owned('arb_of_number', $ctx, $n);
 }
 
 function ofString(\FFI\CData $ctx, string $s): int
 {
     return owned('arb_of_string', $ctx, $s);
 }
 
 function toNumber(\FFI\CData $ctx, int $root): int
 {
     $out = ArboricxFFI::ffi()->new('uint64_t');
     $ok = ArboricxFFI::ffi()->arb_to_number($ctx, $root, \FFI::addr($out));
     if ($ok !== 0) {
         throw new \RuntimeException('arb_to_number failed');
     }
     return (int) $out->cdata;
 }
 
 function toString(\FFI\CData $ctx, int $root): string
 {
     $ptr = ArboricxFFI::ffi()->new('uint8_t*');
     $len = ArboricxFFI::ffi()->new('size_t');
     $ok = ArboricxFFI::ffi()->arb_to_string($ctx, $root, \FFI::addr($ptr), \FFI::addr($len));
     if ($ok !== 0) {
         throw new \RuntimeException('arb_to_string failed');
     }
     $length = (int) $len->cdata;
     $result = '';
     for ($i = 0; $i < $length; $i++) {
         $result .= chr($ptr[$i]);
     }
     ArboricxFFI::ffi()->arboricx_free_buf($ctx, $ptr, $length);
     return $result;
 }
 
 function toBool(\FFI\CData $ctx, int $root): bool
 {
     $out = ArboricxFFI::ffi()->new('int');
     $ok = ArboricxFFI::ffi()->arb_to_bool($ctx, $root, \FFI::addr($out));
     if ($ok !== 0) {
         throw new \RuntimeException('arb_to_bool failed');
     }
     return (bool) $out->cdata;
 }
 
 function loadBundleDefault(\FFI\CData $ctx, string $bytes): int
 {
     $cdata = ArboricxFFI::ffi()->new('uint8_t[' . strlen($bytes) . ']');
     for ($i = 0; $i < strlen($bytes); $i++) {
         $cdata[$i] = ord($bytes[$i]);
     }
     $result = owned('arb_load_bundle_default', $ctx, $cdata, strlen($bytes));
     if ($result === 0) {
         throw new \RuntimeException('arb_load_bundle_default failed');
     }
     return $result;
 }