/** * Makes the work of autoload registered classes * * @param string $className * @return boolean */ PHP_METHOD(Phalcon_Loader, autoLoad){ zval *class_name, *events_manager, *event_name = NULL; zval *classes, *file_path = NULL, *extensions, *ds, *namespace_separator; zval *empty_str, *zero, *namespaces, *directory = NULL; zval *prefix = NULL, *prefix_namespace = NULL, *file_name = NULL; zval *fixed_directory = NULL, *extension = NULL, *complete_path = NULL; zval *pseudo_separator, *prefixes, *no_prefix_class = NULL; zval *ds_class_name, *ns_class_name, *directories; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) { RETURN_MM_NULL(); } 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, "loader:beforeCheckClass", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name); } /** * First we check for static paths for classes */ PHALCON_OBS_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC); if (Z_TYPE_P(classes) == IS_ARRAY) { if (phalcon_array_isset(classes, class_name)) { PHALCON_OBS_VAR(file_path); phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } if (phalcon_require(file_path TSRMLS_CC) == FAILURE) { return; } RETURN_MM_TRUE; } } PHALCON_OBS_VAR(extensions); phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC); PHALCON_INIT_VAR(ds); zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC); PHALCON_INIT_VAR(namespace_separator); ZVAL_STRING(namespace_separator, "\\", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(zero); ZVAL_LONG(zero, 0); /** * Checking in namespaces */ PHALCON_OBS_VAR(namespaces); phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC); if (Z_TYPE_P(namespaces) == IS_ARRAY) { if (!phalcon_is_iterable(namespaces, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(prefix, ah0, hp0); PHALCON_GET_FOREACH_VALUE(directory); /** * The class name must start with the current namespace */ if (phalcon_start_with(class_name, prefix, NULL)) { /** * Append the namespace separator to the prefix */ PHALCON_INIT_NVAR(prefix_namespace); PHALCON_CONCAT_VV(prefix_namespace, prefix, namespace_separator); PHALCON_INIT_NVAR(file_name); phalcon_fast_str_replace(file_name, prefix_namespace, empty_str, class_name TSRMLS_CC); if (zend_is_true(file_name)) { /** * Add a trailing directory separator if the user forgot to do that */ PHALCON_INIT_NVAR(fixed_directory); phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC); if (!phalcon_is_iterable(extensions, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(extension); PHALCON_INIT_NVAR(complete_path); PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension); PHALCON_INIT_NVAR(file_path); phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC); /** * Check if a events manager is available */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:beforeCheckPath", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } /** * This is probably a good path, let's check if the file exist */ if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) { if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } /** * Simulate a require */ if (phalcon_require(file_path TSRMLS_CC) == FAILURE) { return; } /** * Return true mean success */ RETURN_MM_TRUE; } zend_hash_move_forward_ex(ah1, &hp1); } } } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_INIT_VAR(pseudo_separator); ZVAL_STRING(pseudo_separator, "_", 1); /** * Checking in prefixes */ PHALCON_OBS_VAR(prefixes); phalcon_read_property(&prefixes, this_ptr, SL("_prefixes"), PH_NOISY_CC); if (Z_TYPE_P(prefixes) == IS_ARRAY) { if (!phalcon_is_iterable(prefixes, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_KEY(prefix, ah2, hp2); PHALCON_GET_FOREACH_VALUE(directory); /** * The class name starts with the prefix? */ if (phalcon_start_with(class_name, prefix, NULL)) { /** * Remove the prefix from the class */ PHALCON_INIT_NVAR(no_prefix_class); phalcon_fast_str_replace(no_prefix_class, prefix, empty_str, class_name TSRMLS_CC); /** * Change the pseudo-separator '_' by the directory separator */ PHALCON_INIT_NVAR(file_name); phalcon_fast_str_replace(file_name, pseudo_separator, ds, no_prefix_class TSRMLS_CC); if (zend_is_true(file_name)) { /** * Add a trailing directory separator if the user forgot to do that */ PHALCON_INIT_NVAR(fixed_directory); phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC); if (!phalcon_is_iterable(extensions, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(extension); PHALCON_INIT_NVAR(complete_path); PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension); PHALCON_INIT_NVAR(file_path); phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:beforeCheckPath", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) { /** * Call 'pathFound' event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } if (phalcon_require(file_path TSRMLS_CC) == FAILURE) { return; } RETURN_MM_TRUE; } zend_hash_move_forward_ex(ah3, &hp3); } } } zend_hash_move_forward_ex(ah2, &hp2); } } /** * Change the pseudo-separator by the directory separator in the class name */ PHALCON_INIT_VAR(ds_class_name); phalcon_fast_str_replace(ds_class_name, pseudo_separator, ds, class_name TSRMLS_CC); /** * And change the namespace separator by directory separator too */ PHALCON_INIT_VAR(ns_class_name); phalcon_fast_str_replace(ns_class_name, namespace_separator, ds, ds_class_name TSRMLS_CC); /** * Checking in directories */ PHALCON_OBS_VAR(directories); phalcon_read_property(&directories, this_ptr, SL("_directories"), PH_NOISY_CC); if (Z_TYPE_P(directories) == IS_ARRAY) { if (!phalcon_is_iterable(directories, &ah4, &hp4, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(directory); /** * Add a trailing directory separator if the user forgot to do that */ PHALCON_INIT_NVAR(fixed_directory); phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC); if (!phalcon_is_iterable(extensions, &ah5, &hp5, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(extension); /** * Create a possible path for the file */ PHALCON_INIT_NVAR(file_path); PHALCON_CONCAT_VVSV(file_path, fixed_directory, ns_class_name, ".", extension); if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:beforeCheckPath", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } /** * Check in every directory if the class exists here */ if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) { /** * Call 'pathFound' event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path); } /** * Simulate a require */ if (phalcon_require(file_path TSRMLS_CC) == FAILURE) { return; } /** * Return true meaning success */ RETURN_MM_TRUE; } zend_hash_move_forward_ex(ah5, &hp5); } zend_hash_move_forward_ex(ah4, &hp4); } } /** * Call 'afterCheckClass' event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "loader:afterCheckClass", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name); } /** * Cannot find the class return false */ RETURN_MM_FALSE; }
/** * Rollbacks the transaction * * @param string $rollbackMessage * @param Phalcon\Mvc\Model $rollbackRecord * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback){ zval *rollback_message = NULL, *rollback_record = NULL; zval *manager = NULL, *call_object = NULL, *arguments = NULL, *connection = NULL; zval *success = NULL, *exception = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &rollback_message, &rollback_record) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!rollback_message) { PHALCON_ALLOC_ZVAL_MM(rollback_message); ZVAL_NULL(rollback_message); } else { PHALCON_SEPARATE_PARAM(rollback_message); } if (!rollback_record) { PHALCON_ALLOC_ZVAL_MM(rollback_record); ZVAL_NULL(rollback_record); } else { PHALCON_SEPARATE_PARAM(rollback_record); } PHALCON_INIT_VAR(manager); phalcon_read_property(&manager, this_ptr, SL("_manager"), PH_NOISY_CC); if (zend_is_true(manager)) { PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, manager, PH_SEPARATE TSRMLS_CC); add_next_index_stringl(call_object, SL("notifyRollback"), 1); PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", call_object, arguments); } PHALCON_INIT_VAR(connection); phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD(success, connection, "rollback", PH_NO_CHECK); if (zend_is_true(success)) { if (!zend_is_true(rollback_message)) { PHALCON_INIT_VAR(rollback_message); ZVAL_STRING(rollback_message, "Transaction aborted", 1); } if (zend_is_true(rollback_record)) { phalcon_update_property_zval(this_ptr, SL("_rollbackRecord"), rollback_record TSRMLS_CC); } PHALCON_INIT_VAR(rollback_record); phalcon_read_property(&rollback_record, this_ptr, SL("_rollbackRecord"), PH_NOISY_CC); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_mvc_model_transaction_failed_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", rollback_message, rollback_record, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Db_Column, __set_state){ zval *data = NULL, *definition = NULL, *column_name = NULL, *column_type = NULL; zval *not_null = NULL, *primary = NULL, *size = NULL, *dunsigned = NULL, *after = NULL; zval *is_numeric = NULL, *first = NULL, *column = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(definition); array_init(definition); eval_int = phalcon_array_isset_string(data, SL("_columnName")+1); if (eval_int) { PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, data, SL("_columnName"), PH_NOISY_CC); } eval_int = phalcon_array_isset_string(data, SL("_type")+1); if (eval_int) { PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, data, SL("_type"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("type"), &column_type, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_notNull")+1); if (eval_int) { PHALCON_INIT_VAR(not_null); phalcon_array_fetch_string(¬_null, data, SL("_notNull"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("notNull"), ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_primary")+1); if (eval_int) { PHALCON_INIT_VAR(primary); phalcon_array_fetch_string(&primary, data, SL("_primary"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("primary"), &primary, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_size")+1); if (eval_int) { PHALCON_INIT_VAR(size); phalcon_array_fetch_string(&size, data, SL("_size"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &size, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_unsigned")+1); if (eval_int) { PHALCON_INIT_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, data, SL("_unsigned"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("unsigned"), &dunsigned, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_after")+1); if (eval_int) { PHALCON_INIT_VAR(after); phalcon_array_fetch_string(&after, data, SL("_after"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("after"), &after, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_isNumeric")+1); if (eval_int) { PHALCON_INIT_VAR(is_numeric); phalcon_array_fetch_string(&is_numeric, data, SL("_isNumeric"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("isNumeric"), &is_numeric, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_first")+1); if (eval_int) { PHALCON_INIT_VAR(first); phalcon_array_fetch_string(&first, data, SL("_first"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("first"), &first, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); RETURN_CTOR(column); }
/** * Lists table indexes * * @param string $table * @param string $schema * @return Phalcon\Db\Index[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeIndexes){ zval *table = NULL, *schema = NULL, *dialect = NULL, *fetch_assoc = NULL, *sql = NULL; zval *describe = NULL, *indexes = NULL, *index = NULL, *key_name = NULL, *empty_arr = NULL; zval *column_name = NULL, *index_objects = NULL, *index_columns = NULL; zval *name = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(indexes); array_init(indexes); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(index); PHALCON_INIT_VAR(key_name); phalcon_array_fetch_string(&key_name, index, SL("key_name"), PH_NOISY_CC); eval_int = phalcon_array_isset(indexes, key_name); if (!eval_int) { PHALCON_INIT_VAR(empty_arr); array_init(empty_arr); phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, index, SL("column_name"), PH_NOISY_CC); phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(index_objects); array_init(index_objects); if (!phalcon_valid_foreach(indexes TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(indexes); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto ph_cycle_end_1; } PHALCON_INIT_VAR(name); PHALCON_GET_FOREACH_KEY(name, ah1, hp1); PHALCON_GET_FOREACH_VALUE(index_columns); PHALCON_INIT_VAR(index); object_init_ex(index, phalcon_db_index_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns, PH_CHECK); phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: RETURN_CTOR(index_objects); }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code> * print_r($connection->describeColumns("posts")); ?> * </code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){ zval *table, *schema = NULL, *columns, *dialect, *sql, *fetch_assoc; zval *describe, *old_column = NULL, *size_pattern, *field = NULL; zval *definition = NULL, *column_type = NULL, *matches = NULL, *pos = NULL; zval *match_one = NULL, *attribute = NULL, *column_name = NULL, *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_INIT_NVAR(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); PHALCON_INIT_VAR(size_pattern); ZVAL_STRING(size_pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_NVAR(definition); array_init(definition); add_assoc_long_ex(definition, SS("bindType"), 2); /** * By checking every column type we convert it to a Phalcon\Db\Column */ PHALCON_INIT_NVAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); if (phalcon_memnstr_str(column_type, SL("int") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("varchar") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("date") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("decimal") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("char") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("datetime") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("text") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("float") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("enum") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } } } } } } } } } /** * If the column type has a parentheses we try to get the column size from it */ if (phalcon_memnstr_str(column_type, SL("(") TSRMLS_CC)) { PHALCON_INIT_NVAR(matches); array_init(matches); Z_SET_ISREF_P(matches); PHALCON_INIT_NVAR(pos); PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", size_pattern, column_type, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(pos)) { eval_int = phalcon_array_isset_long(matches, 1); if (eval_int) { PHALCON_INIT_NVAR(match_one); phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } /** * Check if the column is unsigned, only MySQL support this */ if (phalcon_memnstr_str(column_type, SL("unsigned") TSRMLS_CC)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (!zend_is_true(old_column)) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } /** * Check if the field is primary key */ PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } /** * Check if the column allows null values */ PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } /** * Check if the column is auto increment */ PHALCON_INIT_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC); PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(columns); }
/** * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php * * @return array */ PHP_METHOD(Phalcon_Mvc_View, _loadTemplateEngines){ zval *engines = NULL, *dependency_injector = NULL, *registered_engines = NULL; zval *number_engines = NULL, *php_engine = NULL, *arguments = NULL; zval *engine_service = NULL, *extension = NULL, *engine_object = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); PHALCON_INIT_VAR(engines); phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC); if (Z_TYPE_P(engines) == IS_BOOL && !Z_BVAL_P(engines)) { PHALCON_INIT_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); PHALCON_INIT_VAR(engines); array_init(engines); PHALCON_INIT_VAR(registered_engines); phalcon_read_property(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC); PHALCON_INIT_VAR(number_engines); phalcon_fast_count(number_engines, registered_engines TSRMLS_CC); if (phalcon_compare_strict_long(number_engines, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(php_engine); object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(php_engine, "__construct", this_ptr, dependency_injector, PH_CHECK); phalcon_array_update_string(&engines, SL(".phtml"), &php_engine, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { 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 application services"); return; } PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE TSRMLS_CC); if (!phalcon_valid_foreach(registered_engines TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(registered_engines); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ecde_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ecde_0; } PHALCON_INIT_VAR(extension); PHALCON_GET_FOREACH_KEY(extension, ah0, hp0); PHALCON_INIT_VAR(engine_service); ZVAL_ZVAL(engine_service, *hd, 1, 0); PHALCON_INIT_VAR(engine_object); PHALCON_CALL_METHOD_PARAMS_2(engine_object, dependency_injector, "getshared", engine_service, arguments, PH_NO_CHECK); phalcon_array_update_zval(&engines, extension, &engine_object, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ecde_0; fee_ecde_0: if(0){} } phalcon_update_property_zval(this_ptr, SL("_engines"), engines TSRMLS_CC); } else { PHALCON_INIT_VAR(engines); phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC); } RETURN_CCTOR(engines); }
/** * Magic method to get or set services using setters/getters * * @param string $method * @param array $arguments * @return mixed */ PHP_METHOD(Phalcon_DI, __call){ zval *method, *arguments = NULL, *services, *service_name = NULL; zval *possible_service = NULL, *instance = NULL, *handler; zval *exception_message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &method, &arguments); if (!arguments) { PHALCON_INIT_VAR(arguments); } /** * If the magic method starts with 'get' we try to get a service with that name */ if (phalcon_start_with_str(method, SL("get"))) { PHALCON_OBS_VAR(services); phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); PHALCON_INIT_VAR(service_name); phalcon_substr(service_name, method, 3, 0 TSRMLS_CC); PHALCON_INIT_VAR(possible_service); PHALCON_CALL_FUNC_PARAMS_1(possible_service, "lcfirst", service_name); if (phalcon_array_isset(services, possible_service)) { if (phalcon_fast_count_ev(arguments TSRMLS_CC)) { PHALCON_INIT_VAR(instance); PHALCON_CALL_METHOD_PARAMS_2(instance, this_ptr, "get", possible_service, arguments); } else { PHALCON_INIT_NVAR(instance); PHALCON_CALL_METHOD_PARAMS_1(instance, this_ptr, "get", possible_service); } RETURN_CCTOR(instance); } } /** * If the magic method starts with 'set' we try to set a service using that name */ if (phalcon_start_with_str(method, SL("set"))) { if (phalcon_array_isset_long(arguments, 0)) { PHALCON_INIT_NVAR(service_name); phalcon_substr(service_name, method, 3, 0 TSRMLS_CC); PHALCON_INIT_NVAR(possible_service); PHALCON_CALL_FUNC_PARAMS_1(possible_service, "lcfirst", service_name); PHALCON_OBS_VAR(handler); phalcon_array_fetch_long(&handler, arguments, 0, PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "set", possible_service, handler); RETURN_MM_NULL(); } } /** * The method doesn't start with set/get throw an exception */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Call to undefined method or service '", method, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message); return; }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code> * print_r($connection->describeColumns("posts")); ?> * </code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){ zval *table, *schema = NULL, *columns, *dialect, *size_pattern; zval *sql, *fetch_assoc, *describe, *old_column = NULL; zval *field = NULL, *definition = NULL, *column_type = NULL, *pos = NULL, *attribute = NULL; zval *matches = NULL, *match_one = NULL, *column_name = NULL, *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { RETURN_MM_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_OBS_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(size_pattern); ZVAL_STRING(size_pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc); PHALCON_INIT_VAR(old_column); if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_NVAR(definition); array_init_size(definition, 1); add_assoc_long_ex(definition, SS("bindType"), 2); PHALCON_OBS_NVAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_NVAR(pos); phalcon_fast_stripos_str(pos, column_type, SL("int") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(pos)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE TSRMLS_CC); PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } } else { if (phalcon_memnstr_str(column_type, SL("varchar") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("date") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("decimal") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("char") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("datetime") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("text") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("float") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(column_type, SL("enum") TSRMLS_CC)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } } } } } } } } } if (phalcon_memnstr_str(column_type, SL("(") TSRMLS_CC)) { PHALCON_INIT_NVAR(matches); array_init(matches); Z_SET_ISREF_P(matches); PHALCON_INIT_NVAR(pos); PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", size_pattern, column_type, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(pos)) { if (phalcon_array_isset_long(matches, 1)) { PHALCON_OBS_NVAR(match_one); phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } if (phalcon_memnstr_str(column_type, SL("unsigned") TSRMLS_CC)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (!zend_is_true(old_column)) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC); if (zend_is_true(attribute)) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC); PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CTOR(columns); }
/** * Lists table indexes * * @param string $table * @param string $schema * @return Phalcon\Db\Index[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes){ zval *table, *schema = NULL, *dialect, *fetch_assoc, *sql; zval *describe, *indexes, *index = NULL, *key_name = NULL, *empty_arr = NULL; zval *sql_index_describe = NULL, *describe_index = NULL; zval *index_column = NULL, *column_name = NULL, *index_objects; zval *index_columns = NULL, *name = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { RETURN_MM_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); } PHALCON_OBS_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc); PHALCON_INIT_VAR(indexes); array_init(indexes); if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(index); PHALCON_OBS_NVAR(key_name); phalcon_array_fetch_string(&key_name, index, SL("name"), PH_NOISY_CC); if (!phalcon_array_isset(indexes, key_name)) { PHALCON_INIT_NVAR(empty_arr); array_init(empty_arr); phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(sql_index_describe); PHALCON_CALL_METHOD_PARAMS_1(sql_index_describe, dialect, "describeindex", key_name); PHALCON_INIT_NVAR(describe_index); PHALCON_CALL_METHOD_PARAMS_2(describe_index, this_ptr, "fetchall", sql_index_describe, fetch_assoc); if (!phalcon_is_iterable(describe_index, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(index_column); PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_string(&column_name, index_column, SL("name"), PH_NOISY_CC); phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(index_objects); array_init(index_objects); if (!phalcon_is_iterable(indexes, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_KEY(name, ah2, hp2); PHALCON_GET_FOREACH_VALUE(index_columns); PHALCON_INIT_NVAR(index); object_init_ex(index, phalcon_db_index_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns); phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } RETURN_CTOR(index_objects); }
/** * Lists table references * *<code> * print_r($connection->describeReferences('robots_parts')); *</code> * * @param string $table * @param string $schema * @return Phalcon\Db\Reference[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeReferences){ zval *table, *schema = NULL, *dialect, *fetch_num, *sql, *empty_arr; zval *references, *describe, *reference = NULL, *constraint_name = NULL; zval *referenced_schema = NULL, *referenced_table = NULL; zval *reference_array = NULL, *column_name = NULL, *referenced_columns = NULL; zval *reference_objects, *array_reference = NULL; zval *name = NULL, *columns = NULL, *definition = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { RETURN_MM_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); } PHALCON_OBS_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); /** * We're using FETCH_NUM to fetch the columns */ PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, 3); /** * Get the SQL required to describe the references from the Dialect */ PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema); PHALCON_INIT_VAR(empty_arr); array_init(empty_arr); PHALCON_INIT_VAR(references); array_init(references); /** * Execute the SQL returning the */ PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_num); if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(reference); PHALCON_OBS_NVAR(constraint_name); phalcon_array_fetch_long(&constraint_name, reference, 2, PH_NOISY_CC); if (!phalcon_array_isset(references, constraint_name)) { PHALCON_OBS_NVAR(referenced_schema); phalcon_array_fetch_long(&referenced_schema, reference, 3, PH_NOISY_CC); PHALCON_OBS_NVAR(referenced_table); phalcon_array_fetch_long(&referenced_table, reference, 4, PH_NOISY_CC); PHALCON_INIT_NVAR(reference_array); array_init_size(reference_array, 4); phalcon_array_update_string(&reference_array, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&reference_array, SL("columns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&reference_array, SL("referencedColumns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_zval(&references, constraint_name, &reference_array, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_long(&column_name, reference, 1, PH_NOISY_CC); phalcon_array_update_zval_string_append_multi_3(&references, constraint_name, SL("columns"), &column_name, 0 TSRMLS_CC); PHALCON_OBS_NVAR(referenced_columns); phalcon_array_fetch_long(&referenced_columns, reference, 5, PH_NOISY_CC); phalcon_array_update_zval_string_append_multi_3(&references, constraint_name, SL("referencedColumns"), &referenced_columns, 0 TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(reference_objects); array_init(reference_objects); if (!phalcon_is_iterable(references, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(name, ah1, hp1); PHALCON_GET_FOREACH_VALUE(array_reference); PHALCON_OBS_NVAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC); PHALCON_OBS_NVAR(referenced_table); phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC); PHALCON_OBS_NVAR(columns); phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC); PHALCON_OBS_NVAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC); PHALCON_INIT_NVAR(definition); array_init_size(definition, 4); phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(reference); object_init_ex(reference, phalcon_db_reference_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition); phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } RETURN_CTOR(reference_objects); }
/** * Executes a prepared statement binding. This function uses integer indexes starting from zero * *<code> * $statement = $db->prepare('SELECT * FROM robots WHERE name = :name'); * $result = $connection->executePrepared($statement, array('name' => 'Voltron')); *</code> * * @param \PDOStatement $statement * @param array $placeholders * @param array $dataTypes * @return \PDOStatement */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){ zval *statement = NULL, *placeholders = NULL, *data_types = NULL; zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); if (!phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(wildcard) == IS_LONG) { PHALCON_INIT_NVAR(parameter); phalcon_add_function(parameter, wildcard, one TSRMLS_CC); } else { if (Z_TYPE_P(wildcard) == IS_STRING) { PHALCON_CPY_WRT(parameter, wildcard); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter"); return; } } if (Z_TYPE_P(data_types) == IS_ARRAY) { if (phalcon_array_isset(data_types, wildcard)) { /** * The bind type is double so we try to get the double value */ PHALCON_OBS_NVAR(type); phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC); if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) { PHALCON_INIT_NVAR(cast_value); PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 1024); } else { PHALCON_CPY_WRT(cast_value, value); } /** * 1024 is ignore the bind type */ Z_SET_ISREF_P(cast_value); if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) { PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, cast_value); } else { PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type); } Z_UNSET_ISREF_P(cast_value); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter"); return; } } else { Z_SET_ISREF_P(value); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value); Z_UNSET_ISREF_P(value); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_CALL_METHOD_NORETURN(statement, "execute"); RETURN_CCTOR(statement); }
/** * Lists table indexes * *<code> * print_r($connection->describeIndexes('robots_parts')); *</code> * * @param string $table * @param string $schema * @return Phalcon\Db\Index[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeIndexes){ zval *table, *schema = NULL, *dialect, *fetch_num, *sql, *describe; zval *indexes, *index = NULL, *key_name = NULL, *empty_arr = NULL, *column_name = NULL; zval *index_objects, *index_columns = NULL, *name = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { RETURN_MM_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); } PHALCON_OBS_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); /** * We're using FETCH_NUM to fetch the columns */ PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, 3); /** * Get the SQL required to describe indexes from the Dialect */ PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema); /** * Cryptic Guide: 2: table, 3: from, 4: to */ PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_num); PHALCON_INIT_VAR(indexes); array_init(indexes); if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(index); PHALCON_OBS_NVAR(key_name); phalcon_array_fetch_long(&key_name, index, 2, PH_NOISY_CC); if (!phalcon_array_isset(indexes, key_name)) { PHALCON_INIT_NVAR(empty_arr); array_init(empty_arr); phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_long(&column_name, index, 4, PH_NOISY_CC); phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(index_objects); array_init(index_objects); if (!phalcon_is_iterable(indexes, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(name, ah1, hp1); PHALCON_GET_FOREACH_VALUE(index_columns); /** * Every index is abstracted using a Phalcon\Db\Index instance */ PHALCON_INIT_NVAR(index); object_init_ex(index, phalcon_db_index_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns); phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } RETURN_CTOR(index_objects); }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server don't return any row * * //Inserting data * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')"); * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy')); * * @param string $sqlStatement * @param array $placeholders */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){ zval *sql_statement = NULL, *placeholders = NULL, *events_manager = NULL; zval *status = NULL, *pdo = NULL, *number_placeholders = NULL, *n = NULL, *statement = NULL; zval *value = NULL, *success = NULL, *affected_rows = NULL, *error_info = NULL; zval *error_message = NULL, *exception_message = NULL, *error_code = NULL; zval *exception = NULL; zval *c0 = NULL, *c1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &sql_statement, &placeholders) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!placeholders) { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "db:beforeQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c0, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_INIT_VAR(number_placeholders); phalcon_fast_count(number_placeholders, placeholders TSRMLS_CC); if (zend_is_true(number_placeholders)) { PHALCON_INIT_VAR(n); ZVAL_LONG(n, 1); PHALCON_INIT_VAR(statement); PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK); if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(placeholders); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_7f5d_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_7f5d_1; } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", n, value, PH_NO_CHECK); PHALCON_SEPARATE(n); increment_function(n); zend_hash_move_forward_ex(ah0, &hp0); goto fes_7f5d_1; fee_7f5d_1: PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD(success, statement, "execute", PH_NO_CHECK); PHALCON_INIT_VAR(affected_rows); PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK); } else { PHALCON_INIT_VAR(success); ZVAL_BOOL(success, 1); PHALCON_INIT_VAR(affected_rows); PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK); } if (zend_is_true(success)) { if (Z_TYPE_P(affected_rows) == IS_LONG) { phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC); if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "db:afterQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c1, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_MM_RESTORE(); RETURN_TRUE; } } PHALCON_INIT_VAR(error_info); PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK); PHALCON_INIT_VAR(error_message); phalcon_array_fetch_long(&error_message, error_info, 2, PH_NOISY_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_VSV(exception_message, error_message, " when executing ", sql_statement); PHALCON_INIT_VAR(error_code); phalcon_array_fetch_long(&error_code, error_info, 1, PH_NOISY_CC); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, error_code, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server return rows * * //Querying data * $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'"); * $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical")); * * @param string $sqlStatement * @return Phalcon\Db\Result\Pdo */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, query){ zval *sql_statement = NULL, *events_manager = NULL, *status = NULL; zval *pdo = NULL, *result = NULL, *pdo_result = NULL, *error_info = NULL, *error_message = NULL; zval *exception_message = NULL, *error_code = NULL, *exception = NULL; zval *c0 = NULL, *c1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "db:beforeQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c0, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CALL_METHOD_PARAMS_1(result, pdo, "query", sql_statement, PH_NO_CHECK); if (Z_TYPE_P(result) == IS_OBJECT) { if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "db:afterQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c1, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo_result); object_init_ex(pdo_result, phalcon_db_result_pdo_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_result, "__construct", result, PH_CHECK); RETURN_CTOR(pdo_result); } PHALCON_INIT_VAR(error_info); PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK); PHALCON_INIT_VAR(error_message); phalcon_array_fetch_long(&error_message, error_info, 2, PH_NOISY_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_VSV(exception_message, error_message, " when executing ", sql_statement); PHALCON_INIT_VAR(error_code); phalcon_array_fetch_long(&error_code, error_info, 1, PH_NOISY_CC); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, error_code, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Phalcon\DI\FactoryDefault constructor */ PHP_METHOD(Phalcon_DI_FactoryDefault, __construct){ zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher; zval *url, *models_manager, *models_metadata; zval *response, *request, *filter, *escaper, *flash; zval *flash_session, *session, *session_bag; zval *events_manager, *transaction_manager; zval *services; PHALCON_MM_GROW(); PHALCON_CALL_PARENT_NORETURN(this_ptr, "Phalcon\\DI\\FactoryDefault", "__construct"); PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 1); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "router", 1); PHALCON_INIT_VAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Router", 1); PHALCON_INIT_VAR(router); object_init_ex(router, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(router, "__construct", name, definition, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "dispatcher", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Dispatcher", 1); PHALCON_INIT_VAR(dispatcher); object_init_ex(dispatcher, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(dispatcher, "__construct", name, definition, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "url", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Url", 1); PHALCON_INIT_VAR(url); object_init_ex(url, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(url, "__construct", name, definition, shared, PH_CHECK); /** * Models manager for ORM */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Manager", 1); PHALCON_INIT_VAR(models_manager); object_init_ex(models_manager, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(models_manager, "__construct", name, definition, PH_CHECK); /** * Models meta-data using the Memory adapter */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsMetadata", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Metadata\\Memory", 1); PHALCON_INIT_VAR(models_metadata); object_init_ex(models_metadata, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(models_metadata, "__construct", name, definition, PH_CHECK); /** * Request/Response are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "response", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response", 1); PHALCON_INIT_VAR(response); object_init_ex(response, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(response, "__construct", name, definition, shared, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "request", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Request", 1); PHALCON_INIT_VAR(request); object_init_ex(request, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(request, "__construct", name, definition, shared, PH_CHECK); /** * Filter/Escaper services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "filter", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Filter", 1); PHALCON_INIT_VAR(filter); object_init_ex(filter, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(filter, "__construct", name, definition, shared, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "escaper", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Escaper", 1); PHALCON_INIT_VAR(escaper); object_init_ex(escaper, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(escaper, "__construct", name, definition, shared, PH_CHECK); /** * Flash services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flash", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Direct", 1); PHALCON_INIT_VAR(flash); object_init_ex(flash, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(flash, "__construct", name, definition, shared, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flashSession", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Session", 1); PHALCON_INIT_VAR(flash_session); object_init_ex(flash_session, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(flash_session, "__construct", name, definition, shared, PH_CHECK); /** * Session is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "session", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Adapter\\Files", 1); PHALCON_INIT_VAR(session); object_init_ex(session, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(session, "__construct", name, definition, shared, PH_CHECK); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "sessionBag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Bag", 1); PHALCON_INIT_VAR(session_bag); object_init_ex(session_bag, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(session_bag, "__construct", name, definition, PH_CHECK); /** * Events Manager is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "eventsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Events\\Manager", 1); PHALCON_INIT_VAR(events_manager); object_init_ex(events_manager, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "__construct", name, definition, shared, PH_CHECK); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Transaction\\Manager", 1); PHALCON_INIT_VAR(transaction_manager); object_init_ex(transaction_manager, phalcon_di_service_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(transaction_manager, "__construct", name, definition, PH_CHECK); PHALCON_INIT_VAR(services); array_init(services); phalcon_array_update_string(&services, SL("router"), &router, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("dispatcher"), &dispatcher, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("url"), &url, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("modelsManager"), &models_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("modelsMetadata"), &models_metadata, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("response"), &response, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("request"), &request, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("filter"), &filter, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("escaper"), &escaper, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("flash"), &flash, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("flashSession"), &flash_session, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("session"), &session, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("sessionBag"), &session_bag, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("eventsManager"), &events_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("transactionManager"), &transaction_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_services"), services TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Lists table references * * @param string $table * @param string $schema * @return Phalcon\Db\Reference[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeReferences){ zval *table = NULL, *schema = NULL, *dialect = NULL, *sql = NULL, *references = NULL; zval *describe = NULL, *reference = NULL, *constraint_name = NULL; zval *referenced_schema = NULL, *referenced_table = NULL; zval *column_name = NULL, *referenced_columns = NULL, *reference_objects = NULL; zval *array_reference = NULL, *name = NULL, *columns = NULL, *definition = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *a0 = NULL, *a1 = NULL, *a2 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(references); array_init(references); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_get_class_constant(t0, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, t0, PH_NO_CHECK); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ecef_3: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ecef_3; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(constraint_name); phalcon_array_fetch_string(&constraint_name, reference, SL("constraint_name"), PH_NOISY_CC); eval_int = phalcon_array_isset(references, constraint_name); if (!eval_int) { PHALCON_INIT_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, reference, SL("referenced_table_schema"), PH_NOISY_CC); PHALCON_INIT_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, reference, SL("referenced_table_name"), PH_NOISY_CC); PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_update_string(&a0, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&a0, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(a1); array_init(a1); phalcon_array_update_string(&a0, SL("columns"), &a1, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(a2); array_init(a2); phalcon_array_update_string(&a0, SL("referencedColumns"), &a2, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_zval(&references, constraint_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, reference, SL("column_name"), PH_NOISY_CC); if (Z_TYPE_P(references) == IS_ARRAY) { PHALCON_INIT_VAR(t1); phalcon_array_fetch(&t1, references, constraint_name, PH_SILENT_CC); } if (Z_REFCOUNT_P(t1) > 1) { phalcon_array_update_zval(&references, constraint_name, &t1, PH_COPY | PH_CTOR TSRMLS_CC); } if (Z_TYPE_P(t1) != IS_ARRAY) { convert_to_array(t1); phalcon_array_update_zval(&references, constraint_name, &t1, PH_COPY TSRMLS_CC); } if (Z_TYPE_P(t1) == IS_ARRAY) { PHALCON_INIT_VAR(t2); phalcon_array_fetch_string(&t2, t1, SL("columns"), PH_SILENT_CC); } if (Z_REFCOUNT_P(t2) > 1) { phalcon_array_update_string(&t1, SL("columns"), &t2, PH_COPY | PH_CTOR TSRMLS_CC); } if (Z_TYPE_P(t2) != IS_ARRAY) { convert_to_array(t2); phalcon_array_update_string(&t1, SL("columns"), &t2, PH_COPY TSRMLS_CC); } phalcon_array_append(&t2, column_name, 0 TSRMLS_CC); PHALCON_INIT_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, reference, SL("referenced_column_name"), PH_NOISY_CC); if (Z_TYPE_P(references) == IS_ARRAY) { PHALCON_INIT_VAR(t3); phalcon_array_fetch(&t3, references, constraint_name, PH_SILENT_CC); } if (Z_REFCOUNT_P(t3) > 1) { phalcon_array_update_zval(&references, constraint_name, &t3, PH_COPY | PH_CTOR TSRMLS_CC); } if (Z_TYPE_P(t3) != IS_ARRAY) { convert_to_array(t3); phalcon_array_update_zval(&references, constraint_name, &t3, PH_COPY TSRMLS_CC); } if (Z_TYPE_P(t3) == IS_ARRAY) { PHALCON_INIT_VAR(t4); phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PH_SILENT_CC); } if (Z_REFCOUNT_P(t4) > 1) { phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PH_COPY | PH_CTOR TSRMLS_CC); } if (Z_TYPE_P(t4) != IS_ARRAY) { convert_to_array(t4); phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PH_COPY TSRMLS_CC); } phalcon_array_append(&t4, referenced_columns, 0 TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ecef_3; fee_ecef_3: PHALCON_INIT_VAR(reference_objects); array_init(reference_objects); if (!phalcon_valid_foreach(references TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(references); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_ecef_4: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_ecef_4; } PHALCON_INIT_VAR(name); PHALCON_GET_FOREACH_KEY(name, ah1, hp1); PHALCON_INIT_VAR(array_reference); ZVAL_ZVAL(array_reference, *hd, 1, 0); PHALCON_INIT_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC); PHALCON_INIT_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC); PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC); PHALCON_INIT_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC); PHALCON_INIT_VAR(definition); array_init(definition); phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference); object_init_ex(reference, phalcon_db_reference_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition, PH_CHECK); phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_ecef_4; fee_ecef_4: RETURN_CTOR(reference_objects); }
/** * Makes the work of autoload registered classes * * @param string $className * @return boolean */ PHP_METHOD(Phalcon_Loader, autoLoad){ zval *class_name = NULL, *events_manager = NULL, *classes = NULL; zval *file_path = NULL, *extensions = NULL, *namespaces = NULL, *namespace_separator = NULL; zval *ds = NULL, *directory = NULL, *preffix = NULL, *class_name_len = NULL; zval *preffix_len = NULL, *possible_preffix = NULL, *file_name = NULL; zval *extension = NULL, *path = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL, *c4 = NULL, *c5 = NULL, *c6 = NULL; zval *c7 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *t0 = NULL; HashTable *ah0, *ah1, *ah2, *ah3; HashPosition hp0, hp1, hp2, hp3; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "loader:beforeCheckClass", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c0, this_ptr, PH_NO_CHECK); } PHALCON_INIT_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC); eval_int = phalcon_array_isset(classes, class_name); if (eval_int) { PHALCON_INIT_VAR(file_path); phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c1, this_ptr, PH_NO_CHECK); } if (phalcon_require(file_path TSRMLS_CC) == FAILURE) { return; } PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_INIT_VAR(extensions); phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC); PHALCON_INIT_VAR(namespaces); phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_count(r0, namespaces TSRMLS_CC); if (zend_is_true(r0)) { PHALCON_INIT_VAR(namespace_separator); ZVAL_STRING(namespace_separator, "\\", 1); PHALCON_INIT_VAR(ds); zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC); if (!phalcon_valid_foreach(namespaces TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(namespaces); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_0c08_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_0c08_0; } PHALCON_INIT_VAR(preffix); PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0); PHALCON_INIT_VAR(directory); ZVAL_ZVAL(directory, *hd, 1, 0); PHALCON_INIT_VAR(class_name_len); PHALCON_CALL_FUNC_PARAMS_1(class_name_len, "strlen", class_name); PHALCON_INIT_VAR(preffix_len); PHALCON_CALL_FUNC_PARAMS_1(preffix_len, "strlen", preffix); PHALCON_INIT_VAR(r1); is_smaller_function(r1, preffix_len, class_name_len TSRMLS_CC); if (zend_is_true(r1)) { PHALCON_INIT_VAR(c2); ZVAL_LONG(c2, 0); PHALCON_INIT_VAR(possible_preffix); PHALCON_CALL_FUNC_PARAMS_3(possible_preffix, "substr", class_name, c2, preffix_len); PHALCON_INIT_VAR(r2); is_equal_function(r2, possible_preffix, preffix TSRMLS_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(r3); PHALCON_CONCAT_VV(r3, preffix, namespace_separator); PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, "", 1); PHALCON_INIT_VAR(file_name); phalcon_fast_str_replace(file_name, r3, c3, class_name TSRMLS_CC); if (zend_is_true(file_name)) { if (!phalcon_valid_foreach(extensions TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(extensions); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_0c08_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_0c08_1; } PHALCON_INIT_VAR(extension); ZVAL_ZVAL(extension, *hd, 1, 0); PHALCON_INIT_VAR(r4); PHALCON_CONCAT_VVSV(r4, directory, file_name, ".", extension); PHALCON_INIT_VAR(path); phalcon_fast_str_replace(path, namespace_separator, ds, r4 TSRMLS_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC); PHALCON_INIT_VAR(c4); ZVAL_STRING(c4, "loader:beforeCheckPath", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c4, this_ptr, PH_NO_CHECK); } if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) { if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC); PHALCON_INIT_VAR(c5); ZVAL_STRING(c5, "loader:pathFound", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c5, this_ptr, PH_NO_CHECK); } if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } PHALCON_MM_RESTORE(); RETURN_TRUE; } zend_hash_move_forward_ex(ah1, &hp1); goto fes_0c08_1; fee_0c08_1: if(0){} } } } zend_hash_move_forward_ex(ah0, &hp0); goto fes_0c08_0; fee_0c08_0: if(0){} } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_directories"), PH_NOISY_CC); if (!phalcon_valid_foreach(t0 TSRMLS_CC)) { return; } ah2 = Z_ARRVAL_P(t0); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_0c08_2: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_0c08_2; } PHALCON_INIT_VAR(directory); ZVAL_ZVAL(directory, *hd, 1, 0); if (!phalcon_valid_foreach(extensions TSRMLS_CC)) { return; } ah3 = Z_ARRVAL_P(extensions); zend_hash_internal_pointer_reset_ex(ah3, &hp3); fes_0c08_3: if(zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) != SUCCESS){ goto fee_0c08_3; } PHALCON_INIT_VAR(extension); ZVAL_ZVAL(extension, *hd, 1, 0); PHALCON_INIT_VAR(path); PHALCON_CONCAT_VVSV(path, directory, class_name, ".", extension); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC); PHALCON_INIT_VAR(c6); ZVAL_STRING(c6, "loader:beforeCheckPath", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c6, this_ptr, PH_NO_CHECK); } if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) { if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } PHALCON_MM_RESTORE(); RETURN_TRUE; } zend_hash_move_forward_ex(ah3, &hp3); goto fes_0c08_3; fee_0c08_3: if(0){} zend_hash_move_forward_ex(ah2, &hp2); goto fes_0c08_2; fee_0c08_2: if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c7); ZVAL_STRING(c7, "loader:afterCheckClass", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c7, this_ptr, PH_NO_CHECK); } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){ zval *table = NULL, *schema = NULL, *columns = NULL, *dialect = NULL, *sql = NULL, *describe = NULL; zval *old_column = NULL, *field = NULL, *definition = NULL, *column_type = NULL; zval *pos = NULL, *matches = NULL, *match_one = NULL, *attribute = NULL, *column_name = NULL; zval *column = NULL; zval *t0 = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_get_class_constant(t0, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, t0, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); ZVAL_NULL(old_column); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ecef_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ecef_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(definition); array_init(definition); PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("int") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("varchar") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("date") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("decimal") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("char") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("datetime") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("text") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("float") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("enum") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); } } } } } } } } } PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("(") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { PHALCON_INIT_VAR(matches); array_init(matches); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1); Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(pos); PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", c0, column_type, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(pos)) { eval_int = phalcon_array_isset_long(matches, 1); if (eval_int) { PHALCON_INIT_VAR(match_one); phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } PHALCON_INIT_VAR(pos); phalcon_fast_strpos_str(pos, column_type, SL("unsigned") TSRMLS_CC); if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (!zend_is_true(old_column)) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC); PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ecef_0; fee_ecef_0: RETURN_CTOR(columns); }
/** * Executes render process from dispatching data * *<code> * $view->start(); * //Shows recent posts view (app/views/posts/recent.phtml) * $view->render('posts', 'recent'); * $view->finish(); *</code> * * @param string $controllerName * @param string $actionName * @param array $params */ PHP_METHOD(Phalcon_Mvc_View, render){ zval *controller_name = NULL, *action_name = NULL, *params = NULL; zval *layouts_dir = NULL, *engines = NULL, *pick_view = NULL, *render_view = NULL; zval *render_controller = NULL, *pick_view_action = NULL; zval *cache = NULL, *cache_level = NULL, *events_manager = NULL, *event_name = NULL; zval *status = NULL, *contents = NULL, *must_clean = NULL, *silence = NULL; zval *render_level = NULL, *enter_level = NULL, *templates_before = NULL; zval *template_before = NULL, *view_temp_path = NULL, *templates_after = NULL; zval *template_after = NULL, *main_view = NULL, *is_started = NULL; zval *is_fresh = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &controller_name, &action_name, ¶ms) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!params) { PHALCON_INIT_VAR(params); array_init(params); } PHALCON_INIT_VAR(layouts_dir); phalcon_read_property(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC); if (!zend_is_true(layouts_dir)) { PHALCON_INIT_VAR(layouts_dir); ZVAL_STRING(layouts_dir, "layouts/", 1); } phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); PHALCON_INIT_VAR(engines); PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines", PH_NO_CHECK); PHALCON_INIT_VAR(pick_view); phalcon_read_property(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC); if (Z_TYPE_P(pick_view) == IS_NULL) { PHALCON_INIT_VAR(render_view); PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name); PHALCON_CPY_WRT(render_controller, controller_name); } else { PHALCON_INIT_VAR(render_view); phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC); eval_int = phalcon_array_isset_long(pick_view, 1); if (eval_int) { PHALCON_INIT_VAR(pick_view_action); phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC); PHALCON_CPY_WRT(render_controller, pick_view_action); } else { PHALCON_CPY_WRT(render_controller, controller_name); } } PHALCON_INIT_VAR(cache); ZVAL_NULL(cache); PHALCON_INIT_VAR(cache_level); phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC); if (zend_is_true(cache_level)) { PHALCON_INIT_VAR(cache); PHALCON_CALL_METHOD(cache, this_ptr, "getcache", PH_NO_CHECK); } PHALCON_INIT_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, "view:beforeRender", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_zval(this_ptr, SL("_content"), contents TSRMLS_CC); PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 1); PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); PHALCON_INIT_VAR(render_level); phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC); if (zend_is_true(render_level)) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC); if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) { PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache, PH_NO_CHECK); } PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 2); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC); if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) { PHALCON_INIT_VAR(templates_before); phalcon_read_property(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC); if (Z_TYPE_P(templates_before) == IS_ARRAY) { PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 0); if (!phalcon_valid_foreach(templates_before TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(templates_before); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ecde_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ecde_2; } PHALCON_INIT_VAR(template_before); ZVAL_ZVAL(template_before, *hd, 1, 0); PHALCON_INIT_VAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ecde_2; fee_ecde_2: PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); } } PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 3); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC); if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) { PHALCON_INIT_VAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, render_controller); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); } PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 4); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC); if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) { PHALCON_INIT_VAR(templates_after); phalcon_read_property(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC); if (Z_TYPE_P(templates_after) == IS_ARRAY) { PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 0); if (!phalcon_valid_foreach(templates_after TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(templates_after); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_ecde_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_ecde_3; } PHALCON_INIT_VAR(template_after); ZVAL_ZVAL(template_after, *hd, 1, 0); PHALCON_INIT_VAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache, PH_NO_CHECK); zend_hash_move_forward_ex(ah1, &hp1); goto fes_ecde_3; fee_ecde_3: PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); } } PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 5); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC); if (Z_TYPE_P(enter_level) == IS_BOOL && Z_BVAL_P(enter_level)) { PHALCON_INIT_VAR(main_view); phalcon_read_property(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache, PH_NO_CHECK); } if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_VAR(is_started); PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK); if (zend_is_true(is_started)) { PHALCON_INIT_VAR(is_fresh); PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK); if (zend_is_true(is_fresh)) { PHALCON_CALL_METHOD_NORETURN(cache, "save", PH_NO_CHECK); } } } } if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "view:afterRender", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr, PH_NO_CHECK); } 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_sufix, *scope = NULL, *prefix = NULL; zval *dependency_injector = NULL, *service = NULL, *handler = NULL; zval *sufixed = NULL, *handler_annotations = NULL, *class_annotations = NULL; zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL; zval *lowercased = NULL, *collection = NULL, *method = NULL; HashTable *ah0, *ah1, *ah2, *ah3; HashPosition hp0, hp1, hp2, hp3; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { RETURN_MM_NULL(); } if (!uri) { PHALCON_INIT_VAR(uri); } if (!zend_is_true(uri)) { /** * If 'uri' isn't passed as parameter it reads $_GET['_url'] */ PHALCON_INIT_VAR(real_uri); PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri"); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_OBS_VAR(processed); phalcon_read_property(&processed, this_ptr, SL("_processed"), PH_NOISY_CC); if (!zend_is_true(processed)) { PHALCON_INIT_VAR(annotations_service); PHALCON_OBS_VAR(handlers); phalcon_read_property(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC); PHALCON_OBS_VAR(controller_sufix); phalcon_read_property(&controller_sufix, this_ptr, SL("_controllerSufix"), PH_NOISY_CC); if (!phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(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_CC); 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(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_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_INIT_NVAR(annotations_service); PHALCON_CALL_METHOD_PARAMS_1(annotations_service, dependency_injector, "getshared", service); } /** * The controller must be in position 1 */ PHALCON_OBS_NVAR(handler); phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY_CC); phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC); PHALCON_INIT_NVAR(sufixed); PHALCON_CONCAT_VV(sufixed, handler, controller_sufix); PHALCON_INIT_NVAR(handler_annotations); PHALCON_CALL_METHOD_PARAMS_1(handler_annotations, annotations_service, "get", sufixed); /** * Process class annotations */ PHALCON_INIT_NVAR(class_annotations); PHALCON_CALL_METHOD(class_annotations, handler_annotations, "getclassannotations"); if (Z_TYPE_P(class_annotations) == IS_OBJECT) { PHALCON_INIT_NVAR(annotations); PHALCON_CALL_METHOD(annotations, class_annotations, "getannotations"); if (Z_TYPE_P(annotations) == IS_ARRAY) { if (!phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(annotation); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "processcontrollerannotation", handler, annotation); zend_hash_move_forward_ex(ah1, &hp1); } } } /** * Process method annotations */ PHALCON_INIT_NVAR(method_annotations); PHALCON_CALL_METHOD(method_annotations, handler_annotations, "getmethodsannotations"); if (Z_TYPE_P(method_annotations) == IS_ARRAY) { PHALCON_INIT_NVAR(lowercased); phalcon_fast_strtolower(lowercased, handler); if (!phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_KEY(method, ah2, hp2); PHALCON_GET_FOREACH_VALUE(collection); if (Z_TYPE_P(collection) == IS_OBJECT) { PHALCON_INIT_NVAR(annotations); PHALCON_CALL_METHOD(annotations, collection, "getannotations"); if (!phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(annotation); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "processactionannotation", lowercased, 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_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Mvc\\Router\\Annotations", "handle", real_uri); PHALCON_MM_RESTORE(); }
/** * Executes a prepared statement binding * * @param PDOStatement $statement * @param array $placeholders * @param array $dataTypes * @return PDOStatement */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, _executePrepared){ zval *statement = NULL, *placeholders = NULL, *data_types = NULL; zval *one = NULL, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(placeholders); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_INIT_VAR(wildcard); PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(wildcard) == IS_LONG) { PHALCON_INIT_VAR(parameter); phalcon_add_function(parameter, wildcard, one TSRMLS_CC); } else { if (Z_TYPE_P(wildcard) == IS_STRING) { PHALCON_CPY_WRT(parameter, wildcard); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter"); return; } } if (Z_TYPE_P(data_types) == IS_ARRAY) { eval_int = phalcon_array_isset(data_types, wildcard); if (eval_int) { PHALCON_INIT_VAR(type); phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC); if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) { PHALCON_INIT_VAR(cast_value); PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value); PHALCON_INIT_VAR(type); ZVAL_LONG(type, 2); } else { PHALCON_CPY_WRT(cast_value, value); } Z_SET_ISREF_P(cast_value); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type, PH_NO_CHECK); Z_UNSET_ISREF_P(cast_value); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter"); return; } } else { PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value, PH_NO_CHECK); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_CALL_METHOD_NORETURN(statement, "execute", PH_NO_CHECK); RETURN_CCTOR(statement);}
/** * Checks for annotations in the public methods of the controller * * @param string $controller * @param string $action * @param Phalcon\Annotations\Annotation $annotation */ PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation){ zval *controller, *action, *annotation, *is_route = NULL; zval *methods = NULL, *name, *action_sufix, *empty_str; zval *real_action_name, *action_name, *route_prefix; zval *parameter = NULL, *paths = NULL, *position, *value, *uri = NULL, *route; zval *converts, *convert = NULL, *param = NULL, *route_name; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &controller, &action, &annotation) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(is_route); ZVAL_BOOL(is_route, 0); PHALCON_INIT_VAR(methods); PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, annotation, "getname"); /** * Find if the route is for adding routes */ if (PHALCON_IS_STRING(name, "Route")) { ZVAL_BOOL(is_route, 1); } else { if (PHALCON_IS_STRING(name, "Get")) { ZVAL_BOOL(is_route, 1); ZVAL_STRING(methods, "GET", 1); } else { if (PHALCON_IS_STRING(name, "Post")) { ZVAL_BOOL(is_route, 1); PHALCON_INIT_NVAR(methods); ZVAL_STRING(methods, "POST", 1); } else { if (PHALCON_IS_STRING(name, "Put")) { ZVAL_BOOL(is_route, 1); PHALCON_INIT_NVAR(methods); ZVAL_STRING(methods, "PUT", 1); } else { if (PHALCON_IS_STRING(name, "Options")) { ZVAL_BOOL(is_route, 1); PHALCON_INIT_NVAR(methods); ZVAL_STRING(methods, "OPTIONS", 1); } } } } } if (PHALCON_IS_TRUE(is_route)) { PHALCON_OBS_VAR(action_sufix); phalcon_read_property(&action_sufix, this_ptr, SL("_actionSufix"), PH_NOISY_CC); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(real_action_name); phalcon_fast_str_replace(real_action_name, action_sufix, empty_str, action TSRMLS_CC); PHALCON_INIT_VAR(action_name); phalcon_fast_strtolower(action_name, real_action_name); PHALCON_OBS_VAR(route_prefix); phalcon_read_property(&route_prefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC); PHALCON_INIT_VAR(parameter); ZVAL_STRING(parameter, "paths", 1); /** * Check for existing paths in the annotation */ PHALCON_INIT_VAR(paths); PHALCON_CALL_METHOD_PARAMS_1(paths, annotation, "getnamedparameter", parameter); if (Z_TYPE_P(paths) != IS_ARRAY) { PHALCON_INIT_NVAR(paths); array_init(paths); } phalcon_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&paths, SL("action"), &action_name, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(position); ZVAL_LONG(position, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, annotation, "getargument", position); /** * Create the route using the prefix */ if (Z_TYPE_P(value) != IS_NULL) { if (!PHALCON_IS_STRING(value, "/")) { PHALCON_INIT_VAR(uri); PHALCON_CONCAT_VV(uri, route_prefix, value); } else { PHALCON_CPY_WRT(uri, route_prefix); } } else { PHALCON_INIT_NVAR(uri); PHALCON_CONCAT_VV(uri, route_prefix, action_name); } /** * Add the route to the router */ PHALCON_INIT_VAR(route); PHALCON_CALL_METHOD_PARAMS_2(route, this_ptr, "add", uri, paths); if (Z_TYPE_P(methods) == IS_NULL) { PHALCON_INIT_NVAR(parameter); ZVAL_STRING(parameter, "methods", 1); PHALCON_INIT_NVAR(methods); PHALCON_CALL_METHOD_PARAMS_1(methods, annotation, "getnamedparameter", parameter); if (Z_TYPE_P(methods) == IS_ARRAY) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods); } else { if (Z_TYPE_P(methods) == IS_STRING) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods); } } } else { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods); } PHALCON_INIT_NVAR(parameter); ZVAL_STRING(parameter, "converts", 1); PHALCON_INIT_VAR(converts); PHALCON_CALL_METHOD_PARAMS_1(converts, annotation, "getnamedparameter", parameter); if (Z_TYPE_P(converts) == IS_ARRAY) { if (!phalcon_is_iterable(converts, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(param, ah0, hp0); PHALCON_GET_FOREACH_VALUE(convert); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(route, "convert", param, convert); zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_INIT_NVAR(parameter); ZVAL_STRING(parameter, "name", 1); PHALCON_INIT_VAR(route_name); PHALCON_CALL_METHOD_PARAMS_1(route_name, annotation, "getnamedparameter", parameter); if (Z_TYPE_P(route_name) == IS_STRING) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "setname", route_name); } RETURN_MM_TRUE; } PHALCON_MM_RESTORE(); }
/** * Check whether a role is allowed to access an action from a resource * * <code> * //Does andres have access to the customers resource to create? * $acl->isAllowed('andres', 'Products', 'create'); * * //Do guests have access to any resource to edit? * $acl->isAllowed('guests', '*', 'edit'); * </code> * * @param string $role * @param string $resource * @param string $access * @return boolean */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed){ zval *role, *resource, *access, *events_manager; zval *event_name = NULL, *status, *default_access, *roles_names; zval *have_access = NULL, *access_roles, *resource_access = NULL; zval *resource_name = NULL; zval *t0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &role, &resource, &access) == FAILURE) { RETURN_MM_NULL(); } phalcon_update_property_zval(this_ptr, SL("_activeRole"), role TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_activeResource"), resource TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_activeAccess"), access TSRMLS_CC); 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, "acl:beforeCheckAccess", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } PHALCON_OBS_VAR(default_access); phalcon_read_property(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC); /** * Check if the role exists */ PHALCON_OBS_VAR(roles_names); phalcon_read_property(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC); if (!phalcon_array_isset(roles_names, role)) { RETURN_CCTOR(default_access); } PHALCON_INIT_VAR(have_access); PHALCON_OBS_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_access"), PH_NOISY_CC); PHALCON_OBS_VAR(access_roles); phalcon_array_fetch(&access_roles, t0, role, PH_NOISY_CC); if (!phalcon_is_iterable(access_roles, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(resource_name, ah0, hp0); PHALCON_GET_FOREACH_VALUE(resource_access); if (PHALCON_IS_EQUAL(resource_name, resource)) { if (phalcon_array_isset(resource_access, access)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, resource_access, access, PH_NOISY_CC); break; } PHALCON_OBS_NVAR(have_access); phalcon_array_fetch_string(&have_access, resource_access, SL("*"), PH_NOISY_CC); break; } zend_hash_move_forward_ex(ah0, &hp0); } if (Z_TYPE_P(have_access) == IS_NULL) { if (!phalcon_is_iterable(access_roles, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(resource_name, ah1, hp1); PHALCON_GET_FOREACH_VALUE(resource_access); if (phalcon_array_isset_string(resource_access, SS("*"))) { if (phalcon_array_isset(resource_access, access)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, resource_access, access, PH_NOISY_CC); break; } PHALCON_OBS_NVAR(have_access); phalcon_array_fetch_string(&have_access, resource_access, SL("*"), PH_NOISY_CC); break; } zend_hash_move_forward_ex(ah1, &hp1); } } phalcon_update_property_zval(this_ptr, SL("_accessGranted"), have_access TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "acl:afterCheckAccess", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_MM_RESTORE(); RETURN_LONG(0); } RETURN_CCTOR(have_access); }
/** * Dispatches a controller action taking into account the routing parameters * * @param Phalcon_Request $request * @param Phalcon_Response $response * @param Phalcon_View $view * @param Phalcon_Model_Manager $model * @return Phalcon_Controller */ PHP_METHOD(Phalcon_Dispatcher, dispatch){ zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL; zval *value = NULL, *controller = NULL, *number_dispatches = NULL; zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL; zval *controller_path = NULL, *params = NULL, *action_name = NULL; zval *action_method = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL; zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *i0 = NULL; zval *a0 = NULL, *a1 = NULL; zval *p5[] = { NULL, NULL, NULL, NULL, NULL }; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!view) { PHALCON_INIT_VAR(view); ZVAL_NULL(view); } if (!model) { PHALCON_INIT_VAR(model); ZVAL_NULL(model); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_basePath", sizeof("_basePath")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_controllersDir", sizeof("_controllersDir")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CONCAT_VV(r0, t0, t1); PHALCON_CPY_WRT(controllers_dir, r0); PHALCON_INIT_VAR(value); ZVAL_NULL(value); PHALCON_INIT_VAR(controller); ZVAL_NULL(controller); PHALCON_INIT_VAR(number_dispatches); ZVAL_LONG(number_dispatches, 0); phalcon_update_property_bool(this_ptr, "_finished", strlen("_finished"), 0 TSRMLS_CC); ws_e10f_0: PHALCON_INIT_VAR(t2); phalcon_read_property(&t2, this_ptr, "_finished", sizeof("_finished")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t2)) { goto we_e10f_0; } phalcon_update_property_bool(this_ptr, "_finished", strlen("_finished"), 1 TSRMLS_CC); PHALCON_INIT_VAR(t3); phalcon_read_property(&t3, this_ptr, "_controllerName", sizeof("_controllerName")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller_name, t3); if (!zend_is_true(controller_name)) { PHALCON_INIT_VAR(t4); phalcon_read_property(&t4, this_ptr, "_defaultController", sizeof("_defaultController")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller_name, t4); phalcon_update_property_zval(this_ptr, "_controllerName", strlen("_controllerName"), controller_name TSRMLS_CC); } PHALCON_INIT_VAR(t5); phalcon_read_property(&t5, this_ptr, "_controllers", sizeof("_controllers")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controllers, t5); PHALCON_INIT_VAR(r1); PHALCON_INIT_VAR(r2); PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name); PHALCON_CONCAT_VS(r1, r2, "Controller"); PHALCON_CPY_WRT(controller_class, r1); eval_int = phalcon_array_isset(controllers, controller_class); if (!eval_int) { PHALCON_INIT_VAR(r3); PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 0); PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0, 0x012); if (!zend_is_true(r3)) { PHALCON_INIT_VAR(r4); PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php"); PHALCON_CPY_WRT(controller_path, r4); if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) { if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) { return; } } else { PHALCON_INIT_VAR(r5); PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK); } PHALCON_INIT_VAR(r6); PHALCON_INIT_VAR(c1); ZVAL_BOOL(c1, 0); PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1, 0x012); if (!zend_is_true(r6)) { PHALCON_INIT_VAR(r7); PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK); } } ce0 = phalcon_fetch_class(controller_class TSRMLS_CC); PHALCON_INIT_VAR(i0); object_init_ex(i0, ce0); p5[0] = this_ptr; p5[1] = request; p5[2] = response; p5[3] = view; p5[4] = model; PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p5, PHALCON_CHECK); PHALCON_CPY_WRT(controller, i0); if (phalcon_method_exists_ex(controller, "initialize", strlen("initialize") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK); } PHALCON_INIT_VAR(t6); phalcon_read_property(&t6, this_ptr, "_controllers", sizeof("_controllers")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_controllers", strlen("_controllers"), t6 TSRMLS_CC); } else { PHALCON_INIT_VAR(r8); phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller, r8); } PHALCON_INIT_VAR(t7); phalcon_read_property(&t7, this_ptr, "_params", sizeof("_params")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(params, t7); PHALCON_INIT_VAR(t8); phalcon_read_property(&t8, this_ptr, "_actionName", sizeof("_actionName")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(action_name, t8); if (!zend_is_true(action_name)) { PHALCON_INIT_VAR(t9); phalcon_read_property(&t9, this_ptr, "_defaultAction", sizeof("_defaultAction")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(action_name, t9); phalcon_update_property_zval(this_ptr, "_actionName", strlen("_actionName"), action_name TSRMLS_CC); } if (phalcon_method_exists_ex(controller, "beforedispatch", strlen("beforedispatch") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(r9); PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK); if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) { PHALCON_INIT_VAR(value); ZVAL_BOOL(value, 0); goto we_e10f_0; } } PHALCON_INIT_VAR(r10); PHALCON_CONCAT_VS(r10, action_name, "Action"); PHALCON_CPY_WRT(action_method, r10); if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(r11); PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC); phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_2(r11, "call_user_func_array", a0, params, 0x013); PHALCON_CPY_WRT(value, r11); } else { if (phalcon_method_exists_ex(controller, "notfoundaction", strlen("notfoundaction") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(r12); PHALCON_INIT_VAR(a1); array_init(a1); phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC); add_next_index_stringl(a1, "notFoundAction", strlen("notFoundAction"), 1); PHALCON_CALL_FUNC_PARAMS_2(r12, "call_user_func_array", a1, params, 0x013); PHALCON_CPY_WRT(value, r12); } else { PHALCON_INIT_VAR(r13); PHALCON_CONCAT_SVSVS(r13, "Action '", action_name, "' was not found on controller '", controller_name, "'"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r13, PHALCON_NO_CHECK); } } if (phalcon_method_exists_ex(controller, "afterdispatch", strlen("afterdispatch") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK); } PHALCON_SEPARATE(number_dispatches); increment_function(number_dispatches); PHALCON_INIT_VAR(t10); ZVAL_LONG(t10, 256); PHALCON_INIT_VAR(r14); is_smaller_function(r14, t10, number_dispatches TSRMLS_CC); if (zend_is_true(r14)) { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK); } goto ws_e10f_0; we_e10f_0: phalcon_update_property_zval(this_ptr, "_returnedValue", strlen("_returnedValue"), value TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_lastController", strlen("_lastController"), controller TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(controller); }
/** * Fires a event in the events manager causing that the acive listeners will be notified about it * * @param string $eventType * @param object $source * @return mixed */ PHP_METHOD(Phalcon_Events_Manager, fire){ zval *event_type = NULL, *source = NULL, *colon = NULL, *event_parts = NULL; zval *exception_message = NULL, *exception = NULL, *type = NULL, *event_name = NULL; zval *status = NULL, *events = NULL, *fire_events = NULL, *handler = NULL, *event = NULL; zval *class_name = NULL, *arguments = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_type, &source) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(colon); ZVAL_STRING(colon, ":", 1); PHALCON_INIT_VAR(event_parts); phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC); eval_int = phalcon_array_isset_long(event_parts, 1); if (!eval_int) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_events_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(type); phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(event_name); phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(status); ZVAL_NULL(status); PHALCON_INIT_VAR(events); phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC); eval_int = phalcon_array_isset(events, type); if (eval_int) { PHALCON_INIT_VAR(fire_events); phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC); if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { PHALCON_INIT_VAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(event, "__construct", event_name, source, PH_CHECK); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, handler TSRMLS_CC); if (PHALCON_COMPARE_STRING(class_name, "Closure")) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(status); PHALCON_CALL_FUNC_PARAMS_2(status, "call_user_func_array", handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, handler, Z_STRVAL_P(event_name), event, source, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0){} } RETURN_CCTOR(status); }
/** * Lists table references * * @param string $table * @param string $schema * @return Phalcon\Db\Reference[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences){ zval *table, *schema = NULL, *dialect, *sql, *fetch_assoc; zval *describe, *reference_objects, *reference_describe = NULL; zval *number = NULL, *constraint_name = NULL, *referenced_table = NULL; zval *from = NULL, *to = NULL, *columns = NULL, *referenced_columns = NULL; zval *reference_array = NULL, *reference = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_INIT_NVAR(schema); } PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(reference_objects); array_init(reference_objects); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_KEY(number, ah0, hp0); PHALCON_GET_FOREACH_VALUE(reference_describe); PHALCON_INIT_NVAR(constraint_name); PHALCON_CONCAT_SV(constraint_name, "foreign_key_", number); PHALCON_INIT_NVAR(referenced_table); phalcon_array_fetch_string(&referenced_table, reference_describe, SL("table"), PH_NOISY_CC); PHALCON_INIT_NVAR(from); phalcon_array_fetch_string(&from, reference_describe, SL("from"), PH_NOISY_CC); PHALCON_INIT_NVAR(to); phalcon_array_fetch_string(&to, reference_describe, SL("to"), PH_NOISY_CC); PHALCON_INIT_NVAR(columns); array_init(columns); phalcon_array_append(&columns, from, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(referenced_columns); array_init(referenced_columns); phalcon_array_append(&referenced_columns, to, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(reference_array); array_init(reference_array); add_assoc_null_ex(reference_array, SS("referencedSchema")); phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&reference_array, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&reference_array, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(reference); object_init_ex(reference, phalcon_db_reference_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", constraint_name, reference_array, PH_CHECK); phalcon_array_update_zval(&reference_objects, constraint_name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(reference_objects); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\ModelInterface $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize){ zval *model, *key, *table, *schema, *strategy = NULL, *class_name; zval *meta_data = NULL, *prefix_key = NULL, *data = NULL, *model_metadata = NULL; zval *exception_message, *dependency_injector = NULL; zval *key_name, *column_map = NULL, *model_column_map; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(strategy); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model, 0 TSRMLS_CC); if (Z_TYPE_P(key) != IS_NULL) { PHALCON_OBS_VAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); if (!phalcon_array_isset(meta_data, key)) { PHALCON_INIT_VAR(prefix_key); PHALCON_CONCAT_SV(prefix_key, "meta-", key); /** * The meta-data is read from the adapter always */ PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", prefix_key); if (Z_TYPE_P(data) != IS_NULL) { if (Z_TYPE_P(meta_data) != IS_ARRAY) { PHALCON_INIT_NVAR(meta_data); array_init(meta_data); } phalcon_array_update_zval(&meta_data, key, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC); } else { /** * Check if there is a method 'metaData' in the model to retrieve meta-data from it */ if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(model_metadata); PHALCON_CALL_METHOD(model_metadata, model, "metadata"); if (Z_TYPE_P(model_metadata) != IS_ARRAY) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_OBS_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); /** * Get the meta-data extraction strategy */ PHALCON_CALL_METHOD(strategy, this_ptr, "getstrategy"); /** * Get the meta-data */ PHALCON_INIT_NVAR(model_metadata); PHALCON_CALL_METHOD_PARAMS_2(model_metadata, strategy, "getmetadata", model, dependency_injector); } /** * Store the meta-data locally */ phalcon_update_property_array(this_ptr, SL("_metaData"), key, model_metadata TSRMLS_CC); /** * Store the meta-data in the adapter */ PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", prefix_key, model_metadata); } } } /** * Check for a column map, store in _columnMap in order and reversed order */ if (!PHALCON_GLOBAL(orm).column_renaming) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(key_name); phalcon_fast_strtolower(key_name, class_name); PHALCON_OBS_VAR(column_map); phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC); if (phalcon_array_isset(column_map, key_name)) { RETURN_MM_NULL(); } if (Z_TYPE_P(column_map) != IS_ARRAY) { PHALCON_INIT_NVAR(column_map); array_init(column_map); } /** * Create the map key name */ PHALCON_INIT_NVAR(prefix_key); PHALCON_CONCAT_SV(prefix_key, "map-", key_name); /** * Check if the meta-data is already in the adapter */ PHALCON_INIT_NVAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", prefix_key); if (Z_TYPE_P(data) != IS_NULL) { phalcon_array_update_zval(&column_map, key_name, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_columnMap"), column_map TSRMLS_CC); RETURN_MM_NULL(); } /** * Get the meta-data extraction strategy */ if (Z_TYPE_P(strategy) != IS_OBJECT) { PHALCON_OBS_NVAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); PHALCON_INIT_NVAR(strategy); PHALCON_CALL_METHOD(strategy, this_ptr, "getstrategy"); } /** * Get the meta-data */ PHALCON_INIT_VAR(model_column_map); PHALCON_CALL_METHOD_PARAMS_2(model_column_map, strategy, "getcolumnmaps", model, dependency_injector); /** * Update the column map locally */ phalcon_update_property_array(this_ptr, SL("_columnMap"), key_name, model_column_map TSRMLS_CC); /** * Write the data to the adapter */ PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", prefix_key, model_column_map); PHALCON_MM_RESTORE(); }
/** * Restore a Phalcon_Db_Reference object from export * * @param array $data * @return Phalcon_Db_Reference */ PHP_METHOD(Phalcon_Db_Reference, __set_state){ zval *data = NULL, *constraint_name = NULL, *referenced_schema = NULL; zval *referenced_table = NULL, *columns = NULL, *referenced_columns = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *i0 = NULL; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } eval_int = phalcon_array_isset_string(data, "_referenceName", strlen("_referenceName")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "_referenceName parameter is required"); return; } else { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, data, "_referenceName", strlen("_referenceName"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(constraint_name, r0); } eval_int = phalcon_array_isset_string(data, "_referencedSchema", strlen("_referencedSchema")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, data, "_referencedSchema", strlen("_referencedSchema"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(referenced_schema, r1); } else { PHALCON_INIT_VAR(referenced_schema); ZVAL_NULL(referenced_schema); } eval_int = phalcon_array_isset_string(data, "_referencedTable", strlen("_referencedTable")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, data, "_referencedTable", strlen("_referencedTable"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(referenced_table, r2); } else { PHALCON_INIT_VAR(referenced_table); ZVAL_NULL(referenced_table); } eval_int = phalcon_array_isset_string(data, "_columns", strlen("_columns")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, data, "_columns", strlen("_columns"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(columns, r3); } else { PHALCON_INIT_VAR(columns); ZVAL_NULL(columns); } eval_int = phalcon_array_isset_string(data, "_referencedColumns", strlen("_referencedColumns")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, data, "_referencedColumns", strlen("_referencedColumns"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(referenced_columns, r4); } else { PHALCON_INIT_VAR(referenced_columns); ZVAL_NULL(referenced_columns); } PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_db_reference_ce); PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_update_string(&a0, "referencedSchema", strlen("referencedSchema"), &referenced_schema, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_string(&a0, "referencedTable", strlen("referencedTable"), &referenced_table, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_string(&a0, "columns", strlen("columns"), &columns, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_string(&a0, "referencedColumns", strlen("referencedColumns"), &referenced_columns, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", constraint_name, a0, PHALCON_CHECK); PHALCON_RETURN_CTOR(i0); }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) { zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL; zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL; zval *char_size = NULL, *numeric_size = NULL, *column_type = NULL; zval *status = NULL, *attribute = NULL, *column_name = NULL, *column = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, t0, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); ZVAL_NULL(old_column); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_VAR(definition); array_init(definition); PHALCON_INIT_VAR(char_size); phalcon_array_fetch_string(&char_size, field, SL("size"), PH_NOISY_CC); PHALCON_INIT_VAR(numeric_size); phalcon_array_fetch_string(&numeric_size, field, SL("numericsize"), PH_NOISY_CC); PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("varying") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } } } } } } } PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (Z_TYPE_P(old_column) == IS_NULL) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC); PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(columns); }
/** * Throws an internal exception * * @param string $message * @param int $exceptionCode */ PHP_METHOD(Phalcon_Mvc_Dispatcher, _throwDispatchException){ zval *message, *exception_code = NULL, *dependency_injector; zval *exception_message, *exception = NULL, *service; zval *response, *status_code, *status_message; zval *events_manager, *event_name, *status; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &exception_code) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!exception_code) { PHALCON_INIT_NVAR(exception_code); ZVAL_LONG(exception_code, 0); } else { PHALCON_SEPARATE_PARAM(exception_code); } 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_INIT_NVAR(exception_code); ZVAL_LONG(exception_code, 0); PHALCON_INIT_VAR(exception_message); ZVAL_STRING(exception_message, "A dependency injection container is required to access the 'response' service", 1); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, exception_code, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "response", 1); PHALCON_INIT_VAR(response); PHALCON_CALL_METHOD_PARAMS_1(response, dependency_injector, "getshared", service, PH_NO_CHECK); PHALCON_INIT_VAR(status_code); ZVAL_LONG(status_code, 404); PHALCON_INIT_VAR(status_message); ZVAL_STRING(status_message, "Not Found", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(response, "setstatuscode", status_code, status_message, PH_NO_CHECK); PHALCON_INIT_NVAR(exception); object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", message, exception_code, PH_CHECK); PHALCON_INIT_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, PH_NO_CHECK); if (PHALCON_IS_FALSE(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } phalcon_throw_exception(exception TSRMLS_CC); return; }