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

static void zend_print_zval_r_to_buf(smart_str *buf, zval *expr, int indent) /* {{{ */{	switch (Z_TYPE_P(expr)) {		case IS_ARRAY:			smart_str_appends(buf, "Array/n");			if (Z_REFCOUNTED_P(expr)) {				if (Z_IS_RECURSIVE_P(expr)) {					smart_str_appends(buf, " *RECURSION*");					return;				}				Z_PROTECT_RECURSION_P(expr);			}			print_hash(buf, Z_ARRVAL_P(expr), indent, 0);			if (Z_REFCOUNTED_P(expr)) {				Z_UNPROTECT_RECURSION_P(expr);			}			break;		case IS_OBJECT:			{				HashTable *properties;				int is_temp;				zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr));				smart_str_appends(buf, ZSTR_VAL(class_name));				zend_string_release(class_name);				smart_str_appends(buf, " Object/n");				if (Z_IS_RECURSIVE_P(expr)) {					smart_str_appends(buf, " *RECURSION*");					return;				}				if ((properties = Z_OBJDEBUG_P(expr, is_temp)) == NULL) {					break;				}				Z_PROTECT_RECURSION_P(expr);				print_hash(buf, properties, indent, 1);				Z_UNPROTECT_RECURSION_P(expr);				if (is_temp) {					zend_hash_destroy(properties);					FREE_HASHTABLE(properties);				}				break;			}		case IS_LONG:			smart_str_append_long(buf, Z_LVAL_P(expr));			break;		case IS_REFERENCE:			zend_print_zval_r_to_buf(buf, Z_REFVAL_P(expr), indent);			break;		default:			{				zend_string *str = zval_get_string(expr);				smart_str_append(buf, str);				zend_string_release(str);			}			break;	}}

		/* error already emitted, but let's emit another more relevant */		do_from_zval_err(ctx, "could not resolve address '%s' to get an AF_INET6 "				"address", Z_STRVAL_P(zaddr_str));	}	zend_string_release(addr_str);}static void to_zval_read_sin6_addr(const char *data, zval *zv, res_context *ctx){	const struct in6_addr *addr = (const struct in6_addr *)data;	socklen_t size = INET6_ADDRSTRLEN;	zend_string *str = zend_string_alloc(size - 1, 0);	memset(str->val, '/0', size);	ZVAL_NEW_STR(zv, str);	if (inet_ntop(AF_INET6, addr, Z_STRVAL_P(zv), size) == NULL) {		do_to_zval_err(ctx, "could not convert IPv6 address to string "				"(errno %d)", errno);		return;	}	Z_STRLEN_P(zv) = strlen(Z_STRVAL_P(zv));}static const field_descriptor descriptors_sockaddr_in6[] = {		{"family", sizeof("family"), 0, offsetof(struct sockaddr_in6, sin6_family), from_zval_write_sa_family, to_zval_read_sa_family},		{"addr", sizeof("addr"), 0, offsetof(struct sockaddr_in6, sin6_addr), from_zval_write_sin6_addr, to_zval_read_sin6_addr},		{"port", sizeof("port"), 0, offsetof(struct sockaddr_in6, sin6_port), from_zval_write_net_uint16, to_zval_read_net_uint16},		{"flowinfo", sizeof("flowinfo"), 0, offsetof(struct sockaddr_in6, sin6_flowinfo), from_zval_write_uint32, to_zval_read_uint32},		{"scope_id", sizeof("scope_id"), 0, offsetof(struct sockaddr_in6, sin6_scope_id), from_zval_write_uint32, to_zval_read_uint32},		{0}};static void from_zval_write_sockaddr_in6(const zval *container, char *sockaddr6, ser_context *ctx){	from_zval_write_aggregation(container, sockaddr6, descriptors_sockaddr_in6, ctx);}static void to_zval_read_sockaddr_in6(const char *data, zval *zv, res_context *ctx){	to_zval_read_aggregation(data, zv, descriptors_sockaddr_in6, ctx);}#endif /* HAVE_IPV6 */static void from_zval_write_sun_path(const zval *path, char *sockaddr_un_c, ser_context *ctx){	zend_string			*path_str;	struct sockaddr_un	*saddr = (struct sockaddr_un*)sockaddr_un_c;	path_str = zval_get_string((zval *) path);	/* code in this file relies on the path being nul terminated, even though	 * this is not required, at least on linux for abstract paths. It also	 * assumes that the path is not empty */	if (path_str->len == 0) {		do_from_zval_err(ctx, "%s", "the path is cannot be empty");		return;	}	if (path_str->len >= sizeof(saddr->sun_path)) {		do_from_zval_err(ctx, "the path is too long, the maximum permitted "				"length is %ld", sizeof(saddr->sun_path) - 1);		return;	}	memcpy(&saddr->sun_path, path_str->val, path_str->len);	saddr->sun_path[path_str->len] = '/0';	zend_string_release(path_str);}

int dom_node_node_value_write(dom_object *obj, zval *newval){	xmlNode *nodep = dom_object_get_node(obj);	if (nodep == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	/* Access to Element node is implemented as a convience method */	switch (nodep->type) {		case XML_ELEMENT_NODE:		case XML_ATTRIBUTE_NODE:			if (nodep->children) {				node_list_unlink(nodep->children);				php_libxml_node_free_list((xmlNodePtr) nodep->children);				nodep->children = NULL;			}		case XML_TEXT_NODE:		case XML_COMMENT_NODE:		case XML_CDATA_SECTION_NODE:		case XML_PI_NODE:			{				zend_string *str = zval_get_string(newval);				xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);				zend_string_release_ex(str, 0);				break;			}		default:			break;	}	return SUCCESS;}

static int real_php_log_buffer(zval *msg_buffer, char *opt, int opt_len TSRMLS_DC){    php_stream *stream = NULL;    HashTable *ht;#if PHP_VERSION_ID >= 70000    zend_ulong num_key;    zend_string *str_key;    zval *entry;#else    zval **log;#endif    stream = process_stream(opt,opt_len TSRMLS_CC);    if (stream == NULL)    {        return FAILURE;    }#if PHP_VERSION_ID >= 70000    ht = HASH_OF(msg_buffer);    ZEND_HASH_FOREACH_KEY_VAL(ht, num_key, str_key, entry)    {        zend_string *s = zval_get_string(entry);        php_stream_write(stream, ZSTR_VAL(s), ZSTR_LEN(s));        zend_string_release(s);    }

int dom_node_text_content_write(dom_object *obj, zval *newval){	xmlNode *nodep = dom_object_get_node(obj);	zend_string *str;	if (nodep == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	if (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE) {		if (nodep->children) {			node_list_unlink(nodep->children);			php_libxml_node_free_list((xmlNodePtr) nodep->children);			nodep->children = NULL;		}	}	str = zval_get_string(newval);	/* we have to use xmlNodeAddContent() to get the same behavior as with xmlNewText() */	xmlNodeSetContent(nodep, (xmlChar *) "");	xmlNodeAddContent(nodep, (xmlChar *) ZSTR_VAL(str));	zend_string_release_ex(str, 0);	return SUCCESS;}

	ZEND_HASH_FOREACH_STR_KEY_VAL(target_hash, string_key, element) {		zend_string *str = zval_get_string(element);		if (str->len == 0) {			goto next_element;		}		if (string_key) {			if (string_key->len == 0) {				goto next_element;			}			l = string_key->len + str->len + 2;			memcpy(p, string_key->val, string_key->len);			strncat(p, "=", 1);			strncat(p, str->val, str->len);#ifndef PHP_WIN32			*ep = p;			++ep;#endif			p += l;		} else {			memcpy(p, str->val, str->len);#ifndef PHP_WIN32			*ep = p;			++ep;#endif			p += str->len + 1;		}next_element:		STR_RELEASE(str);	} ZEND_HASH_FOREACH_END();

/* {{{ proto Closure Closure::bind(callable old, object to [, mixed scope])   Create a closure from another one and bind to another object and scope */ZEND_METHOD(Closure, bind){	zval *newthis, *zclosure, *scope_arg = NULL;	zend_closure *closure, *new_closure;	zend_class_entry *ce, *called_scope;	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {		RETURN_NULL();	}	closure = (zend_closure *)Z_OBJ_P(zclosure);	if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {		zend_error(E_WARNING, "Cannot bind an instance to a static closure");	}	if (scope_arg != NULL) { /* scope argument was given */		if (Z_TYPE_P(scope_arg) == IS_OBJECT) {			ce = Z_OBJCE_P(scope_arg);		} else if (Z_TYPE_P(scope_arg) == IS_NULL) {			ce = NULL;		} else {			zend_string *class_name = zval_get_string(scope_arg);			if (zend_string_equals_literal(class_name, "static")) {				ce = closure->func.common.scope;			} else if ((ce = zend_lookup_class_ex(class_name, NULL, 1)) == NULL) {				zend_error(E_WARNING, "Class '%s' not found", ZSTR_VAL(class_name));				zend_string_release(class_name);				RETURN_NULL();			}			zend_string_release(class_name);		}		if(ce && ce != closure->func.common.scope && ce->type == ZEND_INTERNAL_CLASS) {			/* rebinding to internal class is not allowed */			zend_error(E_WARNING, "Cannot bind closure to scope of internal class %s", ZSTR_VAL(ce->name));			return;		}	} else { /* scope argument not given; do not change the scope by default */		ce = closure->func.common.scope;	}	if (newthis) {		called_scope = Z_OBJCE_P(newthis);	} else {		called_scope = ce;	}	zend_create_closure(return_value, &closure->func, ce, called_scope, newthis);	new_closure = (zend_closure *) Z_OBJ_P(return_value);	/* Runtime cache relies on bound scope to be immutable, hence we need a separate rt cache in case scope changed */	if (ZEND_USER_CODE(closure->func.type) && (closure->func.common.scope != new_closure->func.common.scope || (closure->func.op_array.fn_flags & ZEND_ACC_NO_RT_ARENA))) {		new_closure->func.op_array.run_time_cache = emalloc(new_closure->func.op_array.cache_size);		memset(new_closure->func.op_array.run_time_cache, 0, new_closure->func.op_array.cache_size);		new_closure->func.op_array.fn_flags |= ZEND_ACC_NO_RT_ARENA;	}}

static void zend_print_zval_r_to_buf(smart_str *buf, zval *expr, int indent) /* {{{ */{	ZVAL_DEREF(expr);	switch (Z_TYPE_P(expr)) {		case IS_ARRAY:			smart_str_appends(buf, "Array/n");			if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr)) &&			    ++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {				smart_str_appends(buf, " *RECURSION*");				Z_ARRVAL_P(expr)->u.v.nApplyCount--;				return;			}			print_hash(buf, Z_ARRVAL_P(expr), indent, 0);			if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr))) {				Z_ARRVAL_P(expr)->u.v.nApplyCount--;			}			break;		case IS_OBJECT:			{				HashTable *properties;				int is_temp;				zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr));				smart_str_appends(buf, ZSTR_VAL(class_name));				zend_string_release(class_name);				smart_str_appends(buf, " Object/n");				if (Z_OBJ_APPLY_COUNT_P(expr) > 0) {					smart_str_appends(buf, " *RECURSION*");					return;				}				if ((properties = Z_OBJDEBUG_P(expr, is_temp)) == NULL) {					break;				}				Z_OBJ_INC_APPLY_COUNT_P(expr);				print_hash(buf, properties, indent, 1);				Z_OBJ_DEC_APPLY_COUNT_P(expr);				if (is_temp) {					zend_hash_destroy(properties);					FREE_HASHTABLE(properties);				}				break;			}		case IS_LONG:			smart_str_append_long(buf, Z_LVAL_P(expr));			break;		default:			{				zend_string *str = zval_get_string(expr);				smart_str_append(buf, str);				zend_string_release(str);			}			break;	}}

ZEND_API size_t zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */{	zend_string *str = zval_get_string(expr);	size_t len = ZSTR_LEN(str);	if (len != 0) {		write_func(ZSTR_VAL(str), len);	}	zend_string_release(str);	return len;}

/* {{{ _php_array_to_envp */static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent TSRMLS_DC){	zval *element;	php_process_env_t env;	zend_string *string_key;#ifndef PHP_WIN32	char **ep;#endif	char *p;	uint cnt, l, sizeenv=0;	HashTable *target_hash;	memset(&env, 0, sizeof(env));	if (!environment) {		return env;	}	cnt = zend_hash_num_elements(Z_ARRVAL_P(environment));	if (cnt < 1) {#ifndef PHP_WIN32		env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent);#endif		env.envp = (char *) pecalloc(4, 1, is_persistent);		return env;	}	target_hash = HASH_OF(environment);	if (!target_hash) {		return env;	}	/* first, we have to get the size of all the elements in the hash */	ZEND_HASH_FOREACH_STR_KEY_VAL(target_hash, string_key, element) {		zend_string *str = zval_get_string(element);		uint el_len = str->len;		STR_RELEASE(str);		if (el_len == 0) {			continue;		}		sizeenv += el_len + 1;		if (string_key) {			if (string_key->len == 0) {				continue;			}			sizeenv += string_key->len + 1;		}	} ZEND_HASH_FOREACH_END();

/* {{{ proto Closure Closure::bind(Closure $old, object $to [, mixed $scope = "static" ] )   Create a closure from another one and bind to another object and scope */ZEND_METHOD(Closure, bind){    zval *newthis, *zclosure, *scope_arg = NULL;    zend_closure *closure;    zend_class_entry *ce, *called_scope;    if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {        RETURN_NULL();    }    closure = (zend_closure *)Z_OBJ_P(zclosure);    if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {        zend_error(E_WARNING, "Cannot bind an instance to a static closure");    }    if (scope_arg != NULL) { /* scope argument was given */        if (Z_TYPE_P(scope_arg) == IS_OBJECT) {            ce = Z_OBJCE_P(scope_arg);        } else if (Z_TYPE_P(scope_arg) == IS_NULL) {            ce = NULL;        } else {            zend_string *class_name = zval_get_string(scope_arg);            if (zend_string_equals_literal(class_name, "static")) {                ce = closure->func.common.scope;            } else if ((ce = zend_lookup_class_ex(class_name, NULL, 1)) == NULL) {                zend_error(E_WARNING, "Class '%s' not found", class_name->val);                zend_string_release(class_name);                RETURN_NULL();            }            zend_string_release(class_name);        }        if(ce && ce != closure->func.common.scope && ce->type == ZEND_INTERNAL_CLASS) {            /* rebinding to internal class is not allowed */            zend_error(E_WARNING, "Cannot bind closure to scope of internal class %s", ce->name->val);            return;        }    } else { /* scope argument not given; do not change the scope by default */        ce = closure->func.common.scope;    }    if (newthis) {        called_scope = Z_OBJCE_P(newthis);    } else {        called_scope = ce;    }    zend_create_closure(return_value, &closure->func, ce, called_scope, newthis);}

/* {{{ _php_array_to_envp */static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent){	zval *element;	php_process_env_t env;	zend_string *key, *str;#ifndef PHP_WIN32	char **ep;#endif	char *p;	size_t cnt, l, sizeenv = 0;	HashTable *env_hash;	memset(&env, 0, sizeof(env));	if (!environment) {		return env;	}	cnt = zend_hash_num_elements(Z_ARRVAL_P(environment));	if (cnt < 1) {#ifndef PHP_WIN32		env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent);#endif		env.envp = (char *) pecalloc(4, 1, is_persistent);		return env;	}	ALLOC_HASHTABLE(env_hash);	zend_hash_init(env_hash, cnt, NULL, NULL, 0);	/* first, we have to get the size of all the elements in the hash */	ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(environment), key, element) {		str = zval_get_string(element);		if (ZSTR_LEN(str) == 0) {			zend_string_release(str);			continue;		}		sizeenv += ZSTR_LEN(str) + 1;		if (key && ZSTR_LEN(key)) {			sizeenv += ZSTR_LEN(key) + 1;			zend_hash_add_ptr(env_hash, key, str);		} else {			zend_hash_next_index_insert_ptr(env_hash, str);		}	} ZEND_HASH_FOREACH_END();

void smart_str_appendz(smart_str *buffer, zval *value){    switch (Z_TYPE_P(value)) {        case IS_STRING:            smart_str_append(buffer, Z_STR_P(value));            return;        case IS_LONG:            smart_str_append_long(buffer, Z_LVAL_P(value));            return;    }    zend_string *str = zval_get_string(value);    smart_str_append(buffer, str);    zend_string_free(str);}

/* {{{ proto mixed hstore_encode(array hstore)   Decodes the hStore representation into a PHP value */static PHP_FUNCTION(hstore_encode){    zval *array, *value;	zend_ulong num_idx;    zend_string *str_idx;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {        return;    }    smart_str buf = {};    smart_str_alloc(&buf, 2048, 0);    zend_bool need_comma = 0;    ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, value) {        if (need_comma) {            smart_str_appendl(&buf, ", ", 2);        } else {            need_comma = 1;        }        smart_str_appendc(&buf, '"');        if (str_idx) {            escape_string(&buf, str_idx);        } else {            smart_str_append_long(&buf, (long) num_idx);        }        smart_str_appendl(&buf, "/"=>", 3);        if (Z_TYPE_P(value) == IS_NULL) {            smart_str_appendl(&buf, "NULL", 4);        } else {            convert_to_string_ex(value);            smart_str_appendc(&buf, '"');            zend_string *str = zval_get_string(value);            escape_string(&buf, str);            zend_string_release(str);            smart_str_appendc(&buf, '"');        }    } ZEND_HASH_FOREACH_END();	smart_str_0(&buf); /* copy? */	ZVAL_NEW_STR(return_value, buf.s);}

static zend_bool zlib_create_dictionary_string(HashTable *options, char **dict, size_t *dictlen) {	zval *option_buffer;	if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("dictionary"))) != NULL) {		HashTable *dictionary;		ZVAL_DEREF(option_buffer);		if (Z_TYPE_P(option_buffer) != IS_ARRAY) {			php_error_docref(NULL, E_WARNING, "dictionary must be of type array, got %s", zend_get_type_by_const(Z_TYPE_P(option_buffer)));			return 0;		}		dictionary = Z_ARR_P(option_buffer);		if (zend_hash_num_elements(dictionary) > 0) {			char *dictptr;			zval *cur;			zend_string **strings = emalloc(sizeof(zend_string *) * zend_hash_num_elements(dictionary));			zend_string **end, **ptr = strings - 1;			ZEND_HASH_FOREACH_VAL(dictionary, cur) {				int i;				*++ptr = zval_get_string(cur);				if (!*ptr || (*ptr)->len == 0) {					if (*ptr) {						efree(*ptr);					}					while (--ptr >= strings) {						efree(ptr);					}					efree(strings);					php_error_docref(NULL, E_WARNING, "dictionary entries must be non-empty strings");					return 0;				}				for (i = 0; i < (*ptr)->len; i++) {					if ((*ptr)->val[i] == 0) {						do {							efree(ptr);						} while (--ptr >= strings);						efree(strings);						php_error_docref(NULL, E_WARNING, "dictionary entries must not contain a NULL-byte");						return 0;					}				}				*dictlen += (*ptr)->len + 1;			} ZEND_HASH_FOREACH_END();

int dom_characterdata_data_write(dom_object *obj, zval *newval){	xmlNode *nodep = dom_object_get_node(obj);	zend_string *str;	if (nodep == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	str = zval_get_string(newval);	xmlNodeSetContentLen(nodep, (xmlChar *) str->val, str->len + 1);	zend_string_release(str);	return SUCCESS;}

static void from_zval_write_sin6_addr(const zval *zaddr_str, char *addr6, ser_context *ctx){	int					res;	struct sockaddr_in6	saddr6 = {0};	zend_string			*addr_str;	addr_str = zval_get_string((zval *) zaddr_str);	res = php_set_inet6_addr(&saddr6, addr_str->val, ctx->sock);	if (res) {		memcpy(addr6, &saddr6.sin6_addr, sizeof saddr6.sin6_addr);	} else {		/* error already emitted, but let's emit another more relevant */		do_from_zval_err(ctx, "could not resolve address '%s' to get an AF_INET6 "				"address", Z_STRVAL_P(zaddr_str));	}	zend_string_release(addr_str);}

zend_string *ds_join_zval_buffer(    zval        *buffer,    zend_long    size,    char        *glue,    size_t       len) {    smart_str str = {0};    if (size <= 0) {        return ZSTR_EMPTY_ALLOC();    }    if (size == 1) {        return zval_get_string(buffer);    }    // Glue is optional, will use empty string by default if NULL    if (glue && len) {        zval *pos = buffer;        zval *end = buffer + size - 1; // Exclude last value        // Append each part and the glue right up to the last value.        do {            smart_str_appendz(&str, pos);            smart_str_appendl(&str, glue, len);        } while (++pos != end);        // Append last value        smart_str_appendz(&str, pos);    } else {        zval *pos = buffer;        zval *end = buffer + size;        // Append each part including the last, without glue.        do {            smart_str_appendz(&str, pos);        } while (++pos != end);    }    smart_str_0(&str);    return str.s;}

int dom_attr_value_write(dom_object *obj, zval *newval){	zend_string *str;	xmlAttrPtr attrp = (xmlAttrPtr) dom_object_get_node(obj);	if (attrp == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	if (attrp->children) {		node_list_unlink(attrp->children);	}	str = zval_get_string(newval);	xmlNodeSetContentLen((xmlNodePtr) attrp, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);	zend_string_release(str);	return SUCCESS;}

/* {{{ proto Closure Closure::bind(Closure $old, object $to [, mixed $scope = "static" ] )   Create a closure from another one and bind to another object and scope */ZEND_METHOD(Closure, bind){	zval *newthis, *zclosure, *scope_arg = NULL;	zend_closure *closure;	zend_class_entry *ce;	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {		RETURN_NULL();	}	closure = (zend_closure *)Z_OBJ_P(zclosure);	if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {		zend_error(E_WARNING, "Cannot bind an instance to a static closure");	}	if (scope_arg != NULL) { /* scope argument was given */		if (IS_ZEND_STD_OBJECT(*scope_arg)) {			ce = Z_OBJCE_P(scope_arg);		} else if (Z_TYPE_P(scope_arg) == IS_NULL) {			ce = NULL;		} else {			zend_string *class_name = zval_get_string(scope_arg);			if ((class_name->len == sizeof("static") - 1) &&				(memcmp("static", class_name->val, sizeof("static") - 1) == 0)) {				ce = closure->func.common.scope;			} else if ((ce = zend_lookup_class_ex(class_name, NULL, 1 TSRMLS_CC)) == NULL) {				zend_error(E_WARNING, "Class '%s' not found", class_name->val);				STR_RELEASE(class_name);				RETURN_NULL();			}			STR_RELEASE(class_name);		}	} else { /* scope argument not given; do not change the scope by default */		ce = closure->func.common.scope;	}	zend_create_closure(return_value, &closure->func, ce, newthis TSRMLS_CC);}

/** * Replaces directory separators by the virtual separator */void zephir_prepare_virtual_path(zval *return_value, zval *path, zval *virtual_separator){	unsigned int i;	unsigned char ch;	smart_str virtual_str = {0};	if (Z_TYPE_P(path) != IS_STRING || Z_TYPE_P(virtual_separator) != IS_STRING) {		if (Z_TYPE_P(path) == IS_STRING) {			RETURN_STR(zval_get_string(path));		} else {			RETURN_EMPTY_STRING();		}		return;	}	for (i = 0; i < Z_STRLEN_P(path); i++) {		ch = Z_STRVAL_P(path)[i];		if (ch == '/0') {			break;		}		if (ch == '/' || ch == '//' || ch == ':') {			smart_str_appendl(&virtual_str, Z_STRVAL_P(virtual_separator), Z_STRLEN_P(virtual_separator));		}		else {			smart_str_appendc(&virtual_str, tolower(ch));		}	}	smart_str_0(&virtual_str);	if (virtual_str.s) {		RETURN_STR(virtual_str.s);	} else {		RETURN_EMPTY_STRING();	}}

static zend_bool zlib_create_dictionary_string(HashTable *options, char **dict, size_t *dictlen) {	zval *option_buffer;	if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("dictionary"))) != NULL) {		ZVAL_DEREF(option_buffer);		switch (Z_TYPE_P(option_buffer)) {			case IS_STRING: {				zend_string *str = Z_STR_P(option_buffer);				int i;				zend_bool last_null = 1;				for (i = 0; i < ZSTR_LEN(str); i++) {					if (ZSTR_VAL(str)[i]) {						last_null = 0;					} else {						if (last_null) {							php_error_docref(NULL, E_WARNING, "dictionary string must not contain empty entries (two consecutive NULL-bytes or one at the very beginning)");							return 0;						}						last_null = 1;					}				}				if (!last_null) {					php_error_docref(NULL, E_WARNING, "dictionary string must be NULL-byte terminated (each dictionary entry has to be NULL-terminated)");				}				*dict = emalloc(ZSTR_LEN(str));				memcpy(*dict, ZSTR_VAL(str), ZSTR_LEN(str));				*dictlen = ZSTR_LEN(str);			} break;			case IS_ARRAY: {				HashTable *dictionary = Z_ARR_P(option_buffer);				if (zend_hash_num_elements(dictionary) > 0) {					char *dictptr;					zval *cur;					zend_string **strings = emalloc(sizeof(zend_string *) * zend_hash_num_elements(dictionary));					zend_string **end, **ptr = strings - 1;					ZEND_HASH_FOREACH_VAL(dictionary, cur) {						int i;						*++ptr = zval_get_string(cur);						if (!*ptr || ZSTR_LEN(*ptr) == 0) {							if (*ptr) {								efree(*ptr);							}							while (--ptr >= strings) {								efree(ptr);							}							efree(strings);							php_error_docref(NULL, E_WARNING, "dictionary entries must be non-empty strings");							return 0;						}						for (i = 0; i < ZSTR_LEN(*ptr); i++) {							if (ZSTR_VAL(*ptr)[i] == 0) {								do {									efree(ptr);								} while (--ptr >= strings);								efree(strings);								php_error_docref(NULL, E_WARNING, "dictionary entries must not contain a NULL-byte");								return 0;							}						}						*dictlen += ZSTR_LEN(*ptr) + 1;					} ZEND_HASH_FOREACH_END();					dictptr = *dict = emalloc(*dictlen);					ptr = strings;					end = strings + zend_hash_num_elements(dictionary);					do {						memcpy(dictptr, ZSTR_VAL(*ptr), ZSTR_LEN(*ptr));						dictptr += ZSTR_LEN(*ptr);						*dictptr++ = 0;						zend_string_release(*ptr);					} while (++ptr != end);					efree(strings);				}			} break;

php_http_message_parser_state_t php_http_message_parser_parse(php_http_message_parser_t *parser, php_http_buffer_t *buffer, unsigned flags, php_http_message_t **message){	char *str = NULL;	size_t len = 0;	size_t cut = 0;	while (buffer->used || !php_http_message_parser_states[php_http_message_parser_state_is(parser)].need_data) {#if DBG_PARSER		fprintf(stderr, "#MP: %s (f: %u, t:%d, l:%zu)/n", 			php_http_message_parser_state_name(php_http_message_parser_state_is(parser)),			flags, 			message && *message ? (*message)->type : -1, 			buffer->used		);		_dpf(0, buffer->data, buffer->used);#endif		switch (php_http_message_parser_state_pop(parser))		{			case PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE:				return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);			case PHP_HTTP_MESSAGE_PARSER_STATE_START:			{				char *ptr = buffer->data;				while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {					++ptr;				}				php_http_buffer_cut(buffer, 0, ptr - buffer->data);				if (buffer->used) {					php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);				}				break;			}			case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER:			{				unsigned header_parser_flags = (flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP) ? PHP_HTTP_HEADER_PARSER_CLEANUP : 0;				switch (php_http_header_parser_parse(&parser->header, buffer, header_parser_flags, *message ? &(*message)->hdrs : NULL, (php_http_info_callback_t) php_http_message_info_callback, message)) {					case PHP_HTTP_HEADER_PARSER_STATE_FAILURE:						return PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;					case PHP_HTTP_HEADER_PARSER_STATE_DONE:						php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);						break;					default:						if (buffer->used || !(flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP)) {							return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);						} else {							php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);						}				}				break;			}			case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE:			{				zval h, *h_ptr, *h_loc = NULL, *h_con = NULL, *h_ce;				zend_bool chunked = 0;				zend_long content_length = -1;				zend_string *content_range = NULL;				/* Content-Range has higher precedence than Content-Length,				 * and content-length denotes the original length of the entity,				 * so let's *NOT* remove CR/CL, because that would fundamentally				 * change the meaning of the whole message				 */				if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Transfer-Encoding")))) {					zend_string *zs = zval_get_string(h_ptr);					chunked = zend_string_equals_literal(zs, "chunked");					zend_string_release(zs);					Z_TRY_ADDREF_P(h_ptr);					zend_hash_str_update(&(*message)->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), h_ptr);					zend_hash_str_del(&(*message)->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));					/* reset */					ZVAL_LONG(&h, 0);					zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &h);				} else if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Content-Length")))) {					content_length = zval_get_long(h_ptr);					Z_TRY_ADDREF_P(h_ptr);					zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), h_ptr);				}				if ((content_range = php_http_message_header_string(*message, ZEND_STRL("Content-Range")))) {					ZVAL_STR_COPY(&h, content_range);					zend_hash_str_update(&(*message)->hdrs, "Content-Range", lenof("Content-Range"), &h);				}				/* so, if curl sees a 3xx code, a Location header and a Connection:close header				 * it decides not to read the response body.				 */				if ((flags & PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS)//.........这里部分代码省略.........

/** {{{ zend_string * yaf_route_map_assemble(zval *info, zval *query) */zend_string * yaf_route_map_assemble(yaf_route_t *this_ptr, zval *info, zval *query) {	char *seg, *ptrptr, *pname;	smart_str uri = {0};	size_t seg_len;	zend_bool has_delim = 0;	zval *delim, *ctl_prefer, *zv;	ctl_prefer = zend_read_property(yaf_route_map_ce, this_ptr, ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_CTL_PREFER), 1, NULL);	delim = zend_read_property(yaf_route_map_ce, this_ptr, ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_DELIMETER), 1, NULL);	if (IS_STRING == Z_TYPE_P(delim) && Z_STRLEN_P(delim)) {		has_delim = 1;	}	do {		if (Z_TYPE_P(ctl_prefer) == IS_TRUE) {			if ((zv = zend_hash_str_find(Z_ARRVAL_P(info),					ZEND_STRL(YAF_ROUTE_ASSEMBLE_ACTION_FORMAT))) != NULL && Z_TYPE_P(zv) == IS_STRING) {				pname = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));			} else {				yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s",						"Undefined the 'action' parameter for the 1st parameter");				break;			}		} else {			if ((zv = zend_hash_str_find(Z_ARRVAL_P(info),					ZEND_STRL(YAF_ROUTE_ASSEMBLE_CONTROLLER_FORMAT))) != NULL && Z_TYPE_P(zv) == IS_STRING) {				pname = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));			} else {				yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s",						"Undefined the 'controller' parameter for the 1st parameter");				break;			}		}		seg = php_strtok_r(pname, "_", &ptrptr);			while (seg) {			seg_len = strlen(seg);			if (seg_len) {				smart_str_appendc(&uri, '/');				smart_str_appendl(&uri, seg, seg_len);			}			seg = php_strtok_r(NULL, "_", &ptrptr);		}		efree(pname);		if (query && IS_ARRAY == Z_TYPE_P(query)) {			zend_bool start = 1;			zend_string *key, *val;			if (has_delim) {				smart_str_appendc(&uri, '/');				smart_str_appendl(&uri, Z_STRVAL_P(delim), Z_STRLEN_P(delim));			}            ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(query), key, zv) {				if (key) {					val = zval_get_string(zv);					if (has_delim) {						smart_str_appendc(&uri, '/');						smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key));						smart_str_appendc(&uri, '/');						smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));					} else {						if (start) {							smart_str_appendc(&uri, '?');							smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key));							smart_str_appendc(&uri, '=');							smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));							start = 0;						} else {							smart_str_appendc(&uri, '&');							smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key));							smart_str_appendc(&uri, '=');							smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));						}					}					zend_string_release(val);				}			} ZEND_HASH_FOREACH_END();		}		smart_str_0(&uri);		return uri.s;	} while (0);

//.........这里部分代码省略.........				memcpy(p, num_prefix, num_prefix_len);				p += num_prefix_len;				memcpy(p, ekey, ekey_len);				p += ekey_len;				efree(ekey);				if (key_suffix) {					memcpy(p, key_suffix, key_suffix_len);					p += key_suffix_len;				}				*(p++) = '%';				*(p++) = '5';				*(p++) = 'B';				*p = '/0';			}			if (ZEND_HASH_APPLY_PROTECTION(ht)) {				ht->u.v.nApplyCount++;			}			php_url_encode_hash_ex(HASH_OF(zdata), formstr, NULL, 0, newprefix, newprefix_len, "%5D", 3, (Z_TYPE_P(zdata) == IS_OBJECT ? zdata : NULL), arg_sep, enc_type);			if (ZEND_HASH_APPLY_PROTECTION(ht)) {				ht->u.v.nApplyCount--;			}			efree(newprefix);		} else if (Z_TYPE_P(zdata) == IS_NULL || Z_TYPE_P(zdata) == IS_RESOURCE) {			/* Skip these types */			continue;		} else {			if (formstr->s) {				smart_str_appendl(formstr, arg_sep, arg_sep_len);			}			/* Simple key=value */			smart_str_appendl(formstr, key_prefix, key_prefix_len);			if (key) {				zend_string *ekey;				if (enc_type == PHP_QUERY_RFC3986) {					ekey = php_raw_url_encode(prop_name, prop_len);				} else {					ekey = php_url_encode(prop_name, prop_len);				}				smart_str_append(formstr, ekey);				zend_string_free(ekey);			} else {				/* Numeric key */				if (num_prefix) {					smart_str_appendl(formstr, num_prefix, num_prefix_len);				}				smart_str_append_long(formstr, idx);			}			smart_str_appendl(formstr, key_suffix, key_suffix_len);			smart_str_appendl(formstr, "=", 1);			switch (Z_TYPE_P(zdata)) {				case IS_STRING: {						zend_string *ekey;						if (enc_type == PHP_QUERY_RFC3986) {							ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata));						} else {							ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata));						}						smart_str_append(formstr, ekey);						zend_string_free(ekey);					}					break;				case IS_LONG:					smart_str_append_long(formstr, Z_LVAL_P(zdata));					break;				case IS_FALSE:					smart_str_appendl(formstr, "0", sizeof("0")-1);					break;				case IS_TRUE:					smart_str_appendl(formstr, "1", sizeof("1")-1);					break;				case IS_DOUBLE:					{						char *ekey;					  	size_t ekey_len;						ekey_len = spprintf(&ekey, 0, "%.*G", (int) EG(precision), Z_DVAL_P(zdata));						smart_str_appendl(formstr, ekey, ekey_len);						efree(ekey);				  	}					break;				default:					{						zend_string *ekey;						zend_string *tmp = zval_get_string(zdata);						if (enc_type == PHP_QUERY_RFC3986) {							ekey = php_raw_url_encode(tmp->val, tmp->len);						} else {							ekey = php_url_encode(tmp->val, tmp->len);						}						smart_str_append(formstr, ekey);						zend_string_release(tmp);						zend_string_free(ekey);					}			}		}	} ZEND_HASH_FOREACH_END();	return SUCCESS;}

//.........这里部分代码省略.........						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);	}}

/** {{{ zend_string * yaf_route_simple_assemble(zval *info, zval *query) */zend_string * yaf_route_simple_assemble(yaf_route_t *this_ptr, zval *info, zval *query) {	smart_str uri = {0};	zend_string *val;	zval *nmodule, *ncontroller, *naction;	smart_str_appendc(&uri, '?');	nmodule = zend_read_property(yaf_route_simple_ce,			this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_MODULE), 1, NULL);	ncontroller = zend_read_property(yaf_route_simple_ce,			this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_CONTROLLER), 1, NULL);	naction = zend_read_property(yaf_route_simple_ce,			this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_ACTION), 1, NULL);	do {		zval *zv;		if ((zv = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_MOUDLE_FORMAT))) != NULL) {			val = zval_get_string(zv);			smart_str_appendl(&uri, Z_STRVAL_P(nmodule), Z_STRLEN_P(nmodule));			smart_str_appendc(&uri, '=');			smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));			smart_str_appendc(&uri, '&');			zend_string_release(val);		} 		if ((zv = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_CONTROLLER_FORMAT))) == NULL) {			yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "You need to specify the controller by ':c'");			break;		}		val = zval_get_string(zv);		smart_str_appendl(&uri, Z_STRVAL_P(ncontroller), Z_STRLEN_P(ncontroller));		smart_str_appendc(&uri, '=');		smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));		smart_str_appendc(&uri, '&');		zend_string_release(val);		if ((zv = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_ACTION_FORMAT))) == NULL) {			yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "You need to specify the action by ':a'");			break;		}		val = zval_get_string(zv);		smart_str_appendl(&uri, Z_STRVAL_P(naction), Z_STRLEN_P(naction));		smart_str_appendc(&uri, '=');		smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));		zend_string_release(val);		if (query && IS_ARRAY == Z_TYPE_P(query)) {			zend_string *key;            ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(query), key, zv) {				if (key) {					val = zval_get_string(zv);					smart_str_appendc(&uri, '&');					smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key));					smart_str_appendc(&uri, '=');					smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val));					zend_string_release(val);				}			} ZEND_HASH_FOREACH_END();		}		smart_str_0(&uri);		return uri.s;	} while (0);

static inline void hstore_parse(HSParser *state, zval *result) /* {{{ */{    #define WKEY  0    #define WVAL  1    #define WEQ   2    #define WDEL  4    state->error   = 0;    int st = WKEY;    smart_str buf = {};    smart_str_alloc(&buf, 1024, 0);	zend_string *key;    while (state->ptr < state->ptr_max) {        char ch = *(state->ptr);        if (isspace((unsigned char) ch)) {            ++state->ptr;            continue;        }		if (st == WKEY) {            if (!hstore_parse_value(state, &buf, 0)) {                goto free;            }            key = zval_get_string(&state->value);            st = WEQ;        } else if (st == WEQ) {            if (state->ptr + 2 > state->ptr_max) {                state->error = ERROR_UNEXPECTED_END;                goto free;            }            if ('=' == *(state->ptr) && '>' == *(state->ptr + 1)) {                st          = WVAL;                state->ptr += 2;                continue;            }            state->error = ERROR_SYNTAX;            return;        } else if (st == WVAL) {            if (!hstore_parse_value(state, &buf, 1)) {                goto free;            }            zend_symtable_update(Z_ARRVAL_P(result), key, &state->value);            zend_string_release(key);            zend_string_release(key);            st = WDEL;        } else if (st == WDEL) {            if (',' == ch) {                st = WKEY;            } else {                state->error = ERROR_SYNTAX;                goto free;            }        } else {            state->error = ERROR_UNKNOWN_STATE;            goto free;        }        state->ptr++;    }    if (st != WKEY && st != WDEL) {        state->error = ERROR_UNEXPECTED_END;    }free:    smart_str_free(&buf);}

int dom_node_prefix_write(dom_object *obj, zval *newval){	zend_string *str;	xmlNode *nodep, *nsnode = NULL;	xmlNsPtr ns = NULL, curns;	char *strURI;	char *prefix;	nodep = dom_object_get_node(obj);	if (nodep == NULL) {		php_dom_throw_error(INVALID_STATE_ERR, 0);		return FAILURE;	}	switch (nodep->type) {		case XML_ELEMENT_NODE:			nsnode = nodep;		case XML_ATTRIBUTE_NODE:			if (nsnode == NULL) {				nsnode = nodep->parent;				if (nsnode == NULL) {					nsnode = xmlDocGetRootElement(nodep->doc);				}			}			str = zval_get_string(newval);			prefix = ZSTR_VAL(str);			if (nsnode && nodep->ns != NULL && !xmlStrEqual(nodep->ns->prefix, (xmlChar *)prefix)) {				strURI = (char *) nodep->ns->href;				if (strURI == NULL ||					(!strcmp(prefix, "xml") && strcmp(strURI, (char *) XML_XML_NAMESPACE)) ||					(nodep->type == XML_ATTRIBUTE_NODE && !strcmp(prefix, "xmlns") &&					 strcmp(strURI, (char *) DOM_XMLNS_NAMESPACE)) ||					(nodep->type == XML_ATTRIBUTE_NODE && !strcmp((char *) nodep->name, "xmlns"))) {					ns = NULL;				} else {					curns = nsnode->nsDef;					while (curns != NULL) {						if (xmlStrEqual((xmlChar *)prefix, curns->prefix) && xmlStrEqual(nodep->ns->href, curns->href)) {							ns = curns;							break;						}						curns = curns->next;					}					if (ns == NULL) {						ns = xmlNewNs(nsnode, nodep->ns->href, (xmlChar *)prefix);					}				}				if (ns == NULL) {					zend_string_release_ex(str, 0);					php_dom_throw_error(NAMESPACE_ERR, dom_get_strict_error(obj->document));					return FAILURE;				}				xmlSetNs(nodep, ns);			}			zend_string_release_ex(str, 0);			break;		default:			break;	}	return SUCCESS;}

static zend_string* php_password_get_salt(zval *return_value, size_t required_salt_len, HashTable *options) {	zend_string *buffer;	zval *option_buffer;	if (!options || !(option_buffer = zend_hash_str_find(options, "salt", sizeof("salt") - 1))) {		buffer = php_password_make_salt(required_salt_len);		if (!buffer) {			RETVAL_FALSE;		}		return buffer;	}	php_error_docref(NULL, E_DEPRECATED, "Use of the 'salt' option to password_hash is deprecated");	switch (Z_TYPE_P(option_buffer)) {		case IS_STRING:			buffer = zend_string_copy(Z_STR_P(option_buffer));			break;		case IS_LONG:		case IS_DOUBLE:		case IS_OBJECT:			buffer = zval_get_string(option_buffer);			break;		case IS_FALSE:		case IS_TRUE:		case IS_NULL:		case IS_RESOURCE:		case IS_ARRAY:		default:			php_error_docref(NULL, E_WARNING, "Non-string salt parameter supplied");			return NULL;	}	/* XXX all the crypt related APIs work with int for string length.		That should be revised for size_t and then we maybe don't require		the > INT_MAX check. */	if (ZEND_SIZE_T_INT_OVFL(ZSTR_LEN(buffer))) {		php_error_docref(NULL, E_WARNING, "Supplied salt is too long");		zend_string_release(buffer);		return NULL;	}	if (ZSTR_LEN(buffer) < required_salt_len) {		php_error_docref(NULL, E_WARNING, "Provided salt is too short: %zd expecting %zd", ZSTR_LEN(buffer), required_salt_len);		zend_string_release(buffer);		return NULL;	}	if (php_password_salt_is_alphabet(ZSTR_VAL(buffer), ZSTR_LEN(buffer)) == FAILURE) {		zend_string *salt = zend_string_alloc(required_salt_len, 0);		if (php_password_salt_to64(ZSTR_VAL(buffer), ZSTR_LEN(buffer), required_salt_len, ZSTR_VAL(salt)) == FAILURE) {			php_error_docref(NULL, E_WARNING, "Provided salt is too short: %zd", ZSTR_LEN(buffer));			zend_string_release(salt);			zend_string_release(buffer);			return NULL;		}		zend_string_release(buffer);		return salt;	} else {		zend_string *salt = zend_string_alloc(required_salt_len, 0);		memcpy(ZSTR_VAL(salt), ZSTR_VAL(buffer), required_salt_len);		zend_string_release(buffer);		return salt;	}}