/**
* 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;
}