Update more func info information for ext/standard

diff --git a/ext/opcache/Optimizer/zend_func_info.c b/ext/opcache/Optimizer/zend_func_info.c
index eee98b31377f224f5a688b5ccfc43ec80a086f81..b6e970b506dc347c678bbe2e0ed11a834d23c9e4 100644 (file)
--- a/ext/opcache/Optimizer/zend_func_info.c
+++ b/ext/opcache/Optimizer/zend_func_info.c
@@ -245,34 +245,34 @@ static const func_info_t func_infos[] = {
        F0("parse_str",                    MAY_BE_NULL),
        F1("str_getcsv",                   MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_NULL | MAY_BE_ARRAY_OF_STRING),
        F1("str_pad",                      MAY_BE_NULL | MAY_BE_STRING),
-       F1("chop",                         MAY_BE_NULL | MAY_BE_STRING),
+       F1("chop",                         MAY_BE_STRING),
        F1("strchr",                       MAY_BE_FALSE | MAY_BE_STRING),
        F1("sprintf",                      MAY_BE_FALSE | MAY_BE_STRING),
        F0("printf",                       MAY_BE_FALSE | MAY_BE_LONG),
        F0("vprintf",                      MAY_BE_FALSE | MAY_BE_LONG),
        F1("vsprintf",                     MAY_BE_FALSE | MAY_BE_STRING),
-       F0("fprintf",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("vfprintf",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
+       F0("fprintf",                      MAY_BE_FALSE | MAY_BE_LONG),
+       F0("vfprintf",                     MAY_BE_FALSE | MAY_BE_LONG),
        F1("sscanf",                       MAY_BE_NULL | MAY_BE_LONG | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ANY),
        F1("fscanf",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ANY),
-       F1("parse_url",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_STRING | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_LONG),
-       F1("urlencode",                    MAY_BE_NULL | MAY_BE_STRING),
-       F1("urldecode",                    MAY_BE_NULL | MAY_BE_STRING),
-       F1("rawurlencode",                 MAY_BE_NULL | MAY_BE_STRING),
-       F1("rawurldecode",                 MAY_BE_NULL | MAY_BE_STRING),
+       F1("parse_url",                    MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_STRING | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_LONG),
+       F1("urlencode",                    MAY_BE_STRING),
+       F1("urldecode",                    MAY_BE_STRING),
+       F1("rawurlencode",                 MAY_BE_STRING),
+       F1("rawurldecode",                 MAY_BE_STRING),
        F1("http_build_query",             MAY_BE_FALSE | MAY_BE_STRING),
 #if defined(HAVE_SYMLINK) || defined(PHP_WIN32)
-       F1("readlink",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F0("linkinfo",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("symlink",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("link",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("readlink",                     MAY_BE_FALSE | MAY_BE_STRING),
+       F0("linkinfo",                     MAY_BE_FALSE | MAY_BE_LONG),
+       F0("symlink",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("link",                         MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
        F0("unlink",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F1("exec",                         MAY_BE_FALSE | MAY_BE_STRING),
        F1("system",                       MAY_BE_FALSE | MAY_BE_STRING),
        F1("escapeshellcmd",               MAY_BE_NULL | MAY_BE_STRING),
        F1("escapeshellarg",               MAY_BE_NULL | MAY_BE_STRING),
-       F1("passthru",                     MAY_BE_FALSE | MAY_BE_STRING),
+       F1("passthru",                     MAY_BE_NULL | MAY_BE_FALSE),
        F1("shell_exec",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
 #ifdef PHP_CAN_SUPPORT_PROC_OPEN
        F1("proc_open",                    MAY_BE_FALSE | MAY_BE_RESOURCE),
@@ -306,54 +306,54 @@ static const func_info_t func_infos[] = {
        F0("getmypid",                     MAY_BE_FALSE | MAY_BE_LONG),
        F0("getmyinode",                   MAY_BE_FALSE | MAY_BE_LONG),
        F0("getlastmod",                   MAY_BE_FALSE | MAY_BE_LONG),
-       F1("base64_decode",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("base64_encode",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("password_hash",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("password_get_info",            MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_ARRAY),
-       F0("password_needs_rehash",        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("base64_decode",                MAY_BE_FALSE | MAY_BE_STRING),
+       F1("base64_encode",                MAY_BE_STRING),
+       F1("password_hash",                MAY_BE_NULL | MAY_BE_STRING),
+       F1("password_get_info",            MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_ARRAY),
+       F0("password_needs_rehash",        MAY_BE_FALSE | MAY_BE_TRUE),
        F0("password_verify",              MAY_BE_FALSE | MAY_BE_TRUE),
        F1("convert_uuencode",             MAY_BE_FALSE | MAY_BE_STRING),
        F1("convert_uudecode",             MAY_BE_FALSE | MAY_BE_STRING),
-       F0("abs",                          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F0("ceil",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("floor",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("round",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("sin",                          MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("cos",                          MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("tan",                          MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("asin",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("acos",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("atan",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("atanh",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("atan2",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("sinh",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("cosh",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("tanh",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("asinh",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("acosh",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("expm1",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("log1p",                        MAY_BE_NULL | MAY_BE_DOUBLE),
+       F0("abs",                          MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
+       F0("ceil",                         MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("floor",                        MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("round",                        MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("sin",                          MAY_BE_DOUBLE),
+       F0("cos",                          MAY_BE_DOUBLE),
+       F0("tan",                          MAY_BE_DOUBLE),
+       F0("asin",                         MAY_BE_DOUBLE),
+       F0("acos",                         MAY_BE_DOUBLE),
+       F0("atan",                         MAY_BE_DOUBLE),
+       F0("atanh",                        MAY_BE_DOUBLE),
+       F0("atan2",                        MAY_BE_DOUBLE),
+       F0("sinh",                         MAY_BE_DOUBLE),
+       F0("cosh",                         MAY_BE_DOUBLE),
+       F0("tanh",                         MAY_BE_DOUBLE),
+       F0("asinh",                        MAY_BE_DOUBLE),
+       F0("acosh",                        MAY_BE_DOUBLE),
+       F0("expm1",                        MAY_BE_DOUBLE),
+       F0("log1p",                        MAY_BE_DOUBLE),
        F0("pi",                           MAY_BE_DOUBLE),
-       F0("is_finite",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_nan",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_infinite",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("pow",                          MAY_BE_NULL | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F0("exp",                          MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("log",                          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("log10",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("sqrt",                         MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("hypot",                        MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("deg2rad",                      MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("rad2deg",                      MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("bindec",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F0("hexdec",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F0("octdec",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F1("decbin",                       MAY_BE_NULL | MAY_BE_STRING),
-       F1("decoct",                       MAY_BE_NULL | MAY_BE_STRING),
+       F0("is_finite",                    MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_nan",                       MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_infinite",                  MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("pow",                          MAY_BE_NULL | MAY_BE_LONG | MAY_BE_DOUBLE | MAY_BE_OBJECT),
+       F0("exp",                          MAY_BE_DOUBLE),
+       F0("log",                          MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("log10",                        MAY_BE_DOUBLE),
+       F0("sqrt",                         MAY_BE_DOUBLE),
+       F0("hypot",                        MAY_BE_DOUBLE),
+       F0("deg2rad",                      MAY_BE_DOUBLE),
+       F0("rad2deg",                      MAY_BE_DOUBLE),
+       F0("bindec",                       MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
+       F0("hexdec",                       MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
+       F0("octdec",                       MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_DOUBLE),
+       F1("decbin",                       MAY_BE_STRING),
+       F1("decoct",                       MAY_BE_STRING),
        F1("dechex",                       MAY_BE_STRING),
-       F1("base_convert",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("number_format",                MAY_BE_NULL | MAY_BE_STRING),
-       F0("fmod",                         MAY_BE_NULL | MAY_BE_DOUBLE),
+       F1("base_convert",                 MAY_BE_FALSE | MAY_BE_STRING),
+       F1("number_format",                MAY_BE_STRING),
+       F0("fmod",                         MAY_BE_DOUBLE),
 #ifdef HAVE_INET_NTOP
        F1("inet_ntop",                    MAY_BE_FALSE | MAY_BE_STRING),
 #endif
@@ -371,18 +371,18 @@ static const func_info_t func_infos[] = {
        F1("sys_getloadavg",               MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_DOUBLE),
 #endif
 #ifdef HAVE_GETTIMEOFDAY
-       F1("microtime",                    MAY_BE_NULL | MAY_BE_DOUBLE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_LONG | MAY_BE_STRING),
-       F1("gettimeofday",                 MAY_BE_NULL | MAY_BE_DOUBLE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG | MAY_BE_STRING),
+       F1("microtime",                    MAY_BE_DOUBLE | MAY_BE_STRING),
+       F1("gettimeofday",                 MAY_BE_DOUBLE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG),
 #endif
 #ifdef HAVE_GETRUSAGE
-       F1("getrusage",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG),
+       F1("getrusage",                    MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_LONG),
 #endif
 #ifdef HAVE_GETTIMEOFDAY
-       F1("uniqid",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+       F1("uniqid",                       MAY_BE_STRING),
 #endif
-       F1("quoted_printable_decode",      MAY_BE_NULL | MAY_BE_STRING),
-       F1("quoted_printable_encode",      MAY_BE_NULL | MAY_BE_STRING),
-       F1("convert_cyr_string",           MAY_BE_NULL | MAY_BE_STRING),
+       F1("quoted_printable_decode",      MAY_BE_STRING),
+       F1("quoted_printable_encode",      MAY_BE_STRING),
+       F1("convert_cyr_string",           MAY_BE_STRING),
        F1("get_current_user",             MAY_BE_STRING),
        F0("set_time_limit",               MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
        F0("header_register_callback",     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
@@ -439,28 +439,28 @@ static const func_info_t func_infos[] = {
 #endif
        F0("is_uploaded_file",             MAY_BE_FALSE | MAY_BE_TRUE),
        F0("move_uploaded_file",           MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("gethostbyaddr",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("gethostbyname",                MAY_BE_NULL | MAY_BE_STRING),
-       F1("gethostbynamel",               MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("gethostbyaddr",                MAY_BE_FALSE | MAY_BE_STRING),
+       F1("gethostbyname",                MAY_BE_STRING),
+       F1("gethostbynamel",               MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
 #ifdef HAVE_GETHOSTNAME
        F1("gethostname",                  MAY_BE_FALSE | MAY_BE_STRING),
 #endif
 #if defined(PHP_WIN32) || HAVE_DNS_SEARCH_FUNC
-       F0("dns_check_record",             MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("checkdnsrr",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("dns_check_record",             MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("checkdnsrr",                   MAY_BE_FALSE | MAY_BE_TRUE),
 # if defined(PHP_WIN32) || HAVE_FULL_DNS_FUNCS
-       F0("dns_get_mx",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("getmxrr",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("dns_get_record",               MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ARRAY),
+       F0("dns_get_mx",                   MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("getmxrr",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("dns_get_record",               MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ARRAY),
 # endif
 #endif
-       F0("intval",                       MAY_BE_NULL | MAY_BE_LONG),
-       F0("floatval",                     MAY_BE_NULL | MAY_BE_DOUBLE),
-       F0("doubleval",                    MAY_BE_NULL | MAY_BE_DOUBLE),
-       FN("strval",                       MAY_BE_NULL | MAY_BE_STRING),
-       F0("boolval",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       FN("gettype",                      MAY_BE_NULL | MAY_BE_STRING),
-       F0("settype",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("intval",                       MAY_BE_LONG),
+       F0("floatval",                     MAY_BE_DOUBLE),
+       F0("doubleval",                    MAY_BE_DOUBLE),
+       FN("strval",                       MAY_BE_STRING),
+       F0("boolval",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       FN("gettype",                      MAY_BE_STRING),
+       F0("settype",                      MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_null",                      MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_resource",                  MAY_BE_FALSE | MAY_BE_TRUE), // TODO: inline with support for closed resources
        F0("is_bool",                      MAY_BE_FALSE | MAY_BE_TRUE),
@@ -470,16 +470,16 @@ static const func_info_t func_infos[] = {
        F0("is_integer",                   MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_double",                    MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_real",                      MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_numeric",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_numeric",                   MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_string",                    MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_array",                     MAY_BE_FALSE | MAY_BE_TRUE),
        F0("is_object",                    MAY_BE_FALSE | MAY_BE_TRUE), // TODO: inline with support for incomplete class
-       F0("is_scalar",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_callable",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_countable",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_iterable",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_scalar",                    MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_callable",                  MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_countable",                 MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_iterable",                  MAY_BE_FALSE | MAY_BE_TRUE),
        F0("pclose",                       MAY_BE_FALSE | MAY_BE_LONG),
-       F1("popen",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_RESOURCE),
+       F1("popen",                        MAY_BE_FALSE | MAY_BE_RESOURCE),
        F0("readfile",                     MAY_BE_FALSE | MAY_BE_LONG),
        F0("rewind",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F0("rmdir",                        MAY_BE_FALSE | MAY_BE_TRUE),

diff --git a/ext/standard/base64.c b/ext/standard/base64.c
index 3286b7d30d9911321eed74b616d7526d11bb05f3..541bf8f582139e26ab1ea0b56e596d4e330e322e 100644 (file)
--- a/ext/standard/base64.c
+++ b/ext/standard/base64.c
@@ -803,7 +803,7 @@ PHP_FUNCTION(base64_encode)
 }
 /* }}} */
 
-/* {{{ proto string base64_decode(string str[, bool strict])
+/* {{{ proto string|false base64_decode(string str[, bool strict])
    Decodes string using MIME base64 algorithm */
 PHP_FUNCTION(base64_decode)
 {

diff --git a/ext/standard/dns.c b/ext/standard/dns.c
index 3f34ba67eecadcbcac83e9c2ffc6b057eb2d6461..6e856842f9de0799b4a8269d3aec48e96accfa64 100644 (file)
--- a/ext/standard/dns.c
+++ b/ext/standard/dns.c
@@ -120,7 +120,7 @@ static zend_string *php_gethostbyaddr(char *ip);
 static zend_string *php_gethostbyname(char *name);
 
 #ifdef HAVE_GETHOSTNAME
-/* {{{ proto string gethostname()
+/* {{{ proto string|false gethostname()
    Get the host name of the current machine */
 PHP_FUNCTION(gethostname)
 {
@@ -144,7 +144,7 @@ PHP_FUNCTION(gethostname)
  we can have a dns.c, dns_unix.c and dns_win32.c instead of a messy dns.c full of #ifdef
 */
 
-/* {{{ proto string gethostbyaddr(string ip_address)
+/* {{{ proto string|false gethostbyaddr(string ip_address)
    Get the Internet host name corresponding to a given IP address */
 PHP_FUNCTION(gethostbyaddr)
 {
@@ -227,7 +227,7 @@ PHP_FUNCTION(gethostbyname)
 }
 /* }}} */
 
-/* {{{ proto array gethostbynamel(string hostname)
+/* {{{ proto array|false gethostbynamel(string hostname)
    Return a list of IP addresses that a given hostname resolves to. */
 PHP_FUNCTION(gethostbynamel)
 {

diff --git a/ext/standard/exec.c b/ext/standard/exec.c
index b79eb37c0408b4d5e8731421238dba4492133120..8ca0c9c6ae8ed8af134560500f248c47d840a73b 100644 (file)
--- a/ext/standard/exec.c
+++ b/ext/standard/exec.c
@@ -216,7 +216,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
                        Z_PARAM_ZVAL(ret_array)
                }
                Z_PARAM_ZVAL(ret_code)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if (!cmd_len) {
                php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
@@ -248,7 +248,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
 }
 /* }}} */
 
-/* {{{ proto string exec(string command [, array &output [, int &return_value]])
+/* {{{ proto string|false exec(string command [, array &output [, int &return_value]])
    Execute an external program */
 PHP_FUNCTION(exec)
 {
@@ -256,7 +256,7 @@ PHP_FUNCTION(exec)
 }
 /* }}} */
 
-/* {{{ proto int system(string command [, int &return_value])
+/* {{{ proto int|false system(string command [, int &return_value])
    Execute an external program and display output */
 PHP_FUNCTION(system)
 {
@@ -264,7 +264,7 @@ PHP_FUNCTION(system)
 }
 /* }}} */
 
-/* {{{ proto void passthru(string command [, int &return_value])
+/* {{{ proto bool passthru(string command [, int &return_value])
    Execute an external program and display raw output */
 PHP_FUNCTION(passthru)
 {
@@ -515,7 +515,7 @@ PHP_FUNCTION(escapeshellarg)
 }
 /* }}} */
 
-/* {{{ proto string shell_exec(string cmd)
+/* {{{ proto string|false shell_exec(string cmd)
    Execute command via shell and return complete output as string */
 PHP_FUNCTION(shell_exec)
 {

diff --git a/ext/standard/file.c b/ext/standard/file.c
index 8e129334e635804dc6321958c5cb03ceaa50d11a..8020e607d1e3e260e2b518ebb3316e48f7a62fac 100644 (file)
--- a/ext/standard/file.c
+++ b/ext/standard/file.c
@@ -927,7 +927,7 @@ PHPAPI PHP_FUNCTION(fclose)
 }
 /* }}} */
 
-/* {{{ proto resource popen(string command, string mode)
+/* {{{ proto resource|false popen(string command, string mode)
    Execute a command and open either a read or a write pipe to it */
 PHP_FUNCTION(popen)
 {
@@ -1463,7 +1463,7 @@ PHP_FUNCTION(unlink)
                Z_PARAM_PATH(filename, filename_len)
                Z_PARAM_OPTIONAL
                Z_PARAM_RESOURCE_EX(zcontext, 1, 0)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        context = php_stream_context_from_zval(zcontext, 0);
 

diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c
index b804cda5002fcee6e2fafb99b122c10fcf366b88..863ca829201cf252b25172ea65d29fd6415626a0 100644 (file)
--- a/ext/standard/formatted_print.c
+++ b/ext/standard/formatted_print.c
@@ -659,7 +659,7 @@ php_formatted_print_get_array(zval *array, int *argc)
 }
 /* }}} */
 
-/* {{{ proto string sprintf(string format [, mixed arg1 [, mixed ...]])
+/* {{{ proto string|false sprintf(string format [, mixed arg1 [, mixed ...]])
    Return a formatted string */
 PHP_FUNCTION(user_sprintf)
 {
@@ -670,7 +670,7 @@ PHP_FUNCTION(user_sprintf)
        ZEND_PARSE_PARAMETERS_START(1, -1)
                Z_PARAM_ZVAL(format)
                Z_PARAM_VARIADIC('*', args, argc)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        result = php_formatted_print(format, args, argc);
        if (result == NULL) {
@@ -680,7 +680,7 @@ PHP_FUNCTION(user_sprintf)
 }
 /* }}} */
 
-/* {{{ proto string vsprintf(string format, array args)
+/* {{{ proto string|false vsprintf(string format, array args)
    Return a formatted string */
 PHP_FUNCTION(vsprintf)
 {
@@ -691,7 +691,7 @@ PHP_FUNCTION(vsprintf)
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_ZVAL(format)
                Z_PARAM_ZVAL(array)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        args = php_formatted_print_get_array(array, &argc);
 
@@ -704,7 +704,7 @@ PHP_FUNCTION(vsprintf)
 }
 /* }}} */
 
-/* {{{ proto int printf(string format [, mixed arg1 [, mixed ...]])
+/* {{{ proto int|false printf(string format [, mixed arg1 [, mixed ...]])
    Output a formatted string */
 PHP_FUNCTION(user_printf)
 {
@@ -716,7 +716,7 @@ PHP_FUNCTION(user_printf)
        ZEND_PARSE_PARAMETERS_START(1, -1)
                Z_PARAM_ZVAL(format)
                Z_PARAM_VARIADIC('*', args, argc)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        result = php_formatted_print(format, args, argc);
        if (result == NULL) {
@@ -728,7 +728,7 @@ PHP_FUNCTION(user_printf)
 }
 /* }}} */
 
-/* {{{ proto int vprintf(string format, array args)
+/* {{{ proto int|false vprintf(string format, array args)
    Output a formatted string */
 PHP_FUNCTION(vprintf)
 {
@@ -740,7 +740,7 @@ PHP_FUNCTION(vprintf)
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_ZVAL(format)
                Z_PARAM_ZVAL(array)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        args = php_formatted_print_get_array(array, &argc);
 
@@ -755,7 +755,7 @@ PHP_FUNCTION(vprintf)
 }
 /* }}} */
 
-/* {{{ proto int fprintf(resource stream, string format [, mixed arg1 [, mixed ...]])
+/* {{{ proto int|false fprintf(resource stream, string format [, mixed arg1 [, mixed ...]])
    Output a formatted string into a stream */
 PHP_FUNCTION(fprintf)
 {
@@ -772,7 +772,7 @@ PHP_FUNCTION(fprintf)
                Z_PARAM_RESOURCE(arg1)
                Z_PARAM_ZVAL(format)
                Z_PARAM_VARIADIC('*', args, argc)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, arg1);
 
@@ -788,7 +788,7 @@ PHP_FUNCTION(fprintf)
 }
 /* }}} */
 
-/* {{{ proto int vfprintf(resource stream, string format, array args)
+/* {{{ proto int|false vfprintf(resource stream, string format, array args)
    Output a formatted string into a stream */
 PHP_FUNCTION(vfprintf)
 {
@@ -805,7 +805,7 @@ PHP_FUNCTION(vfprintf)
                Z_PARAM_RESOURCE(arg1)
                Z_PARAM_ZVAL(format)
                Z_PARAM_ZVAL(array)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, arg1);
 

diff --git a/ext/standard/http.c b/ext/standard/http.c
index 3ec6d3b932c4eccccde738c55c36efc37c828860..7db3b701ece3c1bd4b8ae96bfd8b00bf59f01403 100644 (file)
--- a/ext/standard/http.c
+++ b/ext/standard/http.c
@@ -224,7 +224,7 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 }
 /* }}} */
 
-/* {{{ proto string http_build_query(mixed formdata [, string prefix [, string arg_separator [, int enc_type]]])
+/* {{{ proto string|false http_build_query(mixed formdata [, string prefix [, string arg_separator [, int enc_type]]])
    Generates a form-encoded query string from an associative array or object. */
 PHP_FUNCTION(http_build_query)
 {
@@ -240,7 +240,7 @@ PHP_FUNCTION(http_build_query)
                Z_PARAM_STRING(prefix, prefix_len)
                Z_PARAM_STRING(arg_sep, arg_sep_len)
                Z_PARAM_LONG(enc_type)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if (php_url_encode_hash_ex(HASH_OF(formdata), &formstr, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL), arg_sep, (int)enc_type) == FAILURE) {
                if (formstr.s) {

diff --git a/ext/standard/link.c b/ext/standard/link.c
index 111704934446d45d06433325dcda6f0f81f828dc..c723c376549ef0103a827505d8a65a5feb375bef 100644 (file)
--- a/ext/standard/link.c
+++ b/ext/standard/link.c
@@ -62,7 +62,7 @@
 #define VOLUME_NAME_DOS 0x0
 #endif
 
-/* {{{ proto string readlink(string filename)
+/* {{{ proto string|false readlink(string filename)
    Return the target of a symbolic link */
 PHP_FUNCTION(readlink)
 {
@@ -96,7 +96,7 @@ PHP_FUNCTION(readlink)
 }
 /* }}} */
 
-/* {{{ proto int linkinfo(string filename)
+/* {{{ proto int|false linkinfo(string filename)
    Returns the st_dev field of the UNIX C stat structure describing the link */
 PHP_FUNCTION(linkinfo)
 {
@@ -130,7 +130,7 @@ PHP_FUNCTION(linkinfo)
 }
 /* }}} */
 
-/* {{{ proto int symlink(string target, string link)
+/* {{{ proto bool symlink(string target, string link)
    Create a symbolic link */
 PHP_FUNCTION(symlink)
 {
@@ -189,7 +189,7 @@ PHP_FUNCTION(symlink)
 }
 /* }}} */
 
-/* {{{ proto int link(string target, string link)
+/* {{{ proto bool link(string target, string link)
    Create a hard link */
 PHP_FUNCTION(link)
 {

diff --git a/ext/standard/math.c b/ext/standard/math.c
index cefcd387693533d87cfcaf9696ec8f8a787300aa..1490fa0a4847a74954491ff3989e56d69d5fd38d 100644 (file)
--- a/ext/standard/math.c
+++ b/ext/standard/math.c
@@ -283,7 +283,7 @@ static double php_expm1(double x)
 }
 /* }}}*/
 
-/* {{{ proto int abs(int number)
+/* {{{ proto int|float|false abs(int number)
    Return the absolute value of the number */
 PHP_FUNCTION(abs)
 {
@@ -308,7 +308,7 @@ PHP_FUNCTION(abs)
 }
 /* }}} */
 
-/* {{{ proto float ceil(float number)
+/* {{{ proto float|false ceil(float number)
    Returns the next highest integer value of the number */
 PHP_FUNCTION(ceil)
 {
@@ -329,7 +329,7 @@ PHP_FUNCTION(ceil)
 }
 /* }}} */
 
-/* {{{ proto float floor(float number)
+/* {{{ proto float|false floor(float number)
    Returns the next lowest integer value from the number */
 PHP_FUNCTION(floor)
 {
@@ -350,7 +350,7 @@ PHP_FUNCTION(floor)
 }
 /* }}} */
 
-/* {{{ proto float round(float number [, int precision [, int mode]])
+/* {{{ proto float|false round(float number [, int precision [, int mode]])
    Returns the number rounded to specified precision */
 PHP_FUNCTION(round)
 {
@@ -683,7 +683,7 @@ PHP_FUNCTION(log1p)
 }
 /* }}} */
 
-/* {{{ proto float log(float number, [float base])
+/* {{{ proto float|false log(float number, [float base])
    Returns the natural logarithm of the number, or the base log if base is specified */
 PHP_FUNCTION(log)
 {
@@ -1077,7 +1077,7 @@ PHP_FUNCTION(dechex)
 }
 /* }}} */
 
-/* {{{ proto string base_convert(string number, int frombase, int tobase)
+/* {{{ proto string|false base_convert(string number, int frombase, int tobase)
    Converts a number in a string from any base <= 36 to any base <= 36 */
 PHP_FUNCTION(base_convert)
 {

diff --git a/ext/standard/microtime.c b/ext/standard/microtime.c
index 46d1a7b2784aa2c46ec1c5b9a54262b2a4d18630..b4ed537dd9c9de7e65bc7624ff6777fcd0296606 100644 (file)
--- a/ext/standard/microtime.c
+++ b/ext/standard/microtime.c
@@ -100,7 +100,7 @@ PHP_FUNCTION(gettimeofday)
 /* }}} */
 
 #ifdef HAVE_GETRUSAGE
-/* {{{ proto array getrusage([int who])
+/* {{{ proto array|false getrusage([int who])
    Returns an array of usage statistics */
 PHP_FUNCTION(getrusage)
 {

diff --git a/ext/standard/password.c b/ext/standard/password.c
index 4a4d99dc6e0191f4fd6c67900f99f88c1de2d2a8..093df4fc06ce312ec26e8046ddf5fba8f0126776 100644 (file)
--- a/ext/standard/password.c
+++ b/ext/standard/password.c
@@ -545,7 +545,7 @@ const php_password_algo* php_password_algo_identify_ex(const zend_string* hash,
        return (!algo || (algo->valid && !algo->valid(hash))) ? default_algo : algo;
 }
 
-/* {{{ proto array password_get_info(string $hash)
+/* {{{ proto array|null password_get_info(string $hash)
 Retrieves information about a given hash */
 PHP_FUNCTION(password_get_info)
 {
@@ -628,14 +628,14 @@ PHP_FUNCTION(password_verify)
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_STR(password)
                Z_PARAM_STR(hash)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        algo = php_password_algo_identify(hash);
        RETURN_BOOL(algo && (!algo->verify || algo->verify(password, hash)));
 }
 /* }}} */
 
-/* {{{ proto string password_hash(string password, mixed algo[, array options = array()])
+/* {{{ proto string|null password_hash(string password, mixed algo[, array options = array()])
 Hash a password */
 PHP_FUNCTION(password_hash)
 {

diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c
index 326cfc14312f5f3201584dad39a1a6abc98c1f23..bd8a94eca48d70a66b018633bec0856141de1f5e 100644 (file)
--- a/ext/standard/proc_open.c
+++ b/ext/standard/proc_open.c
@@ -248,7 +248,7 @@ PHP_FUNCTION(proc_terminate)
                Z_PARAM_RESOURCE(zproc)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(sig_no)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if ((proc = (struct php_process_handle *)zend_fetch_resource(Z_RES_P(zproc), "process", le_proc_open)) == NULL) {
                RETURN_FALSE;
@@ -270,7 +270,7 @@ PHP_FUNCTION(proc_terminate)
 }
 /* }}} */
 
-/* {{{ proto int proc_close(resource process)
+/* {{{ proto int|false proc_close(resource process)
    close a process opened by proc_open */
 PHP_FUNCTION(proc_close)
 {
@@ -279,7 +279,7 @@ PHP_FUNCTION(proc_close)
 
        ZEND_PARSE_PARAMETERS_START(1, 1)
                Z_PARAM_RESOURCE(zproc)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if ((proc = (struct php_process_handle *)zend_fetch_resource(Z_RES_P(zproc), "process", le_proc_open)) == NULL) {
                RETURN_FALSE;
@@ -292,7 +292,7 @@ PHP_FUNCTION(proc_close)
 }
 /* }}} */
 
-/* {{{ proto array proc_get_status(resource process)
+/* {{{ proto array|false proc_get_status(resource process)
    get information about a process opened by proc_open */
 PHP_FUNCTION(proc_get_status)
 {
@@ -309,7 +309,7 @@ PHP_FUNCTION(proc_get_status)
 
        ZEND_PARSE_PARAMETERS_START(1, 1)
                Z_PARAM_RESOURCE(zproc)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if ((proc = (struct php_process_handle *)zend_fetch_resource(Z_RES_P(zproc), "process", le_proc_open)) == NULL) {
                RETURN_FALSE;
@@ -399,7 +399,7 @@ struct php_proc_open_descriptor_item {
 };
 /* }}} */
 
-/* {{{ proto resource proc_open(string command, array descriptorspec, array &pipes [, string cwd [, array env [, array other_options]]])
+/* {{{ proto resource|false proc_open(string command, array descriptorspec, array &pipes [, string cwd [, array env [, array other_options]]])
    Run a process with more control over it's file descriptors */
 PHP_FUNCTION(proc_open)
 {

diff --git a/ext/standard/uuencode.c b/ext/standard/uuencode.c
index bfe605a49b283bdac6e3ef5122dc6e59ad9344d2..fcb8ba03d8c67d78e718c53f975eb36f1cb811d7 100644 (file)
--- a/ext/standard/uuencode.c
+++ b/ext/standard/uuencode.c
@@ -196,7 +196,7 @@ err:
 }
 /* }}} */
 
-/* {{{ proto string convert_uuencode(string data)
+/* {{{ proto string|false convert_uuencode(string data)
    uuencode a string */
 PHP_FUNCTION(convert_uuencode)
 {
@@ -204,14 +204,14 @@ PHP_FUNCTION(convert_uuencode)
 
        ZEND_PARSE_PARAMETERS_START(1, 1)
                Z_PARAM_STR(src)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
        if (ZSTR_LEN(src) < 1) { RETURN_FALSE; }
 
        RETURN_STR(php_uuencode(ZSTR_VAL(src), ZSTR_LEN(src)));
 }
 /* }}} */
 
-/* {{{ proto string convert_uudecode(string data)
+/* {{{ proto string|false convert_uudecode(string data)
    decode a uuencoded string */
 PHP_FUNCTION(convert_uudecode)
 {
@@ -220,7 +220,7 @@ PHP_FUNCTION(convert_uudecode)
 
        ZEND_PARSE_PARAMETERS_START(1, 1)
                Z_PARAM_STR(src)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
        if (ZSTR_LEN(src) < 1) { RETURN_FALSE; }
 
        if ((dest = php_uudecode(ZSTR_VAL(src), ZSTR_LEN(src))) == NULL) {