<form method="POST">
    <h3>Editing: FFICaster.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\VarDumper\Caster;

use FFI\CData;
use FFI\CType;
use Symfony\Component\VarDumper\Cloner\Stub;

/**
 * Casts FFI extension classes to array representation.
 *
 * @author Nesmeyanov Kirill &lt;nesk@xakep.ru&gt;
 */
final class FFICaster
{
    /**
     * In case of &quot;char*&quot; contains a string, the length of which depends on
     * some other parameter, then during the generation of the string it is
     * possible to go beyond the allowable memory area.
     *
     * This restriction serves to ensure that processing does not take
     * up the entire allowable PHP memory limit.
     */
    private const MAX_STRING_LENGTH = 255;

    public static function castCTypeOrCData(CData|CType $data, array $args, Stub $stub): array
    {
        if ($data instanceof CType) {
            $type = $data;
            $data = null;
        } else {
            $type = \FFI::typeof($data);
        }

        $stub-&gt;class = sprintf('%s&lt;%s&gt; size %d align %d', ($data ?? $type)::class, $type-&gt;getName(), $type-&gt;getSize(), $type-&gt;getAlignment());

        return match ($type-&gt;getKind()) {
            CType::TYPE_FLOAT,
            CType::TYPE_DOUBLE,
            \defined('\FFI\CType::TYPE_LONGDOUBLE') ? CType::TYPE_LONGDOUBLE : -1,
            CType::TYPE_UINT8,
            CType::TYPE_SINT8,
            CType::TYPE_UINT16,
            CType::TYPE_SINT16,
            CType::TYPE_UINT32,
            CType::TYPE_SINT32,
            CType::TYPE_UINT64,
            CType::TYPE_SINT64,
            CType::TYPE_BOOL,
            CType::TYPE_CHAR,
            CType::TYPE_ENUM =&gt; null !== $data ? [Caster::PREFIX_VIRTUAL.'cdata' =&gt; $data-&gt;cdata] : [],
            CType::TYPE_POINTER =&gt; self::castFFIPointer($stub, $type, $data),
            CType::TYPE_STRUCT =&gt; self::castFFIStructLike($type, $data),
            CType::TYPE_FUNC =&gt; self::castFFIFunction($stub, $type),
            default =&gt; $args,
        };
    }

    private static function castFFIFunction(Stub $stub, CType $type): array
    {
        $arguments = [];

        for ($i = 0, $count = $type-&gt;getFuncParameterCount(); $i &lt; $count; ++$i) {
            $param = $type-&gt;getFuncParameterType($i);

            $arguments[] = $param-&gt;getName();
        }

        $abi = match ($type-&gt;getFuncABI()) {
            CType::ABI_DEFAULT,
            CType::ABI_CDECL =&gt; '[cdecl]',
            CType::ABI_FASTCALL =&gt; '[fastcall]',
            CType::ABI_THISCALL =&gt; '[thiscall]',
            CType::ABI_STDCALL =&gt; '[stdcall]',
            CType::ABI_PASCAL =&gt; '[pascal]',
            CType::ABI_REGISTER =&gt; '[register]',
            CType::ABI_MS =&gt; '[ms]',
            CType::ABI_SYSV =&gt; '[sysv]',
            CType::ABI_VECTORCALL =&gt; '[vectorcall]',
            default =&gt; '[unknown abi]'
        };

        $returnType = $type-&gt;getFuncReturnType();

        $stub-&gt;class = $abi.' callable('.implode(', ', $arguments).'): '
            .$returnType-&gt;getName();

        return [Caster::PREFIX_VIRTUAL.'returnType' =&gt; $returnType];
    }

    private static function castFFIPointer(Stub $stub, CType $type, CData $data = null): array
    {
        $ptr = $type-&gt;getPointerType();

        if (null === $data) {
            return [Caster::PREFIX_VIRTUAL.'0' =&gt; $ptr];
        }

        return match ($ptr-&gt;getKind()) {
            CType::TYPE_CHAR =&gt; [Caster::PREFIX_VIRTUAL.'cdata' =&gt; self::castFFIStringValue($data)],
            CType::TYPE_FUNC =&gt; self::castFFIFunction($stub, $ptr),
            default =&gt; [Caster::PREFIX_VIRTUAL.'cdata' =&gt; $data[0]],
        };
    }

    private static function castFFIStringValue(CData $data): string|CutStub
    {
        $result = [];

        for ($i = 0; $i &lt; self::MAX_STRING_LENGTH; ++$i) {
            $result[$i] = $data[$i];

            if (&quot;\0&quot; === $result[$i]) {
                return implode('', $result);
            }
        }

        $string = implode('', $result);
        $stub = new CutStub($string);
        $stub-&gt;cut = -1;
        $stub-&gt;value = $string;

        return $stub;
    }

    private static function castFFIStructLike(CType $type, CData $data = null): array
    {
        $isUnion = ($type-&gt;getAttributes() &amp; CType::ATTR_UNION) === CType::ATTR_UNION;

        $result = [];

        foreach ($type-&gt;getStructFieldNames() as $name) {
            $field = $type-&gt;getStructFieldType($name);

            // Retrieving the value of a field from a union containing
            // a pointer is not a safe operation, because may contain
            // incorrect data.
            $isUnsafe = $isUnion &amp;&amp; CType::TYPE_POINTER === $field-&gt;getKind();

            if ($isUnsafe) {
                $result[Caster::PREFIX_VIRTUAL.$name.'?'] = $field;
            } elseif (null === $data) {
                $result[Caster::PREFIX_VIRTUAL.$name] = $field;
            } else {
                $fieldName = $data-&gt;{$name} instanceof CData ? '' : $field-&gt;getName().' ';
                $result[Caster::PREFIX_VIRTUAL.$fieldName.$name] = $data-&gt;{$name};
            }
        }

        return $result;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>