/** * Isset property * * @param string $property * @return boolean */ PHP_METHOD(Phalcon_Session_Bag, __isset){ zval *property, *initalized, *data; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &property) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(initalized); phalcon_read_property(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { PHALCON_CALL_METHOD_NORETURN(this_ptr, "initialize", PH_NO_CHECK); } PHALCON_INIT_VAR(data); phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC); eval_int = phalcon_array_isset(data, property); if (eval_int) { PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Register an array of modules present in the jsonrpc * *<code> * $this->registerModules(array( * 'frontend' => array( * 'className' => 'Multiple\Frontend\Module', * 'path' => '../apps/frontend/Module.php' * ), * 'backend' => array( * 'className' => 'Multiple\Backend\Module', * 'path' => '../apps/backend/Module.php' * ) * )); *</code> * * @param array $modules * @param boolean $merge * @param Phalcon\Mvc\JsonRpc */ PHP_METHOD(Phalcon_Mvc_JsonRpc, registerModules){ zval *modules, *merge = NULL, *registered_modules, *merged_modules = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &modules, &merge); if (!merge) { merge = &PHALCON_GLOBAL(z_false); } if (Z_TYPE_P(modules) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Modules must be an Array"); return; } if (PHALCON_IS_FALSE(merge)) { phalcon_update_property_this(getThis(), SL("_modules"), modules); } else { registered_modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY); if (Z_TYPE_P(registered_modules) == IS_ARRAY) { PHALCON_INIT_VAR(merged_modules); phalcon_fast_array_merge(merged_modules, registered_modules, modules); } else { PHALCON_CPY_WRT(merged_modules, modules); } phalcon_update_property_this(getThis(), SL("_modules"), merged_modules); } RETURN_THIS(); }
/** * Sets a value in the session bag * *<code> * $user->set('name', 'Kimbra'); *</code> * * @param string $property * @param string $value */ PHP_METHOD(Phalcon_Session_Bag, set){ zval *property, *value, *initalized, *name, *data; zval *session; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &property, &value); PHALCON_OBS_VAR(initalized); phalcon_read_property_this(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { phalcon_call_method_noret(this_ptr, "initialize"); } phalcon_update_property_array(this_ptr, SL("_data"), property, value TSRMLS_CC); PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); PHALCON_OBS_VAR(session); phalcon_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC); phalcon_call_method_p2_noret(session, "set", name, data); PHALCON_MM_RESTORE(); }
/** * Throws an internal exception * * @param string $message * @param int $exceptionCode */ PHP_METHOD(Phalcon_CLI_Dispatcher, _throwDispatchException) { zval *message, *exception_code = NULL, *exception, *events_manager; zval *event_name, *status; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &message, &exception_code); if (!exception_code) { PHALCON_INIT_VAR(exception_code); ZVAL_LONG(exception_code, 0); } PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_cli_dispatcher_exception_ce); phalcon_call_method_p2_noret(exception, "__construct", message, exception_code); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "dispatch:beforeException", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, exception); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Removes a property from the internal bag * *<code> * $user->remove('name'); *</code> * * @param string $property * @return boolean */ PHP_METHOD(Phalcon_Session_Bag, remove){ zval *property, *data = NULL, *name, *session; zval *initialized; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &property); PHALCON_OBS_VAR(initialized); phalcon_read_property_this(&initialized, this_ptr, SL("_initialized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initialized)) { phalcon_call_method_noret(this_ptr, "initialize"); } PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { phalcon_unset_property_array(this_ptr, SL("_data"), property TSRMLS_CC); PHALCON_OBS_NVAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_OBS_VAR(session); phalcon_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC); phalcon_call_method_p2_noret(session, "set", name, data); RETURN_MM_TRUE; } RETURN_MM_FALSE; }
/** * Returns the content of the resource as an string * Optionally a base path where the resource is located can be set * * @param string $basePath * @return string */ PHP_METHOD(Phalcon_Assets_Resource, getContent){ zval *base_path = NULL, *source_path = NULL, *complete_path; zval *local, *exception_message = NULL, *content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &base_path); if (!base_path) { PHALCON_INIT_VAR(base_path); } PHALCON_OBS_VAR(source_path); phalcon_read_property_this(&source_path, this_ptr, SL("_sourcePath"), PH_NOISY_CC); if (PHALCON_IS_EMPTY(source_path)) { PHALCON_OBS_NVAR(source_path); phalcon_read_property_this(&source_path, this_ptr, SL("_path"), PH_NOISY_CC); } /** * A base path for resources can be set in the assets manager */ PHALCON_INIT_VAR(complete_path); PHALCON_CONCAT_VV(complete_path, base_path, source_path); PHALCON_OBS_VAR(local); phalcon_read_property_this(&local, this_ptr, SL("_local"), PH_NOISY_CC); /** * Local resources are loaded from the local disk */ if (zend_is_true(local)) { /** * Check first if the file is readable */ if (phalcon_file_exists(complete_path TSRMLS_CC) == FAILURE) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource's content for \"", complete_path, "\" cannot be loaded"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } } /** * Use file_get_contents to respect the openbase_dir. Access urls must be enabled */ PHALCON_INIT_VAR(content); phalcon_file_get_contents(content, complete_path TSRMLS_CC); if (PHALCON_IS_FALSE(content)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource's content for \"", complete_path, "\" cannot be read"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } RETURN_CCTOR(content); }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Identical, validate){ zval *validator, *attribute, *value = NULL, *identical_value, *valid = NULL; zval *message_str, *message, *code; zval *label, *pairs, *prepared = NULL; zend_class_entry *ce = Z_OBJCE_P(getThis()); PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1); PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute); PHALCON_OBS_VAR(identical_value); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &identical_value, getThis(), ISV(value))); PHALCON_CALL_SELF(&valid, "valid", value, identical_value); if (PHALCON_IS_FALSE(valid)) { PHALCON_OBS_VAR(label); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), ISV(label))); if (!zend_is_true(label)) { PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute); if (!zend_is_true(label)) { PHALCON_CPY_WRT(label, attribute); } } PHALCON_ALLOC_INIT_ZVAL(pairs); array_init_size(pairs, 1); Z_TRY_ADDREF_P(label); add_assoc_zval_ex(pairs, SL(":field"), label); PHALCON_OBS_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), ISV(message))); if (!zend_is_true(message_str)) { PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), message_str, validator, "Identical")); } PHALCON_OBS_VAR(code); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), ISV(code))); if (Z_TYPE_P(code) == IS_NULL) { ZVAL_LONG(code, 0); } PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs); message = phalcon_validation_message_construct_helper(prepared, attribute, "Identical", code); Z_TRY_DELREF_P(message); PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Prints out HTTP response to the client * * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, send){ zval *sent, *headers, *cookies, *content, *file; PHALCON_MM_GROW(); PHALCON_OBS_VAR(sent); phalcon_read_property_this(&sent, this_ptr, SL("_sent"), PH_NOISY_CC); if (PHALCON_IS_FALSE(sent)) { /** * Send headers */ PHALCON_OBS_VAR(headers); phalcon_read_property_this(&headers, this_ptr, SL("_headers"), PH_NOISY_CC); if (Z_TYPE_P(headers) == IS_OBJECT) { phalcon_call_method_noret(headers, "send"); } PHALCON_OBS_VAR(cookies); phalcon_read_property_this(&cookies, this_ptr, SL("_cookies"), PH_NOISY_CC); if (Z_TYPE_P(cookies) == IS_OBJECT) { phalcon_call_method_noret(cookies, "send"); } /** * Output the response body */ PHALCON_OBS_VAR(content); phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY_CC); if (Z_STRLEN_P(content)) { zend_print_zval(content, 0); } else { PHALCON_OBS_VAR(file); phalcon_read_property_this(&file, this_ptr, SL("_file"), PH_NOISY_CC); if (Z_STRLEN_P(file)) { php_stream *stream; stream = php_stream_open_wrapper(Z_STRVAL_P(file), "rb", REPORT_ERRORS, NULL); if (stream != NULL) { php_stream_passthru(stream); php_stream_close(stream); } } } phalcon_update_property_bool(this_ptr, SL("_sent"), 1 TSRMLS_CC); RETURN_THIS(); } PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "Response was already sent"); return; }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, validate){ zval *validator, *attribute, value = {}, allow_empty = {}, minimum = {}, maximum = {}, label = {}, pairs = {}, valid = {}, message_str = {}, code = {}, prepared = {}, message = {}; zend_class_entry *ce = Z_OBJCE_P(getThis()); phalcon_fetch_params(0, 2, 0, &validator, &attribute); PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 0); PHALCON_CALL_METHODW(&value, validator, "getvalue", attribute); RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&allow_empty, ce, getThis(), ISV(allowEmpty))); if (zend_is_true(&allow_empty) && phalcon_validation_validator_isempty_helper(&value)) { RETURN_TRUE; } RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&minimum, ce, getThis(), "minimum")); RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&maximum, ce, getThis(), "maximum")); PHALCON_CALL_SELFW(&valid, "valid", &value, &minimum, &maximum); if (PHALCON_IS_FALSE(&valid)) { RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&label, ce, getThis(), ISV(label))); if (!zend_is_true(&label)) { PHALCON_CALL_METHODW(&label, validator, "getlabel", attribute); if (!zend_is_true(&label)) { PHALCON_CPY_WRT_CTOR(&label, attribute); } } array_init_size(&pairs, 3); phalcon_array_update_str(&pairs, SL(":field"), &label, PH_COPY); phalcon_array_update_str(&pairs, SL(":min"), &minimum, PH_COPY); phalcon_array_update_str(&pairs, SL(":max"), &maximum, PH_COPY); RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message))); if (!zend_is_true(&message_str)) { RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "Between")); } RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&code, ce, getThis(), ISV(code))); if (Z_TYPE_P(&code) == IS_NULL) { ZVAL_LONG(&code, 0); } PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs); phalcon_validation_message_construct_helper(&message, &prepared, attribute, "Between", &code); PHALCON_CALL_METHODW(NULL, validator, "appendmessage", &message); RETURN_FALSE; } RETURN_TRUE; }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, validate){ zval *validator, *attribute, *value, *option = NULL, *minimum; zval *maximum, *valid = NULL, *type, *message_str = NULL, *message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, validator, "getvalue", attribute); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "minimum", 1); PHALCON_INIT_VAR(minimum); phalcon_call_method_p1(minimum, this_ptr, "getoption", option); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "maximum", 1); PHALCON_INIT_VAR(maximum); phalcon_call_method_p1(maximum, this_ptr, "getoption", option); PHALCON_INIT_VAR(valid); is_smaller_or_equal_function(valid, minimum, value TSRMLS_CC); if (zend_is_true(valid)) { is_smaller_or_equal_function(valid, value, maximum TSRMLS_CC); } if (PHALCON_IS_FALSE(valid)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Between", 1); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message_str); phalcon_call_method_p1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_VS(message_str, attribute, " is not between a valid range"); } PHALCON_INIT_VAR(message); object_init_ex(message, phalcon_validation_message_ce); phalcon_call_method_p3_noret(message, "__construct", message_str, attribute, type); phalcon_call_method_p1_noret(validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Starts the session (if headers are already sent the session will not started) * * @return boolean */ PHP_METHOD(Phalcon_Session_Adapter, start){ zval *headers_sent; PHALCON_MM_GROW(); PHALCON_INIT_VAR(headers_sent); PHALCON_CALL_FUNC(headers_sent, "headers_sent"); if (PHALCON_IS_FALSE(headers_sent)) { PHALCON_CALL_FUNC_NORETURN("session_start"); phalcon_update_property_bool(this_ptr, SL("_started"), 1 TSRMLS_CC); RETURN_MM_TRUE; } RETURN_MM_FALSE; }
PHP_METHOD(Phalcon_Mvc_Collection_GridFS, saveBytes){ zval *bytes, *arr = NULL, *white_list = NULL, *mode = NULL; zval *old_sha1, *old_md5, *sha1 = NULL, *md5 = NULL, *status = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 3, &bytes, &arr, &white_list, &mode); if (!arr) { arr = &PHALCON_GLOBAL(z_null); } if (!white_list) { white_list = &PHALCON_GLOBAL(z_null); } if (!mode) { mode = &PHALCON_GLOBAL(z_null); } if (zend_is_true(bytes)) { old_sha1 = phalcon_read_property(getThis(), SL("sha1"), PH_NOISY); old_md5 = phalcon_read_property(getThis(), SL("md5"), PH_NOISY); PHALCON_CALL_FUNCTION(&sha1, "sha1", bytes); PHALCON_CALL_FUNCTION(&md5, "md5", bytes); phalcon_update_property_this(getThis(), SL("sha1"), sha1); phalcon_update_property_this(getThis(), SL("md5"), md5); } PHALCON_CALL_PARENT(&status, phalcon_mvc_collection_gridfs_ce, getThis(), "save", arr, white_list, mode); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } if (zend_is_true(bytes)) { PHALCON_CALL_SELF(&status, "store", bytes, &PHALCON_GLOBAL(z_null), &PHALCON_GLOBAL(z_null), &PHALCON_GLOBAL(z_true)); if (zend_is_true(old_sha1)) { PHALCON_CALL_SELF(NULL, "remove", old_sha1, old_md5); } } RETURN_CTOR(status); }
/** * Internal get wrapper to filter * * @param string $name * @param string|array $filters * @param mixed $defaultValue * @param boolean $notAllowEmpty * @param boolean $noRecursive * @return mixed */ PHP_METHOD(Phalcon_Http_Request, _get) { zval *data, *name, *filters, *default_value, *not_allow_empty, *norecursive; zval value = {}, dependency_injector = {}, service = {}, filter = {}, filter_value = {}; phalcon_fetch_params(0, 6, 0, &data, &name, &filters, &default_value, ¬_allow_empty, &norecursive); if (Z_TYPE_P(name) != IS_NULL) { if (!phalcon_array_isset_fetch(&value, data, name, 0)) { RETURN_CTORW(default_value); } } else { PHALCON_CPY_WRT_CTOR(&value, data); } if (Z_TYPE_P(filters) != IS_NULL) { phalcon_return_property(&filter, getThis(), SL("_filter")); if (Z_TYPE(filter) != IS_OBJECT) { PHALCON_CALL_METHODW(&dependency_injector, getThis(), "getdi"); if (Z_TYPE(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STRW(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } PHALCON_STR(&service, ISV(filter)); PHALCON_CALL_METHODW(&filter, &dependency_injector, "getshared", &service); PHALCON_VERIFY_INTERFACEW(&filter, phalcon_filterinterface_ce); phalcon_update_property_zval(getThis(), SL("_filter"), &filter); } PHALCON_CALL_METHODW(&filter_value, &filter, "sanitize", &value, filters, norecursive); if ((PHALCON_IS_EMPTY(&filter_value) && zend_is_true(not_allow_empty)) || PHALCON_IS_FALSE(&filter_value)) { RETURN_CTORW(default_value); } RETURN_CTORW(&filter_value); } if (PHALCON_IS_EMPTY(&value) && zend_is_true(not_allow_empty)) { RETURN_CTORW(default_value); } RETURN_CTORW(&value); }
/** * Executes the validation * * @param int $value * @param int $minimum * @param int $maximum * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, valid){ zval *value, *minimum = NULL, *maximum = NULL, valid = {}; phalcon_fetch_params(0, 3, 0, &value, &minimum, &maximum); is_smaller_or_equal_function(&valid, minimum, value); if (zend_is_true(&valid)) { is_smaller_or_equal_function(&valid, value, maximum); } if (PHALCON_IS_FALSE(&valid)) { RETURN_FALSE; } RETURN_TRUE; }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Memcache, get){ zval *key_name, *lifetime = NULL, *memcache = NULL, *frontend; zval *prefix, *prefixed_key, *cached_content; zval *content; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { RETURN_MM_NULL(); } if (!lifetime) { PHALCON_INIT_VAR(lifetime); } PHALCON_OBS_VAR(memcache); phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); if (Z_TYPE_P(memcache) != IS_OBJECT) { PHALCON_CALL_METHOD_NORETURN(this_ptr, "_connect"); PHALCON_OBS_NVAR(memcache); phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); } PHALCON_OBS_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_OBS_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, key_name); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD_PARAMS_1(cached_content, memcache, "get", prefixed_key); if (PHALCON_IS_FALSE(cached_content)) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(content); PHALCON_CALL_METHOD_PARAMS_1(content, frontend, "afterretrieve", cached_content); RETURN_CCTOR(content); }
/** * Executes the validation * * @param string $value * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, valid){ zval *value, *minimum = NULL, *maximum = NULL, *valid; PHALCON_MM_GROW(); phalcon_fetch_params(1, 3, 0, &value, &minimum, &maximum); PHALCON_INIT_VAR(valid); is_smaller_or_equal_function(valid, minimum, value TSRMLS_CC); if (zend_is_true(valid)) { is_smaller_or_equal_function(valid, value, maximum TSRMLS_CC); } if (PHALCON_IS_FALSE(valid)) { RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Register the autoload method * * @return Phalcon\Loader */ PHP_METHOD(Phalcon_Loader, register){ zval *registered, *autoloader; PHALCON_MM_GROW(); PHALCON_OBS_VAR(registered); phalcon_read_property(®istered, this_ptr, SL("_registered"), PH_NOISY_CC); if (PHALCON_IS_FALSE(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_register", autoloader); } RETURN_THIS(); }
/** * Writes parsed annotations to files * * @param string $key * @param Phalcon\Annotations\Reflection $data */ PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){ zval *key, *data, *annotations_dir, *separator; zval *virtual_key, *path, *to_string, *export, *php_export; zval *status; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &key, &data); PHALCON_OBS_VAR(annotations_dir); phalcon_read_property_this(&annotations_dir, this_ptr, SL("_annotationsDir"), PH_NOISY_CC); PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "_", 1); /** * Paths must be normalized before be used as keys */ PHALCON_INIT_VAR(virtual_key); phalcon_prepare_virtual_path(virtual_key, key, separator TSRMLS_CC); PHALCON_INIT_VAR(path); PHALCON_CONCAT_VVS(path, annotations_dir, virtual_key, ".php"); PHALCON_INIT_VAR(to_string); ZVAL_BOOL(to_string, 1); PHALCON_INIT_VAR(export); phalcon_call_func_p2(export, "var_export", data, to_string); PHALCON_INIT_VAR(php_export); PHALCON_CONCAT_SVS(php_export, "<?php return ", export, "; "); PHALCON_INIT_VAR(status); phalcon_file_put_contents(status, path, php_export TSRMLS_CC); if (PHALCON_IS_FALSE(status)) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Annotations directory cannot be written"); return; } PHALCON_MM_RESTORE(); }
/** * Writes parsed annotations to files * * @param string $key * @param array $data */ PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){ zval *key, *data, *annotations_dir, *separator; zval *virtual_key, *path, *to_string, *export, *php_export; zval *status; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &data) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(annotations_dir); phalcon_read_property_this(&annotations_dir, this_ptr, SL("_annotationsDir"), PH_NOISY_CC); PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "_", 1); PHALCON_INIT_VAR(virtual_key); phalcon_prepare_virtual_path(virtual_key, key, separator TSRMLS_CC); PHALCON_INIT_VAR(path); PHALCON_CONCAT_VVS(path, annotations_dir, virtual_key, ".php"); PHALCON_INIT_VAR(to_string); ZVAL_BOOL(to_string, 1); PHALCON_INIT_VAR(export); PHALCON_CALL_FUNC_PARAMS_2(export, "var_export", data, to_string); PHALCON_INIT_VAR(php_export); PHALCON_CONCAT_SVS(php_export, "<?php return ", export, "; "); PHALCON_INIT_VAR(status); PHALCON_CALL_FUNC_PARAMS_2(status, "file_put_contents", path, php_export); if (PHALCON_IS_FALSE(status)) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Annotations directory cannot be written"); return; } PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Memcache, get){ zval *key_name, *lifetime = NULL, *memcache = NULL, *frontend; zval *prefix, *prefixed_key, *cached_content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &key_name, &lifetime); if (!lifetime) { PHALCON_INIT_VAR(lifetime); } PHALCON_OBS_VAR(memcache); phalcon_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); if (Z_TYPE_P(memcache) != IS_OBJECT) { phalcon_call_method_noret(this_ptr, "_connect"); PHALCON_OBS_NVAR(memcache); phalcon_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); } PHALCON_OBS_VAR(frontend); phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_OBS_VAR(prefix); phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, key_name); phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cached_content); phalcon_call_method_p1(cached_content, memcache, "get", prefixed_key); if (PHALCON_IS_FALSE(cached_content)) { RETURN_MM_NULL(); } phalcon_call_method_p1(return_value, frontend, "afterretrieve", cached_content); RETURN_MM(); }
/** * Obtains a value from the session bag optionally setting a default value * *<code> * echo $user->get('name', 'Kimbra'); *</code> * * @param string $property * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Session_Bag, get){ zval *property, *default_value = NULL, *initalized; zval *data, *value; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &property, &default_value) == FAILURE) { RETURN_MM_NULL(); } if (!default_value) { PHALCON_INIT_VAR(default_value); } /** * Check first if the bag is initialized */ PHALCON_OBS_VAR(initalized); phalcon_read_property(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { PHALCON_CALL_METHOD_NORETURN(this_ptr, "initialize"); } /** * Retrieve the data */ PHALCON_OBS_VAR(data); phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, data, property, PH_NOISY_CC); if (PHALCON_IS_NOT_EMPTY(value)) { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); }
/** * Destroyes the session bag * *<code> * $user->destroy(); *</code> */ PHP_METHOD(Phalcon_Session_Bag, destroy){ zval *initalized, *name, *session; PHALCON_MM_GROW(); PHALCON_OBS_VAR(initalized); phalcon_read_property(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { PHALCON_CALL_METHOD_NORETURN(this_ptr, "initialize"); } PHALCON_OBS_VAR(name); phalcon_read_property(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_OBS_VAR(session); phalcon_read_property(&session, this_ptr, SL("_session"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(session, "remove", name); PHALCON_MM_RESTORE(); }
/** * Destroyes the session bag * *<code> * $user->destroy(); *</code> */ PHP_METHOD(Phalcon_Session_Bag, destroy){ zval *initalized, *name, *session; PHALCON_MM_GROW(); PHALCON_OBS_VAR(initalized); phalcon_read_property_this(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { phalcon_call_method_noret(this_ptr, "initialize"); } PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_OBS_VAR(session); phalcon_read_property_this(&session, this_ptr, SL("_session"), PH_NOISY_CC); phalcon_call_method_p1_noret(session, "remove", name); PHALCON_MM_RESTORE(); }
/** * Phalcon\Cache\Backend\File constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_File, __construct){ zval *frontend, *options = NULL, *cache_dir, *is_writable; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &frontend, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_NVAR(options); array_init(options); } eval_int = phalcon_array_isset_string(options, SS("cacheDir")); if (eval_int) { PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); /** * Prod mode? */ PHALCON_INIT_VAR(is_writable); PHALCON_CALL_FUNC_PARAMS_1(is_writable, "is_writable", cache_dir); if (PHALCON_IS_FALSE(is_writable)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache directory does not exist or is not writable"); return; } PHALCON_CALL_PARENT_PARAMS_2_NORETURN(this_ptr, "Phalcon\\Cache\\Backend\\File", "__construct", frontend, options); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "You must specify the cache directory with the option cacheDir"); return; } PHALCON_MM_RESTORE(); }
/** * Prints out HTTP response to the client * * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, send){ zval *sent, *headers, *cookies, *content; PHALCON_MM_GROW(); PHALCON_OBS_VAR(sent); phalcon_read_property(&sent, this_ptr, SL("_sent"), PH_NOISY_CC); if (PHALCON_IS_FALSE(sent)) { /** * Sent headers */ PHALCON_OBS_VAR(headers); phalcon_read_property(&headers, this_ptr, SL("_headers"), PH_NOISY_CC); if (Z_TYPE_P(headers) != IS_NULL) { PHALCON_CALL_METHOD_NORETURN(headers, "send"); } PHALCON_OBS_VAR(cookies); phalcon_read_property(&cookies, this_ptr, SL("_cookies"), PH_NOISY_CC); if (Z_TYPE_P(cookies) != IS_NULL) { PHALCON_CALL_METHOD_NORETURN(cookies, "send"); } /** * Output the response body */ PHALCON_OBS_VAR(content); phalcon_read_property(&content, this_ptr, SL("_content"), PH_NOISY_CC); zend_print_zval(content, 0); phalcon_update_property_bool(this_ptr, SL("_sent"), 1 TSRMLS_CC); RETURN_THIS(); } PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "Response was already sent"); return; }
/** * Check whether a property is defined in the internal bag * *<code> * var_dump($user->has('name')); *</code> * * @param string $property * @return boolean */ PHP_METHOD(Phalcon_Session_Bag, has){ zval *property, *initalized, *data; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &property); PHALCON_OBS_VAR(initalized); phalcon_read_property_this(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { phalcon_call_method_noret(this_ptr, "initialize"); } PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { RETURN_MM_TRUE; } RETURN_MM_FALSE; }
/** * Obtains a value from the session bag optionally setting a default value * *<code> * echo $user->get('name', 'Kimbra'); *</code> * * @param string $property * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Session_Bag, get){ zval *property, *default_value = NULL, *initalized; zval *data, *value; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &property, &default_value); if (!default_value) { PHALCON_INIT_VAR(default_value); } /** * Check first if the bag is initialized */ PHALCON_OBS_VAR(initalized); phalcon_read_property_this(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { phalcon_call_method_noret(this_ptr, "initialize"); } /** * Retrieve the data */ PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, data, property, PH_NOISY); if (PHALCON_IS_NOT_EMPTY(value)) { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); }
/** * Returns a cached content * * @param string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Apc, get) { zval *key_name, *lifetime = NULL, prefixed_key = {}, prefix = {}, frontend = {}, cached_content = {}; phalcon_fetch_params(0, 1, 1, &key_name, &lifetime); phalcon_read_property(&prefix, getThis(), SL("_prefix"), PH_NOISY); PHALCON_CONCAT_SVV(&prefixed_key, "_PHCA", &prefix, key_name); phalcon_update_property_zval(getThis(), SL("_lastKey"), &prefixed_key); PHALCON_CALL_FUNCTIONW(&cached_content, "apc_fetch", &prefixed_key); if (PHALCON_IS_FALSE(&cached_content)) { RETURN_NULL(); } if (phalcon_is_numeric(&cached_content)) { RETURN_CTORW(&cached_content); } else { phalcon_read_property(&frontend, getThis(), SL("_frontend"), PH_NOISY); PHALCON_RETURN_CALL_METHODW(&frontend, "afterretrieve", &cached_content); } }
/** * Throws an internal exception * * @param string $message * @param int $exceptionCode */ PHP_METHOD(Phalcon_CLI_Dispatcher, _throwDispatchException){ zval *message, *exception_code = NULL, *exception, *events_manager; zval *event_name, *status; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &exception_code) == FAILURE) { RETURN_MM_NULL(); } if (!exception_code) { PHALCON_INIT_VAR(exception_code); ZVAL_LONG(exception_code, 0); } PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_cli_dispatcher_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", message, exception_code); PHALCON_OBS_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "dispatch:beforeException", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, exception); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Converts texts into URL-friendly titles * * @param string $text * @param string $separator * @param boolean $lowercase * @return text */ PHP_METHOD(Phalcon_Tag, friendlyTitle){ zval *text, *separator = NULL, *lowercase = NULL, *pattern, *friendly; zval *friendly_text = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &text, &separator, &lowercase) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!separator) { PHALCON_INIT_NVAR(separator); ZVAL_STRING(separator, "-", 1); } if (!lowercase) { PHALCON_INIT_NVAR(lowercase); ZVAL_BOOL(lowercase, 0); } PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "~[ \\t]+~", 1); PHALCON_INIT_VAR(friendly); PHALCON_CALL_FUNC_PARAMS_3(friendly, "preg_replace", pattern, separator, text); if (PHALCON_IS_FALSE(lowercase)) { PHALCON_INIT_VAR(friendly_text); PHALCON_CALL_FUNC_PARAMS_1(friendly_text, "strtolower", friendly); } else { PHALCON_CPY_WRT(friendly_text, friendly); } RETURN_CTOR(friendly_text); }