Back to index

php5  5.3.10
Classes | Defines | Functions | Variables
php_spl.c File Reference
#include "php.h"
#include "php_ini.h"
#include "php_main.h"
#include "ext/standard/info.h"
#include "php_spl.h"
#include "spl_functions.h"
#include "spl_engine.h"
#include "spl_array.h"
#include "spl_directory.h"
#include "spl_iterators.h"
#include "spl_exceptions.h"
#include "spl_observer.h"
#include "spl_dllist.h"
#include "spl_fixedarray.h"
#include "spl_heap.h"
#include "zend_exceptions.h"
#include "zend_interfaces.h"
#include "ext/standard/php_rand.h"
#include "ext/standard/php_lcg.h"
#include "main/snprintf.h"

Go to the source code of this file.

Classes

struct  autoload_func_info

Defines

#define SPL_DEFAULT_FILE_EXTENSIONS   ".inc,.php"
#define SPL_ADD_CLASS(class_name, z_list, sub, allow, ce_flags)   spl_add_classes(spl_ce_ ## class_name, z_list, sub, allow, ce_flags TSRMLS_CC)
#define SPL_LIST_CLASSES(z_list, sub, allow, ce_flags)
#define HT_MOVE_TAIL_TO_HEAD(ht)

Functions

static PHP_GINIT_FUNCTION (spl)
static zend_class_entry * spl_find_ce_by_name (char *name, int len, zend_bool autoload TSRMLS_DC)
 PHP_FUNCTION (class_parents)
 PHP_FUNCTION (class_implements)
 PHP_FUNCTION (spl_classes)
static int spl_autoload (const char *class_name, const char *lc_name, int class_name_len, const char *file_extension TSRMLS_DC)
 PHP_FUNCTION (spl_autoload)
 PHP_FUNCTION (spl_autoload_extensions)
static void autoload_func_info_dtor (autoload_func_info *alfi)
 PHP_FUNCTION (spl_autoload_call)
 PHP_FUNCTION (spl_autoload_register)
 PHP_FUNCTION (spl_autoload_unregister)
 PHP_FUNCTION (spl_autoload_functions)
 PHP_FUNCTION (spl_object_hash)
PHPAPI void php_spl_object_hash (zval *obj, char *result TSRMLS_DC)
int spl_build_class_list_string (zval **entry, char **list TSRMLS_DC)
 PHP_MINFO_FUNCTION (spl)
 ZEND_END_ARG_INFO ()
 PHP_MINIT_FUNCTION (spl)
 PHP_RINIT_FUNCTION (spl)
 PHP_RSHUTDOWN_FUNCTION (spl)

Variables

const zend_function_entry spl_functions []
zend_module_entry spl_module_entry

Class Documentation

struct autoload_func_info

Definition at line 363 of file php_spl.c.

Collaboration diagram for autoload_func_info:
Class Members
zend_class_entry * ce
zval * closure
zend_function * func_ptr
zval * obj

Define Documentation

#define HT_MOVE_TAIL_TO_HEAD (   ht)
Value:
(ht)->pListTail->pListNext = (ht)->pListHead;                  \
       (ht)->pListHead = (ht)->pListTail;                                    \
       (ht)->pListTail = (ht)->pListHead->pListLast;                  \
       (ht)->pListHead->pListNext->pListLast = (ht)->pListHead;\
       (ht)->pListTail->pListNext = NULL;                                    \
       (ht)->pListHead->pListLast = NULL;

Definition at line 425 of file php_spl.c.

#define SPL_ADD_CLASS (   class_name,
  z_list,
  sub,
  allow,
  ce_flags 
)    spl_add_classes(spl_ce_ ## class_name, z_list, sub, allow, ce_flags TSRMLS_CC)

Definition at line 153 of file php_spl.c.

#define SPL_DEFAULT_FILE_EXTENSIONS   ".inc,.php"

Definition at line 52 of file php_spl.c.

#define SPL_LIST_CLASSES (   z_list,
  sub,
  allow,
  ce_flags 
)

Definition at line 156 of file php_spl.c.


Function Documentation

static void autoload_func_info_dtor ( autoload_func_info alfi) [static]

Definition at line 370 of file php_spl.c.

{
       if (alfi->obj) {
              zval_ptr_dtor(&alfi->obj);
       }
       if (alfi->closure) {
              zval_ptr_dtor(&alfi->closure);
       }
}

Here is the caller graph for this function:

PHP_FUNCTION ( class_parents  )

Definition at line 92 of file php_spl.c.

{
       zval *obj;
       zend_class_entry *parent_class, *ce;
       zend_bool autoload = 1;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &obj, &autoload) == FAILURE) {
              RETURN_FALSE;
       }
       
       if (Z_TYPE_P(obj) != IS_OBJECT && Z_TYPE_P(obj) != IS_STRING) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "object or string expected");
              RETURN_FALSE;
       }
       
       if (Z_TYPE_P(obj) == IS_STRING) {
              if (NULL == (ce = spl_find_ce_by_name(Z_STRVAL_P(obj), Z_STRLEN_P(obj), autoload TSRMLS_CC))) {
                     RETURN_FALSE;
              }
       } else {
              ce = Z_OBJCE_P(obj);
       }
       
       array_init(return_value);
       parent_class = ce->parent;
       while (parent_class) {
              spl_add_class_name(return_value, parent_class, 0, 0 TSRMLS_CC);
              parent_class = parent_class->parent;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( class_implements  )

Definition at line 126 of file php_spl.c.

{
       zval *obj;
       zend_bool autoload = 1;
       zend_class_entry *ce;
       
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &obj, &autoload) == FAILURE) {
              RETURN_FALSE;
       }
       if (Z_TYPE_P(obj) != IS_OBJECT && Z_TYPE_P(obj) != IS_STRING) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "object or string expected");
              RETURN_FALSE;
       }
       
       if (Z_TYPE_P(obj) == IS_STRING) {
              if (NULL == (ce = spl_find_ce_by_name(Z_STRVAL_P(obj), Z_STRLEN_P(obj), autoload TSRMLS_CC))) {
                     RETURN_FALSE;
              }
       } else {
              ce = Z_OBJCE_P(obj);
       }
       
       array_init(return_value);
       spl_add_interfaces(return_value, ce, 1, ZEND_ACC_INTERFACE TSRMLS_CC);
}

Here is the call graph for this function:

Definition at line 214 of file php_spl.c.

{
       array_init(return_value);
       
       SPL_LIST_CLASSES(return_value, 0, 0, 0)
}

Definition at line 285 of file php_spl.c.

{
       char *class_name, *lc_name, *file_exts = SPL_G(autoload_extensions);
       int class_name_len, file_exts_len = SPL_G(autoload_extensions_len), found = 0;
       char *copy, *pos1, *pos2;
       zval **original_return_value = EG(return_value_ptr_ptr);
       zend_op **original_opline_ptr = EG(opline_ptr);
       zend_op_array *original_active_op_array = EG(active_op_array);
       
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &class_name, &class_name_len, &file_exts, &file_exts_len) == FAILURE) {
              RETURN_FALSE;
       }

       if (file_exts == NULL) { /* autoload_extensions is not intialzed, set to defaults */
              copy = pos1 = estrndup(SPL_DEFAULT_FILE_EXTENSIONS, sizeof(SPL_DEFAULT_FILE_EXTENSIONS)-1);
       } else {
              copy = pos1 = estrndup(file_exts, file_exts_len);
       }
       lc_name = zend_str_tolower_dup(class_name, class_name_len);
       while(pos1 && *pos1 && !EG(exception)) {
              EG(return_value_ptr_ptr) = original_return_value;
              EG(opline_ptr) = original_opline_ptr;
              EG(active_op_array) = original_active_op_array;
              pos2 = strchr(pos1, ',');
              if (pos2) *pos2 = '\0';
              if (spl_autoload(class_name, lc_name, class_name_len, pos1 TSRMLS_CC)) {
                     found = 1;
                     break; /* loaded */
              }
              pos1 = pos2 ? pos2 + 1 : NULL;
       }
       efree(lc_name);
       if (copy) {
              efree(copy);
       }

       EG(return_value_ptr_ptr) = original_return_value;
       EG(opline_ptr) = original_opline_ptr;
       EG(active_op_array) = original_active_op_array;

       if (!found && !SPL_G(autoload_running)) {
              /* For internal errors, we generate E_ERROR, for direct calls an exception is thrown.
               * The "scope" is determined by an opcode, if it is ZEND_FETCH_CLASS we know function was called indirectly by
               * the Zend engine.
               */
              if (active_opline->opcode != ZEND_FETCH_CLASS) {
                     zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Class %s could not be loaded", class_name);
              } else {
                     php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be loaded", class_name);
              }
       }
} /* }}} */

Here is the call graph for this function:

Definition at line 340 of file php_spl.c.

{
       char *file_exts = NULL;
       int file_exts_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &file_exts, &file_exts_len) == FAILURE) {
              return;
       }
       if (file_exts) {
              if (SPL_G(autoload_extensions)) {
                     efree(SPL_G(autoload_extensions));
              }
              SPL_G(autoload_extensions) = estrndup(file_exts, file_exts_len);
              SPL_G(autoload_extensions_len) = file_exts_len;
       }

       if (SPL_G(autoload_extensions) == NULL) {
              RETURN_STRINGL(SPL_DEFAULT_FILE_EXTENSIONS, sizeof(SPL_DEFAULT_FILE_EXTENSIONS) - 1, 1);
       } else {
              RETURN_STRINGL(SPL_G(autoload_extensions), SPL_G(autoload_extensions_len), 1);
       }
} /* }}} */

Here is the call graph for this function:

Definition at line 382 of file php_spl.c.

{
       zval *class_name, *retval = NULL;
       int class_name_len;
       char *func_name, *lc_name;
       uint func_name_len;
       ulong dummy;
       HashPosition function_pos;
       autoload_func_info *alfi;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE || Z_TYPE_P(class_name) != IS_STRING) {
              return;
       }

       if (SPL_G(autoload_functions)) {
              int l_autoload_running = SPL_G(autoload_running);
              SPL_G(autoload_running) = 1;
              class_name_len = Z_STRLEN_P(class_name);
              lc_name = zend_str_tolower_dup(Z_STRVAL_P(class_name), class_name_len);
              zend_hash_internal_pointer_reset_ex(SPL_G(autoload_functions), &function_pos);
              while(zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
                     zend_hash_get_current_key_ex(SPL_G(autoload_functions), &func_name, &func_name_len, &dummy, 0, &function_pos);
                     zend_hash_get_current_data_ex(SPL_G(autoload_functions), (void **) &alfi, &function_pos);
                     zend_call_method(alfi->obj ? &alfi->obj : NULL, alfi->ce, &alfi->func_ptr, func_name, func_name_len, &retval, 1, class_name, NULL TSRMLS_CC);
                     zend_exception_save(TSRMLS_C);
                     if (retval) {
                            zval_ptr_dtor(&retval);
                            retval = NULL;
                     }
                     if (zend_hash_exists(EG(class_table), lc_name, class_name_len + 1)) {
                            break;
                     }
                     zend_hash_move_forward_ex(SPL_G(autoload_functions), &function_pos);
              }
              zend_exception_restore(TSRMLS_C);
              efree(lc_name);
              SPL_G(autoload_running) = l_autoload_running;
       } else {
              /* do not use or overwrite &EG(autoload_func) here */
              zend_call_method_with_1_params(NULL, NULL, NULL, "spl_autoload", NULL, class_name);
       }
} /* }}} */

Here is the call graph for this function:

Definition at line 435 of file php_spl.c.

{
       char *func_name, *error = NULL;
       int  func_name_len;
       char *lc_name = NULL;
       zval *zcallable = NULL;
       zend_bool do_throw = 1;
       zend_bool prepend  = 0;
       zend_function *spl_func_ptr;
       autoload_func_info alfi;
       zval *obj_ptr;
       zend_fcall_info_cache fcc;

       if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|zbb", &zcallable, &do_throw, &prepend) == FAILURE) {
              return;
       }

       if (ZEND_NUM_ARGS()) {
              if (Z_TYPE_P(zcallable) == IS_STRING) {
                     if (Z_STRLEN_P(zcallable) == sizeof("spl_autoload_call") - 1) {
                            if (!zend_binary_strcasecmp(Z_STRVAL_P(zcallable), sizeof("spl_autoload_call"), "spl_autoload_call", sizeof("spl_autoload_call"))) {
                                   if (do_throw) {
                                          zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function spl_autoload_call() cannot be registered");
                                   }
                                   RETURN_FALSE;
                            }
                     }
              }
       
              if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_STRICT, &func_name, &func_name_len, &fcc, &error TSRMLS_CC)) {
                     alfi.ce = fcc.calling_scope;
                     alfi.func_ptr = fcc.function_handler;
                     obj_ptr = fcc.object_ptr;
                     if (Z_TYPE_P(zcallable) == IS_ARRAY) {
                            if (!obj_ptr && alfi.func_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
                                   if (do_throw) {
                                          zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array specifies a non static method but no object (%s)", error);
                                   }
                                   if (error) {
                                          efree(error);
                                   }
                                   efree(func_name);
                                   RETURN_FALSE;
                            }
                            else if (do_throw) {
                                   zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array does not specify %s %smethod (%s)", alfi.func_ptr ? "a callable" : "an existing", !obj_ptr ? "static " : "", error);
                            }
                            if (error) {
                                   efree(error);
                            }
                            efree(func_name);
                            RETURN_FALSE;
                     } else if (Z_TYPE_P(zcallable) == IS_STRING) {
                            if (do_throw) {
                                   zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function '%s' not %s (%s)", func_name, alfi.func_ptr ? "callable" : "found", error);
                            }
                            if (error) {
                                   efree(error);
                            }
                            efree(func_name);
                            RETURN_FALSE;
                     } else {
                            if (do_throw) {
                                   zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Illegal value passed (%s)", error);
                            }
                            if (error) {
                                   efree(error);
                            }
                            efree(func_name);
                            RETURN_FALSE;
                     }
              }
              alfi.closure = NULL;
              alfi.ce = fcc.calling_scope;
              alfi.func_ptr = fcc.function_handler;
              obj_ptr = fcc.object_ptr;
              if (error) {
                     efree(error);
              }
       
              lc_name = safe_emalloc(func_name_len, 1, sizeof(long) + 1);
              zend_str_tolower_copy(lc_name, func_name, func_name_len);
              efree(func_name);

              if (Z_TYPE_P(zcallable) == IS_OBJECT) {
                     alfi.closure = zcallable;
                     Z_ADDREF_P(zcallable);

                     lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
                     memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(zcallable),
                            sizeof(zend_object_handle));
                     func_name_len += sizeof(zend_object_handle);
                     lc_name[func_name_len] = '\0';
              }

              if (SPL_G(autoload_functions) && zend_hash_exists(SPL_G(autoload_functions), (char*)lc_name, func_name_len+1)) {
                     if (alfi.closure) {
                            Z_DELREF_P(zcallable);
                     }
                     goto skip;
              }

              if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
                     /* add object id to the hash to ensure uniqueness, for more reference look at bug #40091 */
                     lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
                     memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_object_handle));
                     func_name_len += sizeof(zend_object_handle);
                     lc_name[func_name_len] = '\0';
                     alfi.obj = obj_ptr;
                     Z_ADDREF_P(alfi.obj);
              } else {
                     alfi.obj = NULL;
              }

              if (!SPL_G(autoload_functions)) {
                     ALLOC_HASHTABLE(SPL_G(autoload_functions));
                     zend_hash_init(SPL_G(autoload_functions), 1, NULL, (dtor_func_t) autoload_func_info_dtor, 0);
              }

              zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &spl_func_ptr);

              if (EG(autoload_func) == spl_func_ptr) { /* registered already, so we insert that first */
                     autoload_func_info spl_alfi;

                     spl_alfi.func_ptr = spl_func_ptr;
                     spl_alfi.obj = NULL;
                     spl_alfi.ce = NULL;
                     spl_alfi.closure = NULL;
                     zend_hash_add(SPL_G(autoload_functions), "spl_autoload", sizeof("spl_autoload"), &spl_alfi, sizeof(autoload_func_info), NULL);
                     if (prepend && SPL_G(autoload_functions)->nNumOfElements > 1) {
                            /* Move the newly created element to the head of the hashtable */
                            HT_MOVE_TAIL_TO_HEAD(SPL_G(autoload_functions));
                     }
              }

              zend_hash_add(SPL_G(autoload_functions), lc_name, func_name_len+1, &alfi.func_ptr, sizeof(autoload_func_info), NULL);
              if (prepend && SPL_G(autoload_functions)->nNumOfElements > 1) {
                     /* Move the newly created element to the head of the hashtable */
                     HT_MOVE_TAIL_TO_HEAD(SPL_G(autoload_functions));
              }
skip:
              efree(lc_name);
       }

       if (SPL_G(autoload_functions)) {
              zend_hash_find(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call"), (void **) &EG(autoload_func));
       } else {
              zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &EG(autoload_func));
       }
       RETURN_TRUE;
} /* }}} */

Here is the call graph for this function:

Definition at line 589 of file php_spl.c.

{
       char *func_name, *error = NULL;
       int func_name_len;
       char *lc_name = NULL;
       zval *zcallable;
       int success = FAILURE;
       zend_function *spl_func_ptr;
       zval *obj_ptr;
       zend_fcall_info_cache fcc;

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

       if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_CHECK_SYNTAX_ONLY, &func_name, &func_name_len, &fcc, &error TSRMLS_CC)) {
              zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Unable to unregister invalid function (%s)", error);
              if (error) {
                     efree(error);
              }
              if (func_name) {
                     efree(func_name);
              }
              RETURN_FALSE;
       }
       obj_ptr = fcc.object_ptr;
       if (error) {
              efree(error);
       }

       lc_name = safe_emalloc(func_name_len, 1, sizeof(long) + 1);
       zend_str_tolower_copy(lc_name, func_name, func_name_len);
       efree(func_name);

       if (Z_TYPE_P(zcallable) == IS_OBJECT) {
              lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
              memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(zcallable),
                     sizeof(zend_object_handle));
              func_name_len += sizeof(zend_object_handle);
              lc_name[func_name_len] = '\0';
       }

       if (SPL_G(autoload_functions)) {
              if (func_name_len == sizeof("spl_autoload_call")-1 && !strcmp(lc_name, "spl_autoload_call")) {
                     /* remove all */
                     zend_hash_destroy(SPL_G(autoload_functions));
                     FREE_HASHTABLE(SPL_G(autoload_functions));
                     SPL_G(autoload_functions) = NULL;
                     EG(autoload_func) = NULL;
                     success = SUCCESS;
              } else {
                     /* remove specific */
                     success = zend_hash_del(SPL_G(autoload_functions), lc_name, func_name_len+1);
                     if (success != SUCCESS && obj_ptr) {
                            lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
                            memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_object_handle));
                            func_name_len += sizeof(zend_object_handle);
                            lc_name[func_name_len] = '\0';
                            success = zend_hash_del(SPL_G(autoload_functions), lc_name, func_name_len+1);
                     }
              }
       } else if (func_name_len == sizeof("spl_autoload")-1 && !strcmp(lc_name, "spl_autoload")) {
              /* register single spl_autoload() */
              zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &spl_func_ptr);

              if (EG(autoload_func) == spl_func_ptr) {
                     success = SUCCESS;
                     EG(autoload_func) = NULL;
              }
       }

       efree(lc_name);
       RETURN_BOOL(success == SUCCESS);
} /* }}} */

Here is the call graph for this function:

Definition at line 666 of file php_spl.c.

{
       zend_function *fptr;
       HashPosition function_pos;
       autoload_func_info *alfi;

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }
       
       if (!EG(autoload_func)) {
              if (zend_hash_find(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME), (void **) &fptr) == SUCCESS) {
                     array_init(return_value);
                     add_next_index_stringl(return_value, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1, 1);
                     return;
              }
              RETURN_FALSE;
       }

       zend_hash_find(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call"), (void **) &fptr);

       if (EG(autoload_func) == fptr) {
              array_init(return_value);
              zend_hash_internal_pointer_reset_ex(SPL_G(autoload_functions), &function_pos);
              while(zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
                     zend_hash_get_current_data_ex(SPL_G(autoload_functions), (void **) &alfi, &function_pos);
                     if (alfi->closure) {
                            Z_ADDREF_P(alfi->closure);
                            add_next_index_zval(return_value, alfi->closure);
                     } else if (alfi->func_ptr->common.scope) {
                            zval *tmp;
                            MAKE_STD_ZVAL(tmp);
                            array_init(tmp);

                            if (alfi->obj) {
                                   Z_ADDREF_P(alfi->obj);
                                   add_next_index_zval(tmp, alfi->obj);
                            } else {
                                   add_next_index_string(tmp, alfi->ce->name, 1);
                            }
                            add_next_index_string(tmp, alfi->func_ptr->common.function_name, 1);
                            add_next_index_zval(return_value, tmp);
                     } else
                            add_next_index_string(return_value, alfi->func_ptr->common.function_name, 1);

                     zend_hash_move_forward_ex(SPL_G(autoload_functions), &function_pos);
              }
              return;
       }

       array_init(return_value);
       add_next_index_string(return_value, EG(autoload_func)->common.function_name, 1);
} /* }}} */

Here is the call graph for this function:

PHP_FUNCTION ( spl_object_hash  )

Definition at line 722 of file php_spl.c.

{
       zval *obj;
       char* hash;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
              return;
       }
       
       hash = emalloc(33);
       php_spl_object_hash(obj, hash TSRMLS_CC);
       
       RETVAL_STRING(hash, 0);
}

Here is the call graph for this function:

static PHP_GINIT_FUNCTION ( spl  ) [static]

Definition at line 56 of file php_spl.c.

{
       spl_globals->autoload_extensions     = NULL;
       spl_globals->autoload_extensions_len = 0;
       spl_globals->autoload_functions      = NULL;
       spl_globals->autoload_running        = 0;
}
PHP_MINFO_FUNCTION ( spl  )

Definition at line 775 of file php_spl.c.

{
       zval list;
       char *strg;

       php_info_print_table_start();
       php_info_print_table_header(2, "SPL support",        "enabled");

       INIT_PZVAL(&list);
       array_init(&list);
       SPL_LIST_CLASSES(&list, 0, 1, ZEND_ACC_INTERFACE)
       strg = estrdup("");
       zend_hash_apply_with_argument(Z_ARRVAL_P(&list), (apply_func_arg_t)spl_build_class_list_string, &strg TSRMLS_CC);
       zval_dtor(&list);
       php_info_print_table_row(2, "Interfaces", strg + 2);
       efree(strg);

       INIT_PZVAL(&list);
       array_init(&list);
       SPL_LIST_CLASSES(&list, 0, -1, ZEND_ACC_INTERFACE)
       strg = estrdup("");
       zend_hash_apply_with_argument(Z_ARRVAL_P(&list), (apply_func_arg_t)spl_build_class_list_string, &strg TSRMLS_CC);
       zval_dtor(&list);
       php_info_print_table_row(2, "Classes", strg + 2);
       efree(strg);

       php_info_print_table_end();
}

Here is the call graph for this function:

PHP_MINIT_FUNCTION ( spl  )
PHP_RINIT_FUNCTION ( spl  )

Definition at line 902 of file php_spl.c.

PHPAPI void php_spl_object_hash ( zval *  obj,
char *result  TSRMLS_DC 
)

Definition at line 738 of file php_spl.c.

{
       intptr_t hash_handle, hash_handlers;
       char *hex;

       if (!SPL_G(hash_mask_init)) {
              if (!BG(mt_rand_is_seeded)) {
                     php_mt_srand(GENERATE_SEED() TSRMLS_CC);
              }

              SPL_G(hash_mask_handle)   = (intptr_t)(php_mt_rand(TSRMLS_C) >> 1);
              SPL_G(hash_mask_handlers) = (intptr_t)(php_mt_rand(TSRMLS_C) >> 1);
              SPL_G(hash_mask_init) = 1;
       }

       hash_handle   = SPL_G(hash_mask_handle)^(intptr_t)Z_OBJ_HANDLE_P(obj);
       hash_handlers = SPL_G(hash_mask_handlers)^(intptr_t)Z_OBJ_HT_P(obj);

       spprintf(&hex, 32, "%016x%016x", hash_handle, hash_handlers);

       strlcpy(result, hex, 33);
       efree(hex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int spl_autoload ( const char *  class_name,
const char *  lc_name,
int  class_name_len,
const char *file_extension  TSRMLS_DC 
) [static]

Definition at line 222 of file php_spl.c.

{
       char *class_file;
       int class_file_len;
       int dummy = 1;
       zend_file_handle file_handle;
       zend_op_array *new_op_array;
       zval *result = NULL;
       int ret;

       class_file_len = spprintf(&class_file, 0, "%s%s", lc_name, file_extension);

#if DEFAULT_SLASH != '\\'
       {
              char *ptr = class_file;
              char *end = ptr + class_file_len;
              
              while ((ptr = memchr(ptr, '\\', (end - ptr))) != NULL) {
                     *ptr = DEFAULT_SLASH;
              }
       }
#endif

       ret = php_stream_open_for_zend_ex(class_file, &file_handle, ENFORCE_SAFE_MODE|USE_PATH|STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);

       if (ret == SUCCESS) {
              if (!file_handle.opened_path) {
                     file_handle.opened_path = estrndup(class_file, class_file_len);
              }
              if (zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
                     new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE TSRMLS_CC);
                     zend_destroy_file_handle(&file_handle TSRMLS_CC);
              } else {
                     new_op_array = NULL;
                     zend_file_handle_dtor(&file_handle TSRMLS_CC);
              }
              if (new_op_array) {
                     EG(return_value_ptr_ptr) = &result;
                     EG(active_op_array) = new_op_array;
                     if (!EG(active_symbol_table)) {
                            zend_rebuild_symbol_table(TSRMLS_C);
                     }

                     zend_execute(new_op_array TSRMLS_CC);
       
                     destroy_op_array(new_op_array TSRMLS_CC);
                     efree(new_op_array);
                     if (!EG(exception)) {
                            if (EG(return_value_ptr_ptr)) {
                                   zval_ptr_dtor(EG(return_value_ptr_ptr));
                            }
                     }

                     efree(class_file);
                     return zend_hash_exists(EG(class_table), (char*)lc_name, class_name_len+1);
              }
       }
       efree(class_file);
       return 0;
} /* }}} */

Here is the call graph for this function:

Here is the caller graph for this function:

int spl_build_class_list_string ( zval **  entry,
char **list  TSRMLS_DC 
)

Definition at line 763 of file php_spl.c.

{
       char *res;
       
       spprintf(&res, 0, "%s, %s", *list, Z_STRVAL_PP(entry));
       efree(*list);
       *list = res;
       return ZEND_HASH_APPLY_KEEP;
} /* }}} */

Here is the call graph for this function:

Here is the caller graph for this function:

static zend_class_entry* spl_find_ce_by_name ( char *  name,
int  len,
zend_bool autoload  TSRMLS_DC 
) [static]

Definition at line 65 of file php_spl.c.

{
       zend_class_entry **ce;
       int found;

       if (!autoload) {
              char *lc_name;
              ALLOCA_FLAG(use_heap)

              lc_name = do_alloca(len + 1, use_heap);
              zend_str_tolower_copy(lc_name, name, len);

              found = zend_hash_find(EG(class_table), lc_name, len +1, (void **) &ce);
              free_alloca(lc_name, use_heap);
       } else {
              found = zend_lookup_class(name, len, &ce TSRMLS_CC);
       }
       if (found != SUCCESS) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class %s does not exist%s", name, autoload ? " and could not be loaded" : "");
              return NULL;
       }
       
       return *ce;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Initial value:

Definition at line 865 of file php_spl.c.

zend_module_entry spl_module_entry
Initial value:

Definition at line 931 of file php_spl.c.