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

/** * Sets the conditions parameter in the criteria */PHP_METHOD(Phalcon_Mvc_Model_Criteria, where) {	zval *conditions_param = NULL, *bindParams = NULL, *bindTypes = NULL, *currentBindParams = NULL, *mergedParams = NULL, *mergedParamsTypes = NULL, *currentBindTypes = NULL, *_0, *_1$$3, *_2$$3, *_3$$6, *_4$$6;	zval *conditions = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 2, &conditions_param, &bindParams, &bindTypes);	if (unlikely(Z_TYPE_P(conditions_param) != IS_STRING && Z_TYPE_P(conditions_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'conditions' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(conditions_param) == IS_STRING)) {		zephir_get_strval(conditions, conditions_param);	} else {		ZEPHIR_INIT_VAR(conditions);		ZVAL_EMPTY_STRING(conditions);	}	if (!bindParams) {		bindParams = ZEPHIR_GLOBAL(global_null);	}	if (!bindTypes) {		bindTypes = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_INIT_VAR(_0);	ZVAL_STRING(_0, "conditions", 1);	zephir_update_property_array(this_ptr, SL("_params"), _0, conditions TSRMLS_CC);	if (Z_TYPE_P(bindParams) == IS_ARRAY) {		ZEPHIR_OBS_VAR(currentBindParams);		_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);		if (zephir_array_isset_string_fetch(&currentBindParams, _1$$3, SS("bind"), 0 TSRMLS_CC)) {			ZEPHIR_INIT_VAR(mergedParams);			zephir_fast_array_merge(mergedParams, &(currentBindParams), &(bindParams) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedParams, bindParams);		}		ZEPHIR_INIT_VAR(_2$$3);		ZVAL_STRING(_2$$3, "bind", 1);		zephir_update_property_array(this_ptr, SL("_params"), _2$$3, mergedParams TSRMLS_CC);	}	if (Z_TYPE_P(bindTypes) == IS_ARRAY) {		ZEPHIR_OBS_VAR(currentBindTypes);		_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);		if (zephir_array_isset_string_fetch(&currentBindTypes, _3$$6, SS("bindTypes"), 0 TSRMLS_CC)) {			ZEPHIR_INIT_VAR(mergedParamsTypes);			zephir_fast_array_merge(mergedParamsTypes, &(currentBindTypes), &(bindTypes) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedParamsTypes, bindTypes);		}		ZEPHIR_INIT_VAR(_4$$6);		ZVAL_STRING(_4$$6, "bindTypes", 1);		zephir_update_property_array(this_ptr, SL("_params"), _4$$6, mergedParamsTypes TSRMLS_CC);	}	RETURN_THIS();}

/** * Set all the render params * *<code> *	$this->view->setVars(array('products' => $products)); *</code> */PHP_METHOD(Phalcon_Mvc_View_Simple, setVars) {	zend_bool merge;	zval *params_param = NULL, *merge_param = NULL, *viewParams, *mergedParams = NULL;	zval *params = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &params_param, &merge_param);	params = params_param;	if (!merge_param) {		merge = 1;	} else {		merge = zephir_get_boolval(merge_param);	}	if (merge) {		ZEPHIR_OBS_VAR(viewParams);		zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);		if (Z_TYPE_P(viewParams) == IS_ARRAY) {			ZEPHIR_INIT_VAR(mergedParams);			zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedParams, params);		}		zephir_update_property_this(this_ptr, SL("_viewParams"), mergedParams TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("_viewParams"), params TSRMLS_CC);	}	RETURN_THIS();}

/** * Returns the pool configuration settings for a given namespace. * * @param string namespaceName [Optional] * * @return array */PHP_METHOD(Xpl_Cache_Cache, getConfig) {	zend_bool _0;	zval *defaults;	zval *name_param = NULL, *_1, *_2, *_3;	zval *name = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &name_param);	zephir_get_strval(name, name_param);	ZEPHIR_INIT_VAR(defaults);	array_init(defaults);	_0 = ZEPHIR_IS_EMPTY(name);	if (!(_0)) {		_1 = zephir_fetch_nproperty_this(this_ptr, SL("config"), PH_NOISY_CC);		_0 = !(zephir_array_isset(_1, name));	}	if (_0) {		RETURN_CTOR(defaults);	}	_2 = zephir_fetch_nproperty_this(this_ptr, SL("config"), PH_NOISY_CC);	zephir_array_fetch(&_3, _2, name, PH_NOISY | PH_READONLY, "xpl/cache/cache.zep", 108 TSRMLS_CC);	zephir_fast_array_merge(return_value, &(defaults), &(_3) TSRMLS_CC);	RETURN_MM();}

/** * Set all the render params * *<code> * $this->view->setVars( *     [ *         "products" => $products, *     ] * ); *</code> */PHP_METHOD(Phalcon_Mvc_View_Simple, setVars) {	zend_bool merge, _0;	zval *params_param = NULL, *merge_param = NULL, *_1, *_2$$3, *_3$$3;	zval *params = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &params_param, &merge_param);	params = params_param;	if (!merge_param) {		merge = 1;	} else {		merge = zephir_get_boolval(merge_param);	}	_0 = merge;	if (_0) {		ZEPHIR_OBS_VAR(_1);		zephir_read_property_this(&_1, this_ptr, SL("_viewParams"), PH_NOISY_CC);		_0 = Z_TYPE_P(_1) == IS_ARRAY;	}	if (_0) {		ZEPHIR_INIT_VAR(_2$$3);		_3$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_viewParams"), PH_NOISY_CC);		zephir_fast_array_merge(_2$$3, &(_3$$3), &(params) TSRMLS_CC);		zephir_update_property_this(getThis(), SL("_viewParams"), _2$$3 TSRMLS_CC);	} else {		zephir_update_property_this(getThis(), SL("_viewParams"), params TSRMLS_CC);	}	RETURN_THIS();}

/** * Mounts a group of routes in the router * * @param Test/Router/Group route * @return Test/Router */PHP_METHOD(Test_Router, mount) {	HashTable *_1, *_4;	HashPosition _0, _3;	int ZEPHIR_LAST_CALL_STATUS;	zval *group, *groupRoutes = NULL, *beforeMatch = NULL, *hostname = NULL, *routes, *route = NULL, **_2, **_5, *_6;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &group);	if (Z_TYPE_P(group) != IS_OBJECT) {		ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The group of routes is not valid");		return;	}	ZEPHIR_CALL_METHOD(&groupRoutes, group, "getroutes",  NULL);	zephir_check_call_status();	if (!(zephir_fast_count_int(groupRoutes TSRMLS_CC))) {		ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The group of routes does not contain any routes");		return;	}	ZEPHIR_CALL_METHOD(&beforeMatch, group, "getbeforematch",  NULL);	zephir_check_call_status();	if (Z_TYPE_P(beforeMatch) != IS_NULL) {		zephir_is_iterable(groupRoutes, &_1, &_0, 0, 0);		for (		  ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS		  ; zephir_hash_move_forward_ex(_1, &_0)		) {			ZEPHIR_GET_HVALUE(route, _2);			ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, beforeMatch);			zephir_check_call_status();		}	}	ZEPHIR_CALL_METHOD(&hostname, group, "gethostname",  NULL);	zephir_check_call_status();	if (Z_TYPE_P(hostname) != IS_NULL) {		zephir_is_iterable(groupRoutes, &_4, &_3, 0, 0);		for (		  ; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS		  ; zephir_hash_move_forward_ex(_4, &_3)		) {			ZEPHIR_GET_HVALUE(route, _5);			ZEPHIR_CALL_METHOD(NULL, route, "sethostname", NULL, hostname);			zephir_check_call_status();		}	}	ZEPHIR_OBS_VAR(routes);	zephir_read_property_this(&routes, this_ptr, SL("_routes"), PH_NOISY_CC);	if (Z_TYPE_P(routes) == IS_ARRAY) {		ZEPHIR_INIT_VAR(_6);		zephir_fast_array_merge(_6, &(routes), &(groupRoutes) TSRMLS_CC);		zephir_update_property_this(this_ptr, SL("_routes"), _6 TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("_routes"), groupRoutes TSRMLS_CC);	}	RETURN_THIS();}

/** * Adds a group of validators * * @param /Phalcon/Validation/ValidatorInterface[] * @return /Phalcon/Forms/ElementInterface */PHP_METHOD(Phalcon_Forms_Element, addValidators) {	zend_bool merge;	zval *validators_param = NULL, *merge_param = NULL, *currentValidators = NULL, *mergedValidators = NULL;	zval *validators = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &validators_param, &merge_param);	validators = validators_param;	if (!merge_param) {		merge = 1;	} else {		merge = zephir_get_boolval(merge_param);	}	if (merge) {		ZEPHIR_OBS_VAR(currentValidators);		zephir_read_property_this(&currentValidators, this_ptr, SL("_validators"), PH_NOISY_CC);		if (Z_TYPE_P(currentValidators) == IS_ARRAY) {			ZEPHIR_INIT_VAR(mergedValidators);			zephir_fast_array_merge(mergedValidators, &(currentValidators), &(validators) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedValidators, validators);		}		zephir_update_property_this(this_ptr, SL("_validators"), mergedValidators TSRMLS_CC);	}	RETURN_THIS();}

PHP_METHOD(Test_Optimizers_ArrayMerge, mergeTwoRequiredArrays) {	zval *arr1_param = NULL, *arr2_param = NULL;	zval arr1, arr2;		zval this_zv;	zval *this_ptr = getThis();	if (EXPECTED(this_ptr)) {		ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));		this_ptr = &this_zv;	} else this_ptr = NULL;		ZVAL_UNDEF(&arr1);	ZVAL_UNDEF(&arr2);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 0, &arr1_param, &arr2_param);	zephir_get_arrval(&arr1, arr1_param);	zephir_get_arrval(&arr2, arr2_param);	zephir_fast_array_merge(return_value, &arr1, &arr2 TSRMLS_CC);	RETURN_MM();}

/** * @inheritdoc */PHP_METHOD(Owl_Log_AbstractWriter, commit) {	int ZEPHIR_LAST_CALL_STATUS;	zval *records_param = NULL, *_0, *_1, *_2 = NULL, *_3, *_4;	zval *records = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &records_param);	zephir_get_arrval(records, records_param);	ZEPHIR_INIT_VAR(_0);	_1 = zephir_fetch_nproperty_this(this_ptr, SL("records"), PH_NOISY_CC);	ZEPHIR_CALL_METHOD(&_2, this_ptr, "filterrecords", NULL, 0, records);	zephir_check_call_status();	zephir_fast_array_merge(_0, &(_1), &(_2) TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("records"), _0 TSRMLS_CC);	_3 = zephir_fetch_nproperty_this(this_ptr, SL("records"), PH_NOISY_CC);	_4 = zephir_fetch_nproperty_this(this_ptr, SL("recordsInterval"), PH_NOISY_CC);	if (ZEPHIR_LE_LONG(_4, zephir_fast_count_int(_3 TSRMLS_CC))) {		ZEPHIR_CALL_METHOD(NULL, this_ptr, "push", NULL, 0);		zephir_check_call_status();	}	ZEPHIR_MM_RESTORE();}

/** * Adds a route applying the common attributes */PHP_METHOD(Phalcon_Mvc_Router_Group, _addRoute) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_fcall_cache_entry *_0 = NULL;	zval *pattern_param = NULL, *paths = NULL, *httpMethods = NULL, *mergedPaths = NULL, *route, *defaultPaths, *processedPaths = NULL, *_1, *_2;	zval *pattern = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 2, &pattern_param, &paths, &httpMethods);	if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {		zephir_get_strval(pattern, pattern_param);	} else {		ZEPHIR_INIT_VAR(pattern);		ZVAL_EMPTY_STRING(pattern);	}	if (!paths) {		paths = ZEPHIR_GLOBAL(global_null);	}	if (!httpMethods) {		httpMethods = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_OBS_VAR(defaultPaths);	zephir_read_property_this(&defaultPaths, this_ptr, SL("_paths"), PH_NOISY_CC);	if (Z_TYPE_P(defaultPaths) == IS_ARRAY) {		if (Z_TYPE_P(paths) == IS_STRING) {			ZEPHIR_CALL_CE_STATIC(&processedPaths, phalcon_mvc_router_route_ce, "getroutepaths", &_0, 77, paths);			zephir_check_call_status();		} else {			ZEPHIR_CPY_WRT(processedPaths, paths);		}		if (Z_TYPE_P(processedPaths) == IS_ARRAY) {			ZEPHIR_INIT_VAR(mergedPaths);			zephir_fast_array_merge(mergedPaths, &(defaultPaths), &(processedPaths) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedPaths, defaultPaths);		}	} else {		ZEPHIR_CPY_WRT(mergedPaths, paths);	}	ZEPHIR_INIT_VAR(route);	object_init_ex(route, phalcon_mvc_router_route_ce);	_1 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);	ZEPHIR_INIT_VAR(_2);	ZEPHIR_CONCAT_VV(_2, _1, pattern);	ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 76, _2, mergedPaths, httpMethods);	zephir_check_call_status();	zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, route, "setgroup", NULL, 361, this_ptr);	zephir_check_call_status();	RETURN_CCTOR(route);}

/** * Register classes and their locations */PHP_METHOD(Phalcon_Loader, registerClasses) {	zend_bool merge;	zval *classes_param = NULL, *merge_param = NULL, *mergedClasses = NULL, *currentClasses;	zval *classes = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &classes_param, &merge_param);	classes = classes_param;	if (!merge_param) {		merge = 0;	} else {		merge = zephir_get_boolval(merge_param);	}	if (merge) {		ZEPHIR_OBS_VAR(currentClasses);		zephir_read_property_this(&currentClasses, this_ptr, SL("_classes"), PH_NOISY_CC);		if (Z_TYPE_P(currentClasses) == IS_ARRAY) {			ZEPHIR_INIT_VAR(mergedClasses);			zephir_fast_array_merge(mergedClasses, &(currentClasses), &(classes) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedClasses, classes);		}		zephir_update_property_this(this_ptr, SL("_classes"), mergedClasses TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("_classes"), classes TSRMLS_CC);	}	RETURN_THIS();}

PHP_METHOD(OAuth2_ResponseType_AuthorizationCode, __construct) {	zval *config = NULL, *_1;	zval *storage, *config_param = NULL, *_0;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &storage, &config_param);	if (!config_param) {		ZEPHIR_INIT_VAR(config);		array_init(config);	} else {		zephir_get_arrval(config, config_param);	}	if (!(zephir_instance_of_ev(storage, oauth2_storage_authorizationcodeinterface_ce TSRMLS_CC))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'storage' must be an instance of 'OAuth2//Storage//AuthorizationCodeInterface'", "", 0);		return;	}	zephir_update_property_this(this_ptr, SL("storage"), storage TSRMLS_CC);	ZEPHIR_INIT_VAR(_0);	ZEPHIR_INIT_VAR(_1);	array_init_size(_1, 3);	zephir_array_update_string(&_1, SL("enforce_redirect"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);	add_assoc_long_ex(_1, SS("auth_code_lifetime"), 30);	zephir_fast_array_merge(_0, &(_1), &(config) TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("config"), _0 TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Adds a route to the router without any HTTP constraint * *<code> * use Phalcon/Mvc/Router; * * $router->add('/about', 'About::index'); * $router->add('/about', 'About::index', ['GET', 'POST']); * $router->add('/about', 'About::index', ['GET', 'POST'], Router::POSITION_FIRST); *</code> */PHP_METHOD(Phalcon_Mvc_Router, add) {	zval *_1$$4;	int ZEPHIR_LAST_CALL_STATUS;	zval *pattern_param = NULL, *paths = NULL, *httpMethods = NULL, *position = NULL, *route = NULL, *_0$$4, *_2$$4;	zval *pattern = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 3, &pattern_param, &paths, &httpMethods, &position);	if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {		zephir_get_strval(pattern, pattern_param);	} else {		ZEPHIR_INIT_VAR(pattern);		ZVAL_EMPTY_STRING(pattern);	}	if (!paths) {		paths = ZEPHIR_GLOBAL(global_null);	}	if (!httpMethods) {		httpMethods = ZEPHIR_GLOBAL(global_null);	}	if (!position) {		ZEPHIR_INIT_VAR(position);		ZVAL_LONG(position, 1);	}	ZEPHIR_INIT_VAR(route);	object_init_ex(route, phalcon_mvc_router_route_ce);	ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 78, pattern, paths, httpMethods);	zephir_check_call_status();	do {		if (ZEPHIR_IS_LONG(position, 1)) {			zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);			break;		}		if (ZEPHIR_IS_LONG(position, 0)) {			ZEPHIR_INIT_VAR(_0$$4);			ZEPHIR_INIT_VAR(_1$$4);			zephir_create_array(_1$$4, 1, 0 TSRMLS_CC);			zephir_array_fast_append(_1$$4, route);			_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);			zephir_fast_array_merge(_0$$4, &(_1$$4), &(_2$$4) TSRMLS_CC);			zephir_update_property_this(this_ptr, SL("_routes"), _0$$4 TSRMLS_CC);			break;		}		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "Invalid route position", "phalcon/mvc/router.zep", 683);		return;	} while(0);	RETURN_CCTOR(route);}

/** * Renders a partial view * * <code> * 	//Show a partial inside another view * 	$this->partial('shared/footer'); * </code> * * <code> * 	//Show a partial inside another view with parameters * 	$this->partial('shared/footer', array('content' => $html)); * </code> * * @param string partialPath * @param array  params */PHP_METHOD(Phalcon_Mvc_View_Simple, partial) {	int ZEPHIR_LAST_CALL_STATUS;	zephir_nts_static zephir_fcall_cache_entry *_0 = NULL, *_2 = NULL, *_3 = NULL;	zval *partialPath_param = NULL, *params = NULL, *viewParams, *mergedParams = NULL, *_1, *_4;	zval *partialPath = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &partialPath_param, &params);	if (unlikely(Z_TYPE_P(partialPath_param) != IS_STRING && Z_TYPE_P(partialPath_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'partialPath' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(partialPath_param) == IS_STRING)) {		zephir_get_strval(partialPath, partialPath_param);	} else {		ZEPHIR_INIT_VAR(partialPath);		ZVAL_EMPTY_STRING(partialPath);	}	if (!params) {		params = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_CALL_FUNCTION(NULL, "ob_start", &_0);	zephir_check_call_status();	if (Z_TYPE_P(params) == IS_ARRAY) {		ZEPHIR_OBS_VAR(viewParams);		zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);		if (Z_TYPE_P(viewParams) == IS_ARRAY) {			ZEPHIR_INIT_VAR(mergedParams);			zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(mergedParams, params);		}		ZEPHIR_INIT_VAR(_1);		zephir_create_symbol_table(TSRMLS_C);			} else {		ZEPHIR_CPY_WRT(mergedParams, params);	}	ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", &_2, partialPath, mergedParams);	zephir_check_call_status();	if (Z_TYPE_P(params) == IS_ARRAY) {		zephir_update_property_this(this_ptr, SL("_viewParams"), viewParams TSRMLS_CC);	}	ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", &_3);	zephir_check_call_status();	_4 = zephir_fetch_nproperty_this(this_ptr, SL("_content"), PH_NOISY_CC);	zend_print_zval(_4, 0);	ZEPHIR_MM_RESTORE();}

/** * Adds default messages to validators */PHP_METHOD(Phalcon_Validation, setDefaultMessages) {	zval *messages_param = NULL, *defaultMessages = NULL, *_0$$3;	zval *messages = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &messages_param);	if (!messages_param) {		ZEPHIR_INIT_VAR(messages);		array_init(messages);	} else {		zephir_get_arrval(messages, messages_param);	}	ZEPHIR_INIT_VAR(defaultMessages);	zephir_create_array(defaultMessages, 25, 0 TSRMLS_CC);	add_assoc_stringl_ex(defaultMessages, SS("Alnum"), SL("Field :field must contain only letters and numbers"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Alpha"), SL("Field :field must contain only letters"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Between"), SL("Field :field must be within the range of :min to :max"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Confirmation"), SL("Field :field must be the same as :with"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Digit"), SL("Field :field must be numeric"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Email"), SL("Field :field must be an email address"), 1);	add_assoc_stringl_ex(defaultMessages, SS("ExclusionIn"), SL("Field :field must not be a part of list: :domain"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileEmpty"), SL("Field :field must not be empty"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileIniSize"), SL("File :field exceeds the maximum file size"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileMaxResolution"), SL("File :field must not exceed :max resolution"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileMinResolution"), SL("File :field must be at least :min resolution"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileSize"), SL("File :field exceeds the size of :max"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileType"), SL("File :field must be of type: :types"), 1);	add_assoc_stringl_ex(defaultMessages, SS("FileValid"), SL("Field :field is not valid"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Identical"), SL("Field :field does not have the expected value"), 1);	add_assoc_stringl_ex(defaultMessages, SS("InclusionIn"), SL("Field :field must be a part of list: :domain"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Numericality"), SL("Field :field does not have a valid numeric format"), 1);	add_assoc_stringl_ex(defaultMessages, SS("PresenceOf"), SL("Field :field is required"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Regex"), SL("Field :field does not match the required format"), 1);	add_assoc_stringl_ex(defaultMessages, SS("TooLong"), SL("Field :field must not exceed :max characters long"), 1);	add_assoc_stringl_ex(defaultMessages, SS("TooShort"), SL("Field :field must be at least :min characters long"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Uniqueness"), SL("Field :field must be unique"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Url"), SL("Field :field must be a url"), 1);	add_assoc_stringl_ex(defaultMessages, SS("CreditCard"), SL("Field :field is not valid for a credit card number"), 1);	add_assoc_stringl_ex(defaultMessages, SS("Date"), SL("Field :field is not a valid date"), 1);	if (zephir_fast_count_int(messages TSRMLS_CC)) {		ZEPHIR_INIT_VAR(_0$$3);		zephir_fast_array_merge(_0$$3, &(defaultMessages), &(messages) TSRMLS_CC);		zephir_update_property_this(this_ptr, SL("_defaultMessages"), _0$$3 TSRMLS_CC);		RETURN_MM_MEMBER(this_ptr, "_defaultMessages");	}	zephir_update_property_this(this_ptr, SL("_defaultMessages"), defaultMessages TSRMLS_CC);	RETURN_CCTOR(defaultMessages);}

/** * Reconfigure the route adding a new pattern and a set of paths */PHP_METHOD(Phalcon_Mvc_Router_Route, reConfigure) {	int ZEPHIR_LAST_CALL_STATUS;	zval *pattern_param = NULL, *paths = NULL, *routePaths = NULL, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_0, *_1;	zval *pattern = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 1, &pattern_param, &paths);	if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {		zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);		RETURN_MM_NULL();	}	if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {		zephir_get_strval(pattern, pattern_param);	} else {		ZEPHIR_INIT_VAR(pattern);		ZVAL_EMPTY_STRING(pattern);	}	if (!paths) {		paths = ZEPHIR_GLOBAL(global_null);	}	ZEPHIR_CALL_SELF(&routePaths, "getroutepaths", NULL, 0, paths);	zephir_check_call_status();	if (!(zephir_start_with_str(pattern, SL("#")))) {		if (zephir_memnstr_str(pattern, SL("{"), "phalcon/mvc/router/route.zep", 295)) {			ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, 0, pattern);			zephir_check_call_status();			ZEPHIR_OBS_VAR(pcrePattern);			zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 300 TSRMLS_CC);			ZEPHIR_INIT_VAR(_0);			zephir_array_fetch_long(&_1, extracted, 1, PH_NOISY | PH_READONLY, "phalcon/mvc/router/route.zep", 301 TSRMLS_CC);			zephir_fast_array_merge(_0, &(routePaths), &(_1) TSRMLS_CC);			ZEPHIR_CPY_WRT(routePaths, _0);		} else {			ZEPHIR_CPY_WRT(pcrePattern, pattern);		}		ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, 0, pcrePattern);		zephir_check_call_status();	} else {		ZEPHIR_CPY_WRT(compiledPattern, pattern);	}	zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Appends an array of messages to the group * *<code> * $messages->appendMessages($messagesArray); *</code> * * @param /Phalcon/Validation/MessageInterface[] messages */PHP_METHOD(Phalcon_Validation_Message_Group, appendMessages) {	zend_bool _0;	zephir_fcall_cache_entry *_2 = NULL, *_3 = NULL, *_4 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *messages, *currentMessages = NULL, *finalMessages = NULL, *message = NULL, *_1$$7 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &messages);	_0 = Z_TYPE_P(messages) != IS_ARRAY;	if (_0) {		_0 = Z_TYPE_P(messages) != IS_OBJECT;	}	if (_0) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The messages must be array or object", "phalcon/validation/message/group.zep", 151);		return;	}	ZEPHIR_OBS_VAR(currentMessages);	zephir_read_property_this(&currentMessages, this_ptr, SL("_messages"), PH_NOISY_CC);	if (Z_TYPE_P(messages) == IS_ARRAY) {		if (Z_TYPE_P(currentMessages) == IS_ARRAY) {			ZEPHIR_INIT_VAR(finalMessages);			zephir_fast_array_merge(finalMessages, &(currentMessages), &(messages) TSRMLS_CC);		} else {			ZEPHIR_CPY_WRT(finalMessages, messages);		}		zephir_update_property_this(this_ptr, SL("_messages"), finalMessages TSRMLS_CC);	} else {		ZEPHIR_CALL_METHOD(NULL, messages, "rewind", NULL, 0);		zephir_check_call_status();		while (1) {			ZEPHIR_CALL_METHOD(&_1$$7, messages, "valid", NULL, 0);			zephir_check_call_status();			if (!(zephir_is_true(_1$$7))) {				break;			}			ZEPHIR_CALL_METHOD(&message, messages, "current", &_2, 0);			zephir_check_call_status();			ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", &_3, 0, message);			zephir_check_call_status();			ZEPHIR_CALL_METHOD(NULL, messages, "next", &_4, 0);			zephir_check_call_status();		}	}	ZEPHIR_MM_RESTORE();}

/** * Appends an array of messages to the group * *<code> * $messages->appendMessages($messagesArray); *</code> * * @param Phalcon/Validation/MessageInterface[] messages */PHP_METHOD(Phalcon_Validation_Message_Group, appendMessages) {    zephir_fcall_cache_entry *_2 = NULL;    int ZEPHIR_LAST_CALL_STATUS;    zend_object_iterator *_1;    zend_bool _0;    zval *messages, *currentMessages, *finalMessages = NULL, *message = NULL;    ZEPHIR_MM_GROW();    zephir_fetch_params(1, 1, 0, &messages);    _0 = Z_TYPE_P(messages) != IS_ARRAY;    if (_0) {        _0 = Z_TYPE_P(messages) != IS_OBJECT;    }    if (_0) {        ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The messages must be array or object", "phalcon/validation/message/group.zep", 146);        return;    }    ZEPHIR_OBS_VAR(currentMessages);    zephir_read_property_this(&currentMessages, this_ptr, SL("_messages"), PH_NOISY_CC);    if (Z_TYPE_P(messages) == IS_ARRAY) {        if (ZEPHIR_IS_STRING(currentMessages, "array")) {            ZEPHIR_INIT_VAR(finalMessages);            zephir_fast_array_merge(finalMessages, &(currentMessages), &(messages) TSRMLS_CC);        } else {            ZEPHIR_CPY_WRT(finalMessages, messages);        }        zephir_update_property_this(this_ptr, SL("_messages"), finalMessages TSRMLS_CC);    } else {        _1 = zephir_get_iterator(messages TSRMLS_CC);        _1->funcs->rewind(_1 TSRMLS_CC);        for (; _1->funcs->valid(_1 TSRMLS_CC) == SUCCESS && !EG(exception); _1->funcs->move_forward(_1 TSRMLS_CC)) {            {                zval **ZEPHIR_TMP_ITERATOR_PTR;                _1->funcs->get_current_data(_1, &ZEPHIR_TMP_ITERATOR_PTR TSRMLS_CC);                ZEPHIR_CPY_WRT(message, (*ZEPHIR_TMP_ITERATOR_PTR));            }            ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", &_2, 0, message);            zephir_check_call_status();        }        _1->funcs->dtor(_1 TSRMLS_CC);    }    ZEPHIR_MM_RESTORE();}

/** * Merge modules with the existing ones * *<code> *	application->addModules(array( *		'admin' => array( *			'className' => 'Multiple/Admin/Module', *			'path' => '../apps/admin/Module.php' *		) *	)); *</code> */PHP_METHOD(Phalcon_Cli_Console, addModules) {	zval *modules_param = NULL, *_0, *_1;	zval *modules = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &modules_param);	modules = modules_param;	ZEPHIR_INIT_VAR(_0);	_1 = zephir_fetch_nproperty_this(this_ptr, SL("_modules"), PH_NOISY_CC);	zephir_fast_array_merge(_0, &(modules), &(_1) TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_modules"), _0 TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

/** * Validator for constructor */PHP_METHOD(Phalcon_Translate_Adapter_Gettext, prepareOptions) {	int ZEPHIR_LAST_CALL_STATUS;	zval *options_param = NULL, *_0, *_1 = NULL, *_2, *_3, *_4, *_5, *_6;	zval *options = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &options_param);	options = options_param;	if (!(zephir_array_isset_string(options, SS("locale")))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter /"locale/" is required", "phalcon/translate/adapter/gettext.zep", 227);		return;	}	if (!(zephir_array_isset_string(options, SS("directory")))) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter /"directory/" is required", "phalcon/translate/adapter/gettext.zep", 231);		return;	}	ZEPHIR_INIT_VAR(_0);	ZEPHIR_CALL_METHOD(&_1, this_ptr, "getoptionsdefault", NULL, 0);	zephir_check_call_status();	zephir_fast_array_merge(_0, &(_1), &(options) TSRMLS_CC);	ZEPHIR_CPY_WRT(options, _0);	zephir_array_fetch_string(&_2, options, SL("category"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 236 TSRMLS_CC);	zephir_array_fetch_string(&_3, options, SL("locale"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 236 TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "setlocale", NULL, 0, _2, _3);	zephir_check_call_status();	zephir_array_fetch_string(&_4, options, SL("defaultDomain"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 237 TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdefaultdomain", NULL, 0, _4);	zephir_check_call_status();	zephir_array_fetch_string(&_5, options, SL("directory"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 238 TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdirectory", NULL, 0, _5);	zephir_check_call_status();	zephir_array_fetch_string(&_6, options, SL("defaultDomain"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/gettext.zep", 239 TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdomain", NULL, 0, _6);	zephir_check_call_status();	ZEPHIR_MM_RESTORE();}

/** * Sets a single attribute. * * @param string name * @param mixed value * @param boolean overwrite [Optional] Default = true * @return /Xpl/HtmlElement */PHP_METHOD(Xpl_HtmlElement, setAttribute) {	zend_bool overwrite, _0;	zval *name_param = NULL, *value, *overwrite_param = NULL, *attrs = NULL, *arrVal = NULL, *_1$$6, *_2$$6;	zval *name = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 2, 1, &name_param, &value, &overwrite_param);	zephir_get_strval(name, name_param);	if (!overwrite_param) {		overwrite = 1;	} else {		overwrite = zephir_get_boolval(overwrite_param);	}	ZEPHIR_OBS_VAR(attrs);	zephir_read_property_this(&attrs, this_ptr, SL("_attributes"), PH_NOISY_CC);	if (Z_TYPE_P(value) == IS_ARRAY) {		ZEPHIR_CPY_WRT(arrVal, value);	} else {		ZEPHIR_INIT_NVAR(arrVal);		zephir_create_array(arrVal, 1, 0 TSRMLS_CC);		zephir_array_fast_append(arrVal, value);	}	_0 = !(zephir_array_isset(attrs, name));	if (!(_0)) {		_0 = overwrite;	}	if (_0) {		zephir_array_update_zval(&attrs, name, &arrVal, PH_COPY | PH_SEPARATE);	} else {		ZEPHIR_INIT_VAR(_1$$6);		zephir_array_fetch(&_2$$6, attrs, name, PH_NOISY | PH_READONLY, "xpl/htmlelement.zep", 84 TSRMLS_CC);		zephir_fast_array_merge(_1$$6, &(_2$$6), &(arrVal) TSRMLS_CC);		zephir_array_update_zval(&attrs, name, &_1$$6, PH_COPY | PH_SEPARATE);	}	zephir_update_property_this(this_ptr, SL("_attributes"), attrs TSRMLS_CC);	RETURN_THIS();}

/** * Set styles for vars type */PHP_METHOD(Phalcon_Debug_Dump, setStyles) {	zval *styles = NULL, *defaultStyles = NULL, *_0;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &styles);	if (!styles) {		ZEPHIR_CPY_WRT(styles, ZEPHIR_GLOBAL(global_null));	} else {		ZEPHIR_SEPARATE_PARAM(styles);	}	if (Z_TYPE_P(styles) == IS_NULL) {		ZEPHIR_INIT_NVAR(styles);		array_init(styles);	}	if (Z_TYPE_P(styles) != IS_ARRAY) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_debug_exception_ce, "The styles must be an array", "phalcon/debug/dump.zep", 102);		return;	}	ZEPHIR_INIT_VAR(defaultStyles);	zephir_create_array(defaultStyles, 11, 0 TSRMLS_CC);	add_assoc_stringl_ex(defaultStyles, SS("pre"), SL("background-color:#f3f3f3; font-size:11px; padding:10px; border:1px solid #ccc; text-align:left; color:#333"), 1);	add_assoc_stringl_ex(defaultStyles, SS("arr"), SL("color:red"), 1);	add_assoc_stringl_ex(defaultStyles, SS("bool"), SL("color:green"), 1);	add_assoc_stringl_ex(defaultStyles, SS("float"), SL("color:fuchsia"), 1);	add_assoc_stringl_ex(defaultStyles, SS("int"), SL("color:blue"), 1);	add_assoc_stringl_ex(defaultStyles, SS("null"), SL("color:black"), 1);	add_assoc_stringl_ex(defaultStyles, SS("num"), SL("color:navy"), 1);	add_assoc_stringl_ex(defaultStyles, SS("obj"), SL("color:purple"), 1);	add_assoc_stringl_ex(defaultStyles, SS("other"), SL("color:maroon"), 1);	add_assoc_stringl_ex(defaultStyles, SS("res"), SL("color:lime"), 1);	add_assoc_stringl_ex(defaultStyles, SS("str"), SL("color:teal"), 1);	ZEPHIR_INIT_VAR(_0);	zephir_fast_array_merge(_0, &(defaultStyles), &(styles) TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_styles"), _0 TSRMLS_CC);	RETURN_MM_MEMBER(this_ptr, "_styles");}

/** * Set styles for vars type */PHP_METHOD(Phalcon_Debug_Dump, setStyles) {	zval *styles_param = NULL, defaultStyles, _0;	zval styles;	zval *this_ptr = getThis();	ZVAL_UNDEF(&styles);	ZVAL_UNDEF(&defaultStyles);	ZVAL_UNDEF(&_0);	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 0, 1, &styles_param);	if (!styles_param) {		ZEPHIR_INIT_VAR(&styles);		array_init(&styles);	} else {	ZEPHIR_OBS_COPY_OR_DUP(&styles, styles_param);	}	ZEPHIR_INIT_VAR(&defaultStyles);	zephir_create_array(&defaultStyles, 11, 0 TSRMLS_CC);	add_assoc_stringl_ex(&defaultStyles, SL("pre"), SL("background-color:#f3f3f3; font-size:11px; padding:10px; border:1px solid #ccc; text-align:left; color:#333"));	add_assoc_stringl_ex(&defaultStyles, SL("arr"), SL("color:red"));	add_assoc_stringl_ex(&defaultStyles, SL("bool"), SL("color:green"));	add_assoc_stringl_ex(&defaultStyles, SL("float"), SL("color:fuchsia"));	add_assoc_stringl_ex(&defaultStyles, SL("int"), SL("color:blue"));	add_assoc_stringl_ex(&defaultStyles, SL("null"), SL("color:black"));	add_assoc_stringl_ex(&defaultStyles, SL("num"), SL("color:navy"));	add_assoc_stringl_ex(&defaultStyles, SL("obj"), SL("color:purple"));	add_assoc_stringl_ex(&defaultStyles, SL("other"), SL("color:maroon"));	add_assoc_stringl_ex(&defaultStyles, SL("res"), SL("color:lime"));	add_assoc_stringl_ex(&defaultStyles, SL("str"), SL("color:teal"));	ZEPHIR_INIT_VAR(&_0);	zephir_fast_array_merge(&_0, &defaultStyles, &styles TSRMLS_CC);	zephir_update_property_zval(this_ptr, SL("styles"), &_0);	RETURN_MM_MEMBER(getThis(), "styles");}

/** * Merges items into the object * * @param mixed data */PHP_METHOD(Xpl_Collection_ArrayObject, merge) {	zephir_fcall_cache_entry *_3 = NULL;	int ZEPHIR_LAST_CALL_STATUS;	zval *data, *_0, *_1 = NULL, *_2 = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &data);	ZEPHIR_INIT_VAR(_0);	ZEPHIR_CALL_METHOD(&_1, this_ptr, "getarraycopy", NULL, 0);	zephir_check_call_status();	ZEPHIR_CALL_CE_STATIC(&_2, xpl_type_ce, "toarray", &_3, 66, data);	zephir_check_call_status();	zephir_fast_array_merge(_0, &(_1), &(_2) TSRMLS_CC);	ZEPHIR_CALL_METHOD(NULL, this_ptr, "exchangearray", NULL, 0, _0);	zephir_check_call_status();	RETURN_THIS();}

/** * @param array $classMap Class to filename map */PHP_METHOD(Xpl_ClassLoader, addClassMap) {	zval *classMap_param = NULL, *_0, *_1$$3, *_2$$3;	zval *classMap = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &classMap_param);	classMap = classMap_param;	ZEPHIR_OBS_VAR(_0);	zephir_read_property_this(&_0, this_ptr, SL("classMap"), PH_NOISY_CC);	if (Z_TYPE_P(_0) == IS_ARRAY) {		ZEPHIR_INIT_VAR(_1$$3);		_2$$3 = zephir_fetch_nproperty_this(this_ptr, SL("classMap"), PH_NOISY_CC);		zephir_fast_array_merge(_1$$3, &(_2$$3), &(classMap) TSRMLS_CC);		zephir_update_property_this(this_ptr, SL("classMap"), _1$$3 TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("classMap"), classMap TSRMLS_CC);	}	ZEPHIR_MM_RESTORE();}

PHP_METHOD(ZFrame_Request, addParams) {	zval *arr_param = NULL, *_0, *_1, *_2;	zval *arr = NULL;	ZEPHIR_MM_GROW();	zephir_fetch_params(1, 1, 0, &arr_param);	arr = arr_param;	_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);	if (Z_TYPE_P(_0) == IS_ARRAY) {		ZEPHIR_INIT_VAR(_1);		_2 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);		zephir_fast_array_merge(_1, &(_2), &(arr) TSRMLS_CC);		zephir_update_property_this(this_ptr, SL("_params"), _1 TSRMLS_CC);	} else {		zephir_update_property_this(this_ptr, SL("_params"), arr TSRMLS_CC);	}	ZEPHIR_MM_RESTORE();}

//.........这里部分代码省略.........	if (Z_TYPE_P(pattern) != IS_STRING) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270);		return;	}	if (Z_TYPE_P(paths) != IS_NULL) {		if (Z_TYPE_P(paths) == IS_STRING) {			ZEPHIR_INIT_VAR(&moduleName);			ZVAL_NULL(&moduleName);			ZEPHIR_INIT_VAR(&controllerName);			ZVAL_NULL(&controllerName);			ZEPHIR_INIT_VAR(&actionName);			ZVAL_NULL(&actionName);			ZEPHIR_INIT_VAR(&parts);			zephir_fast_explode_str(&parts, SL("::"), paths, LONG_MAX TSRMLS_CC);			do {				_0$$5 = zephir_fast_count_int(&parts TSRMLS_CC);				if (_0$$5 == 3) {					ZEPHIR_OBS_NVAR(&moduleName);					zephir_array_fetch_long(&moduleName, &parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC);					ZEPHIR_OBS_NVAR(&controllerName);					zephir_array_fetch_long(&controllerName, &parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC);					ZEPHIR_OBS_NVAR(&actionName);					zephir_array_fetch_long(&actionName, &parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC);					break;				}				if (_0$$5 == 2) {					ZEPHIR_OBS_NVAR(&controllerName);					zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC);					ZEPHIR_OBS_NVAR(&actionName);					zephir_array_fetch_long(&actionName, &parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC);					break;				}				if (_0$$5 == 1) {					ZEPHIR_OBS_NVAR(&controllerName);					zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC);					break;				}			} while(0);			ZEPHIR_INIT_VAR(&routePaths);			array_init(&routePaths);			if (Z_TYPE_P(&moduleName) != IS_NULL) {				zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);			}			if (Z_TYPE_P(&controllerName) != IS_NULL) {				if (zephir_memnstr_str(&controllerName, SL("//"), "test/router/route.zep", 310)) {					ZEPHIR_INIT_VAR(&realClassName);					zephir_get_class_ns(&realClassName, &controllerName, 0 TSRMLS_CC);					ZEPHIR_INIT_VAR(&namespaceName);					zephir_get_ns_class(&namespaceName, &controllerName, 0 TSRMLS_CC);					if (zephir_is_true(&namespaceName)) {						zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);					}				} else {					ZEPHIR_CPY_WRT(&realClassName, &controllerName);				}				ZEPHIR_INIT_VAR(&_1$$10);				zephir_uncamelize(&_1$$10, &realClassName);				zephir_array_update_string(&routePaths, SL("controller"), &_1$$10, PH_COPY | PH_SEPARATE);			}			if (Z_TYPE_P(&actionName) != IS_NULL) {				zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);			}		} else {			ZEPHIR_CPY_WRT(&routePaths, paths);		}	} else {		ZEPHIR_INIT_NVAR(&routePaths);		array_init(&routePaths);	}	if (Z_TYPE_P(&routePaths) != IS_ARRAY) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342);		return;	}	if (!(zephir_start_with_str(pattern, SL("#")))) {		if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) {			ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, 0, pattern);			zephir_check_call_status();			ZEPHIR_OBS_VAR(&pcrePattern);			zephir_array_fetch_long(&pcrePattern, &extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC);			ZEPHIR_INIT_VAR(&_2$$19);			zephir_array_fetch_long(&_3$$19, &extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC);			zephir_fast_array_merge(&_2$$19, &routePaths, &_3$$19 TSRMLS_CC);			ZEPHIR_CPY_WRT(&routePaths, &_2$$19);		} else {			ZEPHIR_CPY_WRT(&pcrePattern, pattern);		}		ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, 0, &pcrePattern);		zephir_check_call_status();	} else {		ZEPHIR_CPY_WRT(&compiledPattern, pattern);	}	zephir_update_property_zval(this_ptr, SL("_pattern"), pattern);	zephir_update_property_zval(this_ptr, SL("_compiledPattern"), &compiledPattern);	zephir_update_property_zval(this_ptr, SL("_paths"), &routePaths);	ZEPHIR_MM_RESTORE();}

//.........这里部分代码省略.........	if ((Z_TYPE_P(pattern) != IS_STRING)) {		ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The pattern must be string");		return;	}	if ((Z_TYPE_P(paths) != IS_NULL)) {		if ((Z_TYPE_P(paths) == IS_STRING)) {			ZEPHIR_INIT_VAR(moduleName);			ZVAL_NULL(moduleName);			ZEPHIR_INIT_VAR(controllerName);			ZVAL_NULL(controllerName);			ZEPHIR_INIT_VAR(actionName);			ZVAL_NULL(actionName);			ZEPHIR_SINIT_VAR(_0);			ZVAL_STRING(&_0, "::", 0);			ZEPHIR_INIT_VAR(parts);			zephir_call_func_p2(parts, "explode", &_0, paths);			do {				_1 = zephir_fast_count_int(parts TSRMLS_CC);				if ((_1 == 3)) {					ZEPHIR_OBS_NVAR(moduleName);					zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY TSRMLS_CC);					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY TSRMLS_CC);					ZEPHIR_OBS_NVAR(actionName);					zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY TSRMLS_CC);					break;				}				if ((_1 == 2)) {					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);					ZEPHIR_OBS_NVAR(actionName);					zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY TSRMLS_CC);					break;				}				if ((_1 == 1)) {					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);					break;				}			} while(0);			ZEPHIR_INIT_VAR(routePaths);			array_init(routePaths);			if ((Z_TYPE_P(moduleName) != IS_NULL)) {				zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);			}			if ((Z_TYPE_P(controllerName) != IS_NULL)) {				if (zephir_memnstr_str(controllerName, SL("//"), "test/router/route.zep", 313)) {					ZEPHIR_INIT_VAR(realClassName);					zephir_call_func_p1(realClassName, "get_class_ns", controllerName);					ZEPHIR_INIT_VAR(namespaceName);					zephir_call_func_p1(namespaceName, "get_ns_class", controllerName);					if (zephir_is_true(namespaceName)) {						zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);					}				} else {					ZEPHIR_CPY_WRT(realClassName, controllerName);				}				ZEPHIR_INIT_VAR(_2);				zephir_uncamelize(_2, realClassName);				zephir_array_update_string(&routePaths, SL("controller"), &_2, PH_COPY | PH_SEPARATE);			}			if ((Z_TYPE_P(actionName) != IS_NULL)) {				zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);			}		} else {			ZEPHIR_CPY_WRT(routePaths, paths);		}	} else {		ZEPHIR_INIT_NVAR(routePaths);		array_init(routePaths);	}	if ((Z_TYPE_P(routePaths) != IS_ARRAY)) {		ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The route contains invalid paths");		return;	}	if (!(zephir_start_with_str(pattern, SL("#")))) {		if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 351)) {			ZEPHIR_INIT_VAR(extracted);			zephir_call_method_p1(extracted, this_ptr, "extractnamedparams", pattern);			ZEPHIR_OBS_VAR(pcrePattern);			zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY TSRMLS_CC);			ZEPHIR_INIT_NVAR(_2);			zephir_array_fetch_long(&_3, extracted, 1, PH_NOISY | PH_READONLY TSRMLS_CC);			zephir_fast_array_merge(_2, &(routePaths), &(_3) TSRMLS_CC);			ZEPHIR_CPY_WRT(routePaths, _2);		} else {			ZEPHIR_CPY_WRT(pcrePattern, pattern);		}		ZEPHIR_INIT_VAR(compiledPattern);		zephir_call_method_p1(compiledPattern, this_ptr, "compilepattern", pcrePattern);	} else {		ZEPHIR_CPY_WRT(compiledPattern, pattern);	}	zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);	ZEPHIR_MM_RESTORE();}

//.........这里部分代码省略.........	if (Z_TYPE_P(pattern) != IS_STRING) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270);		return;	}	if (Z_TYPE_P(paths) != IS_NULL) {		if (Z_TYPE_P(paths) == IS_STRING) {			ZEPHIR_INIT_VAR(moduleName);			ZVAL_NULL(moduleName);			ZEPHIR_INIT_VAR(controllerName);			ZVAL_NULL(controllerName);			ZEPHIR_INIT_VAR(actionName);			ZVAL_NULL(actionName);			ZEPHIR_INIT_VAR(parts);			zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);			do {				_0 = zephir_fast_count_int(parts TSRMLS_CC);				if (_0 == 3) {					ZEPHIR_OBS_NVAR(moduleName);					zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC);					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC);					ZEPHIR_OBS_NVAR(actionName);					zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC);					break;				}				if (_0 == 2) {					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC);					ZEPHIR_OBS_NVAR(actionName);					zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC);					break;				}				if (_0 == 1) {					ZEPHIR_OBS_NVAR(controllerName);					zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC);					break;				}			} while(0);			ZEPHIR_INIT_VAR(routePaths);			array_init(routePaths);			if (Z_TYPE_P(moduleName) != IS_NULL) {				zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);			}			if (Z_TYPE_P(controllerName) != IS_NULL) {				if (zephir_memnstr_str(controllerName, SL("//"), "test/router/route.zep", 310)) {					ZEPHIR_INIT_VAR(realClassName);					zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);					ZEPHIR_INIT_VAR(namespaceName);					zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);					if (zephir_is_true(namespaceName)) {						zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);					}				} else {					ZEPHIR_CPY_WRT(realClassName, controllerName);				}				ZEPHIR_INIT_VAR(_1);				zephir_uncamelize(_1, realClassName);				zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE);			}			if (Z_TYPE_P(actionName) != IS_NULL) {				zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);			}		} else {			ZEPHIR_CPY_WRT(routePaths, paths);		}	} else {		ZEPHIR_INIT_NVAR(routePaths);		array_init(routePaths);	}	if (Z_TYPE_P(routePaths) != IS_ARRAY) {		ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342);		return;	}	if (!(zephir_start_with_str(pattern, SL("#")))) {		if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) {			ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, pattern);			zephir_check_call_status();			ZEPHIR_OBS_VAR(pcrePattern);			zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC);			ZEPHIR_INIT_NVAR(_1);			zephir_array_fetch_long(&_2, extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC);			zephir_fast_array_merge(_1, &(routePaths), &(_2) TSRMLS_CC);			ZEPHIR_CPY_WRT(routePaths, _1);		} else {			ZEPHIR_CPY_WRT(pcrePattern, pattern);		}		ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, pcrePattern);		zephir_check_call_status();	} else {		ZEPHIR_CPY_WRT(compiledPattern, pattern);	}	zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);	zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);	ZEPHIR_MM_RESTORE();}