/** * Choose a different view to render instead of last-controller/last-action * * <code> * class ProductsController extends Phalcon\Mvc\Controller * { * * public function saveAction() * { * * //Do some save stuff... * * //Then show the list view * $this->view->pick("products/list"); * } * } * </code> * * @param string $renderView */ PHP_METHOD(Phalcon_Mvc_View, pick){ zval *render_view, *separator, *pick_view = NULL, *layout = NULL; zval *parts; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &render_view); PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "/", 1); if (Z_TYPE_P(render_view) == IS_ARRAY) { PHALCON_CPY_WRT(pick_view, render_view); } else { PHALCON_INIT_VAR(layout); if (phalcon_memnstr(render_view, separator TSRMLS_CC)) { PHALCON_INIT_VAR(parts); phalcon_fast_explode(parts, separator, render_view TSRMLS_CC); PHALCON_OBS_NVAR(layout); phalcon_array_fetch_long(&layout, parts, 0, PH_NOISY_CC); } PHALCON_INIT_VAR(pick_view); array_init_size(pick_view, 1); phalcon_array_append(&pick_view, render_view, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(layout) != IS_NULL) { phalcon_array_append(&pick_view, layout, PH_SEPARATE TSRMLS_CC); } } phalcon_update_property_this(this_ptr, SL("_pickView"), pick_view TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Gets most possible client IPv4 Address. This method search in $_SERVER['REMOTE_ADDR'] and optionally in $_SERVER['HTTP_X_FORWARDED_FOR'] * * @param boolean $trustForwardedHeader * @return string */ PHP_METHOD(Phalcon_Http_Request, getClientAddress){ zval *trust_forwarded_header = NULL, *address = NULL, *_SERVER; zval *comma, *addresses, *first; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &trust_forwarded_header) == FAILURE) { RETURN_MM_NULL(); } if (!trust_forwarded_header) { PHALCON_INIT_VAR(trust_forwarded_header); ZVAL_BOOL(trust_forwarded_header, 0); } PHALCON_INIT_VAR(address); /** * Proxies uses this IP */ phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); if (phalcon_array_isset_string(_SERVER, SS("HTTP_X_FORWARDED_FOR"))) { if (zend_is_true(trust_forwarded_header)) { PHALCON_OBS_NVAR(address); phalcon_array_fetch_string(&address, _SERVER, SL("HTTP_X_FORWARDED_FOR"), PH_NOISY_CC); } } if (Z_TYPE_P(address) == IS_NULL) { if (phalcon_array_isset_string(_SERVER, SS("REMOTE_ADDR"))) { PHALCON_OBS_NVAR(address); phalcon_array_fetch_string(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY_CC); } } if (Z_TYPE_P(address) == IS_STRING) { if (phalcon_memnstr_str(address, SL(",") TSRMLS_CC)) { /** * The client address has multiples parts, only return the first part */ PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ",", 1); PHALCON_INIT_VAR(addresses); phalcon_fast_explode(addresses, comma, address TSRMLS_CC); PHALCON_OBS_VAR(first); phalcon_array_fetch_long(&first, addresses, 0, PH_NOISY_CC); RETURN_CCTOR(first); } RETURN_CCTOR(address); } RETURN_MM_FALSE; }
/** * Returns the prefix for all the generated urls. By default / * * @return string */ PHP_METHOD(Phalcon_Mvc_Url, getBaseUri){ zval *base_uri = NULL, *slash, *one, *minus_one = NULL, *php_self; zval *dirname, *dir_parts, *slice, *uri = NULL; zval *g0 = NULL; zval *c0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(base_uri); phalcon_read_property(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY_CC); if (Z_TYPE_P(base_uri) == IS_NULL) { PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, SS("PHP_SELF")); if (eval_int) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, -1); PHALCON_CPY_WRT(minus_one, c0); PHALCON_INIT_VAR(php_self); phalcon_array_fetch_string(&php_self, g0, SL("PHP_SELF"), PH_NOISY_CC); PHALCON_INIT_VAR(dirname); PHALCON_CALL_FUNC_PARAMS_1(dirname, "dirname", php_self); PHALCON_INIT_VAR(dir_parts); phalcon_fast_explode(dir_parts, slash, dirname TSRMLS_CC); PHALCON_INIT_VAR(slice); PHALCON_CALL_FUNC_PARAMS_3(slice, "array_slice", dir_parts, one, minus_one); PHALCON_INIT_VAR(uri); phalcon_fast_join(uri, slash, slice TSRMLS_CC); } else { PHALCON_INIT_NVAR(uri); ZVAL_STRING(uri, "", 1); } if (PHALCON_COMPARE_STRING(uri, "")) { PHALCON_CPY_WRT(base_uri, slash); } else { PHALCON_INIT_NVAR(base_uri); PHALCON_CONCAT_VVV(base_uri, slash, uri, slash); } phalcon_update_property_zval(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC); } RETURN_CCTOR(base_uri); }
/** * Gets external uri where app is executed * * @return string */ PHP_METHOD(Phalcon_Controller_Front, getBaseUri){ zval *uri = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; zval *g0 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_baseUri", sizeof("_baseUri")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { phalcon_get_global(&g0, "_SERVER", sizeof("_SERVER") TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, "PHP_SELF", strlen("PHP_SELF")+1); if (eval_int) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "/", 1); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, g0, "PHP_SELF", strlen("PHP_SELF"), PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_1(r1, "dirname", r2, 0x049); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_explode(r3, c1, r1 TSRMLS_CC); PHALCON_INIT_VAR(c2); ZVAL_LONG(c2, 1); PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 1); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, -1); PHALCON_ALLOC_ZVAL_MM(r4); mul_function(r4, t1, t2 TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_3(r0, "array_slice", r3, c2, r4, 0x01F); PHALCON_ALLOC_ZVAL_MM(r5); phalcon_fast_join(r5, c0, r0 TSRMLS_CC); PHALCON_CPY_WRT(uri, r5); } else { PHALCON_INIT_VAR(uri); ZVAL_STRING(uri, "", 1); } if (!zend_is_true(uri)) { phalcon_update_property_string(this_ptr, "_baseUri", strlen("_baseUri"), "/" TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CONCAT_SVS(r6, "/", uri, "/"); phalcon_update_property_zval(this_ptr, "_baseUri", strlen("_baseUri"), r6 TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_baseUri", sizeof("_baseUri")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t3); }
/** * Gets external uri where app is executed * * @return string */ PHP_METHOD(Phalcon_Controller_Front, getBaseUri){ zval *base_uri = NULL, *slash = NULL, *uri = NULL; zval *g0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(base_uri); phalcon_read_property(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY_CC); if (!zend_is_true(base_uri)) { PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, SL("PHP_SELF")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, g0, SL("PHP_SELF"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "dirname", r0); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_fast_explode(r2, slash, r1 TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, 1); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 1); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, -1); PHALCON_ALLOC_ZVAL_MM(r3); mul_function(r3, t0, t1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_FUNC_PARAMS_3(r4, "array_slice", r2, c0, r3); PHALCON_INIT_VAR(uri); phalcon_fast_join(uri, slash, r4 TSRMLS_CC); } else { PHALCON_INIT_VAR(uri); ZVAL_STRING(uri, "", 1); } if (!zend_is_true(uri)) { PHALCON_CPY_WRT(base_uri, slash); } else { PHALCON_INIT_VAR(base_uri); PHALCON_CONCAT_VVV(base_uri, slash, uri, slash); } phalcon_update_property_zval(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC); } RETURN_CCTOR(base_uri); }
/** * Choose a view different to render than last-controller/last-action * * * * @param string $renderView */ PHP_METHOD(Phalcon_View, pick){ zval *render_view = NULL, *separator = NULL, *pick_view = NULL, *layout = NULL; zval *parts = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; zval *a0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &render_view) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "/", 1); if (Z_TYPE_P(render_view) == IS_ARRAY) { PHALCON_CPY_WRT(pick_view, render_view); } else { PHALCON_INIT_VAR(layout); ZVAL_NULL(layout); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_strpos(r0, render_view, separator TSRMLS_CC); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_explode(r1, separator, render_view TSRMLS_CC); PHALCON_CPY_WRT(parts, r1); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(layout, r2); } PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_append(&a0, render_view, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CPY_WRT(pick_view, a0); if (Z_TYPE_P(layout) != IS_NULL) { phalcon_array_append(&pick_view, layout, PHALCON_SEPARATE_PLZ TSRMLS_CC); } } phalcon_update_property_zval(this_ptr, "_pickView", strlen("_pickView"), pick_view TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Choose a view different to render than last-controller/last-action * * <code> * class ProductsController extends Phalcon\Mvc\Controller * { * * public function saveAction() * { * * //Do some save stuff... * * //Then show the list view * $this->view->pick("products/list"); * } * } * </code> * * @param string $renderView */ PHP_METHOD(Phalcon_Mvc_View, pick){ zval *render_view = NULL, *separator = NULL, *pick_view = NULL, *layout = NULL; zval *have_separator = NULL, *parts = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &render_view) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "/", 1); if (Z_TYPE_P(render_view) == IS_ARRAY) { PHALCON_CPY_WRT(pick_view, render_view); } else { PHALCON_INIT_VAR(layout); ZVAL_NULL(layout); PHALCON_INIT_VAR(have_separator); phalcon_fast_strpos(have_separator, render_view, separator TSRMLS_CC); if (Z_TYPE_P(have_separator) != IS_BOOL || (Z_TYPE_P(have_separator) == IS_BOOL && Z_BVAL_P(have_separator))) { PHALCON_INIT_VAR(parts); phalcon_fast_explode(parts, separator, render_view TSRMLS_CC); PHALCON_INIT_VAR(layout); phalcon_array_fetch_long(&layout, parts, 0, PH_NOISY_CC); } PHALCON_INIT_VAR(pick_view); array_init(pick_view); phalcon_array_append(&pick_view, render_view, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(layout) != IS_NULL) { phalcon_array_append(&pick_view, layout, PH_SEPARATE TSRMLS_CC); } } phalcon_update_property_zval(this_ptr, SL("_pickView"), pick_view TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Adds a number to a string or increment that number if it already is defined * *<code> * echo Phalcon\Text::increment("a"); // "a_1" * echo Phalcon\Text::increment("a_1"); // "a_2" *</code> * * @param string $str * @param string $separator * @return string */ PHP_METHOD(Phalcon_Text, increment) { zval *str, *separator = NULL, *parts, *number = NULL, *first_part; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &str, &separator); if (!separator) { PHALCON_INIT_VAR(separator); } else { PHALCON_SEPARATE_PARAM(separator); } if (Z_TYPE_P(separator) == IS_NULL) { PHALCON_INIT_NVAR(separator); ZVAL_STRING(separator, "_", 1); } PHALCON_INIT_VAR(parts); phalcon_fast_explode(parts, separator, str); if (phalcon_array_isset_long(parts, 1)) { PHALCON_OBS_VAR(number); phalcon_array_fetch_long(&number, parts, 1, PH_NOISY); SEPARATE_ZVAL(&number); phalcon_increment(number); } else { PHALCON_INIT_VAR(number); ZVAL_LONG(number, 1); } PHALCON_OBS_VAR(first_part); phalcon_array_fetch_long(&first_part, parts, 0, PH_NOISY); PHALCON_CONCAT_VVV(return_value, first_part, separator, number); RETURN_MM(); }
/** * Fires a event in the events manager causing that the acive listeners will be notified about it * * @param string $eventType * @param object $source * @param mixed $data * @return mixed */ PHP_METHOD(Phalcon_Events_Manager, fire){ zval *event_type, *source, *data = NULL, *events, *exception_message; zval *colon, *event_parts, *type, *event_name, *status = NULL; zval *fire_events = NULL, *handler = NULL, *event = NULL, *arguments = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &event_type, &source, &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!data) { PHALCON_INIT_NVAR(data); } if (Z_TYPE_P(event_type) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string"); return; } PHALCON_INIT_VAR(events); phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC); if (Z_TYPE_P(events) != IS_ARRAY) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!phalcon_memnstr_str(event_type, SL(":") TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message); return; } PHALCON_INIT_VAR(colon); ZVAL_STRING(colon, ":", 1); PHALCON_INIT_VAR(event_parts); phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC); PHALCON_INIT_VAR(type); phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(event_name); phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(status); eval_int = phalcon_array_isset(events, type); if (eval_int) { PHALCON_INIT_VAR(fire_events); phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC); if (Z_TYPE_P(fire_events) == IS_ARRAY) { if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0){} } } eval_int = phalcon_array_isset(events, event_type); if (eval_int) { PHALCON_INIT_NVAR(fire_events); phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY_CC); if (Z_TYPE_P(fire_events) == IS_ARRAY) { if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: if(0){} } } RETURN_CCTOR(status); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router, handle){ zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL; zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL; zval *route = NULL, *methods = NULL, *dependency_injector = NULL; zval *match_method = NULL, *pattern = NULL, *paths = NULL, *position = NULL; zval *part = NULL, *match_position = NULL, *module = NULL, *default_module = NULL; zval *controller = NULL, *default_controller = NULL, *action = NULL; zval *default_action = NULL, *params_str = NULL, *str_params = NULL; zval *params_merge = NULL, *default_params = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_ALLOC_ZVAL_MM(uri); ZVAL_NULL(uri); } if (!zend_is_true(uri)) { PHALCON_INIT_VAR(real_uri); PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_INIT_VAR(request); ZVAL_NULL(request); PHALCON_INIT_VAR(route_found); ZVAL_BOOL(route_found, 0); PHALCON_INIT_VAR(parts); array_init(parts); PHALCON_INIT_VAR(params); array_init(params); PHALCON_INIT_VAR(matches); array_init(matches); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); PHALCON_INIT_VAR(routes); phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC); PHALCON_INIT_VAR(reversed_routes); PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes); if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(reversed_routes); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_c9ff_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_c9ff_0; } PHALCON_INIT_VAR(route); ZVAL_ZVAL(route, *hd, 1, 0); PHALCON_INIT_VAR(methods); PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK); if (Z_TYPE_P(methods) != IS_NULL) { if (Z_TYPE_P(request) == IS_NULL) { PHALCON_INIT_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service"); return; } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "request", 1); PHALCON_INIT_VAR(request); PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", c0, PH_NO_CHECK); } PHALCON_INIT_VAR(match_method); PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK); if (!zend_is_true(match_method)) { zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_0; } } PHALCON_INIT_VAR(pattern); PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK); Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(route_found); PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(route_found)) { PHALCON_INIT_VAR(paths); PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK); PHALCON_CPY_WRT(parts, paths); if (!phalcon_valid_foreach(paths TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(paths); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_c9ff_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_c9ff_1; } PHALCON_INIT_VAR(part); PHALCON_GET_FOREACH_KEY(part, ah1, hp1); PHALCON_INIT_VAR(position); ZVAL_ZVAL(position, *hd, 1, 0); eval_int = phalcon_array_isset(matches, position); if (eval_int) { PHALCON_INIT_VAR(match_position); phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC); phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_c9ff_1; fee_c9ff_1: phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); goto fee_c9ff_0; } zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_0; fee_c9ff_0: if (zend_is_true(route_found)) { eval_int = phalcon_array_isset_string(parts, SL("module")+1); if (eval_int) { PHALCON_INIT_VAR(module); phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("module")+1); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_INIT_VAR(controller); phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("controller")+1); } else { PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_INIT_VAR(action); phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("action")+1); } else { PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("params")+1); if (eval_int) { PHALCON_INIT_VAR(params_str); phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC); PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 1); PHALCON_INIT_VAR(str_params); PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, c1); if (zend_is_true(str_params)) { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "/", 1); PHALCON_INIT_VAR(params); phalcon_fast_explode(params, c2, str_params TSRMLS_CC); } PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("params")+1); } PHALCON_INIT_VAR(params_merge); PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts); phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); PHALCON_INIT_VAR(default_params); phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Process a request header and return an array of values with their qualities * * @param string $serverIndex * @param string $name * @return array */ PHP_METHOD(Phalcon_Http_Request, _getQualityHeader){ zval *server_index = NULL, *name = NULL, *quality_one = NULL, *returned_parts = NULL; zval *http_server = NULL, *pattern = NULL, *parts = NULL, *part = NULL, *header_parts = NULL; zval *quality_part = NULL, *quality = NULL, *header_name = NULL; zval *c0 = NULL, *c1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &server_index, &name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(quality_one); ZVAL_DOUBLE(quality_one, 1); PHALCON_INIT_VAR(returned_parts); array_init(returned_parts); PHALCON_INIT_VAR(http_server); PHALCON_CALL_METHOD_PARAMS_1(http_server, this_ptr, "getserver", server_index, PH_NO_CHECK); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/,\\s*/", 1); PHALCON_INIT_VAR(parts); PHALCON_CALL_FUNC_PARAMS_2(parts, "preg_split", pattern, http_server); if (!phalcon_valid_foreach(parts TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ac06_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ac06_2; } PHALCON_INIT_VAR(part); ZVAL_ZVAL(part, *hd, 1, 0); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ";", 1); PHALCON_INIT_VAR(header_parts); phalcon_fast_explode(header_parts, c0, part TSRMLS_CC); eval_int = phalcon_array_isset_long(header_parts, 1); if (eval_int) { PHALCON_INIT_VAR(quality_part); phalcon_array_fetch_long(&quality_part, header_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 2); PHALCON_INIT_VAR(quality); PHALCON_CALL_FUNC_PARAMS_2(quality, "substr", quality_part, c1); } else { PHALCON_CPY_WRT(quality, quality_one); } PHALCON_INIT_VAR(header_name); phalcon_array_fetch_long(&header_name, header_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(quality_part); array_init(quality_part); phalcon_array_update_zval(&quality_part, name, &header_name, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&quality_part, SL("quality"), &quality, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_append(&returned_parts, quality_part, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ac06_2; fee_ac06_2: RETURN_CTOR(returned_parts); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router, handle){ zval *uri = NULL, *real_uri = NULL, *route_found = NULL, *parts = NULL, *params = NULL; zval *matches = NULL, *route = NULL, *position = NULL, *part = NULL, *str_params = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL; zval *c0 = NULL, *c1 = NULL; zval *a0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_ALLOC_ZVAL_MM(uri); ZVAL_NULL(uri); } if (!zend_is_true(uri)) { PHALCON_INIT_VAR(real_uri); PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_INIT_VAR(route_found); ZVAL_BOOL(route_found, 0); PHALCON_INIT_VAR(parts); array_init(parts); PHALCON_INIT_VAR(params); array_init(params); PHALCON_INIT_VAR(matches); array_init(matches); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_routes"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "array_reverse", t0); if (!phalcon_valid_foreach(r0 TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(r0); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_c9ff_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_c9ff_1; } PHALCON_INIT_VAR(route); ZVAL_ZVAL(route, *hd, 1, 0); PHALCON_INIT_VAR(parts); phalcon_array_fetch_string(&parts, route, SL("paths"), PH_NOISY_CC); PHALCON_INIT_VAR(r1); phalcon_array_fetch_string(&r1, route, SL("pattern"), PH_NOISY_CC); Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(r2); PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", r1, real_uri, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(r2)) { PHALCON_INIT_VAR(r3); phalcon_array_fetch_string(&r3, route, SL("paths"), PH_NOISY_CC); if (!phalcon_valid_foreach(r3 TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(r3); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_c9ff_2: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_c9ff_2; } PHALCON_INIT_VAR(part); PHALCON_GET_FOREACH_KEY(part, ah1, hp1); PHALCON_INIT_VAR(position); ZVAL_ZVAL(position, *hd, 1, 0); eval_int = phalcon_array_isset(matches, position); if (eval_int) { PHALCON_INIT_VAR(r4); phalcon_array_fetch(&r4, matches, position, PH_NOISY_CC); phalcon_array_update_zval(&parts, part, &r4, PH_COPY | PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_c9ff_2; fee_c9ff_2: if(0){} phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_currentRoute"), route TSRMLS_CC); PHALCON_INIT_VAR(route_found); ZVAL_BOOL(route_found, 1); goto fee_c9ff_1; } zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_1; fee_c9ff_1: if(0){} if (zend_is_true(route_found)) { eval_int = phalcon_array_isset_string(parts, SL("module")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r5); phalcon_array_fetch_string(&r5, parts, SL("module"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), r5 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("module")+1); } else { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), t1 TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_string(&r6, parts, SL("controller"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), r6 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("controller")+1); } else { phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r7); phalcon_array_fetch_string(&r7, parts, SL("action"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), r7 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("action")+1); } else { phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("params")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_string(&r8, parts, SL("params"), PH_NOISY_CC); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, 1); PHALCON_INIT_VAR(str_params); PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", r8, c0); if (zend_is_true(str_params)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "/", 1); PHALCON_INIT_VAR(params); phalcon_fast_explode(params, c1, str_params TSRMLS_CC); } PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("params")+1); } PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CALL_FUNC_PARAMS_2(r9, "array_merge", params, parts); phalcon_update_property_zval(this_ptr, SL("_params"), r9 TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), t2 TSRMLS_CC); phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC); phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); phalcon_update_property_zval(this_ptr, SL("_params"), a0 TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Add a route to the router * * @param string $pattern * @param string/array $paths */ PHP_METHOD(Phalcon_Mvc_Router, add){ zval *pattern = NULL, *paths = NULL, *parts = NULL, *route_paths = NULL, *pcre_pattern = NULL; zval *matches = NULL, *match = NULL, *n = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL; zval *a0 = NULL; zval *p0[] = { NULL, NULL, NULL, NULL }; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &pattern, &paths) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(paths) == IS_STRING) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "::", 1); PHALCON_INIT_VAR(parts); phalcon_fast_explode(parts, c0, paths TSRMLS_CC); PHALCON_INIT_VAR(route_paths); array_init(route_paths); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_long(&r0, parts, 0, PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "strtolower", r0); phalcon_array_update_string(&route_paths, SL("controller"), &r1, PH_COPY | PH_SEPARATE TSRMLS_CC); eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_long(&r2, parts, 1, PH_NOISY_CC); phalcon_array_update_string(&route_paths, SL("action"), &r2, PH_COPY | PH_SEPARATE TSRMLS_CC); } } else { PHALCON_CPY_WRT(route_paths, paths); } PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "#", 1); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "\\#", 1); PHALCON_INIT_VAR(pcre_pattern); phalcon_fast_str_replace(pcre_pattern, c1, c2, pattern TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_strpos_str(r3, pcre_pattern, SL("{") TSRMLS_CC); if (zend_is_true(r3)) { PHALCON_INIT_VAR(matches); array_init(matches); PHALCON_INIT_VAR(p0[0]); ZVAL_STRING(p0[0], "#{([a-zA-Z0-9\\_\\-]+):([^}]+)}#", 1); p0[1] = pcre_pattern; Z_SET_ISREF_P(matches); p0[2] = matches; PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 2); p0[3] = t0; PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_FUNC_PARAMS(r4, "preg_match_all", 4, p0); Z_UNSET_ISREF_P(p0[2]); if (zend_is_true(r4)) { if (!phalcon_valid_foreach(matches TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(matches); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_c9ff_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_c9ff_0; } PHALCON_INIT_VAR(n); PHALCON_GET_FOREACH_KEY(n, ah0, hp0); PHALCON_INIT_VAR(match); ZVAL_ZVAL(match, *hd, 1, 0); PHALCON_INIT_VAR(r5); phalcon_array_fetch_long(&r5, match, 0, PH_NOISY_CC); PHALCON_INIT_VAR(r6); phalcon_array_fetch_long(&r6, match, 2, PH_NOISY_CC); PHALCON_INIT_VAR(r7); PHALCON_CONCAT_SVS(r7, "(", r6, ")"); PHALCON_INIT_VAR(r8); phalcon_fast_str_replace(r8, r5, r7, pcre_pattern TSRMLS_CC); PHALCON_CPY_WRT(pcre_pattern, r8); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 1); PHALCON_INIT_VAR(r9); phalcon_add_function(r9, n, t1 TSRMLS_CC); PHALCON_INIT_VAR(r10); phalcon_array_fetch_long(&r10, match, 1, PH_NOISY_CC); phalcon_array_update_zval(&route_paths, r10, &r9, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_0; fee_c9ff_0: if(0){} } } PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "compilepattern", pcre_pattern, PH_NO_CHECK); phalcon_array_update_string(&a0, SL("pattern"), &r11, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&a0, SL("paths"), &route_paths, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, SL("_routes"), PH_NOISY_CC); phalcon_array_append(&t2, a0, 0 TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_routes"), t2 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Handles routing information received from command-line arguments * * @param array $arguments */ PHP_METHOD(Phalcon_CLI_Router, handle){ int i; zval *arguments = NULL, *arguments_count, *params, *arg = NULL; zval *module_name, *default_module; zval *task_name, *default_task, *task_name_tmp, *task_name_parts; zval *delimiter, *status; zval *action_name, *default_action; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arguments) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!arguments) { PHALCON_INIT_VAR(arguments); array_init(arguments); } if (Z_TYPE_P(arguments) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_cli_router_exception_ce, "Arguments must be an Array"); return; } /* * process arguments */ // initial and set default to null PHALCON_INIT_VAR(module_name); PHALCON_INIT_VAR(task_name); PHALCON_INIT_VAR(task_name_tmp); PHALCON_INIT_VAR(action_name); PHALCON_INIT_VAR(params); PHALCON_INIT_VAR(delimiter); array_init(params); phalcon_update_property_zval(this_ptr, SL("_module"), module_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_task"), task_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_action"), action_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); ZVAL_STRING(delimiter, ":", 1); PHALCON_INIT_VAR(arguments_count); phalcon_fast_count(arguments_count, arguments TSRMLS_CC); if (Z_LVAL_P(arguments_count) > 3) { // script, task, action, params..... phalcon_array_fetch_long(&task_name_tmp, arguments, 1, PH_NOISY_CC); phalcon_array_fetch_long(&action_name, arguments, 2, PH_NOISY_CC); // process params for (i = 3; i < Z_LVAL_P(arguments_count); i++) { PHALCON_INIT_NVAR(arg); phalcon_array_fetch_long(&arg, arguments, i, PH_NOISY_CC); phalcon_array_append(¶ms, arg, PH_SEPARATE TSRMLS_CC); } } else { if (Z_LVAL_P(arguments_count) > 2) { // script, task, action phalcon_array_fetch_long(&task_name_tmp, arguments, 1, PH_NOISY_CC); phalcon_array_fetch_long(&action_name, arguments, 2, PH_NOISY_CC); } else { if (Z_LVAL_P(arguments_count) > 1) { // script, task phalcon_array_fetch_long(&task_name_tmp, arguments, 1, PH_NOISY_CC); } } } // if task_name settings, parse task_name for module_name if (Z_TYPE_P(task_name_tmp) != IS_NULL) { PHALCON_INIT_VAR(task_name_parts); phalcon_fast_explode(task_name_parts, delimiter, task_name_tmp TSRMLS_CC); PHALCON_INIT_VAR(status); phalcon_fast_count(status, task_name_parts TSRMLS_CC); if (Z_LVAL_P(status) == 2) { PHALCON_INIT_NVAR(module_name); PHALCON_INIT_NVAR(task_name); phalcon_array_fetch_long(&module_name, task_name_parts, 0, PH_NOISY_CC); phalcon_array_fetch_long(&task_name, task_name_parts, 1, PH_NOISY_CC); }else { PHALCON_INIT_NVAR(task_name); phalcon_array_fetch_long(&task_name, task_name_parts, 0, PH_NOISY_CC); } } // update properties if (Z_TYPE_P(module_name) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_module"), module_name TSRMLS_CC); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); if (Z_TYPE_P(default_module) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); } } PHALCON_INIT_NVAR(module_name); phalcon_read_property(&module_name, this_ptr, SL("_module"), PH_NOISY_CC); if (Z_TYPE_P(task_name) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_task"), task_name TSRMLS_CC); } else { PHALCON_INIT_VAR(default_task); phalcon_read_property(&default_task, this_ptr, SL("_defaultTask"), PH_NOISY_CC); if (Z_TYPE_P(default_task) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_task"), default_task TSRMLS_CC); } } PHALCON_INIT_NVAR(task_name); phalcon_read_property(&task_name, this_ptr, SL("_task"), PH_NOISY_CC); if (Z_TYPE_P(action_name) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_action"), action_name TSRMLS_CC); } else { PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); if (Z_TYPE_P(default_action) != IS_NULL) { phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); } } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Fires a event in the events manager causing that the acive listeners will be notified about it * * @param string $eventType * @param object $source * @return mixed */ PHP_METHOD(Phalcon_Events_Manager, fire){ zval *event_type = NULL, *source = NULL, *colon = NULL, *event_parts = NULL; zval *exception_message = NULL, *exception = NULL, *type = NULL, *event_name = NULL; zval *status = NULL, *events = NULL, *fire_events = NULL, *handler = NULL, *event = NULL; zval *class_name = NULL, *arguments = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_type, &source) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(colon); ZVAL_STRING(colon, ":", 1); PHALCON_INIT_VAR(event_parts); phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC); eval_int = phalcon_array_isset_long(event_parts, 1); if (!eval_int) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_events_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(type); phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(event_name); phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(status); ZVAL_NULL(status); PHALCON_INIT_VAR(events); phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC); eval_int = phalcon_array_isset(events, type); if (eval_int) { PHALCON_INIT_VAR(fire_events); phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC); if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { PHALCON_INIT_VAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(event, "__construct", event_name, source, PH_CHECK); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, handler TSRMLS_CC); if (PHALCON_COMPARE_STRING(class_name, "Closure")) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(status); PHALCON_CALL_FUNC_PARAMS_2(status, "call_user_func_array", handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, handler, Z_STRVAL_P(event_name), event, source, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0){} } RETURN_CCTOR(status); }
PHP_METHOD(Phalcon_Request, _getQualityHeader){ zval *server_index = NULL, *name = NULL, *http_server = NULL, *parts = NULL; zval *returned_parts = NULL, *part = NULL, *header_parts = NULL, *quality = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *a0 = NULL, *a1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &server_index, &name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "getserver", server_index, PHALCON_NO_CHECK); PHALCON_CPY_WRT(http_server, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/,\\s*/", 1); PHALCON_CALL_FUNC_PARAMS_2(r1, "preg_split", c0, http_server, 0x048); PHALCON_CPY_WRT(parts, r1); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(returned_parts, a0); if (phalcon_valid_foreach(parts TSRMLS_CC)) { ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_9aea_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_9aea_1; } PHALCON_INIT_VAR(part); ZVAL_ZVAL(part, *hd, 1, 0); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, ";", 1); PHALCON_INIT_VAR(r2); phalcon_fast_explode(r2, c1, part TSRMLS_CC); PHALCON_CPY_WRT(header_parts, r2); eval_int = phalcon_array_isset_long(header_parts, 1); if (eval_int) { PHALCON_INIT_VAR(r3); PHALCON_INIT_VAR(r4); phalcon_array_fetch_long(&r4, header_parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_INIT_VAR(c2); ZVAL_LONG(c2, 2); PHALCON_CALL_FUNC_PARAMS_2(r3, "substr", r4, c2, 0x002); PHALCON_CPY_WRT(quality, r3); } else { PHALCON_INIT_VAR(quality); ZVAL_DOUBLE(quality, 1); } PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_INIT_VAR(r5); phalcon_array_fetch_long(&r5, header_parts, 0, PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&a1, name, &r5, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_string(&a1, "quality", strlen("quality"), &quality, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_append(&returned_parts, a1, PHALCON_SEPARATE_PLZ TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_9aea_1; fee_9aea_1: if(0){} } else { return; } PHALCON_RETURN_CTOR(returned_parts); }
/** * Generates SQL to add the table creation options * * @param array $definition * @return array */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){ zval *definition = NULL, *table_options = NULL, *engine = NULL, *sql_engine = NULL; zval *auto_increment = NULL, *sql_autoincrement = NULL; zval *table_collation = NULL, *collation_parts = NULL, *sql_charset = NULL; zval *sql_collate = NULL, *number_options = NULL, *sql_table_options = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL; zval *c0 = NULL, *c1 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(table_options); array_init(table_options); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("ENGINE")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(engine); phalcon_array_fetch_string(&engine, r1, SL("ENGINE"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, r2, SL("ENGINE"), PH_NOISY_CC); if (zend_is_true(r3)) { PHALCON_INIT_VAR(sql_engine); PHALCON_CONCAT_SV(sql_engine, "ENGINE=", engine); phalcon_array_append(&table_options, sql_engine, PH_SEPARATE TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r4, SL("AUTO_INCREMENT")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r5); phalcon_array_fetch_string(&r5, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(auto_increment); phalcon_array_fetch_string(&auto_increment, r5, SL("AUTO_INCREMENT"), PH_NOISY_CC); if (zend_is_true(auto_increment)) { PHALCON_INIT_VAR(sql_autoincrement); PHALCON_CONCAT_SV(sql_autoincrement, "AUTO_INCREMENT=", auto_increment); phalcon_array_append(&table_options, sql_autoincrement, PH_SEPARATE TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_string(&r6, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r6, SL("TABLE_COLLATION")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r7); phalcon_array_fetch_string(&r7, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(table_collation); phalcon_array_fetch_string(&table_collation, r7, SL("TABLE_COLLATION"), PH_NOISY_CC); if (zend_is_true(table_collation)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "_", 1); PHALCON_INIT_VAR(collation_parts); phalcon_fast_explode(collation_parts, c0, table_collation TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, collation_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(sql_charset); PHALCON_CONCAT_SV(sql_charset, "DEFAULT CHARSET=", r8); phalcon_array_append(&table_options, sql_charset, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(sql_collate); PHALCON_CONCAT_SV(sql_collate, "COLLATE=", table_collation); phalcon_array_append(&table_options, sql_collate, PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_VAR(number_options); phalcon_fast_count(number_options, table_options TSRMLS_CC); if (!phalcon_compare_strict_long(number_options, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, " ", 1); PHALCON_INIT_VAR(sql_table_options); phalcon_fast_join(sql_table_options, c1, table_options TSRMLS_CC); RETURN_CTOR(sql_table_options); } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Gets most possibly client IPv4 Address. This methods search in $_SERVER['REMOTE_ADDR'] and optionally in $_SERVER['HTTP_X_FORWARDED_FOR'] * * @param boolean $trustForwardedHeader * @return string */ PHP_METHOD(Phalcon_Http_Request, getClientAddress) { zval *trust_forwarded_header = NULL, *server = NULL, *address = NULL; zval *comma, *addresses, *first; zval *g0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &trust_forwarded_header) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!trust_forwarded_header) { PHALCON_INIT_NVAR(trust_forwarded_header); ZVAL_BOOL(trust_forwarded_header, 0); } phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); PHALCON_CPY_WRT(server, g0); /** * Proxies uses this IP */ if (PHALCON_IS_TRUE(trust_forwarded_header)) { eval_int = phalcon_array_isset_string(server, SS("HTTP_X_FORWARDED_FOR")); if (eval_int) { PHALCON_INIT_VAR(address); phalcon_array_fetch_string(&address, server, SL("HTTP_X_FORWARDED_FOR"), PH_NOISY_CC); RETURN_CCTOR(address); } } eval_int = phalcon_array_isset_string(server, SS("REMOTE_ADDR")); if (eval_int) { PHALCON_INIT_NVAR(address); phalcon_array_fetch_string(&address, server, SL("REMOTE_ADDR"), PH_NOISY_CC); if (phalcon_memnstr_str(address, SL(",") TSRMLS_CC)) { /** * The client address has multiples parts, only return the first part */ PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ",", 1); PHALCON_INIT_VAR(addresses); phalcon_fast_explode(addresses, comma, address TSRMLS_CC); PHALCON_INIT_VAR(first); phalcon_array_fetch_long(&first, addresses, 0, PH_NOISY_CC); RETURN_CCTOR(first); } RETURN_CCTOR(address); } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Router_Rewrite, handle) { zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_INIT_VAR(uri); ZVAL_NULL(uri); } else { PHALCON_SEPARATE_PARAM(uri); } if (!zend_is_true(uri)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK); PHALCON_CPY_WRT(uri, r0); } if (zend_is_true(uri)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_explode(r1, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r1); eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_filter_alphanum(r3, r2); phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r5); phalcon_filter_alphanum(r5, r4); phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t1)) { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); PHALCON_ALLOC_ZVAL_MM(r6); phalcon_fast_count(r6, parts TSRMLS_CC); PHALCON_CPY_WRT(number_parts, r6); PHALCON_INIT_VAR(i); ZVAL_LONG(i, 2); fs_ef57_0: PHALCON_INIT_VAR(r7); is_smaller_function(r7, i, number_parts TSRMLS_CC); if (!zend_is_true(r7)) { goto fe_ef57_0; } PHALCON_INIT_VAR(r8); phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); goto fs_ef57_0; fe_ef57_0: phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC); } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Generates SQL to add the table creation options * * @param array $definition * @return array */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){ zval *definition = NULL, *table_options = NULL, *engine = NULL, *auto_increment = NULL; zval *table_collation = NULL, *collation_parts = NULL; zval *a0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL; zval *c0 = NULL, *c1 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(table_options, a0); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); eval_int = phalcon_array_isset_string(r0, "ENGINE", strlen("ENGINE")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, r1, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(engine, r2); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, r3, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC); if (zend_is_true(r4)) { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CONCAT_SV(r5, "ENGINE=", engine); phalcon_array_append(&table_options, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_string(&r6, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); eval_int = phalcon_array_isset_string(r6, "AUTO_INCREMENT", strlen("AUTO_INCREMENT")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r7); phalcon_array_fetch_string(&r7, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_string(&r8, r7, "AUTO_INCREMENT", strlen("AUTO_INCREMENT"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(auto_increment, r8); if (zend_is_true(auto_increment)) { PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CONCAT_SV(r9, "AUTO_INCREMENT=", auto_increment); phalcon_array_append(&table_options, r9, PHALCON_SEPARATE_PLZ TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r10); phalcon_array_fetch_string(&r10, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); eval_int = phalcon_array_isset_string(r10, "TABLE_COLLATION", strlen("TABLE_COLLATION")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r11); phalcon_array_fetch_string(&r11, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r12); phalcon_array_fetch_string(&r12, r11, "TABLE_COLLATION", strlen("TABLE_COLLATION"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(table_collation, r12); if (zend_is_true(table_collation)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "_", 1); PHALCON_ALLOC_ZVAL_MM(r13); phalcon_fast_explode(r13, c0, table_collation TSRMLS_CC); PHALCON_CPY_WRT(collation_parts, r13); PHALCON_ALLOC_ZVAL_MM(r14); PHALCON_ALLOC_ZVAL_MM(r15); phalcon_array_fetch_long(&r15, collation_parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_CONCAT_SV(r14, "DEFAULT CHARSET=", r15); phalcon_array_append(&table_options, r14, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r16); PHALCON_CONCAT_SV(r16, "COLLATE=", table_collation); phalcon_array_append(&table_options, r16, PHALCON_SEPARATE_PLZ TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r17); phalcon_fast_count(r17, table_options TSRMLS_CC); if (zend_is_true(r17)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, " ", 1); PHALCON_ALLOC_ZVAL_MM(r18); phalcon_fast_join(r18, c1, table_options TSRMLS_CC); PHALCON_RETURN_DZVAL(r18); } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Phalcon\Config\Adapter\Ini constructor * * @param string $filePath */ PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) { zval *file_path, *config, *process_sections; zval *ini_config, *base_path, *exception_message; zval *dot, *directives = NULL, *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL; zval *left_part = NULL, *right_part = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &file_path); PHALCON_INIT_VAR(config); array_init(config); PHALCON_INIT_VAR(process_sections); ZVAL_BOOL(process_sections, 1); PHALCON_INIT_VAR(ini_config); PHALCON_CALL_FUNC_PARAMS_2(ini_config, "parse_ini_file", file_path, process_sections); if (PHALCON_IS_FALSE(ini_config)) { PHALCON_INIT_VAR(base_path); PHALCON_CALL_FUNC_PARAMS_1(base_path, "basename", file_path); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Configuration file ", base_path, " can't be loaded"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_config_exception_ce, exception_message); return; } PHALCON_INIT_VAR(dot); ZVAL_STRING(dot, ".", 1); if (!phalcon_is_iterable(ini_config, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(section, ah0, hp0); PHALCON_GET_FOREACH_VALUE(directives); if (!phalcon_is_iterable(directives, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(key, ah1, hp1); PHALCON_GET_FOREACH_VALUE(value); if (phalcon_memnstr_str(key, SL(".") TSRMLS_CC)) { PHALCON_INIT_NVAR(directive_parts); phalcon_fast_explode(directive_parts, dot, key TSRMLS_CC); PHALCON_OBS_NVAR(left_part); phalcon_array_fetch_long(&left_part, directive_parts, 0, PH_NOISY_CC); PHALCON_OBS_NVAR(right_part); phalcon_array_fetch_long(&right_part, directive_parts, 1, PH_NOISY_CC); phalcon_array_update_zval_zval_zval_multi_3(&config, section, left_part, right_part, &value, 0 TSRMLS_CC); } else { phalcon_array_update_multi_2(&config, section, key, &value, 0 TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Config\\Adapter\\Ini", "__construct", config); PHALCON_MM_RESTORE(); }
/** * Routes to a controller/action using a string or array uri * * @param string $uri */ PHP_METHOD(Phalcon_Dispatcher, forward){ zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL; zval *c0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL; zval *a0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(uri) == IS_ARRAY) { PHALCON_CPY_WRT(parts, uri); } else { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_explode(r0, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r0); } eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_filter_alphanum(r2, r1); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 0); } else { eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); phalcon_filter_alphanum(r4, r3); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC); } } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_filter_alphanum(r7, r6); phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 1); } else { eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r10); phalcon_filter_alphanum(r10, r9); phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC); } } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); if (phalcon_valid_foreach(parts TSRMLS_CC)) { ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e10f_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e10f_1; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(key) == IS_LONG) { PHALCON_INIT_VAR(r12); phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e10f_1; fee_e10f_1: if(0){} } else { return; } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Phalcon_Config_Adapter_Ini constructor * * @param string $filePath * @return Phalcon_Config_Adapter_Ini * */ PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct){ zval *file_path = NULL, *config = NULL, *ini_config = NULL, *directives = NULL; zval *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL; zval *a0 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *i0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; zval *t0 = NULL, *t1 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &file_path) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(config, a0); PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 1); PHALCON_INIT_VAR(ini_config); PHALCON_CALL_FUNC_PARAMS_2(ini_config, "parse_ini_file", file_path, c0); if (Z_TYPE_P(ini_config) == IS_BOOL && !Z_BVAL_P(ini_config)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_config_exception_ce); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "basename", file_path); PHALCON_CONCAT_SVS(r0, "Configuration file ", r1, " can't be loaded"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r0, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } if (phalcon_valid_foreach(ini_config TSRMLS_CC)) { ah0 = Z_ARRVAL_P(ini_config); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_b840_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_b840_0; } else { PHALCON_INIT_VAR(section); PHALCON_GET_FOREACH_KEY(section, ah0, hp0); } PHALCON_INIT_VAR(directives); ZVAL_ZVAL(directives, *hd, 1, 0); if (phalcon_valid_foreach(directives TSRMLS_CC)) { ah1 = Z_ARRVAL_P(directives); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_b840_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_b840_1; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah1, hp1); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, ".", 1); PHALCON_INIT_VAR(r2); phalcon_fast_strpos(r2, key, c1 TSRMLS_CC); if (Z_TYPE_P(r2) != IS_BOOL || (Z_TYPE_P(r2) == IS_BOOL && Z_BVAL_P(r2))) { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, ".", 1); PHALCON_INIT_VAR(r3); phalcon_fast_explode(r3, c2, key TSRMLS_CC); PHALCON_CPY_WRT(directive_parts, r3); if (Z_TYPE_P(config) == IS_ARRAY) { PHALCON_INIT_VAR(t0); phalcon_array_fetch(&t0, config, section, PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t0) > 1) { phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t0) != IS_ARRAY) { convert_to_array(t0); phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } PHALCON_INIT_VAR(r4); phalcon_array_fetch_long(&r4, directive_parts, 0, PHALCON_NOISY TSRMLS_CC); if (Z_TYPE_P(t0) == IS_ARRAY) { PHALCON_INIT_VAR(t1); phalcon_array_fetch(&t1, t0, r4, PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t1) > 1) { phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t1) != IS_ARRAY) { convert_to_array(t1); phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } PHALCON_INIT_VAR(r5); phalcon_array_fetch_long(&r5, directive_parts, 1, PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&t1, r5, &value, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } else { phalcon_array_update_multi_2(&config, section, key, &value, PHALCON_NO_SEPARATE_THX TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_b840_1; fee_b840_1: if(0){} } else { return; } zend_hash_move_forward_ex(ah0, &hp0); goto fes_b840_0; fee_b840_0: if(0){} } else { return; } PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon_Config_Adapter_Ini", "__construct", config); PHALCON_MM_RESTORE(); }