/** * Externally sets the view content * *<code> *$this->view->setContent("<h1>hello</h1>"); *</code> * * @param string $content */ PHP_METHOD(Phalcon_Mvc_View, setContent){ zval *content; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &content) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(content) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "Content must be a string"); return; } phalcon_update_property_zval(this_ptr, SL("_content"), content TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Sets the DependencyInjector container * * @param Phalcon\DI $dependencyInjector */ PHP_METHOD(Phalcon_Session_Bag, setDI){ zval *dependency_injector; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &dependency_injector) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The dependency injector must be an Object"); return; } phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Constructor for Phalcon\Db\Adapter\Pdo * * @param array $descriptor */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, __construct){ zval *descriptor; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &descriptor) == FAILURE) { RETURN_MM_NULL(); } 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_PARAMS_1_NORETURN(this_ptr, "connect", descriptor); PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Db\\Adapter\\Pdo", "__construct", descriptor); PHALCON_MM_RESTORE(); }
/** * Sets the dependency injector container. * * @param Phalcon\DI $dispatcher */ PHP_METHOD(Phalcon_Tag, setDI){ zval *dependency_injector = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &dependency_injector) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "Parameter dependencyInjector must be an Object"); return; } phalcon_update_static_property(SL("phalcon\\tag"), SL("_dependencyInjector"), dependency_injector TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Return active Dispatcher * * @return Phalcon_Dispatcher */ PHP_METHOD(Phalcon_Controller_Front, getDispatcher){ zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_dispatcher", sizeof("_dispatcher")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_dispatcher", sizeof("_dispatcher")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t1); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_exception_ce, "Dispatch process has not started yet"); return; } PHALCON_MM_RESTORE(); }
/** * Register an array of modules present in the console * *<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 */ PHP_METHOD(Phalcon_CLI_Console, registerModules){ zval *modules; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &modules) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(modules) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "Modules must be an Array"); return; } phalcon_update_property_zval(this_ptr, SL("_modules"), modules TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Phalcon\Logger\Adapter\File constructor * * @param string $name * @param array $options */ PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){ zval *name, *options = NULL, *mode = NULL, *handler, *exception_message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &name, &options); if (!options) { PHALCON_INIT_VAR(options); } if (phalcon_array_isset_string(options, SS("mode"))) { PHALCON_OBS_VAR(mode); phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY); if (phalcon_memnstr_str(mode, SL("r"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Logger must be opened in append or write mode"); return; } } else { PHALCON_INIT_NVAR(mode); ZVAL_STRING(mode, "ab", 1); } /** * We use 'fopen' to respect to open-basedir directive */ PHALCON_INIT_VAR(handler); phalcon_call_func_p2(handler, "fopen", name, mode); if (!zend_is_true(handler)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Can't open log file at '", name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_logger_exception_ce, exception_message); return; } phalcon_update_property_this(this_ptr, SL("_path"), name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_options"), options TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_fileHandler"), handler TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Register templating engines * *<code> *$this->view->registerEngines(array( * ".phtml" => "Phalcon\Mvc\View\Engine\Php", * ".volt" => "Phalcon\Mvc\View\Engine\Volt", * ".mhtml" => "MyCustomEngine" *)); *</code> * * @param array $engines */ PHP_METHOD(Phalcon_Mvc_View, registerEngines){ zval *engines; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &engines) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(engines) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "Engines to register must be an array"); return; } phalcon_update_property_zval(this_ptr, SL("_registeredEngines"), engines TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * 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(); }
/** * Unserializing a resultset will allow to only works on the rows present in the saved state * * @param string $data */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, unserialize){ zval *data, *resultset, *model, *rows, *cache, *column_map; zval *hydrate_mode; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { RETURN_MM_NULL(); } phalcon_update_property_long(this_ptr, SL("_type"), 0 TSRMLS_CC); PHALCON_INIT_VAR(resultset); PHALCON_CALL_FUNC_PARAMS_1(resultset, "unserialize", data); if (Z_TYPE_P(resultset) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Invalid serialization data"); return; } PHALCON_OBS_VAR(model); phalcon_array_fetch_string(&model, resultset, SL("model"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_model"), model TSRMLS_CC); PHALCON_OBS_VAR(rows); phalcon_array_fetch_string(&rows, resultset, SL("rows"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); PHALCON_OBS_VAR(cache); phalcon_array_fetch_string(&cache, resultset, SL("cache"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC); PHALCON_OBS_VAR(column_map); phalcon_array_fetch_string(&column_map, resultset, SL("columnMap"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_columnMap"), column_map TSRMLS_CC); PHALCON_OBS_VAR(hydrate_mode); phalcon_array_fetch_string(&hydrate_mode, resultset, SL("hydrateMode"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_hydrateMode"), hydrate_mode TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Check if a model has certain attribute * * @param Phalcon\Mvc\ModelInterface $model * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, hasAttribute){ zval *model, *attribute, *column_map, *meta_data; zval *data_types; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &attribute) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(attribute) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Attribute must be a string"); return; } PHALCON_INIT_VAR(column_map); PHALCON_CALL_METHOD_PARAMS_1(column_map, this_ptr, "getreversecolumnmap", model, PH_NO_CHECK); if (Z_TYPE_P(column_map) == IS_ARRAY) { eval_int = phalcon_array_isset(column_map, attribute); if (eval_int) { PHALCON_MM_RESTORE(); RETURN_TRUE; } } else { PHALCON_INIT_VAR(meta_data); PHALCON_CALL_METHOD_PARAMS_1(meta_data, this_ptr, "readmetadata", model, PH_NO_CHECK); PHALCON_INIT_VAR(data_types); phalcon_array_fetch_long(&data_types, meta_data, 4, PH_NOISY_CC); eval_int = phalcon_array_isset(data_types, attribute); if (eval_int) { PHALCON_MM_RESTORE(); RETURN_TRUE; } } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Phalcon_View_Engine_Mustache constructor * * @param Phalcon_View $view * @param array $options */ PHP_METHOD(Phalcon_View_Engine_Mustache, __construct){ zval *view = NULL, *options = NULL, *mustache = NULL; zval *c0 = NULL; zval *r0 = NULL, *r1 = NULL; zval *i0 = NULL; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &view, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "Mustache", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "class_exists", c0); if (!zend_is_true(r0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_view_exception_ce, "Mustache class must be loaded first"); return; } eval_int = phalcon_array_isset_string(options, SL("mustache")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, options, SL("mustache"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(mustache, r1); } else { ce0 = zend_fetch_class("Mustache", strlen("Mustache"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, ce0); PHALCON_CALL_METHOD_NORETURN(i0, "__construct", PHALCON_CHECK); PHALCON_CPY_WRT(mustache, i0); } phalcon_update_property_zval(this_ptr, SL("_mustache"), mustache TSRMLS_CC); PHALCON_CALL_PARENT_PARAMS_2_NORETURN(this_ptr, "Phalcon_View_Engine_Mustache", "__construct", view, options); PHALCON_MM_RESTORE(); }
/** * Rollbacks the internal transaction * */ PHP_METHOD(Phalcon_Logger_Adapter_File, rollback){ zval *transaction = NULL, *quenue = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(transaction); phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC); if (!zend_is_true(transaction)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction"); return; } phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC); PHALCON_INIT_VAR(quenue); array_init(quenue); phalcon_update_property_zval(this_ptr, SL("_quenue"), quenue TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Sets a database profiler to the connection * * @param Phalcon_Db_Profiler $profiler */ PHP_METHOD(Phalcon_Db, setProfiler){ zval *profiler = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &profiler) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(profiler) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, "_profiler", strlen("_profiler"), profiler TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Profiler must be an object"); return; } PHALCON_MM_RESTORE(); }
/** * Set an array with CSS classes to format the messages * * @param array $cssClasses */ PHP_METHOD(Phalcon_Flash, setCssClasses){ zval *css_classes = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &css_classes) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(css_classes) == IS_ARRAY) { phalcon_update_property_zval(this_ptr, SL("_cssClasses"), css_classes TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_flash_exception_ce, "CSS classes must be an Array"); return; } RETURN_CCTOR(this_ptr); }
/** * Rollbacks the internal transaction * */ PHP_METHOD(Phalcon_Logger_Adapter_File, rollback){ zval *t0 = NULL; zval *a0 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC); if (!zend_is_true(t0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction"); return; } phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); phalcon_update_property_zval(this_ptr, SL("_quenue"), a0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Initializes the engine adapter * * @param Phalcon_View $view * @param array $options */ PHP_METHOD(Phalcon_View_Engine, initialize){ zval *view = NULL, *options = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &view, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(view) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_view_exception_ce, "Invalid view component provided to Phalcon_View_Engine"); return; } phalcon_update_property_zval(this_ptr, "_view", strlen("_view"), view TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_options", strlen("_options"), options TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns attributes that must be ignored from the UPDATE SQL generation * *<code> * print_r($metaData->getAutomaticUpdateAttributes(new Robots())); *</code> * * @param Phalcon\Mvc\ModelInterface $model * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, getAutomaticUpdateAttributes) { zval *model, *index, *data; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &model); PHALCON_INIT_VAR(index); ZVAL_LONG(index, 11); PHALCON_INIT_VAR(data); phalcon_call_method_p2(data, this_ptr, "readmetadataindex", model, index); if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The meta-data is invalid or is corrupt"); return; } RETURN_CCTOR(data); }
/** * Reads meta-data for certain model * * @param Phalcon\Mvc\ModelInterface $model * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaData){ zval *model, *table, *schema, *key, *meta_data = NULL, *data; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(model) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A model instance is required to retrieve the meta-data"); return; } PHALCON_INIT_VAR(table); PHALCON_CALL_METHOD(table, model, "getsource", PH_NO_CHECK); PHALCON_INIT_VAR(schema); PHALCON_CALL_METHOD(schema, model, "getschema", PH_NO_CHECK); PHALCON_INIT_VAR(key); PHALCON_CONCAT_VV(key, schema, table); 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_CALL_METHOD_PARAMS_4_NORETURN(this_ptr, "_initialize", model, key, table, schema, PH_NO_CHECK); PHALCON_INIT_NVAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); } PHALCON_INIT_VAR(data); phalcon_array_fetch(&data, meta_data, key, PH_NOISY_CC); RETURN_CCTOR(data); }
/** * Generates SQL to add an index to a table * * @param string $tableName * @param string $schemaName * @param Phalcon_Db_Index $index * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addIndex){ zval *table_name = NULL, *schema_name = NULL, *index = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &index) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(index) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Index parameter must be an instance of Phalcon_Db_Index"); return; } if (zend_is_true(schema_name)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD INDEX "); PHALCON_CPY_WRT(sql, r0); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` ADD INDEX "); PHALCON_CPY_WRT(sql, r1); } PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_METHOD(r3, index, "getname", PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, index, "getcolumns", PHALCON_NO_CHECK); PHALCON_CALL_SELF_PARAMS_1(r4, this_ptr, "getcolumnlist", r5); PHALCON_CONCAT_SVSVS(r2, "`", r3, "` (", r4, ")"); phalcon_concat_self(&sql, r2 TSRMLS_CC); PHALCON_RETURN_CTOR(sql); }
/** * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed */ PHP_METHOD(Phalcon_Session_Bag, initialize){ zval *session = NULL, *dependency_injector, *service; zval *name, *data = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(session); phalcon_read_property(&session, this_ptr, SL("_session"), PH_NOISY_CC); if (Z_TYPE_P(session) != IS_OBJECT) { PHALCON_OBS_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_session_exception_ce, "A dependency injection object is required to access the 'session' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "session", 1); PHALCON_INIT_NVAR(session); PHALCON_CALL_METHOD_PARAMS_1(session, dependency_injector, "getshared", service); phalcon_update_property_zval(this_ptr, SL("_session"), session TSRMLS_CC); } PHALCON_OBS_VAR(name); phalcon_read_property(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, session, "get", name); if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_INIT_NVAR(data); array_init(data); } phalcon_update_property_zval(this_ptr, SL("_data"), data TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_initalized"), 1 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns the column map if any * *<code> * print_r($metaData->getColumnMap(new Robots())); *</code> * * @param Phalcon\Mvc\ModelInterface $model * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, getColumnMap){ zval *model, *index, *data = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &model); PHALCON_INIT_VAR(index); ZVAL_LONG(index, 0); PHALCON_CALL_METHOD(&data, this_ptr, "readcolumnmapindex", model, index); if (Z_TYPE_P(data) != IS_NULL) { if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The meta-data is invalid or is corrupt"); return; } } RETURN_CTOR(data); }
/** * Executes a find using the parameters built with the criteria * * @return Phalcon\Mvc\Model\ResultsetInterface */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, execute){ zval *model, *params, *resultset; PHALCON_MM_GROW(); PHALCON_OBS_VAR(model); phalcon_read_property_this(&model, this_ptr, SL("_model"), PH_NOISY_CC); if (Z_TYPE_P(model) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Model name must be string"); return; } PHALCON_INIT_VAR(params); phalcon_call_method(params, this_ptr, "getparams"); PHALCON_INIT_VAR(resultset); phalcon_call_zval_str_static_p1(resultset, model, "find", params); RETURN_CCTOR(resultset); }
/** * Create a Phalcon\Cache based on the internal cache options * * @return Phalcon\Cache\Backend */ PHP_METHOD(Phalcon_Mvc_View, _createCache){ zval *dependency_injector, *cache_service = NULL; zval *view_options, *cache_options, *view_cache; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the view cache services"); return; } PHALCON_INIT_VAR(cache_service); ZVAL_STRING(cache_service, "viewCache", 1); PHALCON_INIT_VAR(view_options); phalcon_read_property(&view_options, this_ptr, SL("_options"), PH_NOISY_CC); if (Z_TYPE_P(view_options) == IS_ARRAY) { eval_int = phalcon_array_isset_string(view_options, SS("cache")); if (eval_int) { PHALCON_INIT_VAR(cache_options); phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC); if (Z_TYPE_P(cache_options) == IS_ARRAY) { eval_int = phalcon_array_isset_string(cache_options, SS("service")); if (eval_int) { PHALCON_INIT_NVAR(cache_service); phalcon_array_fetch_string(&cache_service, cache_options, SL("service"), PH_NOISY_CC); } } } } PHALCON_INIT_VAR(view_cache); PHALCON_CALL_METHOD_PARAMS_1(view_cache, dependency_injector, "getshared", cache_service, PH_NO_CHECK); RETURN_CCTOR(view_cache); }
/** * Generate a >22-length pseudo random string to be used as salt for passwords * * @return string */ PHP_METHOD(Phalcon_Security, getSaltBytes){ zval *number_bytes, *random_bytes = NULL, *base64bytes = NULL; zval *safe_bytes = NULL, *bytes_length = NULL; PHALCON_MM_GROW(); if (phalcon_function_exists_ex(SS("openssl_random_pseudo_bytes") TSRMLS_CC) == FAILURE) { PHALCON_THROW_EXCEPTION_STR(phalcon_security_exception_ce, "Openssl extension must be loaded"); return; } PHALCON_OBS_VAR(number_bytes); phalcon_read_property_this(&number_bytes, this_ptr, SL("_numberBytes"), PH_NOISY_CC); while (1) { PHALCON_INIT_NVAR(random_bytes); phalcon_call_func_p1(random_bytes, "openssl_random_pseudo_bytes", number_bytes); PHALCON_INIT_NVAR(base64bytes); phalcon_base64_encode(base64bytes, random_bytes); PHALCON_INIT_NVAR(safe_bytes); phalcon_filter_alphanum(safe_bytes, base64bytes); if (!zend_is_true(safe_bytes)) { continue; } PHALCON_INIT_NVAR(bytes_length); phalcon_fast_strlen(bytes_length, safe_bytes); if (PHALCON_LT_LONG(bytes_length, 22)) { continue; } break; } RETURN_CTOR(safe_bytes); }
/** * Constructor for Phalcon\Db\Adapter\Pdo * * @param array $descriptor */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, __construct){ zval *descriptor = NULL, *dialect_type = NULL, *dialect_class = NULL; zval *dialect_object = NULL; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &descriptor) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(descriptor) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "$descriptor must be an array"); return; } eval_int = phalcon_array_isset_string(descriptor, SL("dialectClass")+1); if (!eval_int) { PHALCON_INIT_VAR(dialect_type); phalcon_read_property(&dialect_type, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(dialect_class); PHALCON_CONCAT_SV(dialect_class, "phalcon\\db\\dialect\\", dialect_type); } else { PHALCON_INIT_VAR(dialect_class); phalcon_array_fetch_string(&dialect_class, descriptor, SL("dialectClass"), PH_NOISY_CC); } ce0 = phalcon_fetch_class(dialect_class TSRMLS_CC); PHALCON_INIT_VAR(dialect_object); object_init_ex(dialect_object, ce0); PHALCON_CALL_METHOD_NORETURN(dialect_object, "__construct", PH_CHECK); phalcon_update_property_zval(this_ptr, SL("_dialect"), dialect_object TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "connect", descriptor, PH_NO_CHECK); PHALCON_MM_RESTORE(); }
/** * Generates SQL to add an index to a table * * @param string $tableName * @param string $schemaName * @param Phalcon\Db\Index $index * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addIndex){ zval *table_name = NULL, *schema_name = NULL, *index = NULL, *sql = NULL, *columns = NULL; zval *quoted_column_list = NULL, *name = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &index) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(index) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Index parameter must be an instance of Phalcon\\Db\\Index"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSVS(sql, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD INDEX "); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "ALTER TABLE `", table_name, "` ADD INDEX "); } PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(quoted_column_list); PHALCON_CALL_METHOD_PARAMS_1(quoted_column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, index, "getname", PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "`", name, "` (", quoted_column_list, ")"); phalcon_concat_self(&sql, r0 TSRMLS_CC); RETURN_CTOR(sql); }
/** * Phalcon\Cache\Backend constructor * * @param mixed $frontendObject * @param array $backendOptions */ PHP_METHOD(Phalcon_Cache_Backend, __construct){ zval *frontend_object = NULL, *backend_options = NULL; zval *a0 = NULL; zval *r0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); zend_update_property(phalcon_cache_backend_ce, this_ptr, SL("_backendOptions"), a0 TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &frontend_object, &backend_options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!backend_options) { PHALCON_INIT_VAR(backend_options); array_init(backend_options); } if (Z_TYPE_P(frontend_object) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Frontend must be an Object"); return; } eval_int = phalcon_array_isset_string(backend_options, SL("prefix")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, backend_options, SL("prefix"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_prefix"), r0 TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_frontendObject"), frontend_object TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_backendOptions"), backend_options TSRMLS_CC); 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; }