自学教程：C++ zend_hash_init函数代码示例

static zend_object_value php_runkit_sandbox_parent_ctor(zend_class_entry *ce){	php_runkit_sandbox_parent_object *objval;	zend_object_value retval;	if (RUNKIT_G(current_sandbox)) {		objval = ecalloc(1, sizeof(php_runkit_sandbox_parent_object));		objval->obj.ce = ce;		objval->self = RUNKIT_G(current_sandbox);	} else {		/* Assign a "blind" stdClass when invoked from the top-scope */		objval = ecalloc(1, sizeof(zend_object));		objval->obj.ce = zend_standard_class_def;	}	ALLOC_HASHTABLE(objval->obj.properties);	zend_hash_init(objval->obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);	retval.handle = zend_objects_store_put(objval, NULL, (zend_objects_free_object_storage_t)php_runkit_sandbox_parent_dtor, NULL);	retval.handlers = RUNKIT_G(current_sandbox) ? &php_runkit_sandbox_parent_handlers : zend_get_std_object_handlers();	return retval;}

void zend_shared_alloc_lock(TSRMLS_D){#ifndef ZEND_WIN32#ifdef ZTS	tsrm_mutex_lock(zts_lock);#endif#if 0	/* this will happen once per process, and will un-globalize mem_write_lock */	if (mem_write_lock.l_pid == -1) {		mem_write_lock.l_pid = getpid();	}#endif	while (1) {		if (fcntl(lock_file, F_SETLKW, &mem_write_lock) == -1) {			if (errno == EINTR) {				continue;			}			zend_accel_error(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);		}		break;	}#else	zend_shared_alloc_lock_win32();#endif	ZCG(locked) = 1;	/* Prepare translation table	 *	 * Make it persistent so that it uses malloc() and allocated blocks	 * won't be taken from space which is freed by efree in memdup.	 * Otherwise it leads to false matches in memdup check.	 */	zend_hash_init(&xlat_table, 100, NULL, NULL, 1);}

void apc_interned_strings_init(TSRMLS_D){    if (APCG(shm_strings_buffer) && APCG(shm_strings_buffer) < APCG(shm_size)) {        int count = APCG(shm_strings_buffer) / (sizeof(Bucket) + sizeof(Bucket*) * 2);        apc_interned_strings_data = (apc_interned_strings_data_t*) apc_sma_malloc(APCG(shm_strings_buffer) TSRMLS_CC);        if (apc_interned_strings_data) {            memset((void *)apc_interned_strings_data, 0, APCG(shm_strings_buffer));            CREATE_LOCK(APCSG(lock));            zend_hash_init(&APCSG(interned_strings), count, NULL, NULL, 1);            APCSG(interned_strings).nTableMask = APCSG(interned_strings).nTableSize - 1;            APCSG(interned_strings).arBuckets = (Bucket**)((char*)apc_interned_strings_data + sizeof(apc_interned_strings_data_t));            APCSG(interned_strings_start) = (char*)APCSG(interned_strings).arBuckets + APCSG(interned_strings).nTableSize * sizeof(Bucket *);            APCSG(interned_strings_end)   = (char*)apc_interned_strings_data + APCG(shm_strings_buffer);            APCSG(interned_strings_top)   = APCSG(interned_strings_start);            old_interned_strings_start = CG(interned_strings_start);            old_interned_strings_end = CG(interned_strings_end);            old_new_interned_string = zend_new_interned_string;            old_interned_strings_snapshot = zend_interned_strings_snapshot;            old_interned_strings_restore = zend_interned_strings_restore;            CG(interned_strings_start) = APCSG(interned_strings_start);            CG(interned_strings_end) = APCSG(interned_strings_end);            zend_new_interned_string = apc_dummy_new_interned_string_for_php;            zend_interned_strings_snapshot = apc_dummy_interned_strings_snapshot_for_php;            zend_interned_strings_restore = apc_dummy_interned_strings_restore_for_php;            apc_copy_internal_strings(TSRMLS_C);        }     } else if (APCG(shm_strings_buffer)) {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "apc.shm_strings_buffer '%ld' exceed apc.shm_size '%ld'", APCG(shm_strings_buffer), APCG(shm_size));    }}

static int lsapi_activate_user_ini_mk_user_config(_lsapi_activate_user_ini_ctx *ctx,                                                  void* next){    fn_activate_user_ini_chain_t *fn_next = next;    /* Find cached config entry: If not found, create one */    ctx->entry = zend_hash_str_find_ptr(&user_config_cache, ctx->path, ctx->path_len);    if (!ctx->entry)    {        ctx->entry = pemalloc(sizeof(user_config_cache_entry), 1);        ctx->entry->expires = 0;        zend_hash_init(&ctx->entry->user_config, 0, NULL,                       config_zval_dtor, 1);        zend_hash_str_update_ptr(&user_config_cache, ctx->path,                                            ctx->path_len, ctx->entry);    }    if (*fn_next) {        return (*fn_next)(ctx, fn_next + 1);    } else {        return SUCCESS;    }}

/* {{{ php_bcompiler_init_globals */static void php_bcompiler_init_globals(zend_bcompiler_globals *bcompiler_globals){#ifdef ZEND_ENGINE_2	HashTable ht;	zend_hash_init(&ht, 0, NULL, (dtor_func_t)&zend_destroy_property_info, 0);	zend_hash_destroy(&ht);	bcompiler_globals->properties_info_destructor = &zend_destroy_property_info;#endif	bcompiler_globals->stream = NULL;	bcompiler_globals->callback = NULL;	bcompiler_globals->callback_value = NULL;	bcompiler_globals->callback_key = "NONE";	bcompiler_globals->current_version = BCOMPILER_CUR_VER;	bcompiler_globals->is_unicode = 0;	bcompiler_globals->current_write   = BCOMPILER_CUR_VER;	bcompiler_globals->current_include = 0;	bcompiler_globals->parsing_error   = 0;	bcompiler_set_stdsize(BCOMPILER_CUR_VER, &(bcompiler_globals->bcompiler_stdsize));	bcompiler_globals->cur_zc = NULL;	bcompiler_globals->current_filename = NULL;	bcompiler_globals->filename_handler = NULL;	bcompiler_globals->filename_handler_name = NULL;}

SAPI_API SAPI_POST_HANDLER_FUNC(suhosin_rfc1867_post_handler) /* {{{ */{	char *boundary, *s = NULL, *boundary_end = NULL, *start_arr = NULL, *array_index = NULL;	char *lbuf = NULL, *abuf = NULL;	zend_string *temp_filename = NULL;	int boundary_len = 0, cancel_upload = 0, is_arr_upload = 0, array_len = 0;	int64_t total_bytes = 0, max_file_size = 0;	int skip_upload = 0, anonindex = 0, is_anonymous;	HashTable *uploaded_files = NULL;	multipart_buffer *mbuff;	zval *array_ptr = (zval *) arg;	int fd = -1;	zend_llist header;	void *event_extra_data = NULL;	unsigned int llen = 0;	int upload_cnt = INI_INT("max_file_uploads");	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();	php_rfc1867_getword_t getword;	php_rfc1867_getword_conf_t getword_conf;	php_rfc1867_basename_t _basename;	zend_long count = 0;	if (php_rfc1867_encoding_translation() && internal_encoding) {		getword = php_rfc1867_getword;		getword_conf = php_rfc1867_getword_conf;		_basename = php_rfc1867_basename;	} else {		getword = php_ap_getword;		getword_conf = php_ap_getword_conf;		_basename = php_ap_basename;	}	if (SG(post_max_size) > 0 && SG(request_info).content_length > SG(post_max_size)) {		sapi_module.sapi_error(E_WARNING, "POST Content-Length of " ZEND_LONG_FMT " bytes exceeds the limit of " ZEND_LONG_FMT " bytes", SG(request_info).content_length, SG(post_max_size));		return;	}	/* Get the boundary */	boundary = strstr(content_type_dup, "boundary");	if (!boundary) {		int content_type_len = (int)strlen(content_type_dup);		char *content_type_lcase = estrndup(content_type_dup, content_type_len);		php_strtolower(content_type_lcase, content_type_len);		boundary = strstr(content_type_lcase, "boundary");		if (boundary) {			boundary = content_type_dup + (boundary - content_type_lcase);		}		efree(content_type_lcase);	}	if (!boundary || !(boundary = strchr(boundary, '='))) {		sapi_module.sapi_error(E_WARNING, "Missing boundary in multipart/form-data POST data");		return;	}	boundary++;	boundary_len = (int)strlen(boundary);	if (boundary[0] == '"') {		boundary++;		boundary_end = strchr(boundary, '"');		if (!boundary_end) {			sapi_module.sapi_error(E_WARNING, "Invalid boundary in multipart/form-data POST data");			return;		}	} else {		/* search for the end of the boundary */		boundary_end = strpbrk(boundary, ",;");	}	if (boundary_end) {		boundary_end[0] = '/0';		boundary_len = boundary_end-boundary;	}	/* Initialize the buffer */	if (!(mbuff = multipart_buffer_new(boundary, boundary_len))) {		sapi_module.sapi_error(E_WARNING, "Unable to initialize the input buffer");		return;	}	/* Initialize $_FILES[] */	zend_hash_init(&PG(rfc1867_protected_variables), 8, NULL, NULL, 0);	ALLOC_HASHTABLE(uploaded_files);	zend_hash_init(uploaded_files, 8, NULL, free_filename, 0);	SG(rfc1867_uploaded_files) = uploaded_files;	if (Z_TYPE(PG(http_globals)[TRACK_VARS_FILES]) != IS_ARRAY) {		/* php_auto_globals_create_files() might have already done that */		array_init(&PG(http_globals)[TRACK_VARS_FILES]);	}	zend_llist_init(&header, sizeof(mime_header_entry), (llist_dtor_func_t) php_free_hdr_entry, 0);	if (php_rfc1867_callback != NULL) {		multipart_event_start event_start;		event_start.content_length = SG(request_info).content_length;		if (php_rfc1867_callback(MULTIPART_EVENT_START, &event_start, &event_extra_data) == FAILURE) {//.........这里部分代码省略.........

void zend_shared_alloc_init_xlat_table(void){	/* Prepare translation table */	zend_hash_init(&ZCG(xlat_table), 128, NULL, NULL, 0);}

ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */{	zend_closure *closure;	object_init_ex(res, zend_ce_closure);	closure = (zend_closure *)Z_OBJ_P(res);	if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {		/* use dummy scope if we're binding an object without specifying a scope */		/* maybe it would be better to create one for this purpose */		scope = zend_ce_closure;	}	if (func->type == ZEND_USER_FUNCTION) {		memcpy(&closure->func, func, sizeof(zend_op_array));		closure->func.common.prototype = (zend_function*)closure;		closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;		if (closure->func.op_array.static_variables) {			HashTable *static_variables = closure->func.op_array.static_variables;			ALLOC_HASHTABLE(closure->func.op_array.static_variables);			zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);			zend_hash_apply_with_arguments(static_variables, zval_copy_static_var, 1, closure->func.op_array.static_variables);		}		if (UNEXPECTED(!closure->func.op_array.run_time_cache)) {			closure->func.op_array.run_time_cache = func->op_array.run_time_cache = zend_arena_alloc(&CG(arena), func->op_array.cache_size);			memset(func->op_array.run_time_cache, 0, func->op_array.cache_size);		}		if (closure->func.op_array.refcount) {			(*closure->func.op_array.refcount)++;		}	} else {		memcpy(&closure->func, func, sizeof(zend_internal_function));		closure->func.common.prototype = (zend_function*)closure;		closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;		/* wrap internal function handler to avoid memory leak */		if (UNEXPECTED(closure->func.internal_function.handler == zend_closure_internal_handler)) {			/* avoid infinity recursion, by taking handler from nested closure */			zend_closure *nested = (zend_closure*)((char*)func - XtOffsetOf(zend_closure, func));			ZEND_ASSERT(nested->std.ce == zend_ce_closure);			closure->orig_internal_handler = nested->orig_internal_handler;		} else {			closure->orig_internal_handler = closure->func.internal_function.handler;		}		closure->func.internal_function.handler = zend_closure_internal_handler;		if (!func->common.scope) {			/* if it's a free function, we won't set scope & this since they're meaningless */			this_ptr = NULL;			scope = NULL;		}	}	ZVAL_UNDEF(&closure->this_ptr);	/* Invariant:	 * If the closure is unscoped or static, it has no bound object. */	closure->func.common.scope = scope;	closure->called_scope = called_scope;	if (scope) {		closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;		if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {			ZVAL_COPY(&closure->this_ptr, this_ptr);		}	}}

//.........这里部分代码省略.........						for (j = 0; j < obj->nodesetval->nodeNr; j++) {							xmlNodePtr node = obj->nodesetval->nodeTab[j];							zval child;							/* not sure, if we need this... it's copied from xpath.c */							if (node->type == XML_NAMESPACE_DECL) {								xmlNsPtr curns;								xmlNodePtr nsparent;								nsparent = node->_private;								curns = xmlNewNs(NULL, node->name, NULL);								if (node->children) {									curns->prefix = xmlStrdup((xmlChar *) node->children);								}								if (node->children) {									node = xmlNewDocNode(node->doc, NULL, (xmlChar *) node->children, node->name);								} else {									node = xmlNewDocNode(node->doc, NULL, (xmlChar *) "xmlns", node->name);								}								node->type = XML_NAMESPACE_DECL;								node->parent = nsparent;								node->ns = curns;							}							php_dom_create_object(node, &child, &intern->dom);							add_next_index_zval(&fci.params[i], &child);						}					}				}				break;			default:			ZVAL_STRING(&fci.params[i], (char *)xmlXPathCastToString(obj));		}		xmlXPathFreeObject(obj);	}	fci.size = sizeof(fci);	fci.function_table = EG(function_table);	obj = valuePop(ctxt);	if (obj->stringval == NULL) {		php_error_docref(NULL, E_WARNING, "Handler name must be a string");		xmlXPathFreeObject(obj);		if (fci.param_count > 0) {			for (i = 0; i < nargs - 1; i++) {				zval_ptr_dtor(&fci.params[i]);			}			efree(fci.params);		}		return;	}	ZVAL_STRING(&fci.function_name, (char *) obj->stringval);	xmlXPathFreeObject(obj);	fci.symbol_table = NULL;	fci.object = NULL;	fci.retval = &retval;	fci.no_separation = 0;	if (!zend_make_callable(&fci.function_name, &callable)) {		php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", callable->val);	} else if (intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {		php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'.", callable->val);		/* Push an empty string, so that we at least have an xslt result... */		valuePush(ctxt, xmlXPathNewString((xmlChar *)""));	} else {		result = zend_call_function(&fci, NULL);		if (result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {			if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {				xmlNode *nodep;				dom_object *obj;				if (intern->node_list == NULL) {					ALLOC_HASHTABLE(intern->node_list);					zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);				}				GC_REFCOUNT(&retval)++;				zend_hash_next_index_insert(intern->node_list, &retval);				obj = Z_DOMOBJ_P(&retval);				nodep = dom_object_get_node(obj);				valuePush(ctxt, xmlXPathNewNodeSet(nodep));			} else if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {				valuePush(ctxt, xmlXPathNewBoolean(Z_TYPE(retval) == IS_TRUE));			} else if (Z_TYPE(retval) == IS_OBJECT) {				php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");				valuePush(ctxt, xmlXPathNewString((xmlChar *)""));			} else {				zend_string *str = zval_get_string(&retval);				valuePush(ctxt, xmlXPathNewString((xmlChar *) str->val));				zend_string_release(str);			}			zval_ptr_dtor(&retval);		}	}	zend_string_release(callable);	zval_dtor(&fci.function_name);	if (fci.param_count > 0) {		for (i = 0; i < nargs - 1; i++) {			zval_ptr_dtor(&fci.params[i]);		}		efree(fci.params);	}}

static int LoadDirectory(HashTable *directories, HKEY key, char *path, int path_len, HashTable *parent_ht){	DWORD keys, values, max_key, max_name, max_value;	int ret = 0;	HashTable *ht = NULL;	if (RegQueryInfoKey(key, NULL, NULL, NULL, &keys, &max_key, NULL, &values, &max_name, &max_value, NULL, NULL) == ERROR_SUCCESS) {		if (values) {			DWORD i;			char *name = (char*)emalloc(max_name+1);			char *value = (char*)emalloc(max_value+1);			DWORD name_len, type, value_len;			for (i = 0; i < values; i++) {				name_len = max_name+1;				value_len = max_value+1;				memset(name, '/0', max_name+1);				memset(value, '/0', max_value+1);				if (RegEnumValue(key, i, name, &name_len, NULL, &type, value, &value_len) == ERROR_SUCCESS) {					if ((type == REG_SZ) || (type == REG_EXPAND_SZ)) {						zval data;						if (!ht) {							ht = (HashTable*)malloc(sizeof(HashTable));							if (!ht) {								return ret;							}							zend_hash_init(ht, 0, NULL, ZVAL_INTERNAL_PTR_DTOR, 1);						}						ZVAL_PSTRINGL(&data, value, value_len-1);						zend_hash_str_update(ht, name, name_len, &data);					}				}			}			if (ht) {				if (parent_ht) {					zend_string *index;					zend_ulong num;					zval *tmpdata;					ZEND_HASH_FOREACH_KEY_VAL(parent_ht, num, index, tmpdata) {						zend_hash_add(ht, index, tmpdata);					} ZEND_HASH_FOREACH_END();				}				zend_hash_str_update_mem(directories, path, path_len, ht, sizeof(HashTable));				ret = 1;			}			efree(name);			efree(value);		}		if (ht == NULL) {			ht = parent_ht;		}		if (keys) {			DWORD i;			char *name = (char*)emalloc(max_key+1);			char *new_path = (char*)emalloc(path_len+max_key+2);			DWORD name_len;			FILETIME t;			HKEY subkey;			for (i = 0; i < keys; i++) {				name_len = max_key+1;				if (RegEnumKeyEx(key, i, name, &name_len, NULL, NULL, NULL, &t) == ERROR_SUCCESS) {					if (RegOpenKeyEx(key, name, 0, KEY_READ, &subkey) == ERROR_SUCCESS) {						if (path_len) {							memcpy(new_path, path, path_len);							new_path[path_len] = '/';							memcpy(new_path+path_len+1, name, name_len+1);							zend_str_tolower(new_path, path_len+name_len+1);							name_len += path_len+1;						} else {							memcpy(new_path, name, name_len+1);							zend_str_tolower(new_path, name_len);						}						if (LoadDirectory(directories, subkey, new_path, name_len, ht)) {							ret = 1;						}						RegCloseKey(subkey);					}				}			}			efree(new_path);			efree(name);		}	}

int php_init_config(char *php_ini_path_override){	char *env_location, *php_ini_search_path;	int safe_mode_state;	char *open_basedir;	int free_ini_search_path=0;	zend_file_handle fh;	PLS_FETCH();	if (zend_hash_init(&configuration_hash, 0, NULL, (dtor_func_t) pvalue_config_destructor, 1)==FAILURE) {		return FAILURE;	}	zend_llist_init(&extension_lists.engine, sizeof(zval), (llist_dtor_func_t) free_estring, 1);	zend_llist_init(&extension_lists.functions, sizeof(zval), (llist_dtor_func_t)  ZVAL_DESTRUCTOR, 1);		safe_mode_state = PG(safe_mode);	open_basedir = PG(open_basedir);	env_location = getenv("PHPRC");	if (!env_location) {		env_location="";	}	if (php_ini_path_override) {		php_ini_search_path = php_ini_path_override;		free_ini_search_path = 0;	} else {		char *default_location;		int free_default_location;#ifdef PHP_WIN32		default_location = (char *) emalloc(512);			if (!GetWindowsDirectory(default_location,255)) {			default_location[0]=0;		}		free_default_location=1;#else		default_location = PHP_CONFIG_FILE_PATH;		free_default_location=0;#endif		php_ini_search_path = (char *) emalloc(sizeof(".")+strlen(env_location)+strlen(default_location)+2+1);		free_ini_search_path = 1;		if(env_location && env_location[0]) {			sprintf(php_ini_search_path, ".%c%s%c%s", ZEND_PATHS_SEPARATOR, env_location, ZEND_PATHS_SEPARATOR, default_location);		} else {			sprintf(php_ini_search_path, ".%c%s", ZEND_PATHS_SEPARATOR, default_location);		}		if (free_default_location) {			efree(default_location);		}	}	PG(safe_mode) = 0;	PG(open_basedir) = NULL;		fh.handle.fp = php_fopen_with_path("php.ini", "r", php_ini_search_path, &php_ini_opened_path);	if (free_ini_search_path) {		efree(php_ini_search_path);	}	PG(safe_mode) = safe_mode_state;	PG(open_basedir) = open_basedir;	if (!fh.handle.fp) {		return SUCCESS;  /* having no configuration file is ok */	}	fh.type = ZEND_HANDLE_FP;	fh.filename = php_ini_opened_path;	zend_parse_ini_file(&fh, 1, php_config_ini_parser_cb, &extension_lists);		if (php_ini_opened_path) {		zval tmp;				tmp.value.str.len = strlen(php_ini_opened_path);		tmp.value.str.val = zend_strndup(php_ini_opened_path, tmp.value.str.len);		tmp.type = IS_STRING;		zend_hash_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path"),(void *) &tmp,sizeof(zval), NULL);		persist_alloc(php_ini_opened_path);	}		return SUCCESS;}

//.........这里部分代码省略.........    switch (Z_TYPE_PP(value))    {        case IS_ARRAY:        {            char *key;            uint key_len;            int key_type;            ulong key_index;            zval **data;            HashPosition pos;            HashTable *ht, *ret;            HashTable *var = NULL;            int num;            ht = HASH_OF(*value);            ret = HASH_OF(return_value);            num = zend_hash_num_elements(ht);            if (num <= 0)            {                zval_ptr_dtor(value);                break;            }            /* string - php_only mode? */            if (ht->nNumOfElements != ht->nNextFreeElement                || ht->nNumOfElements != ret->nNumOfElements)            {                HashTable *properties = NULL;                HashPosition prop_pos;                ALLOC_HASHTABLE(var);                zend_hash_init(var, num, NULL, NULL, 0);                zend_hash_internal_pointer_reset_ex(ht, &pos);                for (;; zend_hash_move_forward_ex(ht, &pos))                {                    key_type = zend_hash_get_current_key_ex(                        ht, &key, &key_len, &key_index, 0, &pos);                    if (key_type == HASH_KEY_NON_EXISTANT)                    {                        break;                    }                    if (zend_hash_get_current_data_ex(                            ht, (void *)&data, &pos) != SUCCESS)                    {                        continue;                    }                    if (key_type == HASH_KEY_IS_STRING)                    {                        zval *val;                        MSGPACK_CONVERT_COPY_ZVAL(val, data);                        if (msgpack_convert_string_to_properties(                                return_value, key, key_len, val, var) != SUCCESS)                        {                            zval_ptr_dtor(&val);                            MSGPACK_WARNING(                                "[msgpack] (%s) "                                "illegal offset type, skip this decoding",                                __FUNCTION__);                        }                    }

static void user_config_cache_init(){    zend_hash_init(&user_config_cache, 0, NULL, user_config_cache_entry_dtor, 1);}

/* {{{ mysqlnd_reverse_api_init */PHPAPI voidmysqlnd_reverse_api_init(TSRMLS_D){	zend_hash_init(&mysqlnd_api_ext_ht, 3, NULL, NULL, 1);}

zval * php_can_strtr_array(char *str, int slen, HashTable *hash){    zval **entry;    char  *string_key;    uint   string_key_len;    zval **trans;    zval   ctmp;    ulong num_key;    int minlen = 128*1024;    int maxlen = 0, pos, len, found;    char *key;    HashPosition hpos;    smart_str result = {0};    HashTable tmp_hash;    zend_hash_init(&tmp_hash, zend_hash_num_elements(hash), NULL, NULL, 0);    zend_hash_internal_pointer_reset_ex(hash, &hpos);    while (zend_hash_get_current_data_ex(hash, (void **)&entry, &hpos) == SUCCESS) {        switch (zend_hash_get_current_key_ex(hash, &string_key, &string_key_len, &num_key, 0, &hpos)) {            case HASH_KEY_IS_STRING:                len = string_key_len-1;                if (len < 1) {                    zend_hash_destroy(&tmp_hash);                    return NULL;                }                zend_hash_add(&tmp_hash, string_key, string_key_len, entry, sizeof(zval*), NULL);                if (len > maxlen) {                    maxlen = len;                }                if (len < minlen) {                    minlen = len;                }                break;            case HASH_KEY_IS_LONG:                Z_TYPE(ctmp) = IS_LONG;                Z_LVAL(ctmp) = num_key;                convert_to_string(&ctmp);                len = Z_STRLEN(ctmp);                zend_hash_add(&tmp_hash, Z_STRVAL(ctmp), len+1, entry, sizeof(zval*), NULL);                zval_dtor(&ctmp);                if (len > maxlen) {                    maxlen = len;                }                if (len < minlen) {                    minlen = len;                }                break;        }        zend_hash_move_forward_ex(hash, &hpos);    }    key = emalloc(maxlen+1);    pos = 0;    while (pos < slen) {        if ((pos + maxlen) > slen) {            maxlen = slen - pos;        }        found = 0;        memcpy(key, str+pos, maxlen);        for (len = maxlen; len >= minlen; len--) {            key[len] = 0;            if (zend_hash_find(&tmp_hash, key, len+1, (void**)&trans) == SUCCESS) {                char *tval;                int tlen;                zval tmp;                if (Z_TYPE_PP(trans) != IS_STRING) {                    tmp = **trans;                    zval_copy_ctor(&tmp);                    convert_to_string(&tmp);                    tval = Z_STRVAL(tmp);                    tlen = Z_STRLEN(tmp);                } else {                    tval = Z_STRVAL_PP(trans);                    tlen = Z_STRLEN_PP(trans);                }                smart_str_appendl(&result, tval, tlen);                pos += len;                found = 1;                if (Z_TYPE_PP(trans) != IS_STRING) {                    zval_dtor(&tmp);                }                break;            }        }        if (! found) {            smart_str_appendc(&result, str[pos++]);        }    }//.........这里部分代码省略.........

zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script, int from_shared_memory){	zend_op_array *op_array;	op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));	*op_array = persistent_script->main_op_array;	if (EXPECTED(from_shared_memory)) {		zend_hash_init(&ZCG(bind_hash), 10, NULL, NULL, 0);		ZCG(current_persistent_script) = persistent_script;		ZCG(arena_mem) = NULL;		if (EXPECTED(persistent_script->arena_size)) {#ifdef __SSE2__			/* Target address must be aligned to 64-byte boundary */			ZCG(arena_mem) = zend_arena_alloc(&CG(arena), persistent_script->arena_size + 64);			ZCG(arena_mem) = (void*)(((zend_uintptr_t)ZCG(arena_mem) + 63L) & ~63L);			fast_memcpy(ZCG(arena_mem), persistent_script->arena_mem, persistent_script->arena_size);#else			ZCG(arena_mem) = zend_arena_alloc(&CG(arena), persistent_script->arena_size);			memcpy(ZCG(arena_mem), persistent_script->arena_mem, persistent_script->arena_size);#endif		}		/* Copy all the necessary stuff from shared memory to regular memory, and protect the shared script */		if (zend_hash_num_elements(&persistent_script->class_table) > 0) {			zend_accel_class_hash_copy(CG(class_table), &persistent_script->class_table, (unique_copy_ctor_func_t) zend_class_copy_ctor);		}		/* we must first to copy all classes and then prepare functions, since functions may try to bind		   classes - which depend on pre-bind class entries existent in the class table */		if (zend_hash_num_elements(&persistent_script->function_table) > 0) {			zend_accel_function_hash_copy_from_shm(CG(function_table), &persistent_script->function_table);		}		/* Register __COMPILER_HALT_OFFSET__ constant */		if (persistent_script->compiler_halt_offset != 0 &&		    persistent_script->full_path) {			zend_string *name;			char haltoff[] = "__COMPILER_HALT_OFFSET__";			name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, persistent_script->full_path->val, persistent_script->full_path->len, 0);			if (!zend_hash_exists(EG(zend_constants), name)) {				zend_register_long_constant(name->val, name->len, persistent_script->compiler_halt_offset, CONST_CS, 0);			}			zend_string_release(name);		}		zend_hash_destroy(&ZCG(bind_hash));		ZCG(current_persistent_script) = NULL;	} else /* if (!from_shared_memory) */ {		if (zend_hash_num_elements(&persistent_script->function_table) > 0) {			zend_accel_function_hash_copy(CG(function_table), &persistent_script->function_table);		}		if (zend_hash_num_elements(&persistent_script->class_table) > 0) {			zend_accel_class_hash_copy(CG(class_table), &persistent_script->class_table, NULL);		}	}	if (op_array->early_binding != (uint32_t)-1) {		zend_string *orig_compiled_filename = CG(compiled_filename);		CG(compiled_filename) = persistent_script->full_path;		zend_do_delayed_early_binding(op_array);		CG(compiled_filename) = orig_compiled_filename;	}	if (UNEXPECTED(!from_shared_memory)) {		free_persistent_script(persistent_script, 0); /* free only hashes */	}	return op_array;}

static HashTable *umsg_parse_format(MessageFormatter_object *mfo,									const MessagePattern& mp,									intl_error& err){	HashTable *ret;	int32_t parts_count;	if (U_FAILURE(err.code)) {		return NULL;	}	if (!((MessageFormat *)mfo->mf_data.umsgf)->usesNamedArguments()) {		return umsg_get_numeric_types(mfo, err);	}	if (mfo->mf_data.arg_types) {		/* already cached */		return mfo->mf_data.arg_types;	}	/* Hash table will store Formattable::Type objects directly,	 * so no need for destructor */	ALLOC_HASHTABLE(ret);	zend_hash_init(ret, 32, NULL, arg_types_dtor, 0);	parts_count = mp.countParts();	// See MessageFormat::cacheExplicitFormats()	/*	 * Looking through the pattern, go to each arg_start part type.	 * The arg-typeof that tells us the argument type (simple, complicated)	 * then the next part is either the arg_name or arg number	 * and then if it's simple after that there could be a part-type=arg-type	 * while substring will tell us number, spellout, etc.	 * If the next thing isn't an arg-type then assume string.	*/	/* The last two "parts" can at most be ARG_LIMIT and MSG_LIMIT	 * which we need not examine. */	for (int32_t i = 0; i < parts_count - 2 && U_SUCCESS(err.code); i++) {		MessagePattern::Part p = mp.getPart(i);		if (p.getType() != UMSGPAT_PART_TYPE_ARG_START) {			continue;		}		MessagePattern::Part name_part = mp.getPart(++i); /* Getting name, advancing i */		Formattable::Type type,						  *storedType;		if (name_part.getType() == UMSGPAT_PART_TYPE_ARG_NAME) {			UnicodeString argName = mp.getSubstring(name_part);			if ((storedType = (Formattable::Type*)zend_hash_str_find_ptr(ret, (char*)argName.getBuffer(), argName.length())) == NULL) {				/* not found already; create new entry in HT */				Formattable::Type bogusType = Formattable::kObject;				if ((storedType = (Formattable::Type*)zend_hash_str_update_mem(ret, (char*)argName.getBuffer(), argName.length(),						(void*)&bogusType, sizeof(bogusType))) == NULL) {					intl_errors_set(&err, U_MEMORY_ALLOCATION_ERROR,						"Write to argument types hash table failed", 0);					continue;				}			}		} else if (name_part.getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) {			int32_t argNumber = name_part.getValue();			if (argNumber < 0) {				intl_errors_set(&err, U_INVALID_FORMAT_ERROR,					"Found part with negative number", 0);				continue;			}			if ((storedType = (Formattable::Type*)zend_hash_index_find_ptr(ret, (zend_ulong)argNumber)) == NULL) {				/* not found already; create new entry in HT */				Formattable::Type bogusType = Formattable::kObject;				if ((storedType = (Formattable::Type*)zend_hash_index_update_mem(ret, (zend_ulong)argNumber, (void*)&bogusType, sizeof(bogusType))) == NULL) {					intl_errors_set(&err, U_MEMORY_ALLOCATION_ERROR,						"Write to argument types hash table failed", 0);					continue;				}			}		} else {			intl_errors_set(&err, U_INVALID_FORMAT_ERROR, "Invalid part type encountered", 0);			continue;		}		UMessagePatternArgType argType = p.getArgType();		/* No type specified, treat it as a string */		if (argType == UMSGPAT_ARG_TYPE_NONE) {			type = Formattable::kString;		} else { /* Some type was specified, might be simple or complicated */			if (argType == UMSGPAT_ARG_TYPE_SIMPLE) {				/* For a SIMPLE arg, after the name part, there should be				 * an ARG_TYPE part whose string value tells us what to do */				MessagePattern::Part type_part = mp.getPart(++i); /* Getting type, advancing i */				if (type_part.getType() == UMSGPAT_PART_TYPE_ARG_TYPE) {					UnicodeString typeString = mp.getSubstring(type_part);					/* This is all based on the rules in the docs for MessageFormat					 * @see http://icu-project.org/apiref/icu4c/classMessageFormat.html */					if (typeString == "number") {						MessagePattern::Part style_part = mp.getPart(i + 1); /* Not advancing i */						if (style_part.getType() == UMSGPAT_PART_TYPE_ARG_STYLE) {							UnicodeString styleString = mp.getSubstring(style_part);							if (styleString == "integer") {//.........这里部分代码省略.........

static phpdbg_watchpoint_t *phpdbg_create_watchpoint(phpdbg_watchpoint_t *watch) {	phpdbg_watchpoint_t *ret = watch;	/* exclude references & refcounted */	if (!watch->parent || watch->parent->type != WATCH_ON_ZVAL || watch->type == WATCH_ON_HASHTABLE) {		phpdbg_watchpoint_t *old_watch = zend_hash_find_ptr(&PHPDBG_G(watchpoints), watch->str);		if (old_watch) {#define return_and_free_watch(x) { /	phpdbg_watchpoint_t *ref = phpdbg_get_refcount_watch(old_watch); /	if (ref) { /		phpdbg_add_watch_collision(ref); /	} /	if (watch != old_watch) { /		phpdbg_free_watch(watch); /		efree(watch); /	} /	return (x); /}			if (watch->flags & PHPDBG_WATCH_RECURSIVE) {				if (old_watch->flags & PHPDBG_WATCH_RECURSIVE) {					return_and_free_watch(NULL);				} else {					old_watch->flags &= ~(PHPDBG_WATCH_SIMPLE | PHPDBG_WATCH_IMPLICIT);					old_watch->flags |= PHPDBG_WATCH_RECURSIVE;					return_and_free_watch(old_watch);				}			} else {				if (!(old_watch->flags & PHPDBG_WATCH_RECURSIVE)) {					old_watch->flags |= watch->flags & (PHPDBG_WATCH_IMPLICIT | PHPDBG_WATCH_SIMPLE);				}				return_and_free_watch(NULL);			}		} else {			if (watch->parent && watch->parent->type == WATCH_ON_HASHTABLE) {				watch->parent->implicit_ht_count++;			}			zend_hash_add_ptr(&PHPDBG_G(watchpoints), watch->str, watch);		}	}	phpdbg_store_watchpoint(watch);	if (watch->parent && watch->parent->type == WATCH_ON_ZVAL && Z_REFCOUNTED_P(watch->parent->addr.zv)) {		phpdbg_add_watch_collision(phpdbg_create_refcounted_watchpoint(watch, Z_COUNTED_P(watch->parent->addr.zv)));	}	if (watch->type == WATCH_ON_ZVAL) {		if (watch->parent_container) {			HashTable *ht_watches;			phpdbg_btree_result *find;			if (!(find = phpdbg_btree_find(&PHPDBG_G(watch_HashTables), (zend_ulong) watch->parent_container))) {				phpdbg_watch_ht_info *hti = emalloc(sizeof(*hti));				hti->dtor = watch->parent_container->pDestructor;				ht_watches = &hti->watches;				zend_hash_init(ht_watches, 0, grrrrr, ZVAL_PTR_DTOR, 0);				phpdbg_btree_insert(&PHPDBG_G(watch_HashTables), (zend_ulong) watch->parent_container, hti);				watch->parent_container->pDestructor = (dtor_func_t) phpdbg_watch_HashTable_dtor;			} else {				ht_watches = &((phpdbg_watch_ht_info *) find->ptr)->watches;			}			zend_hash_add_ptr(ht_watches, watch->name_in_parent, watch);		}		if (Z_ISREF_P(watch->addr.zv)) {			ret = phpdbg_create_reference_watch(watch);		}	}	phpdbg_activate_watchpoint(watch);	return ret;}

/* Must prevent duplicates ... if there are duplicates, replace new by old! */static void phpdbg_add_watch_collision(phpdbg_watchpoint_t *watch) {	phpdbg_watch_collision *cur;	/* Check for either recursive or (simple and/or implicit) */	ZEND_ASSERT(((watch->flags & PHPDBG_WATCH_RECURSIVE) == 0) ^ ((watch->flags & (PHPDBG_WATCH_IMPLICIT | PHPDBG_WATCH_SIMPLE)) == 0));	if ((cur = zend_hash_index_find_ptr(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref))) {		phpdbg_watchpoint_t *old;		int flags = 0;		if ((old = zend_hash_find_ptr(&cur->watches, watch->str)) || (old = zend_hash_find_ptr(&cur->implicit_watches, watch->str))) {			if (((old->flags ^ watch->flags) & (PHPDBG_WATCH_NORMAL|PHPDBG_WATCH_IMPLICIT)) == 0) {				return; /* there was no change ... */			}			flags = old->flags;			if (flags & PHPDBG_WATCH_RECURSIVE) {				if (!(watch->flags & PHPDBG_WATCH_RECURSIVE) && !--cur->refs) {					phpdbg_delete_watchpoints_recursive(watch);				}			}			if (flags & PHPDBG_WATCH_NORMAL) {				zend_hash_del(&cur->watches, watch->str);				if (zend_hash_num_elements(&cur->watches) > 0) {					cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->watches, NULL));				} else {					cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->implicit_watches, NULL));				}			}			if (flags & PHPDBG_WATCH_IMPLICIT) {				zend_hash_del(&cur->implicit_watches, watch->str);			}			old->flags = watch->flags;			phpdbg_free_watch(watch);			efree(watch);			watch = old;		}		if (watch->flags & PHPDBG_WATCH_RECURSIVE) {			if (!(flags & PHPDBG_WATCH_RECURSIVE) && !cur->refs++) {				phpdbg_create_recursive_zval_watch(watch->parent);			}		}	} else {		phpdbg_watch_collision coll;		coll.refs = (watch->flags & PHPDBG_WATCH_RECURSIVE) != 0;		coll.watch = watch;		zend_hash_init(&coll.watches, 8, arghs, NULL, 0);		zend_hash_init(&coll.implicit_watches, 8, ..., NULL, 0);		cur = zend_hash_index_add_mem(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref, &coll, sizeof(phpdbg_watch_collision));		phpdbg_store_watchpoint(cur->watch);		phpdbg_activate_watchpoint(cur->watch);		if (coll.refs) {			phpdbg_create_recursive_zval_watch(watch->parent);		}	}	if (watch->flags & PHPDBG_WATCH_NORMAL) {		cur->watch = watch;		zend_hash_add_ptr(&cur->watches, watch->str, watch->parent);	}	if (watch->flags & PHPDBG_WATCH_IMPLICIT) {		zend_hash_add_ptr(&cur->implicit_watches, watch->str, watch->parent);	}}

static void zend_init_interned_strings_ht(HashTable *interned_strings, int permanent){	zend_hash_init(interned_strings, 1024, NULL, _str_dtor, permanent);	zend_hash_real_init(interned_strings, 0);}

//.........这里部分代码省略.........								node->ns = curns;							} else {								node = xmlDocCopyNodeList(domintern->document->ptr, node);							}							php_dom_create_object(node, &child, domintern);							add_next_index_zval(&args[i], &child);						}					}				}				break;			default:				str = (char *) xmlXPathCastToString(obj);				ZVAL_STRING(&args[i], str);				xmlFree(str);		}		xmlXPathFreeObject(obj);	}	fci.size = sizeof(fci);	fci.function_table = EG(function_table);	if (fci.param_count > 0) {		fci.params = args;	} else {		fci.params = NULL;	}	obj = valuePop(ctxt);	if (obj->stringval == NULL) {		php_error_docref(NULL, E_WARNING, "Handler name must be a string");		xmlXPathFreeObject(obj);		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));		if (fci.param_count > 0) {			for (i = 0; i < nargs - 1; i++) {				zval_ptr_dtor(&args[i]);			}			efree(args);		}		return;	}	ZVAL_STRING(&handler, (char *) obj->stringval);	xmlXPathFreeObject(obj);	ZVAL_COPY_VALUE(&fci.function_name, &handler);	fci.symbol_table = NULL;	fci.object = NULL;	fci.retval = &retval;	fci.no_separation = 0;	/*fci.function_handler_cache = &function_ptr;*/	if (!zend_make_callable(&handler, &callable)) {		php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", ZSTR_VAL(callable));		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));	} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {		php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'", ZSTR_VAL(callable));		/* Push an empty string, so that we at least have an xslt result... */		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));	} else {		result = zend_call_function(&fci, NULL);		if (result == FAILURE) {			if (Z_TYPE(handler) == IS_STRING) {				php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", Z_STRVAL(handler));				valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));			}		/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */		} else if (Z_ISUNDEF(retval)) {		} else {			if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {				xmlNode *nodep;				dom_object *obj;				if (intern->node_list == NULL) {					ALLOC_HASHTABLE(intern->node_list);					zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);				}				Z_ADDREF(retval);				zend_hash_next_index_insert(intern->node_list, &retval);				obj = Z_DOMOBJ_P(&retval);				nodep = dom_object_get_node(obj);				valuePush(ctxt, xmlXPathNewNodeSet(nodep));			} else if (Z_TYPE(retval) == IS_TRUE || Z_TYPE(retval) == IS_FALSE) {				valuePush(ctxt, xmlXPathNewBoolean(Z_LVAL(retval)));			} else if (Z_TYPE(retval) == IS_OBJECT) {				php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");				valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));			} else {				convert_to_string_ex(&retval);				valuePush(ctxt, xmlXPathNewString((xmlChar *) Z_STRVAL(retval)));			}			zval_ptr_dtor(&retval);		}	}	zend_string_release(callable);	zval_ptr_dtor(&handler);	if (fci.param_count > 0) {		for (i = 0; i < nargs - 1; i++) {			zval_ptr_dtor(&args[i]);		}		efree(args);	}}

//.........这里部分代码省略.........			t = plc->pos - ptr;			if (t) {				memcpy(newbuffer, ptr, t);				newbuffer += t;			}			memcpy(newbuffer, plc->quoted, plc->qlen);			newbuffer += plc->qlen;			ptr = plc->pos + plc->len;			plc = plc->next;		} while (plc);		t = (inquery + inquery_len) - ptr;		if (t) {			memcpy(newbuffer, ptr, t);			newbuffer += t;		}		*newbuffer = '/0';		*outquery_len = newbuffer - *outquery;		ret = 1;		goto clean_up;	} else if (query_type == PDO_PLACEHOLDER_POSITIONAL) {		/* rewrite ? to :pdoX */		char *name, *idxbuf;		const char *tmpl = stmt->named_rewrite_template ? stmt->named_rewrite_template : ":pdo%d";		int bind_no = 1;		newbuffer_len = inquery_len;		if (stmt->bound_param_map == NULL) {			ALLOC_HASHTABLE(stmt->bound_param_map);			zend_hash_init(stmt->bound_param_map, 13, NULL, free_param_name, 0);		}		for (plc = placeholders; plc; plc = plc->next) {			int skip_map = 0;			char *p;			name = estrndup(plc->pos, plc->len);			/* check if bound parameter is already available */			if (!strcmp(name, "?") || (p = zend_hash_str_find_ptr(stmt->bound_param_map, name, plc->len)) == NULL) {				spprintf(&idxbuf, 0, tmpl, bind_no++);			} else {				idxbuf = estrdup(p);				skip_map = 1;			}			plc->quoted = idxbuf;			plc->qlen = strlen(plc->quoted);			plc->freeq = 1;			newbuffer_len += plc->qlen;			if (!skip_map && stmt->named_rewrite_template) {				/* create a mapping */				zend_hash_str_update_mem(stmt->bound_param_map, name, plc->len, idxbuf, plc->qlen + 1);			}			/* map number to name */			zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1);			efree(name);		}		goto rewrite;

/* ArchiveWriter::__construct {{{ **/ZEND_METHOD(ArchiveWriter, __construct){	archive_file_t *arch = NULL;	int resource_id;	zval *this = getThis();	const char *error_string = NULL;	char *filename;	long error_num, filename_len, result, format=0, compression=0;	zend_error_handling error_handling;	zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC);	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &filename, &filename_len, &format, &compression) == FAILURE) {		zend_restore_error_handling(&error_handling TSRMLS_CC);		return;	}#if PHP_API_VERSION < 20100412	if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {		zend_restore_error_handling(&error_handling TSRMLS_CC);		return;	}#endif	if (php_check_open_basedir(filename TSRMLS_CC)) {		zend_restore_error_handling(&error_handling TSRMLS_CC);		return;	}	arch = (archive_file_t *) emalloc(sizeof(archive_file_t));	arch->stream = NULL;	ALLOC_HASHTABLE(arch->entries);	zend_hash_init(arch->entries, 10, NULL, _archive_entries_hash_dtor, 0);	arch->mode = PHP_ARCHIVE_WRITE_MODE;	arch->buf = emalloc(PHP_ARCHIVE_BUF_LEN + 1);	arch->filename = estrndup(filename, filename_len);	arch->arch = archive_write_new();	switch (compression) {		case PHP_ARCHIVE_COMPRESSION_GZIP:			if (archive_write_add_filter_gzip(arch->arch) != ARCHIVE_OK) {				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gzip compression is not supported in this build");				zend_restore_error_handling(&error_handling TSRMLS_CC);				return;			}			break;		case PHP_ARCHIVE_COMPRESSION_BZIP2:			if (archive_write_add_filter_bzip2(arch->arch) != ARCHIVE_OK) {				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bzip2 compression is not supported in this build");				zend_restore_error_handling(&error_handling TSRMLS_CC);				return;			}			break;		case 0: /* default value */		case PHP_ARCHIVE_COMPRESSION_NONE:			/* always supported */			break;		default:			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported compression type %ld", compression);			zend_restore_error_handling(&error_handling TSRMLS_CC);			return;			break;	}	switch (format) {		case 0: /* default value */		case PHP_ARCHIVE_FORMAT_TAR:		case PHP_ARCHIVE_FORMAT_PAX_RESTRICTED:			archive_write_set_format_pax_restricted(arch->arch);			break;		case PHP_ARCHIVE_FORMAT_PAX:			archive_write_set_format_pax(arch->arch);			break;		case PHP_ARCHIVE_FORMAT_CPIO:			archive_write_set_format_cpio(arch->arch);			break;		case PHP_ARCHIVE_FORMAT_SHAR:			archive_write_set_format_shar(arch->arch);			break;		case PHP_ARCHIVE_FORMAT_USTAR:			archive_write_set_format_ustar(arch->arch);			break;		default:			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported archive format: %ld", format);			zend_restore_error_handling(&error_handling TSRMLS_CC);			return;			break;	}	archive_write_set_bytes_per_block(arch->arch, DEFAULT_BYTES_PER_BLOCK);	result = archive_write_open(arch->arch, arch, _archive_open_clbk, _archive_write_clbk, _archive_close_clbk);	/* do not pad the last block */	archive_write_set_bytes_in_last_block(arch->arch, 1);//.........这里部分代码省略.........

int fcnotify_initialize(fcnotify_context * pnotify, unsigned short islocal, void * paplist, alloc_context * palloc, unsigned int filecount TSRMLS_DC){    int               result   = NONFATAL;    unsigned short    locktype = LOCK_TYPE_SHARED;    fcnotify_header * header   = NULL;    unsigned int      msize    = 0;    _ASSERT(pnotify != NULL);    _ASSERT(paplist != NULL);    _ASSERT(palloc  != NULL);    _ASSERT(palloc->memaddr != NULL);    if(islocal)    {        locktype = LOCK_TYPE_LOCAL;        pnotify->islocal = islocal;    }    pnotify->islocal   = islocal;    pnotify->fcaplist  = paplist;    pnotify->fcalloc   = palloc;    pnotify->processid = WCG(fmapgdata)->pid;    pnotify->fcmemaddr = palloc->memaddr;    pnotify->lscavenge = GetTickCount();    /* Get memory for fcnotify header */    msize = sizeof(fcnotify_header) + (filecount - 1) * sizeof(size_t);    pnotify->fcheader = (fcnotify_header *)alloc_get_cacheheader(pnotify->fcalloc, msize, CACHE_TYPE_FCNOTIFY);    if(pnotify->fcheader == NULL)    {        result = FATAL_FCNOTIFY_INITIALIZE;        goto Finished;    }    header = pnotify->fcheader;     /* Create reader writer lock for the file change notification hashtable */    result = lock_create(&pnotify->fclock);    if(FAILED(result))    {        goto Finished;    }    result = lock_initialize(pnotify->fclock, "FILE_CHANGE_NOTIFY", 1, locktype, LOCK_USET_SREAD_XWRITE, &header->rdcount TSRMLS_CC);    if(FAILED(result))    {        goto Finished;    }    /* Create IO completion port */    pnotify->port_handle = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)0, 0);    if(pnotify->port_handle == NULL)    {        result = FATAL_FCNOTIFY_INITIALIZE;        goto Finished;    }    /* Create listener thread */    pnotify->listen_thread = CreateThread(NULL, 0, change_notification_thread, (void *)pnotify, 0, NULL);    if(pnotify->listen_thread == NULL)    {        result = FATAL_FCNOTIFY_INITIALIZE;        goto Finished;    }    /* Create pidhandles hashtable */    pnotify->pidhandles = (HashTable *)alloc_pemalloc(sizeof(HashTable));    if(pnotify->pidhandles == NULL)    {        result = FATAL_OUT_OF_LMEMORY;        goto Finished;    }    zend_hash_init(pnotify->pidhandles, 0, NULL, NULL, 1);Finished:    if(FAILED(result))    {        dprintimportant("failure %d in fcnotify_initialize", result);        _ASSERT(result > WARNING_COMMON_BASE);        if(pnotify->listen_thread != NULL)        {            CloseHandle(pnotify->listen_thread);            pnotify->listen_thread = NULL;        }        if(pnotify->port_handle != NULL)        {            CloseHandle(pnotify->port_handle);            pnotify->port_handle = NULL;        }        if(pnotify->fclock != NULL)        {            lock_terminate(pnotify->fclock);            lock_destroy(pnotify->fclock);//.........这里部分代码省略.........

static PHP_RINIT_FUNCTION(phpdbg) /* {{{ */{	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE],   8, NULL, php_phpdbg_destroy_bp_file, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], 8, NULL, php_phpdbg_destroy_bp_symbol, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], 8, NULL, php_phpdbg_destroy_bp_methods, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], 8, NULL, NULL, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], 8, NULL, php_phpdbg_destroy_bp_opcode, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], 8, NULL, php_phpdbg_destroy_bp_methods, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], 8, NULL, php_phpdbg_destroy_bp_condition, 0);	zend_hash_init(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], 8, NULL, NULL, 0);	zend_hash_init(&PHPDBG_G(seek), 8, NULL, NULL, 0);	zend_hash_init(&PHPDBG_G(registered), 8, NULL, php_phpdbg_destroy_registered, 0);	return SUCCESS;} /* }}} */

//.........这里部分代码省略.........					if (opline->op1_type == IS_CONST) {						LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1);					}					if (opline->op2_type == IS_CONST) {						LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1);					}					break;			}			opline++;		}#if DEBUG_COMPACT_LITERALS		{			int i, use_copy;			fprintf(stderr, "File %s func %s/n", op_array->filename->val,					op_array->function_name ? op_array->function_name->val : "main");			fprintf(stderr, "Literlas table size %d/n", op_array->last_literal);			for (i = 0; i < op_array->last_literal; i++) {				zval zv;				ZVAL_COPY_VALUE(&zv, op_array->literals + i);				use_copy = zend_make_printable_zval(op_array->literals + i, &zv);				fprintf(stderr, "Literal %d, val (%d):%s/n", i, Z_STRLEN(zv), Z_STRVAL(zv));				if (use_copy) {					zval_ptr_dtor_nogc(&zv);				}			}			fflush(stderr);		}#endif		/* Merge equal constants */		j = 0;		zend_hash_init(&hash, op_array->last_literal, NULL, NULL, 0);		map = (int*)zend_arena_alloc(&ctx->arena, op_array->last_literal * sizeof(int));		memset(map, 0, op_array->last_literal * sizeof(int));		for (i = 0; i < op_array->last_literal; i++) {			if (!info[i].flags) {				/* unset literal */				zval_ptr_dtor_nogc(&op_array->literals[i]);				continue;			}			switch (Z_TYPE(op_array->literals[i])) {				case IS_NULL:					if (l_null < 0) {						l_null = j;						if (i != j) {							op_array->literals[j] = op_array->literals[i];							info[j] = info[i];						}						j++;					}					map[i] = l_null;					break;				case IS_FALSE:					if (l_false < 0) {						l_false = j;						if (i != j) {							op_array->literals[j] = op_array->literals[i];							info[j] = info[i];						}						j++;					}					map[i] = l_false;					break;				case IS_TRUE:

PHP_METHOD(air_view, render){	AIR_INIT_THIS;	char *tpl_str;	int tpl_len = 0;	zend_bool ret_res = 0;	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sb", &tpl_str, &tpl_len, &ret_res) == FAILURE)	{		RETURN_FALSE;	}	smart_str ss_path = {0};	if(tpl_str[0] != '/'){		zval *root_path = NULL;		MAKE_STD_ZVAL(root_path);		if(zend_get_constant(ZEND_STRL("ROOT_PATH"), root_path) == FAILURE){			php_error_docref(NULL TSRMLS_CC, E_ERROR,  "ROOT_PATH not defined");		}		smart_str_appendl(&ss_path, Z_STRVAL_P(root_path), Z_STRLEN_P(root_path));		smart_str_appendc(&ss_path, '/');		if(root_path != NULL){			zval_ptr_dtor(&root_path);		}		zval *tmp = NULL;		zval **tmp_pp;		zval *config = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_config"), 0 TSRMLS_CC);		if(config != NULL && Z_TYPE_P(config) == IS_ARRAY				&& zend_hash_find(Z_ARRVAL_P(config), ZEND_STRL("path"), (void **)&tmp_pp) == SUCCESS){			smart_str_appendl(&ss_path, Z_STRVAL_PP(tmp_pp), Z_STRLEN_PP(tmp_pp));		}else{			zval *app_conf;			zval *view_conf;			if(air_config_get(NULL, ZEND_STRS("app"), &app_conf TSRMLS_CC) == FAILURE){				AIR_NEW_EXCEPTION(1, "@error config: app");			}			zval *app_path = NULL;			if(air_config_get(app_conf, ZEND_STRS("path"), &app_path) == FAILURE){				AIR_NEW_EXCEPTION(1, "@error config: app.path");			}			zval *view_path = NULL;			if(air_config_get_path(app_conf, ZEND_STRS("view.path"), &view_path) == FAILURE){				AIR_NEW_EXCEPTION(1, "@view config not found");			}			smart_str_appendl(&ss_path, Z_STRVAL_P(app_path), Z_STRLEN_P(app_path));			smart_str_appendc(&ss_path, '/');			smart_str_appendl(&ss_path, Z_STRVAL_P(view_path), Z_STRLEN_P(view_path));		}		smart_str_appendc(&ss_path, '/');	}	smart_str_appendl(&ss_path, tpl_str, tpl_len);	smart_str_0(&ss_path);	//php_printf("full view path: %s/n", ss_path.c);	//构造运行时所需基本变量	HashTable *origin_symbol_table = NULL;	zval *output_handler = NULL;	long chunk_size = 0;	long flags = PHP_OUTPUT_HANDLER_STDFLAGS;	zval *view_ret = NULL;	//尝试缓存当前符号表	if(EG(active_symbol_table)){		origin_symbol_table = EG(active_symbol_table);	}	if (ret_res) {		MAKE_STD_ZVAL(view_ret);		if(php_output_start_user(output_handler, chunk_size, flags TSRMLS_CC) == FAILURE)		{			php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to create buffer");			RETURN_FALSE;		}	}	ALLOC_HASHTABLE(EG(active_symbol_table));	zval *data = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_data"), 0 TSRMLS_CC);	zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);	//将当前的模板变量放到符号表去	ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), "var", 4, data, Z_REFCOUNT_P(data) + 1, PZVAL_IS_REF(data));	if(air_loader_include_file(ss_path.c TSRMLS_CC) == FAILURE){		air_throw_exception_ex(1, "tpl %s render failed!/n", ss_path.c);		return ;	}	if(ret_res){		php_output_get_contents(view_ret TSRMLS_CC);		php_output_discard(TSRMLS_C);		RETVAL_ZVAL(view_ret, 1, 0);		zval_ptr_dtor(&view_ret);	}	zend_hash_destroy(EG(active_symbol_table));	FREE_HASHTABLE(EG(active_symbol_table));	EG(active_symbol_table) = origin_symbol_table;	smart_str_free(&ss_path);}

/** * Inserts data into a table using custom RBDM SQL syntax * * @param string $table * @param array $values * @param array $fields * @return boolean */PHP_METHOD(Phalcon_Db, insert){	zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL;	zval *exception = NULL, *placeholders = NULL, *value = NULL, *position = NULL;	zval *str_value = NULL, *comma = NULL, *joined_values = NULL, *joined_fields = NULL;	zval *insert_sql = NULL, *success = NULL;	HashTable *ah0;	HashPosition hp0;	zval **hd;	char *hash_index;	uint hash_index_len;	ulong hash_num;	int hash_type;	PHALCON_MM_GROW();		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table, &values, &fields) == FAILURE) {		PHALCON_MM_RESTORE();		RETURN_NULL();	}	PHALCON_SEPARATE_PARAM(values);		if (!fields) {		PHALCON_ALLOC_ZVAL_MM(fields);		ZVAL_NULL(fields);	}		if (Z_TYPE_P(values) == IS_ARRAY) { 		PHALCON_INIT_VAR(number_values);		phalcon_fast_count(number_values, values TSRMLS_CC);		if (phalcon_compare_strict_long(number_values, 0 TSRMLS_CC)) {			PHALCON_INIT_VAR(exception_message);			PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data");						PHALCON_INIT_VAR(exception);			object_init_ex(exception, phalcon_db_exception_ce);			PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);			phalcon_throw_exception(exception TSRMLS_CC);			return;		}				PHALCON_INIT_VAR(placeholders);		array_init(placeholders);				if (!phalcon_valid_foreach(values TSRMLS_CC)) {			return;		}				ALLOC_HASHTABLE(ah0);		zend_hash_init(ah0, 0, NULL, NULL, 0);		zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*));		zend_hash_internal_pointer_reset_ex(ah0, &hp0);				ph_cycle_start_0:					if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){				goto ph_cycle_end_0;			}						PHALCON_INIT_VAR(position);			PHALCON_GET_FOREACH_KEY(position, ah0, hp0);			PHALCON_GET_FOREACH_VALUE(value);						if (Z_TYPE_P(value) == IS_OBJECT) {				PHALCON_INIT_VAR(str_value);				PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value);				phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC);				PHALCON_SEPARATE_PARAM(values);				phalcon_array_unset(values, position);			} else {				if (Z_TYPE_P(value) == IS_NULL) {					phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC);					PHALCON_SEPARATE_PARAM(values);					phalcon_array_unset(values, position);				} else {					phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC);				}			}						zend_hash_move_forward_ex(ah0, &hp0);			goto ph_cycle_start_0;				ph_cycle_end_0:		zend_hash_destroy(ah0);		efree(ah0);				PHALCON_INIT_VAR(comma);		ZVAL_STRING(comma, ", ", 1);				PHALCON_INIT_VAR(joined_values);		phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC);//.........这里部分代码省略.........

static int fcgi_read_request(fcgi_request *req){	fcgi_header hdr;	int len, padding;	unsigned char buf[FCGI_MAX_LENGTH+8];	req->keep = 0;	req->closed = 0;	req->in_len = 0;	req->out_hdr = NULL;	req->out_pos = req->out_buf;	ALLOC_HASHTABLE(req->env);	zend_hash_init(req->env, 0, NULL, (void (*)(void *)) fcgi_free_var, 0);	if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||	    hdr.version < FCGI_VERSION_1) {		return 0;	}	len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;	padding = hdr.paddingLength;	while (hdr.type == FCGI_STDIN && len == 0) {		if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||		    hdr.version < FCGI_VERSION_1) {			return 0;		}		len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;		padding = hdr.paddingLength;	}	if (len + padding > FCGI_MAX_LENGTH) {		return 0;	}	req->id = (hdr.requestIdB1 << 8) + hdr.requestIdB0;	if (hdr.type == FCGI_BEGIN_REQUEST && len == sizeof(fcgi_begin_request)) {		char *val;		if (safe_read(req, buf, len+padding) != len+padding) {			return 0;		}		req->keep = (((fcgi_begin_request*)buf)->flags & FCGI_KEEP_CONN);		switch ((((fcgi_begin_request*)buf)->roleB1 << 8) + ((fcgi_begin_request*)buf)->roleB0) {			case FCGI_RESPONDER:				val = estrdup("RESPONDER");				zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);				break;			case FCGI_AUTHORIZER:				val = estrdup("AUTHORIZER");				zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);				break;			case FCGI_FILTER:				val = estrdup("FILTER");				zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);				break;			default:				return 0;		}		if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||		    hdr.version < FCGI_VERSION_1) {			return 0;		}		len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;		padding = hdr.paddingLength;		while (hdr.type == FCGI_PARAMS && len > 0) {			if (len + padding > FCGI_MAX_LENGTH) {				return 0;			}			if (safe_read(req, buf, len+padding) != len+padding) {				req->keep = 0;				return 0;			}			if (!fcgi_get_params(req, buf, buf+len)) {				req->keep = 0;				return 0;			}			if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||			    hdr.version < FCGI_VERSION_1) {				req->keep = 0;				return 0;			}			len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;			padding = hdr.paddingLength;		}	} else if (hdr.type == FCGI_GET_VALUES) {		unsigned char *p = buf + sizeof(fcgi_header);		HashPosition pos;		char * str_index;		uint str_length;		ulong num_index;//.........这里部分代码省略.........