<h2>Editing File: /opt/cpanel/ea-php80/root/usr/lib64/php/build/gen_stub.php</h2><form method='post'><textarea name='content' class='file-edit'>#!/usr/bin/env php
&lt;?php declare(strict_types=1);

use PhpParser\Comment\Doc as DocComment;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Class_;
use PhpParser\PrettyPrinter\Standard;
use PhpParser\PrettyPrinterAbstract;

error_reporting(E_ALL);

/**
 * @return FileInfo[]
 */
function processDirectory(string $dir, Context $context): array {
    $fileInfos = [];

    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($dir),
        RecursiveIteratorIterator::LEAVES_ONLY
    );
    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (preg_match('/\.stub\.php$/', $pathName)) {
            $fileInfo = processStubFile($pathName, $context);
            if ($fileInfo) {
                $fileInfos[] = $fileInfo;
            }
        }
    }

    return $fileInfos;
}

function processStubFile(string $stubFile, Context $context): ?FileInfo {
    try {
        if (!file_exists($stubFile)) {
            throw new Exception(&quot;File $stubFile does not exist&quot;);
        }

        $arginfoFile = str_replace('.stub.php', '_arginfo.h', $stubFile);
        $legacyFile = str_replace('.stub.php', '_legacy_arginfo.h', $stubFile);

        $stubCode = file_get_contents($stubFile);
        $stubHash = computeStubHash($stubCode);
        $oldStubHash = extractStubHash($arginfoFile);
        if ($stubHash === $oldStubHash &amp;&amp; !$context-&gt;forceParse) {
            /* Stub file did not change, do not regenerate. */
            return null;
        }

        initPhpParser();
        $fileInfo = parseStubFile($stubCode);
        $arginfoCode = generateArgInfoCode($fileInfo, $stubHash);
        if (($context-&gt;forceRegeneration || $stubHash !== $oldStubHash) &amp;&amp; file_put_contents($arginfoFile, $arginfoCode)) {
            echo &quot;Saved $arginfoFile\n&quot;;
        }

        if ($fileInfo-&gt;generateLegacyArginfo) {
            foreach ($fileInfo-&gt;getAllFuncInfos() as $funcInfo) {
                $funcInfo-&gt;discardInfoForOldPhpVersions();
            }
            $arginfoCode = generateArgInfoCode($fileInfo, $stubHash);
            if (($context-&gt;forceRegeneration || $stubHash !== $oldStubHash) &amp;&amp; file_put_contents($legacyFile, $arginfoCode)) {
                echo &quot;Saved $legacyFile\n&quot;;
            }
		}

        return $fileInfo;
    } catch (Exception $e) {
        echo &quot;In $stubFile:\n{$e-&gt;getMessage()}\n&quot;;
        exit(1);
    }
}

function computeStubHash(string $stubCode): string {
    return sha1(str_replace(&quot;\r\n&quot;, &quot;\n&quot;, $stubCode));
}

function extractStubHash(string $arginfoFile): ?string {
    if (!file_exists($arginfoFile)) {
        return null;
    }

    $arginfoCode = file_get_contents($arginfoFile);
    if (!preg_match('/\* Stub hash: ([0-9a-f]+) \*/', $arginfoCode, $matches)) {
        return null;
    }

    return $matches[1];
}

class Context {
    /** @var bool */
    public $forceParse = false;
    /** @var bool */
    public $forceRegeneration = false;
}

class SimpleType {
    /** @var string */
    public $name;
    /** @var bool */
    public $isBuiltin;

    public function __construct(string $name, bool $isBuiltin) {
        $this-&gt;name = $name;
        $this-&gt;isBuiltin = $isBuiltin;
    }

    public static function fromNode(Node $node): SimpleType {
        if ($node instanceof Node\Name) {
            if ($node-&gt;toLowerString() === 'static') {
                // PHP internally considers &quot;static&quot; a builtin type.
                return new SimpleType($node-&gt;toString(), true);
            }

            if ($node-&gt;toLowerString() === 'self') {
                throw new Exception('The exact class name must be used instead of &quot;self&quot;');
            }

            assert($node-&gt;isFullyQualified());
            return new SimpleType($node-&gt;toString(), false);
        }
        if ($node instanceof Node\Identifier) {
            return new SimpleType($node-&gt;toString(), true);
        }
        throw new Exception(&quot;Unexpected node type&quot;);
    }

    public static function fromPhpDoc(string $type): SimpleType
    {
        switch (strtolower($type)) {
            case &quot;void&quot;:
            case &quot;null&quot;:
            case &quot;false&quot;:
            case &quot;bool&quot;:
            case &quot;int&quot;:
            case &quot;float&quot;:
            case &quot;string&quot;:
            case &quot;array&quot;:
            case &quot;iterable&quot;:
            case &quot;object&quot;:
            case &quot;resource&quot;:
            case &quot;mixed&quot;:
            case &quot;static&quot;:
                return new SimpleType(strtolower($type), true);
            case &quot;self&quot;:
                throw new Exception('The exact class name must be used instead of &quot;self&quot;');
        }

        if (strpos($type, &quot;[]&quot;) !== false) {
            return new SimpleType(&quot;array&quot;, true);
        }

        return new SimpleType($type, false);
    }

    public static function null(): SimpleType
    {
        return new SimpleType(&quot;null&quot;, true);
    }

    public static function void(): SimpleType
    {
        return new SimpleType(&quot;void&quot;, true);
    }

    public function isNull(): bool {
        return $this-&gt;isBuiltin &amp;&amp; $this-&gt;name === 'null';
    }

    public function toTypeCode(): string {
        assert($this-&gt;isBuiltin);
        switch (strtolower($this-&gt;name)) {
        case &quot;bool&quot;:
            return &quot;_IS_BOOL&quot;;
        case &quot;int&quot;:
            return &quot;IS_LONG&quot;;
        case &quot;float&quot;:
            return &quot;IS_DOUBLE&quot;;
        case &quot;string&quot;:
            return &quot;IS_STRING&quot;;
        case &quot;array&quot;:
            return &quot;IS_ARRAY&quot;;
        case &quot;object&quot;:
            return &quot;IS_OBJECT&quot;;
        case &quot;void&quot;:
            return &quot;IS_VOID&quot;;
        case &quot;callable&quot;:
            return &quot;IS_CALLABLE&quot;;
        case &quot;iterable&quot;:
            return &quot;IS_ITERABLE&quot;;
        case &quot;mixed&quot;:
            return &quot;IS_MIXED&quot;;
        case &quot;static&quot;:
            return &quot;IS_STATIC&quot;;
        default:
            throw new Exception(&quot;Not implemented: $this-&gt;name&quot;);
        }
    }

    public function toTypeMask() {
        assert($this-&gt;isBuiltin);
        switch (strtolower($this-&gt;name)) {
        case &quot;null&quot;:
            return &quot;MAY_BE_NULL&quot;;
        case &quot;false&quot;:
            return &quot;MAY_BE_FALSE&quot;;
        case &quot;bool&quot;:
            return &quot;MAY_BE_BOOL&quot;;
        case &quot;int&quot;:
            return &quot;MAY_BE_LONG&quot;;
        case &quot;float&quot;:
            return &quot;MAY_BE_DOUBLE&quot;;
        case &quot;string&quot;:
            return &quot;MAY_BE_STRING&quot;;
        case &quot;array&quot;:
            return &quot;MAY_BE_ARRAY&quot;;
        case &quot;object&quot;:
            return &quot;MAY_BE_OBJECT&quot;;
        case &quot;callable&quot;:
            return &quot;MAY_BE_CALLABLE&quot;;
        case &quot;mixed&quot;:
            return &quot;MAY_BE_ANY&quot;;
        case &quot;static&quot;:
            return &quot;MAY_BE_STATIC&quot;;
        default:
            throw new Exception(&quot;Not implemented: $this-&gt;name&quot;);
        }
    }

    public function toEscapedName(): string {
        return str_replace('\\', '\\\\', $this-&gt;name);
    }

    public function equals(SimpleType $other) {
        return $this-&gt;name === $other-&gt;name
            &amp;&amp; $this-&gt;isBuiltin === $other-&gt;isBuiltin;
    }
}

class Type {
    /** @var SimpleType[] $types */
    public $types;

    public function __construct(array $types) {
        $this-&gt;types = $types;
    }

    public static function fromNode(Node $node): Type {
        if ($node instanceof Node\UnionType) {
            return new Type(array_map(['SimpleType', 'fromNode'], $node-&gt;types));
        }
        if ($node instanceof Node\NullableType) {
            return new Type([
                SimpleType::fromNode($node-&gt;type),
                SimpleType::null(),
            ]);
        }
        return new Type([SimpleType::fromNode($node)]);
    }

    public static function fromPhpDoc(string $phpDocType) {
        $types = explode(&quot;|&quot;, $phpDocType);

        $simpleTypes = [];
        foreach ($types as $type) {
            $simpleTypes[] = SimpleType::fromPhpDoc($type);
        }

        return new Type($simpleTypes);
    }

    public function isNullable(): bool {
        foreach ($this-&gt;types as $type) {
            if ($type-&gt;isNull()) {
                return true;
            }
        }
        return false;
    }

    public function getWithoutNull(): Type {
        return new Type(array_filter($this-&gt;types, function(SimpleType $type) {
            return !$type-&gt;isNull();
        }));
    }

    public function tryToSimpleType(): ?SimpleType {
        $withoutNull = $this-&gt;getWithoutNull();
        if (count($withoutNull-&gt;types) === 1) {
            return $withoutNull-&gt;types[0];
        }
        return null;
    }

    public function toArginfoType(): ?ArginfoType {
        $classTypes = [];
        $builtinTypes = [];
        foreach ($this-&gt;types as $type) {
            if ($type-&gt;isBuiltin) {
                $builtinTypes[] = $type;
            } else {
                $classTypes[] = $type;
            }
        }
        return new ArginfoType($classTypes, $builtinTypes);
    }

    public static function equals(?Type $a, ?Type $b): bool {
        if ($a === null || $b === null) {
            return $a === $b;
        }

        if (count($a-&gt;types) !== count($b-&gt;types)) {
            return false;
        }

        for ($i = 0; $i &lt; count($a-&gt;types); $i++) {
            if (!$a-&gt;types[$i]-&gt;equals($b-&gt;types[$i])) {
                return false;
            }
        }

        return true;
    }

    public function __toString() {
        if ($this-&gt;types === null) {
            return 'mixed';
        }

        return implode('|', array_map(
            function ($type) { return $type-&gt;name; },
            $this-&gt;types)
        );
    }
}

class ArginfoType {
    /** @var ClassType[] $classTypes */
    public $classTypes;

    /** @var SimpleType[] $builtinTypes */
    private $builtinTypes;

    public function __construct(array $classTypes, array $builtinTypes) {
        $this-&gt;classTypes = $classTypes;
        $this-&gt;builtinTypes = $builtinTypes;
    }

    public function hasClassType(): bool {
        return !empty($this-&gt;classTypes);
    }

    public function toClassTypeString(): string {
        return implode('|', array_map(function(SimpleType $type) {
            return $type-&gt;toEscapedName();
        }, $this-&gt;classTypes));
    }

    public function toTypeMask(): string {
        if (empty($this-&gt;builtinTypes)) {
            return '0';
        }
        return implode('|', array_map(function(SimpleType $type) {
            return $type-&gt;toTypeMask();
        }, $this-&gt;builtinTypes));
    }
}

class ArgInfo {
    const SEND_BY_VAL = 0;
    const SEND_BY_REF = 1;
    const SEND_PREFER_REF = 2;

    /** @var string */
    public $name;
    /** @var int */
    public $sendBy;
    /** @var bool */
    public $isVariadic;
    /** @var Type|null */
    public $type;
    /** @var Type|null */
    public $phpDocType;
    /** @var string|null */
    public $defaultValue;

    public function __construct(string $name, int $sendBy, bool $isVariadic, ?Type $type, ?Type $phpDocType, ?string $defaultValue) {
        $this-&gt;name = $name;
        $this-&gt;sendBy = $sendBy;
        $this-&gt;isVariadic = $isVariadic;
        $this-&gt;type = $type;
        $this-&gt;phpDocType = $phpDocType;
        $this-&gt;defaultValue = $defaultValue;
    }

    public function equals(ArgInfo $other): bool {
        return $this-&gt;name === $other-&gt;name
            &amp;&amp; $this-&gt;sendBy === $other-&gt;sendBy
            &amp;&amp; $this-&gt;isVariadic === $other-&gt;isVariadic
            &amp;&amp; Type::equals($this-&gt;type, $other-&gt;type)
            &amp;&amp; $this-&gt;defaultValue === $other-&gt;defaultValue;
    }

    public function getSendByString(): string {
        switch ($this-&gt;sendBy) {
        case self::SEND_BY_VAL:
            return &quot;0&quot;;
        case self::SEND_BY_REF:
            return &quot;1&quot;;
        case self::SEND_PREFER_REF:
            return &quot;ZEND_SEND_PREFER_REF&quot;;
        }
        throw new Exception(&quot;Invalid sendBy value&quot;);
    }

    public function getMethodSynopsisType(): Type {
        if ($this-&gt;type) {
            return $this-&gt;type;
        }

        if ($this-&gt;phpDocType) {
            return $this-&gt;phpDocType;
        }

        throw new Exception(&quot;A parameter must have a type&quot;);
    }

    public function hasProperDefaultValue(): bool {
        return $this-&gt;defaultValue !== null &amp;&amp; $this-&gt;defaultValue !== &quot;UNKNOWN&quot;;
    }

    public function getDefaultValueAsArginfoString(): string {
        if ($this-&gt;hasProperDefaultValue()) {
            return '&quot;' . addslashes($this-&gt;defaultValue) . '&quot;';
        }

        return &quot;NULL&quot;;
    }

    public function getDefaultValueAsMethodSynopsisString(): ?string {
        if ($this-&gt;defaultValue === null) {
            return null;
        }

        switch ($this-&gt;defaultValue) {
            case 'UNKNOWN':
                return null;
            case 'false':
            case 'true':
            case 'null':
                return &quot;&amp;{$this-&gt;defaultValue};&quot;;
        }

        return $this-&gt;defaultValue;
    }
}

interface FunctionOrMethodName {
    public function getDeclaration(): string;
    public function getArgInfoName(): string;
    public function getMethodSynopsisFilename(): string;
    public function __toString(): string;
    public function isMethod(): bool;
    public function isConstructor(): bool;
    public function isDestructor(): bool;
}

class FunctionName implements FunctionOrMethodName {
    /** @var Name */
    private $name;

    public function __construct(Name $name) {
        $this-&gt;name = $name;
    }

    public function getNamespace(): ?string {
        if ($this-&gt;name-&gt;isQualified()) {
            return $this-&gt;name-&gt;slice(0, -1)-&gt;toString();
        }
        return null;
    }

    public function getNonNamespacedName(): string {
        if ($this-&gt;name-&gt;isQualified()) {
            throw new Exception(&quot;Namespaced name not supported here&quot;);
        }
        return $this-&gt;name-&gt;toString();
    }

    public function getDeclarationName(): string {
        return $this-&gt;name-&gt;getLast();
    }

    public function getDeclaration(): string {
        return &quot;ZEND_FUNCTION({$this-&gt;getDeclarationName()});\n&quot;;
    }

    public function getArgInfoName(): string {
        $underscoreName = implode('_', $this-&gt;name-&gt;parts);
        return &quot;arginfo_$underscoreName&quot;;
    }

    public function getMethodSynopsisFilename(): string {
        return implode('_', $this-&gt;name-&gt;parts);
    }

    public function __toString(): string {
        return $this-&gt;name-&gt;toString();
    }

    public function isMethod(): bool {
        return false;
    }

    public function isConstructor(): bool {
        return false;
    }

    public function isDestructor(): bool {
        return false;
    }
}

class MethodName implements FunctionOrMethodName {
    /** @var Name */
    private $className;
    /** @var string */
    public $methodName;

    public function __construct(Name $className, string $methodName) {
        $this-&gt;className = $className;
        $this-&gt;methodName = $methodName;
    }

    public function getDeclarationClassName(): string {
        return implode('_', $this-&gt;className-&gt;parts);
    }

    public function getDeclaration(): string {
        return &quot;ZEND_METHOD({$this-&gt;getDeclarationClassName()}, $this-&gt;methodName);\n&quot;;
    }

    public function getArgInfoName(): string {
        return &quot;arginfo_class_{$this-&gt;getDeclarationClassName()}_{$this-&gt;methodName}&quot;;
    }

    public function getMethodSynopsisFilename(): string {
        return $this-&gt;getDeclarationClassName() . &quot;_{$this-&gt;methodName}&quot;;
    }

    public function __toString(): string {
        return &quot;$this-&gt;className::$this-&gt;methodName&quot;;
    }

    public function isMethod(): bool {
        return true;
    }

    public function isConstructor(): bool {
        return $this-&gt;methodName === &quot;__construct&quot;;
    }

    public function isDestructor(): bool {
        return $this-&gt;methodName === &quot;__destruct&quot;;
    }
}

class ReturnInfo {
    /** @var bool */
    public $byRef;
    /** @var Type|null */
    public $type;
    /** @var Type|null */
    public $phpDocType;

    public function __construct(bool $byRef, ?Type $type, ?Type $phpDocType) {
        $this-&gt;byRef = $byRef;
        $this-&gt;type = $type;
        $this-&gt;phpDocType = $phpDocType;
    }

    public function equals(ReturnInfo $other): bool {
        return $this-&gt;byRef === $other-&gt;byRef
            &amp;&amp; Type::equals($this-&gt;type, $other-&gt;type);
    }

    public function getMethodSynopsisType(): ?Type {
        return $this-&gt;type ?? $this-&gt;phpDocType;
    }
}

class FuncInfo {
    /** @var FunctionOrMethodName */
    public $name;
    /** @var int */
    public $classFlags;
    /** @var int */
    public $flags;
    /** @var string|null */
    public $aliasType;
    /** @var FunctionName|null */
    public $alias;
    /** @var bool */
    public $isDeprecated;
    /** @var bool */
    public $verify;
    /** @var ArgInfo[] */
    public $args;
    /** @var ReturnInfo */
    public $return;
    /** @var int */
    public $numRequiredArgs;
    /** @var string|null */
    public $cond;

    public function __construct(
        FunctionOrMethodName $name,
        int $classFlags,
        int $flags,
        ?string $aliasType,
        ?FunctionOrMethodName $alias,
        bool $isDeprecated,
        bool $verify,
        array $args,
        ReturnInfo $return,
        int $numRequiredArgs,
        ?string $cond
    ) {
        $this-&gt;name = $name;
        $this-&gt;classFlags = $classFlags;
        $this-&gt;flags = $flags;
        $this-&gt;aliasType = $aliasType;
        $this-&gt;alias = $alias;
        $this-&gt;isDeprecated = $isDeprecated;
        $this-&gt;verify = $verify;
        $this-&gt;args = $args;
        $this-&gt;return = $return;
        $this-&gt;numRequiredArgs = $numRequiredArgs;
        $this-&gt;cond = $cond;
    }

    public function isMethod(): bool
    {
        return $this-&gt;name-&gt;isMethod();
    }

    public function isFinalMethod(): bool
    {
        return ($this-&gt;flags &amp; Class_::MODIFIER_FINAL) || ($this-&gt;classFlags &amp; Class_::MODIFIER_FINAL);
    }

    public function isInstanceMethod(): bool
    {
        return !($this-&gt;flags &amp; Class_::MODIFIER_STATIC) &amp;&amp; $this-&gt;isMethod() &amp;&amp; !$this-&gt;name-&gt;isConstructor();
    }

    /** @return string[] */
    public function getModifierNames(): array
    {
        if (!$this-&gt;isMethod()) {
            return [];
        }

        $result = [];

        if ($this-&gt;flags &amp; Class_::MODIFIER_FINAL) {
            $result[] = &quot;final&quot;;
        } elseif ($this-&gt;flags &amp; Class_::MODIFIER_ABSTRACT &amp;&amp; $this-&gt;classFlags &amp; ~Class_::MODIFIER_ABSTRACT) {
            $result[] = &quot;abstract&quot;;
        }

        if ($this-&gt;flags &amp; Class_::MODIFIER_PROTECTED) {
            $result[] = &quot;protected&quot;;
        } elseif ($this-&gt;flags &amp; Class_::MODIFIER_PRIVATE) {
            $result[] = &quot;private&quot;;
        } else {
            $result[] = &quot;public&quot;;
        }

        if ($this-&gt;flags &amp; Class_::MODIFIER_STATIC) {
            $result[] = &quot;static&quot;;
        }

        return $result;
    }

    public function hasParamWithUnknownDefaultValue(): bool
    {
        foreach ($this-&gt;args as $arg) {
            if ($arg-&gt;defaultValue &amp;&amp; !$arg-&gt;hasProperDefaultValue()) {
                return true;
            }
        }

        return false;
    }

    public function equalsApartFromName(FuncInfo $other): bool {
        if (count($this-&gt;args) !== count($other-&gt;args)) {
            return false;
        }

        for ($i = 0; $i &lt; count($this-&gt;args); $i++) {
            if (!$this-&gt;args[$i]-&gt;equals($other-&gt;args[$i])) {
                return false;
            }
        }

        return $this-&gt;return-&gt;equals($other-&gt;return)
            &amp;&amp; $this-&gt;numRequiredArgs === $other-&gt;numRequiredArgs
            &amp;&amp; $this-&gt;cond === $other-&gt;cond;
    }

    public function getArgInfoName(): string {
        return $this-&gt;name-&gt;getArgInfoName();
    }

    public function getDeclarationKey(): string
    {
        $name = $this-&gt;alias ?? $this-&gt;name;

        return &quot;$name|$this-&gt;cond&quot;;
    }

    public function getDeclaration(): ?string
    {
        if ($this-&gt;flags &amp; Class_::MODIFIER_ABSTRACT) {
            return null;
        }

        $name = $this-&gt;alias ?? $this-&gt;name;

        return $name-&gt;getDeclaration();
    }

    public function getFunctionEntry(): string {
        if ($this-&gt;name instanceof MethodName) {
            if ($this-&gt;alias) {
                if ($this-&gt;alias instanceof MethodName) {
                    return sprintf(
                        &quot;\tZEND_MALIAS(%s, %s, %s, %s, %s)\n&quot;,
                        $this-&gt;alias-&gt;getDeclarationClassName(), $this-&gt;name-&gt;methodName,
                        $this-&gt;alias-&gt;methodName, $this-&gt;getArgInfoName(), $this-&gt;getFlagsAsArginfoString()
                    );
                } else if ($this-&gt;alias instanceof FunctionName) {
                    return sprintf(
                        &quot;\tZEND_ME_MAPPING(%s, %s, %s, %s)\n&quot;,
                        $this-&gt;name-&gt;methodName, $this-&gt;alias-&gt;getNonNamespacedName(),
                        $this-&gt;getArgInfoName(), $this-&gt;getFlagsAsArginfoString()
                    );
                } else {
                    throw new Error(&quot;Cannot happen&quot;);
                }
            } else {
                $declarationClassName = $this-&gt;name-&gt;getDeclarationClassName();
                if ($this-&gt;flags &amp; Class_::MODIFIER_ABSTRACT) {
                    return sprintf(
                        &quot;\tZEND_ABSTRACT_ME_WITH_FLAGS(%s, %s, %s, %s)\n&quot;,
                        $declarationClassName, $this-&gt;name-&gt;methodName, $this-&gt;getArgInfoName(),
                        $this-&gt;getFlagsAsArginfoString()
                    );
                }

                return sprintf(
                    &quot;\tZEND_ME(%s, %s, %s, %s)\n&quot;,
                    $declarationClassName, $this-&gt;name-&gt;methodName, $this-&gt;getArgInfoName(),
                    $this-&gt;getFlagsAsArginfoString()
                );
            }
        } else if ($this-&gt;name instanceof FunctionName) {
            $namespace = $this-&gt;name-&gt;getNamespace();
            $declarationName = $this-&gt;name-&gt;getDeclarationName();

            if ($this-&gt;alias &amp;&amp; $this-&gt;isDeprecated) {
                return sprintf(
                    &quot;\tZEND_DEP_FALIAS(%s, %s, %s)\n&quot;,
                    $declarationName, $this-&gt;alias-&gt;getNonNamespacedName(), $this-&gt;getArgInfoName()
                );
            }

            if ($this-&gt;alias) {
                return sprintf(
                    &quot;\tZEND_FALIAS(%s, %s, %s)\n&quot;,
                    $declarationName, $this-&gt;alias-&gt;getNonNamespacedName(), $this-&gt;getArgInfoName()
                );
            }

            if ($this-&gt;isDeprecated) {
                return sprintf(
                    &quot;\tZEND_DEP_FE(%s, %s)\n&quot;, $declarationName, $this-&gt;getArgInfoName());
            }

            if ($namespace) {
                // Render A\B as &quot;A\\B&quot; in C strings for namespaces
                return sprintf(
                    &quot;\tZEND_NS_FE(\&quot;%s\&quot;, %s, %s)\n&quot;,
                    addslashes($namespace), $declarationName, $this-&gt;getArgInfoName());
            } else {
                return sprintf(&quot;\tZEND_FE(%s, %s)\n&quot;, $declarationName, $this-&gt;getArgInfoName());
            }
        } else {
            throw new Error(&quot;Cannot happen&quot;);
        }
    }

    private function getFlagsAsArginfoString(): string
    {
        $flags = &quot;ZEND_ACC_PUBLIC&quot;;
        if ($this-&gt;flags &amp; Class_::MODIFIER_PROTECTED) {
            $flags = &quot;ZEND_ACC_PROTECTED&quot;;
        } elseif ($this-&gt;flags &amp; Class_::MODIFIER_PRIVATE) {
            $flags = &quot;ZEND_ACC_PRIVATE&quot;;
        }

        if ($this-&gt;flags &amp; Class_::MODIFIER_STATIC) {
            $flags .= &quot;|ZEND_ACC_STATIC&quot;;
        }

        if ($this-&gt;flags &amp; Class_::MODIFIER_FINAL) {
            $flags .= &quot;|ZEND_ACC_FINAL&quot;;
        }

        if ($this-&gt;flags &amp; Class_::MODIFIER_ABSTRACT) {
            $flags .= &quot;|ZEND_ACC_ABSTRACT&quot;;
        }

        if ($this-&gt;isDeprecated) {
            $flags .= &quot;|ZEND_ACC_DEPRECATED&quot;;
        }

        return $flags;
    }

    /**
     * @param FuncInfo[] $funcMap
     * @param FuncInfo[] $aliasMap
     * @throws Exception
     */
    public function getMethodSynopsisDocument(array $funcMap, array $aliasMap): ?string {

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = true;
        $methodSynopsis = $this-&gt;getMethodSynopsisElement($funcMap, $aliasMap, $doc);
        if (!$methodSynopsis) {
            return null;
        }

        $doc-&gt;appendChild($methodSynopsis);

        return $doc-&gt;saveXML();
    }

    /**
     * @param FuncInfo[] $funcMap
     * @param FuncInfo[] $aliasMap
     * @throws Exception
     */
    public function getMethodSynopsisElement(array $funcMap, array $aliasMap, DOMDocument $doc): ?DOMElement {
        if ($this-&gt;hasParamWithUnknownDefaultValue()) {
            return null;
        }

        if ($this-&gt;name-&gt;isConstructor()) {
            $synopsisType = &quot;constructorsynopsis&quot;;
        } elseif ($this-&gt;name-&gt;isDestructor()) {
            $synopsisType = &quot;destructorsynopsis&quot;;
        } else {
            $synopsisType = &quot;methodsynopsis&quot;;
        }

        $methodSynopsis = $doc-&gt;createElement($synopsisType);

        $aliasedFunc = $this-&gt;aliasType === &quot;alias&quot; &amp;&amp; isset($funcMap[$this-&gt;alias-&gt;__toString()]) ? $funcMap[$this-&gt;alias-&gt;__toString()] : null;
        $aliasFunc = $aliasMap[$this-&gt;name-&gt;__toString()] ?? null;

        if (($this-&gt;aliasType === &quot;alias&quot; &amp;&amp; $aliasedFunc !== null &amp;&amp; $aliasedFunc-&gt;isMethod() !== $this-&gt;isMethod()) ||
            ($aliasFunc !== null &amp;&amp; $aliasFunc-&gt;isMethod() !== $this-&gt;isMethod())
        ) {
            $role = $doc-&gt;createAttribute(&quot;role&quot;);
            $role-&gt;value = $this-&gt;isMethod() ? &quot;oop&quot; : &quot;procedural&quot;;
            $methodSynopsis-&gt;appendChild($role);
        }

        $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));

        foreach ($this-&gt;getModifierNames() as $modifierString) {
            $modifierElement = $doc-&gt;createElement('modifier', $modifierString);
            $methodSynopsis-&gt;appendChild($modifierElement);
            $methodSynopsis-&gt;appendChild(new DOMText(&quot; &quot;));
        }

        $returnType = $this-&gt;return-&gt;getMethodSynopsisType();
        if ($returnType) {
            $this-&gt;appendMethodSynopsisTypeToElement($doc, $methodSynopsis, $returnType);
        }

        $methodname = $doc-&gt;createElement('methodname', $this-&gt;name-&gt;__toString());
        $methodSynopsis-&gt;appendChild($methodname);

        if (empty($this-&gt;args)) {
            $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));
            $void = $doc-&gt;createElement('void');
            $methodSynopsis-&gt;appendChild($void);
        } else {
            foreach ($this-&gt;args as $arg) {
                $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n   &quot;));
                $methodparam = $doc-&gt;createElement('methodparam');
                if ($arg-&gt;defaultValue !== null) {
                    $methodparam-&gt;setAttribute(&quot;choice&quot;, &quot;opt&quot;);
                }
                if ($arg-&gt;isVariadic) {
                    $methodparam-&gt;setAttribute(&quot;rep&quot;, &quot;repeat&quot;);
                }

                $methodSynopsis-&gt;appendChild($methodparam);
                $this-&gt;appendMethodSynopsisTypeToElement($doc, $methodparam, $arg-&gt;getMethodSynopsisType());

                $parameter = $doc-&gt;createElement('parameter', $arg-&gt;name);
                if ($arg-&gt;sendBy !== ArgInfo::SEND_BY_VAL) {
                    $parameter-&gt;setAttribute(&quot;role&quot;, &quot;reference&quot;);
                }

                $methodparam-&gt;appendChild($parameter);
                $defaultValue = $arg-&gt;getDefaultValueAsMethodSynopsisString();
                if ($defaultValue !== null) {
                    $initializer = $doc-&gt;createElement('initializer');
                    if (preg_match('/^[a-zA-Z_][a-zA-Z_0-9]*$/', $defaultValue)) {
                        $constant = $doc-&gt;createElement('constant', $defaultValue);
                        $initializer-&gt;appendChild($constant);
                    } else {
                        $initializer-&gt;nodeValue = $defaultValue;
                    }
                    $methodparam-&gt;appendChild($initializer);
                }
            }
        }
        $methodSynopsis-&gt;appendChild(new DOMText(&quot;\n  &quot;));

        return $methodSynopsis;
    }

    public function discardInfoForOldPhpVersions(): void {
        $this-&gt;return-&gt;type = null;
        foreach ($this-&gt;args as $arg) {
            $arg-&gt;type = null;
            $arg-&gt;defaultValue = null;
        }
    }

    private function appendMethodSynopsisTypeToElement(DOMDocument $doc, DOMElement $elementToAppend, Type $type) {
        if (count($type-&gt;types) &gt; 1) {
            $typeElement = $doc-&gt;createElement('type');
            $typeElement-&gt;setAttribute(&quot;class&quot;, &quot;union&quot;);

            foreach ($type-&gt;types as $type) {
                $unionTypeElement = $doc-&gt;createElement('type', $type-&gt;name);
                $typeElement-&gt;appendChild($unionTypeElement);
            }
        } else {
            $typeElement = $doc-&gt;createElement('type', $type-&gt;types[0]-&gt;name);
        }

        $elementToAppend-&gt;appendChild($typeElement);
    }
}

class ClassInfo {
    /** @var Name */
    public $name;
    /** @var FuncInfo[] */
    public $funcInfos;

    public function __construct(Name $name, array $funcInfos) {
        $this-&gt;name = $name;
        $this-&gt;funcInfos = $funcInfos;
    }
}

class FileInfo {
    /** @var FuncInfo[] */
    public $funcInfos = [];
    /** @var ClassInfo[] */
    public $classInfos = [];
    /** @var bool */
    public $generateFunctionEntries = false;
    /** @var string */
    public $declarationPrefix = &quot;&quot;;
    /** @var bool */
    public $generateLegacyArginfo = false;

    /**
     * @return iterable&lt;FuncInfo&gt;
     */
    public function getAllFuncInfos(): iterable {
        yield from $this-&gt;funcInfos;
        foreach ($this-&gt;classInfos as $classInfo) {
            yield from $classInfo-&gt;funcInfos;
        }
    }
}

class DocCommentTag {
    /** @var string */
    public $name;
    /** @var string|null */
    public $value;

    public function __construct(string $name, ?string $value) {
        $this-&gt;name = $name;
        $this-&gt;value = $value;
    }

    public function getValue(): string {
        if ($this-&gt;value === null) {
            throw new Exception(&quot;@$this-&gt;name does not have a value&quot;);
        }

        return $this-&gt;value;
    }

    public function getType(): string {
        $value = $this-&gt;getValue();

        $matches = [];

        if ($this-&gt;name === &quot;param&quot;) {
            preg_match('/^\s*([\w\|\\\\\[\]]+)\s*\$\w+.*$/', $value, $matches);
        } elseif ($this-&gt;name === &quot;return&quot;) {
            preg_match('/^\s*([\w\|\\\\\[\]]+)\s*$/', $value, $matches);
        }

        if (isset($matches[1]) === false) {
            throw new Exception(&quot;@$this-&gt;name doesn't contain a type or has an invalid format \&quot;$value\&quot;&quot;);
        }

        return $matches[1];
    }

    public function getVariableName(): string {
        $value = $this-&gt;value;
        if ($value === null || strlen($value) === 0) {
            throw new Exception(&quot;@$this-&gt;name doesn't have any value&quot;);
        }

        $matches = [];

        if ($this-&gt;name === &quot;param&quot;) {
            preg_match('/^\s*[\w\|\\\\\[\]]+\s*\$(\w+).*$/', $value, $matches);
        } elseif ($this-&gt;name === &quot;prefer-ref&quot;) {
            preg_match('/^\s*\$(\w+).*$/', $value, $matches);
        }

        if (isset($matches[1]) === false) {
            throw new Exception(&quot;@$this-&gt;name doesn't contain a variable name or has an invalid format \&quot;$value\&quot;&quot;);
        }

        return $matches[1];
    }
}

/** @return DocCommentTag[] */
function parseDocComment(DocComment $comment): array {
    $commentText = substr($comment-&gt;getText(), 2, -2);
    $tags = [];
    foreach (explode(&quot;\n&quot;, $commentText) as $commentLine) {
        $regex = '/^\*\s*@([a-z-]+)(?:\s+(.+))?$/';
        if (preg_match($regex, trim($commentLine), $matches)) {
            $tags[] = new DocCommentTag($matches[1], $matches[2] ?? null);
        }
    }

    return $tags;
}

function parseFunctionLike(
    PrettyPrinterAbstract $prettyPrinter,
    FunctionOrMethodName $name,
    int $classFlags,
    int $flags,
    Node\FunctionLike $func,
    ?string $cond
): FuncInfo {
    $comment = $func-&gt;getDocComment();
    $paramMeta = [];
    $aliasType = null;
    $alias = null;
    $isDeprecated = false;
    $verify = true;
    $docReturnType = null;
    $docParamTypes = [];

    if ($comment) {
        $tags = parseDocComment($comment);
        foreach ($tags as $tag) {
            if ($tag-&gt;name === 'prefer-ref') {
                $varName = $tag-&gt;getVariableName();
                if (!isset($paramMeta[$varName])) {
                    $paramMeta[$varName] = [];
                }
                $paramMeta[$varName]['preferRef'] = true;
            } else if ($tag-&gt;name === 'alias' || $tag-&gt;name === 'implementation-alias') {
                $aliasType = $tag-&gt;name;
                $aliasParts = explode(&quot;::&quot;, $tag-&gt;getValue());
                if (count($aliasParts) === 1) {
                    $alias = new FunctionName(new Name($aliasParts[0]));
                } else {
                    $alias = new MethodName(new Name($aliasParts[0]), $aliasParts[1]);
                }
            } else if ($tag-&gt;name === 'deprecated') {
                $isDeprecated = true;
            }  else if ($tag-&gt;name === 'no-verify') {
                $verify = false;
            } else if ($tag-&gt;name === 'return') {
                $docReturnType = $tag-&gt;getType();
            } else if ($tag-&gt;name === 'param') {
                $docParamTypes[$tag-&gt;getVariableName()] = $tag-&gt;getType();
            }
        }
    }

    $varNameSet = [];
    $args = [];
    $numRequiredArgs = 0;
    $foundVariadic = false;
    foreach ($func-&gt;getParams() as $i =&gt; $param) {
        $varName = $param-&gt;var-&gt;name;
        $preferRef = !empty($paramMeta[$varName]['preferRef']);
        unset($paramMeta[$varName]);

        if (isset($varNameSet[$varName])) {
            throw new Exception(&quot;Duplicate parameter name $varName for function $name&quot;);
        }
        $varNameSet[$varName] = true;

        if ($preferRef) {
            $sendBy = ArgInfo::SEND_PREFER_REF;
        } else if ($param-&gt;byRef) {
            $sendBy = ArgInfo::SEND_BY_REF;
        } else {
            $sendBy = ArgInfo::SEND_BY_VAL;
        }

        if ($foundVariadic) {
            throw new Exception(&quot;Error in function $name: only the last parameter can be variadic&quot;);
        }

        $type = $param-&gt;type ? Type::fromNode($param-&gt;type) : null;
        if ($type === null &amp;&amp; !isset($docParamTypes[$varName])) {
            throw new Exception(&quot;Missing parameter type for function $name()&quot;);
        }

        if ($param-&gt;default instanceof Expr\ConstFetch &amp;&amp;
            $param-&gt;default-&gt;name-&gt;toLowerString() === &quot;null&quot; &amp;&amp;
            $type &amp;&amp; !$type-&gt;isNullable()
        ) {
            $simpleType = $type-&gt;tryToSimpleType();
            if ($simpleType === null) {
                throw new Exception(
                    &quot;Parameter $varName of function $name has null default, but is not nullable&quot;);
            }
        }

        if ($param-&gt;default instanceof Expr\ClassConstFetch &amp;&amp; $param-&gt;default-&gt;class-&gt;toLowerString() === &quot;self&quot;) {
            throw new Exception('The exact class name must be used instead of &quot;self&quot;');
        }

        $foundVariadic = $param-&gt;variadic;

        $args[] = new ArgInfo(
            $varName,
            $sendBy,
            $param-&gt;variadic,
            $type,
            isset($docParamTypes[$varName]) ? Type::fromPhpDoc($docParamTypes[$varName]) : null,
            $param-&gt;default ? $prettyPrinter-&gt;prettyPrintExpr($param-&gt;default) : null
        );
        if (!$param-&gt;default &amp;&amp; !$param-&gt;variadic) {
            $numRequiredArgs = $i + 1;
        }
    }

    foreach (array_keys($paramMeta) as $var) {
        throw new Exception(&quot;Found metadata for invalid param $var of function $name&quot;);
    }

    $returnType = $func-&gt;getReturnType();
    if ($returnType === null &amp;&amp; $docReturnType === null &amp;&amp; !$name-&gt;isConstructor() &amp;&amp; !$name-&gt;isDestructor()) {
        throw new Exception(&quot;Missing return type for function $name()&quot;);
    }

    $return = new ReturnInfo(
        $func-&gt;returnsByRef(),
        $returnType ? Type::fromNode($returnType) : null,
        $docReturnType ? Type::fromPhpDoc($docReturnType) : null
    );

    return new FuncInfo(
        $name,
        $classFlags,
        $flags,
        $aliasType,
        $alias,
        $isDeprecated,
        $verify,
        $args,
        $return,
        $numRequiredArgs,
        $cond
    );
}

function handlePreprocessorConditions(array &amp;$conds, Stmt $stmt): ?string {
    foreach ($stmt-&gt;getComments() as $comment) {
        $text = trim($comment-&gt;getText());
        if (preg_match('/^#\s*if\s+(.+)$/', $text, $matches)) {
            $conds[] = $matches[1];
        } else if (preg_match('/^#\s*ifdef\s+(.+)$/', $text, $matches)) {
            $conds[] = &quot;defined($matches[1])&quot;;
        } else if (preg_match('/^#\s*ifndef\s+(.+)$/', $text, $matches)) {
            $conds[] = &quot;!defined($matches[1])&quot;;
        } else if (preg_match('/^#\s*else$/', $text)) {
            if (empty($conds)) {
                throw new Exception(&quot;Encountered else without corresponding #if&quot;);
            }
            $cond = array_pop($conds);
            $conds[] = &quot;!($cond)&quot;;
        } else if (preg_match('/^#\s*endif$/', $text)) {
            if (empty($conds)) {
                throw new Exception(&quot;Encountered #endif without corresponding #if&quot;);
            }
            array_pop($conds);
        } else if ($text[0] === '#') {
            throw new Exception(&quot;Unrecognized preprocessor directive \&quot;$text\&quot;&quot;);
        }
    }

    return empty($conds) ? null : implode(' &amp;&amp; ', $conds);
}

function getFileDocComment(array $stmts): ?DocComment {
    if (empty($stmts)) {
        return null;
    }

    $comments = $stmts[0]-&gt;getComments();
    if (empty($comments)) {
        return null;
    }

    if ($comments[0] instanceof DocComment) {
        return $comments[0];
    }

    return null;
}

function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstract $prettyPrinter) {
    $conds = [];
    foreach ($stmts as $stmt) {
        if ($stmt instanceof Stmt\Nop) {
            continue;
        }

        if ($stmt instanceof Stmt\Namespace_) {
            handleStatements($fileInfo, $stmt-&gt;stmts, $prettyPrinter);
            continue;
        }

        $cond = handlePreprocessorConditions($conds, $stmt);
        if ($stmt instanceof Stmt\Function_) {
            $fileInfo-&gt;funcInfos[] = parseFunctionLike(
                $prettyPrinter,
                new FunctionName($stmt-&gt;namespacedName),
                0,
                0,
                $stmt,
                $cond
            );
            continue;
        }

        if ($stmt instanceof Stmt\ClassLike) {
            $className = $stmt-&gt;namespacedName;
            $methodInfos = [];
            foreach ($stmt-&gt;stmts as $classStmt) {
                $cond = handlePreprocessorConditions($conds, $classStmt);
                if ($classStmt instanceof Stmt\Nop) {
                    continue;
                }

                if (!$classStmt instanceof Stmt\ClassMethod) {
                    throw new Exception(&quot;Not implemented {$classStmt-&gt;getType()}&quot;);
                }

                $classFlags = 0;
                if ($stmt instanceof Class_) {
                    $classFlags = $stmt-&gt;flags;
                }

                $flags = $classStmt-&gt;flags;
                if ($stmt instanceof Stmt\Interface_) {
                    $flags |= Class_::MODIFIER_ABSTRACT;
                }

                if (!($flags &amp; Class_::VISIBILITY_MODIFIER_MASK)) {
                    throw new Exception(&quot;Method visibility modifier is required&quot;);
                }

                $methodInfos[] = parseFunctionLike(
                    $prettyPrinter,
                    new MethodName($className, $classStmt-&gt;name-&gt;toString()),
                    $classFlags,
                    $flags,
                    $classStmt,
                    $cond
                );
            }

            $fileInfo-&gt;classInfos[] = new ClassInfo($className, $methodInfos);
            continue;
        }

        throw new Exception(&quot;Unexpected node {$stmt-&gt;getType()}&quot;);
    }
}

function parseStubFile(string $code): FileInfo {
    $lexer = new PhpParser\Lexer();
    $parser = new PhpParser\Parser\Php7($lexer);
    $nodeTraverser = new PhpParser\NodeTraverser;
    $nodeTraverser-&gt;addVisitor(new PhpParser\NodeVisitor\NameResolver);
    $prettyPrinter = new class extends Standard {
        protected function pName_FullyQualified(Name\FullyQualified $node) {
            return implode('\\', $node-&gt;parts);
        }
    };

    $stmts = $parser-&gt;parse($code);
    $nodeTraverser-&gt;traverse($stmts);

    $fileInfo = new FileInfo;
    $fileDocComment = getFileDocComment($stmts);
    if ($fileDocComment) {
        $fileTags = parseDocComment($fileDocComment);
        foreach ($fileTags as $tag) {
            if ($tag-&gt;name === 'generate-function-entries') {
                $fileInfo-&gt;generateFunctionEntries = true;
                $fileInfo-&gt;declarationPrefix = $tag-&gt;value ? $tag-&gt;value . &quot; &quot; : &quot;&quot;;
            } else if ($tag-&gt;name === 'generate-legacy-arginfo') {
                $fileInfo-&gt;generateLegacyArginfo = true;
            }
        }
    }

    handleStatements($fileInfo, $stmts, $prettyPrinter);
    return $fileInfo;
}

function funcInfoToCode(FuncInfo $funcInfo): string {
    $code = '';
    $returnType = $funcInfo-&gt;return-&gt;type;
    if ($returnType !== null) {
        if (null !== $simpleReturnType = $returnType-&gt;tryToSimpleType()) {
            if ($simpleReturnType-&gt;isBuiltin) {
                $code .= sprintf(
                    &quot;ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(%s, %d, %d, %s, %d)\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $simpleReturnType-&gt;toTypeCode(), $returnType-&gt;isNullable()
                );
            } else {
                $code .= sprintf(
                    &quot;ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(%s, %d, %d, %s, %d)\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $simpleReturnType-&gt;toEscapedName(), $returnType-&gt;isNullable()
                );
            }
        } else {
            $arginfoType = $returnType-&gt;toArginfoType();
            if ($arginfoType-&gt;hasClassType()) {
                $code .= sprintf(
                    &quot;ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(%s, %d, %d, %s, %s)\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $arginfoType-&gt;toClassTypeString(), $arginfoType-&gt;toTypeMask()
                );
            } else {
                $code .= sprintf(
                    &quot;ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(%s, %d, %d, %s)\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef,
                    $funcInfo-&gt;numRequiredArgs,
                    $arginfoType-&gt;toTypeMask()
                );
            }
        }
    } else {
        $code .= sprintf(
            &quot;ZEND_BEGIN_ARG_INFO_EX(%s, 0, %d, %d)\n&quot;,
            $funcInfo-&gt;getArgInfoName(), $funcInfo-&gt;return-&gt;byRef, $funcInfo-&gt;numRequiredArgs
        );
    }

    foreach ($funcInfo-&gt;args as $argInfo) {
        $argKind = $argInfo-&gt;isVariadic ? &quot;ARG_VARIADIC&quot; : &quot;ARG&quot;;
        $argDefaultKind = $argInfo-&gt;hasProperDefaultValue() ? &quot;_WITH_DEFAULT_VALUE&quot; : &quot;&quot;;
        $argType = $argInfo-&gt;type;
        if ($argType !== null) {
            if (null !== $simpleArgType = $argType-&gt;tryToSimpleType()) {
                if ($simpleArgType-&gt;isBuiltin) {
                    $code .= sprintf(
                        &quot;\tZEND_%s_TYPE_INFO%s(%s, %s, %s, %d%s)\n&quot;,
                        $argKind, $argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $simpleArgType-&gt;toTypeCode(), $argType-&gt;isNullable(),
                        $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
                    );
                } else {
                    $code .= sprintf(
                        &quot;\tZEND_%s_OBJ_INFO%s(%s, %s, %s, %d%s)\n&quot;,
                        $argKind,$argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $simpleArgType-&gt;toEscapedName(), $argType-&gt;isNullable(),
                        $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
                    );
                }
            } else {
                $arginfoType = $argType-&gt;toArginfoType();
                if ($arginfoType-&gt;hasClassType()) {
                    $code .= sprintf(
                        &quot;\tZEND_%s_OBJ_TYPE_MASK(%s, %s, %s, %s, %s)\n&quot;,
                        $argKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $arginfoType-&gt;toClassTypeString(), $arginfoType-&gt;toTypeMask(),
                        $argInfo-&gt;getDefaultValueAsArginfoString()
                    );
                } else {
                    $code .= sprintf(
                        &quot;\tZEND_%s_TYPE_MASK(%s, %s, %s, %s)\n&quot;,
                        $argKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                        $arginfoType-&gt;toTypeMask(),
                        $argInfo-&gt;getDefaultValueAsArginfoString()
                    );
                }
            }
        } else {
            $code .= sprintf(
                &quot;\tZEND_%s_INFO%s(%s, %s%s)\n&quot;,
                $argKind, $argDefaultKind, $argInfo-&gt;getSendByString(), $argInfo-&gt;name,
                $argInfo-&gt;hasProperDefaultValue() ? &quot;, &quot; . $argInfo-&gt;getDefaultValueAsArginfoString() : &quot;&quot;
            );
        }
    }

    $code .= &quot;ZEND_END_ARG_INFO()&quot;;
    return $code . &quot;\n&quot;;
}

/** @param FuncInfo[] $generatedFuncInfos */
function findEquivalentFuncInfo(array $generatedFuncInfos, FuncInfo $funcInfo): ?FuncInfo {
    foreach ($generatedFuncInfos as $generatedFuncInfo) {
        if ($generatedFuncInfo-&gt;equalsApartFromName($funcInfo)) {
            return $generatedFuncInfo;
        }
    }
    return null;
}

/** @param iterable&lt;FuncInfo&gt; $funcInfos */
function generateCodeWithConditions(
        iterable $funcInfos, string $separator, Closure $codeGenerator): string {
    $code = &quot;&quot;;
    foreach ($funcInfos as $funcInfo) {
        $funcCode = $codeGenerator($funcInfo);
        if ($funcCode === null) {
            continue;
        }

        $code .= $separator;
        if ($funcInfo-&gt;cond) {
            $code .= &quot;#if {$funcInfo-&gt;cond}\n&quot;;
            $code .= $funcCode;
            $code .= &quot;#endif\n&quot;;
        } else {
            $code .= $funcCode;
        }
    }
    return $code;
}

function generateArgInfoCode(FileInfo $fileInfo, string $stubHash): string {
    $code = &quot;/* This is a generated file, edit the .stub.php file instead.\n&quot;
          . &quot; * Stub hash: $stubHash */\n&quot;;
    $generatedFuncInfos = [];
    $code .= generateCodeWithConditions(
        $fileInfo-&gt;getAllFuncInfos(), &quot;\n&quot;,
        function (FuncInfo $funcInfo) use(&amp;$generatedFuncInfos) {
            /* If there already is an equivalent arginfo structure, only emit a #define */
            if ($generatedFuncInfo = findEquivalentFuncInfo($generatedFuncInfos, $funcInfo)) {
                $code = sprintf(
                    &quot;#define %s %s\n&quot;,
                    $funcInfo-&gt;getArgInfoName(), $generatedFuncInfo-&gt;getArgInfoName()
                );
            } else {
                $code = funcInfoToCode($funcInfo);
            }

            $generatedFuncInfos[] = $funcInfo;
            return $code;
        }
    );

    if ($fileInfo-&gt;generateFunctionEntries) {
        $code .= &quot;\n\n&quot;;

        $generatedFunctionDeclarations = [];
        $code .= generateCodeWithConditions(
            $fileInfo-&gt;getAllFuncInfos(), &quot;&quot;,
            function (FuncInfo $funcInfo) use($fileInfo, &amp;$generatedFunctionDeclarations) {
                $key = $funcInfo-&gt;getDeclarationKey();
                if (isset($generatedFunctionDeclarations[$key])) {
                    return null;
                }

                $generatedFunctionDeclarations[$key] = true;
                return $fileInfo-&gt;declarationPrefix . $funcInfo-&gt;getDeclaration();
            }
        );

        if (!empty($fileInfo-&gt;funcInfos)) {
            $code .= generateFunctionEntries(null, $fileInfo-&gt;funcInfos);
        }

        foreach ($fileInfo-&gt;classInfos as $classInfo) {
            $code .= generateFunctionEntries($classInfo-&gt;name, $classInfo-&gt;funcInfos);
        }
    }

    return $code;
}

/** @param FuncInfo[] $funcInfos */
function generateFunctionEntries(?Name $className, array $funcInfos): string {
    $code = &quot;&quot;;

    $functionEntryName = &quot;ext_functions&quot;;
    if ($className) {
        $underscoreName = implode(&quot;_&quot;, $className-&gt;parts);
        $functionEntryName = &quot;class_{$underscoreName}_methods&quot;;
    }

    $code .= &quot;\n\nstatic const zend_function_entry {$functionEntryName}[] = {\n&quot;;
    $code .= generateCodeWithConditions($funcInfos, &quot;&quot;, function (FuncInfo $funcInfo) {
        return $funcInfo-&gt;getFunctionEntry();
    });
    $code .= &quot;\tZEND_FE_END\n&quot;;
    $code .= &quot;};\n&quot;;

    return $code;
}

/**
 * @param FuncInfo[] $funcMap
 * @param FuncInfo[] $aliasMap
 * @return array&lt;string, string&gt;
 */
function generateMethodSynopses(array $funcMap, array $aliasMap): array {
    $result = [];

    foreach ($funcMap as $funcInfo) {
        $methodSynopsis = $funcInfo-&gt;getMethodSynopsisDocument($funcMap, $aliasMap);
        if ($methodSynopsis !== null) {
            $result[$funcInfo-&gt;name-&gt;getMethodSynopsisFilename() . &quot;.xml&quot;] = $methodSynopsis;
        }
    }

    return $result;
}

/**
 * @param FuncInfo[] $funcMap
 * @param FuncInfo[] $aliasMap
 * @return array&lt;string, string&gt;
 */
function replaceMethodSynopses(string $targetDirectory, array $funcMap, array $aliasMap): array {
    $methodSynopses = [];

    $it = new RecursiveIteratorIterator(
        new RecursiveDirectoryIterator($targetDirectory),
        RecursiveIteratorIterator::LEAVES_ONLY
    );

    foreach ($it as $file) {
        $pathName = $file-&gt;getPathName();
        if (!preg_match('/\.xml$/i', $pathName)) {
            continue;
        }

        $xml = file_get_contents($pathName);
        if ($xml === false) {
            continue;
        }

        if (stripos($xml, &quot;&lt;methodsynopsis&quot;) === false &amp;&amp; stripos($xml, &quot;&lt;constructorsynopsis&quot;) === false &amp;&amp; stripos($xml, &quot;&lt;destructorsynopsis&quot;) === false) {
            continue;
        }

        $replacedXml = preg_replace(&quot;/&amp;([A-Za-z0-9._{}%-]+?;)/&quot;, &quot;REPLACED-ENTITY-$1&quot;, $xml);

        $doc = new DOMDocument();
        $doc-&gt;formatOutput = false;
        $doc-&gt;preserveWhiteSpace = true;
        $doc-&gt;validateOnParse = true;
        $success = $doc-&gt;loadXML($replacedXml);
        if (!$success) {
            echo &quot;Failed opening $pathName\n&quot;;
            continue;
        }

        $docComparator = new DOMDocument();
        $docComparator-&gt;preserveWhiteSpace = false;
        $docComparator-&gt;formatOutput = true;

        $methodSynopsisElements = [];
        foreach ($doc-&gt;getElementsByTagName(&quot;constructorsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }
        foreach ($doc-&gt;getElementsByTagName(&quot;destructorsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }
        foreach ($doc-&gt;getElementsByTagName(&quot;methodsynopsis&quot;) as $element) {
            $methodSynopsisElements[] = $element;
        }

        foreach ($methodSynopsisElements as $methodSynopsis) {
            if (!$methodSynopsis instanceof DOMElement) {
                continue;
            }

            $list = $methodSynopsis-&gt;getElementsByTagName(&quot;methodname&quot;);
            $item = $list-&gt;item(0);
            if (!$item instanceof DOMElement) {
                continue;
            }
            $funcName = $item-&gt;textContent;
            if (!isset($funcMap[$funcName])) {
                continue;
            }
            $funcInfo = $funcMap[$funcName];

            $newMethodSynopsis = $funcInfo-&gt;getMethodSynopsisElement($funcMap, $aliasMap, $doc);
            if ($newMethodSynopsis === null) {
                continue;
            }

            // Retrieve current signature

            $params = [];
            $list = $methodSynopsis-&gt;getElementsByTagName(&quot;methodparam&quot;);
            foreach ($list as $i =&gt; $item) {
                if (!$item instanceof DOMElement) {
                    continue;
                }

                $paramList = $item-&gt;getElementsByTagName(&quot;parameter&quot;);
                if ($paramList-&gt;count() !== 1) {
                    continue;
                }

                $paramName = $paramList-&gt;item(0)-&gt;textContent;
                $paramTypes = [];

                $paramList = $item-&gt;getElementsByTagName(&quot;type&quot;);
                foreach ($paramList as $type) {
                    if (!$type instanceof DOMElement) {
                        continue;
                    }

                    $paramTypes[] = $type-&gt;textContent;
                }

                $params[$paramName] = [&quot;index&quot; =&gt; $i, &quot;type&quot; =&gt; $paramTypes];
            }

            // Check if there is any change - short circuit if there is not any.

            $xml1 = $doc-&gt;saveXML($methodSynopsis);
            $xml1 = preg_replace(&quot;/&amp;([A-Za-z0-9._{}%-]+?;)/&quot;, &quot;REPLACED-ENTITY-$1&quot;, $xml1);
            $docComparator-&gt;loadXML($xml1);
            $xml1 = $docComparator-&gt;saveXML();

            $methodSynopsis-&gt;parentNode-&gt;replaceChild($newMethodSynopsis, $methodSynopsis);

            $xml2 = $doc-&gt;saveXML($newMethodSynopsis);
            $xml2 = preg_replace(&quot;/&amp;([A-Za-z0-9._{}%-]+?;)/&quot;, &quot;REPLACED-ENTITY-$1&quot;, $xml2);
            $docComparator-&gt;loadXML($xml2);
            $xml2 = $docComparator-&gt;saveXML();

            if ($xml1 === $xml2) {
                continue;
            }

            // Update parameter references

            $paramList = $doc-&gt;getElementsByTagName(&quot;parameter&quot;);
            /** @var DOMElement $paramElement */
            foreach ($paramList as $paramElement) {
                if ($paramElement-&gt;parentNode &amp;&amp; $paramElement-&gt;parentNode-&gt;nodeName === &quot;methodparam&quot;) {
                    continue;
                }

                $name = $paramElement-&gt;textContent;
                if (!isset($params[$name])) {
                    continue;
                }

                $index = $params[$name][&quot;index&quot;];
                if (!isset($funcInfo-&gt;args[$index])) {
                    continue;
                }

                $paramElement-&gt;textContent = $funcInfo-&gt;args[$index]-&gt;name;
            }

            // Return the updated XML

            $replacedXml = $doc-&gt;saveXML();

            $replacedXml = preg_replace(
                [
                    &quot;/REPLACED-ENTITY-([A-Za-z0-9._{}%-]+?;)/&quot;,
                    &quot;/&lt;refentry\s+xmlns=\&quot;([a-z0-9.:\/]+)\&quot;\s+xml:id=\&quot;([a-z0-9._-]+)\&quot;\s*&gt;/i&quot;,
                    &quot;/&lt;refentry\s+xmlns=\&quot;([a-z0-9.:\/]+)\&quot;\s+xmlns:xlink=\&quot;([a-z0-9.:\/]+)\&quot;\s+xml:id=\&quot;([a-z0-9._-]+)\&quot;\s*&gt;/i&quot;,
                ],
                [
                    &quot;&amp;$1&quot;,
                    &quot;&lt;refentry xml:id=\&quot;$2\&quot; xmlns=\&quot;$1\&quot;&gt;&quot;,
                    &quot;&lt;refentry xml:id=\&quot;$3\&quot; xmlns=\&quot;$1\&quot; xmlns:xlink=\&quot;$2\&quot;&gt;&quot;,
                ],
                $replacedXml
            );

            $methodSynopses[$pathName] = $replacedXml;
        }
    }

    return $methodSynopses;
}

function installPhpParser(string $version, string $phpParserDir) {
    $lockFile = __DIR__ . &quot;/PHP-Parser-install-lock&quot;;
    $lockFd = fopen($lockFile, 'w+');
    if (!flock($lockFd, LOCK_EX)) {
        throw new Exception(&quot;Failed to acquire installation lock&quot;);
    }

    try {
        // Check whether a parallel process has already installed PHP-Parser.
        if (is_dir($phpParserDir)) {
            return;
        }

        $cwd = getcwd();
        chdir(__DIR__);

        $tarName = &quot;v$version.tar.gz&quot;;
        passthru(&quot;wget https://github.com/nikic/PHP-Parser/archive/$tarName&quot;, $exit);
        if ($exit !== 0) {
            passthru(&quot;curl -LO https://github.com/nikic/PHP-Parser/archive/$tarName&quot;, $exit);
        }
        if ($exit !== 0) {
            throw new Exception(&quot;Failed to download PHP-Parser tarball&quot;);
        }
        if (!mkdir($phpParserDir)) {
            throw new Exception(&quot;Failed to create directory $phpParserDir&quot;);
        }
        passthru(&quot;tar xvzf $tarName -C PHP-Parser-$version --strip-components 1&quot;, $exit);
        if ($exit !== 0) {
            throw new Exception(&quot;Failed to extract PHP-Parser tarball&quot;);
        }
        unlink(__DIR__ . &quot;/$tarName&quot;);
        chdir($cwd);
    } finally {
        flock($lockFd, LOCK_UN);
        @unlink($lockFile);
    }
}

function initPhpParser() {
    static $isInitialized = false;
    if ($isInitialized) {
        return;
    }

    if (!extension_loaded(&quot;tokenizer&quot;)) {
        throw new Exception(&quot;The \&quot;tokenizer\&quot; extension is not available&quot;);
    }

    $isInitialized = true;
    $version = &quot;4.13.0&quot;;
    $phpParserDir = __DIR__ . &quot;/PHP-Parser-$version&quot;;
    if (!is_dir($phpParserDir)) {
        installPhpParser($version, $phpParserDir);
    }

    spl_autoload_register(function(string $class) use($phpParserDir) {
        if (strpos($class, &quot;PhpParser\\&quot;) === 0) {
            $fileName = $phpParserDir . &quot;/lib/&quot; . str_replace(&quot;\\&quot;, &quot;/&quot;, $class) . &quot;.php&quot;;
            require $fileName;
        }
    });
}

$optind = null;
$options = getopt(&quot;fh&quot;, [&quot;force-regeneration&quot;, &quot;parameter-stats&quot;, &quot;help&quot;, &quot;verify&quot;, &quot;generate-methodsynopses&quot;, &quot;replace-methodsynopses&quot;], $optind);

$context = new Context;
$printParameterStats = isset($options[&quot;parameter-stats&quot;]);
$verify = isset($options[&quot;verify&quot;]);
$generateMethodSynopses = isset($options[&quot;generate-methodsynopses&quot;]);
$replaceMethodSynopses = isset($options[&quot;replace-methodsynopses&quot;]);
$context-&gt;forceRegeneration = isset($options[&quot;f&quot;]) || isset($options[&quot;force-regeneration&quot;]);
$context-&gt;forceParse = $context-&gt;forceRegeneration || $printParameterStats || $verify || $generateMethodSynopses || $replaceMethodSynopses;
$targetMethodSynopses = $argv[$optind + 1] ?? null;
if ($replaceMethodSynopses &amp;&amp; $targetMethodSynopses === null) {
    die(&quot;A target directory must be provided.\n&quot;);
}

if (isset($options[&quot;h&quot;]) || isset($options[&quot;help&quot;])) {
    die(&quot;\nusage: gen-stub.php [ -f | --force-regeneration ] [ --generate-methodsynopses ] [ --replace-methodsynopses ] [ --parameter-stats ] [ --verify ] [ -h | --help ] [ name.stub.php | directory ] [ directory ]\n\n&quot;);
}

$fileInfos = [];
$location = $argv[$optind] ?? &quot;.&quot;;
if (is_file($location)) {
    // Generate single file.
    $fileInfo = processStubFile($location, $context);
    if ($fileInfo) {
        $fileInfos[] = $fileInfo;
    }
} else if (is_dir($location)) {
    $fileInfos = processDirectory($location, $context);
} else {
    echo &quot;$location is neither a file nor a directory.\n&quot;;
    exit(1);
}

if ($printParameterStats) {
    $parameterStats = [];

    foreach ($fileInfos as $fileInfo) {
        foreach ($fileInfo-&gt;getAllFuncInfos() as $funcInfo) {
            foreach ($funcInfo-&gt;args as $argInfo) {
                if (!isset($parameterStats[$argInfo-&gt;name])) {
                    $parameterStats[$argInfo-&gt;name] = 0;
                }
                $parameterStats[$argInfo-&gt;name]++;
            }
        }
    }

    arsort($parameterStats);
    echo json_encode($parameterStats, JSON_PRETTY_PRINT), &quot;\n&quot;;
}

/** @var FuncInfo[] $funcMap */
$funcMap = [];
/** @var FuncInfo[] $aliasMap */
$aliasMap = [];

foreach ($fileInfos as $fileInfo) {
    foreach ($fileInfo-&gt;getAllFuncInfos() as $funcInfo) {
        /** @var FuncInfo $funcInfo */
        $funcMap[$funcInfo-&gt;name-&gt;__toString()] = $funcInfo;

        if ($funcInfo-&gt;aliasType === &quot;alias&quot;) {
            $aliasMap[$funcInfo-&gt;alias-&gt;__toString()] = $funcInfo;
        }
    }
}

if ($verify) {
    $errors = [];

    foreach ($aliasMap as $aliasFunc) {
        if (!isset($funcMap[$aliasFunc-&gt;alias-&gt;__toString()])) {
            $errors[] = &quot;Aliased function {$aliasFunc-&gt;alias}() cannot be found&quot;;
            continue;
        }

        if (!$aliasFunc-&gt;verify) {
            continue;
        }

        $aliasedFunc = $funcMap[$aliasFunc-&gt;alias-&gt;__toString()];
        $aliasedArgs = $aliasedFunc-&gt;args;
        $aliasArgs = $aliasFunc-&gt;args;

        if ($aliasFunc-&gt;isInstanceMethod() !== $aliasedFunc-&gt;isInstanceMethod()) {
            if ($aliasFunc-&gt;isInstanceMethod()) {
                $aliasedArgs = array_slice($aliasedArgs, 1);
            }

            if ($aliasedFunc-&gt;isInstanceMethod()) {
                $aliasArgs = array_slice($aliasArgs, 1);
            }
        }

        array_map(
            function(?ArgInfo $aliasArg, ?ArgInfo $aliasedArg) use ($aliasFunc, $aliasedFunc, &amp;$errors) {
                if ($aliasArg === null) {
                    assert($aliasedArg !== null);
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() is missing&quot;;
                    return null;
                }

                if ($aliasedArg === null) {
                    $errors[] = &quot;{$aliasedFunc-&gt;name}(): Argument \$$aliasArg-&gt;name of alias function {$aliasFunc-&gt;name}() is missing&quot;;
                    return null;
                }

                if ($aliasArg-&gt;name !== $aliasedArg-&gt;name) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same name&quot;;
                    return null;
                }

                if ($aliasArg-&gt;type != $aliasedArg-&gt;type) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same type&quot;;
                }

                if ($aliasArg-&gt;defaultValue !== $aliasedArg-&gt;defaultValue) {
                    $errors[] = &quot;{$aliasFunc-&gt;name}(): Argument \$$aliasArg-&gt;name and argument \$$aliasedArg-&gt;name of aliased function {$aliasedFunc-&gt;name}() must have the same default value&quot;;
                }
            },
            $aliasArgs, $aliasedArgs
        );

        if ((!$aliasedFunc-&gt;isMethod() || $aliasedFunc-&gt;isFinalMethod()) &amp;&amp;
            (!$aliasFunc-&gt;isMethod() || $aliasFunc-&gt;isFinalMethod()) &amp;&amp;
            $aliasFunc-&gt;return != $aliasedFunc-&gt;return
        ) {
            $errors[] = &quot;{$aliasFunc-&gt;name}() and {$aliasedFunc-&gt;name}() must have the same return type&quot;;
        }
    }

    echo implode(&quot;\n&quot;, $errors);
    if (!empty($errors)) {
        echo &quot;\n&quot;;
        exit(1);
    }
}

if ($generateMethodSynopses) {
    $methodSynopsesDirectory = getcwd() . &quot;/methodsynopses&quot;;

    $methodSynopses = generateMethodSynopses($funcMap, $aliasMap);
    if (!empty($methodSynopses)) {
        if (!file_exists($methodSynopsesDirectory)) {
            mkdir($methodSynopsesDirectory);
        }

        foreach ($methodSynopses as $filename =&gt; $content) {
            if (file_put_contents(&quot;$methodSynopsesDirectory/$filename&quot;, $content)) {
                echo &quot;Saved $filename\n&quot;;
            }
        }
    }
}

if ($replaceMethodSynopses) {
    $methodSynopses = replaceMethodSynopses($targetMethodSynopses, $funcMap, $aliasMap);

    foreach ($methodSynopses as $filename =&gt; $content) {
        if (file_put_contents($filename, $content)) {
            echo &quot;Saved $filename\n&quot;;
        }
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-php80%2Froot%2Fusr%2Flib64%2Fphp%2Fbuild'>Back to Directory</a>