/**
* 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(¤tBindParams, _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(¤tBindTypes, _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, ¶ms_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, ¶ms_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(¤tValidators, 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(¤tClasses, 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);
}
/**
* Mounts a group of routes in the router
*/
PHP_METHOD(Phalcon_Mvc_Router, mount) {
HashTable *_1$$4, *_4$$6;
HashPosition _0$$4, _3$$6;
int ZEPHIR_LAST_CALL_STATUS;
zval *group, *groupRoutes = NULL, *beforeMatch = NULL, *hostname = NULL, *routes = NULL, *route = NULL, **_2$$4, **_5$$6, *_6$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &group);
ZEPHIR_CALL_METHOD(&groupRoutes, group, "getroutes", NULL, 0);
zephir_check_call_status();
if (!(zephir_fast_count_int(groupRoutes TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "The group of routes does not contain any routes", "phalcon/mvc/router.zep", 754);
return;
}
ZEPHIR_CALL_METHOD(&beforeMatch, group, "getbeforematch", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
zephir_is_iterable(groupRoutes, &_1$$4, &_0$$4, 0, 0, "phalcon/mvc/router.zep", 766);
for (
; zephir_hash_get_current_data_ex(_1$$4, (void**) &_2$$4, &_0$$4) == SUCCESS
; zephir_hash_move_forward_ex(_1$$4, &_0$$4)
) {
ZEPHIR_GET_HVALUE(route, _2$$4);
ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, 0, beforeMatch);
zephir_check_call_status();
}
}
ZEPHIR_CALL_METHOD(&hostname, group, "gethostname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(hostname) != IS_NULL) {
zephir_is_iterable(groupRoutes, &_4$$6, &_3$$6, 0, 0, "phalcon/mvc/router.zep", 775);
for (
; zephir_hash_get_current_data_ex(_4$$6, (void**) &_5$$6, &_3$$6) == SUCCESS
; zephir_hash_move_forward_ex(_4$$6, &_3$$6)
) {
ZEPHIR_GET_HVALUE(route, _5$$6);
ZEPHIR_CALL_METHOD(NULL, route, "sethostname", NULL, 0, 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$$8);
zephir_fast_array_merge(_6$$8, &(routes), &(groupRoutes) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_routes"), _6$$8 TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_routes"), groupRoutes TSRMLS_CC);
}
RETURN_THIS();
}
/**
* 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, ¶ms);
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(¤tMessages, 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();
}
PHP_METHOD(OAuth2_ResponseType_AuthorizationCode, getAuthorizeResponse) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_1;
zval *user_id = NULL;
zval *params = NULL, *user_id_param = NULL, *result, *_0 = NULL, *_2 = NULL, *_3, *_4, *_5, *_6, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, ¶ms, &user_id_param);
ZEPHIR_SEPARATE_PARAM(params);
if (!user_id_param) {
ZEPHIR_INIT_VAR(user_id);
ZVAL_EMPTY_STRING(user_id);
} else {
zephir_get_strval(user_id, user_id_param);
}
ZEPHIR_INIT_VAR(result);
array_init_size(result, 2);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(&result, SL("query"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 3);
zephir_array_update_string(&_1, SL("scope"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_1, SL("state"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_fast_array_merge(_0, &(_1), &(params) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _0);
zephir_array_fetch_string(&_3, params, SL("client_id"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_4, params, SL("redirect_uri"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_5, params, SL("scope"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "createauthorizationcode", NULL, _3, user_id, _4, _5);
zephir_check_call_status();
zephir_array_update_multi(&result, &_2 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("code"));
if (zephir_array_isset_string(params, SS("state"))) {
zephir_array_fetch_string(&_6, params, SL("state"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 40 TSRMLS_CC);
zephir_array_update_multi(&result, &_6 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("state"));
}
array_init_size(return_value, 3);
ZEPHIR_OBS_VAR(_7);
zephir_array_fetch_string(&_7, params, SL("redirect_uri"), PH_NOISY, "oauth2/responsetype/authorizationcode.zep", 43 TSRMLS_CC);
zephir_array_fast_append(return_value, _7);
zephir_array_fast_append(return_value, result);
RETURN_MM();
}
/**
* 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(¤tMessages, 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();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int ZEPHIR_LAST_CALL_STATUS, _0$$5;
zval *pattern, pattern_sub, *paths = NULL, paths_sub, __$null, moduleName, controllerName, actionName, parts, routePaths, realClassName, namespaceName, pcrePattern, compiledPattern, extracted, _1$$10, _2$$19, _3$$19;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&pattern_sub);
ZVAL_UNDEF(&paths_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&moduleName);
ZVAL_UNDEF(&controllerName);
ZVAL_UNDEF(&actionName);
ZVAL_UNDEF(&parts);
ZVAL_UNDEF(&routePaths);
ZVAL_UNDEF(&realClassName);
ZVAL_UNDEF(&namespaceName);
ZVAL_UNDEF(&pcrePattern);
ZVAL_UNDEF(&compiledPattern);
ZVAL_UNDEF(&extracted);
ZVAL_UNDEF(&_1$$10);
ZVAL_UNDEF(&_2$$19);
ZVAL_UNDEF(&_3$$19);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = &paths_sub;
paths = &__$null;
}
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();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _1;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted, _0, *_2 = NULL, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
ZEPHIR_CPY_WRT(paths, ZEPHIR_GLOBAL(global_null));
}
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();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _0, ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
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();
}
