Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions | Variables
basic_functions.c File Reference
#include "php.h"
#include "php_streams.h"
#include "php_main.h"
#include "php_globals.h"
#include "php_ini.h"
#include "php_standard.h"
#include "php_math.h"
#include "php_http.h"
#include "php_incomplete_class.h"
#include "php_getopt.h"
#include "ext/standard/info.h"
#include "ext/session/php_session.h"
#include "zend_operators.h"
#include "ext/standard/php_dns.h"
#include "ext/standard/php_uuencode.h"
#include "safe_mode.h"
#include "zend.h"
#include "zend_ini_scanner.h"
#include "zend_language_scanner.h"
#include <zend_language_parser.h>
#include <stdarg.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netdb.h>
#include <strings.h>
#include "zend_globals.h"
#include "SAPI.h"
#include "php_ticks.h"
#include "php_fopen_wrappers.h"
#include "streamsfuncs.h"

Go to the source code of this file.

Classes

struct  _php_shutdown_function_entry
struct  _user_tick_function_entry

Defines

#define INADDR_NONE   ((unsigned long int) -1)
#define PHP_DOUBLE_INFINITY_HIGH   0x7ff00000
#define PHP_DOUBLE_QUIET_NAN_HIGH   0xfff80000
#define REGISTER_MATH_CONSTANT(x)   REGISTER_DOUBLE_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT)
#define _CHECK_PATH(var, var_len, ini)   php_ini_check_path(var, var_len, ini, sizeof(ini))

Typedefs

typedef struct yy_buffer_state * YY_BUFFER_STATE
typedef struct
_php_shutdown_function_entry 
php_shutdown_function_entry
typedef struct
_user_tick_function_entry 
user_tick_function_entry

Functions

static void user_shutdown_function_dtor (php_shutdown_function_entry *shutdown_function_entry)
static void user_tick_function_dtor (user_tick_function_entry *tick_function_entry)
 ZEND_ARG_INFO (ZEND_ARG_INFO(1, arg)
static PHP_INI_MH (OnUpdateSafeModeProtectedEnvVars)
static PHP_INI_MH (OnUpdateSafeModeAllowedEnvVars)
 PHP_INI_BEGIN ()
static void basic_globals_ctor (php_basic_globals *basic_globals_p TSRMLS_DC)
static void basic_globals_dtor (php_basic_globals *basic_globals_p TSRMLS_DC)
PHPAPI double php_get_nan (void)
PHPAPI double php_get_inf (void)
 PHP_MINIT_FUNCTION (basic)
 PHP_MSHUTDOWN_FUNCTION (basic)
 PHP_RINIT_FUNCTION (basic)
 PHP_RSHUTDOWN_FUNCTION (basic)
 PHP_MINFO_FUNCTION (basic)
 PHP_FUNCTION (constant)
 PHP_FUNCTION (ip2long)
 PHP_FUNCTION (long2ip)
 PHP_FUNCTION (getenv)
static void free_argv (char **argv, int argc)
static void free_longopts (opt_struct *longopts)
static int parse_opts (char *opts, opt_struct **result)
 PHP_FUNCTION (getopt)
 PHP_FUNCTION (flush)
 PHP_FUNCTION (sleep)
 PHP_FUNCTION (usleep)
 PHP_FUNCTION (get_current_user)
static int add_config_entry_cb (zval *entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 PHP_FUNCTION (get_cfg_var)
 PHP_FUNCTION (set_magic_quotes_runtime)
 PHP_FUNCTION (get_magic_quotes_runtime)
 PHP_FUNCTION (get_magic_quotes_gpc)
 PHP_FUNCTION (error_log)
PHPAPI int _php_error_log (int opt_err, char *message, char *opt, char *headers TSRMLS_DC)
PHPAPI int _php_error_log_ex (int opt_err, char *message, int message_len, char *opt, char *headers TSRMLS_DC)
 PHP_FUNCTION (error_get_last)
 PHP_FUNCTION (call_user_func)
 PHP_FUNCTION (call_user_func_array)
 PHP_FUNCTION (call_user_method)
 PHP_FUNCTION (call_user_method_array)
 PHP_FUNCTION (forward_static_call)
 PHP_FUNCTION (forward_static_call_array)
static int user_shutdown_function_call (php_shutdown_function_entry *shutdown_function_entry TSRMLS_DC)
static void user_tick_function_call (user_tick_function_entry *tick_fe TSRMLS_DC)
static void run_user_tick_functions (int tick_count)
static int user_tick_function_compare (user_tick_function_entry *tick_fe1, user_tick_function_entry *tick_fe2)
void php_call_shutdown_functions (TSRMLS_D)
void php_free_shutdown_functions (TSRMLS_D)
 PHP_FUNCTION (register_shutdown_function)
ZEND_API void php_get_highlight_struct (zend_syntax_highlighter_ini *syntax_highlighter_ini)
 PHP_FUNCTION (highlight_file)
 PHP_FUNCTION (php_strip_whitespace)
 PHP_FUNCTION (highlight_string)
 PHP_FUNCTION (ini_get)
static int php_ini_get_option (zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 PHP_FUNCTION (ini_get_all)
static int php_ini_check_path (char *option_name, int option_len, char *new_option_name, int new_option_len)
 PHP_FUNCTION (ini_set)
 PHP_FUNCTION (ini_restore)
 PHP_FUNCTION (set_include_path)
 PHP_FUNCTION (get_include_path)
 PHP_FUNCTION (restore_include_path)
 PHP_FUNCTION (print_r)
 PHP_FUNCTION (connection_aborted)
 PHP_FUNCTION (connection_status)
 PHP_FUNCTION (ignore_user_abort)
 PHP_FUNCTION (register_tick_function)
 PHP_FUNCTION (unregister_tick_function)
 PHP_FUNCTION (is_uploaded_file)
 PHP_FUNCTION (move_uploaded_file)
static void php_simple_ini_parser_cb (zval *arg1, zval *arg2, zval *arg3, int callback_type, zval *arr TSRMLS_DC)
static void php_ini_parser_cb_with_sections (zval *arg1, zval *arg2, zval *arg3, int callback_type, zval *arr TSRMLS_DC)
 PHP_FUNCTION (parse_ini_file)
 PHP_FUNCTION (parse_ini_string)
static int copy_request_variable (void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 PHP_FUNCTION (import_request_variables)

Variables

PHPAPI php_basic_globals basic_globals
static zend_class_entry * incomplete_class_entry = NULL
zend_module_entry basic_functions_module

Class Documentation

struct _php_shutdown_function_entry

Definition at line 122 of file basic_functions.c.

Class Members
int arg_count
zval ** arguments
struct _user_tick_function_entry

Definition at line 127 of file basic_functions.c.

Class Members
int arg_count
zval ** arguments
int calling

Define Documentation

#define _CHECK_PATH (   var,
  var_len,
  ini 
)    php_ini_check_path(var, var_len, ini, sizeof(ini))
#define INADDR_NONE   ((unsigned long int) -1)

Definition at line 103 of file basic_functions.c.

#define PHP_DOUBLE_INFINITY_HIGH   0x7ff00000

Definition at line 3506 of file basic_functions.c.

#define PHP_DOUBLE_QUIET_NAN_HIGH   0xfff80000

Definition at line 3507 of file basic_functions.c.


Typedef Documentation

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 44 of file basic_functions.c.


Function Documentation

PHPAPI int _php_error_log ( int  opt_err,
char *  message,
char *  opt,
char *headers  TSRMLS_DC 
)

Definition at line 4698 of file basic_functions.c.

{
       return _php_error_log_ex(opt_err, message, (opt_err == 3) ? strlen(message) : 0, opt, headers TSRMLS_CC);
}

Here is the call graph for this function:

PHPAPI int _php_error_log_ex ( int  opt_err,
char *  message,
int  message_len,
char *  opt,
char *headers  TSRMLS_DC 
)

Definition at line 4704 of file basic_functions.c.

{
       php_stream *stream = NULL;

       switch (opt_err)
       {
              case 1:              /*send an email */
                     if (!php_mail(opt, "PHP error_log message", message, headers, NULL TSRMLS_CC)) {
                            return FAILURE;
                     }
                     break;

              case 2:              /*send to an address */
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "TCP/IP option not available!");
                     return FAILURE;
                     break;

              case 3:              /*save to a file */
                     stream = php_stream_open_wrapper(opt, "a", IGNORE_URL_WIN | ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL);
                     if (!stream) {
                            return FAILURE;
                     }
                     php_stream_write(stream, message, message_len);
                     php_stream_close(stream);
                     break;

              case 4: /* send to SAPI */
                     if (sapi_module.log_message) {
                            sapi_module.log_message(message);
                     } else {
                            return FAILURE;
                     }
                     break;

              default:
                     php_log_err(message TSRMLS_CC);
                     break;
       }
       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_config_entry_cb ( zval *entry  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 4572 of file basic_functions.c.

{
       zval *retval = (zval *)va_arg(args, zval*);
       zval *tmp;

       if (Z_TYPE_P(entry) == IS_STRING) {
              if (hash_key->nKeyLength > 0) {
                     add_assoc_stringl_ex(retval, hash_key->arKey, hash_key->nKeyLength, Z_STRVAL_P(entry), Z_STRLEN_P(entry), 1);
              } else {
                     add_index_stringl(retval, hash_key->h, Z_STRVAL_P(entry), Z_STRLEN_P(entry), 1);
              }
       } else if (Z_TYPE_P(entry) == IS_ARRAY) {
              MAKE_STD_ZVAL(tmp);
              array_init(tmp);
              zend_hash_apply_with_arguments(Z_ARRVAL_P(entry) TSRMLS_CC, (apply_func_args_t) add_config_entry_cb, 1, tmp);
              add_assoc_zval_ex(retval, hash_key->arKey, hash_key->nKeyLength, tmp);
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void basic_globals_ctor ( php_basic_globals *basic_globals_p  TSRMLS_DC) [static]

Definition at line 3469 of file basic_functions.c.

{
       BG(rand_is_seeded) = 0;
       BG(mt_rand_is_seeded) = 0;
       BG(umask) = -1;
       BG(next) = NULL;
       BG(left) = -1;
       BG(user_tick_functions) = NULL;
       BG(user_filter_map) = NULL;
       zend_hash_init(&BG(sm_protected_env_vars), 5, NULL, NULL, 1);
       BG(sm_allowed_env_vars) = NULL;

       memset(&BG(url_adapt_state_ex), 0, sizeof(BG(url_adapt_state_ex)));

#if defined(_REENTRANT) && defined(HAVE_MBRLEN) && defined(HAVE_MBSTATE_T)
       memset(&BG(mblen_state), 0, sizeof(BG(mblen_state)));
#endif

       BG(incomplete_class) = incomplete_class_entry;
       BG(page_uid) = -1;
       BG(page_gid) = -1;
}

Here is the caller graph for this function:

static void basic_globals_dtor ( php_basic_globals *basic_globals_p  TSRMLS_DC) [static]

Definition at line 3493 of file basic_functions.c.

{
       zend_hash_destroy(&BG(sm_protected_env_vars));
       if (BG(sm_allowed_env_vars)) {
              free(BG(sm_allowed_env_vars));
       }
       if (BG(url_adapt_state_ex).tags) {
              zend_hash_destroy(BG(url_adapt_state_ex).tags);
              free(BG(url_adapt_state_ex).tags);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int copy_request_variable ( void *pDest  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 6082 of file basic_functions.c.

{
       zval *prefix, new_key;
       int prefix_len;
       zval **var = (zval **) pDest;

       if (num_args != 1) {
              return 0;
       }

       prefix = va_arg(args, zval *);
       prefix_len = Z_STRLEN_P(prefix);

       if (!prefix_len && !hash_key->nKeyLength) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric key detected - possible security hazard");
              return 0;
       }

       if (hash_key->nKeyLength) {
              php_prefix_varname(&new_key, prefix, hash_key->arKey, hash_key->nKeyLength - 1, 0 TSRMLS_CC);
       } else {
              zval num;

              ZVAL_LONG(&num, hash_key->h);
              convert_to_string(&num);
              php_prefix_varname(&new_key, prefix, Z_STRVAL(num), Z_STRLEN(num), 0 TSRMLS_CC);
              zval_dtor(&num);
       }

       if (php_varname_check(Z_STRVAL(new_key), Z_STRLEN(new_key), 0 TSRMLS_CC) == FAILURE) {
              zval_dtor(&new_key);
              return 0;
       }

       zend_delete_global_variable(Z_STRVAL(new_key), Z_STRLEN(new_key) TSRMLS_CC);
       ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), Z_STRVAL(new_key), Z_STRLEN(new_key) + 1, *var, Z_REFCOUNT_PP(var) + 1, 0);

       zval_dtor(&new_key);
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_argv ( char **  argv,
int  argc 
) [static]

Definition at line 4176 of file basic_functions.c.

{
       int i;

       if (argv) {
              for (i = 0; i < argc; i++) {
                     if (argv[i]) {
                            efree(argv[i]);
                     }
              }
              efree(argv);
       }
}

Here is the caller graph for this function:

static void free_longopts ( opt_struct longopts) [static]

Definition at line 4193 of file basic_functions.c.

{
       opt_struct *p;

       if (longopts) {
              for (p = longopts; p && p->opt_char != '-'; p++) {
                     if (p->opt_name != NULL) {
                            efree((char *)(p->opt_name));
                     }
              }
       }
}

Here is the caller graph for this function:

static int parse_opts ( char *  opts,
opt_struct **  result 
) [static]

Definition at line 4209 of file basic_functions.c.

{
       opt_struct * paras = NULL;
       unsigned int i, count = 0;

       for (i = 0; i < strlen(opts); i++) {
              if ((opts[i] >= 48 && opts[i] <= 57) ||
                     (opts[i] >= 65 && opts[i] <= 90) ||
                     (opts[i] >= 97 && opts[i] <= 122)
              ) {
                     count++;
              }
       }

       paras = safe_emalloc(sizeof(opt_struct), count, 0);
       memset(paras, 0, sizeof(opt_struct) * count);
       *result = paras;
       while ( (*opts >= 48 && *opts <= 57) || /* 0 - 9 */
                     (*opts >= 65 && *opts <= 90) || /* A - Z */
                     (*opts >= 97 && *opts <= 122)   /* a - z */
       ) {
              paras->opt_char = *opts;
              paras->need_param = (*(++opts) == ':') ? 1 : 0;
              paras->opt_name = NULL;
              if (paras->need_param == 1) {
                     opts++;
                     if (*opts == ':') {
                            paras->need_param++;
                            opts++;
                     }
              }
              paras++;
       }
       return count;
}

Here is the caller graph for this function:

Definition at line 5081 of file basic_functions.c.

{
       if (BG(user_shutdown_function_names)) {
              zend_try {
                     zend_hash_apply(BG(user_shutdown_function_names), (apply_func_t) user_shutdown_function_call TSRMLS_CC);
              }
              zend_end_try();
              php_free_shutdown_functions(TSRMLS_C);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5093 of file basic_functions.c.

{
       if (BG(user_shutdown_function_names))
              zend_try {
                     zend_hash_destroy(BG(user_shutdown_function_names));
                     FREE_HASHTABLE(BG(user_shutdown_function_names));
                     BG(user_shutdown_function_names) = NULL;
              }
              zend_end_try();
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_FUNCTION ( constant  )

Definition at line 3826 of file basic_functions.c.

{
       char *const_name;
       int const_name_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &const_name, &const_name_len) == FAILURE) {
              return;
       }

       if (!zend_get_constant_ex(const_name, const_name_len, return_value, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't find constant %s", const_name);
              RETURN_NULL();
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( ip2long  )

Definition at line 3915 of file basic_functions.c.

{
       char *addr;
       int addr_len;
#ifdef HAVE_INET_PTON
       struct in_addr ip;
#else
       unsigned long int ip;
#endif

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &addr, &addr_len) == FAILURE) {
              return;
       }

#ifdef HAVE_INET_PTON
       if (addr_len == 0 || inet_pton(AF_INET, addr, &ip) != 1) {
              RETURN_FALSE;
       }
       RETURN_LONG(ntohl(ip.s_addr));
#else
       if (addr_len == 0 || (ip = inet_addr(addr)) == INADDR_NONE) {
              /* The only special case when we should return -1 ourselves,
               * because inet_addr() considers it wrong. We return 0xFFFFFFFF and
               * not -1 or ~0 because of 32/64bit issues. */
              if (addr_len == sizeof("255.255.255.255") - 1 &&
                     !memcmp(addr, "255.255.255.255", sizeof("255.255.255.255") - 1)
              ) {
                     RETURN_LONG(0xFFFFFFFF);
              }
              RETURN_FALSE;
       }
       RETURN_LONG(ntohl(ip));
#endif
}

Here is the call graph for this function:

PHP_FUNCTION ( long2ip  )

Definition at line 3953 of file basic_functions.c.

{
       /* "It's a long but it's not, PHP ints are signed */
       char *ip;
       int ip_len;
       unsigned long n;
       struct in_addr myaddr;
#ifdef HAVE_INET_PTON
       char str[40];
#endif

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ip, &ip_len) == FAILURE) {
              return;
       }

       n = strtoul(ip, NULL, 0);

       myaddr.s_addr = htonl(n);
#ifdef HAVE_INET_PTON
       if (inet_ntop(AF_INET, &myaddr, str, sizeof(str))) {
              RETURN_STRING(str, 1);
       } else {
              RETURN_FALSE;
       }
#else
       RETURN_STRING(inet_ntoa(myaddr), 1);
#endif
}

Here is the call graph for this function:

PHP_FUNCTION ( getenv  )

Definition at line 3989 of file basic_functions.c.

{
       char *ptr, *str;
       int str_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
              RETURN_FALSE;
       }

       /* SAPI method returns an emalloc()'d string */
       ptr = sapi_getenv(str, str_len TSRMLS_CC);
       if (ptr) {
              RETURN_STRING(ptr, 0);
       }
#ifdef PHP_WIN32
       {
              char dummybuf;
              int size;

              SetLastError(0);
              /*If the given bugger is not large enough to hold the data, the return value is 
              the buffer size,  in characters, required to hold the string and its terminating 
              null character. We use this return value to alloc the final buffer. */
              size = GetEnvironmentVariableA(str, &dummybuf, 0);
              if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
                            /* The environment variable doesn't exist. */
                            RETURN_FALSE;
              }

              if (size == 0) {
                            /* env exists, but it is empty */
                            RETURN_EMPTY_STRING();
              }

              ptr = emalloc(size);
              size = GetEnvironmentVariableA(str, ptr, size);
              if (size == 0) {
                            /* has been removed between the two calls */
                            efree(ptr);
                            RETURN_EMPTY_STRING();
              } else {
                     RETURN_STRING(ptr, 0);
              }
       }
#else
       /* system method returns a const */
       ptr = getenv(str);
       if (ptr) {
              RETURN_STRING(ptr, 1);
       }
#endif
       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( getopt  )

Definition at line 4248 of file basic_functions.c.

{
       char *options = NULL, **argv = NULL;
       char opt[2] = { '\0' };
       char *optname;
       int argc = 0, options_len = 0, len, o;
       char *php_optarg = NULL;
       int php_optind = 1;
       zval *val, **args = NULL, *p_longopts = NULL;
       int optname_len = 0;
       opt_struct *opts, *orig_opts;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &options, &options_len, &p_longopts) == FAILURE) {
              RETURN_FALSE;
       }

       /* Get argv from the global symbol table. We calculate argc ourselves
        * in order to be on the safe side, even though it is also available
        * from the symbol table. */
       if (PG(http_globals)[TRACK_VARS_SERVER] &&
              (zend_hash_find(HASH_OF(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), (void **) &args) != FAILURE ||
              zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void **) &args) != FAILURE) && Z_TYPE_PP(args) == IS_ARRAY
       ) {
              int pos = 0;
              zval **entry;

              argc = zend_hash_num_elements(Z_ARRVAL_PP(args));

              /* Attempt to allocate enough memory to hold all of the arguments
               * and a trailing NULL */
              argv = (char **) safe_emalloc(sizeof(char *), (argc + 1), 0);

              /* Reset the array indexes. */
              zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args));

              /* Iterate over the hash to construct the argv array. */
              while (zend_hash_get_current_data(Z_ARRVAL_PP(args), (void **)&entry) == SUCCESS) {
                     zval arg, *arg_ptr = *entry;

                     if (Z_TYPE_PP(entry) != IS_STRING) {
                            arg = **entry;
                            zval_copy_ctor(&arg);
                            convert_to_string(&arg);
                            arg_ptr = &arg;
                     }

                     argv[pos++] = estrdup(Z_STRVAL_P(arg_ptr));

                     if (arg_ptr != *entry) {
                            zval_dtor(&arg);
                     }

                     zend_hash_move_forward(Z_ARRVAL_PP(args));
              }

              /* The C Standard requires argv[argc] to be NULL - this might
               * keep some getopt implementations happy. */
              argv[argc] = NULL;
       } else {
              /* Return false if we can't find argv. */
              RETURN_FALSE;
       }

       len = parse_opts(options, &opts);

       if (p_longopts) {
              int count;
              zval **entry;

              count = zend_hash_num_elements(Z_ARRVAL_P(p_longopts));

              /* the first <len> slots are filled by the one short ops
               * we now extend our array and jump to the new added structs */
              opts = (opt_struct *) erealloc(opts, sizeof(opt_struct) * (len + count + 1));
              orig_opts = opts;
              opts += len;

              memset(opts, 0, count * sizeof(opt_struct));

              /* Reset the array indexes. */
              zend_hash_internal_pointer_reset(Z_ARRVAL_P(p_longopts));

              /* Iterate over the hash to construct the argv array. */
              while (zend_hash_get_current_data(Z_ARRVAL_P(p_longopts), (void **)&entry) == SUCCESS) {
                     zval arg, *arg_ptr = *entry;

                     if (Z_TYPE_PP(entry) != IS_STRING) {
                            arg = **entry;
                            zval_copy_ctor(&arg);
                            convert_to_string(&arg);
                            arg_ptr = &arg;
                     }

                     opts->need_param = 0;
                     opts->opt_name = estrdup(Z_STRVAL_P(arg_ptr));
                     len = strlen(opts->opt_name);
                     if ((len > 0) && (opts->opt_name[len - 1] == ':')) {
                            opts->need_param++;
                            opts->opt_name[len - 1] = '\0';
                            if ((len > 1) && (opts->opt_name[len - 2] == ':')) {
                                   opts->need_param++;
                                   opts->opt_name[len - 2] = '\0';
                            }
                     }
                     opts->opt_char = 0;
                     opts++;

                     if (arg_ptr != *entry) {
                            zval_dtor(&arg);
                     }

                     zend_hash_move_forward(Z_ARRVAL_P(p_longopts));
              }
       } else {
              opts = (opt_struct*) erealloc(opts, sizeof(opt_struct) * (len + 1));
              orig_opts = opts;
              opts += len;
       }

       /* php_getopt want to identify the last param */
       opts->opt_char   = '-';
       opts->need_param = 0;
       opts->opt_name   = NULL;

       /* Initialize the return value as an array. */
       array_init(return_value);

       /* after our pointer arithmetic jump back to the first element */
       opts = orig_opts;

       while ((o = php_getopt(argc, argv, opts, &php_optarg, &php_optind, 0, 1)) != -1) {
              /* Skip unknown arguments. */
              if (o == '?') {
                     continue;
              }

              /* Prepare the option character and the argument string. */
              if (o == 0) {
                     optname = opts[php_optidx].opt_name;
              } else {
                     if (o == 1) {
                            o = '-';
                     }
                     opt[0] = o;
                     optname = opt;
              }

              MAKE_STD_ZVAL(val);
              if (php_optarg != NULL) {
                     /* keep the arg as binary, since the encoding is not known */
                     ZVAL_STRING(val, php_optarg, 1);
              } else {
                     ZVAL_FALSE(val);
              }

              /* Add this option / argument pair to the result hash. */
              optname_len = strlen(optname);
              if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_LONG) {
                     /* numeric string */
                     int optname_int = atoi(optname);
                     if (zend_hash_index_find(HASH_OF(return_value), optname_int, (void **)&args) != FAILURE) {
                            if (Z_TYPE_PP(args) != IS_ARRAY) {
                                   convert_to_array_ex(args);
                            }
                            zend_hash_next_index_insert(HASH_OF(*args), (void *)&val, sizeof(zval *), NULL);
                     } else {
                            zend_hash_index_update(HASH_OF(return_value), optname_int, &val, sizeof(zval *), NULL);
                     }
              } else {
                     /* other strings */
                     if (zend_hash_find(HASH_OF(return_value), optname, strlen(optname)+1, (void **)&args) != FAILURE) {
                            if (Z_TYPE_PP(args) != IS_ARRAY) {
                                   convert_to_array_ex(args);
                            }
                            zend_hash_next_index_insert(HASH_OF(*args), (void *)&val, sizeof(zval *), NULL);
                     } else {
                            zend_hash_add(HASH_OF(return_value), optname, strlen(optname)+1, (void *)&val, sizeof(zval *), NULL);
                     }
              }

              php_optarg = NULL;
       }

       free_longopts(orig_opts);
       efree(orig_opts);
       free_argv(argv, argc);
}

Here is the call graph for this function:

PHP_FUNCTION ( flush  )

Definition at line 4439 of file basic_functions.c.

Here is the call graph for this function:

PHP_FUNCTION ( sleep  )

Definition at line 4447 of file basic_functions.c.

{
       long num;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num) == FAILURE) {
              RETURN_FALSE;
       }
       if (num < 0) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of seconds must be greater than or equal to 0");
              RETURN_FALSE;
       }
#ifdef PHP_SLEEP_NON_VOID
       RETURN_LONG(php_sleep(num));
#else
       php_sleep(num);
#endif

}

Here is the call graph for this function:

Definition at line 4469 of file basic_functions.c.

{
#if HAVE_USLEEP
       long num;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num) == FAILURE) {
              return;
       }
       if (num < 0) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of microseconds must be greater than or equal to 0");
              RETURN_FALSE;
       }
       usleep(num);
#endif
}

Here is the call graph for this function:

PHP_FUNCTION ( get_current_user  )

Definition at line 4560 of file basic_functions.c.

Here is the call graph for this function:

PHP_FUNCTION ( get_cfg_var  )

Definition at line 4595 of file basic_functions.c.

{
       char *varname;
       int varname_len;
       zval *retval;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
              return;
       }

       retval = cfg_get_entry(varname, varname_len + 1);

       if (retval) {
              if (Z_TYPE_P(retval) == IS_ARRAY) {
                     array_init(return_value);
                     zend_hash_apply_with_arguments(Z_ARRVAL_P(retval) TSRMLS_CC, (apply_func_args_t) add_config_entry_cb, 1, return_value);
                     return;
              } else {
                     RETURN_STRING(Z_STRVAL_P(retval), 1);
              }
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( set_magic_quotes_runtime  )

Definition at line 4623 of file basic_functions.c.

{
       zend_bool new_setting;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &new_setting) == FAILURE) {
              return;
       }

       PG(magic_quotes_runtime) = new_setting;
       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( get_magic_quotes_runtime  )

Definition at line 4638 of file basic_functions.c.

{
       RETURN_LONG(PG(magic_quotes_runtime));
}
PHP_FUNCTION ( get_magic_quotes_gpc  )

Definition at line 4646 of file basic_functions.c.

{
       RETURN_LONG(PG(magic_quotes_gpc));
}
PHP_FUNCTION ( error_log  )

Definition at line 4668 of file basic_functions.c.

{
       char *message, *opt = NULL, *headers = NULL;
       int message_len, opt_len = 0, headers_len = 0;
       int opt_err = 0, argc = ZEND_NUM_ARGS();
       long erropt = 0;

       if (zend_parse_parameters(argc TSRMLS_CC, "s|lss", &message, &message_len, &erropt, &opt, &opt_len, &headers, &headers_len) == FAILURE) {
              return;
       }

       if (argc > 1) {
              opt_err = erropt;
       }

       if (opt_err == 3 && opt) {
              if (strlen(opt) != opt_len) {
                     RETURN_FALSE;
              }
       }

       if (_php_error_log_ex(opt_err, message, message_len, opt, headers TSRMLS_CC) == FAILURE) {
              RETURN_FALSE;
       }

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( error_get_last  )

Definition at line 4748 of file basic_functions.c.

{
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
              return;
       }

       if (PG(last_error_message)) {
              array_init(return_value);
              add_assoc_long_ex(return_value, "type", sizeof("type"), PG(last_error_type));
              add_assoc_string_ex(return_value, "message", sizeof("message"), PG(last_error_message), 1);
              add_assoc_string_ex(return_value, "file", sizeof("file"), PG(last_error_file)?PG(last_error_file):"-", 1 );
              add_assoc_long_ex(return_value, "line", sizeof("line"), PG(last_error_lineno));
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( call_user_func  )

Definition at line 4766 of file basic_functions.c.

{
       zval *retval_ptr = NULL;
       zend_fcall_info fci;
       zend_fcall_info_cache fci_cache;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f*", &fci, &fci_cache, &fci.params, &fci.param_count) == FAILURE) {
              return;
       }

       fci.retval_ptr_ptr = &retval_ptr;

       if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
              COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
       }

       if (fci.params) {
              efree(fci.params);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( call_user_func_array  )

Definition at line 4790 of file basic_functions.c.

{
       zval *params, *retval_ptr = NULL;
       zend_fcall_info fci;
       zend_fcall_info_cache fci_cache;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "fa/", &fci, &fci_cache, &params) == FAILURE) {
              return;
       }

       zend_fcall_info_args(&fci, params TSRMLS_CC);
       fci.retval_ptr_ptr = &retval_ptr;

       if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
              COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
       }

       zend_fcall_info_args_clear(&fci, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( call_user_method  )

Definition at line 4813 of file basic_functions.c.

{
       zval ***params = NULL;
       int n_params = 0;
       zval *retval_ptr;
       zval *callback, *object;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/z*", &callback, &object, &params, &n_params) == FAILURE) {
              return;
       }

       if (Z_TYPE_P(object) != IS_OBJECT &&
              Z_TYPE_P(object) != IS_STRING
       ) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Second argument is not an object or class name");
              if (params) {
                     efree(params);
              }
              RETURN_FALSE;
       }

       convert_to_string(callback);

       if (call_user_function_ex(EG(function_table), &object, callback, &retval_ptr, n_params, params, 0, NULL TSRMLS_CC) == SUCCESS) {
              if (retval_ptr) {
                     COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
              }
       } else {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", Z_STRVAL_P(callback));
       }
       if (n_params) {
              efree(params);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( call_user_method_array  )

Definition at line 4851 of file basic_functions.c.

{
       zval *params, ***method_args = NULL, *retval_ptr;
       zval *callback, *object;
       HashTable *params_ar;
       int num_elems, element = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/zA/", &callback, &object, &params) == FAILURE) {
              return;
       }

       if (Z_TYPE_P(object) != IS_OBJECT &&
              Z_TYPE_P(object) != IS_STRING
       ) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Second argument is not an object or class name");
              RETURN_FALSE;
       }

       convert_to_string(callback);

       params_ar = HASH_OF(params);
       num_elems = zend_hash_num_elements(params_ar);
       method_args = (zval ***) safe_emalloc(sizeof(zval **), num_elems, 0);

       for (zend_hash_internal_pointer_reset(params_ar);
              zend_hash_get_current_data(params_ar, (void **) &(method_args[element])) == SUCCESS;
              zend_hash_move_forward(params_ar)
       ) {
              element++;
       }

       if (call_user_function_ex(EG(function_table), &object, callback, &retval_ptr, num_elems, method_args, 0, NULL TSRMLS_CC) == SUCCESS) {
              if (retval_ptr) {
                     COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
              }
       } else {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", Z_STRVAL_P(callback));
       }

       efree(method_args);
}

Here is the call graph for this function:

PHP_FUNCTION ( forward_static_call  )

Definition at line 4896 of file basic_functions.c.

{
       zval *retval_ptr = NULL;
       zend_fcall_info fci;
       zend_fcall_info_cache fci_cache;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f*", &fci, &fci_cache, &fci.params, &fci.param_count) == FAILURE) {
              return;
       }

       if (!EG(active_op_array)->scope) {
              zend_error(E_ERROR, "Cannot call forward_static_call() when no class scope is active");
       }

       fci.retval_ptr_ptr = &retval_ptr;

       if (EG(called_scope) &&
              instanceof_function(EG(called_scope), fci_cache.calling_scope TSRMLS_CC)) {
                     fci_cache.called_scope = EG(called_scope);
       }
       
       if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
              COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
       }

       if (fci.params) {
              efree(fci.params);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( forward_static_call_array  )

Definition at line 4929 of file basic_functions.c.

{
       zval *params, *retval_ptr = NULL;
       zend_fcall_info fci;
       zend_fcall_info_cache fci_cache;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "fa/", &fci, &fci_cache, &params) == FAILURE) {
              return;
       }

       zend_fcall_info_args(&fci, params TSRMLS_CC);
       fci.retval_ptr_ptr = &retval_ptr;

       if (EG(called_scope) &&
              instanceof_function(EG(called_scope), fci_cache.calling_scope TSRMLS_CC)) {
                     fci_cache.called_scope = EG(called_scope);
       }

       if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
              COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
       }

       zend_fcall_info_args_clear(&fci, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( register_shutdown_function  )

Definition at line 5107 of file basic_functions.c.

{
       php_shutdown_function_entry shutdown_function_entry;
       char *function_name = NULL;
       int i;

       shutdown_function_entry.arg_count = ZEND_NUM_ARGS();

       if (shutdown_function_entry.arg_count < 1) {
              WRONG_PARAM_COUNT;
       }

       shutdown_function_entry.arguments = (zval **) safe_emalloc(sizeof(zval *), shutdown_function_entry.arg_count, 0);

       if (zend_get_parameters_array(ht, shutdown_function_entry.arg_count, shutdown_function_entry.arguments) == FAILURE) {
              efree(shutdown_function_entry.arguments);
              RETURN_FALSE;
       }

       /* Prevent entering of anything but valid callback (syntax check only!) */
       if (!zend_is_callable(shutdown_function_entry.arguments[0], 0, &function_name TSRMLS_CC)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid shutdown callback '%s' passed", function_name);
              efree(shutdown_function_entry.arguments);
              RETVAL_FALSE;
       } else {
              if (!BG(user_shutdown_function_names)) {
                     ALLOC_HASHTABLE(BG(user_shutdown_function_names));
                     zend_hash_init(BG(user_shutdown_function_names), 0, NULL, (void (*)(void *)) user_shutdown_function_dtor, 0);
              }

              for (i = 0; i < shutdown_function_entry.arg_count; i++) {
                     Z_ADDREF_P(shutdown_function_entry.arguments[i]);
              }
              zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL);
       }
       if (function_name) {
              efree(function_name);
       }
}

Here is the call graph for this function:

Definition at line 5160 of file basic_functions.c.

{
       char *filename;
       int filename_len;
       zend_syntax_highlighter_ini syntax_highlighter_ini;
       zend_bool i = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &filename_len, &i) == FAILURE) {
              RETURN_FALSE;
       }

       if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_ALLOW_ONLY_FILE))) {
              RETURN_FALSE;
       }

       if (php_check_open_basedir(filename TSRMLS_CC)) {
              RETURN_FALSE;
       }

       if (strlen(filename) != filename_len) {
              RETURN_FALSE;
       }

       if (i) {
              php_start_ob_buffer (NULL, 0, 1 TSRMLS_CC);
       }

       php_get_highlight_struct(&syntax_highlighter_ini);

       if (highlight_file(filename, &syntax_highlighter_ini TSRMLS_CC) == FAILURE) {
              if (i) {
                     int res = php_ob_get_buffer(return_value TSRMLS_CC);

                     /* flush the buffer only if there is something to flush */
                     if (res == SUCCESS && Z_STRLEN_P(return_value) > 0) {
                            php_end_ob_buffer (1, 0 TSRMLS_CC);
                            zval_dtor(return_value);
                     } else {
                            php_end_ob_buffer (0, 0 TSRMLS_CC);
                            if (res == SUCCESS) {
                                   zval_dtor(return_value);
                            }
                     }
              }
              RETURN_FALSE;
       }

       if (i) {
              php_ob_get_buffer (return_value TSRMLS_CC);
              php_end_ob_buffer (0, 0 TSRMLS_CC);
       } else {
              RETURN_TRUE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( php_strip_whitespace  )

Definition at line 5218 of file basic_functions.c.

{
       char *filename;
       int filename_len;
       zend_lex_state original_lex_state;
       zend_file_handle file_handle = {0};

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
              RETURN_FALSE;
       }

       if (strlen(filename) != filename_len) {
              RETURN_FALSE;
       }

       file_handle.type = ZEND_HANDLE_FILENAME;
       file_handle.filename = filename;
       file_handle.free_filename = 0;
       file_handle.opened_path = NULL;
       zend_save_lexical_state(&original_lex_state TSRMLS_CC);
       if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
              zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
              RETURN_EMPTY_STRING();
       }

       php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC);

       zend_strip(TSRMLS_C);

       zend_destroy_file_handle(&file_handle TSRMLS_CC);
       zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

       php_ob_get_buffer(return_value TSRMLS_CC);
       php_end_ob_buffer(0, 0 TSRMLS_CC);
}

Here is the call graph for this function:

Definition at line 5257 of file basic_functions.c.

{
       zval **expr;
       zend_syntax_highlighter_ini syntax_highlighter_ini;
       char *hicompiled_string_description;
       zend_bool i = 0;
       int old_error_reporting = EG(error_reporting);

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|b", &expr, &i) == FAILURE) {
              RETURN_FALSE;
       }
       convert_to_string_ex(expr);

       if (i) {
              php_start_ob_buffer (NULL, 0, 1 TSRMLS_CC);
       }

       EG(error_reporting) = E_ERROR;

       php_get_highlight_struct(&syntax_highlighter_ini);

       hicompiled_string_description = zend_make_compiled_string_description("highlighted code" TSRMLS_CC);

       if (highlight_string(*expr, &syntax_highlighter_ini, hicompiled_string_description TSRMLS_CC) == FAILURE) {
              efree(hicompiled_string_description);
              EG(error_reporting) = old_error_reporting;
              if (i) {
                     php_end_ob_buffer (1, 0 TSRMLS_CC);
              }
              RETURN_FALSE;
       }
       efree(hicompiled_string_description);

       EG(error_reporting) = old_error_reporting;

       if (i) {
              php_ob_get_buffer (return_value TSRMLS_CC);
              php_end_ob_buffer (0, 0 TSRMLS_CC);
       } else {
              RETURN_TRUE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( ini_get  )

Definition at line 5303 of file basic_functions.c.

{
       char *varname, *str;
       int varname_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
              return;
       }

       str = zend_ini_string(varname, varname_len + 1, 0);

       if (!str) {
              RETURN_FALSE;
       }

       RETURN_STRING(str, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( ini_get_all  )

Definition at line 5371 of file basic_functions.c.

{
       char *extname = NULL;
       int extname_len = 0, extnumber = 0;
       zend_module_entry *module;
       zend_bool details = 1;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!b", &extname, &extname_len, &details) == FAILURE) {
              return;
       }

       zend_ini_sort_entries(TSRMLS_C);

       if (extname) {
              if (zend_hash_find(&module_registry, extname, extname_len+1, (void **) &module) == FAILURE) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find extension '%s'", extname);
                     RETURN_FALSE;
              }
              extnumber = module->module_number;
       }

       array_init(return_value);
       zend_hash_apply_with_arguments(EG(ini_directives) TSRMLS_CC, (apply_func_args_t) php_ini_get_option, 2, return_value, extnumber, details);
}

Here is the call graph for this function:

PHP_FUNCTION ( ini_set  )

Definition at line 5409 of file basic_functions.c.

{
       char *varname, *new_value;
       int varname_len, new_value_len;
       char *old_value;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &varname, &varname_len, &new_value, &new_value_len) == FAILURE) {
              return;
       }

       old_value = zend_ini_string(varname, varname_len + 1, 0);

       /* copy to return here, because alter might free it! */
       if (old_value) {
              RETVAL_STRING(old_value, 1);
       } else {
              RETVAL_FALSE;
       }

#define _CHECK_PATH(var, var_len, ini) php_ini_check_path(var, var_len, ini, sizeof(ini))
       /* safe_mode & basedir check */
       if (PG(safe_mode) || PG(open_basedir)) {
              if (_CHECK_PATH(varname, varname_len, "error_log") ||
                     _CHECK_PATH(varname, varname_len, "java.class.path") ||
                     _CHECK_PATH(varname, varname_len, "java.home") ||
                     _CHECK_PATH(varname, varname_len, "mail.log") ||
                     _CHECK_PATH(varname, varname_len, "java.library.path") ||
                     _CHECK_PATH(varname, varname_len, "vpopmail.directory")) {
                     if (PG(safe_mode) && (!php_checkuid(new_value, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                            zval_dtor(return_value);
                            RETURN_FALSE;
                     }
                     if (php_check_open_basedir(new_value TSRMLS_CC)) {
                            zval_dtor(return_value);
                            RETURN_FALSE;
                     }
              }
       }

       /* checks that ensure the user does not overwrite certain ini settings when safe_mode is enabled */
       if (PG(safe_mode)) {
              if (!strncmp("max_execution_time", varname, sizeof("max_execution_time")) ||
                     !strncmp("memory_limit", varname, sizeof("memory_limit")) ||
                     !strncmp("child_terminate", varname, sizeof("child_terminate"))
              ) {
                     zval_dtor(return_value);
                     RETURN_FALSE;
              }
       }

       if (zend_alter_ini_entry_ex(varname, varname_len + 1, new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
              zval_dtor(return_value);
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( ini_restore  )

Definition at line 5468 of file basic_functions.c.

{
       char *varname;
       int varname_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
              return;
       }

       zend_restore_ini_entry(varname, varname_len+1, PHP_INI_STAGE_RUNTIME);
}

Here is the call graph for this function:

PHP_FUNCTION ( set_include_path  )

Definition at line 5483 of file basic_functions.c.

{
       char *new_value;
       int new_value_len;
       char *old_value;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &new_value, &new_value_len) == FAILURE) {
              return;
       }

       /* No nulls allowed in paths */
       if (strlen(new_value) != new_value_len) {
              RETURN_FALSE;
       }

       old_value = zend_ini_string("include_path", sizeof("include_path"), 0);
       /* copy to return here, because alter might free it! */
       if (old_value) {
              RETVAL_STRING(old_value, 1);
       } else {
              RETVAL_FALSE;
       }

       if (zend_alter_ini_entry_ex("include_path", sizeof("include_path"), new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
              zval_dtor(return_value);
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( get_include_path  )

Definition at line 5515 of file basic_functions.c.

{
       char *str;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
              return;
       }

       str = zend_ini_string("include_path", sizeof("include_path"), 0);

       if (str == NULL) {
              RETURN_FALSE;
       }

       RETURN_STRING(str, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( restore_include_path  )

Definition at line 5535 of file basic_functions.c.

{
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
              return;
       }
       zend_restore_ini_entry("include_path", sizeof("include_path"), PHP_INI_STAGE_RUNTIME);
}

Here is the call graph for this function:

PHP_FUNCTION ( print_r  )

Definition at line 5546 of file basic_functions.c.

{
       zval *var;
       zend_bool do_return = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &var, &do_return) == FAILURE) {
              RETURN_FALSE;
       }

       if (do_return) {
              php_start_ob_buffer (NULL, 0, 1 TSRMLS_CC);
       }

       zend_print_zval_r(var, 0 TSRMLS_CC);

       if (do_return) {
              php_ob_get_buffer (return_value TSRMLS_CC);
              php_end_ob_buffer (0, 0 TSRMLS_CC);
       } else {
              RETURN_TRUE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( connection_aborted  )

Definition at line 5572 of file basic_functions.c.

{
       RETURN_LONG(PG(connection_status) & PHP_CONNECTION_ABORTED);
}
PHP_FUNCTION ( connection_status  )

Definition at line 5580 of file basic_functions.c.

{
       RETURN_LONG(PG(connection_status));
}
PHP_FUNCTION ( ignore_user_abort  )

Definition at line 5588 of file basic_functions.c.

{
       char *arg = NULL;
       int arg_len = 0;
       int old_setting;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &arg, &arg_len) == FAILURE) {
              return;
       }

       old_setting = PG(ignore_user_abort);

       if (arg) {
              zend_alter_ini_entry_ex("ignore_user_abort", sizeof("ignore_user_abort"), arg, arg_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
       }

       RETURN_LONG(old_setting);
}

Here is the call graph for this function:

PHP_FUNCTION ( register_tick_function  )

Definition at line 5715 of file basic_functions.c.

{
       user_tick_function_entry tick_fe;
       int i;
       char *function_name = NULL;

       tick_fe.calling = 0;
       tick_fe.arg_count = ZEND_NUM_ARGS();

       if (tick_fe.arg_count < 1) {
              WRONG_PARAM_COUNT;
       }

       tick_fe.arguments = (zval **) safe_emalloc(sizeof(zval *), tick_fe.arg_count, 0);

       if (zend_get_parameters_array(ht, tick_fe.arg_count, tick_fe.arguments) == FAILURE) {
              efree(tick_fe.arguments);
              RETURN_FALSE;
       }

       if (!zend_is_callable(tick_fe.arguments[0], 0, &function_name TSRMLS_CC)) {
              efree(tick_fe.arguments);
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid tick callback '%s' passed", function_name);
              efree(function_name);
              RETURN_FALSE;
       } else if (function_name) {
              efree(function_name);
       }

       if (Z_TYPE_P(tick_fe.arguments[0]) != IS_ARRAY && Z_TYPE_P(tick_fe.arguments[0]) != IS_OBJECT) {
              convert_to_string_ex(&tick_fe.arguments[0]);
       }

       if (!BG(user_tick_functions)) {
              BG(user_tick_functions) = (zend_llist *) emalloc(sizeof(zend_llist));
              zend_llist_init(BG(user_tick_functions),
                                          sizeof(user_tick_function_entry),
                                          (llist_dtor_func_t) user_tick_function_dtor, 0);
              php_add_tick_function(run_user_tick_functions);
       }

       for (i = 0; i < tick_fe.arg_count; i++) {
              Z_ADDREF_P(tick_fe.arguments[i]);
       }

       zend_llist_add_element(BG(user_tick_functions), &tick_fe);

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( unregister_tick_function  )

Definition at line 5768 of file basic_functions.c.

{
       zval *function;
       user_tick_function_entry tick_fe;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &function) == FAILURE) {
              return;
       }

       if (!BG(user_tick_functions)) {
              return;
       }

       if (Z_TYPE_P(function) != IS_ARRAY) {
              convert_to_string(function);
       }

       tick_fe.arguments = (zval **) emalloc(sizeof(zval *));
       tick_fe.arguments[0] = function;
       tick_fe.arg_count = 1;
       zend_llist_del_element(BG(user_tick_functions), &tick_fe, (int (*)(void *, void *)) user_tick_function_compare);
       efree(tick_fe.arguments);
}

Here is the call graph for this function:

PHP_FUNCTION ( is_uploaded_file  )

Definition at line 5795 of file basic_functions.c.

{
       char *path;
       int path_len;

       if (!SG(rfc1867_uploaded_files)) {
              RETURN_FALSE;
       }

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
              return;
       }

       if (strlen(path) != path_len) {
              RETURN_FALSE;
       }

       if (zend_hash_exists(SG(rfc1867_uploaded_files), path, path_len + 1)) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( move_uploaded_file  )

Definition at line 5822 of file basic_functions.c.

{
       char *path, *new_path;
       int path_len, new_path_len;
       zend_bool successful = 0;

#ifndef PHP_WIN32
       int oldmask; int ret;
#endif

       if (!SG(rfc1867_uploaded_files)) {
              RETURN_FALSE;
       }

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &path, &path_len, &new_path, &new_path_len) == FAILURE) {
              return;
       }

       if (!zend_hash_exists(SG(rfc1867_uploaded_files), path, path_len + 1)) {
              RETURN_FALSE;
       }

       if (PG(safe_mode) && (!php_checkuid(new_path, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
              RETURN_FALSE;
       }

       if (php_check_open_basedir(new_path TSRMLS_CC)) {
              RETURN_FALSE;
       }

       if (strlen(path) != path_len) {
              RETURN_FALSE;
       }

       if (strlen(new_path) != new_path_len) {
              RETURN_FALSE;
       }

       if (VCWD_RENAME(path, new_path) == 0) {
              successful = 1;
#ifndef PHP_WIN32
              oldmask = umask(077);
              umask(oldmask);

              ret = VCWD_CHMOD(new_path, 0666 & ~oldmask);

              if (ret == -1) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
              }
#endif
       } else if (php_copy_file_ex(path, new_path, STREAM_DISABLE_OPEN_BASEDIR TSRMLS_CC) == SUCCESS) {
              VCWD_UNLINK(path);
              successful = 1;
       }

       if (successful) {
              zend_hash_del(SG(rfc1867_uploaded_files), path, path_len + 1);
       } else {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to move '%s' to '%s'", path, new_path);
       }

       RETURN_BOOL(successful);
}

Here is the call graph for this function:

PHP_FUNCTION ( parse_ini_file  )

Definition at line 5984 of file basic_functions.c.

{
       char *filename = NULL;
       int filename_len = 0;
       zend_bool process_sections = 0;
       long scanner_mode = ZEND_INI_SCANNER_NORMAL;
       zend_file_handle fh;
       zend_ini_parser_cb_t ini_parser_cb;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|bl", &filename, &filename_len, &process_sections, &scanner_mode) == FAILURE) {
              RETURN_FALSE;
       }

       if (filename_len == 0) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filename cannot be empty!");
              RETURN_FALSE;
       }

       if (strlen(filename) != filename_len) {
              RETURN_FALSE;
       }

       /* Set callback function */
       if (process_sections) {
              BG(active_ini_file_section) = NULL;
              ini_parser_cb = (zend_ini_parser_cb_t) php_ini_parser_cb_with_sections;
       } else {
              ini_parser_cb = (zend_ini_parser_cb_t) php_simple_ini_parser_cb;
       }

       /* Setup filehandle */
       memset(&fh, 0, sizeof(fh));
       fh.filename = filename;
       fh.type = ZEND_HANDLE_FILENAME;

       array_init(return_value);
       if (zend_parse_ini_file(&fh, 0, scanner_mode, ini_parser_cb, return_value TSRMLS_CC) == FAILURE) {
              zend_hash_destroy(Z_ARRVAL_P(return_value));
              efree(Z_ARRVAL_P(return_value));
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( parse_ini_string  )

Definition at line 6030 of file basic_functions.c.

{
       char *string = NULL, *str = NULL;
       int str_len = 0;
       zend_bool process_sections = 0;
       long scanner_mode = ZEND_INI_SCANNER_NORMAL;
       zend_ini_parser_cb_t ini_parser_cb;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|bl", &str, &str_len, &process_sections, &scanner_mode) == FAILURE) {
              RETURN_FALSE;
       }

       if (INT_MAX - str_len < ZEND_MMAP_AHEAD) {
              RETVAL_FALSE;
       }

       /* Set callback function */
       if (process_sections) {
              BG(active_ini_file_section) = NULL;
              ini_parser_cb = (zend_ini_parser_cb_t) php_ini_parser_cb_with_sections;
       } else {
              ini_parser_cb = (zend_ini_parser_cb_t) php_simple_ini_parser_cb;
       }

       /* Setup string */
       string = (char *) emalloc(str_len + ZEND_MMAP_AHEAD);
       memcpy(string, str, str_len);
       memset(string + str_len, 0, ZEND_MMAP_AHEAD);

       array_init(return_value);
       if (zend_parse_ini_string(string, 0, scanner_mode, ini_parser_cb, return_value TSRMLS_CC) == FAILURE) {
              zend_hash_destroy(Z_ARRVAL_P(return_value));
              efree(Z_ARRVAL_P(return_value));
              RETVAL_FALSE;
       }
       efree(string);
}

Here is the call graph for this function:

PHP_FUNCTION ( import_request_variables  )

Definition at line 6126 of file basic_functions.c.

{
       char *types;
       int types_len;
       zval *prefix = NULL;
       char *p;
       zend_bool ok = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &types, &types_len, &prefix) == FAILURE) {
              return;
       }

       if (ZEND_NUM_ARGS() > 1) {
              convert_to_string(prefix);

              if (Z_STRLEN_P(prefix) == 0) {
                     php_error_docref(NULL TSRMLS_CC, E_NOTICE, "No prefix specified - possible security hazard");
              }
       } else {
              MAKE_STD_ZVAL(prefix);
              ZVAL_EMPTY_STRING(prefix);
       }

       for (p = types; p && *p; p++) {
              switch (*p) {

                     case 'g':
                     case 'G':
                            zend_hash_apply_with_arguments(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC, (apply_func_args_t) copy_request_variable, 1, prefix);
                            ok = 1;
                            break;

                     case 'p':
                     case 'P':
                            zend_hash_apply_with_arguments(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_POST]) TSRMLS_CC, (apply_func_args_t) copy_request_variable, 1, prefix);
                            zend_hash_apply_with_arguments(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_FILES]) TSRMLS_CC, (apply_func_args_t) copy_request_variable, 1, prefix);
                            ok = 1;
                            break;

                     case 'c':
                     case 'C':
                            zend_hash_apply_with_arguments(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) TSRMLS_CC, (apply_func_args_t) copy_request_variable, 1, prefix);
                            ok = 1;
                            break;
              }
       }

       if (ZEND_NUM_ARGS() < 2) {
              zval_ptr_dtor(&prefix);
       }
       RETURN_BOOL(ok);
}

Here is the call graph for this function:

Definition at line 5148 of file basic_functions.c.

{
       syntax_highlighter_ini->highlight_comment = INI_STR("highlight.comment");
       syntax_highlighter_ini->highlight_default = INI_STR("highlight.default");
       syntax_highlighter_ini->highlight_html    = INI_STR("highlight.html");
       syntax_highlighter_ini->highlight_keyword = INI_STR("highlight.keyword");
       syntax_highlighter_ini->highlight_string  = INI_STR("highlight.string");
}

Here is the caller graph for this function:

PHPAPI double php_get_inf ( void  )

Definition at line 3526 of file basic_functions.c.

{
#if HAVE_HUGE_VAL_INF
       return HUGE_VAL;
#elif defined(__i386__) || defined(_X86_) || defined(ALPHA) || defined(_ALPHA) || defined(__alpha)
       double val = 0.0;
       ((php_uint32*)&val)[1] = PHP_DOUBLE_INFINITY_HIGH;
       ((php_uint32*)&val)[0] = 0;
       return val;
#elif HAVE_ATOF_ACCEPTS_INF
       return atof("INF");
#else
       return 1.0/0.0;
#endif
}

Here is the caller graph for this function:

PHPAPI double php_get_nan ( void  )

Definition at line 3509 of file basic_functions.c.

{
#if HAVE_HUGE_VAL_NAN
       return HUGE_VAL + -HUGE_VAL;
#elif defined(__i386__) || defined(_X86_) || defined(ALPHA) || defined(_ALPHA) || defined(__alpha)
       double val = 0.0;
       ((php_uint32*)&val)[1] = PHP_DOUBLE_QUIET_NAN_HIGH;
       ((php_uint32*)&val)[0] = 0;
       return val;
#elif HAVE_ATOF_ACCEPTS_NAN
       return atof("NAN");
#else
       return 0.0/0.0;
#endif
}

Here is the caller graph for this function:

Definition at line 3396 of file basic_functions.c.

                                               { /* {{{ */
       ZEND_MOD_OPTIONAL("session")
       ZEND_MOD_END
};
static int php_ini_check_path ( char *  option_name,
int  option_len,
char *  new_option_name,
int  new_option_len 
) [static]

Definition at line 5397 of file basic_functions.c.

{
       if (option_len != (new_option_len - 1)) {
              return 0;
       }

       return !strncmp(option_name, new_option_name, option_len);
}
static int php_ini_get_option ( zend_ini_entry *ini_entry  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 5322 of file basic_functions.c.

{
       zval *ini_array = va_arg(args, zval *);
       int module_number = va_arg(args, int);
       int details = va_arg(args, int);
       zval *option;

       if (module_number != 0 && ini_entry->module_number != module_number) {
              return 0;
       }

       if (hash_key->nKeyLength == 0 ||
              hash_key->arKey[0] != 0
       ) {
              if (details) {
                     MAKE_STD_ZVAL(option);
                     array_init(option);

                     if (ini_entry->orig_value) {
                            add_assoc_stringl(option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length, 1);
                     } else if (ini_entry->value) {
                            add_assoc_stringl(option, "global_value", ini_entry->value, ini_entry->value_length, 1);
                     } else {
                            add_assoc_null(option, "global_value");
                     }

                     if (ini_entry->value) {
                            add_assoc_stringl(option, "local_value", ini_entry->value, ini_entry->value_length, 1);
                     } else {
                            add_assoc_null(option, "local_value");
                     }

                     add_assoc_long(option, "access", ini_entry->modifiable);

                     add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, option);
              } else {
                     if (ini_entry->value) {
                            add_assoc_stringl(ini_array, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
                     } else {
                            add_assoc_null(ini_array, ini_entry->name);
                     }
              }
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PHP_INI_MH ( OnUpdateSafeModeProtectedEnvVars  ) [static]

Definition at line 3367 of file basic_functions.c.

{
       char *protected_vars, *protected_var;
       char *token_buf;
       int dummy = 1;

       protected_vars = estrndup(new_value, new_value_length);
       zend_hash_clean(&BG(sm_protected_env_vars));

       protected_var = php_strtok_r(protected_vars, ", ", &token_buf);
       while (protected_var) {
              zend_hash_update(&BG(sm_protected_env_vars), protected_var, strlen(protected_var), &dummy, sizeof(int), NULL);
              protected_var = php_strtok_r(NULL, ", ", &token_buf);
       }
       efree(protected_vars);
       return SUCCESS;
}

Here is the call graph for this function:

static PHP_INI_MH ( OnUpdateSafeModeAllowedEnvVars  ) [static]

Definition at line 3386 of file basic_functions.c.

{
       if (BG(sm_allowed_env_vars)) {
              free(BG(sm_allowed_env_vars));
       }
       BG(sm_allowed_env_vars) = zend_strndup(new_value, new_value_length);
       return SUCCESS;
}

Here is the call graph for this function:

static void php_ini_parser_cb_with_sections ( zval *  arg1,
zval *  arg2,
zval *  arg3,
int  callback_type,
zval *arr  TSRMLS_DC 
) [static]

Definition at line 5962 of file basic_functions.c.

{
       if (callback_type == ZEND_INI_PARSER_SECTION) {
              MAKE_STD_ZVAL(BG(active_ini_file_section));
              array_init(BG(active_ini_file_section));
              zend_symtable_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &BG(active_ini_file_section), sizeof(zval *), NULL);
       } else if (arg2) {
              zval *active_arr;

              if (BG(active_ini_file_section)) {
                     active_arr = BG(active_ini_file_section);
              } else {
                     active_arr = arr;
              }

              php_simple_ini_parser_cb(arg1, arg2, arg3, callback_type, active_arr TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_MINFO_FUNCTION ( basic  )
PHP_MINIT_FUNCTION ( basic  )

Definition at line 3543 of file basic_functions.c.

{
#ifdef ZTS
       ts_allocate_id(&basic_globals_id, sizeof(php_basic_globals), (ts_allocate_ctor) basic_globals_ctor, (ts_allocate_dtor) basic_globals_dtor);
#ifdef PHP_WIN32
       ts_allocate_id(&php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor)php_win32_core_globals_ctor, (ts_allocate_dtor)php_win32_core_globals_dtor );
#endif
#else
       basic_globals_ctor(&basic_globals TSRMLS_CC);
#ifdef PHP_WIN32
       php_win32_core_globals_ctor(&the_php_win32_core_globals TSRMLS_CC);
#endif
#endif

       BG(incomplete_class) = incomplete_class_entry = php_create_incomplete_class(TSRMLS_C);

       REGISTER_LONG_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("CONNECTION_NORMAL",  PHP_CONNECTION_NORMAL,  CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("CONNECTION_TIMEOUT", PHP_CONNECTION_TIMEOUT, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("INI_USER",   ZEND_INI_USER,   CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("INI_PERDIR", ZEND_INI_PERDIR, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("INI_SYSTEM", ZEND_INI_SYSTEM, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("INI_ALL",    ZEND_INI_ALL,    CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("INI_SCANNER_NORMAL", ZEND_INI_SCANNER_NORMAL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("INI_SCANNER_RAW",    ZEND_INI_SCANNER_RAW,    CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("PHP_URL_SCHEME", PHP_URL_SCHEME, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_HOST", PHP_URL_HOST, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_PORT", PHP_URL_PORT, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_USER", PHP_URL_USER, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_PASS", PHP_URL_PASS, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_PATH", PHP_URL_PATH, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_QUERY", PHP_URL_QUERY, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_URL_FRAGMENT", PHP_URL_FRAGMENT, CONST_CS | CONST_PERSISTENT);

#define REGISTER_MATH_CONSTANT(x)  REGISTER_DOUBLE_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT)
       REGISTER_MATH_CONSTANT(M_E);
       REGISTER_MATH_CONSTANT(M_LOG2E);
       REGISTER_MATH_CONSTANT(M_LOG10E);
       REGISTER_MATH_CONSTANT(M_LN2);
       REGISTER_MATH_CONSTANT(M_LN10);
       REGISTER_MATH_CONSTANT(M_PI);
       REGISTER_MATH_CONSTANT(M_PI_2);
       REGISTER_MATH_CONSTANT(M_PI_4);
       REGISTER_MATH_CONSTANT(M_1_PI);
       REGISTER_MATH_CONSTANT(M_2_PI);
       REGISTER_MATH_CONSTANT(M_SQRTPI);
       REGISTER_MATH_CONSTANT(M_2_SQRTPI);
       REGISTER_MATH_CONSTANT(M_LNPI);
       REGISTER_MATH_CONSTANT(M_EULER);
       REGISTER_MATH_CONSTANT(M_SQRT2);
       REGISTER_MATH_CONSTANT(M_SQRT1_2);
       REGISTER_MATH_CONSTANT(M_SQRT3);
       REGISTER_DOUBLE_CONSTANT("INF", php_get_inf(), CONST_CS | CONST_PERSISTENT);
       REGISTER_DOUBLE_CONSTANT("NAN", php_get_nan(), CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_UP", PHP_ROUND_HALF_UP, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_DOWN", PHP_ROUND_HALF_DOWN, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_EVEN", PHP_ROUND_HALF_EVEN, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_ODD", PHP_ROUND_HALF_ODD, CONST_CS | CONST_PERSISTENT);

#if ENABLE_TEST_CLASS
       test_class_startup();
#endif

       REGISTER_INI_ENTRIES();

       register_phpinfo_constants(INIT_FUNC_ARGS_PASSTHRU);
       register_html_constants(INIT_FUNC_ARGS_PASSTHRU);
       register_string_constants(INIT_FUNC_ARGS_PASSTHRU);

       PHP_MINIT(file)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(pack)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(browscap)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(standard_filters)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(user_filters)(INIT_FUNC_ARGS_PASSTHRU);

#if defined(HAVE_LOCALECONV) && defined(ZTS)
       PHP_MINIT(localeconv)(INIT_FUNC_ARGS_PASSTHRU);
#endif

#if defined(HAVE_NL_LANGINFO)
       PHP_MINIT(nl_langinfo)(INIT_FUNC_ARGS_PASSTHRU);
#endif

#if HAVE_CRYPT
       PHP_MINIT(crypt)(INIT_FUNC_ARGS_PASSTHRU);
#endif

       PHP_MINIT(lcg)(INIT_FUNC_ARGS_PASSTHRU);

       PHP_MINIT(dir)(INIT_FUNC_ARGS_PASSTHRU);
#ifdef HAVE_SYSLOG_H
       PHP_MINIT(syslog)(INIT_FUNC_ARGS_PASSTHRU);
#endif
       PHP_MINIT(array)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(assert)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(url_scanner_ex)(INIT_FUNC_ARGS_PASSTHRU);
#ifdef PHP_CAN_SUPPORT_PROC_OPEN
       PHP_MINIT(proc_open)(INIT_FUNC_ARGS_PASSTHRU);
#endif

       PHP_MINIT(user_streams)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_MINIT(imagetypes)(INIT_FUNC_ARGS_PASSTHRU);

       php_register_url_stream_wrapper("php", &php_stream_php_wrapper TSRMLS_CC);
       php_register_url_stream_wrapper("file", &php_plain_files_wrapper TSRMLS_CC);
#ifdef HAVE_GLOB
       php_register_url_stream_wrapper("glob", &php_glob_stream_wrapper TSRMLS_CC);
#endif
       php_register_url_stream_wrapper("data", &php_stream_rfc2397_wrapper TSRMLS_CC);
#ifndef PHP_CURL_URL_WRAPPERS
       php_register_url_stream_wrapper("http", &php_stream_http_wrapper TSRMLS_CC);
       php_register_url_stream_wrapper("ftp", &php_stream_ftp_wrapper TSRMLS_CC);
#endif

#if defined(PHP_WIN32) || (HAVE_DNS_SEARCH_FUNC && !(defined(__BEOS__) || defined(NETWARE)))
# if defined(PHP_WIN32) || HAVE_FULL_DNS_FUNCS
       PHP_MINIT(dns)(INIT_FUNC_ARGS_PASSTHRU);
# endif
#endif

       return SUCCESS;
}

Here is the call graph for this function:

Definition at line 3671 of file basic_functions.c.

{
#ifdef HAVE_SYSLOG_H
       PHP_MSHUTDOWN(syslog)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#endif
#ifdef ZTS
       ts_free_id(basic_globals_id);
#ifdef PHP_WIN32
       ts_free_id(php_win32_core_globals_id);
#endif
#else
       basic_globals_dtor(&basic_globals TSRMLS_CC);
#ifdef PHP_WIN32
       php_win32_core_globals_dtor(&the_php_win32_core_globals TSRMLS_CC);
#endif
#endif

       php_unregister_url_stream_wrapper("php" TSRMLS_CC);
#ifndef PHP_CURL_URL_WRAPPERS
       php_unregister_url_stream_wrapper("http" TSRMLS_CC);
       php_unregister_url_stream_wrapper("ftp" TSRMLS_CC);
#endif

       UNREGISTER_INI_ENTRIES();

       PHP_MSHUTDOWN(browscap)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_MSHUTDOWN(array)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_MSHUTDOWN(assert)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_MSHUTDOWN(url_scanner_ex)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_MSHUTDOWN(file)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_MSHUTDOWN(standard_filters)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#if defined(HAVE_LOCALECONV) && defined(ZTS)
       PHP_MSHUTDOWN(localeconv)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#endif
#if HAVE_CRYPT
       PHP_MSHUTDOWN(crypt)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#endif

       return SUCCESS;
}

Here is the call graph for this function:

PHP_RINIT_FUNCTION ( basic  )

Definition at line 3713 of file basic_functions.c.

{
       memset(BG(strtok_table), 0, 256);
       BG(strtok_string) = NULL;
       BG(strtok_zval) = NULL;
       BG(strtok_last) = NULL;
       BG(locale_string) = NULL;
       BG(array_walk_fci) = empty_fcall_info;
       BG(array_walk_fci_cache) = empty_fcall_info_cache;
       BG(user_compare_fci) = empty_fcall_info;
       BG(user_compare_fci_cache) = empty_fcall_info_cache;
       BG(page_uid) = -1;
       BG(page_gid) = -1;
       BG(page_inode) = -1;
       BG(page_mtime) = -1;
#ifdef HAVE_PUTENV
       if (zend_hash_init(&BG(putenv_ht), 1, NULL, (void (*)(void *)) php_putenv_destructor, 0) == FAILURE) {
              return FAILURE;
       }
#endif
       BG(user_shutdown_function_names) = NULL;

       PHP_RINIT(filestat)(INIT_FUNC_ARGS_PASSTHRU);
#ifdef HAVE_SYSLOG_H
       PHP_RINIT(syslog)(INIT_FUNC_ARGS_PASSTHRU);
#endif
       PHP_RINIT(dir)(INIT_FUNC_ARGS_PASSTHRU);
       PHP_RINIT(url_scanner_ex)(INIT_FUNC_ARGS_PASSTHRU);

       /* Reset magic_quotes_runtime */
       PG(magic_quotes_runtime) = INI_BOOL("magic_quotes_runtime");

       /* Setup default context */
       FG(default_context) = NULL;

       /* Default to global wrappers only */
       FG(stream_wrappers) = NULL;

       /* Default to global filters only */
       FG(stream_filters) = NULL;

       return SUCCESS;
}

Here is the call graph for this function:

Definition at line 3758 of file basic_functions.c.

{
       if (BG(strtok_zval)) {
              zval_ptr_dtor(&BG(strtok_zval));
       }
       BG(strtok_string) = NULL;
       BG(strtok_zval) = NULL;
#ifdef HAVE_PUTENV
       zend_hash_destroy(&BG(putenv_ht));
#endif

       if (BG(umask) != -1) {
              umask(BG(umask));
       }

       /* Check if locale was changed and change it back
        * to the value in startup environment */
       if (BG(locale_string) != NULL) {
              setlocale(LC_ALL, "C");
              setlocale(LC_CTYPE, "");
              zend_update_current_locale();
       }
       STR_FREE(BG(locale_string));
       BG(locale_string) = NULL;

       /* FG(stream_wrappers) and FG(stream_filters) are destroyed
        * during php_request_shutdown() */

       PHP_RSHUTDOWN(filestat)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#ifdef HAVE_SYSLOG_H
#ifdef PHP_WIN32
       PHP_RSHUTDOWN(syslog)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#endif
#endif
       PHP_RSHUTDOWN(assert)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_RSHUTDOWN(url_scanner_ex)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_RSHUTDOWN(streams)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#ifdef PHP_WIN32
       PHP_RSHUTDOWN(win32_core_globals)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
#endif

       if (BG(user_tick_functions)) {
              zend_llist_destroy(BG(user_tick_functions));
              efree(BG(user_tick_functions));
              BG(user_tick_functions) = NULL;
       }

       PHP_RSHUTDOWN(user_filters)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
       PHP_RSHUTDOWN(browscap)(SHUTDOWN_FUNC_ARGS_PASSTHRU);

       BG(page_uid) = -1;
       BG(page_gid) = -1;
       return SUCCESS;
}

Here is the call graph for this function:

static void php_simple_ini_parser_cb ( zval *  arg1,
zval *  arg2,
zval *  arg3,
int  callback_type,
zval *arr  TSRMLS_DC 
) [static]

Definition at line 5889 of file basic_functions.c.

{
       zval *element;

       switch (callback_type) {

              case ZEND_INI_PARSER_ENTRY:
                     if (!arg2) {
                            /* bare string - nothing to do */
                            break;
                     }
                     ALLOC_ZVAL(element);
                     MAKE_COPY_ZVAL(&arg2, element);
                     zend_symtable_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &element, sizeof(zval *), NULL);
                     break;

              case ZEND_INI_PARSER_POP_ENTRY:
              {
                     zval *hash, **find_hash;

                     if (!arg2) {
                            /* bare string - nothing to do */
                            break;
                     }

                     if (!(Z_STRLEN_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), NULL, NULL, 0) == IS_LONG) {
                            ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1));
                            if (zend_hash_index_find(Z_ARRVAL_P(arr), key, (void **) &find_hash) == FAILURE) {
                                   ALLOC_ZVAL(hash);
                                   INIT_PZVAL(hash);
                                   array_init(hash);

                                   zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash, sizeof(zval *), NULL);
                            } else {
                                   hash = *find_hash;
                            }
                     } else {
                            if (zend_hash_find(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, (void **) &find_hash) == FAILURE) {
                                   ALLOC_ZVAL(hash);
                                   INIT_PZVAL(hash);
                                   array_init(hash);

                                   zend_hash_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &hash, sizeof(zval *), NULL);
                            } else {
                                   hash = *find_hash;
                            }
                     }

                     if (Z_TYPE_P(hash) != IS_ARRAY) {
                            zval_dtor(hash);
                            INIT_PZVAL(hash);
                            array_init(hash);
                     }

                     ALLOC_ZVAL(element);
                     MAKE_COPY_ZVAL(&arg2, element);

                     if (arg3 && Z_STRLEN_P(arg3) > 0) {
                            add_assoc_zval_ex(hash, Z_STRVAL_P(arg3), Z_STRLEN_P(arg3) + 1, element);
                     } else {
                            add_next_index_zval(hash, element);
                     }
              }
              break;

              case ZEND_INI_PARSER_SECTION:
                     break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void run_user_tick_functions ( int  tick_count) [static]

Definition at line 5044 of file basic_functions.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static int user_shutdown_function_call ( php_shutdown_function_entry *shutdown_function_entry  TSRMLS_DC) [static]

Definition at line 4977 of file basic_functions.c.

{
       zval retval;
       char *function_name;

       if (!zend_is_callable(shutdown_function_entry->arguments[0], 0, &function_name TSRMLS_CC)) {
              php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name);
              if (function_name) {
                     efree(function_name);
              }
              return 0;
       }
       if (function_name) {
              efree(function_name);
       }

       if (call_user_function(EG(function_table), NULL,
                            shutdown_function_entry->arguments[0],
                            &retval,
                            shutdown_function_entry->arg_count - 1,
                            shutdown_function_entry->arguments + 1
                            TSRMLS_CC ) == SUCCESS)
       {
              zval_dtor(&retval);
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void user_shutdown_function_dtor ( php_shutdown_function_entry shutdown_function_entry) [static]

Definition at line 4955 of file basic_functions.c.

{
       int i;

       for (i = 0; i < shutdown_function_entry->arg_count; i++) {
              zval_ptr_dtor(&shutdown_function_entry->arguments[i]);
       }
       efree(shutdown_function_entry->arguments);
}

Here is the caller graph for this function:

static void user_tick_function_call ( user_tick_function_entry *tick_fe  TSRMLS_DC) [static]

Definition at line 5006 of file basic_functions.c.

{
       zval retval;
       zval *function = tick_fe->arguments[0];

       /* Prevent reentrant calls to the same user ticks function */
       if (! tick_fe->calling) {
              tick_fe->calling = 1;

              if (call_user_function(     EG(function_table), NULL,
                                                        function,
                                                        &retval,
                                                        tick_fe->arg_count - 1,
                                                        tick_fe->arguments + 1
                                                        TSRMLS_CC) == SUCCESS) {
                     zval_dtor(&retval);

              } else {
                     zval **obj, **method;

                     if (Z_TYPE_P(function) == IS_STRING) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s() - function does not exist", Z_STRVAL_P(function));
                     } else if (   Z_TYPE_P(function) == IS_ARRAY
                                          && zend_hash_index_find(Z_ARRVAL_P(function), 0, (void **) &obj) == SUCCESS
                                          && zend_hash_index_find(Z_ARRVAL_P(function), 1, (void **) &method) == SUCCESS
                                          && Z_TYPE_PP(obj) == IS_OBJECT
                                          && Z_TYPE_PP(method) == IS_STRING) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s::%s() - function does not exist", Z_OBJCE_PP(obj)->name, Z_STRVAL_PP(method));
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call tick function");
                     }
              }

              tick_fe->calling = 0;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int user_tick_function_compare ( user_tick_function_entry tick_fe1,
user_tick_function_entry tick_fe2 
) [static]

Definition at line 5052 of file basic_functions.c.

{
       zval *func1 = tick_fe1->arguments[0];
       zval *func2 = tick_fe2->arguments[0];
       int ret;
       TSRMLS_FETCH();

       if (Z_TYPE_P(func1) == IS_STRING && Z_TYPE_P(func2) == IS_STRING) {
              ret = (zend_binary_zval_strcmp(func1, func2) == 0);
       } else if (Z_TYPE_P(func1) == IS_ARRAY && Z_TYPE_P(func2) == IS_ARRAY) {
              zval result;
              zend_compare_arrays(&result, func1, func2 TSRMLS_CC);
              ret = (Z_LVAL(result) == 0);
       } else if (Z_TYPE_P(func1) == IS_OBJECT && Z_TYPE_P(func2) == IS_OBJECT) {
              zval result;
              zend_compare_objects(&result, func1, func2 TSRMLS_CC);
              ret = (Z_LVAL(result) == 0);
       } else {
              ret = 0;
       }

       if (ret && tick_fe1->calling) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to delete tick function executed at the moment");
              return 0;
       }
       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void user_tick_function_dtor ( user_tick_function_entry tick_function_entry) [static]

Definition at line 4966 of file basic_functions.c.

{
       int i;

       for (i = 0; i < tick_function_entry->arg_count; i++) {
              zval_ptr_dtor(&tick_function_entry->arguments[i]);
       }
       efree(tick_function_entry->arguments);
}

Here is the caller graph for this function:

ZEND_ARG_INFO ( ZEND_ARG_INFO 1,
arg   
)

Definition at line 215 of file basic_functions.c.

                                              { /* {{{ */
       PHP_FE(constant,                                                                                                arginfo_constant)
       PHP_FE(bin2hex,                                                                                                        arginfo_bin2hex)
       PHP_FE(sleep,                                                                                                   arginfo_sleep)
       PHP_FE(usleep,                                                                                                         arginfo_usleep)
#if HAVE_NANOSLEEP
       PHP_FE(time_nanosleep,                                                                                          arginfo_time_nanosleep)
       PHP_FE(time_sleep_until,                                                                                 arginfo_time_sleep_until)
#endif

#if HAVE_STRPTIME
       PHP_FE(strptime,                                                                                                arginfo_strptime)
#endif

       PHP_FE(flush,                                                                                                   arginfo_flush)
       PHP_FE(wordwrap,                                                                                                arginfo_wordwrap)
       PHP_FE(htmlspecialchars,                                                                                 arginfo_htmlspecialchars)
       PHP_FE(htmlentities,                                                                                     arginfo_htmlentities)
       PHP_FE(html_entity_decode,                                                                               arginfo_html_entity_decode)
       PHP_FE(htmlspecialchars_decode,                                                                          arginfo_htmlspecialchars_decode)
       PHP_FE(get_html_translation_table,                                                                arginfo_get_html_translation_table)
       PHP_FE(sha1,                                                                                                    arginfo_sha1)
       PHP_FE(sha1_file,                                                                                               arginfo_sha1_file)
       PHP_NAMED_FE(md5,php_if_md5,                                                                             arginfo_md5)
       PHP_NAMED_FE(md5_file,php_if_md5_file,                                                            arginfo_md5_file)
       PHP_NAMED_FE(crc32,php_if_crc32,                                                                  arginfo_crc32)

       PHP_FE(iptcparse,                                                                                               arginfo_iptcparse)
       PHP_FE(iptcembed,                                                                                               arginfo_iptcembed)
       PHP_FE(getimagesize,                                                                                     arginfo_getimagesize)
       PHP_FE(image_type_to_mime_type,                                                                          arginfo_image_type_to_mime_type)
       PHP_FE(image_type_to_extension,                                                                          arginfo_image_type_to_extension)

       PHP_FE(phpinfo,                                                                                                        arginfo_phpinfo)
       PHP_FE(phpversion,                                                                                              arginfo_phpversion)
       PHP_FE(phpcredits,                                                                                              arginfo_phpcredits)
       PHP_FE(php_logo_guid,                                                                                           arginfo_php_logo_guid)
       PHP_FE(php_real_logo_guid,                                                                               arginfo_php_real_logo_guid)
       PHP_FE(php_egg_logo_guid,                                                                                arginfo_php_egg_logo_guid)
       PHP_FE(zend_logo_guid,                                                                                          arginfo_zend_logo_guid)
       PHP_FE(php_sapi_name,                                                                                           arginfo_php_sapi_name)
       PHP_FE(php_uname,                                                                                               arginfo_php_uname)
       PHP_FE(php_ini_scanned_files,                                                                            arginfo_php_ini_scanned_files)
       PHP_FE(php_ini_loaded_file,                                                                              arginfo_php_ini_loaded_file)

       PHP_FE(strnatcmp,                                                                                               arginfo_strnatcmp)
       PHP_FE(strnatcasecmp,                                                                                           arginfo_strnatcasecmp)
       PHP_FE(substr_count,                                                                                     arginfo_substr_count)
       PHP_FE(strspn,                                                                                                         arginfo_strspn)
       PHP_FE(strcspn,                                                                                                        arginfo_strcspn)
       PHP_FE(strtok,                                                                                                         arginfo_strtok)
       PHP_FE(strtoupper,                                                                                              arginfo_strtoupper)
       PHP_FE(strtolower,                                                                                              arginfo_strtolower)
       PHP_FE(strpos,                                                                                                         arginfo_strpos)
       PHP_FE(stripos,                                                                                                        arginfo_stripos)
       PHP_FE(strrpos,                                                                                                        arginfo_strrpos)
       PHP_FE(strripos,                                                                                                arginfo_strripos)
       PHP_FE(strrev,                                                                                                         arginfo_strrev)
       PHP_FE(hebrev,                                                                                                         arginfo_hebrev)
       PHP_FE(hebrevc,                                                                                                        arginfo_hebrevc)
       PHP_FE(nl2br,                                                                                                   arginfo_nl2br)
       PHP_FE(basename,                                                                                                arginfo_basename)
       PHP_FE(dirname,                                                                                                        arginfo_dirname)
       PHP_FE(pathinfo,                                                                                                arginfo_pathinfo)
       PHP_FE(stripslashes,                                                                                     arginfo_stripslashes)
       PHP_FE(stripcslashes,                                                                                           arginfo_stripcslashes)
       PHP_FE(strstr,                                                                                                         arginfo_strstr)
       PHP_FE(stristr,                                                                                                        arginfo_stristr)
       PHP_FE(strrchr,                                                                                                        arginfo_strrchr)
       PHP_FE(str_shuffle,                                                                                             arginfo_str_shuffle)
       PHP_FE(str_word_count,                                                                                          arginfo_str_word_count)
       PHP_FE(str_split,                                                                                               arginfo_str_split)
       PHP_FE(strpbrk,                                                                                                        arginfo_strpbrk)
       PHP_FE(substr_compare,                                                                                          arginfo_substr_compare)

#ifdef HAVE_STRCOLL
       PHP_FE(strcoll,                                                                                                        arginfo_strcoll)
#endif

#ifdef HAVE_STRFMON
       PHP_FE(money_format,                                                                                     arginfo_money_format)
#endif

       PHP_FE(substr,                                                                                                         arginfo_substr)
       PHP_FE(substr_replace,                                                                                          arginfo_substr_replace)
       PHP_FE(quotemeta,                                                                                               arginfo_quotemeta)
       PHP_FE(ucfirst,                                                                                                        arginfo_ucfirst)
       PHP_FE(lcfirst,                                                                                                        arginfo_lcfirst)
       PHP_FE(ucwords,                                                                                                        arginfo_ucwords)
       PHP_FE(strtr,                                                                                                   arginfo_strtr)
       PHP_FE(addslashes,                                                                                              arginfo_addslashes)
       PHP_FE(addcslashes,                                                                                             arginfo_addcslashes)
       PHP_FE(rtrim,                                                                                                   arginfo_rtrim)
       PHP_FE(str_replace,                                                                                             arginfo_str_replace)
       PHP_FE(str_ireplace,                                                                                     arginfo_str_ireplace)
       PHP_FE(str_repeat,                                                                                              arginfo_str_repeat)
       PHP_FE(count_chars,                                                                                             arginfo_count_chars)
       PHP_FE(chunk_split,                                                                                             arginfo_chunk_split)
       PHP_FE(trim,                                                                                                    arginfo_trim)
       PHP_FE(ltrim,                                                                                                   arginfo_ltrim)
       PHP_FE(strip_tags,                                                                                              arginfo_strip_tags)
       PHP_FE(similar_text,                                                                                     arginfo_similar_text)
       PHP_FE(explode,                                                                                                        arginfo_explode)
       PHP_FE(implode,                                                                                                        arginfo_implode)
       PHP_FALIAS(join,                          implode,                                                       arginfo_implode)
       PHP_FE(setlocale,                                                                                               arginfo_setlocale)
       PHP_FE(localeconv,                                                                                              arginfo_localeconv)

#if HAVE_NL_LANGINFO
       PHP_FE(nl_langinfo,                                                                                             arginfo_nl_langinfo)
#endif

       PHP_FE(soundex,                                                                                                        arginfo_soundex)
       PHP_FE(levenshtein,                                                                                             arginfo_levenshtein)
       PHP_FE(chr,                                                                                                            arginfo_chr)
       PHP_FE(ord,                                                                                                            arginfo_ord)
       PHP_FE(parse_str,                                                                                               arginfo_parse_str)
       PHP_FE(str_getcsv,                                                                                              arginfo_str_getcsv)
       PHP_FE(str_pad,                                                                                                        arginfo_str_pad)
       PHP_FALIAS(chop,                          rtrim,                                                         arginfo_rtrim)
       PHP_FALIAS(strchr,                        strstr,                                                               arginfo_strstr)
       PHP_NAMED_FE(sprintf,                     PHP_FN(user_sprintf),                                   arginfo_sprintf)
       PHP_NAMED_FE(printf,               PHP_FN(user_printf),                             arginfo_printf)
       PHP_FE(vprintf,                                                                                                        arginfo_vprintf)
       PHP_FE(vsprintf,                                                                                                arginfo_vsprintf)
       PHP_FE(fprintf,                                                                                                        arginfo_fprintf)
       PHP_FE(vfprintf,                                                                                                arginfo_vfprintf)
       PHP_FE(sscanf,                                                                                                         arginfo_sscanf)
       PHP_FE(fscanf,                                                                                                         arginfo_fscanf)
       PHP_FE(parse_url,                                                                                               arginfo_parse_url)
       PHP_FE(urlencode,                                                                                               arginfo_urlencode)
       PHP_FE(urldecode,                                                                                               arginfo_urldecode)
       PHP_FE(rawurlencode,                                                                                     arginfo_rawurlencode)
       PHP_FE(rawurldecode,                                                                                     arginfo_rawurldecode)
       PHP_FE(http_build_query,                                                                                 arginfo_http_build_query)

#if defined(HAVE_SYMLINK) || defined(PHP_WIN32)
       PHP_FE(readlink,                                                                                                arginfo_readlink)
       PHP_FE(linkinfo,                                                                                                arginfo_linkinfo)
       PHP_FE(symlink,                                                                                                        arginfo_symlink)
       PHP_FE(link,                                                                                                    arginfo_link)
#endif

       PHP_FE(unlink,                                                                                                         arginfo_unlink)
       PHP_FE(exec,                                                                                                    arginfo_exec)
       PHP_FE(system,                                                                                                         arginfo_system)
       PHP_FE(escapeshellcmd,                                                                                          arginfo_escapeshellcmd)
       PHP_FE(escapeshellarg,                                                                                          arginfo_escapeshellarg)
       PHP_FE(passthru,                                                                                                arginfo_passthru)
       PHP_FE(shell_exec,                                                                                              arginfo_shell_exec)
#ifdef PHP_CAN_SUPPORT_PROC_OPEN
       PHP_FE(proc_open,                                                                                               arginfo_proc_open)
       PHP_FE(proc_close,                                                                                              arginfo_proc_close)
       PHP_FE(proc_terminate,                                                                                          arginfo_proc_terminate)
       PHP_FE(proc_get_status,                                                                                         arginfo_proc_get_status)
#endif

#ifdef HAVE_NICE
       PHP_FE(proc_nice,                                                                                               arginfo_proc_nice)
#endif

       PHP_FE(rand,                                                                                                    arginfo_rand)
       PHP_FE(srand,                                                                                                   arginfo_srand)
       PHP_FE(getrandmax,                                                                                              arginfo_getrandmax)
       PHP_FE(mt_rand,                                                                                                        arginfo_mt_rand)
       PHP_FE(mt_srand,                                                                                                arginfo_mt_srand)
       PHP_FE(mt_getrandmax,                                                                                           arginfo_mt_getrandmax)

#if HAVE_GETSERVBYNAME
       PHP_FE(getservbyname,                                                                                           arginfo_getservbyname)
#endif

#if HAVE_GETSERVBYPORT
       PHP_FE(getservbyport,                                                                                           arginfo_getservbyport)
#endif

#if HAVE_GETPROTOBYNAME
       PHP_FE(getprotobyname,                                                                                          arginfo_getprotobyname)
#endif

#if HAVE_GETPROTOBYNUMBER
       PHP_FE(getprotobynumber,                                                                                 arginfo_getprotobynumber)
#endif

       PHP_FE(getmyuid,                                                                                                arginfo_getmyuid)
       PHP_FE(getmygid,                                                                                                arginfo_getmygid)
       PHP_FE(getmypid,                                                                                                arginfo_getmypid)
       PHP_FE(getmyinode,                                                                                              arginfo_getmyinode)
       PHP_FE(getlastmod,                                                                                              arginfo_getlastmod)

       PHP_FE(base64_decode,                                                                                           arginfo_base64_decode)
       PHP_FE(base64_encode,                                                                                           arginfo_base64_encode)

       PHP_FE(convert_uuencode,                                                                                 arginfo_convert_uuencode)
       PHP_FE(convert_uudecode,                                                                                 arginfo_convert_uudecode)

       PHP_FE(abs,                                                                                                            arginfo_abs)
       PHP_FE(ceil,                                                                                                    arginfo_ceil)
       PHP_FE(floor,                                                                                                   arginfo_floor)
       PHP_FE(round,                                                                                                   arginfo_round)
       PHP_FE(sin,                                                                                                            arginfo_sin)
       PHP_FE(cos,                                                                                                            arginfo_cos)
       PHP_FE(tan,                                                                                                            arginfo_tan)
       PHP_FE(asin,                                                                                                    arginfo_asin)
       PHP_FE(acos,                                                                                                    arginfo_acos)
       PHP_FE(atan,                                                                                                    arginfo_atan)
       PHP_FE(atanh,                                                                                                   arginfo_atanh)
       PHP_FE(atan2,                                                                                                   arginfo_atan2)
       PHP_FE(sinh,                                                                                                    arginfo_sinh)
       PHP_FE(cosh,                                                                                                    arginfo_cosh)
       PHP_FE(tanh,                                                                                                    arginfo_tanh)
       PHP_FE(asinh,                                                                                                   arginfo_asinh)
       PHP_FE(acosh,                                                                                                   arginfo_acosh)
       PHP_FE(expm1,                                                                                                   arginfo_expm1)
       PHP_FE(log1p,                                                                                                   arginfo_log1p)
       PHP_FE(pi,                                                                                                             arginfo_pi)
       PHP_FE(is_finite,                                                                                               arginfo_is_finite)
       PHP_FE(is_nan,                                                                                                         arginfo_is_nan)
       PHP_FE(is_infinite,                                                                                             arginfo_is_infinite)
       PHP_FE(pow,                                                                                                            arginfo_pow)
       PHP_FE(exp,                                                                                                            arginfo_exp)
       PHP_FE(log,                                                                                                            arginfo_log)
       PHP_FE(log10,                                                                                                   arginfo_log10)
       PHP_FE(sqrt,                                                                                                    arginfo_sqrt)
       PHP_FE(hypot,                                                                                                   arginfo_hypot)
       PHP_FE(deg2rad,                                                                                                        arginfo_deg2rad)
       PHP_FE(rad2deg,                                                                                                        arginfo_rad2deg)
       PHP_FE(bindec,                                                                                                         arginfo_bindec)
       PHP_FE(hexdec,                                                                                                         arginfo_hexdec)
       PHP_FE(octdec,                                                                                                         arginfo_octdec)
       PHP_FE(decbin,                                                                                                         arginfo_decbin)
       PHP_FE(decoct,                                                                                                         arginfo_decoct)
       PHP_FE(dechex,                                                                                                         arginfo_dechex)
       PHP_FE(base_convert,                                                                                     arginfo_base_convert)
       PHP_FE(number_format,                                                                                           arginfo_number_format)
       PHP_FE(fmod,                                                                                                    arginfo_fmod)
#ifdef HAVE_INET_NTOP
       PHP_RAW_NAMED_FE(inet_ntop,        php_inet_ntop,                                                        arginfo_inet_ntop)
#endif
#ifdef HAVE_INET_PTON
       PHP_RAW_NAMED_FE(inet_pton,        php_inet_pton,                                                        arginfo_inet_pton)
#endif
       PHP_FE(ip2long,                                                                                                        arginfo_ip2long)
       PHP_FE(long2ip,                                                                                                        arginfo_long2ip)

       PHP_FE(getenv,                                                                                                         arginfo_getenv)
#ifdef HAVE_PUTENV
       PHP_FE(putenv,                                                                                                         arginfo_putenv)
#endif

       PHP_FE(getopt,                                                                                                         arginfo_getopt)

#ifdef HAVE_GETLOADAVG
       PHP_FE(sys_getloadavg,                                                                                          arginfo_sys_getloadavg)
#endif
#ifdef HAVE_GETTIMEOFDAY
       PHP_FE(microtime,                                                                                               arginfo_microtime)
       PHP_FE(gettimeofday,                                                                                     arginfo_gettimeofday)
#endif

#ifdef HAVE_GETRUSAGE
       PHP_FE(getrusage,                                                                                               arginfo_getrusage)
#endif

#ifdef HAVE_GETTIMEOFDAY
       PHP_FE(uniqid,                                                                                                         arginfo_uniqid)
#endif

       PHP_FE(quoted_printable_decode,                                                                          arginfo_quoted_printable_decode)
       PHP_FE(quoted_printable_encode,                                                                          arginfo_quoted_printable_encode)
       PHP_FE(convert_cyr_string,                                                                               arginfo_convert_cyr_string)
       PHP_FE(get_current_user,                                                                                 arginfo_get_current_user)
       PHP_FE(set_time_limit,                                                                                          arginfo_set_time_limit)
       PHP_FE(get_cfg_var,                                                                                             arginfo_get_cfg_var)

       PHP_DEP_FALIAS(magic_quotes_runtime,      set_magic_quotes_runtime,          arginfo_set_magic_quotes_runtime)
       PHP_DEP_FE(set_magic_quotes_runtime,                                                              arginfo_set_magic_quotes_runtime)
       PHP_FE(get_magic_quotes_gpc,                                                                             arginfo_get_magic_quotes_gpc)
       PHP_FE(get_magic_quotes_runtime,                                                                  arginfo_get_magic_quotes_runtime)

       PHP_FE(import_request_variables,                                                                  arginfo_import_request_variables)
       PHP_FE(error_log,                                                                                               arginfo_error_log)
       PHP_FE(error_get_last,                                                                                          arginfo_error_get_last)
       PHP_FE(call_user_func,                                                                                          arginfo_call_user_func)
       PHP_FE(call_user_func_array,                                                                             arginfo_call_user_func_array)
       PHP_DEP_FE(call_user_method,                                                                             arginfo_call_user_method)
       PHP_DEP_FE(call_user_method_array,                                                                arginfo_call_user_method_array)
       PHP_FE(forward_static_call,                                                                       arginfo_forward_static_call)
       PHP_FE(forward_static_call_array,                                                                 arginfo_forward_static_call_array)
       PHP_FE(serialize,                                                                                               arginfo_serialize)
       PHP_FE(unserialize,                                                                                             arginfo_unserialize)

       PHP_FE(var_dump,                                                                                                arginfo_var_dump)
       PHP_FE(var_export,                                                                                              arginfo_var_export)
       PHP_FE(debug_zval_dump,                                                                                         arginfo_debug_zval_dump)
       PHP_FE(print_r,                                                                                                        arginfo_print_r)
       PHP_FE(memory_get_usage,                                                                                 arginfo_memory_get_usage)
       PHP_FE(memory_get_peak_usage,                                                                            arginfo_memory_get_peak_usage)

       PHP_FE(register_shutdown_function,                                                                arginfo_register_shutdown_function)
       PHP_FE(register_tick_function,                                                                           arginfo_register_tick_function)
       PHP_FE(unregister_tick_function,                                                                  arginfo_unregister_tick_function)

       PHP_FE(highlight_file,                                                                                          arginfo_highlight_file)
       PHP_FALIAS(show_source,                   highlight_file,                                                arginfo_highlight_file)
       PHP_FE(highlight_string,                                                                                 arginfo_highlight_string)
       PHP_FE(php_strip_whitespace,                                                                             arginfo_php_strip_whitespace)

       PHP_FE(ini_get,                                                                                                        arginfo_ini_get)
       PHP_FE(ini_get_all,                                                                                             arginfo_ini_get_all)
       PHP_FE(ini_set,                                                                                                        arginfo_ini_set)
       PHP_FALIAS(ini_alter,                     ini_set,                                                       arginfo_ini_set)
       PHP_FE(ini_restore,                                                                                             arginfo_ini_restore)
       PHP_FE(get_include_path,                                                                                 arginfo_get_include_path)
       PHP_FE(set_include_path,                                                                                 arginfo_set_include_path)
       PHP_FE(restore_include_path,                                                                             arginfo_restore_include_path)

       PHP_FE(setcookie,                                                                                               arginfo_setcookie)
       PHP_FE(setrawcookie,                                                                                     arginfo_setrawcookie)
       PHP_FE(header,                                                                                                         arginfo_header)
       PHP_FE(header_remove,                                                                                           arginfo_header_remove)
       PHP_FE(headers_sent,                                                                                     arginfo_headers_sent)
       PHP_FE(headers_list,                                                                                     arginfo_headers_list)

       PHP_FE(connection_aborted,                                                                               arginfo_connection_aborted)
       PHP_FE(connection_status,                                                                                arginfo_connection_status)
       PHP_FE(ignore_user_abort,                                                                                arginfo_ignore_user_abort)
       PHP_FE(parse_ini_file,                                                                                          arginfo_parse_ini_file)
       PHP_FE(parse_ini_string,                                                                                 arginfo_parse_ini_string)
#if ZEND_DEBUG
       PHP_FE(config_get_hash,                                                                                         arginfo_config_get_hash)
#endif
       PHP_FE(is_uploaded_file,                                                                                 arginfo_is_uploaded_file)
       PHP_FE(move_uploaded_file,                                                                               arginfo_move_uploaded_file)

       /* functions from dns.c */
       PHP_FE(gethostbyaddr,                                                                                           arginfo_gethostbyaddr)
       PHP_FE(gethostbyname,                                                                                           arginfo_gethostbyname)
       PHP_FE(gethostbynamel,                                                                                          arginfo_gethostbynamel)

#ifdef HAVE_GETHOSTNAME
       PHP_FE(gethostname,                                                                                      arginfo_gethostname)
#endif

#if defined(PHP_WIN32) || (HAVE_DNS_SEARCH_FUNC && !(defined(__BEOS__) || defined(NETWARE)))

       PHP_FE(dns_check_record,                                                                                 arginfo_dns_check_record)
       PHP_FALIAS(checkdnsrr,                    dns_check_record,                                       arginfo_dns_check_record)

# if defined(PHP_WIN32) || HAVE_FULL_DNS_FUNCS
       PHP_FE(dns_get_mx,                                                                                              arginfo_dns_get_mx)
       PHP_FALIAS(getmxrr,                       dns_get_mx,                               arginfo_dns_get_mx)
       PHP_FE(dns_get_record,                                                                                          arginfo_dns_get_record)
# endif
#endif

       /* functions from type.c */
       PHP_FE(intval,                                                                                                         arginfo_intval)
       PHP_FE(floatval,                                                                                                arginfo_floatval)
       PHP_FALIAS(doubleval,                     floatval,                                                      arginfo_floatval)
       PHP_FE(strval,                                                                                                         arginfo_strval)
       PHP_FE(gettype,                                                                                                        arginfo_gettype)
       PHP_FE(settype,                                                                                                        arginfo_settype)
       PHP_FE(is_null,                                                                                                        arginfo_is_null)
       PHP_FE(is_resource,                                                                                             arginfo_is_resource)
       PHP_FE(is_bool,                                                                                                        arginfo_is_bool)
       PHP_FE(is_long,                                                                                                        arginfo_is_long)
       PHP_FE(is_float,                                                                                                arginfo_is_float)
       PHP_FALIAS(is_int,                        is_long,                                                       arginfo_is_long)
       PHP_FALIAS(is_integer,                    is_long,                                                       arginfo_is_long)
       PHP_FALIAS(is_double,                     is_float,                                                      arginfo_is_float)
       PHP_FALIAS(is_real,                       is_float,                                                      arginfo_is_float)
       PHP_FE(is_numeric,                                                                                              arginfo_is_numeric)
       PHP_FE(is_string,                                                                                               arginfo_is_string)
       PHP_FE(is_array,                                                                                                arginfo_is_array)
       PHP_FE(is_object,                                                                                               arginfo_is_object)
       PHP_FE(is_scalar,                                                                                               arginfo_is_scalar)
       PHP_FE(is_callable,                                                                                             arginfo_is_callable)

       /* functions from file.c */
       PHP_FE(pclose,                                                                                                         arginfo_pclose)
       PHP_FE(popen,                                                                                                   arginfo_popen)
       PHP_FE(readfile,                                                                                                arginfo_readfile)
       PHP_FE(rewind,                                                                                                         arginfo_rewind)
       PHP_FE(rmdir,                                                                                                   arginfo_rmdir)
       PHP_FE(umask,                                                                                                   arginfo_umask)
       PHP_FE(fclose,                                                                                                         arginfo_fclose)
       PHP_FE(feof,                                                                                                    arginfo_feof)
       PHP_FE(fgetc,                                                                                                   arginfo_fgetc)
       PHP_FE(fgets,                                                                                                   arginfo_fgets)
       PHP_FE(fgetss,                                                                                                         arginfo_fgetss)
       PHP_FE(fread,                                                                                                   arginfo_fread)
       PHP_NAMED_FE(fopen,                       php_if_fopen,                                           arginfo_fopen)
       PHP_FE(fpassthru,                                                                                               arginfo_fpassthru)
       PHP_NAMED_FE(ftruncate,                   php_if_ftruncate,                                       arginfo_ftruncate)
       PHP_NAMED_FE(fstat,                       php_if_fstat,                                           arginfo_fstat)
       PHP_FE(fseek,                                                                                                   arginfo_fseek)
       PHP_FE(ftell,                                                                                                   arginfo_ftell)
       PHP_FE(fflush,                                                                                                         arginfo_fflush)
       PHP_FE(fwrite,                                                                                                         arginfo_fwrite)
       PHP_FALIAS(fputs,                         fwrite,                                                               arginfo_fwrite)
       PHP_FE(mkdir,                                                                                                   arginfo_mkdir)
       PHP_FE(rename,                                                                                                         arginfo_rename)
       PHP_FE(copy,                                                                                                    arginfo_copy)
       PHP_FE(tempnam,                                                                                                        arginfo_tempnam)
       PHP_NAMED_FE(tmpfile,                     php_if_tmpfile,                                                arginfo_tmpfile)
       PHP_FE(file,                                                                                                    arginfo_file)
       PHP_FE(file_get_contents,                                                                                arginfo_file_get_contents)
       PHP_FE(file_put_contents,                                                                                arginfo_file_put_contents)
       PHP_FE(stream_select,                                                                                           arginfo_stream_select)
       PHP_FE(stream_context_create,                                                                            arginfo_stream_context_create)
       PHP_FE(stream_context_set_params,                                                                 arginfo_stream_context_set_params)
       PHP_FE(stream_context_get_params,                                                                 arginfo_stream_context_get_params)
       PHP_FE(stream_context_set_option,                                                                 arginfo_stream_context_set_option)
       PHP_FE(stream_context_get_options,                                                                arginfo_stream_context_get_options)
       PHP_FE(stream_context_get_default,                                                                arginfo_stream_context_get_default)
       PHP_FE(stream_context_set_default,                                                                arginfo_stream_context_set_default)
       PHP_FE(stream_filter_prepend,                                                                            arginfo_stream_filter_prepend)
       PHP_FE(stream_filter_append,                                                                             arginfo_stream_filter_append)
       PHP_FE(stream_filter_remove,                                                                             arginfo_stream_filter_remove)
       PHP_FE(stream_socket_client,                                                                             arginfo_stream_socket_client)
       PHP_FE(stream_socket_server,                                                                             arginfo_stream_socket_server)
       PHP_FE(stream_socket_accept,                                                                             arginfo_stream_socket_accept)
       PHP_FE(stream_socket_get_name,                                                                           arginfo_stream_socket_get_name)
       PHP_FE(stream_socket_recvfrom,                                                                           arginfo_stream_socket_recvfrom)
       PHP_FE(stream_socket_sendto,                                                                             arginfo_stream_socket_sendto)
       PHP_FE(stream_socket_enable_crypto,                                                                      arginfo_stream_socket_enable_crypto)
#ifdef HAVE_SHUTDOWN
       PHP_FE(stream_socket_shutdown,                                                                           arginfo_stream_socket_shutdown)
#endif
#if HAVE_SOCKETPAIR
       PHP_FE(stream_socket_pair,                                                                               arginfo_stream_socket_pair)
#endif
       PHP_FE(stream_copy_to_stream,                                                                            arginfo_stream_copy_to_stream)
       PHP_FE(stream_get_contents,                                                                              arginfo_stream_get_contents)
       PHP_FE(stream_supports_lock,                                                                             arginfo_stream_supports_lock)
       PHP_FE(fgetcsv,                                                                                                        arginfo_fgetcsv)
       PHP_FE(fputcsv,                                                                                                        arginfo_fputcsv)
       PHP_FE(flock,                                                                                                   arginfo_flock)
       PHP_FE(get_meta_tags,                                                                                           arginfo_get_meta_tags)
       PHP_FE(stream_set_read_buffer,                                                                           arginfo_stream_set_read_buffer)
       PHP_FE(stream_set_write_buffer,                                                                          arginfo_stream_set_write_buffer)
       PHP_FALIAS(set_file_buffer, stream_set_write_buffer,                                arginfo_stream_set_write_buffer)

       PHP_DEP_FALIAS(set_socket_blocking, stream_set_blocking,                            arginfo_stream_set_blocking)
       PHP_FE(stream_set_blocking,                                                                              arginfo_stream_set_blocking)
       PHP_FALIAS(socket_set_blocking, stream_set_blocking,                                arginfo_stream_set_blocking)

       PHP_FE(stream_get_meta_data,                                                                             arginfo_stream_get_meta_data)
       PHP_FE(stream_get_line,                                                                                         arginfo_stream_get_line)
       PHP_FE(stream_wrapper_register,                                                                          arginfo_stream_wrapper_register)
       PHP_FALIAS(stream_register_wrapper, stream_wrapper_register,                 arginfo_stream_wrapper_register)
       PHP_FE(stream_wrapper_unregister,                                                                 arginfo_stream_wrapper_unregister)
       PHP_FE(stream_wrapper_restore,                                                                           arginfo_stream_wrapper_restore)
       PHP_FE(stream_get_wrappers,                                                                              arginfo_stream_get_wrappers)
       PHP_FE(stream_get_transports,                                                                            arginfo_stream_get_transports)
       PHP_FE(stream_resolve_include_path,                                                                      arginfo_stream_resolve_include_path)
       PHP_FE(stream_is_local,                                                                                  arginfo_stream_is_local)
       PHP_FE(get_headers,                                                                                             arginfo_get_headers)

#if HAVE_SYS_TIME_H || defined(PHP_WIN32)
       PHP_FE(stream_set_timeout,                                                                               arginfo_stream_set_timeout)
       PHP_FALIAS(socket_set_timeout, stream_set_timeout,                                         arginfo_stream_set_timeout)
#endif

       PHP_FALIAS(socket_get_status, stream_get_meta_data,                                        arginfo_stream_get_meta_data)

#if (!defined(__BEOS__) && !defined(NETWARE) && HAVE_REALPATH) || defined(ZTS)
       PHP_FE(realpath,                                                                                                arginfo_realpath)
#endif

#ifdef HAVE_FNMATCH
       PHP_FE(fnmatch,                                                                                                        arginfo_fnmatch)
#endif

       /* functions from fsock.c */
       PHP_FE(fsockopen,                                                                                               arginfo_fsockopen)
       PHP_FE(pfsockopen,                                                                                              arginfo_pfsockopen)

       /* functions from pack.c */
       PHP_FE(pack,                                                                                                    arginfo_pack)
       PHP_FE(unpack,                                                                                                         arginfo_unpack)

       /* functions from browscap.c */
       PHP_FE(get_browser,                                                                                             arginfo_get_browser)

#if HAVE_CRYPT
       /* functions from crypt.c */
       PHP_FE(crypt,                                                                                                   arginfo_crypt)
#endif

       /* functions from dir.c */
       PHP_FE(opendir,                                                                                                        arginfo_opendir)
       PHP_FE(closedir,                                                                                                arginfo_closedir)
       PHP_FE(chdir,                                                                                                   arginfo_chdir)

#if defined(HAVE_CHROOT) && !defined(ZTS) && ENABLE_CHROOT_FUNC
       PHP_FE(chroot,                                                                                                         arginfo_chroot)
#endif

       PHP_FE(getcwd,                                                                                                         arginfo_getcwd)
       PHP_FE(rewinddir,                                                                                               arginfo_rewinddir)
       PHP_NAMED_FE(readdir,                     php_if_readdir,                                                arginfo_readdir)
       PHP_FALIAS(dir,                                  getdir,                                                               arginfo_dir)
       PHP_FE(scandir,                                                                                                        arginfo_scandir)
#ifdef HAVE_GLOB
       PHP_FE(glob,                                                                                                    arginfo_glob)
#endif
       /* functions from filestat.c */
       PHP_FE(fileatime,                                                                                               arginfo_fileatime)
       PHP_FE(filectime,                                                                                               arginfo_filectime)
       PHP_FE(filegroup,                                                                                               arginfo_filegroup)
       PHP_FE(fileinode,                                                                                               arginfo_fileinode)
       PHP_FE(filemtime,                                                                                               arginfo_filemtime)
       PHP_FE(fileowner,                                                                                               arginfo_fileowner)
       PHP_FE(fileperms,                                                                                               arginfo_fileperms)
       PHP_FE(filesize,                                                                                                arginfo_filesize)
       PHP_FE(filetype,                                                                                                arginfo_filetype)
       PHP_FE(file_exists,                                                                                             arginfo_file_exists)
       PHP_FE(is_writable,                                                                                             arginfo_is_writable)
       PHP_FALIAS(is_writeable,           is_writable,                                            arginfo_is_writable)
       PHP_FE(is_readable,                                                                                             arginfo_is_readable)
       PHP_FE(is_executable,                                                                                           arginfo_is_executable)
       PHP_FE(is_file,                                                                                                        arginfo_is_file)
       PHP_FE(is_dir,                                                                                                         arginfo_is_dir)
       PHP_FE(is_link,                                                                                                        arginfo_is_link)
       PHP_NAMED_FE(stat,                        php_if_stat,                                            arginfo_stat)
       PHP_NAMED_FE(lstat,                       php_if_lstat,                                           arginfo_lstat)
#ifndef NETWARE
       PHP_FE(chown,                                                                                                   arginfo_chown)
       PHP_FE(chgrp,                                                                                                   arginfo_chgrp)
#endif
#if HAVE_LCHOWN
       PHP_FE(lchown,                                                                                                         arginfo_lchown)
#endif
#if HAVE_LCHOWN
       PHP_FE(lchgrp,                                                                                                         arginfo_lchgrp)
#endif
       PHP_FE(chmod,                                                                                                   arginfo_chmod)
#if HAVE_UTIME
       PHP_FE(touch,                                                                                                   arginfo_touch)
#endif
       PHP_FE(clearstatcache,                                                                                          arginfo_clearstatcache)
       PHP_FE(disk_total_space,                                                                                 arginfo_disk_total_space)
       PHP_FE(disk_free_space,                                                                                         arginfo_disk_free_space)
       PHP_FALIAS(diskfreespace,          disk_free_space,                                        arginfo_disk_free_space)
       PHP_FE(realpath_cache_size,                                                                              arginfo_realpath_cache_size)
       PHP_FE(realpath_cache_get,                                                                               arginfo_realpath_cache_get)

       /* functions from mail.c */
       PHP_FE(mail,                                                                                                    arginfo_mail)
       PHP_FE(ezmlm_hash,                                                                                              arginfo_ezmlm_hash)

       /* functions from syslog.c */
#ifdef HAVE_SYSLOG_H
       PHP_FE(openlog,                                                                                                        arginfo_openlog)
       PHP_FE(syslog,                                                                                                         arginfo_syslog)
       PHP_FE(closelog,                                                                                                arginfo_closelog)
       PHP_DEP_FE(define_syslog_variables,                                                                             arginfo_define_syslog_variables)
#endif

       /* functions from lcg.c */
       PHP_FE(lcg_value,                                                                                               arginfo_lcg_value)

       /* functions from metaphone.c */
       PHP_FE(metaphone,                                                                                               arginfo_metaphone)

       /* functions from output.c */
       PHP_FE(ob_start,                                                                                                arginfo_ob_start)
       PHP_FE(ob_flush,                                                                                                arginfo_ob_flush)
       PHP_FE(ob_clean,                                                                                                arginfo_ob_clean)
       PHP_FE(ob_end_flush,                                                                                     arginfo_ob_end_flush)
       PHP_FE(ob_end_clean,                                                                                     arginfo_ob_end_clean)
       PHP_FE(ob_get_flush,                                                                                     arginfo_ob_get_flush)
       PHP_FE(ob_get_clean,                                                                                     arginfo_ob_get_clean)
       PHP_FE(ob_get_length,                                                                                           arginfo_ob_get_length)
       PHP_FE(ob_get_level,                                                                                     arginfo_ob_get_level)
       PHP_FE(ob_get_status,                                                                                           arginfo_ob_get_status)
       PHP_FE(ob_get_contents,                                                                                         arginfo_ob_get_contents)
       PHP_FE(ob_implicit_flush,                                                                                arginfo_ob_implicit_flush)
       PHP_FE(ob_list_handlers,                                                                                 arginfo_ob_list_handlers)

       /* functions from array.c */
       PHP_FE(ksort,                                                                                                   arginfo_ksort)
       PHP_FE(krsort,                                                                                                         arginfo_krsort)
       PHP_FE(natsort,                                                                                                        arginfo_natsort)
       PHP_FE(natcasesort,                                                                                             arginfo_natcasesort)
       PHP_FE(asort,                                                                                                   arginfo_asort)
       PHP_FE(arsort,                                                                                                         arginfo_arsort)
       PHP_FE(sort,                                                                                                    arginfo_sort)
       PHP_FE(rsort,                                                                                                   arginfo_rsort)
       PHP_FE(usort,                                                                                                   arginfo_usort)
       PHP_FE(uasort,                                                                                                         arginfo_uasort)
       PHP_FE(uksort,                                                                                                         arginfo_uksort)
       PHP_FE(shuffle,                                                                                                        arginfo_shuffle)
       PHP_FE(array_walk,                                                                                              arginfo_array_walk)
       PHP_FE(array_walk_recursive,                                                                             arginfo_array_walk_recursive)
       PHP_FE(count,                                                                                                   arginfo_count)
       PHP_FE(end,                                                                                                            arginfo_end)
       PHP_FE(prev,                                                                                                    arginfo_prev)
       PHP_FE(next,                                                                                                    arginfo_next)
       PHP_FE(reset,                                                                                                   arginfo_reset)
       PHP_FE(current,                                                                                                        arginfo_current)
       PHP_FE(key,                                                                                                            arginfo_key)
       PHP_FE(min,                                                                                                            arginfo_min)
       PHP_FE(max,                                                                                                            arginfo_max)
       PHP_FE(in_array,                                                                                                arginfo_in_array)
       PHP_FE(array_search,                                                                                     arginfo_array_search)
       PHP_FE(extract,                                                                                                        arginfo_extract)
       PHP_FE(compact,                                                                                                        arginfo_compact)
       PHP_FE(array_fill,                                                                                              arginfo_array_fill)
       PHP_FE(array_fill_keys,                                                                                         arginfo_array_fill_keys)
       PHP_FE(range,                                                                                                   arginfo_range)
       PHP_FE(array_multisort,                                                                                         arginfo_array_multisort)
       PHP_FE(array_push,                                                                                              arginfo_array_push)
       PHP_FE(array_pop,                                                                                               arginfo_array_pop)
       PHP_FE(array_shift,                                                                                             arginfo_array_shift)
       PHP_FE(array_unshift,                                                                                           arginfo_array_unshift)
       PHP_FE(array_splice,                                                                                     arginfo_array_splice)
       PHP_FE(array_slice,                                                                                             arginfo_array_slice)
       PHP_FE(array_merge,                                                                                             arginfo_array_merge)
       PHP_FE(array_merge_recursive,                                                                            arginfo_array_merge_recursive)
       PHP_FE(array_replace,                                                                                           arginfo_array_replace)
       PHP_FE(array_replace_recursive,                                                                          arginfo_array_replace_recursive)
       PHP_FE(array_keys,                                                                                              arginfo_array_keys)
       PHP_FE(array_values,                                                                                     arginfo_array_values)
       PHP_FE(array_count_values,                                                                               arginfo_array_count_values)
       PHP_FE(array_reverse,                                                                                           arginfo_array_reverse)
       PHP_FE(array_reduce,                                                                                     arginfo_array_reduce)
       PHP_FE(array_pad,                                                                                               arginfo_array_pad)
       PHP_FE(array_flip,                                                                                              arginfo_array_flip)
       PHP_FE(array_change_key_case,                                                                            arginfo_array_change_key_case)
       PHP_FE(array_rand,                                                                                              arginfo_array_rand)
       PHP_FE(array_unique,                                                                                     arginfo_array_unique)
       PHP_FE(array_intersect,                                                                                         arginfo_array_intersect)
       PHP_FE(array_intersect_key,                                                                              arginfo_array_intersect_key)
       PHP_FE(array_intersect_ukey,                                                                             arginfo_array_intersect_ukey)
       PHP_FE(array_uintersect,                                                                                 arginfo_array_uintersect)
       PHP_FE(array_intersect_assoc,                                                                            arginfo_array_intersect_assoc)
       PHP_FE(array_uintersect_assoc,                                                                           arginfo_array_uintersect_assoc)
       PHP_FE(array_intersect_uassoc,                                                                           arginfo_array_intersect_uassoc)
       PHP_FE(array_uintersect_uassoc,                                                                          arginfo_array_uintersect_uassoc)
       PHP_FE(array_diff,                                                                                              arginfo_array_diff)
       PHP_FE(array_diff_key,                                                                                          arginfo_array_diff_key)
       PHP_FE(array_diff_ukey,                                                                                         arginfo_array_diff_ukey)
       PHP_FE(array_udiff,                                                                                             arginfo_array_udiff)
       PHP_FE(array_diff_assoc,                                                                                 arginfo_array_diff_assoc)
       PHP_FE(array_udiff_assoc,                                                                                arginfo_array_udiff_assoc)
       PHP_FE(array_diff_uassoc,                                                                                arginfo_array_diff_uassoc)
       PHP_FE(array_udiff_uassoc,                                                                               arginfo_array_udiff_uassoc)
       PHP_FE(array_sum,                                                                                               arginfo_array_sum)
       PHP_FE(array_product,                                                                                           arginfo_array_product)
       PHP_FE(array_filter,                                                                                     arginfo_array_filter)
       PHP_FE(array_map,                                                                                               arginfo_array_map)
       PHP_FE(array_chunk,                                                                                             arginfo_array_chunk)
       PHP_FE(array_combine,                                                                                           arginfo_array_combine)
       PHP_FE(array_key_exists,                                                                                 arginfo_array_key_exists)

       /* aliases from array.c */
       PHP_FALIAS(pos,                                  current,                                                       arginfo_current)
       PHP_FALIAS(sizeof,                        count,                                                         arginfo_count)
       PHP_FALIAS(key_exists,                    array_key_exists,                                       arginfo_array_key_exists)

       /* functions from assert.c */
       PHP_FE(assert,                                                                                                         arginfo_assert)
       PHP_FE(assert_options,                                                                                          arginfo_assert_options)

       /* functions from versioning.c */
       PHP_FE(version_compare,                                                                                         arginfo_version_compare)

       /* functions from ftok.c*/
#if HAVE_FTOK
       PHP_FE(ftok,                                                                                                    arginfo_ftok)
#endif

       PHP_FE(str_rot13,                                                                                               arginfo_str_rot13)
       PHP_FE(stream_get_filters,                                                                               arginfo_stream_get_filters)
       PHP_FE(stream_filter_register,                                                                           arginfo_stream_filter_register)
       PHP_FE(stream_bucket_make_writeable,                                                              arginfo_stream_bucket_make_writeable)
       PHP_FE(stream_bucket_prepend,                                                                            arginfo_stream_bucket_prepend)
       PHP_FE(stream_bucket_append,                                                                             arginfo_stream_bucket_append)
       PHP_FE(stream_bucket_new,                                                                                arginfo_stream_bucket_new)

       PHP_FE(output_add_rewrite_var,                                                                           arginfo_output_add_rewrite_var)
       PHP_FE(output_reset_rewrite_vars,                                                                 arginfo_output_reset_rewrite_vars)

       PHP_FE(sys_get_temp_dir,                                                                                 arginfo_sys_get_temp_dir)

       PHP_FE_END
};

Here is the call graph for this function:


Variable Documentation

zend_module_entry basic_functions_module
Initial value:
 { 
       STANDARD_MODULE_HEADER_EX,
       NULL,
       standard_deps,
       "standard",                               
       basic_functions,                   
       PHP_MINIT(basic),                  
       PHP_MSHUTDOWN(basic),              
       PHP_RINIT(basic),                  
       PHP_RSHUTDOWN(basic),              
       PHP_MINFO(basic),                  
       PHP_VERSION,                       
       STANDARD_MODULE_PROPERTIES
}

Definition at line 3408 of file basic_functions.c.

Definition at line 114 of file basic_functions.c.

zend_class_entry* incomplete_class_entry = NULL [static]

Definition at line 120 of file basic_functions.c.