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

void zephir_concat_vvvs(zval **result, zval *op1, zval *op2, zval *op3, const char *op4, zend_uint op4_len, int self_var TSRMLS_DC) {    zval result_copy, op1_copy, op2_copy, op3_copy;    int use_copy = 0, use_copy1 = 0, use_copy2 = 0, use_copy3 = 0;    uint offset = 0, length;    if (Z_TYPE_P(op1) != IS_STRING) {        zend_make_printable_zval(op1, &op1_copy, &use_copy1);        if (use_copy1) {            op1 = &op1_copy;        }    }    if (Z_TYPE_P(op2) != IS_STRING) {        zend_make_printable_zval(op2, &op2_copy, &use_copy2);        if (use_copy2) {            op2 = &op2_copy;        }    }    if (Z_TYPE_P(op3) != IS_STRING) {        zend_make_printable_zval(op3, &op3_copy, &use_copy3);        if (use_copy3) {            op3 = &op3_copy;        }    }    length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2) + Z_STRLEN_P(op3) + op4_len;    if (self_var) {        if (Z_TYPE_PP(result) != IS_STRING) {            zend_make_printable_zval(*result, &result_copy, &use_copy);            if (use_copy) {                ZEPHIR_CPY_WRT_CTOR(*result, (&result_copy));            }        }        offset = Z_STRLEN_PP(result);        length += offset;        Z_STRVAL_PP(result) = (char *) str_erealloc(Z_STRVAL_PP(result), length + 1);    } else {        Z_STRVAL_PP(result) = (char *) emalloc(length + 1);    }    memcpy(Z_STRVAL_PP(result) + offset, Z_STRVAL_P(op1), Z_STRLEN_P(op1));    memcpy(Z_STRVAL_PP(result) + offset + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));    memcpy(Z_STRVAL_PP(result) + offset + Z_STRLEN_P(op1) + Z_STRLEN_P(op2), Z_STRVAL_P(op3), Z_STRLEN_P(op3));    memcpy(Z_STRVAL_PP(result) + offset + Z_STRLEN_P(op1) + Z_STRLEN_P(op2) + Z_STRLEN_P(op3), op4, op4_len);    Z_STRVAL_PP(result)[length] = 0;    Z_TYPE_PP(result) = IS_STRING;    Z_STRLEN_PP(result) = length;    if (use_copy1) {        zval_dtor(op1);    }    if (use_copy2) {        zval_dtor(op2);    }    if (use_copy3) {        zval_dtor(op3);    }    if (use_copy) {        zval_dtor(&result_copy);    }}

static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops){	while (elements-- > 0) {		zval key, *data, d, *old_data;		zend_ulong idx;		ZVAL_UNDEF(&key);		if (!php_var_unserialize_ex(&key, p, max, NULL, classes)) {			zval_dtor(&key);			return 0;		}		data = NULL;		ZVAL_UNDEF(&d);		if (!objprops) {			if (Z_TYPE(key) == IS_LONG) {				idx = Z_LVAL(key);numeric_key:				if (UNEXPECTED((old_data = zend_hash_index_find(ht, idx)) != NULL)) {					//??? update hash					var_push_dtor(var_hash, old_data);					data = zend_hash_index_update(ht, idx, &d);				} else {					data = zend_hash_index_add_new(ht, idx, &d);				}			} else if (Z_TYPE(key) == IS_STRING) {				if (UNEXPECTED(ZEND_HANDLE_NUMERIC(Z_STR(key), idx))) {					goto numeric_key;				}				if (UNEXPECTED((old_data = zend_hash_find(ht, Z_STR(key))) != NULL)) {					//??? update hash					var_push_dtor(var_hash, old_data);					data = zend_hash_update(ht, Z_STR(key), &d);				} else {					data = zend_hash_add_new(ht, Z_STR(key), &d);				}			} else {				zval_dtor(&key);				return 0;			}		} else {			if (EXPECTED(Z_TYPE(key) == IS_STRING)) {string_key:				if ((old_data = zend_hash_find(ht, Z_STR(key))) != NULL) {					if (Z_TYPE_P(old_data) == IS_INDIRECT) {						old_data = Z_INDIRECT_P(old_data);					}					var_push_dtor(var_hash, old_data);					data = zend_hash_update_ind(ht, Z_STR(key), &d);				} else {					data = zend_hash_add_new(ht, Z_STR(key), &d);				}			} else if (Z_TYPE(key) == IS_LONG) {				/* object properties should include no integers */				convert_to_string(&key);				goto string_key;			} else {				zval_dtor(&key);				return 0;			}		}		zval_dtor(&key);		if (!php_var_unserialize_ex(data, p, max, var_hash, classes)) {			return 0;		}		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {			(*p)--;			return 0;		}	}	return 1;}

static void tokenize(zval *return_value){	zval token;	zval keyword;	int token_type;	zend_bool destroy;	int token_line = 1;	int need_tokens = -1; // for __halt_compiler lexing. -1 = disabled	array_init(return_value);	ZVAL_NULL(&token);	while ((token_type = lex_scan(&token))) {		destroy = 1;		switch (token_type) {			case T_CLOSE_TAG:				if (zendtext[zendleng - 1] != '>') {					CG(zend_lineno)++;				}			case T_OPEN_TAG:			case T_OPEN_TAG_WITH_ECHO:			case T_WHITESPACE:			case T_COMMENT:			case T_DOC_COMMENT:				destroy = 0;				break;		}		if (token_type >= 256) {			array_init(&keyword);			add_next_index_long(&keyword, token_type);			if (token_type == T_END_HEREDOC) {				if (CG(increment_lineno)) {					token_line = ++CG(zend_lineno);					CG(increment_lineno) = 0;				}			}			add_next_index_stringl(&keyword, (char *)zendtext, zendleng);			add_next_index_long(&keyword, token_line);			add_next_index_zval(return_value, &keyword);		} else {			add_next_index_stringl(return_value, (char *)zendtext, zendleng);		}		if (destroy && Z_TYPE(token) != IS_NULL) {			zval_dtor(&token);		}		ZVAL_NULL(&token);		// after T_HALT_COMPILER collect the next three non-dropped tokens		if (need_tokens != -1) {			if (token_type != T_WHITESPACE && token_type != T_OPEN_TAG			    && token_type != T_COMMENT && token_type != T_DOC_COMMENT			    && --need_tokens == 0			) {				// fetch the rest into a T_INLINE_HTML				if (zendcursor != zendlimit) {					array_init(&keyword);					add_next_index_long(&keyword, T_INLINE_HTML);					add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);					add_next_index_long(&keyword, token_line);					add_next_index_zval(return_value, &keyword);				}				break;			}		} else if (token_type == T_HALT_COMPILER) {			need_tokens = 3;		}		token_line = CG(zend_lineno);	}}

//.........这里部分代码省略.........			if (!redirected				|| (Z_STRLEN_PP(tmpzval) == 3 && memcmp("GET", Z_STRVAL_PP(tmpzval), 3) == 0)				|| (Z_STRLEN_PP(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_PP(tmpzval), 4) == 0)			) {				scratch_len = strlen(path) + 29 + Z_STRLEN_PP(tmpzval);				scratch = emalloc(scratch_len);				strlcpy(scratch, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval) + 1);				strncat(scratch, " ", 1);			}		}	} 	if (context && php_stream_context_get_option(context, "http", "protocol_version", &tmpzval) == SUCCESS) {		SEPARATE_ZVAL(tmpzval);		convert_to_double_ex(tmpzval);		protocol_version_len = spprintf(&protocol_version, 0, "%.1F", Z_DVAL_PP(tmpzval));	}	if (!scratch) {		scratch_len = strlen(path) + 29 + protocol_version_len;		scratch = emalloc(scratch_len);		strncpy(scratch, "GET ", scratch_len);	}	/* Should we send the entire path in the request line, default to no. */	if (!request_fulluri &&		context &&		php_stream_context_get_option(context, "http", "request_fulluri", &tmpzval) == SUCCESS) {		zval ztmp = **tmpzval;		zval_copy_ctor(&ztmp);		convert_to_boolean(&ztmp);		request_fulluri = Z_BVAL(ztmp) ? 1 : 0;		zval_dtor(&ztmp);	}	if (request_fulluri) {		/* Ask for everything */		strcat(scratch, path);	} else {		/* Send the traditional /path/to/file?query_string */		/* file */		if (resource->path && *resource->path) {			strlcat(scratch, resource->path, scratch_len);		} else {			strlcat(scratch, "/", scratch_len);		}		/* query string */		if (resource->query) {			strlcat(scratch, "?", scratch_len);			strlcat(scratch, resource->query, scratch_len);		}	}	/* protocol version we are speaking */	if (protocol_version) {		strlcat(scratch, " HTTP/", scratch_len);		strlcat(scratch, protocol_version, scratch_len);		strlcat(scratch, "/r/n", scratch_len);		efree(protocol_version);		protocol_version = NULL;	} else {		strlcat(scratch, " HTTP/1.0/r/n", scratch_len);	}

//.........这里部分代码省略.........			if (format[inpos] == 'l') {				inpos++;			}			PRINTF_DEBUG(("sprintf: format character='%c'/n", format[inpos]));			/* now we expect to find a type specifier */			if (multiuse) {				MAKE_STD_ZVAL(tmp);				*tmp = **(args[argnum]);				INIT_PZVAL(tmp);				zval_copy_ctor(tmp);			} else {				SEPARATE_ZVAL(args[argnum]);				tmp = *(args[argnum]);			}			switch (format[inpos]) {				case 's': {					zval *var, var_copy;					int use_copy;					zend_make_printable_zval(tmp, &var_copy, &use_copy);					if (use_copy) {						var = &var_copy;					} else {						var = tmp;					}					php_sprintf_appendstring(&result, &outpos, &size,											 Z_STRVAL_P(var),											 width, precision, padding,											 alignment,											 Z_STRLEN_P(var),											 0, expprec, 0);					if (use_copy) {						zval_dtor(&var_copy);					}					break;				}				case 'd':					convert_to_long(tmp);					php_sprintf_appendint(&result, &outpos, &size,										  Z_LVAL_P(tmp),										  width, padding, alignment,										  always_sign);					break;				case 'u':					convert_to_long(tmp);					php_sprintf_appenduint(&result, &outpos, &size,										  Z_LVAL_P(tmp),										  width, padding, alignment);					break;				case 'g':				case 'G':				case 'e':				case 'E':				case 'f':				case 'F':					convert_to_double(tmp);					php_sprintf_appenddouble(&result, &outpos, &size,											 Z_DVAL_P(tmp),											 width, padding, alignment,											 precision, adjusting,											 format[inpos], always_sign											 TSRMLS_CC);

PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars_array){	char *p = NULL;	char *ip = NULL;		/* index pointer */	char *index;	char *var, *var_orig;	size_t var_len, index_len;	zval gpc_element, *gpc_element_p;	zend_bool is_array = 0;	HashTable *symtable1 = NULL;	ALLOCA_FLAG(use_heap)	assert(var_name != NULL);	if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) {		symtable1 = Z_ARRVAL_P(track_vars_array);	}	if (!symtable1) {		/* Nothing to do */		zval_dtor(val);		return;	}	/* ignore leading spaces in the variable name */	while (*var_name && *var_name==' ') {		var_name++;	}	/*	 * Prepare variable name	 */	var_len = strlen(var_name);	var = var_orig = do_alloca(var_len + 1, use_heap);	memcpy(var_orig, var_name, var_len + 1);	/* ensure that we don't have spaces or dots in the variable name (not binary safe) */	for (p = var; *p; p++) {		if (*p == ' ' || *p == '.') {			*p='_';		} else if (*p == '[') {			is_array = 1;			ip = p;			*p = 0;			break;		}	}	var_len = p - var;	if (var_len==0) { /* empty variable name, or variable name with a space in it */		zval_dtor(val);		free_alloca(var_orig, use_heap);		return;	}	/* GLOBALS hijack attempt, reject parameter */	if (symtable1 == &EG(symbol_table) &&		var_len == sizeof("GLOBALS")-1 &&		!memcmp(var, "GLOBALS", sizeof("GLOBALS")-1)) {		zval_dtor(val);		free_alloca(var_orig, use_heap);		return;	}	index = var;	index_len = var_len;	if (is_array) {		int nest_level = 0;		while (1) {			char *index_s;			size_t new_idx_len = 0;			if(++nest_level > PG(max_input_nesting_level)) {				HashTable *ht;				/* too many levels of nesting */				if (track_vars_array) {					ht = Z_ARRVAL_P(track_vars_array);					zend_symtable_str_del(ht, var, var_len);				}				zval_dtor(val);				/* do not output the error message to the screen,				 this helps us to to avoid "information disclosure" */				if (!PG(display_errors)) {					php_error_docref(NULL, E_WARNING, "Input variable nesting level exceeded " ZEND_LONG_FMT ". To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level));				}				free_alloca(var_orig, use_heap);				return;			}			ip++;			index_s = ip;			if (isspace(*ip)) {				ip++;			}			if (*ip==']') {//.........这里部分代码省略.........

int zend_optimizer_replace_by_const(zend_op_array *op_array,                                    zend_op       *opline,                                    zend_uchar     type,                                    uint32_t       var,                                    zval          *val){	zend_op *end = op_array->opcodes + op_array->last;	while (opline < end) {		if (ZEND_OP1_TYPE(opline) == type &&			ZEND_OP1(opline).var == var) {			switch (opline->opcode) {				case ZEND_FETCH_DIM_W:				case ZEND_FETCH_DIM_RW:				case ZEND_FETCH_DIM_FUNC_ARG:				case ZEND_FETCH_DIM_UNSET:				case ZEND_ASSIGN_DIM:				case ZEND_SEPARATE:					return 0;				case ZEND_SEND_VAR:					opline->extended_value = 0;					opline->opcode = ZEND_SEND_VAL;					break;				case ZEND_SEND_VAR_EX:					opline->extended_value = 0;					opline->opcode = ZEND_SEND_VAL_EX;					break;				case ZEND_SEND_VAR_NO_REF:					if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) {						if (opline->extended_value & ZEND_ARG_SEND_BY_REF) {							return 0;						}						opline->extended_value = 0;						opline->opcode = ZEND_SEND_VAL_EX;					} else {						opline->extended_value = 0;						opline->opcode = ZEND_SEND_VAL;					}					break;				/* In most cases IS_TMP_VAR operand may be used only once.				 * The operands are usually destroyed by the opcode handler.				 * ZEND_CASE is an exception, that keeps operand unchanged,				 * and allows its reuse. The number of ZEND_CASE instructions				 * usually terminated by ZEND_FREE that finally kills the value.				 */				case ZEND_CASE: {					zval old_val;					ZVAL_COPY_VALUE(&old_val, val);					zval_copy_ctor(val);					zend_optimizer_update_op1_const(op_array, opline, val);					ZVAL_COPY_VALUE(val, &old_val);					opline++;					continue;				}				case ZEND_FREE:					MAKE_NOP(opline);					zval_dtor(val);					return 1;				default:					break;			}			zend_optimizer_update_op1_const(op_array, opline, val);			break;		}		if (ZEND_OP2_TYPE(opline) == type &&			ZEND_OP2(opline).var == var) {			switch (opline->opcode) {				case ZEND_ASSIGN_REF:					return 0;				default:					break;			}			zend_optimizer_update_op2_const(op_array, opline, val);			break;		}		opline++;	}	return 1;}

//.........这里部分代码省略.........					p[0] == '//' && p[1] >= '0' && p[1] <= '9') {						n = p[1] - '0';					}					if (n >= 0 && n < regs->num_regs) {						if (regs->beg[n] >= 0 && regs->beg[n] < regs->end[n] && regs->end[n] <= string_len) {							smart_str_appendl(pbuf, string + regs->beg[n], regs->end[n] - regs->beg[n]);						}						p += 2;						i += 2;					} else {						smart_str_appendl(pbuf, p, fwd);						p += fwd;						i += fwd;					}				}			}							if (eval) {				zval v;				/* null terminate buffer */				smart_str_0(&eval_buf);				/* do eval */				if (zend_eval_stringl(eval_buf.s->val, eval_buf.s->len, &v, description) == FAILURE) {					efree(description);					php_error_docref(NULL,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, eval_buf.s->val);					/* zend_error() does not return in this case */				}				/* result of eval */				convert_to_string(&v);				smart_str_appendl(&out_buf, Z_STRVAL(v), Z_STRLEN(v));				/* Clean up */				eval_buf.s->len = 0;				zval_dtor(&v);			} else if (is_callable) {				zval args[1];				zval subpats, retval;				int i;								array_init(&subpats);				for (i = 0; i < regs->num_regs; i++) {					add_next_index_stringl(&subpats, string + regs->beg[i], regs->end[i] - regs->beg[i]);				}												ZVAL_COPY_VALUE(&args[0], &subpats);				/* null terminate buffer */				smart_str_0(&eval_buf);								arg_replace_fci.param_count = 1;				arg_replace_fci.params = args;				arg_replace_fci.retval = &retval;				if (zend_call_function(&arg_replace_fci, &arg_replace_fci_cache) == SUCCESS &&						!Z_ISUNDEF(retval)) {					convert_to_string_ex(&retval);					smart_str_appendl(&out_buf, Z_STRVAL(retval), Z_STRLEN(retval));					if (eval_buf.s) {						eval_buf.s->len = 0;					}					zval_ptr_dtor(&retval);				} else {					efree(description);					if (!EG(exception)) {						php_error_docref(NULL, E_WARNING, "Unable to call custom replacement function");					}				}				zval_ptr_dtor(&subpats);

static int create_transliterator( char *str_id, size_t str_id_len, zend_long direction, zval *object ){	Transliterator_object *to;	UChar	              *ustr_id    = NULL;	int32_t               ustr_id_len = 0;	UTransliterator       *utrans;	UParseError           parse_error   = {0, -1};	intl_error_reset( NULL );	if( ( direction != TRANSLITERATOR_FORWARD ) && (direction != TRANSLITERATOR_REVERSE ) )	{		intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,			"transliterator_create: invalid direction", 0 );		return FAILURE;	}	object_init_ex( object, Transliterator_ce_ptr );	TRANSLITERATOR_METHOD_FETCH_OBJECT_NO_CHECK; /* fetch zend object from zval "object" into "to" */	/* Convert transliterator id to UTF-16 */	intl_convert_utf8_to_utf16( &ustr_id, &ustr_id_len, str_id, str_id_len, TRANSLITERATOR_ERROR_CODE_P( to ) );	if( U_FAILURE( TRANSLITERATOR_ERROR_CODE( to ) ) )	{		intl_error_set_code( NULL, TRANSLITERATOR_ERROR_CODE( to ) );		intl_error_set_custom_msg( NULL, "String conversion of id to UTF-16 failed", 0 );		zval_dtor( object );		return FAILURE;	}	/* Open ICU Transliterator. */	utrans = utrans_openU( ustr_id, ustr_id_len, (UTransDirection ) direction,		NULL, -1, &parse_error, TRANSLITERATOR_ERROR_CODE_P( to ) );	if (ustr_id) {		efree( ustr_id );	}	if( U_FAILURE( TRANSLITERATOR_ERROR_CODE( to ) ) )	{		char *buf = NULL;		intl_error_set_code( NULL, TRANSLITERATOR_ERROR_CODE( to ) );		spprintf( &buf, 0, "transliterator_create: unable to open ICU transliterator"			" with id /"%s/"", str_id );		if( buf == NULL ) {			intl_error_set_custom_msg( NULL,				"transliterator_create: unable to open ICU transliterator", 0 );		}		else		{			intl_error_set_custom_msg( NULL, buf, /* copy message */ 1 );			efree( buf );		}		zval_dtor( object );		return FAILURE;	}	transliterator_object_construct( object, utrans, TRANSLITERATOR_ERROR_CODE_P( to ) );	/* no need to close the transliterator manually on construction error */	if( U_FAILURE( TRANSLITERATOR_ERROR_CODE( to ) ) )	{		intl_error_set_code( NULL, TRANSLITERATOR_ERROR_CODE( to ) );		intl_error_set_custom_msg( NULL,			"transliterator_create: internal constructor call failed", 0 );		zval_dtor( object );		return FAILURE;	}	return SUCCESS;}

 ~PHPTransport() {     efree(buffer);     zval_dtor(&t); }

/* {{{ _php_mb_regex_ereg_exec */static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase){	zval *arg_pattern, *array;	char *string;	size_t string_len;	php_mb_regex_t *re;	OnigRegion *regs = NULL;	int i, match_len, beg, end;	OnigOptionType options;	char *str;	array = NULL;	if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs|z/", &arg_pattern, &string, &string_len, &array) == FAILURE) {		RETURN_FALSE;	}	options = MBREX(regex_default_options);	if (icase) {		options |= ONIG_OPTION_IGNORECASE;	}	/* compile the regular expression from the supplied regex */	if (Z_TYPE_P(arg_pattern) != IS_STRING) {		/* we convert numbers to integers and treat them as a string */		if (Z_TYPE_P(arg_pattern) == IS_DOUBLE) {			convert_to_long_ex(arg_pattern);	/* get rid of decimal places */		}		convert_to_string_ex(arg_pattern);		/* don't bother doing an extended regex with just a number */	}	if (Z_STRLEN_P(arg_pattern) == 0) {		php_error_docref(NULL, E_WARNING, "empty pattern");		RETVAL_FALSE;		goto out;	}	re = php_mbregex_compile_pattern(Z_STRVAL_P(arg_pattern), Z_STRLEN_P(arg_pattern), options, MBREX(current_mbctype), MBREX(regex_default_syntax));	if (re == NULL) {		RETVAL_FALSE;		goto out;	}	regs = onig_region_new();	/* actually execute the regular expression */	if (onig_search(re, (OnigUChar *)string, (OnigUChar *)(string + string_len), (OnigUChar *)string, (OnigUChar *)(string + string_len), regs, 0) < 0) {		RETVAL_FALSE;		goto out;	}	match_len = 1;	str = string;	if (array != NULL) {		zval_dtor(array);		array_init(array);		match_len = regs->end[0] - regs->beg[0];		for (i = 0; i < regs->num_regs; i++) {			beg = regs->beg[i];			end = regs->end[i];			if (beg >= 0 && beg < end && end <= string_len) {				add_index_stringl(array, i, (char *)&str[beg], end - beg);			} else {				add_index_bool(array, i, 0);			}		}	}	if (match_len == 0) {		match_len = 1;	}	RETVAL_LONG(match_len);out:	if (regs != NULL) {		onig_region_free(regs, 1);	}}

 ~PHPExceptionWrapper() throw() {     zval_dtor(&ex); }

static int _php_tidy_set_tidy_opt(TidyDoc doc, char *optname, zval *value){	TidyOption opt = tidyGetOptionByName(doc, optname);	zval conv;	ZVAL_COPY_VALUE(&conv, value);	if (!opt) {		php_error_docref(NULL, E_NOTICE, "Unknown Tidy Configuration Option '%s'", optname);		return FAILURE;	}	if (tidyOptIsReadOnly(opt)) {		php_error_docref(NULL, E_NOTICE, "Attempting to set read-only option '%s'", optname);		return FAILURE;	}	switch(tidyOptGetType(opt)) {		case TidyString:			if (Z_TYPE(conv) != IS_STRING) {				zval_copy_ctor(&conv);				convert_to_string(&conv);			}			if (tidyOptSetValue(doc, tidyOptGetId(opt), Z_STRVAL(conv))) {				if (Z_TYPE(conv) != Z_TYPE_P(value)) {					zval_dtor(&conv);				}				return SUCCESS;			}			if (Z_TYPE(conv) != Z_TYPE_P(value)) {				zval_dtor(&conv);			}			break;		case TidyInteger:			if (Z_TYPE(conv) != IS_LONG) {				zval_copy_ctor(&conv);				convert_to_long(&conv);			}			if (tidyOptSetInt(doc, tidyOptGetId(opt), Z_LVAL(conv))) {				return SUCCESS;			}			break;		case TidyBoolean:			if (Z_TYPE(conv) != IS_LONG) {				zval_copy_ctor(&conv);				convert_to_long(&conv);			}			if (tidyOptSetBool(doc, tidyOptGetId(opt), Z_LVAL(conv))) {				return SUCCESS;			}			break;		default:			php_error_docref(NULL, E_WARNING, "Unable to determine type of configuration option");			break;	}	return FAILURE;}

 ~value() {     zval_dtor(static_cast<zval*>(this)); }

/* event must be initialized with MAKE_STD_ZVAL or similar and array_init before sending here */void php_aware_capture_error_ex(zval *event, int type, const char *error_filename, const uint error_lineno, zend_bool free_event, const char *format, va_list args TSRMLS_DC){	zval **ppzval;	va_list args_cp;	int len;	char *buffer;	char uuid_str[PHP_AWARE_UUID_LEN + 1];		TSRMLS_FETCH();		/* Generate unique identifier */	if (!php_aware_generate_uuid(uuid_str)) {		php_aware_original_error_cb(E_WARNING TSRMLS_CC, "Failed to generate uuid");		return;	}	/* Capture superglobals */	if (AWARE_G(log_get)) {		_add_assoc_zval_helper(event, "_GET", sizeof("_GET") TSRMLS_CC);	}		if (AWARE_G(log_post)) {		_add_assoc_zval_helper(event, "_POST", sizeof("_POST") TSRMLS_CC);	}		if (AWARE_G(log_cookie)) {		_add_assoc_zval_helper(event, "_COOKIE", sizeof("_COOKIE") TSRMLS_CC);	}		if (AWARE_G(log_session)) {		_add_assoc_zval_helper(event, "_SESSION", sizeof("_SESSION") TSRMLS_CC);	}		if (AWARE_G(log_server)) {		_add_assoc_zval_helper(event, "_SERVER", sizeof("_SERVER") TSRMLS_CC);	}		if (AWARE_G(log_env)) {		_add_assoc_zval_helper(event, "_ENV", sizeof("_ENV") TSRMLS_CC);	}		if (AWARE_G(log_files)) {		_add_assoc_zval_helper(event, "_FILES", sizeof("_FILES") TSRMLS_CC);	}		/* Capture backtrace */	if (AWARE_G(log_backtrace)) {		zval *btrace;		ALLOC_INIT_ZVAL(btrace);		zend_fetch_debug_backtrace(btrace, 0, 0 TSRMLS_CC);		add_assoc_zval(event, "backtrace", btrace);	}		va_copy(args_cp, args);	len = vspprintf(&buffer, PG(log_errors_max_len), format, args_cp);	va_end(args_cp);	add_assoc_string(event,	"error_message", buffer, 0);	add_assoc_string(event,	"filename",	(char *)error_filename, 1);		add_assoc_long(event, "line_number", error_lineno);	add_assoc_long(event, "error_type", type);		/*		Set the last logged uuid into _SERVER	*/	add_assoc_string(event, "aware_event_uuid", uuid_str, 1);	add_assoc_long(event, "aware_event_time", time(NULL));	/*		Set the last logged uuid into _SERVER	*/	if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &ppzval) == SUCCESS) {		add_assoc_string(*ppzval, "aware_last_uuid", uuid_str, 1);	}	/* Send to backend */	php_aware_storage_store_all(uuid_str, event, type, error_filename, error_lineno TSRMLS_CC);		if (free_event) {		zval_dtor(event);		FREE_ZVAL(event);	}}

static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent){	char *host;	int host_len;	long port = -1;	zval *zerrno = NULL, *zerrstr = NULL, *zcontext = NULL;	double timeout = FG(default_socket_timeout);	unsigned long conv;	struct timeval tv;	char *hashkey = NULL;	php_stream *stream = NULL;	php_stream_context *context = NULL;	int err;	RETVAL_FALSE;		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lzzdr", &host, &host_len, &port, &zerrno, &zerrstr, &timeout, &zcontext) == FAILURE) {		RETURN_FALSE;	}	if (zcontext) {		ZEND_FETCH_RESOURCE(context, php_stream_context*, &zcontext, -1, "stream-context", php_le_stream_context());	}	if (persistent) {		spprintf(&hashkey, 0, "pfsockopen__%s:%ld", host, port);		switch(php_stream_from_persistent_id(hashkey, &stream TSRMLS_CC)) {			case PHP_STREAM_PERSISTENT_SUCCESS:				if (_php_network_is_stream_alive(stream TSRMLS_CC)) {					php_stream_to_zval(stream, return_value);				} else {					/* it died; we need to replace it */					php_stream_pclose(stream);					break;				}								/* fall through */			case PHP_STREAM_PERSISTENT_FAILURE:				efree(hashkey);				return;		}	}	/* prepare the timeout value for use */	conv = (unsigned long) (timeout * 1000000.0);	tv.tv_sec = conv / 1000000;	tv.tv_usec = conv % 1000000;	if (zerrno)	{		zval_dtor(zerrno);		ZVAL_LONG(zerrno, 0);	}	if (zerrstr) {		zval_dtor(zerrstr);		ZVAL_STRING(zerrstr, "", 1);	}	if (port > 0)	{ /* connect to a host */		enum php_sslflags_t { php_ssl_none, php_ssl_v23, php_ssl_tls };		enum php_sslflags_t ssl_flags = php_ssl_none;		struct {			char *proto;			int protolen;			int socktype;			enum php_sslflags_t ssl_flags;			/* more flags to be added here */		} sockmodes[] = {			{ "udp://", 6, SOCK_DGRAM,	php_ssl_none },			{ "tcp://", 6, SOCK_STREAM,	php_ssl_none },			{ "ssl://", 6, SOCK_STREAM, php_ssl_v23 },			{ "tls://", 6, SOCK_STREAM, php_ssl_tls },			/* more modes to be added here */			{ NULL, 0, 0 }		};		int socktype = SOCK_STREAM;		int i;		for (i = 0; sockmodes[i].proto != NULL; i++) {			if (strncmp(host, sockmodes[i].proto, sockmodes[i].protolen) == 0) {				ssl_flags = sockmodes[i].ssl_flags;						socktype = sockmodes[i].socktype;				host += sockmodes[i].protolen;				break;			}		}#ifndef HAVE_OPENSSL_EXT		if (ssl_flags != php_ssl_none) {			php_error_docref(NULL TSRMLS_CC, E_WARNING, "no SSL support in this build");		}		else#endif		stream = php_stream_sock_open_host(host, (unsigned short)port, socktype, &tv, hashkey);		/* Preserve error */		err = php_socket_errno();		if (stream == NULL) {			php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to connect to %s:%ld", host, port);		} else if (context) {			php_stream_context_set(stream, context);//.........这里部分代码省略.........

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, "s|b", &tpl_str, &tpl_len, &ret_res) == FAILURE)	{		RETURN_FALSE;	}	smart_str ss_path = {0};	if(tpl_str[0] != '/'){		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(root_path), Z_STRLEN(root_path));		smart_str_appendc(&ss_path, '/');		zval_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){			}			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_path_get(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);	//构造运行时所需基本变量	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);}

PHP_COUCHBASE_LOCALvoid php_couchbase_get_impl(INTERNAL_FUNCTION_PARAMETERS,							int multi,							int oo,							int lock,							int touch){	char *key, **keys;	long *klens, klen = 0;	int	 nkey = 0;	long flag = 0;	lcb_time_t exp = {0};	long expiry = 0;	zval *res, *cas_token = NULL;	int argflags;	lcb_error_t retval;	php_couchbase_res *couchbase_res;	php_couchbase_ctx *ctx;	argflags = oo ? PHP_COUCHBASE_ARG_F_OO : PHP_COUCHBASE_ARG_F_FUNCTIONAL;	if (multi) {		zval *akeys;		zval **ppzval;		zend_bool preserve_order;		int i;		if (lock) {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "az|ll",											 &akeys, &cas_token,											 &flag, &expiry);		} else if (touch) {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "al|z",											 &akeys, &expiry, &cas_token);		} else {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "a|zl",											 &akeys, &cas_token, &flag);		}		nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys));		keys = ecalloc(nkey, sizeof(char *));		klens = ecalloc(nkey, sizeof(long));		preserve_order = (flag & COUCHBASE_GET_PRESERVE_ORDER);		array_init(return_value);		for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));				zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;				zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) {			if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) {				nkey--;				continue;			}			if (IS_ARRAY != Z_TYPE_PP(ppzval)) {				convert_to_string_ex(ppzval);			}			if (!Z_STRLEN_PP(ppzval)) {				nkey--;				continue;			}			if (couchbase_res->prefix_key_len) {				klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval));			} else {				keys[i] = Z_STRVAL_PP(ppzval);				klens[i] = Z_STRLEN_PP(ppzval);			}			if (preserve_order) {				add_assoc_null_ex(return_value, keys[i], klens[i] + 1);			}		}		if (!nkey) {			efree(keys);			efree(klens);			return;		}		if (cas_token && IS_ARRAY != Z_TYPE_P(cas_token)) {			zval_dtor(cas_token);			array_init(cas_token);		}	} else {		if (lock) {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "sz|l", &key, &klen,											 &cas_token, &expiry);		} else if (touch) {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "sl|z", &key, &klen, &expiry,											 &cas_token);		} else {			PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,											 "s|z", &key, &klen,//.........这里部分代码省略.........

//.........这里部分代码省略.........			case ZEND_FETCH_RW:			case ZEND_FETCH_IS:			case ZEND_FETCH_UNSET:			case ZEND_FETCH_FUNC_ARG:			case ZEND_FETCH_CLASS:			case ZEND_INIT_FCALL_BY_NAME:			/*case ZEND_INIT_NS_FCALL_BY_NAME:*/			case ZEND_UNSET_VAR:			case ZEND_ISSET_ISEMPTY_VAR:			case ZEND_ADD_INTERFACE:			case ZEND_ADD_TRAIT:			case ZEND_INSTANCEOF:				Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot++;				zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));				zend_optimizer_add_literal(op_array, val);				zend_string_hash_val(Z_STR(op_array->literals[opline->op2.constant+1]));				break;			case ZEND_INIT_METHOD_CALL:			case ZEND_INIT_STATIC_METHOD_CALL:				zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));				zend_optimizer_add_literal(op_array, val);				zend_string_hash_val(Z_STR(op_array->literals[opline->op2.constant+1]));				/* break missing intentionally */			/*case ZEND_FETCH_CONSTANT:*/			case ZEND_ASSIGN_OBJ:			case ZEND_FETCH_OBJ_R:			case ZEND_FETCH_OBJ_W:			case ZEND_FETCH_OBJ_RW:			case ZEND_FETCH_OBJ_IS:			case ZEND_FETCH_OBJ_UNSET:			case ZEND_FETCH_OBJ_FUNC_ARG:			case ZEND_UNSET_OBJ:			case ZEND_PRE_INC_OBJ:			case ZEND_PRE_DEC_OBJ:			case ZEND_POST_INC_OBJ:			case ZEND_POST_DEC_OBJ:			case ZEND_ISSET_ISEMPTY_PROP_OBJ:				Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;				op_array->last_cache_slot += 2;				break;			case ZEND_ASSIGN_ADD:			case ZEND_ASSIGN_SUB:			case ZEND_ASSIGN_MUL:			case ZEND_ASSIGN_DIV:			case ZEND_ASSIGN_MOD:			case ZEND_ASSIGN_SL:			case ZEND_ASSIGN_SR:			case ZEND_ASSIGN_CONCAT:			case ZEND_ASSIGN_BW_OR:			case ZEND_ASSIGN_BW_AND:			case ZEND_ASSIGN_BW_XOR:				if (opline->extended_value == ZEND_ASSIGN_OBJ) {					Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;					op_array->last_cache_slot += 2;				}				break;			case ZEND_OP_DATA:				if ((opline-1)->opcode == ZEND_ASSIGN_DIM ||				    ((opline-1)->extended_value == ZEND_ASSIGN_DIM &&				     ((opline-1)->opcode == ZEND_ASSIGN_ADD ||				     (opline-1)->opcode == ZEND_ASSIGN_SUB ||				     (opline-1)->opcode == ZEND_ASSIGN_MUL ||				     (opline-1)->opcode == ZEND_ASSIGN_DIV ||				     (opline-1)->opcode == ZEND_ASSIGN_MOD ||				     (opline-1)->opcode == ZEND_ASSIGN_SL ||				     (opline-1)->opcode == ZEND_ASSIGN_SR ||				     (opline-1)->opcode == ZEND_ASSIGN_CONCAT ||				     (opline-1)->opcode == ZEND_ASSIGN_BW_OR ||				     (opline-1)->opcode == ZEND_ASSIGN_BW_AND ||				     (opline-1)->opcode == ZEND_ASSIGN_BW_XOR))) {					goto check_numeric;				}				break;			case ZEND_ISSET_ISEMPTY_DIM_OBJ:			case ZEND_ADD_ARRAY_ELEMENT:			case ZEND_INIT_ARRAY:			case ZEND_UNSET_DIM:			case ZEND_FETCH_DIM_R:			case ZEND_FETCH_DIM_W:			case ZEND_FETCH_DIM_RW:			case ZEND_FETCH_DIM_IS:			case ZEND_FETCH_DIM_FUNC_ARG:			case ZEND_FETCH_DIM_UNSET:			case ZEND_FETCH_LIST:check_numeric:				{					zend_ulong index;					if (ZEND_HANDLE_NUMERIC(Z_STR_P(val), index)) {						zval_dtor(val);						ZVAL_LONG(val, index);						op_array->literals[opline->op2.constant] = *val;		        	}				}				break;			default:				break;		}	}}

PHP_COUCHBASE_LOCALvoid php_couchbase_fetch_impl(INTERNAL_FUNCTION_PARAMETERS, int multi, int oo) /* {{{ */{	php_couchbase_res *couchbase_res;	int argflags;	if (oo) {		argflags = PHP_COUCHBASE_ARG_F_OO;	} else {		argflags = PHP_COUCHBASE_ARG_F_FUNCTIONAL;	}	argflags |= PHP_COUCHBASE_ARG_F_ASYNC;	PHP_COUCHBASE_GET_PARAMS(couchbase_res, argflags, "");	{		php_couchbase_ctx *ctx;		if (!couchbase_res->async) {			RETURN_FALSE;		}		ctx = couchbase_res->async_ctx;		if (couchbase_res->async == 2) {fetch_one: {				char *key;				uint key_len;				ulong index = 0;				zval **ppzval;				zval *stash = (zval *)ctx->extended_value;				if (zend_hash_num_elements(Z_ARRVAL_P(stash)) == 0) {					couchbase_res->async = 0;					zval_ptr_dtor(&stash);					efree(ctx);					couchbase_res->async_ctx = NULL;					RETURN_NULL();				}				zend_hash_internal_pointer_reset(Z_ARRVAL_P(stash));				zend_hash_get_current_data(Z_ARRVAL_P(stash), (void **)&ppzval);				RETVAL_ZVAL(*ppzval, 1, 0);				zend_hash_get_current_key_ex(Z_ARRVAL_P(stash), &key, &key_len, &index, 0, NULL);				zend_hash_index_del(Z_ARRVAL_P(stash), index);				return;			}		}		array_init(return_value);		ctx->rv = return_value;		pcbc_start_loop(couchbase_res);		if (!multi) {			zval *stash;			MAKE_STD_ZVAL(stash);			ZVAL_ZVAL(stash, return_value, 1, 0);			ctx->extended_value = (void *)stash;			zval_dtor(return_value);			couchbase_res->async = 2;			goto fetch_one;		} else {			efree(ctx);			couchbase_res->async = 0;			couchbase_res->async_ctx = NULL;		}	}}

static void zend_optimizer_zval_dtor_wrapper(zval *zvalue){	zval_dtor(zvalue);}

static void regexp_ctor(INTERNAL_FUNCTION_PARAMETERS){    zval *object;    Regexp_object *ro;    char *pattern;    int32_t pattern_len;    UChar *upattern = NULL;    int32_t upattern_len = 0;    zval *zflags = NULL;    uint32_t flags = 0;    UParseError pe = { -1, -1, {0}, {0} };    intl_error_reset(NULL TSRMLS_CC);    object = return_value;    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &pattern, &pattern_len, &zflags)) {        intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "bad arguments", 0 TSRMLS_CC);        zval_dtor(object);        RETURN_NULL();    }    if (NULL != zflags) {        switch (Z_TYPE_P(zflags)) {            case IS_LONG:                flags = (uint32_t) Z_LVAL_P(zflags);                if (0 != (flags & ~(UREGEX_CASE_INSENSITIVE|UREGEX_MULTILINE|UREGEX_DOTALL|UREGEX_COMMENTS|UREGEX_UWORD))) {                    intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "invalid flag", 0 TSRMLS_CC);                    zval_dtor(object);                    RETURN_NULL();                }                break;            case IS_STRING:            {                const char *p;                for (p = Z_STRVAL_P(zflags); '/0' != *p; p++) {                    switch (*p) {                        case 'i': flags |= UREGEX_CASE_INSENSITIVE; break;                        case 'm': flags |= UREGEX_MULTILINE;        break;                        case 's': flags |= UREGEX_DOTALL;           break;                        case 'x': flags |= UREGEX_COMMENTS;         break;                        case 'w': flags |= UREGEX_UWORD;            break;                        default:                            intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "invalid modifier", 0 TSRMLS_CC);                            zval_dtor(object);                            RETURN_NULL();                    }                }                break;            }            default:                intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "bad arguments", 0 TSRMLS_CC);                zval_dtor(object);                RETURN_NULL();        }    }    ro = (Regexp_object *) zend_object_store_get_object(object TSRMLS_CC);    intl_convert_utf8_to_utf16(&upattern, &upattern_len, pattern, pattern_len, REGEXP_ERROR_CODE_P(ro));    INTL_CTOR_CHECK_STATUS(ro, "string conversion of pattern to UTF-16 failed");    ro->uregex = uregex_open(upattern, upattern_len, flags, &pe, REGEXP_ERROR_CODE_P(ro));    efree(upattern);    if (U_FAILURE(REGEXP_ERROR_CODE(ro))) {        intl_error_set_code(NULL, REGEXP_ERROR_CODE(ro) TSRMLS_CC);        if (-1 != pe.line) {            smart_str parse_error_str;            parse_error_str = transliterator_parse_error_to_string(&pe);            intl_errors_setf_custom_msg(NULL, TSRMLS_CC "unable to compile ICU regular expression, %s", parse_error_str.c);            smart_str_free(&parse_error_str);        } else {            intl_error_set_custom_msg(NULL, "unable to compile ICU regular expression", 0 TSRMLS_CC);        }        zval_dtor(object);        RETURN_NULL();    }}

//.........这里部分代码省略.........	}		PHALCON_INIT_VAR(use_empty);	ZVAL_BOOL(use_empty, 0);	if (phalcon_array_isset_string(params, SS("useEmpty"))) {		if (!phalcon_array_isset_string(params, SS("emptyValue"))) {			PHALCON_INIT_VAR(empty_value);			ZVAL_STRING(empty_value, "", 1);		} else {			PHALCON_OBS_NVAR(empty_value);			phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY);			phalcon_array_unset_string(&params, SS("emptyValue"), PH_SEPARATE);		}		if (!phalcon_array_isset_string(params, SS("emptyText"))) {			PHALCON_INIT_VAR(empty_text);			ZVAL_STRING(empty_text, "Choose...", 1);		} else {			PHALCON_OBS_NVAR(empty_text);			phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY);			phalcon_array_unset_string(&params, SS("emptyText"), PH_SEPARATE);		}			PHALCON_OBS_NVAR(use_empty);		phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY);		phalcon_array_unset_string(&params, SS("useEmpty"), PH_SEPARATE);	}		PHALCON_INIT_VAR(code);	ZVAL_STRING(code, "<select", 1);	if (Z_TYPE_P(params) == IS_ARRAY) { 			phalcon_is_iterable(params, &ah0, &hp0, 0, 0);			PHALCON_INIT_VAR(escaped);		while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {				PHALCON_GET_HKEY(key, ah0, hp0);			PHALCON_GET_HVALUE(avalue);				if (Z_TYPE_P(key) != IS_LONG) {				if (Z_TYPE_P(avalue) != IS_ARRAY) { 					phalcon_htmlspecialchars(escaped, avalue, NULL, NULL TSRMLS_CC);					PHALCON_SCONCAT_SVSVS(code, " ", key, "=/"", escaped, "/"");					zval_dtor(escaped);					ZVAL_NULL(escaped);				}			}				zend_hash_move_forward_ex(ah0, &hp0);		}		}		PHALCON_SCONCAT_SV(code, ">", eol);		PHALCON_INIT_VAR(close_option);	PHALCON_CONCAT_SV(close_option, "</option>", eol);	if (zend_is_true(use_empty)) {		/** 		 * Create an empty value		 */		PHALCON_SCONCAT_SVSVV(code, "/t<option value=/"", empty_value, "/">", empty_text, close_option);		phalcon_array_unset_string(&params, SS("useEmpty"), PH_SEPARATE);	}		if (phalcon_array_isset_long(params, 1)) {		PHALCON_OBS_VAR(options);		phalcon_array_fetch_long(&options, params, 1, PH_NOISY);	} else {		PHALCON_CPY_WRT(options, data);	}		if (Z_TYPE_P(options) == IS_OBJECT) {			/** 		 * The options is a resultset		 */		if (!phalcon_array_isset_string(params, SS("using"))) {			PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");			return;		} else {			PHALCON_OBS_VAR(using);			phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY);			if (Z_TYPE_P(using) != IS_ARRAY) { 				if (Z_TYPE_P(using) != IS_OBJECT) {					PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");					return;				}			}		}			/** 		 * Create the SELECT's option from a resultset		 */		PHALCON_INIT_VAR(resultset_options);		PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option);		phalcon_concat_self(&code, resultset_options TSRMLS_CC);	} else {		if (Z_TYPE_P(options) == IS_ARRAY) { 

//.........这里部分代码省略.........		RETURN_FALSE;	}	for (i = 0; i < Z_STRLEN_P(param); i += 4) {		issigned = Z_STRVAL_P(param)[i] & 0x80;		value = 0;		if (sizeof(long) > 4 && issigned) {			value = ~INT_MAX;		}		value |= phalcon_unpack(&Z_STRVAL_P(param)[i], 4, issigned, big_endian_long_map);		if (sizeof(long) > 4) {			value = (unsigned int) value;		}		/**		 * CSS 2.1 section 4.1.3: "It is undefined in CSS 2.1 what happens if a		 * style sheet does contain a character with Unicode codepoint zero."		 */		if (value == '/0') {			RETURN_FALSE;		}		/**		 * Alphanumeric characters are not escaped		 */		if (value > 32 && value < 127 && isalnum(value)) {			smart_str_appendc(&escaped_str, (unsigned char) value);			continue;		}		/**		 * Chararters in the whitelist are left as they are		 */		if (use_whitelist) {			switch (value) {				case ' ':				case '/':				case '*':				case '+':				case '-':				case '/t':				case '/n':				case '^':				case '$':				case '!':				case '?':				case '//':				case '#':				case '}':				case '{':				case ')':				case '(':				case ']':				case '[':				case '.':				case ',':				case ':':				case ';':				case '_':				case '|':				case '~':				case '`':					smart_str_appendc(&escaped_str, (unsigned char) value);					continue;			}		}		/**		 * Convert character to hexadecimal		 */		hex = phalcon_longtohex(value);		/**		 * Append the escaped character		 */		smart_str_appendl(&escaped_str, escape_char, escape_length);		smart_str_appendl(&escaped_str, hex, strlen(hex));		if (escape_extra != '/0') {			smart_str_appendc(&escaped_str, escape_extra);		}		efree(hex);	}	if (use_copy) {		zval_dtor(param);	}	smart_str_0(&escaped_str);	if (escaped_str.c) {		RETURN_STRINGL(escaped_str.c, escaped_str.len, 0);	} else {		RETURN_EMPTY_STRING();	}}

static void pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAMETERS, int timedwait) /* {{{ */{	zval            *user_set, **user_signo, *user_siginfo = NULL;	long             tv_sec = 0, tv_nsec = 0;	sigset_t         set;	HashPosition     pos;	int              signo;	siginfo_t        siginfo;	struct timespec  timeout;	if (timedwait) {		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {			return;		}	} else {		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z", &user_set, &user_siginfo) == FAILURE) {			return;		}	}	if (sigemptyset(&set) != 0) {		PCNTL_G(last_error) = errno;		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));		RETURN_FALSE;	}	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(user_set), &pos);	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(user_set), (void **)&user_signo, &pos) == SUCCESS)	{		if (Z_TYPE_PP(user_signo) != IS_LONG) {			SEPARATE_ZVAL(user_signo);			convert_to_long_ex(user_signo);		}		signo = Z_LVAL_PP(user_signo);		if (sigaddset(&set, signo) != 0) {			PCNTL_G(last_error) = errno;			php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));			RETURN_FALSE;		}		zend_hash_move_forward_ex(Z_ARRVAL_P(user_set), &pos);	}	if (timedwait) {		timeout.tv_sec  = (time_t) tv_sec;		timeout.tv_nsec = tv_nsec;		signo = sigtimedwait(&set, &siginfo, &timeout);	} else {		signo = sigwaitinfo(&set, &siginfo);	}	if (signo == -1 && errno != EAGAIN) {		PCNTL_G(last_error) = errno;		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));	}	/*	 * sigtimedwait and sigwaitinfo can return 0 on success on some 	 * platforms, e.g. NetBSD	 */	if (!signo && siginfo.si_signo) {		signo = siginfo.si_signo;	}	if (signo > 0 && user_siginfo) {		if (Z_TYPE_P(user_siginfo) != IS_ARRAY) {			zval_dtor(user_siginfo);			array_init(user_siginfo);		} else {			zend_hash_clean(Z_ARRVAL_P(user_siginfo));		}		add_assoc_long_ex(user_siginfo, "signo", sizeof("signo"), siginfo.si_signo);		add_assoc_long_ex(user_siginfo, "errno", sizeof("errno"), siginfo.si_errno);		add_assoc_long_ex(user_siginfo, "code",  sizeof("code"),  siginfo.si_code);		switch(signo) {#ifdef SIGCHLD			case SIGCHLD:				add_assoc_long_ex(user_siginfo,   "status", sizeof("status"), siginfo.si_status);# ifdef si_utime				add_assoc_double_ex(user_siginfo, "utime",  sizeof("utime"),  siginfo.si_utime);# endif# ifdef si_stime				add_assoc_double_ex(user_siginfo, "stime",  sizeof("stime"),  siginfo.si_stime);# endif				add_assoc_long_ex(user_siginfo,   "pid",    sizeof("pid"),    siginfo.si_pid);				add_assoc_long_ex(user_siginfo,   "uid",    sizeof("uid"),    siginfo.si_uid);				break;#endif			case SIGILL:			case SIGFPE:			case SIGSEGV:			case SIGBUS:				add_assoc_double_ex(user_siginfo, "addr", sizeof("addr"), (long)siginfo.si_addr);				break;#ifdef SIGPOLL			case SIGPOLL:				add_assoc_long_ex(user_siginfo, "band", sizeof("band"), siginfo.si_band);# ifdef si_fd				add_assoc_long_ex(user_siginfo, "fd",   sizeof("fd"),   siginfo.si_fd);# endif				break;#endif//.........这里部分代码省略.........

//.........这里部分代码省略.........                }                break;            case ZEND_RECV:            case ZEND_VERIFY_RETURN_TYPE:                if (opline->op2.num != -1) {                    opline->op2.num = cache_size;                    cache_size += sizeof(void *);                }            default:                if (ZEND_OP1_TYPE(opline) == IS_CONST) {                    LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1);                }                if (ZEND_OP2_TYPE(opline) == IS_CONST) {                    LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1, 0, 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_dtor(&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) {                /* unsed literal */                zval_dtor(&op_array->literals[i]);                continue;            }            switch (Z_TYPE(op_array->literals[i])) {            case IS_NULL:                /* Only checking MAY_MERGE for IS_NULL here                 * is because only IS_NULL can be default value for class type hinting(RECV_INIT). */                if ((info[i].flags & LITERAL_MAY_MERGE)) {                    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;                } else {

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

//.........这里部分代码省略.........					l = *(ISC_INT64*)argv[i]->dsc_address;					if (argv[i]->dsc_scale == 0 && l <= LONG_MAX && l >= LONG_MIN) {						ZVAL_LONG(&args[i], (long)l);					} else {						ZVAL_DOUBLE(&args[i], ((double)l)/scales[-argv[i]->dsc_scale]);					}					break;				case dtype_real:					ZVAL_DOUBLE(&args[i], *(float*)argv[i]->dsc_address);					break;				case dtype_double:					ZVAL_DOUBLE(&args[i], *(double*)argv[i]->dsc_address);					break;				case dtype_sql_date:					isc_decode_sql_date((ISC_DATE*)argv[i]->dsc_address, &t);					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.dateformat"), &t),1);					break;				case dtype_sql_time:					isc_decode_sql_time((ISC_TIME*)argv[i]->dsc_address, &t);					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.timeformat"), &t),1);					break;				case dtype_timestamp:					isc_decode_timestamp((ISC_TIMESTAMP*)argv[i]->dsc_address, &t);					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.timestampformat"), &t));					break;			}		}		LOCK();		/* now call the function */		if (FAILURE == call_user_function(EG(function_table), NULL,				&callback, &return_value, argc, args)) {			UNLOCK();			break;		}		UNLOCK();		for (i = 0; i < argc; ++i) {			switch (argv[i]->dsc_dtype) {				case dtype_sql_date:				case dtype_sql_time:				case dtype_timestamp:					zval_dtor(&args[i]);			}		}		zval_dtor(&callback);		/* return whatever type we got back from the callback: let DB handle conversion */		switch (Z_TYPE(return_value)) {			case IS_LONG:				r->dsc_dtype = dtype_long;				*(long*)r->dsc_address = Z_LVAL(return_value);				r->dsc_length = sizeof(long);				break;			case IS_DOUBLE:				r->dsc_dtype = dtype_double;				*(double*)r->dsc_address = Z_DVAL(return_value);				r->dsc_length = sizeof(double);				break;			case IS_NULL:				r->dsc_flags |= DSC_null;				break;			default:				convert_to_string(&return_value);			case IS_STRING:				r->dsc_dtype = dtype_varying;				memcpy(res->vary_string, Z_STRVAL(return_value),					(res->vary_length = min(r->dsc_length-2,Z_STRLEN(return_value))));				r->dsc_length = res->vary_length+2;				break;		}		zval_dtor(&return_value);		return;	} while (0);	/**	* If we end up here, we should report an error back to the DB engine, but	* that's not possible. We can however report it back to PHP.	*/	LOCK();	php_error_docref(NULL, E_WARNING, "Error calling function '%s' from database", name);	UNLOCK();}

//.........这里部分代码省略.........									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;							}							child = php_dom_create_object(node, &ret, child, (dom_object *)intern TSRMLS_CC);							add_next_index_zval(args[i], child);						}					}				}				break;			default:			ZVAL_STRING(args[i], (char *)xmlXPathCastToString(obj), 1);		}		xmlXPathFreeObject(obj);		fci.params[i] = &args[i];	}		fci.size = sizeof(fci);	fci.function_table = EG(function_table);		obj = valuePop(ctxt);	if (obj->stringval == NULL) {		php_error_docref(NULL TSRMLS_CC, 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(&args[i]);			}			efree(args);			efree(fci.params);		}		return; 	}	INIT_PZVAL(&handler);	ZVAL_STRING(&handler, obj->stringval, 1);	xmlXPathFreeObject(obj);	fci.function_name = &handler;	fci.symbol_table = NULL;	fci.object_ptr = NULL;	fci.retval_ptr_ptr = &retval;	fci.no_separation = 0;	if (!zend_make_callable(&handler, &callable TSRMLS_CC)) {		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", callable);			} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable, strlen(callable) + 1) == 0) { 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%s()'.", callable);		/* Push an empty string, so that we at least have an xslt result... */		valuePush(ctxt, xmlXPathNewString((xmlChar *)""));	} else {		result = zend_call_function(&fci, NULL TSRMLS_CC);		if (result == FAILURE) {			if (Z_TYPE(handler) == IS_STRING) {				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(&handler));			}		/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */		} else if (retval == NULL) {		} else {			if (retval->type == IS_OBJECT && instanceof_function( Z_OBJCE_P(retval), dom_node_class_entry TSRMLS_CC)) {				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);				}				zval_add_ref(&retval);				zend_hash_next_index_insert(intern->node_list, &retval, sizeof(zval *), NULL);				obj = (dom_object *)zend_object_store_get_object(retval TSRMLS_CC);				nodep = dom_object_get_node(obj);				valuePush(ctxt, xmlXPathNewNodeSet(nodep));			} else if (retval->type == IS_BOOL) {				valuePush(ctxt, xmlXPathNewBoolean(retval->value.lval));			} else if (retval->type == IS_OBJECT) {				php_error_docref(NULL TSRMLS_CC, E_WARNING, "A PHP Object cannot be converted to a XPath-string");				valuePush(ctxt, xmlXPathNewString((xmlChar *)""));			} else {				convert_to_string_ex(&retval);				valuePush(ctxt, xmlXPathNewString( Z_STRVAL_P(retval)));			}			zval_ptr_dtor(&retval);		}	}	efree(callable);	zval_dtor(&handler);	if (fci.param_count > 0) {		for (i = 0; i < nargs - 1; i++) {			zval_ptr_dtor(&args[i]);		}		efree(args);		efree(fci.params);	}}

//.........这里部分代码省略.........			qb_add_string(param_info, "name", texture->name, -1);			qb_add_string(param_info, "displayName", NULL, 0);			qb_add_string(param_info, "type", pbj_texture_type_names[texture->channel_count], -1);			qb_add_string(param_info, "parameterType", NULL, 0);			qb_add_string(param_info, "description", NULL, 0);		}	} else if(output_type == QB_PBJ_DECLARATION) {		const char *pbj_path = Z_STRVAL_P(cxt->input);		uint32_t param_count = 0;		ZVAL_STRING(cxt->return_value, "/**/n", TRUE);		qb_append_string(cxt->return_value, " * %.*s()/t", translator_cxt->name_length, translator_cxt->name);		if(translator_cxt->description) {			qb_append_string(cxt->return_value, "%s", translator_cxt->description);		}		if(translator_cxt->vendor) {			qb_append_string(cxt->return_value, " (%s)", translator_cxt->vendor);		}		qb_append_string(cxt->return_value, "/n");				qb_append_string(cxt->return_value, " */n");		qb_append_string(cxt->return_value, " * @engine/tqb/n");		qb_append_string(cxt->return_value, " * @import/t%s/n", pbj_path);		qb_append_string(cxt->return_value, " */n");		if(translator_cxt->out_pixel) {			qb_pbj_parameter *param = translator_cxt->out_pixel;			uint32_t channel_count;			switch(param->type) {				case PBJ_TYPE_FLOAT:  channel_count = 1; break;				case PBJ_TYPE_FLOAT2: channel_count = 2; break;				case PBJ_TYPE_FLOAT3: channel_count = 3; break;				case PBJ_TYPE_FLOAT4: channel_count = 4; break;			}			qb_append_string(cxt->return_value, " * @param/t%s/t$%s/n", pbj_texture_qb_types[channel_count], param->name);		}		for(i = 0; i < translator_cxt->texture_count; i++) {			qb_pbj_texture *texture = &translator_cxt->textures[i];			qb_append_string(cxt->return_value, " * @param/t%s/t$%s/n", pbj_texture_qb_types[texture->channel_count], texture->name);		}		for(i = 0; i < translator_cxt->parameter_count; i++) {			qb_pbj_parameter *param = &translator_cxt->parameters[i];			if(param != translator_cxt->out_coord && param != translator_cxt->out_pixel && !param->input_size_name) {				const char *type = pbj_param_qb_types[param->type];				if(param->parameter_type) {					if(param->type == PBJ_TYPE_FLOAT2) {						if(strcmp(param->parameter_type, "position") == 0) {							type = "float32[x,y]";						}					} else if(param->type == PBJ_TYPE_FLOAT3) {						if(strcmp(param->parameter_type, "colorLAB") == 0) {							type = "float32[L,a,b]";						} else if(strcmp(param->parameter_type, "colorRGB") == 0) {							type = "float32[r,g,b]";						}					} else if(param->type == PBJ_TYPE_FLOAT4) {						if(strcmp(param->parameter_type, "colorCMYK") == 0) {							type = "float32[c,m,y,k]";						} else if(strcmp(param->parameter_type, "colorRGBA") == 0) {							type = "float32[r,g,b,a]";						}					}				}				qb_append_string(cxt->return_value, " * @param/t%s/t$%s", type, param->name);				if(param->description) {					qb_append_string(cxt->return_value, "/t%s", param->description);				}				qb_append_string(cxt->return_value, "/n");			}		}		qb_append_string(cxt->return_value, " */n");		qb_append_string(cxt->return_value, " * @return/tvoid/n");		qb_append_string(cxt->return_value, " *//n");		qb_append_string(cxt->return_value, "function %.*s(", translator_cxt->name_length, translator_cxt->name);		if(translator_cxt->out_pixel) {			qb_pbj_parameter *param = translator_cxt->out_pixel;			qb_append_string(cxt->return_value, "&$%s", param->name);			param_count++;		}		for(i = 0; i < translator_cxt->texture_count; i++) {			qb_pbj_texture *texture = &translator_cxt->textures[i];			if(param_count) {				qb_append_string(cxt->return_value, ", ");			}			qb_append_string(cxt->return_value, "$%s", texture->name);			param_count++;		}		for(i = 0; i < translator_cxt->parameter_count; i++) {			qb_pbj_parameter *param = &translator_cxt->parameters[i];			if(param != translator_cxt->out_coord && param != translator_cxt->out_pixel && !param->input_size_name) {				if(param_count) {					qb_append_string(cxt->return_value, ", ");				}				qb_append_string(cxt->return_value, "$%s", param->name);			}		}		qb_append_string(cxt->return_value, ") {}/n");	}	zval_dtor(&path);}