/** * Phalcon\Cache\Backend\Mongo constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, __construct){ zval *frontend, *options = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { options = PHALCON_GLOBAL(z_null); } if (!phalcon_array_isset_string(options, SS("mongo"))) { if (!phalcon_array_isset_string(options, SS("server"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'server' is required"); return; } } if (!phalcon_array_isset_string(options, SS("db"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'db' is required"); return; } if (!phalcon_array_isset_string(options, SS("collection"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The parameter 'collection' is required"); return; } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_mongo_ce, this_ptr, "__construct", frontend, options); PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, reset) { zval *meta = phalcon_fetch_nproperty_this(this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC); zval *real_key = NULL; PHALCON_MM_GROW(); if (SUCCESS == phalcon_function_exists_ex(SL("xcache_unset_by_prefix") TSRMLS_CC)) { zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(real_key); phalcon_concat_svs(&real_key, SL("$PMM$"), prefix, SL("meta-"), 0 TSRMLS_CC); PHALCON_CALL_FUNCTION(NULL, "xcache_unset_by_prefix", real_key); } else if (Z_TYPE_P(meta) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(meta); HashPosition hp; zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); for ( zend_hash_internal_pointer_reset_ex(ht, &hp); zend_hash_get_current_key_type_ex(ht, &hp) != HASH_KEY_NON_EXISTENT; zend_hash_move_forward_ex(ht, &hp) ) { zval key = phalcon_get_current_key_w(ht, &hp); PHALCON_INIT_NVAR(real_key); phalcon_concat_svsv(&real_key, SL("$PMM$"), prefix, SL("meta-"), &key, 0 TSRMLS_CC); PHALCON_CALL_FUNCTION(NULL, "xcache_unset", real_key); } } PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_xcache_ce, getThis(), "reset"); PHALCON_MM_RESTORE(); }
/** * Phalcon\Http\Request\File constructor * * @param array $file */ PHP_METHOD(Phalcon_Http_Request_File, __construct){ zval *file, *name, *temp_name, *size, *type, *error, *key = NULL; zval *constant, *extension = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &file, &key); if (Z_TYPE_P(file) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "Phalcon\\Http\\Request\\File requires a valid uploaded file"); return; } if (phalcon_array_isset_string(file, SS("name"))) { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, file, SL("name"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC); PHALCON_INIT_VAR(constant); if (zend_get_constant(SL("PATHINFO_EXTENSION"), constant TSRMLS_CC)) { PHALCON_CALL_FUNCTION(&extension, "pathinfo", name, constant); phalcon_update_property_this(this_ptr, SL("_extension"), extension TSRMLS_CC); } } if (phalcon_array_isset_string(file, SS("tmp_name"))) { PHALCON_OBS_VAR(temp_name); phalcon_array_fetch_string(&temp_name, file, SL("tmp_name"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_tmp"), temp_name TSRMLS_CC); } else { PHALCON_INIT_VAR(temp_name); ZVAL_NULL(temp_name); } if (phalcon_array_isset_string(file, SS("size"))) { PHALCON_OBS_VAR(size); phalcon_array_fetch_string(&size, file, SL("size"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC); } if (phalcon_array_isset_string(file, SS("type"))) { PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, file, SL("type"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); } if (phalcon_array_isset_string(file, SS("error"))) { PHALCON_OBS_VAR(error); phalcon_array_fetch_string(&error, file, SL("error"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_error"), error TSRMLS_CC); } if (key) { phalcon_update_property_this(this_ptr, SL("_key"), key TSRMLS_CC); } PHALCON_CALL_PARENT(NULL, phalcon_http_request_file_ce, this_ptr, "__construct", temp_name); PHALCON_MM_RESTORE(); }
/** * Phalcon\Cache\Backend\Xcache constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Xcache, __construct){ zval *frontend, *options = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { PHALCON_INIT_VAR(options); } else { PHALCON_SEPARATE_PARAM(options); } if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_INIT_NVAR(options); array_init(options); } if (!phalcon_array_isset_str(options, SL("statsKey"))) { phalcon_array_update_str_str(options, SL("statsKey"), SL("_PHCX"), PH_COPY); } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_xcache_ce, getThis(), "__construct", frontend, options); PHALCON_MM_RESTORE(); }
/** * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor. * Call it when you need to restore a database connection. * * Support set search_path after connectted if schema is specified in config. * * @param array $descriptor * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect){ zval *descriptor = NULL, *schema = NULL, *sql, *password; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &descriptor); if (!descriptor) { PHALCON_INIT_VAR(descriptor); } else { PHALCON_SEPARATE_PARAM(descriptor); } if (!zend_is_true(descriptor)) { PHALCON_OBS_NVAR(descriptor); phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC); } if (phalcon_array_isset_string(descriptor, SS("schema"))) { PHALCON_OBS_VAR(schema); phalcon_array_fetch_string(&schema, descriptor, SL("schema"), PH_NOISY); phalcon_array_unset_string(&descriptor, SS("schema"), PH_COPY); phalcon_update_property_this(this_ptr, SL("_schema"), schema TSRMLS_CC); } else { PHALCON_INIT_VAR(schema); } if (phalcon_array_isset_string_fetch(&password, descriptor, SS("password"))) { /* There is a bug in pdo_pgsql driver when the password is empty, * the driver tries to access invalid memory: * * if (dbh->password[0] != '\'' && dbh->password[strlen(dbh->password) - 1] != '\'') * * To avoid this we set the password to null */ if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) == 0) { phalcon_array_update_string(&descriptor, SL("password"), PHALCON_GLOBAL(z_null), PH_COPY); } } PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", descriptor); /** * Execute the search path in the after connect */ if (Z_TYPE_P(schema) == IS_STRING) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SET search_path TO '", schema, "'"); PHALCON_CALL_METHOD(NULL, this_ptr, "execute", sql); } PHALCON_MM_RESTORE(); }
/** * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor. * Call it when you need to restore a database connection. * * @param array $descriptor * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, connect) { zval *descriptor = NULL, *startup, *value = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &descriptor); if (!descriptor) { PHALCON_INIT_VAR(descriptor); } else { PHALCON_SEPARATE_PARAM(descriptor); } if (!zend_is_true(descriptor)) { PHALCON_OBS_NVAR(descriptor); phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC); } /** * Connect */ PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_oracle_ce, this_ptr, "connect", descriptor); /** * Database session settings initiated with each HTTP request. Oracle behaviour * depends on particular NLS* parameter. Check if the developer has defined custom * startup or create one from scratch */ if (phalcon_array_isset_string(descriptor, SS("startup"))) { PHALCON_OBS_VAR(startup); phalcon_array_fetch_string(&startup, descriptor, SL("startup"), PH_NOISY); if (Z_TYPE_P(startup) == IS_ARRAY) { phalcon_is_iterable(startup, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(value); PHALCON_CALL_METHOD(NULL, this_ptr, "execute", value); zend_hash_move_forward_ex(ah0, &hp0); } } } PHALCON_MM_RESTORE(); }
/** * Phalcon\Mvc\Model\Transaction\Failed constructor * * @param string $message * @param Phalcon\Mvc\ModelInterface $record */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Failed, __construct){ zval *message, *record; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &message, &record); phalcon_update_property_this(this_ptr, SL("_record"), record TSRMLS_CC); PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_transaction_failed_ce, this_ptr, "__construct", message); PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Files, reset) { zval *metadata_dir, *pattern, *iterator, *itkey = NULL; zend_object_iterator *it; PHALCON_MM_GROW(); metadata_dir = phalcon_fetch_nproperty_this(this_ptr, SL("_metaDataDir"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(pattern); PHALCON_CONCAT_VS(pattern, metadata_dir, "meta-*.php"); PHALCON_INIT_VAR(iterator); object_init_ex(iterator, spl_ce_GlobIterator); PHALCON_CALL_METHOD(NULL, iterator, "__construct", pattern); it = spl_ce_GlobIterator->get_iterator(spl_ce_GlobIterator, iterator, 0 TSRMLS_CC); it->funcs->rewind(it TSRMLS_CC); while (SUCCESS == it->funcs->valid(it TSRMLS_CC) && !EG(exception)) { zval dummy; #if PHP_VERSION_ID < 50500 char *str_key; uint str_key_len; ulong int_key; int key_type = it->funcs->get_current_key(it, &str_key, &str_key_len, &int_key TSRMLS_CC); if (likely(key_type == HASH_KEY_IS_STRING)) { PHALCON_INIT_NVAR(itkey); /* Note that str_key_len includes the trailing zero */ ZVAL_STRINGL(itkey, str_key, str_key_len-1, 1); phalcon_unlink(&dummy, itkey TSRMLS_CC); } #else PHALCON_INIT_NVAR(itkey); it->funcs->get_current_key(it, itkey TSRMLS_CC); phalcon_unlink(&dummy, itkey TSRMLS_CC); #endif it->funcs->move_forward(it TSRMLS_CC); } it->funcs->dtor(it TSRMLS_CC); if (!EG(exception)) { PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_files_ce, getThis(), "reset"); } PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, reset) { zval *redis; PHALCON_MM_GROW(); redis = phalcon_fetch_nproperty_this(this_ptr, SL("_redis"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(redis) == IS_OBJECT) { PHALCON_CALL_METHOD(NULL, redis, "flush"); } PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_redis_ce, getThis(), "reset"); 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; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options || !phalcon_array_isset_string(options, SS("cacheDir"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory must be specified with the option cacheDir"); return; } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_file_ce, this_ptr, "__construct", frontend, options); PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, reset) { zval *libmemcached; PHALCON_MM_GROW(); libmemcached = phalcon_read_property(getThis(), SL("_libmemcached"), PH_NOISY); if (Z_TYPE_P(libmemcached) == IS_OBJECT) { PHALCON_CALL_METHOD(NULL, libmemcached, "flush"); } PHALCON_CALL_PARENT(NULL, phalcon_mvc_model_metadata_libmemcached_ce, getThis(), "reset"); PHALCON_MM_RESTORE(); }
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); }
/** * Constructor for Phalcon\Db\Adapter\Pdo * * @param array $descriptor */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, __construct){ zval *descriptor; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &descriptor); if (Z_TYPE_P(descriptor) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The descriptor must be an array"); return; } PHALCON_CALL_METHOD(NULL, this_ptr, "connect", descriptor); PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_ce, this_ptr, "__construct", descriptor); PHALCON_MM_RESTORE(); }
/** * Phalcon\Cache\Backend\Libmemcached constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, __construct){ zval *frontend, *options = NULL, *server, *servers; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { PHALCON_INIT_VAR(options); } else { PHALCON_SEPARATE_PARAM(options); } if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_INIT_NVAR(options); array_init(options); } if (!phalcon_array_isset_str(options, SL("servers"))) { PHALCON_INIT_VAR(servers); array_init_size(servers, 1); PHALCON_INIT_VAR(server); array_init_size(server, 3); phalcon_array_update_str_str(server, SL("host"), SL("127.0.0.1"), PH_COPY); phalcon_array_update_str_long(server, SL("port"), 11211, PH_COPY); phalcon_array_update_str_long(server, SL("weight"), 1, PH_COPY); phalcon_array_append(servers, server, PH_COPY); phalcon_array_update_str(options, SL("servers"), servers, PH_COPY); } if (!phalcon_array_isset_str(options, SL("statsKey"))) { phalcon_array_update_str_str(options, SL("statsKey"), SL("_PHCM"), PH_COPY); } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_libmemcached_ce, getThis(), "__construct", frontend, options); PHALCON_MM_RESTORE(); }
/** * Phalcon\Forms\Element constructor * * @param string $name * @param object|array $options * @param array $attributes */ PHP_METHOD(Phalcon_Forms_Element_Select, __construct){ zval *name, *options = NULL, *attributes = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &name, &options, &attributes); if (!options) { options = PHALCON_GLOBAL(z_null); } if (!attributes) { attributes = PHALCON_GLOBAL(z_null); } phalcon_update_property_this(this_ptr, SL("_optionsValues"), options TSRMLS_CC); PHALCON_CALL_PARENT(NULL, phalcon_forms_element_select_ce, this_ptr, "__construct", name, attributes); PHALCON_MM_RESTORE(); }
/** * Phalcon\Cache\Backend\Memcache constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Memcache, __construct){ zval *frontend, *options = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { PHALCON_INIT_VAR(options); } else { PHALCON_SEPARATE_PARAM(options); } if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_INIT_NVAR(options); array_init_size(options, 4); } if (!phalcon_array_isset_string(options, SS("host"))) { phalcon_array_update_string_string(&options, SL("host"), SL("127.0.0.1"), PH_COPY); } if (!phalcon_array_isset_string(options, SS("port"))) { phalcon_array_update_string_long(&options, SL("port"), 11211, PH_COPY); } if (!phalcon_array_isset_string(options, SS("persistent"))) { phalcon_array_update_string_bool(&options, SL("persistent"), 0, PH_COPY); } if (!phalcon_array_isset_string(options, SS("statsKey"))) { phalcon_array_update_string_string(&options, SL("statsKey"), SL("_PHCM"), PH_COPY); } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_memcache_ce, this_ptr, "__construct", frontend, options); PHALCON_MM_RESTORE(); }
/** * Phalcon\DI\FactoryDefault\CLI constructor */ PHP_METHOD(Phalcon_DI_FactoryDefault_CLI, __construct){ zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher; PHALCON_MM_GROW(); PHALCON_CALL_PARENT(NULL, phalcon_di_factorydefault_cli_ce, this_ptr, "__construct"); shared = PHALCON_GLOBAL(z_true); PHALCON_INIT_VAR(name); PHALCON_ZVAL_MAYBE_INTERNED_STRING(name, phalcon_interned_router); PHALCON_INIT_VAR(definition); ZVAL_STRING(definition, "Phalcon\\CLI\\Router", 1); PHALCON_INIT_VAR(router); object_init_ex(router, phalcon_di_service_ce); PHALCON_CALL_METHOD(NULL, router, "__construct", name, definition, shared); phalcon_di_set_service(this_ptr, name, router, PH_COPY TSRMLS_CC); PHALCON_INIT_NVAR(name); PHALCON_ZVAL_MAYBE_INTERNED_STRING(name, phalcon_interned_dispatcher); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\CLI\\Dispatcher", 1); PHALCON_INIT_VAR(dispatcher); object_init_ex(dispatcher, phalcon_di_service_ce); PHALCON_CALL_METHOD(NULL, dispatcher, "__construct", name, definition, shared); phalcon_di_set_service(this_ptr, name, dispatcher, PH_COPY TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Produce the routing parameters from the rewrite information * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){ zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL; zval *handlers, *controller_suffix, *scope = NULL, *prefix = NULL; zval *dependency_injector = NULL, *service = NULL, *handler = NULL; zval *controller_name = NULL; zval *namespace_name = NULL, *module_name = NULL, *suffixed = NULL; zval *handler_annotations = NULL, *class_annotations = NULL; zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL; zval *collection = NULL, *method = NULL; HashTable *ah0, *ah1, *ah2, *ah3; HashPosition hp0, hp1, hp2, hp3; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &uri); if (!uri) { uri = PHALCON_GLOBAL(z_null); } if (!zend_is_true(uri)) { /** * If 'uri' isn't passed as parameter it reads $_GET['_url'] */ PHALCON_CALL_METHOD(&real_uri, this_ptr, "getrewriteuri"); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_OBS_VAR(processed); phalcon_read_property_this(&processed, this_ptr, SL("_processed"), PH_NOISY TSRMLS_CC); if (!zend_is_true(processed)) { PHALCON_INIT_VAR(annotations_service); PHALCON_OBS_VAR(handlers); phalcon_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(handlers) == IS_ARRAY) { PHALCON_OBS_VAR(controller_suffix); phalcon_read_property_this(&controller_suffix, this_ptr, SL("_controllerSuffix"), PH_NOISY TSRMLS_CC); phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(scope); if (Z_TYPE_P(scope) == IS_ARRAY) { /** * A prefix (if any) must be in position 0 */ PHALCON_OBS_NVAR(prefix); phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY); if (Z_TYPE_P(prefix) == IS_STRING) { if (!phalcon_start_with(real_uri, prefix, NULL)) { zend_hash_move_forward_ex(ah0, &hp0); continue; } } if (Z_TYPE_P(annotations_service) != IS_OBJECT) { PHALCON_OBS_NVAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service"); return; } PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "annotations", 1); PHALCON_CALL_METHOD(&annotations_service, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(annotations_service, phalcon_annotations_adapterinterface_ce); } /** * The controller must be in position 1 */ PHALCON_OBS_NVAR(handler); phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY); if (phalcon_memnstr_str(handler, SL("\\"))) { /** * Extract the real class name from the namespaced class */ PHALCON_INIT_NVAR(controller_name); phalcon_get_class_ns(controller_name, handler, 0 TSRMLS_CC); /** * Extract the namespace from the namespaced class */ PHALCON_INIT_NVAR(namespace_name); phalcon_get_ns_class(namespace_name, handler, 0 TSRMLS_CC); } else { PHALCON_CPY_WRT(controller_name, handler); PHALCON_INIT_NVAR(namespace_name); } phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC); /** * Check if the scope has a module associated */ if (phalcon_array_isset_long(scope, 2)) { PHALCON_OBS_NVAR(module_name); phalcon_array_fetch_long(&module_name, scope, 2, PH_NOISY); } else { PHALCON_INIT_NVAR(module_name); } PHALCON_INIT_NVAR(suffixed); PHALCON_CONCAT_VV(suffixed, handler, controller_suffix); /** * Get the annotations from the class */ PHALCON_CALL_METHOD(&handler_annotations, annotations_service, "get", suffixed); /** * Process class annotations */ PHALCON_CALL_METHOD(&class_annotations, handler_annotations, "getclassannotations"); if (Z_TYPE_P(class_annotations) == IS_OBJECT) { /** * Process class annotations */ PHALCON_CALL_METHOD(&annotations, class_annotations, "getannotations"); if (Z_TYPE_P(annotations) == IS_ARRAY) { phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(annotation); PHALCON_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", controller_name, annotation); zend_hash_move_forward_ex(ah1, &hp1); } } } /** * Process method annotations */ PHALCON_CALL_METHOD(&method_annotations, handler_annotations, "getmethodsannotations"); if (Z_TYPE_P(method_annotations) == IS_ARRAY) { phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HKEY(method, ah2, hp2); PHALCON_GET_HVALUE(collection); if (Z_TYPE_P(collection) == IS_OBJECT) { PHALCON_CALL_METHOD(&annotations, collection, "getannotations"); phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HVALUE(annotation); PHALCON_CALL_METHOD(NULL, this_ptr, "processactionannotation", module_name, namespace_name, controller_name, method, annotation); zend_hash_move_forward_ex(ah3, &hp3); } } zend_hash_move_forward_ex(ah2, &hp2); } } } zend_hash_move_forward_ex(ah0, &hp0); } } phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC); } /** * Call the parent handle method() */ PHALCON_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", real_uri); PHALCON_MM_RESTORE(); }
/** * Constructor for Phalcon\Session\Adapter\Memcache * * @param array $options */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){ zval *options; zval *host, *port, *lifetime, *persistent, *prefix; zval *frontend_data, *memcache, *option; zval *callable_open , *callable_close , *callable_read , *callable_write , *callable_destroy , *callable_gc; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The options must be an array"); return; } if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "No session host given in options"); return; } if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) { PHALCON_INIT_VAR(port); ZVAL_LONG(port, 11211); } if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) { PHALCON_INIT_VAR(lifetime); ZVAL_LONG(lifetime, 8600); } phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC); if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) { PHALCON_INIT_VAR(persistent); ZVAL_FALSE(persistent); } if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) { PHALCON_INIT_VAR(prefix); ZVAL_EMPTY_STRING(prefix); } /* create memcache instance */ PHALCON_INIT_VAR(option); array_init_size(option, 1); phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY); PHALCON_INIT_VAR(frontend_data); object_init_ex(frontend_data, phalcon_cache_frontend_data_ce); PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option); PHALCON_INIT_NVAR(option); array_init_size(option, 3); phalcon_array_update_string(&option, SL("host"), host, PH_COPY); phalcon_array_update_string(&option, SL("port"), port, PH_COPY); phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY); phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY); PHALCON_INIT_VAR(memcache); object_init_ex(memcache, phalcon_cache_backend_memcache_ce); PHALCON_CALL_METHOD(NULL, memcache, "__construct", frontend_data, option); phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC); /* open callback */ PHALCON_INIT_VAR(callable_open); array_init_size(callable_open, 2); phalcon_array_append(&callable_open, this_ptr, PH_COPY); phalcon_array_append_string(&callable_open, SL("open"), 0); /* close callback */ PHALCON_INIT_VAR(callable_close); array_init_size(callable_close, 2); phalcon_array_append(&callable_close, this_ptr, PH_COPY); phalcon_array_append_string(&callable_close, SL("close"), 0); /* read callback */ PHALCON_INIT_VAR(callable_read); array_init_size(callable_read, 2); phalcon_array_append(&callable_read, this_ptr, PH_COPY); phalcon_array_append_string(&callable_read, SL("read"), 0); /* write callback */ PHALCON_INIT_VAR(callable_write); array_init_size(callable_write, 2); phalcon_array_append(&callable_write, this_ptr, PH_COPY); phalcon_array_append_string(&callable_write, SL("write"), 0); /* destroy callback */ PHALCON_INIT_VAR(callable_destroy); array_init_size(callable_destroy, 2); phalcon_array_append(&callable_destroy, this_ptr, PH_COPY); phalcon_array_append_string(&callable_destroy, SL("destroy"), 0); /* gc callback */ PHALCON_INIT_VAR(callable_gc); array_init_size(callable_gc, 2); phalcon_array_append(&callable_gc, this_ptr, PH_COPY); phalcon_array_append_string(&callable_gc, SL("gc"), 0); PHALCON_CALL_FUNCTION(NULL, "session_set_save_handler", callable_open, callable_close, callable_read, callable_write, callable_destroy, callable_gc); PHALCON_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", options); PHALCON_MM_RESTORE(); }