代码拉取完成,页面将自动刷新
同步操作将从 Gitee 极速下载/Yaf 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
/*
+----------------------------------------------------------------------+
| Yet Another Framework |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Xinchen Hui <laruence@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "Zend/zend_interfaces.h" /* for zend_class_serialize_deny */
#include "ext/standard/php_string.h" /* php_trim */
#include "php_yaf.h"
#include "yaf_application.h"
#include "yaf_namespace.h"
#include "yaf_request.h"
#include "yaf_loader.h"
#include "yaf_exception.h"
#define YAF_LOADER_CONTROLLER "Controller"
#define YAF_LOADER_MODEL "Model"
#define YAF_LOADER_PLUGIN "Plugin"
#define YAF_LOADER_RESERVERD "Yaf_"
#define YAF_CLASS_NAME_NORMAL 0
#define YAF_CLASS_NAME_MODEL 1
#define YAF_CLASS_NAME_PLUGIN 2
#define YAF_CLASS_NAME_CONTROLLER 3
zend_class_entry *yaf_loader_ce;
static zend_object_handlers yaf_loader_obj_handlers;
/** {{{ ARG_INFO
*/
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_void_arginfo, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_getinstance_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, local_library_path)
ZEND_ARG_INFO(0, global_library_path)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_autoloader_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, class_name)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_regnamespace_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, namespace)
ZEND_ARG_INFO(0, path)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_islocalname_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, class_name)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_import_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, file)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_setlib_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, library_path)
ZEND_ARG_INFO(0, is_global)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(yaf_loader_getlib_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, is_global)
ZEND_END_ARG_INFO()
/* }}} */
static void yaf_loader_obj_free(zend_object *object) /* {{{ */ {
yaf_loader_object *loader = (yaf_loader_object*)object;
if (loader->library) {
zend_string_release(loader->library);
}
if (loader->glibrary) {
zend_string_release(loader->glibrary);
}
if (GC_DELREF(YAF_LOADER_NAMESPACES(loader)) == 0) {
GC_REMOVE_FROM_BUFFER(YAF_LOADER_NAMESPACES(loader));
zend_array_destroy(YAF_LOADER_NAMESPACES(loader));
}
if (loader->properties) {
if (GC_DELREF(loader->properties) == 0) {
GC_REMOVE_FROM_BUFFER(loader->properties);
zend_array_destroy(loader->properties);
}
}
zend_object_std_dtor(object);
}
/* }}} */
int yaf_loader_register(yaf_loader_t *loader) /* {{{ */ {
zval autoload, function, method, ret;
array_init(&autoload);
ZVAL_STRING(&method, YAF_AUTOLOAD_FUNC_NAME);
Z_ADDREF_P(loader);
zend_hash_next_index_insert(Z_ARRVAL(autoload), loader);
zend_hash_next_index_insert(Z_ARRVAL(autoload), &method);
ZVAL_STRING(&function, YAF_SPL_AUTOLOAD_REGISTER_NAME);
do {
zend_fcall_info fci = {
sizeof(fci),
#if PHP_VERSION_ID < 70100
EG(function_table),
#endif
function,
#if PHP_VERSION_ID < 70100
NULL,
#endif
&ret,
&autoload,
NULL,
1,
#if PHP_VERSION_ID < 80000
1
#else
NULL
#endif
};
if (zend_call_function(&fci, NULL) == FAILURE) {
zval_ptr_dtor(&function);
zval_ptr_dtor(&autoload);
php_error_docref(NULL,
E_WARNING,
"Unable to register autoload function %s",
YAF_AUTOLOAD_FUNC_NAME);
return 0;
}
zval_ptr_dtor(&function);
zval_ptr_dtor(&autoload);
} while (0);
return 1;
}
/* }}} */
void yaf_loader_set_global_library_path(yaf_loader_object *loader, zend_string *global_library) /* {{{ */ {
if (EXPECTED(loader->glibrary)) {
zend_string_release(loader->glibrary);
}
loader->glibrary = zend_string_copy(global_library);
}
/* }}} */
static zend_array *yaf_loader_get_namespaces(yaf_loader_object *loader) /* {{{ */ {
zval *val, rv;
HashTable *ht;
zend_string *name;
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, zend_hash_num_elements(YAF_LOADER_NAMESPACES(loader)), NULL, ZVAL_PTR_DTOR, 0);
ZEND_HASH_FOREACH_STR_KEY_VAL(YAF_LOADER_NAMESPACES(loader), name, val) {
ZEND_ASSERT(name);
if (Z_TYPE_P(val) == IS_NULL) {
ZVAL_STR_COPY(&rv, name);
zend_hash_next_index_insert(ht, &rv);
} else {
zend_hash_update(ht, name, val);
Z_TRY_ADDREF_P(val);
}
} ZEND_HASH_FOREACH_END();
return ht;
}
/* }}} */
static HashTable *yaf_loader_get_properties(yaf_object *obj) /* {{{ */ {
zval rv;
HashTable *ht;
#if PHP_VERSION_ID < 80000
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(obj);
#else
yaf_loader_object *loader = (yaf_loader_object*)(obj);
#endif
if (!loader->properties) {
ALLOC_HASHTABLE(loader->properties);
zend_hash_init(loader->properties, 4, NULL, ZVAL_PTR_DTOR, 0);
YAF_ALLOW_VIOLATION(loader->properties);;
}
ht = loader->properties;
ZVAL_STR_COPY(&rv, loader->library);
zend_hash_str_update(ht, "library:protected", sizeof("library:protected") - 1, &rv);
if (loader->glibrary) {
ZVAL_STR_COPY(&rv, loader->glibrary);
} else {
ZVAL_NULL(&rv);
}
zend_hash_str_update(ht, "global_library:protected", sizeof("global_library:protected") - 1, &rv);
ZVAL_ARR(&rv, yaf_loader_get_namespaces(loader));
zend_hash_str_update(ht, "namespace:protected", sizeof("namespace:protected") - 1, &rv);
ZVAL_BOOL(&rv, yaf_loader_use_spl_autoload(loader));
zend_hash_str_update(ht, "use_spl_autoload:protected", sizeof("use_spl_autoload:protected") - 1, &rv);
ZVAL_BOOL(&rv, yaf_loader_is_lowcase_path(loader));
zend_hash_str_update(ht, "lowercase_path:protected", sizeof("lowercase_path:protected") - 1, &rv);
ZVAL_BOOL(&rv, yaf_loader_is_name_suffix(loader));
zend_hash_str_update(ht, "is_name_suffix:protected", sizeof("is_name_suffix:protected") - 1, &rv);
ZVAL_BOOL(&rv, yaf_loader_has_name_separator(loader));
zend_hash_str_update(ht, "has_name_seperator:protected", sizeof("has_name_seperator:protected") - 1, &rv);
return ht;
}
/* }}} */
void yaf_loader_reset(yaf_loader_object *loader) /* {{{ */ {
/* for back-compatibility of change of YAF_G after loader in initialized only */
YAF_LOADER_FLAGS(loader) = (zend_uchar)YAF_FLAGS();
}
/* }}} */
yaf_loader_t *yaf_loader_instance(zend_string *library_path) /* {{{ */ {
yaf_loader_object *loader;
yaf_loader_t *instance = &YAF_G(loader);
if (EXPECTED(IS_OBJECT == Z_TYPE_P(instance))) {
return instance;
}
loader = emalloc(sizeof(yaf_loader_object));
zend_object_std_init(&loader->std, yaf_loader_ce);
loader->std.handlers = &yaf_loader_obj_handlers;
/* yaf_loader_reset(loader); */
YAF_LOADER_FLAGS(loader) = (zend_uchar)YAF_FLAGS();
if (library_path) {
loader->library = zend_string_copy(library_path);
} else {
loader->library = ZSTR_EMPTY_ALLOC();
}
if (*YAF_G(global_library)) {
loader->glibrary = zend_string_init(YAF_G(global_library), strlen(YAF_G(global_library)), 0);
} else {
loader->glibrary = NULL;
}
ZVAL_OBJ(&YAF_G(loader), &loader->std);
if (UNEXPECTED(!yaf_loader_register(&YAF_G(loader)))) {
php_error_docref(NULL, E_WARNING, "Failed to register autoload function");
}
ALLOC_HASHTABLE(YAF_LOADER_NAMESPACES(loader));
zend_hash_init(YAF_LOADER_NAMESPACES(loader), 8, NULL, ZVAL_PTR_DTOR, 0);
YAF_ALLOW_VIOLATION(YAF_LOADER_NAMESPACES(loader));
loader->properties = NULL;
return &YAF_G(loader);
}
/* }}} */
int yaf_loader_register_namespace(yaf_loader_object *loader, zend_string *class_name, zend_string *path) /* {{{ */ {
zval *entry, rv;
HashTable *target;
char *delim;
char *name = ZSTR_VAL(class_name);
uint32_t len = ZSTR_LEN(class_name);
ZVAL_NULL(&rv);
target = YAF_LOADER_NAMESPACES(loader);
if (*name == '\\') {
name++;
len--;
}
if (((delim = memchr(name, '\\', len)) || (delim = memchr(name, '_', len)))) {
do {
loop:
if ((entry = zend_hash_str_find(target, name, delim - name)) == NULL) {
entry = zend_hash_str_update(target, name, delim - name, &rv);
array_init(entry);
} else if (UNEXPECTED(Z_TYPE_P(entry) != IS_ARRAY)) {
zval_ptr_dtor(entry);
array_init(entry);
}
len -= delim - name + 1;
name = delim + 1;
target = Z_ARRVAL_P(entry);
if (((delim = memchr(name, '\\', len)) || (delim = memchr(name, '_', len)))) {
goto loop;
} else {
entry = zend_hash_str_update(target, name, len, &rv);
}
} while (0);
} else {
entry = zend_hash_str_update(YAF_LOADER_NAMESPACES(loader), name, len, &rv);
}
if (path) {
ZVAL_STR_COPY(entry, path);
}
return 1;
}
/* }}} */
int yaf_loader_register_namespace_multi(yaf_loader_object *loader, zval *namespaces) /* {{{ */ {
zval *pzval;
HashTable *ht;
zend_string *key;
ht = Z_ARRVAL_P(namespaces);
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, pzval) {
if (key == NULL) {
if (IS_STRING == Z_TYPE_P(pzval)) {
yaf_loader_register_namespace(loader, Z_STR_P(pzval), NULL);
}
} else {
if (IS_STRING == Z_TYPE_P(pzval)) {
yaf_loader_register_namespace(loader, key, Z_STR_P(pzval));
} else {
yaf_loader_register_namespace(loader, key, NULL);
}
}
} ZEND_HASH_FOREACH_END();
return 1;
}
/* }}} */
static void yaf_loader_sanitize_path(char *name, uint32_t len) /* {{{ */ {
yaf_replace_chr(name, len, '_', DEFAULT_SLASH);
}
/* }}} */
static void yaf_loader_sanitize_name(char *name, uint32_t len, char *buf) /* {{{ */ {
memcpy(buf, name, len);
/* replace all '\' to '_' */
yaf_replace_chr(buf, len, '\\', '_');
}
/* }}} */
static zend_string *yaf_loader_resolve_namespace(yaf_loader_object *loader, const char *class_name, uint32_t *name_len) /* {{{ */ {
zval *name;
const char *delim;
uint32_t len = *name_len;
HashTable *target = YAF_LOADER_NAMESPACES(loader);
if ((delim = memchr(class_name, '_', len))) {
do {
if ((name = zend_hash_str_find(target, class_name, delim - class_name))) {
if (Z_TYPE_P(name) == IS_ARRAY) {
target = Z_ARRVAL_P(name);
len -= delim - class_name + 1;
class_name = delim + 1;
} else if (Z_TYPE_P(name) == IS_STRING) {
*name_len = (len - (delim - class_name + 1));
return Z_STR_P(name);
} else {
return (zend_string*)-1; /* use library path */
}
} else {
return NULL;
}
} while ((delim = memchr(class_name, '_', len)));
} else if ((name = zend_hash_str_find(target, class_name, len))) {
return Z_TYPE_P(name) == IS_STRING? Z_STR_P(name) : (zend_string*)-1;
}
return NULL;
}
/* }}} */
static int yaf_loader_identify_category(yaf_loader_object *loader, zend_string *class_name) /* {{{ */ {
char *name = ZSTR_VAL(class_name);
size_t len = ZSTR_LEN(class_name);
char *suspense_name;
int suspense_len;
int suspense_type = YAF_CLASS_NAME_NORMAL;
if (EXPECTED(yaf_loader_is_name_suffix(loader))) {
switch (name[len - 1]) {
case 'l':
suspense_name = YAF_LOADER_MODEL;
suspense_len = sizeof(YAF_LOADER_MODEL) - 1;
suspense_type = YAF_CLASS_NAME_MODEL;
break;
case 'n':
suspense_name = YAF_LOADER_PLUGIN;
suspense_len = sizeof(YAF_LOADER_PLUGIN) - 1;
suspense_type = YAF_CLASS_NAME_PLUGIN;
break;
case 'r':
suspense_name = YAF_LOADER_CONTROLLER;
suspense_len = sizeof(YAF_LOADER_CONTROLLER) - 1;
suspense_type = YAF_CLASS_NAME_CONTROLLER;
break;
default:
return YAF_CLASS_NAME_NORMAL;
}
if (len <= suspense_len || !yaf_slip_equal(name + len - suspense_len, suspense_name, suspense_len - 1)) {
return YAF_CLASS_NAME_NORMAL;
}
if (UNEXPECTED(yaf_loader_has_name_separator(loader))) {
name += (len - suspense_len);
if (len > YAF_G(name_separator_len) &&
memcmp(name - YAF_G(name_separator_len), YAF_G(name_separator), YAF_G(name_separator_len)) == 0) {
return suspense_type;
}
return YAF_CLASS_NAME_NORMAL;
}
return suspense_type;
} else {
switch (*name) {
case 'M':
suspense_name = YAF_LOADER_MODEL;
suspense_len = sizeof(YAF_LOADER_MODEL) - 1;
suspense_type = YAF_CLASS_NAME_MODEL;
break;
case 'P':
suspense_name = YAF_LOADER_PLUGIN;
suspense_len = sizeof(YAF_LOADER_PLUGIN) - 1;
suspense_type = YAF_CLASS_NAME_PLUGIN;
break;
case 'C':
suspense_name = YAF_LOADER_CONTROLLER;
suspense_len = sizeof(YAF_LOADER_CONTROLLER) - 1;
suspense_type = YAF_CLASS_NAME_CONTROLLER;
break;
default:
return YAF_CLASS_NAME_NORMAL;
}
if (len <= suspense_len || !yaf_slip_equal(name + 1, suspense_name + 1, suspense_len - 1)) {
return YAF_CLASS_NAME_NORMAL;
}
if (UNEXPECTED(yaf_loader_has_name_separator(loader))) {
name += suspense_len;
if (len > YAF_G(name_separator_len) &&
memcmp(name, YAF_G(name_separator), YAF_G(name_separator_len)) == 0) {
return suspense_type;
}
return YAF_CLASS_NAME_NORMAL;
}
return suspense_type;
}
}
/* }}} */
ZEND_HOT int yaf_loader_import(const char *path, uint32_t len) /* {{{ */ {
zend_file_handle file_handle;
zend_op_array *op_array;
zend_stat_t sb;
if (UNEXPECTED(VCWD_STAT(path, &sb) == -1)) {
return 0;
}
#if PHP_VERSION_ID < 70400
file_handle.filename = path;
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.free_filename = 0;
file_handle.opened_path = NULL;
file_handle.handle.fp = NULL;
#else
/* setup file-handle */
zend_stream_init_filename(&file_handle, path);
#endif
if (EXPECTED((op_array = zend_compile_file(&file_handle, ZEND_INCLUDE)))) {
zval result;
if (EXPECTED(file_handle.handle.stream.handle)) {
if (UNEXPECTED(!file_handle.opened_path)) {
file_handle.opened_path = zend_string_init(path, len, 0);
}
zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);
}
ZVAL_UNDEF(&result);
zend_execute(op_array, &result);
destroy_op_array(op_array);
efree_size(op_array, sizeof(zend_op_array));
zval_ptr_dtor(&result);
zend_destroy_file_handle(&file_handle);
return 1;
}
zend_destroy_file_handle(&file_handle);
return 0;
}
/* }}} */
ZEND_HOT int yaf_loader_load_internal(yaf_loader_object *loader, char *filename, size_t fname_len, char *directory, uint32_t directory_len) /* {{{ */ {
char *ext;
uint32_t ext_len;
yaf_application_object *app = yaf_application_instance();
if (UNEXPECTED(app->ext)) {
ext = ZSTR_VAL(app->ext);
ext_len = ZSTR_LEN(app->ext);
} else {
ext = YAF_DEFAULT_EXT;
ext_len = sizeof(YAF_DEFAULT_EXT) - 1;
}
if (UNEXPECTED((directory_len + fname_len + ext_len + 3) > MAXPATHLEN)) {
directory[directory_len] = '\0';
return 0;
}
directory[directory_len] = DEFAULT_SLASH;
memcpy(directory + directory_len + 1, filename, fname_len);
filename = directory + directory_len + 1;
if (UNEXPECTED(yaf_loader_is_lowcase_path(loader))) {
zend_str_tolower(filename, fname_len);
}
yaf_loader_sanitize_path(filename, fname_len);
directory[directory_len + 1 + fname_len] = '.';
memcpy(directory + directory_len + 1 + fname_len + 1, ext, ext_len);
/* aussume all the path is not end in slash */
directory[directory_len + 1 + fname_len + 1 + ext_len] = '\0';
directory_len = directory_len + 1 + fname_len + 1 + ext_len;
return yaf_loader_import(directory, directory_len);
}
/* }}} */
ZEND_HOT static int yaf_loader_load_user(yaf_loader_object *loader, char *buf, uint32_t len) /* {{{ */ {
zend_string *library_dir;
const char *ext;
char *name = buf;
uint32_t ext_len;
uint32_t origin_len = len;
yaf_application_object *app = yaf_application_instance();
if ((library_dir = yaf_loader_resolve_namespace(loader, buf, &len))) {
if (library_dir == ((zend_string*)-1)) {
library_dir = loader->library;
} else {
name += (origin_len - len);
}
} else {
if (!loader->glibrary) {
library_dir = loader->library;
} else {
library_dir = loader->glibrary;
}
}
if (UNEXPECTED(yaf_loader_is_lowcase_path(loader))) {
zend_str_tolower(name, len);
}
yaf_loader_sanitize_path(name, len);
if (EXPECTED(app) && UNEXPECTED(app->ext)) {
ext = ZSTR_VAL(app->ext);
ext_len = ZSTR_LEN(app->ext);
} else {
ext = YAF_DEFAULT_EXT;
ext_len = sizeof(YAF_DEFAULT_EXT) - 1;
}
ZEND_ASSERT(library_dir);
if (UNEXPECTED(ZSTR_LEN(library_dir) + len + ext_len + 2 > MAXPATHLEN)) {
return 0;
}
memmove(buf + ZSTR_LEN(library_dir) + 1, name, len);
memcpy(buf, ZSTR_VAL(library_dir), ZSTR_LEN(library_dir));
buf[ZSTR_LEN(library_dir)] = DEFAULT_SLASH;
buf[ZSTR_LEN(library_dir) + 1 + len] = '.';
memcpy(buf + ZSTR_LEN(library_dir) + 1 + len + 1, ext, ext_len);
buf[ZSTR_LEN(library_dir) + 1 + len + 1 + ext_len] = '\0';
len = ZSTR_LEN(library_dir) + 1 + len + 1 + ext_len;
return yaf_loader_import(buf, len);
}
/* }}} */
static zend_never_inline int yaf_loader_load_mvc(yaf_loader_object *loader, char *buf, uint32_t len, int type) /* {{{ */ {
char *name;
const char *folder, *ext;
uint32_t folder_len, ext_len;
zend_string *library_dir;
yaf_application_object *app = yaf_application_instance();
if (UNEXPECTED(app == NULL)) {
php_error_docref(NULL, E_WARNING, "Couldn't load a MVC class unless an %s is initialized", ZSTR_VAL(yaf_application_ce->name));
*buf = '\0';
return 0;
}
switch (type) {
case YAF_CLASS_NAME_MODEL:
folder = YAF_MODEL_DIRECTORY_NAME;
folder_len = sizeof(YAF_MODEL_DIRECTORY_NAME) - 1;
break;
case YAF_CLASS_NAME_PLUGIN:
folder = YAF_PLUGIN_DIRECTORY_NAME;
folder_len = sizeof(YAF_PLUGIN_DIRECTORY_NAME) - 1;
break;
case YAF_CLASS_NAME_CONTROLLER:
folder = YAF_CONTROLLER_DIRECTORY_NAME;
folder_len = sizeof(YAF_CONTROLLER_DIRECTORY_NAME) - 1;
break;
default:
ZEND_ASSERT(0);
break;
}
len -= (folder_len - 1); /* models -> model etc*/
if (EXPECTED(yaf_loader_is_name_suffix(loader))) {
name = buf;
if (UNEXPECTED(yaf_loader_has_name_separator(loader))) {
len -= YAF_G(name_separator_len);
}
} else {
name = buf + folder_len - 1;
if (UNEXPECTED(yaf_loader_has_name_separator(loader))) {
name += YAF_G(name_separator_len);
len -= YAF_G(name_separator_len);
}
}
if (UNEXPECTED(yaf_loader_is_lowcase_path(loader))) {
zend_str_tolower(name, len);
}
yaf_loader_sanitize_path(name, len);
if (UNEXPECTED(app->ext)) {
ext = ZSTR_VAL(app->ext);
ext_len = ZSTR_LEN(app->ext);
} else {
ext = YAF_DEFAULT_EXT;
ext_len = sizeof(YAF_DEFAULT_EXT) - 1;
}
if (UNEXPECTED(ZSTR_LEN(app->directory) + 1 + folder_len + 1 + len + 1 + ext_len > MAXPATHLEN)) {
php_error_docref(NULL, E_WARNING, "Path too long '%s'", ZSTR_VAL(app->directory));
*buf = '\0';
return 0;
}
library_dir = app->directory;
memmove(buf + ZSTR_LEN(library_dir) + 1 + folder_len + 1, name, len);
memcpy(buf, ZSTR_VAL(library_dir), ZSTR_LEN(library_dir));
buf[ZSTR_LEN(library_dir)] = DEFAULT_SLASH;
memcpy(buf + ZSTR_LEN(library_dir) + 1, folder, folder_len);
buf[ZSTR_LEN(library_dir) + 1 + folder_len] = DEFAULT_SLASH;
buf[ZSTR_LEN(library_dir) + 1 + folder_len + 1 + len] = '.';
memcpy(buf + ZSTR_LEN(library_dir) + 1 + folder_len + 1 + len + 1, ext, ext_len);
buf[ZSTR_LEN(library_dir) + 1 + folder_len + 1 + len + 1 + ext_len] = '\0';
return yaf_loader_import(buf, len);
}
/* }}} */
/** {{{ proto public Yaf_Loader::autoload($class_name)
*/
PHP_METHOD(yaf_loader, autoload) {
char directory[MAXPATHLEN];
uint32_t class_type, status;
zend_string *class_name;
zend_string *unqualified = NULL;
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(class_name)
ZEND_PARSE_PARAMETERS_END();
if (UNEXPECTED(ZSTR_LEN(class_name) == 0 || ZSTR_LEN(class_name) > MAXPATHLEN)) {
RETURN_FALSE;
}
/*
if (UNEXPECTED(ZSTR_LEN(class_name) >= sizeof(YAF_LOADER_RESERVERD) - 1 &&
yaf_slip_equal(ZSTR_VAL(class_name), YAF_LOADER_RESERVERD, sizeof(YAF_LOADER_RESERVERD) - 1))) {
php_error_docref(NULL, E_WARNING, "You should not use '%s' as class name prefix", YAF_LOADER_RESERVERD);
}
*/
if (ZSTR_VAL(class_name)[0] == '\\') {
unqualified = zend_string_init(ZSTR_VAL(class_name) + 1, ZSTR_LEN(class_name) - 1, 0);
class_name = unqualified;
}
yaf_loader_sanitize_name(ZSTR_VAL(class_name), ZSTR_LEN(class_name), directory);
if ((class_type = yaf_loader_identify_category(loader, class_name)) == YAF_CLASS_NAME_NORMAL) {
status = yaf_loader_load_user(loader, directory, ZSTR_LEN(class_name));
} else {
status = yaf_loader_load_mvc(loader, directory, ZSTR_LEN(class_name), class_type);
}
if (unqualified) {
zend_string_release(unqualified);
}
if (EXPECTED(!yaf_loader_use_spl_autoload(loader))) {
if (EXPECTED(status)) {
zend_string *lc_name = zend_string_tolower(class_name);
if (UNEXPECTED(!zend_hash_exists(EG(class_table), lc_name))) {
php_error_docref(NULL, E_WARNING, "Could not find class %s in %s", ZSTR_VAL(class_name), directory);
}
zend_string_release(lc_name);
} else if (*directory) {
php_error_docref(NULL, E_WARNING, "Failed opening script %s: %s", directory, strerror(errno));
}
RETURN_TRUE;
}
RETURN_BOOL(status);
}
/* }}} */
/** {{{ proto public static Yaf_Loader::import($file)
*/
PHP_METHOD(yaf_loader, import) {
zend_string *file;
int need_free = 0;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(file)
ZEND_PARSE_PARAMETERS_END();
if (ZSTR_LEN(file) == 0) {
RETURN_FALSE;
} else {
int retval;
if (!IS_ABSOLUTE_PATH(ZSTR_VAL(file), ZSTR_LEN(file))) {
if (UNEXPECTED(Z_TYPE(YAF_G(loader)) != IS_OBJECT)) {
php_error_docref(NULL, E_WARNING, "%s need to be initialize first", ZSTR_VAL(yaf_loader_ce->name));
RETURN_FALSE;
} else {
yaf_loader_object *loader = Z_YAFLOADEROBJ(YAF_G(loader));
zend_string *library = loader->library;
file = strpprintf(0, "%s%c%s", ZSTR_VAL(library), DEFAULT_SLASH, ZSTR_VAL(file));
need_free = 1;
}
}
retval = zend_hash_exists(&EG(included_files), file);
if (retval) {
if (need_free) {
zend_string_release(file);
}
RETURN_TRUE;
}
retval = yaf_loader_import(ZSTR_VAL(file), ZSTR_LEN(file));
if (need_free) {
zend_string_release(file);
}
RETURN_BOOL(retval);
}
}
/* }}} */
/** {{{ proto public Yaf_Loader::registerLocalNamespace(mixed $namespace, string $path = NULL)
*/
PHP_METHOD(yaf_loader, registerLocalNamespace) {
zval *namespaces;
zend_string *path = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|S", &namespaces, &path) == FAILURE) {
return;
}
if (IS_STRING == Z_TYPE_P(namespaces)) {
if (yaf_loader_register_namespace(Z_YAFLOADEROBJ_P(getThis()), Z_STR_P(namespaces), path)) {
RETURN_ZVAL(getThis(), 1, 0);
}
} else if (IS_ARRAY == Z_TYPE_P(namespaces)) {
if (yaf_loader_register_namespace_multi(Z_YAFLOADEROBJ_P(getThis()), namespaces)) {
RETURN_ZVAL(getThis(), 1, 0);
}
} else {
php_error_docref(NULL, E_WARNING, "Invalid parameters provided, must be a string, or an array");
}
RETURN_FALSE;
}
/* }}} */
/** {{{ proto public Yaf_Loader::getLocalNamespace(void)
*/
PHP_METHOD(yaf_loader, getLocalNamespace) {
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
ZVAL_ARR(return_value, yaf_loader_get_namespaces(loader));
}
/* }}} */
/** {{{ proto public Yaf_Loader::clearLocalNamespace(void)
*/
PHP_METHOD(yaf_loader, clearLocalNamespace) {
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
}
zend_hash_clean(YAF_LOADER_NAMESPACES(loader));
RETURN_TRUE;
}
/* }}} */
/** {{{ proto public Yaf_Loader::isLocalName(string $class_name)
*/
PHP_METHOD(yaf_loader, isLocalName) {
zend_string *name;
int result;
char *sanitized_name;
uint32_t sanitized_len;
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
ALLOCA_FLAG(use_heap);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
if (ZSTR_VAL(name)[0] == '\\') {
sanitized_len = ZSTR_LEN(name) - 1;
sanitized_name = do_alloca(sanitized_len, use_heap);
yaf_loader_sanitize_name(ZSTR_VAL(name) + 1, sanitized_len, sanitized_name);
} else {
sanitized_len = ZSTR_LEN(name);
sanitized_name = do_alloca(sanitized_len, use_heap);
yaf_loader_sanitize_name(ZSTR_VAL(name), sanitized_len, sanitized_name);
}
result = YAF_LOADER_NAMESPACES(loader) && yaf_loader_resolve_namespace(loader, sanitized_name, &sanitized_len);
free_alloca(sanitized_name, use_heap);
RETURN_BOOL(result);
}
/* }}} */
/** {{{ proto public Yaf_Loader::getNamespacePath(string $class_name)
*/
PHP_METHOD(yaf_loader, getNamespacePath) {
zend_string *name;
zend_string *path;
char *sanitized_name;
uint32_t sanitized_len;
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
ALLOCA_FLAG(use_heap);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
if (ZSTR_VAL(name)[0] == '\\') {
sanitized_len = ZSTR_LEN(name) - 1;
sanitized_name = do_alloca(sanitized_len, use_heap);
yaf_loader_sanitize_name(ZSTR_VAL(name) + 1, sanitized_len, sanitized_name);
} else {
sanitized_len = ZSTR_LEN(name);
sanitized_name = do_alloca(sanitized_len, use_heap);
yaf_loader_sanitize_name(ZSTR_VAL(name), sanitized_len, sanitized_name);
}
if ((path = yaf_loader_resolve_namespace(loader, sanitized_name, &sanitized_len))) {
if (path == ((zend_string*)-1)) {
RETVAL_STR_COPY(loader->library);
} else {
RETVAL_STR_COPY(path);
}
} else {
if (loader->glibrary) {
RETVAL_STR_COPY(loader->glibrary);
} else {
RETVAL_STR_COPY(loader->library);
}
}
free_alloca(sanitized_name, use_heap);
return;
}
/* }}} */
/** {{{ proto public Yaf_Loader::setLibraryPath(string $path, $global = FALSE)
*/
PHP_METHOD(yaf_loader, setLibraryPath) {
zend_string *library;
zend_bool global = 0;
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|b", &library, &global) == FAILURE) {
return;
}
if (!global) {
yaf_loader_set_library_path(loader, library);
} else {
yaf_loader_set_global_library_path(loader, library);
}
RETURN_ZVAL(getThis(), 1, 0);
}
/* }}} */
/** {{{ proto public Yaf_Loader::getLibraryPath($global = FALSE)
*/
PHP_METHOD(yaf_loader, getLibraryPath) {
zend_bool global = 0;
yaf_loader_object *loader = Z_YAFLOADEROBJ_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &global) == FAILURE) {
return;
}
if (!global) {
RETURN_STR_COPY(loader->library);
} else if (loader->glibrary) {
RETURN_STR_COPY(loader->glibrary);
} else {
RETURN_EMPTY_STRING();
}
}
/* }}} */
/** {{{ proto public Yaf_Loader::getInstance($library = NULL, $global_library = NULL)
*/
PHP_METHOD(yaf_loader, getInstance) {
zend_string *library = NULL;
zend_string *global = NULL;
yaf_loader_t *loader;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|S!S!", &library, &global) == FAILURE) {
return;
}
if ((loader = yaf_loader_instance(NULL))) {
if (library) {
yaf_loader_set_library_path(Z_YAFLOADEROBJ_P(loader), library);
}
if (global) {
yaf_loader_set_global_library_path(Z_YAFLOADEROBJ_P(loader), global);
}
/* for back-compatible with changing of YAF_G(lowcase_path) ini_set */
yaf_loader_reset(Z_YAFLOADEROBJ_P(loader));
RETURN_ZVAL(loader, 1, 0);
}
RETURN_FALSE;
}
/* }}} */
/** {{{ proto private Yaf_Loader::__construct(void)
*/
PHP_METHOD(yaf_loader, __construct) {
}
/* }}} */
/** {{{ yaf_loader_methods
*/
zend_function_entry yaf_loader_methods[] = {
PHP_ME(yaf_loader, __construct, yaf_loader_void_arginfo, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
PHP_ME(yaf_loader, autoload, yaf_loader_autoloader_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, getInstance, yaf_loader_getinstance_arginfo, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(yaf_loader, registerLocalNamespace, yaf_loader_regnamespace_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, getLocalNamespace, yaf_loader_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, clearLocalNamespace, yaf_loader_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, isLocalName, yaf_loader_islocalname_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, getNamespacePath, yaf_loader_islocalname_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, import, yaf_loader_import_arginfo, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(yaf_loader, setLibraryPath, yaf_loader_setlib_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_loader, getLibraryPath, yaf_loader_getlib_arginfo, ZEND_ACC_PUBLIC)
PHP_MALIAS(yaf_loader, registerNamespace, registerLocalNamespace, yaf_loader_regnamespace_arginfo, ZEND_ACC_PUBLIC)
PHP_MALIAS(yaf_loader, getNamespaces, getLocalNamespace, yaf_loader_void_arginfo, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* }}} */
/** {{{ YAF_STARTUP_FUNCTION
*/
YAF_STARTUP_FUNCTION(loader) {
zend_class_entry ce;
YAF_INIT_CLASS_ENTRY(ce, "Yaf_Loader", "Yaf\\Loader", yaf_loader_methods);
yaf_loader_ce = zend_register_internal_class_ex(&ce, NULL);
#if PHP_VERSION_ID < 80100
yaf_loader_ce->ce_flags |= ZEND_ACC_FINAL;
yaf_loader_ce->serialize = zend_class_serialize_deny;
yaf_loader_ce->unserialize = zend_class_unserialize_deny;
#else
yaf_loader_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NOT_SERIALIZABLE;
#endif
memcpy(&yaf_loader_obj_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
yaf_loader_obj_handlers.clone_obj = NULL;
yaf_loader_obj_handlers.get_gc = yaf_fake_get_gc;
yaf_loader_obj_handlers.free_obj = yaf_loader_obj_free;
yaf_loader_obj_handlers.get_properties = yaf_loader_get_properties;
return SUCCESS;
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。