/** * Renders a view using the template engine * * @param string $path * @param array $params * @param boolean $mustClean */ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) { zval *path, *params, *must_clean = NULL, *value = NULL, *key = NULL, *contents; zval *view; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &path, ¶ms, &must_clean); if (!must_clean) { PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 0); } if (PHALCON_IS_TRUE(must_clean)) { phalcon_ob_clean(TSRMLS_C); } /** * Create the variables in local symbol table */ if (Z_TYPE_P(params) == IS_ARRAY) { phalcon_is_iterable(params, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(key, ah0, hp0); PHALCON_GET_HVALUE(value); if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE) { return; } zend_hash_move_forward_ex(ah0, &hp0); } } /** * Require the file */ if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_INIT_VAR(contents); phalcon_ob_get_contents(contents TSRMLS_CC); PHALCON_OBS_VAR(view); phalcon_read_property_this(&view, this_ptr, SL("_view"), PH_NOISY_CC); phalcon_call_method_p1_noret(view, "setcontent", contents); } PHALCON_MM_RESTORE(); }
/** * Renders a view using the template engine * * @param string $path * @param array $params * @param boolean $mustClean */ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render){ zval *path, *params, *must_clean = NULL, *value = NULL, *key = NULL, *contents; zval *view; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &path, ¶ms, &must_clean) == FAILURE) { RETURN_MM_NULL(); } if (!must_clean) { PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 0); } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_CALL_FUNC_NORETURN("ob_clean"); } if (Z_TYPE_P(params) == IS_ARRAY) { if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE){ return; } zend_hash_move_forward_ex(ah0, &hp0); } } if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); PHALCON_OBS_VAR(view); phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents); } PHALCON_MM_RESTORE(); }
/** * Executes the validation * * @param string $value * @param int $minimum * @param int $maximum * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_StringLength, valid){ zval *value, *minimum = NULL, *maximum = NULL; zval *length = NULL, *valid = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &value, &minimum, &maximum); if (!minimum) { minimum = &PHALCON_GLOBAL(z_null); } if (!maximum) { maximum = &PHALCON_GLOBAL(z_null); } /* At least one of 'min' or 'max' must be set */ if (Z_TYPE_P(minimum) == IS_NULL && Z_TYPE_P(maximum) == IS_NULL) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set"); return; } /* Check if mbstring is available to calculate the correct length */ if (phalcon_function_exists_ex(SL("mb_strlen")) == SUCCESS) { PHALCON_CALL_FUNCTION(&length, "mb_strlen", value); } else { convert_to_string(value); PHALCON_INIT_VAR(length); ZVAL_LONG(length, Z_STRLEN_P(value)); } /* Maximum length */ if (Z_TYPE_P(maximum) != IS_NULL) { PHALCON_INIT_NVAR(valid); is_smaller_function(valid, maximum, length); if (PHALCON_IS_TRUE(valid)) { phalcon_update_property_str(getThis(), SL("_type"), SL("TooLong")); RETURN_MM_FALSE; } } /* Minimum length */ if (Z_TYPE_P(minimum) != IS_NULL) { PHALCON_INIT_NVAR(valid); is_smaller_function(valid, length, minimum); if (PHALCON_IS_TRUE(valid)) { phalcon_update_property_str(getThis(), SL("_type"), SL("TooShort")); RETURN_MM_FALSE; } } RETURN_MM_TRUE; }
/** * Stores cached content into the backend and stops the frontend * * @param string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Memory, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *cached_content = NULL, *prepared_content = NULL, *is_buffering = NULL; zval *last_key, *frontend; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer); if (!key_name || Z_TYPE_P(key_name) == IS_NULL) { last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC); } else { zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, key_name); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC); if (!content || Z_TYPE_P(content) == IS_NULL) { PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent"); } else { cached_content = content; } if (phalcon_is_numeric(cached_content)) { phalcon_update_property_array(this_ptr, SL("_data"), last_key, cached_content TSRMLS_CC); } else { PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content); phalcon_update_property_array(this_ptr, SL("_data"), last_key, prepared_content TSRMLS_CC); } PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering"); if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD(NULL, frontend, "stop"); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns the messages stored in session * * @param boolean $remove * @return array */ PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages){ zval *remove, *dependency_injector, *service; zval *session, *index_name, *messages; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &remove); PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (unlikely(Z_TYPE_P(dependency_injector) != IS_OBJECT)) { PHALCON_THROW_EXCEPTION_STR(phalcon_flash_exception_ce, "A dependency injection container is required to access the 'session' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "session", 1); PHALCON_INIT_VAR(session); phalcon_call_method_p1(session, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_INIT_VAR(index_name); ZVAL_STRING(index_name, "_flashMessages", 1); PHALCON_INIT_VAR(messages); phalcon_call_method_p1(messages, session, "get", index_name); if (PHALCON_IS_TRUE(remove)) { phalcon_call_method_p1_noret(session, "remove", index_name); } RETURN_CCTOR(messages); }
/** * Gets the current document title * * <code> * echo Phalcon\Tag::getTitle(); * </code> * * <code> * {{ get_title() }} * </code> * * @return string */ PHP_METHOD(Phalcon_Tag, getTitle){ zval *tags = NULL, *document_title, *eol, *title_html; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &tags); if (!tags) { PHALCON_INIT_VAR(tags); ZVAL_BOOL(tags, 1); } PHALCON_OBS_VAR(document_title); phalcon_read_static_property(&document_title, SL("phalcon\\tag"), SL("_documentTitle") TSRMLS_CC); if (PHALCON_IS_TRUE(tags)) { PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); PHALCON_INIT_VAR(title_html); PHALCON_CONCAT_SVSV(title_html, "<title>", document_title, "</title>", eol); RETURN_CTOR(title_html); } RETURN_CCTOR(document_title); }
/** * Phalcon\Mvc\Router constructor * * @param boolean $defaultRoutes */ PHP_METHOD(Phalcon_Mvc_Router, __construct) { zval *default_routes = NULL, *routes = NULL, *paths = NULL, *route = NULL; zval *a0 = NULL, *a1 = NULL; zval *c0 = NULL, *c1 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); zend_update_property(phalcon_mvc_router_ce, this_ptr, SL("_params"), a0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(a1); array_init(a1); zend_update_property(phalcon_mvc_router_ce, this_ptr, SL("_defaultParams"), a1 TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &default_routes) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!default_routes) { PHALCON_ALLOC_ZVAL_MM(default_routes); ZVAL_BOOL(default_routes, 1); } PHALCON_INIT_VAR(routes); array_init(routes); if (PHALCON_IS_TRUE(default_routes)) { PHALCON_INIT_VAR(paths); array_init(paths); add_assoc_long_ex(paths, SL("controller")+1, 1); PHALCON_INIT_VAR(route); object_init_ex(route, phalcon_mvc_router_route_ce); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "#^/([a-zA-Z0-9\\_]+)[/]{0,1}$#", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(route, "__construct", c0, paths, PH_CHECK); phalcon_array_append(&routes, route, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(paths); array_init(paths); add_assoc_long_ex(paths, SL("controller")+1, 1); add_assoc_long_ex(paths, SL("action")+1, 2); add_assoc_long_ex(paths, SL("params")+1, 3); PHALCON_INIT_VAR(route); object_init_ex(route, phalcon_mvc_router_route_ce); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "#^/([a-zA-Z0-9\\_]+)/([a-zA-Z0-9\\_]+)(/.*)*$#", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(route, "__construct", c1, paths, PH_CHECK); phalcon_array_append(&routes, route, PH_SEPARATE TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_routes"), routes TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns the messages stored in session * * @param boolean $remove * @return array */ PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages){ zval *remove, *dependency_injector, *service; zval *session = NULL, *index_name; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &remove); dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (unlikely(Z_TYPE_P(dependency_injector) != IS_OBJECT)) { PHALCON_THROW_EXCEPTION_STR(phalcon_flash_exception_ce, "A dependency injection container is required to access the 'session' service"); return; } PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_session); PHALCON_CALL_METHOD(&session, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_INIT_VAR(index_name); ZVAL_STRING(index_name, "_flashMessages", 1); PHALCON_RETURN_CALL_METHOD(session, "get", index_name); if (PHALCON_IS_TRUE(remove)) { PHALCON_CALL_METHOD(NULL, session, "remove", index_name); } RETURN_MM(); }
/** * Returns the messages stored in session * * @param boolean $remove * @return array */ PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages){ zval *remove, *dependency_injector = NULL, *service; zval *session = NULL, *index_name; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &remove); PHALCON_CALL_METHOD(&dependency_injector, this_ptr, "getdi"); PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_session); PHALCON_CALL_METHOD(&session, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_INIT_VAR(index_name); ZVAL_STRING(index_name, "_flashMessages", 1); PHALCON_RETURN_CALL_METHOD(session, "get", index_name); if (PHALCON_IS_TRUE(remove)) { PHALCON_CALL_METHOD(NULL, session, "remove", index_name); } RETURN_MM(); }
/** * Check if HTTP method match any of the passed methods * * @param string|array $methods * @return boolean */ PHP_METHOD(Phalcon_Http_Request, isMethod) { zval *methods, *http_method, *is_equals = NULL, *method = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &methods) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(http_method); PHALCON_CALL_METHOD(http_method, this_ptr, "getmethod", PH_NO_CHECK); if (Z_TYPE_P(methods) == IS_STRING) { PHALCON_INIT_VAR(is_equals); is_equal_function(is_equals, methods, http_method TSRMLS_CC); RETURN_NCTOR(is_equals); } else { if (!phalcon_valid_foreach(methods TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(methods); 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(method); PHALCON_INIT_NVAR(is_equals); is_equal_function(is_equals, method, http_method TSRMLS_CC); if (PHALCON_IS_TRUE(is_equals)) { PHALCON_MM_RESTORE(); RETURN_TRUE; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0) {} } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Returns a route object by its name * * @return Phalcon\Mvc\Router\Route */ PHP_METHOD(Phalcon_Mvc_Router, getRouteByName) { zval *name = NULL, *routes = NULL, *route = NULL, *route_name = NULL, *is_equal = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(routes); phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC); if (!phalcon_valid_foreach(routes TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(routes); 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(route); PHALCON_INIT_VAR(route_name); PHALCON_CALL_METHOD(route_name, route, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(is_equal); is_equal_function(is_equal, route_name, name TSRMLS_CC); if (PHALCON_IS_TRUE(is_equal)) { RETURN_CCTOR(route); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Gets row in a specific position of the resultset * * @param int $index * @return Phalcon\Mvc\ModelInterface */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet){ zval *index, *count, *exists, *pointer, *current = NULL, *valid; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &index); PHALCON_INIT_VAR(count); phalcon_call_method(count, this_ptr, "count"); PHALCON_INIT_VAR(exists); is_smaller_function(exists, index, count TSRMLS_CC); if (PHALCON_IS_TRUE(exists)) { /** * Check if the last record returned is the current requested */ PHALCON_OBS_VAR(pointer); phalcon_read_property_this(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); if (PHALCON_IS_EQUAL(pointer, index)) { PHALCON_INIT_VAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } /** * Move the cursor to the specific position */ phalcon_call_method_p1_noret(this_ptr, "seek", index); /** * Check if the last record returned is the requested */ PHALCON_INIT_VAR(valid); phalcon_call_method(valid, this_ptr, "valid"); if (PHALCON_IS_NOT_FALSE(valid)) { PHALCON_INIT_NVAR(current); phalcon_call_method(current, this_ptr, "current"); RETURN_CCTOR(current); } RETURN_MM_FALSE; } PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor"); return; }
/** * Phalcon\Mvc\Model\Resultset\Simple constructor * * @param Phalcon\Mvc\Model $model * @param Phalcon\Db\Result\Pdo $result * @param Phalcon\Cache\Backend $cache */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct){ zval *model = NULL, *result = NULL, *cache = NULL, *fetch_assoc = NULL, *limit = NULL; zval *row_count = NULL, *big_resultset = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &model, &result, &cache) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!cache) { PHALCON_ALLOC_ZVAL_MM(cache); ZVAL_NULL(cache); } phalcon_update_property_zval(this_ptr, SL("_model"), model TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_result"), result TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(fetch_assoc); ZVAL_LONG(fetch_assoc, 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(limit); ZVAL_LONG(limit, 32); PHALCON_INIT_VAR(row_count); PHALCON_CALL_METHOD(row_count, result, "numrows", PH_NO_CHECK); PHALCON_INIT_VAR(big_resultset); is_smaller_function(big_resultset, limit, row_count TSRMLS_CC); if (PHALCON_IS_TRUE(big_resultset)) { phalcon_update_property_long(this_ptr, SL("_type"), 1 TSRMLS_CC); } else { phalcon_update_property_long(this_ptr, SL("_type"), 0 TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_count"), row_count TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Unregister the autoload method * * @return Phalcon\Loader */ PHP_METHOD(Phalcon_Loader, unregister){ zval *registered, *autoloader; PHALCON_MM_GROW(); PHALCON_OBS_VAR(registered); phalcon_read_property(®istered, this_ptr, SL("_registered"), PH_NOISY_CC); if (PHALCON_IS_TRUE(registered)) { PHALCON_INIT_VAR(autoloader); array_init_size(autoloader, 2); phalcon_array_append(&autoloader, this_ptr, PH_SEPARATE TSRMLS_CC); add_next_index_stringl(autoloader, SL("autoLoad"), 1); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("spl_autoload_unregister", autoloader); } RETURN_THIS(); }
/** * Stops the frontend without store any cached content * * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend, stop){ zval *stop_buffer = NULL, *frontend; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &stop_buffer); if (!stop_buffer) { PHALCON_INIT_VAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_OBS_VAR(frontend); phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_CALL_METHOD_NORETURN(frontend, "stop"); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns the messages stored in session * * @param boolean $remove * @return array */ PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages){ zval *remove, *dependency_injector, *service; zval *session, *index_name, *messages; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &remove) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_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_flash_exception_ce, "A dependency injection container is required to access the 'session' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "session", 1); PHALCON_INIT_VAR(session); PHALCON_CALL_METHOD_PARAMS_1(session, dependency_injector, "getshared", service, PH_NO_CHECK); PHALCON_INIT_VAR(index_name); ZVAL_STRING(index_name, "_flashMessages", 1); PHALCON_INIT_VAR(messages); PHALCON_CALL_METHOD_PARAMS_1(messages, session, "get", index_name, PH_NO_CHECK); if (PHALCON_IS_TRUE(remove)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(session, "remove", index_name, PH_NO_CHECK); } RETURN_CCTOR(messages); }
/** * Generates the SQL for LIMIT clause * *<code> * $sql = $dialect->limit('SELECT * FROM robots', 10); * echo $sql; // SELECT * FROM robots LIMIT 10 *</code> * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query, *number, *is_numeric, *limit, *sql_limit; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(is_numeric); PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", number); if (PHALCON_IS_TRUE(is_numeric)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_INIT_VAR(sql_limit); PHALCON_CONCAT_VSV(sql_limit, sql_query, " LIMIT ", limit); RETURN_CTOR(sql_limit); } RETURN_CCTOR(sql_query); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *filtered, *frontend, *options; zval *cache_dir, *cache_file, *cached_content = NULL; zval *prepared_content, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_NVAR(key_name); } if (!content) { PHALCON_INIT_NVAR(content); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_NVAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_INIT_VAR(last_key); phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, filtered); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!zend_is_true(content)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, frontend, "getcontent", PH_NO_CHECK); } else { PHALCON_CPY_WRT(cached_content, content); } /** * We use file_put_contents to repect open-base-dir directive */ PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content, PH_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering", PH_NO_CHECK); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(frontend, "stop", PH_NO_CHECK); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Changes internal pointer to a specific position in the resultset * * @param int $position */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){ long i; zval *type, *result, *rows, *position; zval *pointer, *is_different; HashTable *ah0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_OBS_VAR(pointer); phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); /** * We only seek the records if the current position is diferent than the passed one */ PHALCON_INIT_VAR(is_different); is_not_equal_function(is_different, pointer, position TSRMLS_CC); if (PHALCON_IS_TRUE(is_different)) { PHALCON_OBS_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset is fetched one by one because is large */ PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); phalcon_call_method_p1_noret(result, "dataseek", position); } else { /** * Here, the resultset is a small array */ PHALCON_OBS_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); /** * We need to fetch the records because rows is null */ if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } convert_to_long(position); if(Z_TYPE_P(rows) == IS_ARRAY){ ah0 = Z_ARRVAL_P(rows); zend_hash_internal_pointer_reset(ah0); i = 0; while (1) { if (i >= Z_LVAL_P(position)) { break; } zend_hash_move_forward(ah0); i++; } } phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC); } } PHALCON_MM_RESTORE();}
/** * Outputs a message formatting it with HTML * *<code> * $flash->outputMessage('error', $message); *</code> * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type, *message, *automatic_html, *classes; zval *type_classes, *joined_classes, *css_classes = NULL; zval *eol = NULL, *implicit_flush, *content, *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_OBS_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); if (phalcon_array_isset(classes, type)) { PHALCON_OBS_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(joined_classes); phalcon_fast_join_str(joined_classes, SL(" "), type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_NVAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_NVAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); PHALCON_INIT_NVAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); } PHALCON_OBS_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { /** * We create the message with implicit flush or other */ if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } /** * We create the message with implicit flush or other */ if (!phalcon_is_iterable(message, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(msg); /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * Outputs a message formatting it with HTML * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type = NULL, *message = NULL, *automatic_html = NULL, *classes = NULL; zval *type_classes = NULL, *space = NULL, *joined_classes = NULL; zval *css_classes = NULL, *eol = NULL, *implicit_flush = NULL, *content = NULL; zval *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); eval_int = phalcon_array_isset(classes, type); if (eval_int) { PHALCON_INIT_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(joined_classes); phalcon_fast_join(joined_classes, space, type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_VAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); } PHALCON_INIT_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } if (!phalcon_valid_foreach(message TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(message); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_3b3c_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_3b3c_0; } PHALCON_INIT_VAR(msg); ZVAL_ZVAL(msg, *hd, 1, 0); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_3b3c_0; fee_3b3c_0: if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * Setup a relation 1-n between two models * * @param Phalcon\Mvc\Model $model * @param mixed $fields * @param string $referenceModel * @param mixed $referencedFields * @param array $options */ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany){ zval *model, *fields, *reference_model, *referenced_fields; zval *options = NULL, *entity_name, *has_many, *number_fields; zval *number_referenced, *diferent_fields; zval *relation; zval *a0 = NULL; zval *r0 = NULL; zval *t0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &model, &fields, &reference_model, &referenced_fields, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_NVAR(options); array_init(options); } PHALCON_INIT_VAR(entity_name); phalcon_get_class(entity_name, model TSRMLS_CC); PHALCON_INIT_VAR(has_many); phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_many, entity_name); if (!eval_int) { PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_update_zval(&has_many, entity_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(r0); phalcon_array_fetch(&r0, has_many, entity_name, PH_NOISY_CC); eval_int = phalcon_array_isset(r0, reference_model); if (!eval_int) { if (Z_TYPE_P(referenced_fields) == IS_ARRAY) { PHALCON_INIT_VAR(number_fields); phalcon_fast_count(number_fields, fields TSRMLS_CC); PHALCON_INIT_VAR(number_referenced); phalcon_fast_count(number_referenced, referenced_fields TSRMLS_CC); PHALCON_INIT_VAR(diferent_fields); is_not_equal_function(diferent_fields, number_fields, number_referenced TSRMLS_CC); if (PHALCON_IS_TRUE(diferent_fields)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Number of referenced fields are not the same"); return; } } PHALCON_INIT_VAR(relation); array_init(relation); phalcon_array_update_string(&relation, SL("fi"), &fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rt"), &reference_model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rf"), &referenced_fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("op"), &options, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_hasMany"), PH_NOISY_CC); phalcon_array_update_multi_2(&t0, entity_name, reference_model, &relation, 0 TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_hasMany"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Stores cached content into the APC backend and stops the frontend * * @param string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Apc, save) { zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, prefix = {}, frontend = {}; zval last_key = {}, cached_content = {}, prepared_content = {}, last_lifetime = {}, ttl, is_buffering = {}; phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer); if (!key_name || Z_TYPE_P(key_name) == IS_NULL) { phalcon_return_property(&last_key, getThis(), SL("_lastKey")); } else { phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY); PHALCON_CONCAT_SVV(&last_key, "_PHCA", &prefix, key_name); } if (!zend_is_true(&last_key)) { PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first"); return; } phalcon_read_property(&frontend, getThis(), SL("_frontend"), PH_NOISY); if (!content || Z_TYPE_P(content) == IS_NULL) { PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent"); } else { PHALCON_CPY_WRT(&cached_content, content); } if (!phalcon_is_numeric(&cached_content)) { PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content); } else { PHALCON_CPY_WRT(&prepared_content, &cached_content); } /** * Take the lifetime from the frontend or read it from the set in start() */ if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) { phalcon_read_property(&last_lifetime, getThis(), SL("_lastLifetime"), PH_NOISY); if (Z_TYPE(last_lifetime) == IS_NULL) { PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime"); } else { PHALCON_CPY_WRT(&ttl, &last_lifetime); } } else { PHALCON_CPY_WRT(&ttl, lifetime); } /** * Call apc_store in the PHP userland since most of the time it isn't available at * compile time */ PHALCON_CALL_FUNCTIONW(NULL, "apc_store", &last_key, &prepared_content, &ttl); PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering"); if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHODW(NULL, &frontend, "stop"); } if (PHALCON_IS_TRUE(&is_buffering)) { zend_print_zval(&cached_content, 0); } phalcon_update_property_bool(getThis(), SL("_started"), 0); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *cache_file, *cached_content = NULL, *prepared_content = NULL, *status, *is_buffering = NULL; zval *last_key, *frontend, *options, *cache_dir; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer); if (!key_name || Z_TYPE_P(key_name) == IS_NULL) { last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC); } else { zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, key_name); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC); options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC); if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options"); return; } PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!content || !zend_is_true(content)) { PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent"); } else { cached_content = content; } PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content); /** * We use file_put_contents to respect open-base-dir directive */ PHALCON_INIT_VAR(status); if (!phalcon_is_numeric(cached_content)) { phalcon_file_put_contents(status, cache_file, prepared_content TSRMLS_CC); } else { phalcon_file_put_contents(status, cache_file, cached_content TSRMLS_CC); } if (PHALCON_IS_FALSE(status)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory is not writable"); return; } PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering"); if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD(NULL, frontend, "stop"); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Stores cached content into the XCache backend and stops the frontend * * @param string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Xcache, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL, cached_content = {}, keys = {}, last_key = {}, frontend = {}; zval prepared_content = {}, ttl = {}, success = {}, is_buffering = {}, prefix = {}, options = {}, special_key = {}; phalcon_fetch_params(0, 0, 4, &key_name, &content, &lifetime, &stop_buffer); if (!key_name || Z_TYPE_P(key_name) == IS_NULL) { phalcon_return_property(&last_key, getThis(), SL("_lastKey")); } else { phalcon_return_property(&prefix, getThis(), SL("_prefix")); PHALCON_CONCAT_SVV(&last_key, "_PHCX", &prefix, key_name); } if (!zend_is_true(&last_key)) { PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "The cache must be started first"); return; } phalcon_return_property(&frontend, getThis(), SL("_frontend")); if (!content || Z_TYPE_P(content) == IS_NULL) { PHALCON_CALL_METHODW(&cached_content, &frontend, "getcontent"); } else { PHALCON_CPY_WRT(&cached_content, content); } if (!phalcon_is_numeric(&cached_content)) { PHALCON_CALL_METHODW(&prepared_content, &frontend, "beforestore", &cached_content); } /** * Take the lifetime from the frontend or read it from the set in start() */ if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) { phalcon_return_property(&ttl, getThis(), SL("_lastLifetime")); if (Z_TYPE(ttl) <= IS_NULL) { PHALCON_CALL_METHODW(&ttl, &frontend, "getlifetime"); } } else { PHALCON_CPY_WRT(&ttl, lifetime); } if (Z_TYPE(prepared_content) > IS_NULL) { PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &prepared_content, &ttl); } else { PHALCON_CALL_FUNCTIONW(&success, "xcache_set", &last_key, &cached_content, &ttl); } PHALCON_CALL_METHODW(&is_buffering, &frontend, "isbuffering"); if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHODW(NULL, &frontend, "stop"); } if (PHALCON_IS_TRUE(&is_buffering)) { zend_print_zval(&cached_content, 0); } phalcon_update_property_bool(getThis(), SL("_started"), 0); if (zend_is_true(&success)) { phalcon_return_property(&options, getThis(), SL("_options")); if (unlikely(!phalcon_array_isset_fetch_str(&special_key, &options, SL("statsKey")))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_cache_exception_ce, "Unexpected inconsistency in options"); return; } /** * xcache_list() is available only to the administrator (unless XCache was * patched). We have to update the list of the stored keys. */ PHALCON_CALL_FUNCTIONW(&keys, "xcache_get", &special_key); if (Z_TYPE(keys) != IS_ARRAY) { array_init(&keys); } phalcon_array_update_zval(&keys, &last_key, &ttl, PH_COPY); PHALCON_CALL_FUNCTIONW(NULL, "xcache_set", &special_key, &keys, &PHALCON_GLOBAL(z_zero)); } }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL, *options, *prefix, *filtered; zval *prefixed_key, *cache_dir, *cache_file; zval *frontend, *time, *ttl = NULL, *modified_time, *difference; zval *not_expired, *cached_content, *processed; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, filtered); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); /** * Check if the file has expired */ PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_INIT_VAR(modified_time); PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file); PHALCON_INIT_VAR(difference); sub_function(difference, time, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); /** * The content is only retrieved if the content has not expired */ if (PHALCON_IS_TRUE(not_expired)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file); PHALCON_INIT_VAR(processed); PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK); RETURN_CCTOR(processed); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Renders a view using the template engine * * @param string $path * @param array $params * @param bool $mustClean */ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) { zval *path, *params, *must_clean, *value = NULL, *key = NULL, *contents; zval *view; HashTable *ah0; HashPosition hp0; 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, "zzz", &path, ¶ms, &must_clean) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_CALL_FUNC_NORETURN("ob_clean"); } if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE) { return; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); PHALCON_INIT_VAR(view); phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Phalcon\Db\Column constructor * * @param string $columnName * @param array $definition */ PHP_METHOD(Phalcon_Db_Column, __construct){ zval *column_name, *definition, *type, *not_null; zval *primary, *size, *is_numeric = NULL, *scale, *dunsigned; zval *auto_increment, *first, *after, *bind_type; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &column_name, &definition); phalcon_update_property_this(this_ptr, SL("_columnName"), column_name TSRMLS_CC); /** * Get the column type, one of the TYPE_* constants */ if (phalcon_array_isset_string(definition, SS("type"))) { PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, definition, SL("type"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type is required"); return; } /** * Check if the field is nullable */ if (phalcon_array_isset_string(definition, SS("notNull"))) { PHALCON_OBS_VAR(not_null); phalcon_array_fetch_string(¬_null, definition, SL("notNull"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_notNull"), not_null TSRMLS_CC); } /** * Check if the field is primary key */ if (phalcon_array_isset_string(definition, SS("primary"))) { PHALCON_OBS_VAR(primary); phalcon_array_fetch_string(&primary, definition, SL("primary"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_primary"), primary TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("size"))) { PHALCON_OBS_VAR(size); phalcon_array_fetch_string(&size, definition, SL("size"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC); } /** * Check if the column has a decimal scale */ if (phalcon_array_isset_string(definition, SS("scale"))) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 3); PHALCON_INIT_VAR(is_numeric); is_equal_function(is_numeric, type, t0 TSRMLS_CC); if (PHALCON_IS_NOT_TRUE(is_numeric)) { PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 7); is_equal_function(is_numeric, type, t1 TSRMLS_CC); } if (PHALCON_IS_TRUE(is_numeric)) { PHALCON_OBS_VAR(scale); phalcon_array_fetch_string(&scale, definition, SL("scale"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_scale"), scale TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type does not support scale parameter"); return; } } /** * Check if the field is unsigned (only MySQL) */ if (phalcon_array_isset_string(definition, SS("unsigned"))) { PHALCON_OBS_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, definition, SL("unsigned"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC); } /** * Check if the field is numeric */ if (phalcon_array_isset_string(definition, SS("isNumeric"))) { PHALCON_OBS_NVAR(is_numeric); phalcon_array_fetch_string(&is_numeric, definition, SL("isNumeric"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_isNumeric"), is_numeric TSRMLS_CC); } /** * Check if the field is auto-increment/serial */ if (phalcon_array_isset_string(definition, SS("autoIncrement"))) { if (PHALCON_IS_LONG(type, 0)) { PHALCON_OBS_VAR(auto_increment); phalcon_array_fetch_string(&auto_increment, definition, SL("autoIncrement"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment"); return; } } /** * Check if the field is placed at the first position of the table */ if (phalcon_array_isset_string(definition, SS("first"))) { PHALCON_OBS_VAR(first); phalcon_array_fetch_string(&first, definition, SL("first"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_first"), first TSRMLS_CC); } /** * Name of the column which is placed before the current field */ if (phalcon_array_isset_string(definition, SS("after"))) { PHALCON_OBS_VAR(after); phalcon_array_fetch_string(&after, definition, SL("after"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_after"), after TSRMLS_CC); } /** * The bind type to cast the field when passing it to PDO */ if (phalcon_array_isset_string(definition, SS("bindType"))) { PHALCON_OBS_VAR(bind_type); phalcon_array_fetch_string(&bind_type, definition, SL("bindType"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_bindType"), bind_type TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\Model $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){ zval *model, *key, *table, *schema, *meta_data, *data; zval *table_metadata = NULL, *class_name = NULL, *exception_message = NULL; zval *connection, *exists, *complete_table = NULL, *attributes; zval *primary_keys, *non_primary_keys, *numeric_typed; zval *not_null, *field_types, *field_bind_types; zval *automatic_default, *identity_field = NULL; zval *columns, *column = NULL, *field_name = NULL, *feature = NULL, *type = NULL; zval *bind_type = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); eval_int = phalcon_array_isset(meta_data, key); if (!eval_int) { PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { phalcon_array_update_zval(&meta_data, key, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_NULL(); } if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(table_metadata); PHALCON_CALL_METHOD(table_metadata, model, "metadata", PH_NO_CHECK); if (Z_TYPE_P(table_metadata) != IS_ARRAY) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_INIT_VAR(connection); PHALCON_CALL_METHOD(connection, model, "getconnection", PH_NO_CHECK); PHALCON_INIT_VAR(exists); PHALCON_CALL_METHOD_PARAMS_2(exists, connection, "tableexists", table, schema, PH_NO_CHECK); if (!zend_is_true(exists)) { if (zend_is_true(schema)) { PHALCON_INIT_VAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } PHALCON_INIT_VAR(attributes); array_init(attributes); PHALCON_INIT_VAR(primary_keys); array_init(primary_keys); PHALCON_INIT_VAR(non_primary_keys); array_init(non_primary_keys); PHALCON_INIT_VAR(numeric_typed); array_init(numeric_typed); PHALCON_INIT_VAR(not_null); array_init(not_null); PHALCON_INIT_VAR(field_types); array_init(field_types); PHALCON_INIT_VAR(field_bind_types); array_init(field_bind_types); PHALCON_INIT_VAR(automatic_default); array_init(automatic_default); PHALCON_INIT_VAR(identity_field); ZVAL_BOOL(identity_field, 0); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD_PARAMS_2(columns, connection, "describecolumns", table, schema, PH_NO_CHECK); if (!phalcon_fast_count_ev(columns TSRMLS_CC)) { if (zend_is_true(schema)) { PHALCON_INIT_NVAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); 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(column); PHALCON_INIT_NVAR(field_name); PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK); phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isprimary", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnumeric", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnotnull", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isautoincrement", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } PHALCON_INIT_NVAR(type); PHALCON_CALL_METHOD(type, column, "gettype", PH_NO_CHECK); phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(bind_type); PHALCON_CALL_METHOD(bind_type, column, "getbindtype", PH_NO_CHECK); phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_NVAR(table_metadata); array_init(table_metadata); phalcon_array_update_long(&table_metadata, 0, &attributes, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 4, &field_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC); phalcon_array_update_zval(&t0, key, &table_metadata, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t0 TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", key, table_metadata, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Renders a view * * @param string $path * @param array $params * @return string */ PHP_METHOD(Phalcon_Mvc_View_Simple, render){ zval *path, *params = NULL, *cache, *is_started = NULL, *key = NULL, *lifetime = NULL; zval *cache_options, *content = NULL, *view_params; zval *merged_params = NULL, *is_fresh; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &path, ¶ms); if (!params) { PHALCON_INIT_VAR(params); } /** * Create/Get a cache */ PHALCON_INIT_VAR(cache); phalcon_call_method(cache, this_ptr, "getcache"); if (Z_TYPE_P(cache) == IS_OBJECT) { /** * Check if the cache is started, the first time a cache is started we start the * cache */ PHALCON_INIT_VAR(is_started); phalcon_call_method(is_started, cache, "isstarted"); if (PHALCON_IS_FALSE(is_started)) { PHALCON_INIT_VAR(key); PHALCON_INIT_VAR(lifetime); PHALCON_OBS_VAR(cache_options); phalcon_read_property_this(&cache_options, this_ptr, SL("_cacheOptions"), PH_NOISY_CC); /** * Check if the user has defined a different options to the default */ if (Z_TYPE_P(cache_options) == IS_ARRAY) { if (phalcon_array_isset_string(cache_options, SS("key"))) { PHALCON_OBS_NVAR(key); phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY); } if (phalcon_array_isset_string(cache_options, SS("lifetime"))) { PHALCON_OBS_NVAR(lifetime); phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY); } } /** * If a cache key is not set we create one using a md5 */ if (Z_TYPE_P(key) == IS_NULL) { PHALCON_INIT_NVAR(key); phalcon_md5(key, path); } /** * We start the cache using the key set */ PHALCON_INIT_VAR(content); phalcon_call_method_p2(content, cache, "start", key, lifetime); if (Z_TYPE_P(content) != IS_NULL) { phalcon_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC); RETURN_CCTOR(content); } } } /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); phalcon_ob_start(TSRMLS_C); PHALCON_OBS_VAR(view_params); phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC); /** * Merge parameters */ if (Z_TYPE_P(params) == IS_ARRAY) { if (Z_TYPE_P(view_params) == IS_ARRAY) { PHALCON_INIT_VAR(merged_params); phalcon_fast_array_merge(merged_params, &view_params, ¶ms TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params, params); } } else { PHALCON_CPY_WRT(merged_params, view_params); } /** * internalRender is also reused by partials */ phalcon_call_method_p2_noret(this_ptr, "_internalrender", path, merged_params); /** * Store the data in output into the cache */ if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_NVAR(is_started); phalcon_call_method(is_started, cache, "isstarted"); if (PHALCON_IS_TRUE(is_started)) { PHALCON_INIT_VAR(is_fresh); phalcon_call_method(is_fresh, cache, "isfresh"); if (PHALCON_IS_TRUE(is_fresh)) { phalcon_call_method_noret(cache, "save"); } else { phalcon_call_method_noret(cache, "stop"); } } else { phalcon_call_method_noret(cache, "stop"); } } phalcon_ob_end_clean(TSRMLS_C); PHALCON_OBS_NVAR(content); phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY_CC); RETURN_CCTOR(content); }