Build modified streamline images

The official image from streamline does not currently work for the arm64
platform. As a temporary measure, the source code and docker build scripts
have been lifted from the official images and are used to build locally.

Some additional modifications are made to reduce overall image size, these
are documented in docker/README.md

docker/streamline-src/vendor/symfony/var-dumper/Caster/FFICaster.php

@@ -0,0 +1,161 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * 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 <nesk@xakep.ru>
+ */
+final class FFICaster
+{
+    /**
+     * In case of "char*" 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->class = sprintf('%s<%s> size %d align %d', ($data ?? $type)::class, $type->getName(), $type->getSize(), $type->getAlignment());
+
+        return match ($type->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 => null !== $data ? [Caster::PREFIX_VIRTUAL.'cdata' => $data->cdata] : [],
+            CType::TYPE_POINTER => self::castFFIPointer($stub, $type, $data),
+            CType::TYPE_STRUCT => self::castFFIStructLike($type, $data),
+            CType::TYPE_FUNC => self::castFFIFunction($stub, $type),
+            default => $args,
+        };
+    }
+
+    private static function castFFIFunction(Stub $stub, CType $type): array
+    {
+        $arguments = [];
+
+        for ($i = 0, $count = $type->getFuncParameterCount(); $i < $count; ++$i) {
+            $param = $type->getFuncParameterType($i);
+
+            $arguments[] = $param->getName();
+        }
+
+        $abi = match ($type->getFuncABI()) {
+            CType::ABI_DEFAULT,
+            CType::ABI_CDECL => '[cdecl]',
+            CType::ABI_FASTCALL => '[fastcall]',
+            CType::ABI_THISCALL => '[thiscall]',
+            CType::ABI_STDCALL => '[stdcall]',
+            CType::ABI_PASCAL => '[pascal]',
+            CType::ABI_REGISTER => '[register]',
+            CType::ABI_MS => '[ms]',
+            CType::ABI_SYSV => '[sysv]',
+            CType::ABI_VECTORCALL => '[vectorcall]',
+            default => '[unknown abi]'
+        };
+
+        $returnType = $type->getFuncReturnType();
+
+        $stub->class = $abi.' callable('.implode(', ', $arguments).'): '
+            .$returnType->getName();
+
+        return [Caster::PREFIX_VIRTUAL.'returnType' => $returnType];
+    }
+
+    private static function castFFIPointer(Stub $stub, CType $type, ?CData $data = null): array
+    {
+        $ptr = $type->getPointerType();
+
+        if (null === $data) {
+            return [Caster::PREFIX_VIRTUAL.'0' => $ptr];
+        }
+
+        return match ($ptr->getKind()) {
+            CType::TYPE_CHAR => [Caster::PREFIX_VIRTUAL.'cdata' => self::castFFIStringValue($data)],
+            CType::TYPE_FUNC => self::castFFIFunction($stub, $ptr),
+            default => [Caster::PREFIX_VIRTUAL.'cdata' => $data[0]],
+        };
+    }
+
+    private static function castFFIStringValue(CData $data): string|CutStub
+    {
+        $result = [];
+
+        for ($i = 0; $i < self::MAX_STRING_LENGTH; ++$i) {
+            $result[$i] = $data[$i];
+
+            if ("\0" === $result[$i]) {
+                return implode('', $result);
+            }
+        }
+
+        $string = implode('', $result);
+        $stub = new CutStub($string);
+        $stub->cut = -1;
+        $stub->value = $string;
+
+        return $stub;
+    }
+
+    private static function castFFIStructLike(CType $type, ?CData $data = null): array
+    {
+        $isUnion = ($type->getAttributes() & CType::ATTR_UNION) === CType::ATTR_UNION;
+
+        $result = [];
+
+        foreach ($type->getStructFieldNames() as $name) {
+            $field = $type->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 && CType::TYPE_POINTER === $field->getKind();
+
+            if ($isUnsafe) {
+                $result[Caster::PREFIX_VIRTUAL.$name.'?'] = $field;
+            } elseif (null === $data) {
+                $result[Caster::PREFIX_VIRTUAL.$name] = $field;
+            } else {
+                $fieldName = $data->{$name} instanceof CData ? '' : $field->getName().' ';
+                $result[Caster::PREFIX_VIRTUAL.$fieldName.$name] = $data->{$name};
+            }
+        }
+
+        return $result;
+    }
+}