Finish func_info updates for ext/standard

diff --git a/ext/opcache/Optimizer/zend_func_info.c b/ext/opcache/Optimizer/zend_func_info.c
index efde5927f034aa6a111249b792fc88919a5c241b..5d2ec26a68b949265e91e014878896af762c6462 100644 (file)
--- a/ext/opcache/Optimizer/zend_func_info.c
+++ b/ext/opcache/Optimizer/zend_func_info.c
@@ -500,13 +500,13 @@ static const func_info_t func_infos[] = {
        F0("fputs",                        MAY_BE_FALSE | MAY_BE_LONG),
        F0("mkdir",                        MAY_BE_FALSE | MAY_BE_TRUE),
        F0("rename",                       MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("copy",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("tempnam",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+       F0("copy",                         MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("tempnam",                      MAY_BE_FALSE | MAY_BE_STRING),
        F1("tmpfile",                      MAY_BE_FALSE | MAY_BE_RESOURCE),
-       F1("file",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
-       F1("file_get_contents",            MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F0("file_put_contents",            MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("stream_select",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
+       F1("file",                         MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("file_get_contents",            MAY_BE_FALSE | MAY_BE_STRING),
+       F0("file_put_contents",            MAY_BE_FALSE | MAY_BE_LONG),
+       F0("stream_select",                MAY_BE_FALSE | MAY_BE_LONG),
        F1("stream_context_create",        MAY_BE_FALSE | MAY_BE_RESOURCE),
        F0("stream_context_set_params",    MAY_BE_FALSE | MAY_BE_TRUE),
        F1("stream_context_get_params",    MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
@@ -534,17 +534,17 @@ static const func_info_t func_infos[] = {
        F1("stream_get_contents",          MAY_BE_FALSE | MAY_BE_STRING),
        F0("stream_supports_lock",         MAY_BE_FALSE | MAY_BE_TRUE),
        F1("fgetcsv",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_NULL | MAY_BE_ARRAY_OF_STRING),
-       F0("fputcsv",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("flock",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("get_meta_tags",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_STRING),
+       F0("fputcsv",                      MAY_BE_FALSE | MAY_BE_LONG),
+       F0("flock",                        MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("get_meta_tags",                MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_STRING),
        F0("stream_set_read_buffer",       MAY_BE_FALSE | MAY_BE_LONG),
        F0("stream_set_write_buffer",      MAY_BE_FALSE | MAY_BE_LONG),
        F0("set_file_buffer",              MAY_BE_FALSE | MAY_BE_LONG),
        F0("stream_set_chunk_size",        MAY_BE_FALSE | MAY_BE_LONG),
-       F0("set_socket_blocking",          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("stream_set_blocking",          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("socket_set_blocking",          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("stream_get_meta_data",         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
+       F0("set_socket_blocking",          MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("stream_set_blocking",          MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("socket_set_blocking",          MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("stream_get_meta_data",         MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
        F1("stream_get_line",              MAY_BE_FALSE | MAY_BE_STRING),
        F0("stream_wrapper_register",      MAY_BE_FALSE | MAY_BE_TRUE),
        F0("stream_register_wrapper",      MAY_BE_FALSE | MAY_BE_TRUE),
@@ -552,27 +552,27 @@ static const func_info_t func_infos[] = {
        F0("stream_wrapper_restore",       MAY_BE_FALSE | MAY_BE_TRUE),
        F1("stream_get_wrappers",          MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
        F1("stream_get_transports",        MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
-       F1("stream_resolve_include_path",  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+       F1("stream_resolve_include_path",  MAY_BE_FALSE | MAY_BE_STRING),
        F0("stream_is_local",              MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("get_headers",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_ARRAY),
+       F1("get_headers",                  MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_ARRAY),
 #if HAVE_SYS_TIME_H || defined(PHP_WIN32)
-       F0("stream_set_timeout",           MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("socket_set_timeout",           MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("stream_set_timeout",           MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("socket_set_timeout",           MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
-       F1("socket_get_status",            MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
+       F1("socket_get_status",            MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
 #if HAVE_REALPATH || defined(ZTS)
-       F1("realpath",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+       F1("realpath",                     MAY_BE_FALSE | MAY_BE_STRING),
 #endif
 #ifdef HAVE_FNMATCH
-       F0("fnmatch",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("fnmatch",                      MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
        F1("fsockopen",                    MAY_BE_FALSE | MAY_BE_RESOURCE),
        FN("pfsockopen",                   MAY_BE_FALSE | MAY_BE_RESOURCE),
        F1("pack",                         MAY_BE_FALSE | MAY_BE_STRING),
-       F1("unpack",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY),
+       F1("unpack",                       MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY),
        F1("get_browser",                  MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_OBJECT | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
-       F1("crypt",                        MAY_BE_NULL | MAY_BE_STRING),
-       FN("opendir",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_RESOURCE),
+       F1("crypt",                        MAY_BE_STRING),
+       FN("opendir",                      MAY_BE_FALSE | MAY_BE_RESOURCE),
        F0("closedir",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
        F0("chdir",                        MAY_BE_FALSE | MAY_BE_TRUE),
 #if defined(HAVE_CHROOT) && !defined(ZTS) && ENABLE_CHROOT_FUNC
@@ -580,86 +580,86 @@ static const func_info_t func_infos[] = {
 #endif
        F1("getcwd",                       MAY_BE_FALSE | MAY_BE_STRING),
        F0("rewinddir",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("readdir",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("dir",                          MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_OBJECT),
-       F1("scandir",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("readdir",                      MAY_BE_FALSE | MAY_BE_STRING),
+       F1("dir",                          MAY_BE_FALSE | MAY_BE_OBJECT),
+       F1("scandir",                      MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
 #ifdef HAVE_GLOB
-       F1("glob",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("glob",                         MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
 #endif
-       F0("fileatime",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("filectime",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("filegroup",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("fileinode",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("filemtime",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("fileowner",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("fileperms",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("filesize",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F1("filetype",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F0("file_exists",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_writable",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_writeable",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_readable",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_executable",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_file",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_dir",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("is_link",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("stat",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_FALSE | MAY_BE_ARRAY_OF_TRUE | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
-       F1("lstat",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_FALSE | MAY_BE_ARRAY_OF_TRUE | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
-       F0("chown",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("chgrp",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("fileatime",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("filectime",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("filegroup",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("fileinode",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("filemtime",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("fileowner",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("fileperms",                    MAY_BE_FALSE | MAY_BE_LONG),
+       F0("filesize",                     MAY_BE_FALSE | MAY_BE_LONG),
+       F1("filetype",                     MAY_BE_FALSE | MAY_BE_STRING),
+       F0("file_exists",                  MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_writable",                  MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_writeable",                 MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_readable",                  MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_executable",                MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_file",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_dir",                       MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("is_link",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("stat",                         MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_FALSE | MAY_BE_ARRAY_OF_TRUE | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("lstat",                        MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_FALSE | MAY_BE_ARRAY_OF_TRUE | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
+       F0("chown",                        MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("chgrp",                        MAY_BE_FALSE | MAY_BE_TRUE),
 #if HAVE_LCHOWN
-       F0("lchown",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("lchown",                       MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
 #if HAVE_LCHOWN
-       F0("lchgrp",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("lchgrp",                       MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
-       F0("chmod",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("chmod",                        MAY_BE_FALSE | MAY_BE_TRUE),
 #if HAVE_UTIME
-       F0("touch",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("touch",                        MAY_BE_FALSE | MAY_BE_TRUE),
 #endif
        F0("clearstatcache",               MAY_BE_NULL),
-       F0("disk_total_space",             MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("disk_free_space",              MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
-       F0("diskfreespace",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("disk_total_space",             MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("disk_free_space",              MAY_BE_FALSE | MAY_BE_DOUBLE),
+       F0("diskfreespace",                MAY_BE_FALSE | MAY_BE_DOUBLE),
        F0("realpath_cache_size",          MAY_BE_LONG),
        F1("realpath_cache_get",           MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ARRAY),
-       F0("mail",                         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("ezmlm_hash",                   MAY_BE_NULL | MAY_BE_LONG),
+       F0("mail",                         MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("ezmlm_hash",                   MAY_BE_LONG),
 #ifdef HAVE_SYSLOG_H
-       F0("openlog",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("syslog",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("openlog",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("syslog",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F0("closelog",                     MAY_BE_TRUE),
 #endif
        F0("lcg_value",                    MAY_BE_DOUBLE),
-       F1("metaphone",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F0("ob_start",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("ob_flush",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("ob_clean",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("ob_end_flush",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("ob_end_clean",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("ob_get_flush",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F1("ob_get_clean",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
-       F0("ob_get_length",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-       F0("ob_get_level",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
+       F1("metaphone",                    MAY_BE_FALSE | MAY_BE_STRING),
+       F0("ob_start",                     MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("ob_flush",                     MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("ob_clean",                     MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("ob_end_flush",                 MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("ob_end_clean",                 MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("ob_get_flush",                 MAY_BE_FALSE | MAY_BE_STRING),
+       F1("ob_get_clean",                 MAY_BE_FALSE | MAY_BE_STRING),
+       F0("ob_get_length",                MAY_BE_FALSE | MAY_BE_LONG),
+       F0("ob_get_level",                 MAY_BE_LONG),
        F1("ob_get_status",                MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_ARRAY),
-       FN("ob_get_contents",              MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+       FN("ob_get_contents",              MAY_BE_FALSE | MAY_BE_STRING),
        F0("ob_implicit_flush",            MAY_BE_NULL),
        F1("ob_list_handlers",             MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
        F0("ksort",                        MAY_BE_FALSE | MAY_BE_TRUE),
        F0("krsort",                       MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("natsort",                      MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("natcasesort",                  MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("natsort",                      MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("natcasesort",                  MAY_BE_FALSE | MAY_BE_TRUE),
        F0("asort",                        MAY_BE_FALSE | MAY_BE_TRUE),
        F0("arsort",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F0("sort",                         MAY_BE_FALSE | MAY_BE_TRUE),
        F0("rsort",                        MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("usort",                        MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("uasort",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("uksort",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("usort",                        MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("uasort",                       MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("uksort",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F0("shuffle",                      MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("array_walk",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("array_walk_recursive",         MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("count",                        MAY_BE_NULL | MAY_BE_LONG),
+       F0("array_walk",                   MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("array_walk_recursive",         MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("count",                        MAY_BE_LONG),
        FN("end",                          UNKNOWN_INFO),
        FN("prev",                         UNKNOWN_INFO),
        FN("next",                         UNKNOWN_INFO),
@@ -668,75 +668,77 @@ static const func_info_t func_infos[] = {
        FN("key",                          MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
        FN("min",                          UNKNOWN_INFO),
        FN("max",                          UNKNOWN_INFO),
-       F0("in_array",                     MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("in_array",                     MAY_BE_FALSE | MAY_BE_TRUE),
        FN("array_search",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_STRING),
        F0("extract",                      MAY_BE_NULL | MAY_BE_LONG),
        F1("compact",                      MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_fill",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ANY),
-       F1("array_fill_keys",              MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_fill",                   MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ANY),
+       F1("array_fill_keys",              MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
        FC("range",                        zend_range_info),
-       F0("array_multisort",              MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("array_push",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
+       F0("array_multisort",              MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("array_push",                   MAY_BE_FALSE | MAY_BE_LONG),
        FN("array_pop",                    UNKNOWN_INFO),
        FN("array_shift",                  UNKNOWN_INFO),
-       F0("array_unshift",                MAY_BE_NULL | MAY_BE_LONG),
-       F1("array_splice",                 MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_slice",                  MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       FN("array_merge",                  MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_merge_recursive",        MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_replace",                MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_replace_recursive",      MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       FN("array_keys",                   MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
-       FN("array_values",                 MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_count_values",           MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_LONG),
-       F1("array_column",                 MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_reverse",                MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F0("array_unshift",                MAY_BE_LONG),
+       F1("array_splice",                 MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_slice",                  MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_merge",                  MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_merge_recursive",        MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_replace",                MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_replace_recursive",      MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_keys",                   MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
+       FN("array_values",                 MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_key_first",              MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+       FN("array_key_last",               MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+       F1("array_count_values",           MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_LONG),
+       F1("array_column",                 MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_reverse",                MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
        F1("array_reduce",                 UNKNOWN_INFO),
-       FN("array_pad",                    MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_flip",                   MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
-       F1("array_change_key_case",        MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_pad",                    MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_flip",                   MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_LONG | MAY_BE_ARRAY_OF_STRING),
+       F1("array_change_key_case",        MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
        F1("array_rand",                   UNKNOWN_INFO),
-       FN("array_unique",                 MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_intersect",              MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_intersect_key",          MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_intersect_ukey",         MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_uintersect",             MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_intersect_assoc",        MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_uintersect_assoc",       MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_intersect_uassoc",       MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_uintersect_uassoc",      MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       FN("array_diff",                   MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_diff_key",               MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_diff_ukey",              MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_udiff",                  MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_diff_assoc",             MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_udiff_assoc",            MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_diff_uassoc",            MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_udiff_uassoc",           MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F0("array_sum",                    MAY_BE_NULL | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F0("array_product",                MAY_BE_NULL | MAY_BE_LONG | MAY_BE_DOUBLE),
-       F1("array_filter",                 MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       FN("array_map",                    MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_unique",                 MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_intersect",              MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_intersect_key",          MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_intersect_ukey",         MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_uintersect",             MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_intersect_assoc",        MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_uintersect_assoc",       MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_intersect_uassoc",       MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_uintersect_uassoc",      MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_diff",                   MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_diff_key",               MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_diff_ukey",              MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_udiff",                  MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_diff_assoc",             MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_udiff_assoc",            MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_diff_uassoc",            MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F1("array_udiff_uassoc",           MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F0("array_sum",                    MAY_BE_LONG | MAY_BE_DOUBLE),
+       F0("array_product",                MAY_BE_LONG | MAY_BE_DOUBLE),
+       F1("array_filter",                 MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       FN("array_map",                    MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
        F1("array_chunk",                  MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F1("array_combine",                MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
-       F0("array_key_exists",             MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F1("array_combine",                MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ARRAY_OF_ANY),
+       F0("array_key_exists",             MAY_BE_FALSE | MAY_BE_TRUE),
        F1("pos",                          UNKNOWN_INFO),
-       F0("sizeof",                       MAY_BE_NULL | MAY_BE_LONG),
-       F0("key_exists",                   MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-       F0("assert",                       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("sizeof",                       MAY_BE_LONG),
+       F0("key_exists",                   MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("assert",                       MAY_BE_FALSE | MAY_BE_TRUE),
        F1("assert_options",               MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_STRING | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING | MAY_BE_ARRAY_OF_OBJECT | MAY_BE_OBJECT),
        F0("version_compare",              MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE | MAY_BE_LONG),
 #if HAVE_FTOK
-       F0("ftok",                         MAY_BE_NULL | MAY_BE_LONG),
+       F0("ftok",                         MAY_BE_LONG),
 #endif
-       F1("str_rot13",                    MAY_BE_NULL | MAY_BE_STRING),
+       F1("str_rot13",                    MAY_BE_STRING),
        F1("stream_get_filters",           MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_STRING),
        F0("stream_filter_register",       MAY_BE_FALSE | MAY_BE_TRUE),
-       F1("stream_bucket_make_writeable", MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_OBJECT),
+       F1("stream_bucket_make_writeable", MAY_BE_FALSE | MAY_BE_OBJECT),
        F1("stream_bucket_prepend",        MAY_BE_FALSE | MAY_BE_OBJECT),
        F1("stream_bucket_append",         MAY_BE_FALSE | MAY_BE_OBJECT),
        F1("stream_bucket_new",            MAY_BE_FALSE | MAY_BE_OBJECT),
-       F0("output_add_rewrite_var",       MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
+       F0("output_add_rewrite_var",       MAY_BE_FALSE | MAY_BE_TRUE),
        F0("output_reset_rewrite_vars",    MAY_BE_FALSE),
        F1("sys_get_temp_dir",             MAY_BE_STRING),
 

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 8f04db636d585b628cd5c0c3cdcceb7a5b836019..355f13dfa95f2dfaa867f89a042d9ddb50244cb3 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -2413,7 +2413,7 @@ static zend_long php_extract_skip(zend_array *arr, zend_array *symbol_table) /*
 }
 /* }}} */
 
-/* {{{ proto int extract(array var_array [, int extract_type [, string prefix]])
+/* {{{ proto int|null extract(array var_array [, int extract_type [, string prefix]])
    Imports variables into symbol table from an array */
 PHP_FUNCTION(extract)
 {
@@ -2556,7 +2556,7 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu
 }
 /* }}} */
 
-/* {{{ proto array compact(mixed var_names [, mixed ...])
+/* {{{ proto array|null compact(mixed var_names [, mixed ...])
    Creates a hash containing variables and their values */
 PHP_FUNCTION(compact)
 {
@@ -2592,7 +2592,7 @@ PHP_FUNCTION(compact)
 }
 /* }}} */
 
-/* {{{ proto array array_fill(int start_key, int num, mixed val)
+/* {{{ proto array|false array_fill(int start_key, int num, mixed val)
    Create an array containing num elements starting with index start_key each initialized to val */
 PHP_FUNCTION(array_fill)
 {
@@ -3974,7 +3974,7 @@ PHP_FUNCTION(array_keys)
 }
 /* }}} */
 
-/* {{{ proto mixed array_key_first(array stack)
+/* {{{ proto int|string|false array_key_first(array stack)
    Get the key of the first element of the array */
 PHP_FUNCTION(array_key_first)
 {
@@ -3990,7 +3990,7 @@ PHP_FUNCTION(array_key_first)
 }
 /* }}} */
 
-/* {{{ proto mixed array_key_last(array stack)
+/* {{{ proto int|string|false array_key_last(array stack)
    Get the key of the last element of the array */
 PHP_FUNCTION(array_key_last)
 {
@@ -4159,7 +4159,7 @@ static inline zval *array_column_fetch_prop(zval *data, zval *name, zval *rv) /*
 }
 /* }}} */
 
-/* {{{ proto array array_column(array input, mixed column_key[, mixed index_key])
+/* {{{ proto array|false array_column(array input, mixed column_key[, mixed index_key])
    Return the values from a single column in the input array, identified by the
    value_key and optionally indexed by the index_key */
 PHP_FUNCTION(array_column)
@@ -4748,7 +4748,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
                        param_spec = "+f";
                        intersect_data_compare_func = php_array_user_compare;
                } else {
-                       php_error_docref(NULL, E_WARNING, "data_compare_type is %d. This should never happen. Please report as a bug", data_compare_type);
+                       ZEND_ASSERT(0 && "Invalid data_compare_type");
                        return;
                }
 
@@ -4800,7 +4800,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
                        fci_key = &fci2;
                        fci_key_cache = &fci2_cache;
                } else {
-                       php_error_docref(NULL, E_WARNING, "data_compare_type is %d. key_compare_type is %d. This should never happen. Please report as a bug", data_compare_type, key_compare_type);
+                       ZEND_ASSERT(0 && "Invalid data_compare_type / key_compare_type");
                        return;
                }
 
@@ -4814,7 +4814,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
                }
 
        } else {
-               php_error_docref(NULL, E_WARNING, "behavior is %d. This should never happen. Please report as a bug", behavior);
+               ZEND_ASSERT(0 && "Invalid behavior");
                return;
        }
 
@@ -5211,7 +5211,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
                        fci_key = &fci2;
                        fci_key_cache = &fci2_cache;
                } else {
-                       php_error_docref(NULL, E_WARNING, "data_compare_type is %d. key_compare_type is %d. This should never happen. Please report as a bug", data_compare_type, key_compare_type);
+                       ZEND_ASSERT(0 && "Invalid data_compare_type / key_compare_type");
                        return;
                }
 
@@ -5225,7 +5225,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
                }
 
        } else {
-               php_error_docref(NULL, E_WARNING, "behavior is %d. This should never happen. Please report as a bug", behavior);
+               ZEND_ASSERT(0 && "Invalid behavior");
                return;
        }
 
@@ -6134,8 +6134,6 @@ PHP_FUNCTION(array_map)
                Z_PARAM_VARIADIC('+', arrays, n_arrays)
        ZEND_PARSE_PARAMETERS_END();
 
-       RETVAL_NULL();
-
        if (n_arrays == 1) {
                zend_ulong num_key;
                zend_string *str_key;
@@ -6318,7 +6316,7 @@ PHP_FUNCTION(array_key_exists)
 }
 /* }}} */
 
-/* {{{ proto array array_chunk(array input, int size [, bool preserve_keys])
+/* {{{ proto array|null array_chunk(array input, int size [, bool preserve_keys])
    Split array into chunks */
 PHP_FUNCTION(array_chunk)
 {
@@ -6387,7 +6385,7 @@ PHP_FUNCTION(array_chunk)
 }
 /* }}} */
 
-/* {{{ proto array array_combine(array keys, array values)
+/* {{{ proto array|false array_combine(array keys, array values)
    Creates an array by using the elements of the first parameter as keys and the elements of the second as the corresponding values */
 PHP_FUNCTION(array_combine)
 {

diff --git a/ext/standard/dir.c b/ext/standard/dir.c
index e81855fc29f28250a79244ab10d6ad2a22b72530..e60e3e17b0e3116842acf1418b810b5cb1a8a7e4 100644 (file)
--- a/ext/standard/dir.c
+++ b/ext/standard/dir.c
@@ -239,7 +239,7 @@ static void _php_do_opendir(INTERNAL_FUNCTION_PARAMETERS, int createobject)
 }
 /* }}} */
 
-/* {{{ proto mixed opendir(string path[, resource context])
+/* {{{ proto resource|false opendir(string path[, resource context])
    Open a directory and return a dir_handle */
 PHP_FUNCTION(opendir)
 {
@@ -247,7 +247,7 @@ PHP_FUNCTION(opendir)
 }
 /* }}} */
 
-/* {{{ proto object dir(string directory[, resource context])
+/* {{{ proto objectđalse dir(string directory[, resource context])
    Directory class with properties, handle and class and methods read, rewind and close */
 PHP_FUNCTION(getdir)
 {
@@ -255,7 +255,7 @@ PHP_FUNCTION(getdir)
 }
 /* }}} */
 
-/* {{{ proto void closedir([resource dir_handle])
+/* {{{ proto bool closedir([resource dir_handle])
    Close directory connection identified by the dir_handle */
 PHP_FUNCTION(closedir)
 {
@@ -390,7 +390,7 @@ PHP_FUNCTION(rewinddir)
 }
 /* }}} */
 
-/* {{{ proto string readdir([resource dir_handle])
+/* {{{ proto string|false readdir([resource dir_handle])
    Read directory entry from dir_handle */
 PHP_NAMED_FUNCTION(php_if_readdir)
 {
@@ -413,7 +413,7 @@ PHP_NAMED_FUNCTION(php_if_readdir)
 /* }}} */
 
 #ifdef HAVE_GLOB
-/* {{{ proto array glob(string pattern [, int flags])
+/* {{{ proto array|false glob(string pattern [, int flags])
    Find pathnames matching a pattern */
 PHP_FUNCTION(glob)
 {
@@ -546,7 +546,7 @@ no_results:
 /* }}} */
 #endif
 
-/* {{{ proto array scandir(string dir [, int sorting_order [, resource context]])
+/* {{{ proto array|false scandir(string dir [, int sorting_order [, resource context]])
    List files & directories inside the specified path */
 PHP_FUNCTION(scandir)
 {

diff --git a/ext/standard/file.c b/ext/standard/file.c
index 8020e607d1e3e260e2b518ebb3316e48f7a62fac..32f21fbb0aecbe82b1dcde2b6ecdefb368c92201 100644 (file)
--- a/ext/standard/file.c
+++ b/ext/standard/file.c
@@ -375,7 +375,7 @@ PHP_FUNCTION(flock)
 
 #define PHP_META_UNSAFE ".\\+*?[^]$() "
 
-/* {{{ proto array get_meta_tags(string filename [, bool use_include_path])
+/* {{{ proto array|false get_meta_tags(string filename [, bool use_include_path])
    Extracts all meta tag content attributes from a file and returns an array */
 PHP_FUNCTION(get_meta_tags)
 {
@@ -520,7 +520,7 @@ PHP_FUNCTION(get_meta_tags)
 }
 /* }}} */
 
-/* {{{ proto string file_get_contents(string filename [, bool use_include_path [, resource context [, int offset [, int maxlen]]]])
+/* {{{ proto string|false file_get_contents(string filename [, bool use_include_path [, resource context [, int offset [, int maxlen]]]])
    Read the entire file into a string */
 PHP_FUNCTION(file_get_contents)
 {
@@ -578,7 +578,7 @@ PHP_FUNCTION(file_get_contents)
 }
 /* }}} */
 
-/* {{{ proto int file_put_contents(string file, mixed data [, int flags [, resource context]])
+/* {{{ proto int|false file_put_contents(string file, mixed data [, int flags [, resource context]])
    Write/Create a file with contents data and return the number of bytes written */
 PHP_FUNCTION(file_put_contents)
 {
@@ -720,7 +720,7 @@ PHP_FUNCTION(file_put_contents)
 
 #define PHP_FILE_BUF_SIZE      80
 
-/* {{{ proto array file(string filename [, int flags[, resource context]])
+/* {{{ proto array|false file(string filename [, int flags[, resource context]])
    Read entire file into an array */
 PHP_FUNCTION(file)
 {
@@ -816,7 +816,7 @@ parse_eol:
 }
 /* }}} */
 
-/* {{{ proto string tempnam(string dir, string prefix)
+/* {{{ proto string|false tempnam(string dir, string prefix)
    Create a unique filename in a directory */
 PHP_FUNCTION(tempnam)
 {
@@ -1932,7 +1932,7 @@ PHPAPI size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char
 }
 /* }}} */
 
-/* {{{ proto array fgetcsv(resource fp [,int length [, string delimiter [, string enclosure [, string escape]]]])
+/* {{{ proto array|false fgetcsv(resource fp [,int length [, string delimiter [, string enclosure [, string escape]]]])
    Get line from file pointer and parse for CSV fields */
 PHP_FUNCTION(fgetcsv)
 {
@@ -2293,7 +2293,7 @@ out:
 /* }}} */
 
 #if HAVE_REALPATH || defined(ZTS)
-/* {{{ proto string realpath(string path)
+/* {{{ proto string|false realpath(string path)
    Return the resolved path */
 PHP_FUNCTION(realpath)
 {

diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c
index bf2bc752b03152bc8a2560da37f104d0e3f386c2..91420bbe6e3aa4df091adfd81644fb357183f113 100644 (file)
--- a/ext/standard/filestat.c
+++ b/ext/standard/filestat.c
@@ -178,7 +178,7 @@ static int php_disk_total_space(char *path, double *space) /* {{{ */
 /* }}} */
 /* }}} */
 
-/* {{{ proto float disk_total_space(string path)
+/* {{{ proto float|false disk_total_space(string path)
    Get total disk space for filesystem that path is on */
 PHP_FUNCTION(disk_total_space)
 {
@@ -273,7 +273,7 @@ static int php_disk_free_space(char *path, double *space) /* {{{ */
 /* }}} */
 /* }}} */
 
-/* {{{ proto float disk_free_space(string path)
+/* {{{ proto float|false disk_free_space(string path)
    Get free disk space for filesystem that path is on */
 PHP_FUNCTION(disk_free_space)
 {

diff --git a/ext/standard/mail.c b/ext/standard/mail.c
index c1a21c40592b3a13597641fe0f5d192c128951dc..ef6bd1da4442966d3caca1cfaf6627f300681c73 100644 (file)
--- a/ext/standard/mail.c
+++ b/ext/standard/mail.c
@@ -275,7 +275,7 @@ PHPAPI zend_string *php_mail_build_headers(zval *headers)
 }
 
 
-/* {{{ proto int mail(string to, string subject, string message [, string additional_headers [, string additional_parameters]])
+/* {{{ proto bool mail(string to, string subject, string message [, string additional_headers [, string additional_parameters]])
    Send an email message */
 PHP_FUNCTION(mail)
 {

diff --git a/ext/standard/metaphone.c b/ext/standard/metaphone.c
index 16fd14957134fe0d0422b2eecb0ac079b756ebc4..ee2feac7c079eb9fe553d5b0e3a0df6c2fd66f4e 100644 (file)
--- a/ext/standard/metaphone.c
+++ b/ext/standard/metaphone.c
@@ -25,7 +25,7 @@
 
 static int metaphone(unsigned char *word, size_t word_len, zend_long max_phonemes, zend_string **phoned_word, int traditional);
 
-/* {{{ proto string metaphone(string text[, int phones])
+/* {{{ proto string|false metaphone(string text[, int phones])
    Break english phrases down into their phonemes */
 PHP_FUNCTION(metaphone)
 {

diff --git a/ext/standard/pack.c b/ext/standard/pack.c
index 5f375585d412266c97fdfb5a24c3f978bf543fcc..7ca94ff2cfff1f6c15fbfc1e528bc66454fef85f 100644 (file)
--- a/ext/standard/pack.c
+++ b/ext/standard/pack.c
@@ -710,7 +710,7 @@ static zend_long php_unpack(char *data, size_t size, int issigned, int *map)
  * Implemented formats are Z, A, a, h, H, c, C, s, S, i, I, l, L, n, N, q, Q, J, P, f, d, x, X, @.
  * Added g, G for little endian float and big endian float, added e, E for little endian double and big endian double.
  */
-/* {{{ proto array unpack(string format, string input)
+/* {{{ proto array|false unpack(string format, string input)
    Unpack binary string into named array elements according to format argument */
 PHP_FUNCTION(unpack)
 {

diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c
index 5b2a683ce8f6bb979ea691ef54ae7cba0ed3948c..996b3030e84e74f96a65ed3ad0f34f89f0e259f2 100644 (file)
--- a/ext/standard/streamsfuncs.c
+++ b/ext/standard/streamsfuncs.c
@@ -49,7 +49,7 @@ static php_stream_context *decode_context_param(zval *contextresource);
 /* Streams based network functions */
 
 #if HAVE_SOCKETPAIR
-/* {{{ proto array stream_socket_pair(int domain, int type, int protocol)
+/* {{{ proto array|false stream_socket_pair(int domain, int type, int protocol)
    Creates a pair of connected, indistinguishable socket streams */
 PHP_FUNCTION(stream_socket_pair)
 {
@@ -61,7 +61,7 @@ PHP_FUNCTION(stream_socket_pair)
                Z_PARAM_LONG(domain)
                Z_PARAM_LONG(type)
                Z_PARAM_LONG(protocol)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        if (0 != socketpair((int)domain, (int)type, (int)protocol, pair)) {
                char errbuf[256];
@@ -86,7 +86,7 @@ PHP_FUNCTION(stream_socket_pair)
 /* }}} */
 #endif
 
-/* {{{ proto resource stream_socket_client(string remoteaddress [, int &errcode [, string &errstring [, double timeout [, int flags [, resource context]]]]])
+/* {{{ proto resource|false stream_socket_client(string remoteaddress [, int &errcode [, string &errstring [, double timeout [, int flags [, resource context]]]]])
    Open a client connection to a remote address */
 PHP_FUNCTION(stream_socket_client)
 {
@@ -112,7 +112,7 @@ PHP_FUNCTION(stream_socket_client)
                Z_PARAM_DOUBLE(timeout)
                Z_PARAM_LONG(flags)
                Z_PARAM_RESOURCE(zcontext)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
 
@@ -175,7 +175,7 @@ PHP_FUNCTION(stream_socket_client)
 }
 /* }}} */
 
-/* {{{ proto resource stream_socket_server(string localaddress [, int &errcode [, string &errstring [, int flags [, resource context]]]])
+/* {{{ proto resource|false stream_socket_server(string localaddress [, int &errcode [, string &errstring [, int flags [, resource context]]]])
    Create a server socket bound to localaddress */
 PHP_FUNCTION(stream_socket_server)
 {
@@ -197,7 +197,7 @@ PHP_FUNCTION(stream_socket_server)
                Z_PARAM_ZVAL(zerrstr)
                Z_PARAM_LONG(flags)
                Z_PARAM_RESOURCE(zcontext)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
 
@@ -240,7 +240,7 @@ PHP_FUNCTION(stream_socket_server)
 }
 /* }}} */
 
-/* {{{ proto resource stream_socket_accept(resource serverstream, [ double timeout [, string &peername ]])
+/* {{{ proto resource|false stream_socket_accept(resource serverstream, [ double timeout [, string &peername ]])
    Accept a client connection from a server socket */
 PHP_FUNCTION(stream_socket_accept)
 {
@@ -258,7 +258,7 @@ PHP_FUNCTION(stream_socket_accept)
                Z_PARAM_OPTIONAL
                Z_PARAM_DOUBLE(timeout)
                Z_PARAM_ZVAL(zpeername)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, zstream);
 
@@ -293,7 +293,7 @@ PHP_FUNCTION(stream_socket_accept)
 }
 /* }}} */
 
-/* {{{ proto string stream_socket_get_name(resource stream, bool want_peer)
+/* {{{ proto string|false stream_socket_get_name(resource stream, bool want_peer)
    Returns either the locally bound or remote name for a socket stream */
 PHP_FUNCTION(stream_socket_get_name)
 {
@@ -305,7 +305,7 @@ PHP_FUNCTION(stream_socket_get_name)
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_RESOURCE(zstream)
                Z_PARAM_BOOL(want_peer)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, zstream);
 
@@ -325,7 +325,7 @@ PHP_FUNCTION(stream_socket_get_name)
 }
 /* }}} */
 
-/* {{{ proto int stream_socket_sendto(resource stream, string data [, int flags [, string target_addr]])
+/* {{{ proto int|false stream_socket_sendto(resource stream, string data [, int flags [, string target_addr]])
    Send data to a socket stream.  If target_addr is specified it must be in dotted quad (or [ipv6]) format */
 PHP_FUNCTION(stream_socket_sendto)
 {
@@ -343,7 +343,7 @@ PHP_FUNCTION(stream_socket_sendto)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(flags)
                Z_PARAM_STRING(target_addr, target_addr_len)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
        php_stream_from_zval(stream, zstream);
 
        if (target_addr_len) {
@@ -358,7 +358,7 @@ PHP_FUNCTION(stream_socket_sendto)
 }
 /* }}} */
 
-/* {{{ proto string stream_socket_recvfrom(resource stream, int amount [, int flags [, string &remote_addr]])
+/* {{{ proto string|false stream_socket_recvfrom(resource stream, int amount [, int flags [, string &remote_addr]])
    Receives data from a socket stream */
 PHP_FUNCTION(stream_socket_recvfrom)
 {
@@ -376,7 +376,7 @@ PHP_FUNCTION(stream_socket_recvfrom)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(flags)
                Z_PARAM_ZVAL(zremote)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, zstream);
 
@@ -409,7 +409,7 @@ PHP_FUNCTION(stream_socket_recvfrom)
 }
 /* }}} */
 
-/* {{{ proto string stream_get_contents(resource source [, int maxlen [, int offset]])
+/* {{{ proto string|false stream_get_contents(resource source [, int maxlen [, int offset]])
    Reads all remaining bytes (or up to maxlen bytes) from a stream and returns them as a string. */
 PHP_FUNCTION(stream_get_contents)
 {
@@ -424,7 +424,7 @@ PHP_FUNCTION(stream_get_contents)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(maxlen)
                Z_PARAM_LONG(desiredpos)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(stream, zsrc);
 
@@ -460,7 +460,7 @@ PHP_FUNCTION(stream_get_contents)
 }
 /* }}} */
 
-/* {{{ proto int stream_copy_to_stream(resource source, resource dest [, int maxlen [, int pos]])
+/* {{{ proto int|false stream_copy_to_stream(resource source, resource dest [, int maxlen [, int pos]])
    Reads up to maxlen bytes from source stream and writes them to dest stream. */
 PHP_FUNCTION(stream_copy_to_stream)
 {
@@ -476,7 +476,7 @@ PHP_FUNCTION(stream_copy_to_stream)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(maxlen)
                Z_PARAM_LONG(pos)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        php_stream_from_zval(src, zsrc);
        php_stream_from_zval(dest, zdest);
@@ -495,7 +495,7 @@ PHP_FUNCTION(stream_copy_to_stream)
 }
 /* }}} */
 
-/* {{{ proto array stream_get_meta_data(resource fp)
+/* {{{ proto array|false stream_get_meta_data(resource fp)
     Retrieves header/meta data from streams/file pointers */
 PHP_FUNCTION(stream_get_meta_data)
 {
@@ -552,7 +552,7 @@ PHP_FUNCTION(stream_get_meta_data)
 }
 /* }}} */
 
-/* {{{ proto array stream_get_transports()
+/* {{{ proto array|false stream_get_transports()
    Retrieves list of registered socket transports */
 PHP_FUNCTION(stream_get_transports)
 {
@@ -574,7 +574,7 @@ PHP_FUNCTION(stream_get_transports)
 }
 /* }}} */
 
-/* {{{ proto array stream_get_wrappers()
+/* {{{ proto array|false stream_get_wrappers()
     Retrieves list of registered stream wrappers */
 PHP_FUNCTION(stream_get_wrappers)
 {
@@ -738,7 +738,7 @@ static int stream_array_emulate_read_fd_set(zval *stream_array)
 }
 /* }}} */
 
-/* {{{ proto int stream_select(array &read_streams, array &write_streams, array &except_streams, int tv_sec[, int tv_usec])
+/* {{{ proto int|false stream_select(array &read_streams, array &write_streams, array &except_streams, int tv_sec[, int tv_usec])
    Runs the select() system call on the sets of streams with a timeout specified by tv_sec and tv_usec */
 PHP_FUNCTION(stream_select)
 {
@@ -959,7 +959,7 @@ static php_stream_context *decode_context_param(zval *contextresource)
 }
 /* }}} */
 
-/* {{{ proto array stream_context_get_options(resource context|resource stream)
+/* {{{ proto array|false stream_context_get_options(resource context|resource stream)
    Retrieve options for a stream/wrapper/context */
 PHP_FUNCTION(stream_context_get_options)
 {
@@ -993,7 +993,7 @@ PHP_FUNCTION(stream_context_set_option)
                ZEND_PARSE_PARAMETERS_START(2, 2)
                        Z_PARAM_RESOURCE(zcontext)
                        Z_PARAM_ARRAY(options)
-               ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+               ZEND_PARSE_PARAMETERS_END();
 
                /* figure out where the context is coming from exactly */
                if (!(context = decode_context_param(zcontext))) {
@@ -1012,7 +1012,7 @@ PHP_FUNCTION(stream_context_set_option)
                        Z_PARAM_STRING(wrappername, wrapperlen)
                        Z_PARAM_STRING(optionname, optionlen)
                        Z_PARAM_ZVAL(zvalue)
-               ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+               ZEND_PARSE_PARAMETERS_END();
 
                /* figure out where the context is coming from exactly */
                if (!(context = decode_context_param(zcontext))) {
@@ -1035,7 +1035,7 @@ PHP_FUNCTION(stream_context_set_params)
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_RESOURCE(zcontext)
                Z_PARAM_ARRAY(params)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        context = decode_context_param(zcontext);
        if (!context) {
@@ -1047,7 +1047,7 @@ PHP_FUNCTION(stream_context_set_params)
 }
 /* }}} */
 
-/* {{{ proto array stream_context_get_params(resource context|resource stream)
+/* {{{ proto array|false stream_context_get_params(resource context|resource stream)
    Get parameters of a file context */
 PHP_FUNCTION(stream_context_get_params)
 {
@@ -1056,7 +1056,7 @@ PHP_FUNCTION(stream_context_get_params)
 
        ZEND_PARSE_PARAMETERS_START(1, 1)
                Z_PARAM_RESOURCE(zcontext)
-       ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+       ZEND_PARSE_PARAMETERS_END();
 
        context = decode_context_param(zcontext);
        if (!context) {
@@ -1536,7 +1536,7 @@ PHP_FUNCTION(stream_socket_enable_crypto)
 }
 /* }}} */
 
-/* {{{ proto string stream_resolve_include_path(string filename)
+/* {{{ proto string|false stream_resolve_include_path(string filename)
 Determine what file will be opened by calls to fopen() with a relative path */
 PHP_FUNCTION(stream_resolve_include_path)
 {

diff --git a/ext/standard/url.c b/ext/standard/url.c
index ff70ea4e04585403590188ce2b987793a29dc5ab..8309b2df4ba907e8f4ea8de6077f09e0d29fa637 100644 (file)
--- a/ext/standard/url.c
+++ b/ext/standard/url.c
@@ -658,7 +658,7 @@ PHPAPI size_t php_raw_url_decode(char *str, size_t len)
 }
 /* }}} */
 
-/* {{{ proto array get_headers(string url[, int format[, resource context]])
+/* {{{ proto array|false get_headers(string url[, int format[, resource context]])
    fetches all the headers sent by the server in response to a HTTP request */
 PHP_FUNCTION(get_headers)
 {

diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c
index 4d347a59a2b6b59f98f2469d7af92aeb6942c338..95f2168df9acc94e00a9bfa7bba9c147dd480714 100644 (file)
--- a/ext/standard/user_filters.c
+++ b/ext/standard/user_filters.c
@@ -387,7 +387,7 @@ static void filter_item_dtor(zval *zv)
        efree(fdat);
 }
 
-/* {{{ proto object stream_bucket_make_writeable(resource brigade)
+/* {{{ proto object|false stream_bucket_make_writeable(resource brigade)
    Return a bucket object from the brigade for operating on */
 PHP_FUNCTION(stream_bucket_make_writeable)
 {

diff --git a/ext/standard/versioning.c b/ext/standard/versioning.c
index e4353130d633e9489bfbe2655920d643e9fbac2d..99f62ee47175cf98be172392e5fb8405f38d983d 100644 (file)
--- a/ext/standard/versioning.c
+++ b/ext/standard/versioning.c
@@ -201,7 +201,7 @@ php_version_compare(const char *orig_ver1, const char *orig_ver2)
 }
 
 /* }}} */
-/* {{{ proto int version_compare(string ver1, string ver2 [, string oper])
+/* {{{ proto int|bool|null version_compare(string ver1, string ver2 [, string oper])
   Compares two "PHP-standardized" version number strings */
 
 PHP_FUNCTION(version_compare)

diff --git a/main/output.c b/main/output.c
index 7751586dbc9a58d8b194dae1e52728f9ec0c4236..289f73d0daffe9e03c90e0cc073c868fb1e47114 100644 (file)
--- a/main/output.c
+++ b/main/output.c
@@ -1434,7 +1434,7 @@ PHP_FUNCTION(ob_get_clean)
 }
 /* }}} */
 
-/* {{{ proto string ob_get_contents(void)
+/* {{{ proto string|false ob_get_contents(void)
    Return the contents of the output buffer */
 PHP_FUNCTION(ob_get_contents)
 {
@@ -1460,7 +1460,7 @@ PHP_FUNCTION(ob_get_level)
 }
 /* }}} */
 
-/* {{{ proto int ob_get_length(void)
+/* {{{ proto int|false ob_get_length(void)
    Return the length of the output buffer */
 PHP_FUNCTION(ob_get_length)
 {
@@ -1474,7 +1474,7 @@ PHP_FUNCTION(ob_get_length)
 }
 /* }}} */
 
-/* {{{ proto false|array ob_list_handlers()
+/* {{{ proto null|array ob_list_handlers()
    List all output_buffers in an array */
 PHP_FUNCTION(ob_list_handlers)
 {