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

zend_constant *zend_quick_get_constant(const zval *key, zend_ulong flags){	zend_constant *c;	if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {		key++;		if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||		    (c->flags & CONST_CS) != 0) {			if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {				key++;				if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {				    key++;					if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||					    (c->flags & CONST_CS) != 0) {						key--;						c = NULL;					}				}			} else {				key--;				c = NULL;			}		}	}	return c;}

/* {{{ xmlreader_read_property */zval *xmlreader_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv){	xmlreader_object *obj;	zval tmp_member;	zval *retval = NULL;	xmlreader_prop_handler *hnd = NULL; 	if (Z_TYPE_P(member) != IS_STRING) {		ZVAL_STR(&tmp_member, zval_get_string_func(member));		member = &tmp_member;	}	obj = Z_XMLREADER_P(object);	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd != NULL) {		if (xmlreader_property_reader(obj, hnd, rv) == FAILURE) {			retval = &EG(uninitialized_zval);		} else {			retval = rv;		}	} else {		retval = zend_std_read_property(object, member, type, cache_slot, rv);	}	if (member == &tmp_member) {		zval_ptr_dtor_str(&tmp_member);	}	return retval;}

/* {{{ mysqli_write_property */zval *mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot){	zval tmp_member;	mysqli_object *obj;	mysqli_prop_handler *hnd = NULL;	if (Z_TYPE_P(member) != IS_STRING) {		ZVAL_STR(&tmp_member, zval_get_string_func(member));		member = &tmp_member;	}	obj = Z_MYSQLI_P(object);	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd) {		hnd->write_func(obj, value);	} else {		value = zend_std_write_property(object, member, value, cache_slot);	}	if (member == &tmp_member) {		zval_ptr_dtor_str(&tmp_member);	}	return value;}

zend_class_entry *yaf_dispatcher_get_controller(zend_string *app_dir, zend_string *module, zend_string *controller, int def_module) /* {{{ */ {	char *directory;	size_t directory_len;	if (def_module) {		directory_len = spprintf(&directory, 0,				"%s%c%s", ZSTR_VAL(app_dir), DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);	} else {		directory_len = spprintf(&directory, 0,				"%s%c%s%c%s%c%s", ZSTR_VAL(app_dir), DEFAULT_SLASH, YAF_MODULE_DIRECTORY_NAME,				DEFAULT_SLASH, ZSTR_VAL(module), DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);	}	if (EXPECTED(directory_len)) {		zend_string *class;		zend_string *class_lowercase;		zend_class_entry *ce 	= NULL;		if (YAF_G(name_suffix)) {			class = strpprintf(0, "%s%s%s", ZSTR_VAL(controller), YAF_G(name_separator), "Controller");		} else {			class = strpprintf(0, "%s%s%s", "Controller", YAF_G(name_separator), ZSTR_VAL(controller));		}		class_lowercase = zend_string_tolower(class);		if ((ce = zend_hash_find_ptr(EG(class_table), class_lowercase)) == NULL) {			if (!yaf_internal_autoload(ZSTR_VAL(controller), ZSTR_LEN(controller), &directory)) {				yaf_trigger_error(YAF_ERR_NOTFOUND_CONTROLLER,						"Failed opening controller script %s: %s", directory, strerror(errno));				zend_string_release(class);				zend_string_release(class_lowercase);				efree(directory);				return NULL;			} else if ((ce = zend_hash_find_ptr(EG(class_table), class_lowercase)) == NULL)  {

static inline zend_long *pthreads_get_guard(zend_object *zobj, zval *member) /* {{{ */{    HashTable *guards;    zend_long stub, *guard;    zval tmp;    ZEND_ASSERT(GC_FLAGS(zobj) & IS_OBJ_USE_GUARDS);    if (GC_FLAGS(zobj) & IS_OBJ_HAS_GUARDS) {        guards = Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]);        ZEND_ASSERT(guards != NULL);		if (Z_TYPE_P(member) == IS_LONG) {			if ((guard = (zend_long *)zend_hash_index_find_ptr(guards, Z_LVAL_P(member))) != NULL) {            	return guard;        	}		} else {			if ((guard = (zend_long *)zend_hash_find_ptr(guards, Z_STR_P(member))) != NULL) {            	return guard;        	}		}            } else {        ALLOC_HASHTABLE(guards);        zend_hash_init(guards, 8, NULL, pthreads_guard_dtor, 0);        ZVAL_PTR(&tmp, guards);        Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]) = guards;        GC_FLAGS(zobj) |= IS_OBJ_HAS_GUARDS;    }    stub = 0;	if (Z_TYPE_P(member) == IS_LONG) {		return (zend_long *)zend_hash_index_add_mem(guards, Z_LVAL_P(member), &stub, sizeof(zend_ulong));	} else return (zend_long *)zend_hash_add_mem(guards, Z_STR_P(member), &stub, sizeof(zend_ulong));}

/* {{{ xmlreader_write_property */void xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot){	xmlreader_object *obj;	zval tmp_member;	xmlreader_prop_handler *hnd = NULL;	zend_object_handlers *std_hnd; 	if (Z_TYPE_P(member) != IS_STRING) {		tmp_member = *member;		zval_copy_ctor(&tmp_member);		convert_to_string(&tmp_member);		member = &tmp_member;	}	obj = Z_XMLREADER_P(object);	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd != NULL) {		php_error_docref(NULL, E_WARNING, "Cannot write to read-only property");	} else {		std_hnd = zend_get_std_object_handlers();		std_hnd->write_property(object, member, value, cache_slot);	}	if (member == &tmp_member) {		zval_dtor(member);	}}

/* {{{ proto bool SolrInputDocument::addField(string field_name, field_value [, float field_boost])   Adds a field to the document. Can be called multiple times. */PHP_METHOD(SolrInputDocument, addField){    zend_string *field_str;    zend_string *field_value_str;	double field_boost     = 0.0f;	solr_document_t *doc_entry = NULL;	/* Process the parameters passed to the method */	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|d", &field_str,			&field_value_str, &field_boost) == FAILURE) {		RETURN_FALSE;	}	if (!field_str->len) {		RETURN_FALSE;	}	/* Retrieve the document entry for the SolrDocument instance */	if (solr_fetch_document_entry(getThis(), &doc_entry TSRMLS_CC) == SUCCESS)	{		solr_field_list_t *field_values      = NULL;		/* If the field already exists in the SolrDocument instance append the value to the field list queue */		if ((field_values = (solr_field_list_t *)zend_hash_find_ptr(doc_entry->fields, field_str)) != NULL) {			if (solr_document_insert_field_value(field_values, (solr_char_t *)&field_value_str->val, field_boost) == FAILURE) {				RETURN_FALSE;			}		} else {			/* Otherwise, create a new one and add it to the hash table */			field_values     = (solr_field_list_t *)  pemalloc(sizeof(solr_field_list_t), SOLR_DOCUMENT_FIELD_PERSISTENT);			memset(field_values, 0, sizeof(solr_field_list_t));			field_values->count       = 0L;			field_values->field_boost = 0.0;			field_values->field_name  = (solr_char_t *) pestrdup((char *)field_str->val, SOLR_DOCUMENT_FIELD_PERSISTENT);			field_values->head        = NULL;			field_values->last        = NULL;			if (solr_document_insert_field_value(field_values, field_value_str->val, field_boost) == FAILURE) {				solr_destroy_field_list(field_values);				RETURN_FALSE;			}			if (zend_hash_add_ptr(doc_entry->fields, field_str, (void *) field_values) == NULL) {				solr_destroy_field_list(field_values);				RETURN_FALSE;			}			/* Increment field count only when HEAD is added */			doc_entry->field_count++;		}		RETURN_TRUE;	}	RETURN_FALSE;}

/* {{{ xmlreader_get_property_ptr_ptr */zval *xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot){	xmlreader_object *obj;	zval tmp_member;	zval *retval = NULL;	xmlreader_prop_handler *hnd = NULL;	zend_object_handlers *std_hnd; 	if (Z_TYPE_P(member) != IS_STRING) {		tmp_member = *member;		zval_copy_ctor(&tmp_member);		convert_to_string(&tmp_member);		member = &tmp_member;	}	obj = Z_XMLREADER_P(object);	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd == NULL) {		std_hnd = zend_get_std_object_handlers();		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);	}	if (member == &tmp_member) {		zval_dtor(member);	}	return retval;}

/* {{{ */zend_string* pthreads_globals_string(zend_string *str) {	/*	 This is sourcery of the darkest kind ...		 We don't need all threads to have a copy of every string used as the name for a threaded objects property.	 	 In addition, Zend has troubles with persistent strings in non-persistent hashes and vice versa, to avoid these	 we have a global table of strings that is used when writing to threaded objects properties, this table is detroyed	 on shutdown of the process, so will show as leaked, but we don't care, we want stable !	*/	zend_string* p = NULL;	if (pthreads_globals_lock()) {		if (!(p = zend_hash_find_ptr(&PTHREADS_G(gstrings), str)) && 			(p = (zend_string*) malloc(ZEND_MM_ALIGNED_SIZE(_ZSTR_STRUCT_SIZE(ZSTR_LEN(str)))))) {			memset(p, 0, sizeof(zend_string));			GC_REFCOUNT(p) = 2;			GC_TYPE_INFO(p) = IS_STR_PERSISTENT;			memcpy(ZSTR_VAL(p), ZSTR_VAL(str), ZSTR_LEN(str));			p->len = ZSTR_LEN(str);			ZSTR_VAL(p)[ZSTR_LEN(p)] = '/0';			zend_string_forget_hash_val(p);			zend_hash_update_ptr(				&PTHREADS_G(gstrings), p, p);		}		pthreads_globals_unlock();	}	return p;} /* }}} */

static zend_constant *zend_get_special_constant(const char *name, size_t name_len){	zend_constant *c;	static char haltoff[] = "__COMPILER_HALT_OFFSET__";	if (!EG(current_execute_data)) {		return NULL;	} else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 &&	          !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) {		const char *cfilename;		zend_string *haltname;		size_t clen;		cfilename = zend_get_executed_filename();		clen = strlen(cfilename);		/* check for __COMPILER_HALT_OFFSET__ */		haltname = zend_mangle_property_name(haltoff,			sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0);		c = zend_hash_find_ptr(EG(zend_constants), haltname);		zend_string_free(haltname);		return c;	} else {		return NULL;	}}

/* {{{ mysqli_write_property */void mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot){	zval tmp_member;	mysqli_object *obj;	mysqli_prop_handler *hnd = NULL;	if (Z_TYPE_P(member) != IS_STRING) {		ZVAL_COPY(&tmp_member, member);		convert_to_string(&tmp_member);		member = &tmp_member;	}	obj = Z_MYSQLI_P(object);	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd) {		hnd->write_func(obj, value);	} else {		zend_object_handlers *std_hnd = zend_get_std_object_handlers();		std_hnd->write_property(object, member, value, cache_slot);	}	if (member == &tmp_member) {		zval_dtor(member);	}}

/* {{{ mysqli_read_property */zval *mysqli_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv){	zval tmp_member;	zval *retval;	mysqli_object *obj;	mysqli_prop_handler *hnd = NULL;	obj = Z_MYSQLI_P(object);	if (Z_TYPE_P(member) != IS_STRING) {		ZVAL_COPY(&tmp_member, member);		convert_to_string(&tmp_member);		member = &tmp_member;	}	if (obj->prop_handler != NULL) {		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));	}	if (hnd) {		retval = hnd->read_func(obj, rv);		if (retval == NULL) {			retval = &EG(uninitialized_zval);		}	} else {		zend_object_handlers *std_hnd = zend_get_std_object_handlers();		retval = std_hnd->read_property(object, member, type, cache_slot, rv);	}	if (member == &tmp_member) {		zval_dtor(member);	}	return retval;}

static int pgsql_stmt_describe(pdo_stmt_t *stmt, int colno){	pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;	struct pdo_column_data *cols = stmt->columns;	struct pdo_bound_param_data *param;	char *str;	if (!S->result) {		return 0;	}	str = PQfname(S->result, colno);	cols[colno].name = zend_string_init(str, strlen(str), 0);	cols[colno].maxlen = PQfsize(S->result, colno);	cols[colno].precision = PQfmod(S->result, colno);	S->cols[colno].pgsql_type = PQftype(S->result, colno);	switch (S->cols[colno].pgsql_type) {		case BOOLOID:			cols[colno].param_type = PDO_PARAM_BOOL;			break;		case OIDOID:			/* did the user bind the column as a LOB ? */			if (stmt->bound_columns && (					(param = zend_hash_index_find_ptr(stmt->bound_columns, colno)) != NULL ||					(param = zend_hash_find_ptr(stmt->bound_columns, cols[colno].name)) != NULL)) {				if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {					cols[colno].param_type = PDO_PARAM_LOB;					break;				}			}			cols[colno].param_type = PDO_PARAM_INT;			break;		case INT2OID:		case INT4OID:			cols[colno].param_type = PDO_PARAM_INT;			break;		case INT8OID:			if (sizeof(zend_long)>=8) {				cols[colno].param_type = PDO_PARAM_INT;			} else {				cols[colno].param_type = PDO_PARAM_STR;			}			break;		case BYTEAOID:			cols[colno].param_type = PDO_PARAM_LOB;			break;		default:			cols[colno].param_type = PDO_PARAM_STR;	}	return 1;}

static zend_string *browscap_intern_str(		browscap_parser_ctx *ctx, zend_string *str) {	zend_string *interned = zend_hash_find_ptr(&ctx->str_interned, str);	if (interned) {		zend_string_addref(interned);	} else {		interned = zend_string_copy(str);		zend_hash_add_new_ptr(&ctx->str_interned, interned, interned);	}	return interned;}

ZEND_API zval *zend_get_constant(zend_string *name){	zend_constant *c = zend_hash_find_ptr(EG(zend_constants), name);	if (c) {		return &c->value;	}	c = zend_get_halt_offset_constant(ZSTR_VAL(name), ZSTR_LEN(name));	if (c) {		return &c->value;	}	return zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name));}

static void zend_accel_adjust_fcall_stack_size(zend_op_array *op_array, zend_optimizer_ctx *ctx){	zend_function *func;	zend_op *opline, *end;	opline = op_array->opcodes;	end = opline + op_array->last;	while (opline < end) {		if (opline->opcode == ZEND_INIT_FCALL) {			func = zend_hash_find_ptr(				&ctx->script->function_table,				Z_STR_P(RT_CONSTANT(op_array, opline->op2)));			if (func) {				opline->op1.num = zend_vm_calc_used_stack(opline->extended_value, func);			}		}		opline++;	}}

static zend_class_entry * spl_find_ce_by_name(zend_string *name, zend_bool autoload){	zend_class_entry *ce;	if (!autoload) {		zend_string *lc_name = zend_string_tolower(name);		ce = zend_hash_find_ptr(EG(class_table), lc_name);		zend_string_free(lc_name);	} else { 		ce = zend_lookup_class(name); 	} 	if (ce == NULL) {		php_error_docref(NULL, E_WARNING, "Class %s does not exist%s", ZSTR_VAL(name), autoload ? " and could not be loaded" : "");		return NULL;	}	return ce;}

static zend_string *browscap_intern_str_ci(		browscap_parser_ctx *ctx, zend_string *str, zend_bool persistent) {	zend_string *lcname;	zend_string *interned;	ALLOCA_FLAG(use_heap);	ZSTR_ALLOCA_ALLOC(lcname, ZSTR_LEN(str), use_heap);	zend_str_tolower_copy(ZSTR_VAL(lcname), ZSTR_VAL(str), ZSTR_LEN(str));	interned = zend_hash_find_ptr(&ctx->str_interned, lcname);	if (interned) {		zend_string_addref(interned);	} else {		interned = zend_string_dup(lcname, persistent);		zend_hash_add_new_ptr(&ctx->str_interned, interned, interned);	}	ZSTR_ALLOCA_FREE(lcname, use_heap);	return interned;}

ZEND_API zval *zend_get_constant(zend_string *name){	zend_constant *c;	ALLOCA_FLAG(use_heap)	if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {		char *lcname = do_alloca(name->len + 1, use_heap);		zend_str_tolower_copy(lcname, name->val, name->len);		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, name->len)) != NULL) {			if (c->flags & CONST_CS) {				c = NULL;			}		} else {			c = zend_get_special_constant(name->val, name->len);		}		free_alloca(lcname, use_heap);	}	return c ? &c->value : NULL;}

static int mysqli_object_has_property(zval *object, zval *member, int has_set_exists, void **cache_slot) /* {{{ */{	mysqli_object *obj = Z_MYSQLI_P(object);	mysqli_prop_handler	*p;	int ret = 0;	if ((p = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member))) != NULL) {		switch (has_set_exists) {			case 2:				ret = 1;				break;			case 1: {				zval rv;				zval *value = mysqli_read_property(object, member, BP_VAR_IS, cache_slot, &rv);				if (value != &EG(uninitialized_zval)) {					convert_to_boolean(value);					ret = Z_TYPE_P(value) == IS_TRUE ? 1 : 0;				}				break;			}			case 0:{				zval rv;				zval *value = mysqli_read_property(object, member, BP_VAR_IS, cache_slot, &rv);				if (value != &EG(uninitialized_zval)) {					ret = Z_TYPE_P(value) != IS_NULL? 1 : 0;					zval_ptr_dtor(value);				}				break;			}			default:				php_error_docref(NULL, E_WARNING, "Invalid value for has_set_exists");		}	} else {		zend_object_handlers *std_hnd = zend_get_std_object_handlers();		ret = std_hnd->has_property(object, member, has_set_exists, cache_slot);	}	return ret;} /* }}} */

/* {{{ proto SolrDocumentField SolrInputDocument::getField(string fieldname)   Returns the requested field. */PHP_METHOD(SolrInputDocument, getField){	solr_char_t *field_name = NULL;	COMPAT_ARG_SIZE_T  field_name_length = 0;	solr_document_t *doc_entry = NULL;	zend_string *field_str = NULL;	/* Process the parameters passed to the default constructor */	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &field_name, &field_name_length) == FAILURE) {		RETURN_FALSE;	}	if (!field_name_length) {		RETURN_FALSE;	}	field_str = zend_string_init(field_name, field_name_length, SOLR_DOCUMENT_FIELD_PERSISTENT);	/* Retrieve the document entry for the SolrDocument instance */	if (solr_fetch_document_entry(getThis(), &doc_entry TSRMLS_CC) == SUCCESS)	{		solr_field_list_t *field_values = NULL;		if ((field_values = zend_hash_find_ptr(doc_entry->fields, field_str)) != NULL)		{			solr_create_document_field_object(field_values, &return_value TSRMLS_CC);			/* The field was retrieved, so we're done here */			zend_string_release(field_str);			return ;		}		goto return_false;	}return_false:	zend_string_release(field_str);	RETURN_FALSE;}

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;}

ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, uint32_t flags){	zend_constant *c;	const char *colon;	zend_class_entry *ce = NULL;	const char *name = ZSTR_VAL(cname);	size_t name_len = ZSTR_LEN(cname);	/* Skip leading // */	if (name[0] == '//') {		name += 1;		name_len -= 1;		cname = NULL;	}	if ((colon = zend_memrchr(name, ':', name_len)) &&	    colon > name && (*(colon - 1) == ':')) {		int class_name_len = colon - name - 1;		size_t const_name_len = name_len - class_name_len - 2;		zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0);		zend_string *class_name = zend_string_init(name, class_name_len, 0);		zval *ret_constant = NULL;		if (zend_string_equals_literal_ci(class_name, "self")) {			if (UNEXPECTED(!scope)) {				zend_throw_error(NULL, "Cannot access self:: when no class scope is active");				goto failure;			}			ce = scope;		} else if (zend_string_equals_literal_ci(class_name, "parent")) {			if (UNEXPECTED(!scope)) {				zend_throw_error(NULL, "Cannot access parent:: when no class scope is active");				goto failure;			} else if (UNEXPECTED(!scope->parent)) {				zend_throw_error(NULL, "Cannot access parent:: when current class scope has no parent");				goto failure;			} else {				ce = scope->parent;			}		} else if (zend_string_equals_literal_ci(class_name, "static")) {			ce = zend_get_called_scope(EG(current_execute_data));			if (UNEXPECTED(!ce)) {				zend_throw_error(NULL, "Cannot access static:: when no class scope is active");				goto failure;			}		} else {			ce = zend_fetch_class(class_name, flags);		}		if (ce) {			zend_class_constant *c = zend_hash_find_ptr(&ce->constants_table, constant_name);			if (c == NULL) {				if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {					zend_throw_error(NULL, "Undefined class constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));					goto failure;				}				ret_constant = NULL;			} else {				if (!zend_verify_const_access(c, scope)) {					zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(class_name), ZSTR_VAL(constant_name));					goto failure;				}				ret_constant = &c->value;			}		}		if (ret_constant && Z_CONSTANT_P(ret_constant)) {			if (Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) {				if (IS_CONSTANT_VISITED(ret_constant)) {					zend_throw_error(NULL, "Cannot declare self-referencing constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));					ret_constant = NULL;					goto failure;				}				MARK_CONSTANT_VISITED(ret_constant);			}			if (UNEXPECTED(zval_update_constant_ex(ret_constant, ce) != SUCCESS)) {				RESET_CONSTANT_VISITED(ret_constant);				ret_constant = NULL;				goto failure;			}			RESET_CONSTANT_VISITED(ret_constant);		}failure:		zend_string_release(class_name);		zend_string_free(constant_name);		return ret_constant;	}	/* non-class constant */	if ((colon = zend_memrchr(name, '//', name_len)) != NULL) {		/* compound constant name */		int prefix_len = colon - name;		size_t const_name_len = name_len - prefix_len - 1;		const char *constant_name = colon + 1;		char *lcname;		size_t lcname_len;		ALLOCA_FLAG(use_heap)		lcname_len = prefix_len + 1 + const_name_len;		lcname = do_alloca(lcname_len + 1, use_heap);		zend_str_tolower_copy(lcname, name, prefix_len);//.........这里部分代码省略.........

int zend_accel_script_optimize(zend_persistent_script *script){	uint idx, j;	Bucket *p, *q;	zend_class_entry *ce;	zend_op_array *op_array;	zend_optimizer_ctx ctx;	ctx.arena = zend_arena_create(64 * 1024);	ctx.script = script;	ctx.constants = NULL;	zend_accel_optimize(&script->main_op_array, &ctx);	for (idx = 0; idx < script->function_table.nNumUsed; idx++) {		p = script->function_table.arData + idx;		if (Z_TYPE(p->val) == IS_UNDEF) continue;		op_array = (zend_op_array*)Z_PTR(p->val);		zend_accel_optimize(op_array, &ctx);	}	for (idx = 0; idx < script->class_table.nNumUsed; idx++) {		p = script->class_table.arData + idx;		if (Z_TYPE(p->val) == IS_UNDEF) continue;		ce = (zend_class_entry*)Z_PTR(p->val);		for (j = 0; j < ce->function_table.nNumUsed; j++) {			q = ce->function_table.arData + j;			if (Z_TYPE(q->val) == IS_UNDEF) continue;			op_array = (zend_op_array*)Z_PTR(q->val);			if (op_array->scope == ce) {				zend_accel_optimize(op_array, &ctx);			} else if (op_array->type == ZEND_USER_FUNCTION) {				zend_op_array *orig_op_array;				if ((orig_op_array = zend_hash_find_ptr(&op_array->scope->function_table, q->key)) != NULL) {					HashTable *ht = op_array->static_variables;					*op_array = *orig_op_array;					op_array->static_variables = ht;				}			}		}	}	if (ZEND_OPTIMIZER_PASS_12 & OPTIMIZATION_LEVEL) {		zend_accel_adjust_fcall_stack_size(&script->main_op_array, &ctx);		for (idx = 0; idx < script->function_table.nNumUsed; idx++) {			p = script->function_table.arData + idx;			if (Z_TYPE(p->val) == IS_UNDEF) continue;			op_array = (zend_op_array*)Z_PTR(p->val);			zend_accel_adjust_fcall_stack_size(op_array, &ctx);		}		for (idx = 0; idx < script->class_table.nNumUsed; idx++) {			p = script->class_table.arData + idx;			if (Z_TYPE(p->val) == IS_UNDEF) continue;			ce = (zend_class_entry*)Z_PTR(p->val);			for (j = 0; j < ce->function_table.nNumUsed; j++) {				q = ce->function_table.arData + j;				if (Z_TYPE(q->val) == IS_UNDEF) continue;				op_array = (zend_op_array*)Z_PTR(q->val);				if (op_array->scope == ce) {					zend_accel_adjust_fcall_stack_size(op_array, &ctx);				} else if (op_array->type == ZEND_USER_FUNCTION) {					zend_op_array *orig_op_array;					if ((orig_op_array = zend_hash_find_ptr(&op_array->scope->function_table, q->key)) != NULL) {						HashTable *ht = op_array->static_variables;						*op_array = *orig_op_array;						op_array->static_variables = ht;					}				}			}		}	}	if (ctx.constants) {		zend_hash_destroy(ctx.constants);	}	zend_arena_destroy(ctx.arena);	return 1;}

/* {{{ zend_call_method Only returns the returned zval if retval_ptr != NULL */ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval_ptr, int param_count, zval* arg1, zval* arg2){	int result;	zend_fcall_info fci;	zval retval;	HashTable *function_table;	zval params[2];	if (param_count > 0) {		ZVAL_COPY_VALUE(&params[0], arg1);	}	if (param_count > 1) {		ZVAL_COPY_VALUE(&params[1], arg2);	}	fci.size = sizeof(fci);	/*fci.function_table = NULL; will be read form zend_class_entry of object if needed */	fci.object = (object && Z_TYPE_P(object) == IS_OBJECT) ? Z_OBJ_P(object) : NULL;	ZVAL_STRINGL(&fci.function_name, function_name, function_name_len);	fci.retval = retval_ptr ? retval_ptr : &retval;	fci.param_count = param_count;	fci.params = params;	fci.no_separation = 1;	fci.symbol_table = NULL;	if (!fn_proxy && !obj_ce) {		/* no interest in caching and no information already present that is		 * needed later inside zend_call_function. */		fci.function_table = !object ? EG(function_table) : NULL;		result = zend_call_function(&fci, NULL);		zval_ptr_dtor(&fci.function_name);	} else {		zend_fcall_info_cache fcic;		fcic.initialized = 1;		if (!obj_ce) {			obj_ce = object ? Z_OBJCE_P(object) : NULL;		}		if (obj_ce) {			function_table = &obj_ce->function_table;		} else {			function_table = EG(function_table);		}		if (!fn_proxy || !*fn_proxy) {			if ((fcic.function_handler = zend_hash_find_ptr(function_table, Z_STR(fci.function_name))) == NULL) {				/* error at c-level */				zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);			}			if (fn_proxy) {				*fn_proxy = fcic.function_handler;			}		} else {			fcic.function_handler = *fn_proxy;		}		fcic.calling_scope = obj_ce;		if (object) {			fcic.called_scope = Z_OBJCE_P(object);		} else {			zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));			if (obj_ce &&			    (!called_scope ||			     !instanceof_function(called_scope, obj_ce))) {				fcic.called_scope = obj_ce;			} else {				fcic.called_scope = called_scope;			}		}		fcic.object = object ? Z_OBJ_P(object) : NULL;		result = zend_call_function(&fci, &fcic);		zval_ptr_dtor(&fci.function_name);	}	if (result == FAILURE) {		/* error at c-level */		if (!obj_ce) {			obj_ce = object ? Z_OBJCE_P(object) : NULL;		}		if (!EG(exception)) {			zend_error_noreturn(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);		}	}	/* copy arguments back, they might be changed by references */	if (param_count > 0 && Z_ISREF(params[0]) && !Z_ISREF_P(arg1)) {		ZVAL_COPY_VALUE(arg1, &params[0]);	}	if (param_count > 1 && Z_ISREF(params[1]) && !Z_ISREF_P(arg2)) {		ZVAL_COPY_VALUE(arg2, &params[1]);	}	if (!retval_ptr) {		zval_ptr_dtor(&retval);		return NULL;	}	return retval_ptr;}

static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,		enum pdo_param_event event_type){	pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;	if (stmt->supports_placeholders == PDO_PLACEHOLDER_NAMED && param->is_param) {		switch (event_type) {			case PDO_PARAM_EVT_FREE:				if (param->driver_data) {					efree(param->driver_data);				}				break;			case PDO_PARAM_EVT_NORMALIZE:				/* decode name from $1, $2 into 0, 1 etc. */				if (param->name) {					if (param->name->val[0] == '$') {						ZEND_ATOL(param->paramno, param->name->val + 1);					} else {						/* resolve parameter name to rewritten name */						char *namevar;						if (stmt->bound_param_map && (namevar = zend_hash_find_ptr(stmt->bound_param_map,								param->name)) != NULL) {							ZEND_ATOL(param->paramno, namevar + 1);							param->paramno--;						} else {							pdo_raise_impl_error(stmt->dbh, stmt, "HY093", param->name->val);							return 0;						}					}				}				break;			case PDO_PARAM_EVT_ALLOC:			case PDO_PARAM_EVT_EXEC_POST:			case PDO_PARAM_EVT_FETCH_PRE:			case PDO_PARAM_EVT_FETCH_POST:				/* work is handled by EVT_NORMALIZE */				return 1;			case PDO_PARAM_EVT_EXEC_PRE:				if (!stmt->bound_param_map) {					return 0;				}				if (!S->param_values) {					S->param_values = ecalloc(							zend_hash_num_elements(stmt->bound_param_map),							sizeof(char*));					S->param_lengths = ecalloc(							zend_hash_num_elements(stmt->bound_param_map),							sizeof(int));					S->param_formats = ecalloc(							zend_hash_num_elements(stmt->bound_param_map),							sizeof(int));					S->param_types = ecalloc(							zend_hash_num_elements(stmt->bound_param_map),							sizeof(Oid));				}				if (param->paramno >= 0) {					zval *parameter;					if (param->paramno >= zend_hash_num_elements(stmt->bound_params)) {						pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined");						return 0;					}					if (Z_ISREF(param->parameter)) {						parameter = Z_REFVAL(param->parameter);					} else {						parameter = &param->parameter;					}					if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB &&							Z_TYPE_P(parameter) == IS_RESOURCE) {						php_stream *stm;						php_stream_from_zval_no_verify(stm, parameter);						if (stm) {							if (php_stream_is(stm, &pdo_pgsql_lob_stream_ops)) {								struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stm->abstract;								pdo_pgsql_bound_param *P = param->driver_data;								if (P == NULL) {									P = ecalloc(1, sizeof(*P));									param->driver_data = P;								}								P->oid = htonl(self->oid);								S->param_values[param->paramno] = (char*)&P->oid;								S->param_lengths[param->paramno] = sizeof(P->oid);								S->param_formats[param->paramno] = 1;								S->param_types[param->paramno] = OIDOID;								return 1;							} else {								zend_string *str = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);								if (str != NULL) {									//??SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);									ZVAL_STR(parameter, str);								} else {									ZVAL_EMPTY_STRING(parameter);								}//.........这里部分代码省略.........