/** * Returns attributes and their bind data types * * @param Phalcon\Mvc\ModelInterface $model * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, getBindTypes){ zval *model, *index, *data; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(index); ZVAL_LONG(index, 9); PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_2(data, this_ptr, "readmetadataindex", model, index, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The meta-data is invalid or is corrupted"); return; } RETURN_CCTOR(data); }
/** * Generates SQL to delete primary key from a table * * @param string $tableName * @param string $schemaName * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, dropPrimaryKey){ zval *table_name = NULL, *schema_name = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &table_name, &schema_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (zend_is_true(schema_name)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE ", schema_name, ".", table_name, " DROP PRIMARY KEY"); PHALCON_CPY_WRT(sql, r0); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "ALTER TABLE ", table_name, " DROP PRIMARY KEY"); PHALCON_CPY_WRT(sql, r1); } RETURN_CTOR(sql); }
/** * 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, *cookies, *request, *filter, *escaper; zval *annotations, *security, *crypt, *flash, *flash_session; zval *tag, *session, *session_bag, *events_manager; zval *transaction_manager, *assets, *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_p3_noret(router, "__construct", name, definition, shared); 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_p3_noret(dispatcher, "__construct", name, definition, shared); 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_p3_noret(url, "__construct", name, definition, shared); /** * 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_p3_noret(models_manager, "__construct", name, definition, shared); /** * 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_p3_noret(models_metadata, "__construct", name, definition, shared); /** * 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_p3_noret(response, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "cookies", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response\\Cookies", 1); PHALCON_INIT_VAR(cookies); object_init_ex(cookies, phalcon_di_service_ce); phalcon_call_method_p3_noret(cookies, "__construct", name, definition, shared); 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_p3_noret(request, "__construct", name, definition, shared); /** * 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_p3_noret(filter, "__construct", name, definition, shared); 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_p3_noret(escaper, "__construct", name, definition, shared); /** * Default annotations service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "annotations", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Annotations\\Adapter\\Memory", 1); PHALCON_INIT_VAR(annotations); object_init_ex(annotations, phalcon_di_service_ce); phalcon_call_method_p3_noret(annotations, "__construct", name, definition, shared); /** * Security doesn't need to be shared, but anyways we register it as shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "security", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Security", 1); PHALCON_INIT_VAR(security); object_init_ex(security, phalcon_di_service_ce); phalcon_call_method_p3_noret(security, "__construct", name, definition, shared); /** * Crypt Service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "crypt", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Crypt", 1); PHALCON_INIT_VAR(crypt); object_init_ex(crypt, phalcon_di_service_ce); phalcon_call_method_p3_noret(crypt, "__construct", name, definition, shared); /** * 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_p3_noret(flash, "__construct", name, definition, shared); 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_p3_noret(flash_session, "__construct", name, definition, shared); /** * Tag/Helpers */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "tag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Tag", 1); PHALCON_INIT_VAR(tag); object_init_ex(tag, phalcon_di_service_ce); phalcon_call_method_p3_noret(tag, "__construct", name, definition, shared); /** * 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_p3_noret(session, "__construct", name, definition, shared); 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_p2_noret(session_bag, "__construct", name, definition); /** * 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_p3_noret(events_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "transactions", 1); 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_p3_noret(transaction_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "assets", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Assets\\Manager", 1); PHALCON_INIT_VAR(assets); object_init_ex(assets, phalcon_di_service_ce); phalcon_call_method_p3_noret(assets, "__construct", name, definition, shared); /** * Register services */ PHALCON_INIT_VAR(services); array_init_size(services, 21); phalcon_array_update_string(&services, SL("router"), &router, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("dispatcher"), &dispatcher, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("url"), &url, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsManager"), &models_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsMetadata"), &models_metadata, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("response"), &response, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("cookies"), &cookies, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("request"), &request, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("filter"), &filter, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("escaper"), &escaper, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("security"), &security, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("crypt"), &crypt, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("annotations"), &annotations, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flash"), &flash, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flashSession"), &flash_session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("tag"), &tag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("session"), &session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("sessionBag"), &session_bag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("eventsManager"), &events_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("transactionManager"), &transaction_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("assets"), &assets, PH_COPY | PH_SEPARATE); /** * Update the internal services properties */ phalcon_update_property_this(this_ptr, SL("_services"), services TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\Model $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){ zval *model, *key, *table, *schema, *meta_data, *data; zval *table_metadata = NULL, *class_name = NULL, *exception_message = NULL; zval *connection, *exists, *complete_table = NULL, *attributes; zval *primary_keys, *non_primary_keys, *numeric_typed; zval *not_null, *field_types, *field_bind_types; zval *automatic_default, *identity_field = NULL; zval *columns, *column = NULL, *field_name = NULL, *feature = NULL, *type = NULL; zval *bind_type = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); eval_int = phalcon_array_isset(meta_data, key); if (!eval_int) { PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { 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); PHALCON_MM_RESTORE(); RETURN_NULL(); } if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(table_metadata); PHALCON_CALL_METHOD(table_metadata, model, "metadata", PH_NO_CHECK); if (Z_TYPE_P(table_metadata) != IS_ARRAY) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); 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_INIT_VAR(connection); PHALCON_CALL_METHOD(connection, model, "getconnection", PH_NO_CHECK); PHALCON_INIT_VAR(exists); PHALCON_CALL_METHOD_PARAMS_2(exists, connection, "tableexists", table, schema, PH_NO_CHECK); if (!zend_is_true(exists)) { if (zend_is_true(schema)) { PHALCON_INIT_VAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } PHALCON_INIT_VAR(attributes); array_init(attributes); PHALCON_INIT_VAR(primary_keys); array_init(primary_keys); PHALCON_INIT_VAR(non_primary_keys); array_init(non_primary_keys); PHALCON_INIT_VAR(numeric_typed); array_init(numeric_typed); PHALCON_INIT_VAR(not_null); array_init(not_null); PHALCON_INIT_VAR(field_types); array_init(field_types); PHALCON_INIT_VAR(field_bind_types); array_init(field_bind_types); PHALCON_INIT_VAR(automatic_default); array_init(automatic_default); PHALCON_INIT_VAR(identity_field); ZVAL_BOOL(identity_field, 0); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD_PARAMS_2(columns, connection, "describecolumns", table, schema, PH_NO_CHECK); if (!phalcon_fast_count_ev(columns TSRMLS_CC)) { if (zend_is_true(schema)) { PHALCON_INIT_NVAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); 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(column); PHALCON_INIT_NVAR(field_name); PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK); phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isprimary", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnumeric", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnotnull", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isautoincrement", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } PHALCON_INIT_NVAR(type); PHALCON_CALL_METHOD(type, column, "gettype", PH_NO_CHECK); phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(bind_type); PHALCON_CALL_METHOD(bind_type, column, "getbindtype", PH_NO_CHECK); phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_NVAR(table_metadata); array_init(table_metadata); phalcon_array_update_long(&table_metadata, 0, &attributes, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 4, &field_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC); phalcon_array_update_zval(&t0, key, &table_metadata, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t0 TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", key, table_metadata, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Helper method to query records based on a relation definition * * @param array $relation * @param string $method * @param Phalcon\Mvc\Model $record * @param array $parameters * @return Phalcon\Mvc\Model\Resultset\Simple */ PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){ zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL; zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL; zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL; zval *referenced_fields = NULL, *join_conditions = NULL; zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL; zval *reference_table = NULL, *referenced_entity = NULL; zval *connection_service = NULL, *call_object = NULL, *records = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_string(parameters, SL("bind")+1); if (eval_int) { PHALCON_INIT_VAR(placeholders); phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("bind")+1); } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(pre_conditions); ZVAL_NULL(pre_conditions); if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_long(parameters, 0); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_long(parameters, 0); } else { eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("conditions")+1); } } } else { if (Z_TYPE_P(parameters) == IS_STRING) { PHALCON_CPY_WRT(pre_conditions, parameters); } } if (Z_TYPE_P(pre_conditions) != IS_NULL) { PHALCON_INIT_VAR(conditions); array_init(conditions); phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(conditions); array_init(conditions); } PHALCON_INIT_VAR(fields); phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC); if (Z_TYPE_P(fields) != IS_ARRAY) { PHALCON_CPY_WRT(field, fields); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VS(condition, referenced_field, " = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(referenced_fields); phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC); if (!phalcon_valid_foreach(fields TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_74b5_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_74b5_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_74b5_0; fee_74b5_0: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC); PHALCON_INIT_VAR(find_params); array_init(find_params); phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(parameters) == IS_ARRAY) { PHALCON_INIT_VAR(find_arguments); PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters); } else { PHALCON_CPY_WRT(find_arguments, find_params); } PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference_table); phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC); ce0 = phalcon_fetch_class(reference_table TSRMLS_CC); PHALCON_INIT_VAR(referenced_entity); object_init_ex(referenced_entity, ce0); PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK); PHALCON_INIT_VAR(connection_service); PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK); PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments); RETURN_CCTOR(records); }
/** * Query the relations between two models * * @param string $first * @param string $second * @return array */ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations){ zval *first = NULL, *second = NULL, *belongs_to = NULL, *relation = NULL, *has_many = NULL; zval *has_one = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &first, &second) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(belongs_to); phalcon_read_property(&belongs_to, this_ptr, SL("_belongsTo"), PH_NOISY_CC); eval_int = phalcon_array_isset(belongs_to, first); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch(&r0, belongs_to, first, PH_NOISY_CC); eval_int = phalcon_array_isset(r0, second); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch(&r1, belongs_to, first, PH_NOISY_CC); PHALCON_INIT_VAR(relation); phalcon_array_fetch(&relation, r1, second, PH_NOISY_CC); RETURN_CCTOR(relation); } } PHALCON_INIT_VAR(has_many); phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_many, first); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch(&r2, has_many, first, PH_NOISY_CC); eval_int = phalcon_array_isset(r2, second); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch(&r3, has_many, first, PH_NOISY_CC); PHALCON_INIT_VAR(relation); phalcon_array_fetch(&relation, r3, second, PH_NOISY_CC); RETURN_CCTOR(relation); } } PHALCON_INIT_VAR(has_one); phalcon_read_property(&has_one, this_ptr, SL("_hasOne"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_one, first); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch(&r4, has_one, first, PH_NOISY_CC); eval_int = phalcon_array_isset(r4, second); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r5); phalcon_array_fetch(&r5, has_one, first, PH_NOISY_CC); PHALCON_INIT_VAR(relation); phalcon_array_fetch(&relation, r5, second, PH_NOISY_CC); RETURN_CCTOR(relation); } } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Returns the string meaning of a logger constant * * @param integer $type * @return string */ PHP_METHOD(Phalcon_Logger_Adapter_File, getTypeString){ zval *type = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &type) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(type); if (phalcon_compare_strict_long(type, 7 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "DEBUG", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 3 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "ERROR", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 4 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "WARNING", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 1 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "CRITICAL", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 8 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "CUSTOM", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 2 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "ALERT", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 5 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "NOTICE", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 6 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "INFO", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "EMERGENCE", 1); goto se_654f_0; } if (phalcon_compare_strict_long(type, 9 TSRMLS_CC)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "SPECIAL", 1); goto se_654f_0; } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "CUSTOM", 1); se_654f_0: RETURN_CCTOR(type); }
/** * Outputs a message formatting it with HTML * *<code> * $flash->outputMessage('error', $message); *</code> * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type, *message, *automatic_html, *classes; zval *type_classes, *joined_classes, *css_classes = NULL; zval *eol = NULL, *implicit_flush, *content, *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_OBS_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); if (phalcon_array_isset(classes, type)) { PHALCON_OBS_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(joined_classes); phalcon_fast_join_str(joined_classes, SL(" "), type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_NVAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_NVAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); PHALCON_INIT_NVAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); } PHALCON_OBS_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { /** * We create the message with implicit flush or other */ if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } /** * We create the message with implicit flush or other */ if (!phalcon_is_iterable(message, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(msg); /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * 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; 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 *p0[] = { 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, SL("_basePath"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), 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, SL("_finished"), 0 TSRMLS_CC); ws_e10f_0: PHALCON_INIT_VAR(t2); phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t2)) { goto we_e10f_0; } phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC); PHALCON_INIT_VAR(t3); phalcon_read_property(&t3, this_ptr, SL("_controllerName"), 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, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller_name, t4); phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); } PHALCON_INIT_VAR(t5); phalcon_read_property(&t5, this_ptr, SL("_controllers"), 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(c0); ZVAL_BOOL(c0, 0); PHALCON_INIT_VAR(r3); PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0); 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(c1); ZVAL_BOOL(c1, 0); PHALCON_INIT_VAR(r6); PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1); 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); p0[0] = this_ptr; p0[1] = request; p0[2] = response; p0[3] = view; p0[4] = model; PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK); PHALCON_CPY_WRT(controller, i0); if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK); } PHALCON_INIT_VAR(t6); phalcon_read_property(&t6, this_ptr, SL("_controllers"), 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, SL("_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, SL("_params"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(params, t7); PHALCON_INIT_VAR(t8); phalcon_read_property(&t8, this_ptr, SL("_actionName"), 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, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(action_name, t9); phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC); } if (phalcon_method_exists_ex(controller, SL("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(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_INIT_VAR(value); PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params); } else { if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(a1); array_init(a1); phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC); add_next_index_stringl(a1, SL("notFoundAction"), 1); PHALCON_INIT_VAR(value); PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params); } else { PHALCON_INIT_VAR(r11); PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK); } } if (phalcon_method_exists_ex(controller, SL("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(r12); is_smaller_function(r12, t10, number_dispatches TSRMLS_CC); if (zend_is_true(r12)) { 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, SL("_returnedValue"), value TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC); RETURN_CHECK_CTOR(controller); }
/** * Updates data on a table using custom RBDM SQL syntax * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL; zval *placeholders = NULL, *value = NULL, *position = NULL, *field = NULL, *set_clause_part = NULL; zval *comma = NULL, *set_clause = NULL, *update_sql = NULL, *success = 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|z", &table, &fields, &values, &where_condition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!where_condition) { PHALCON_ALLOC_ZVAL_MM(where_condition); ZVAL_NULL(where_condition); } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); 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(position); PHALCON_GET_FOREACH_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); eval_int = phalcon_array_isset(fields, position); if (eval_int) { PHALCON_INIT_VAR(field); phalcon_array_fetch(&field, fields, position, PH_NOISY_CC); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value); phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { if (Z_TYPE_P(value) == IS_NULL) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = null"); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = ?"); } phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields"); return; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(set_clause); phalcon_fast_join(set_clause, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(where_condition) != IS_NULL) { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition); } else { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", update_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); }
/** * Inserts data into a table using custom RBDM SQL syntax * * @param string $table * @param array $values * @param array $fields * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL; zval *exception = NULL, *placeholders = NULL, *value = NULL, *position = NULL; zval *str_value = NULL, *comma = NULL, *joined_values = NULL, *joined_fields = NULL; zval *insert_sql = NULL, *success = 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, "zz|z", &table, &values, &fields) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!fields) { PHALCON_ALLOC_ZVAL_MM(fields); ZVAL_NULL(fields); } if (Z_TYPE_P(values) == IS_ARRAY) { PHALCON_INIT_VAR(number_values); phalcon_fast_count(number_values, values TSRMLS_CC); if (phalcon_compare_strict_long(number_values, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data"); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); 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(position); PHALCON_GET_FOREACH_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(str_value); PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value); phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { if (Z_TYPE_P(value) == IS_NULL) { phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(joined_values); phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_INIT_VAR(joined_fields); phalcon_fast_join(joined_fields, comma, fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", insert_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *filtered, *frontend, *options; zval *cache_dir, *cache_file, *cached_content = NULL; zval *prepared_content, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_NVAR(key_name); } if (!content) { PHALCON_INIT_NVAR(content); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_NVAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_INIT_VAR(last_key); phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, filtered); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!zend_is_true(content)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, frontend, "getcontent", PH_NO_CHECK); } else { PHALCON_CPY_WRT(cached_content, content); } /** * We use file_put_contents to repect open-base-dir directive */ PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content, PH_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering", PH_NO_CHECK); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(frontend, "stop", PH_NO_CHECK); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL, *options, *prefix, *filtered; zval *prefixed_key, *cache_dir, *cache_file; zval *frontend, *time, *ttl = NULL, *modified_time, *difference; zval *not_expired, *cached_content, *processed; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, filtered); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); /** * Check if the file has expired */ PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_INIT_VAR(modified_time); PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file); PHALCON_INIT_VAR(difference); sub_function(difference, time, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); /** * The content is only retrieved if the content has not expired */ if (PHALCON_IS_TRUE(not_expired)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file); PHALCON_INIT_VAR(processed); PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK); RETURN_CCTOR(processed); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Internal sanizite wrapper to filter_var * * @param mixed $value * @param string $filter * @return mixed */ PHP_METHOD(Phalcon_Filter, _sanitize){ zval *value, *filter, *filters, *filter_object; zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str; zval *escaped, *allow_fraction, *options, *exception_message; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(filters); phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); eval_int = phalcon_array_isset(filters, filter); if (eval_int) { PHALCON_INIT_VAR(filter_object); phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC); /** * If the filter is a closure we call it in the PHP userland */ if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(filtered); PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK); } RETURN_CCTOR(filtered); } PHALCON_INIT_NVAR(filtered); if (PHALCON_COMPARE_STRING(filter, "email")) { /** * The 'email' filter uses the filter extension */ PHALCON_INIT_VAR(type); ZVAL_LONG(type, 517); PHALCON_INIT_VAR(quote); ZVAL_STRING(quote, "'", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(escaped); phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "int")) { /** * 'int' filter sanitizes a numeric input */ PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 519); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "string")) { PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 513); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "float")) { /** * The 'float' filter uses the filter extension */ PHALCON_INIT_VAR(allow_fraction); ZVAL_LONG(allow_fraction, 4096); PHALCON_INIT_VAR(options); array_init(options); phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 520); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "alphanum")) { PHALCON_INIT_NVAR(filtered); phalcon_filter_alphanum(filtered, value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "trim")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "striptags")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "lower")) { if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) { /** * 'lower' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value); } goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "upper")) { if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) { /** * 'upper' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value); } goto ph_end_0; } PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message); return; ph_end_0: RETURN_CCTOR(filtered); }
/** * Renders a view using the template engine * * @param string $path * @param array $params * @param bool $mustClean */ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) { zval *path, *params, *must_clean, *value = NULL, *key = NULL, *contents; zval *view; 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, "zzz", &path, ¶ms, &must_clean) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_CALL_FUNC_NORETURN("ob_clean"); } if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE) { return; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } if (PHALCON_IS_TRUE(must_clean)) { PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); PHALCON_INIT_VAR(view); phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Phalcon\Annotations\Annotation constructor * * @param array $reflectionData */ PHP_METHOD(Phalcon_Annotations_Annotation, __construct){ zval *reflection_data, *name = NULL, *arguments, *expr_arguments; zval *argument = NULL, *expr = NULL, *resolved_argument = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &reflection_data) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(reflection_data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Reflection data must be an array"); return; } PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, reflection_data, SL("name"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_name"), name TSRMLS_CC); /** * Process annotation arguments */ if (phalcon_array_isset_string(reflection_data, SS("arguments"))) { PHALCON_INIT_VAR(arguments); array_init(arguments); PHALCON_OBS_VAR(expr_arguments); phalcon_array_fetch_string(&expr_arguments, reflection_data, SL("arguments"), PH_NOISY_CC); if (!phalcon_is_iterable(expr_arguments, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(argument); PHALCON_OBS_NVAR(expr); phalcon_array_fetch_string(&expr, argument, SL("expr"), PH_NOISY_CC); PHALCON_INIT_NVAR(resolved_argument); PHALCON_CALL_METHOD_PARAMS_1(resolved_argument, this_ptr, "getexpression", expr); if (phalcon_array_isset_string(argument, SS("name"))) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_string(&name, argument, SL("name"), PH_NOISY_CC); phalcon_array_update_zval(&arguments, name, &resolved_argument, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&arguments, resolved_argument, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } phalcon_update_property_zval(this_ptr, SL("_arguments"), arguments TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_exprArguments"), expr_arguments TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Model_Resultset, valid){ zval *result_resource = NULL, *connection = NULL, *row = NULL, *rows = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *c0 = NULL, *c1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(result_resource, t1); if (Z_TYPE_P(result_resource) != IS_BOOL || (Z_TYPE_P(result_resource) == IS_BOOL && Z_BVAL_P(result_resource))) { PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(connection, t2); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(connection, "setfetchmode", c0, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, connection, "fetcharray", result_resource, PHALCON_NO_CHECK); PHALCON_CPY_WRT(row, r0); if (zend_is_true(row)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_model", sizeof("_model")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_STATIC_PARAMS_2(r1, "phalcon_model_base", "dumpresult", t3, row); phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), r1 TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } else { PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 2); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(connection, "setfetchmode", c1, PHALCON_NO_CHECK); } } } else { PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(rows, t4); PHALCON_ALLOC_ZVAL_MM(r2); Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1(r2, "current", rows, 0x054); Z_UNSET_ISREF_P(rows); PHALCON_CPY_WRT(row, r2); if (zend_is_true(row)) { Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059); Z_UNSET_ISREF_P(rows); phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), row TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Routes to a controller/action using a string or array uri * * @param string $uri */ PHP_METHOD(Phalcon_Dispatcher, forward){ zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL; zval *c0 = 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; zval *a0 = 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, "z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(uri) == IS_ARRAY) { PHALCON_CPY_WRT(parts, uri); } else { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_explode(r0, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r0); } eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_filter_alphanum(r2, r1); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 0); } else { eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); phalcon_filter_alphanum(r4, r3); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC); } } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_filter_alphanum(r7, r6); phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 1); } else { eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r10); phalcon_filter_alphanum(r10, r9); phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC); } } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); if (phalcon_valid_foreach(parts TSRMLS_CC)) { ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e10f_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e10f_1; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(key) == IS_LONG) { PHALCON_INIT_VAR(r12); phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e10f_1; fee_e10f_1: if(0){} } else { return; } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Phalcon_Db_Column constructor * * @param string $columnName * @param array $definition */ PHP_METHOD(Phalcon_Db_Column, __construct){ zval *v0 = NULL, *v1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL; zval *i0 = NULL, *i1 = NULL, *i2 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; zval *p0[] = { NULL }, *p1[] = { NULL }, *p2[] = { NULL }; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } phalcon_update_property_zval(this_ptr, "_columnName", strlen("_columnName"), v0 TSRMLS_CC); eval_int = phalcon_array_isset_string(v1, "type", strlen("type")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, v1, "type", strlen("type"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_type", strlen("_type"), r0 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_db_exception_class_entry); PHALCON_INIT_VAR(p0[0]); ZVAL_STRING(p0[0], "Column type is required", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p0, PHALCON_CALL_CHECK); zend_throw_exception_object(i0 TSRMLS_CC); Z_ADDREF_P(i0); PHALCON_MM_RESTORE(); return; } eval_int = phalcon_array_isset_string(v1, "notNull", strlen("notNull")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, v1, "notNull", strlen("notNull"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_notNull", strlen("_notNull"), r1 TSRMLS_CC); } eval_int = phalcon_array_isset_string(v1, "size", strlen("size")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, v1, "size", strlen("size"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_size", strlen("_size"), r2 TSRMLS_CC); } eval_int = phalcon_array_isset_string(v1, "scale", strlen("scale")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 3); PHALCON_ALLOC_ZVAL_MM(r3); is_equal_function(r3, t0, t1 TSRMLS_CC); if (zend_is_true(r3)) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, v1, "scale", strlen("scale"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_scale", strlen("_scale"), r4 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_db_exception_class_entry); PHALCON_INIT_VAR(p1[0]); ZVAL_STRING(p1[0], "Column type does not support scale parameter", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p1, PHALCON_CALL_CHECK); zend_throw_exception_object(i1 TSRMLS_CC); Z_ADDREF_P(i1); PHALCON_MM_RESTORE(); return; } } eval_int = phalcon_array_isset_string(v1, "unsigned", strlen("unsigned")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r5); phalcon_array_fetch_string(&r5, v1, "unsigned", strlen("unsigned"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_unsigned", strlen("_unsigned"), r5 TSRMLS_CC); } eval_int = phalcon_array_isset_string(v1, "autoIncrement", strlen("autoIncrement")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 0); PHALCON_ALLOC_ZVAL_MM(r6); is_equal_function(r6, t2, t3 TSRMLS_CC); if (zend_is_true(r6)) { PHALCON_ALLOC_ZVAL_MM(r7); phalcon_array_fetch_string(&r7, v1, "autoIncrement", strlen("autoIncrement"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_autoIncrement", strlen("_autoIncrement"), r7 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(i2); object_init_ex(i2, phalcon_db_exception_class_entry); PHALCON_INIT_VAR(p2[0]); ZVAL_STRING(p2[0], "Column type cannot be auto-increment", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p2, PHALCON_CALL_CHECK); zend_throw_exception_object(i2 TSRMLS_CC); Z_ADDREF_P(i2); PHALCON_MM_RESTORE(); return; } } eval_int = phalcon_array_isset_string(v1, "first", strlen("first")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_string(&r8, v1, "first", strlen("first"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_first", strlen("_first"), r8 TSRMLS_CC); } eval_int = phalcon_array_isset_string(v1, "after", strlen("after")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); phalcon_array_fetch_string(&r9, v1, "after", strlen("after"), PHALCON_NOISY_FETCH TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_after", strlen("_after"), r9 TSRMLS_CC); } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Produce the routing parameters from the rewrite information * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){ zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL; zval *handlers, *controller_suffix, *scope = NULL, *prefix = NULL; zval *dependency_injector = NULL, *service = NULL, *handler = NULL; zval *controller_name = NULL; zval *namespace_name = NULL, *module_name = NULL, *suffixed = NULL; zval *handler_annotations = NULL, *class_annotations = NULL; zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL; zval *collection = NULL, *method = NULL; HashTable *ah0, *ah1, *ah2, *ah3; HashPosition hp0, hp1, hp2, hp3; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &uri); if (!uri) { uri = PHALCON_GLOBAL(z_null); } if (!zend_is_true(uri)) { /** * If 'uri' isn't passed as parameter it reads $_GET['_url'] */ PHALCON_CALL_METHOD(&real_uri, this_ptr, "getrewriteuri"); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_OBS_VAR(processed); phalcon_read_property_this(&processed, this_ptr, SL("_processed"), PH_NOISY TSRMLS_CC); if (!zend_is_true(processed)) { PHALCON_INIT_VAR(annotations_service); PHALCON_OBS_VAR(handlers); phalcon_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(handlers) == IS_ARRAY) { PHALCON_OBS_VAR(controller_suffix); phalcon_read_property_this(&controller_suffix, this_ptr, SL("_controllerSuffix"), PH_NOISY TSRMLS_CC); phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(scope); if (Z_TYPE_P(scope) == IS_ARRAY) { /** * A prefix (if any) must be in position 0 */ PHALCON_OBS_NVAR(prefix); phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY); if (Z_TYPE_P(prefix) == IS_STRING) { if (!phalcon_start_with(real_uri, prefix, NULL)) { zend_hash_move_forward_ex(ah0, &hp0); continue; } } if (Z_TYPE_P(annotations_service) != IS_OBJECT) { PHALCON_OBS_NVAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service"); return; } PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "annotations", 1); PHALCON_CALL_METHOD(&annotations_service, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(annotations_service, phalcon_annotations_adapterinterface_ce); } /** * The controller must be in position 1 */ PHALCON_OBS_NVAR(handler); phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY); if (phalcon_memnstr_str(handler, SL("\\"))) { /** * Extract the real class name from the namespaced class */ PHALCON_INIT_NVAR(controller_name); phalcon_get_class_ns(controller_name, handler, 0 TSRMLS_CC); /** * Extract the namespace from the namespaced class */ PHALCON_INIT_NVAR(namespace_name); phalcon_get_ns_class(namespace_name, handler, 0 TSRMLS_CC); } else { PHALCON_CPY_WRT(controller_name, handler); PHALCON_INIT_NVAR(namespace_name); } phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC); /** * Check if the scope has a module associated */ if (phalcon_array_isset_long(scope, 2)) { PHALCON_OBS_NVAR(module_name); phalcon_array_fetch_long(&module_name, scope, 2, PH_NOISY); } else { PHALCON_INIT_NVAR(module_name); } PHALCON_INIT_NVAR(suffixed); PHALCON_CONCAT_VV(suffixed, handler, controller_suffix); /** * Get the annotations from the class */ PHALCON_CALL_METHOD(&handler_annotations, annotations_service, "get", suffixed); /** * Process class annotations */ PHALCON_CALL_METHOD(&class_annotations, handler_annotations, "getclassannotations"); if (Z_TYPE_P(class_annotations) == IS_OBJECT) { /** * Process class annotations */ PHALCON_CALL_METHOD(&annotations, class_annotations, "getannotations"); if (Z_TYPE_P(annotations) == IS_ARRAY) { phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(annotation); PHALCON_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", controller_name, annotation); zend_hash_move_forward_ex(ah1, &hp1); } } } /** * Process method annotations */ PHALCON_CALL_METHOD(&method_annotations, handler_annotations, "getmethodsannotations"); if (Z_TYPE_P(method_annotations) == IS_ARRAY) { phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HKEY(method, ah2, hp2); PHALCON_GET_HVALUE(collection); if (Z_TYPE_P(collection) == IS_OBJECT) { PHALCON_CALL_METHOD(&annotations, collection, "getannotations"); phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HVALUE(annotation); PHALCON_CALL_METHOD(NULL, this_ptr, "processactionannotation", module_name, namespace_name, controller_name, method, annotation); zend_hash_move_forward_ex(ah3, &hp3); } } zend_hash_move_forward_ex(ah2, &hp2); } } } zend_hash_move_forward_ex(ah0, &hp0); } } phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC); } /** * Call the parent handle method() */ PHALCON_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", real_uri); PHALCON_MM_RESTORE(); }
/** * Commits the internal transaction * */ PHP_METHOD(Phalcon_Logger_Adapter_File, commit){ zval *transaction = NULL, *file_handler = NULL, *quenue = NULL, *message = NULL; zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL; zval *applied_eol = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); PHALCON_INIT_VAR(transaction); phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC); if (!zend_is_true(transaction)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction"); return; } phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC); PHALCON_INIT_VAR(file_handler); phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC); PHALCON_INIT_VAR(quenue); phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC); if (!phalcon_valid_foreach(quenue TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(quenue); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_654f_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_654f_1; } PHALCON_INIT_VAR(message); ZVAL_ZVAL(message, *hd, 1, 0); PHALCON_INIT_VAR(message_str); PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK); PHALCON_INIT_VAR(type); PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK); PHALCON_INIT_VAR(time); PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK); PHALCON_INIT_VAR(applied_format); PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK); PHALCON_INIT_VAR(t0); zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC); PHALCON_INIT_VAR(applied_eol); PHALCON_CONCAT_VV(applied_eol, applied_format, t0); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", file_handler, applied_eol); zend_hash_move_forward_ex(ah0, &hp0); goto fes_654f_1; fee_654f_1: if(0){} PHALCON_MM_RESTORE(); }
/** * Executes the validator * * @return boolean */ PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){ zval *record = NULL, *field = NULL, *conditions = NULL, *compose_field = NULL; zval *value = NULL, *manager = NULL, *meta_data = NULL, *primary_fields = NULL; zval *primary_field = NULL, *options = 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, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL; zval *i0 = NULL; zval *a0 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *t0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(i0); if (phalcon_clone(i0, r1 TSRMLS_CC) == FAILURE){ return; } PHALCON_CPY_WRT(record, i0); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_NO_CHECK); PHALCON_CPY_WRT(field, r2); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(conditions, a0); if (Z_TYPE_P(field) == IS_ARRAY) { if (phalcon_valid_foreach(field TSRMLS_CC)) { ah0 = Z_ARRVAL_P(field); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_d73d_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_d73d_0; } PHALCON_INIT_VAR(compose_field); ZVAL_ZVAL(compose_field, *hd, 1, 0); PHALCON_INIT_VAR(r3); PHALCON_INIT_VAR(r4); PHALCON_CALL_METHOD_PARAMS_1(r4, record, "readattribute", compose_field, PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x00F); PHALCON_CPY_WRT(value, r3); PHALCON_INIT_VAR(r5); PHALCON_CONCAT_VSVS(r5, compose_field, "='", value, "'"); phalcon_array_append(&conditions, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_d73d_0; fee_d73d_0: if(0){} } else { return; } } else { PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_CALL_METHOD(r7, this_ptr, "getvalue", PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_1(r6, "addslashes", r7, 0x00F); PHALCON_CPY_WRT(value, r6); PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CONCAT_VSVS(r8, field, "='", value, "'"); phalcon_array_append(&conditions, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CALL_METHOD(r9, record, "getmanager", PHALCON_NO_CHECK); PHALCON_CPY_WRT(manager, r9); PHALCON_ALLOC_ZVAL_MM(r10); PHALCON_CALL_METHOD(r10, manager, "getmetadata", PHALCON_NO_CHECK); PHALCON_CPY_WRT(meta_data, r10); PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD_PARAMS_1(r11, meta_data, "getprimarykeyattributes", record, PHALCON_NO_CHECK); PHALCON_CPY_WRT(primary_fields, r11); if (phalcon_valid_foreach(primary_fields TSRMLS_CC)) { ah1 = Z_ARRVAL_P(primary_fields); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_d73d_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_d73d_1; } PHALCON_INIT_VAR(primary_field); ZVAL_ZVAL(primary_field, *hd, 1, 0); PHALCON_INIT_VAR(r12); PHALCON_INIT_VAR(r13); PHALCON_INIT_VAR(r14); PHALCON_CALL_METHOD_PARAMS_1(r14, record, "readattribute", primary_field, PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_1(r13, "addslashes", r14, 0x00F); PHALCON_CONCAT_VSVS(r12, primary_field, "<>'", r13, "'"); phalcon_array_append(&conditions, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_d73d_1; fee_d73d_1: if(0){} } else { return; } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_ALLOC_ZVAL_MM(r15); phalcon_fast_join(r15, c0, conditions TSRMLS_CC); PHALCON_CPY_WRT(conditions, r15); PHALCON_ALLOC_ZVAL_MM(r16); PHALCON_CALL_STATIC_ZVAL_PARAMS_1(r16, record, "count", conditions); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 0); PHALCON_INIT_VAR(r17); is_smaller_function(r17, t0, r16 TSRMLS_CC); if (zend_is_true(r17)) { PHALCON_ALLOC_ZVAL_MM(r18); PHALCON_CALL_METHOD(r18, this_ptr, "getoptions", PHALCON_NO_CHECK); PHALCON_CPY_WRT(options, r18); eval_int = phalcon_array_isset_string(options, "message", strlen("message")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r19); phalcon_array_fetch_string(&r19, options, "message", strlen("message"), PHALCON_NOISY TSRMLS_CC); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "unique", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r19, field, c1, PHALCON_NO_CHECK); } else { PHALCON_ALLOC_ZVAL_MM(r20); PHALCON_CONCAT_SVS(r20, "Value of field '", field, "' is already present in another record"); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "unique", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r20, field, c2, PHALCON_NO_CHECK); } PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_MM_RESTORE(); RETURN_TRUE; }
/** * Setup a relation 1-n between two models * * @param Phalcon\Mvc\Model $model * @param mixed $fields * @param string $referenceModel * @param mixed $referencedFields * @param array $options */ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany){ zval *model = NULL, *fields = NULL, *reference_model = NULL, *referenced_fields = NULL; zval *options = NULL, *entity_name = NULL, *has_many = NULL, *number_fields = NULL; zval *number_referenced = NULL, *diferent_fields = NULL; zval *relation = NULL; zval *a0 = NULL; zval *r0 = NULL; zval *t0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &model, &fields, &reference_model, &referenced_fields, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_VAR(options); array_init(options); } PHALCON_INIT_VAR(entity_name); phalcon_get_class(entity_name, model TSRMLS_CC); PHALCON_INIT_VAR(has_many); phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_many, entity_name); if (!eval_int) { PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); phalcon_array_update_zval(&has_many, entity_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch(&r0, has_many, entity_name, PH_NOISY_CC); eval_int = phalcon_array_isset(r0, reference_model); if (!eval_int) { if (Z_TYPE_P(referenced_fields) == IS_ARRAY) { PHALCON_INIT_VAR(number_fields); phalcon_fast_count(number_fields, fields TSRMLS_CC); PHALCON_INIT_VAR(number_referenced); phalcon_fast_count(number_referenced, referenced_fields TSRMLS_CC); PHALCON_INIT_VAR(diferent_fields); is_not_equal_function(diferent_fields, number_fields, number_referenced TSRMLS_CC); if (zend_is_true(diferent_fields)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Number of referenced fields are not the same"); return; } } PHALCON_INIT_VAR(relation); array_init(relation); phalcon_array_update_string(&relation, SL("fi"), &fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rt"), &reference_model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rf"), &referenced_fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("op"), &options, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_hasMany"), PH_NOISY_CC); phalcon_array_update_multi_2(&t0, entity_name, reference_model, &relation, 0 TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_hasMany"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Outputs a message formatting it with HTML * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type = NULL, *message = NULL, *automatic_html = NULL, *classes = NULL; zval *type_classes = NULL, *space = NULL, *joined_classes = NULL; zval *css_classes = NULL, *eol = NULL, *implicit_flush = NULL, *content = NULL; zval *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); eval_int = phalcon_array_isset(classes, type); if (eval_int) { PHALCON_INIT_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(joined_classes); phalcon_fast_join(joined_classes, space, type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_VAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); } PHALCON_INIT_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } if (!phalcon_valid_foreach(message TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(message); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_3b3c_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_3b3c_0; } PHALCON_INIT_VAR(msg); ZVAL_ZVAL(msg, *hd, 1, 0); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_3b3c_0; fee_3b3c_0: if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * Changes internal pointer to a specific position in the resultset * * @param int $position */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){ long i; zval *type, *result, *rows, *position; zval *pointer, *is_different; HashTable *ah0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_OBS_VAR(pointer); phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); /** * We only seek the records if the current position is diferent than the passed one */ PHALCON_INIT_VAR(is_different); is_not_equal_function(is_different, pointer, position TSRMLS_CC); if (PHALCON_IS_TRUE(is_different)) { PHALCON_OBS_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset is fetched one by one because is large */ PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); phalcon_call_method_p1_noret(result, "dataseek", position); } else { /** * Here, the resultset is a small array */ PHALCON_OBS_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); /** * We need to fetch the records because rows is null */ if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } convert_to_long(position); if(Z_TYPE_P(rows) == IS_ARRAY){ ah0 = Z_ARRVAL_P(rows); zend_hash_internal_pointer_reset(ah0); i = 0; while (1) { if (i >= Z_LVAL_P(position)) { break; } zend_hash_move_forward(ah0); i++; } } phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC); } } PHALCON_MM_RESTORE();}
/** * Checks if a role has access to a resource * * @param string $roleName * @param string $resourceName * @param string $access * @param string $action */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, _allowOrDeny){ zval *role_name, *resource_name, *access, *action; zval *roles_names, *exception_message = NULL, *resources_names; zval *default_access, *access_list, *internal_access; zval *access_name = NULL, *access_key = NULL, *access_key_all = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 4, 0, &role_name, &resource_name, &access, &action); PHALCON_OBS_VAR(roles_names); phalcon_read_property_this(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC); if (!phalcon_array_isset(roles_names, role_name)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Role \"", role_name, "\" does not exist in ACL"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } PHALCON_OBS_VAR(resources_names); phalcon_read_property_this(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC); if (!phalcon_array_isset(resources_names, resource_name)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource \"", resource_name, "\" does not exist in ACL"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } PHALCON_OBS_VAR(default_access); phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC); PHALCON_OBS_VAR(access_list); phalcon_read_property_this(&access_list, this_ptr, SL("_accessList"), PH_NOISY_CC); PHALCON_OBS_VAR(internal_access); phalcon_read_property_this(&internal_access, this_ptr, SL("_access"), PH_NOISY_CC); if (Z_TYPE_P(access) == IS_ARRAY) { phalcon_is_iterable(access, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name); if (!phalcon_array_isset(access_list, access_key)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access_name, "' does not exist in resource '", resource_name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } zend_hash_move_forward_ex(ah0, &hp0); } phalcon_is_iterable(access, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access_name); phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC); if (!PHALCON_IS_STRING(access_name, "*")) { PHALCON_INIT_NVAR(access_key_all); PHALCON_CONCAT_VSVS(access_key_all, role_name, "!", resource_name, "!*"); if (!phalcon_array_isset(internal_access, access_key_all)) { phalcon_update_property_array(this_ptr, SL("_access"), access_key_all, default_access TSRMLS_CC); } } zend_hash_move_forward_ex(ah1, &hp1); } } else { if (!PHALCON_IS_STRING(access, "*")) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access); if (!phalcon_array_isset(access_list, access_key)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access, "' does not exist in resource '", resource_name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } } PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access); /** * Define the access action for the specified accessKey */ phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC); if (!PHALCON_IS_STRING(access, "*")) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, role_name, "!", resource_name, "!*"); /** * If there is no default action for all the rest actions in the resource set the * default one */ if (!phalcon_array_isset(internal_access, access_key)) { phalcon_update_property_array(this_ptr, SL("_access"), access_key, default_access TSRMLS_CC); } } } PHALCON_MM_RESTORE(); }
/** * Factories different caches backends from its adapters * * @param string $frontendAdapter * @param string $backendAdapter * @param array $frontendOptions * @param array $backendOptions * @return Phalcon_Cache_Backend_File * @static */ PHP_METHOD(Phalcon_Cache, factory){ zval *frontend_adapter = NULL, *backend_adapter = NULL; zval *frontend_options = NULL, *backend_options = NULL; zval *frontend_class = NULL, *backend_class = NULL, *front_object = NULL; zval *a0 = NULL, *a1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; zval *i0 = NULL, *i1 = NULL, *i2 = NULL, *i3 = NULL; zend_class_entry *ce0, *ce1; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &frontend_adapter, &backend_adapter, &frontend_options, &backend_options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!frontend_options) { PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(frontend_options, a0); } if (!backend_options) { PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_CPY_WRT(backend_options, a1); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SV(r0, "Phalcon_Cache_Frontend_", frontend_adapter); PHALCON_CPY_WRT(frontend_class, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "class_exists", frontend_class, 0x012); if (!zend_is_true(r1)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_cache_exception_ce); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SVS(r2, "Frontend adapter \"", backend_adapter, "' doesn't exist"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r2, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_SV(r3, "Phalcon_Cache_Backend_", backend_adapter); PHALCON_CPY_WRT(backend_class, r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_FUNC_PARAMS_1(r4, "class_exists", backend_class, 0x012); if (!zend_is_true(r4)) { PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_cache_exception_ce); PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CONCAT_SVS(r5, "Backend adapter \"", backend_adapter, "' doesn't exist"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", r5, PHALCON_CHECK); phalcon_throw_exception(i1 TSRMLS_CC); return; } ce0 = phalcon_fetch_class(frontend_class TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(i2); object_init_ex(i2, ce0); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i2, "__construct", frontend_options, PHALCON_CHECK); PHALCON_CPY_WRT(front_object, i2); ce1 = phalcon_fetch_class(backend_class TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(i3); object_init_ex(i3, ce1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i3, "__construct", front_object, backend_options, PHALCON_CHECK); PHALCON_RETURN_CTOR(i3); }
/** * 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_list, *access_key = NULL; zval *role_inherits, *inherited_roles = NULL, *inherited_role = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 3, 0, &role, &resource, &access); phalcon_update_property_this(this_ptr, SL("_activeRole"), role TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_activeResource"), resource TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_activeAccess"), access TSRMLS_CC); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "acl:beforeCheckAccess", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } PHALCON_OBS_VAR(default_access); phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC); /** * Check if the role exists */ PHALCON_OBS_VAR(roles_names); phalcon_read_property_this(&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(access_list); phalcon_read_property_this(&access_list, this_ptr, SL("_access"), PH_NOISY_CC); PHALCON_INIT_VAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role, "!", resource, "!", access); /** * Check if there is a direct combination for role-resource-access */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } /** * Check in the inherits roles */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_OBS_VAR(role_inherits); phalcon_read_property_this(&role_inherits, this_ptr, SL("_roleInherits"), PH_NOISY_CC); if (phalcon_array_isset(role_inherits, role)) { PHALCON_OBS_VAR(inherited_roles); phalcon_array_fetch(&inherited_roles, role_inherits, role, PH_NOISY); } else { PHALCON_INIT_NVAR(inherited_roles); } if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, inherited_role, "!", resource, "!", access); /** * Check if there is a direct combination in one of the inherited roles */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah0, &hp0); } } } /** * If access wasn't found yet, try role-resource-* */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, role, "!", resource, "!*"); /** * In the direct role */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } else { if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, inherited_role, "!", resource, "!*"); /** * In the inherited roles */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah1, &hp1); } } } } /** * If access wasn't found yet, try role-*-* */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VS(access_key, role, "!*!*"); /** * Try in the direct role */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } else { if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VS(access_key, inherited_role, "!*!*"); if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah2, &hp2); } } } } phalcon_update_property_this(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_p3_noret(events_manager, "fire", event_name, this_ptr, have_access); } if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_MM_RESTORE(); RETURN_LONG(0); } RETURN_CCTOR(have_access); }
/** * Magic method __get * * @param string $propertyName */ PHP_METHOD(Phalcon_Controller, __get){ zval *property_name = NULL, *model = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *i0 = NULL, *i1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &property_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (PHALCON_COMPARE_STRING(property_name, "view")) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "_getviewcomponent", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, "view", strlen("view"), r0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "view", sizeof("view")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t0); } if (PHALCON_COMPARE_STRING(property_name, "filter")) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_filter_ce); PHALCON_CALL_METHOD_NORETURN(i0, "__construct", PHALCON_CHECK); phalcon_update_property_zval(this_ptr, "filter", strlen("filter"), i0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "filter", sizeof("filter")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t1); } if (PHALCON_COMPARE_STRING(property_name, "session")) { PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_session_namespace_ce); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_get_class(r1, this_ptr TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", r1, PHALCON_CHECK); phalcon_update_property_zval(this_ptr, "session", strlen("session"), i1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "session", sizeof("session")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t2); } PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "model", sizeof("model")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t3)) { PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, "model", sizeof("model")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(model, t4); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_METHOD_PARAMS_1(r2, model, "ismodel", property_name, PHALCON_NO_CHECK); if (zend_is_true(r2)) { PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_METHOD_PARAMS_1(r3, model, "getmodel", property_name, PHALCON_NO_CHECK); PHALCON_RETURN_DZVAL(r3); } } PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CONCAT_LEFT(r4, "Access to undefined property ", property_name); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("trigger_error", r4, 0x033); PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Resolves an annotation expression * * @param array $expr * @return mixed */ PHP_METHOD(Phalcon_Annotations_Annotation, getExpression){ zval *expr = NULL, *type, *value = NULL, *array_value, *items, *item = NULL; zval *resolved_item = NULL, *name = NULL, *annotation, *exception_message; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &expr) == FAILURE) { RETURN_MM_NULL(); } PHALCON_SEPARATE_PARAM(expr); if (Z_TYPE_P(expr) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "The expression is not valid"); return; } PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, expr, SL("type"), PH_NOISY_CC); switch (phalcon_get_intval(type)) { case 301: PHALCON_OBS_VAR(value); phalcon_array_fetch_string(&value, expr, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); case 302: PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expr, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); case 303: PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expr, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); case 307: PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expr, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); case 304: RETURN_MM_NULL(); case 305: RETURN_MM_FALSE; case 306: RETURN_MM_TRUE; case 308: PHALCON_INIT_VAR(array_value); array_init(array_value); PHALCON_OBS_VAR(items); phalcon_array_fetch_string(&items, expr, SL("items"), PH_NOISY_CC); if (!phalcon_is_iterable(items, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(item); PHALCON_OBS_NVAR(expr); phalcon_array_fetch_string(&expr, item, SL("expr"), PH_NOISY_CC); PHALCON_INIT_NVAR(resolved_item); PHALCON_CALL_METHOD_PARAMS_1(resolved_item, this_ptr, "getexpression", expr); if (phalcon_array_isset_string(item, SS("name"))) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_string(&name, item, SL("name"), PH_NOISY_CC); phalcon_array_update_zval(&array_value, name, &resolved_item, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&array_value, resolved_item, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CTOR(array_value); case 300: PHALCON_INIT_VAR(annotation); object_init_ex(annotation, phalcon_annotations_annotation_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(annotation, "__construct", expr); RETURN_CTOR(annotation); default: PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "The expression ", type, " is unknown"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_annotations_exception_ce, exception_message); return; } PHALCON_MM_RESTORE(); }