/**
* Generates SQL to drop a view
*
* @param string $viewName
* @param string $schemaName
* @param boolean $ifExists
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropView){
zval *view_name, *schema_name, *if_exists = NULL, *view = NULL;
zval *sql = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &view_name, &schema_name, &if_exists);
if (!if_exists) {
PHALCON_INIT_VAR(if_exists);
ZVAL_BOOL(if_exists, 1);
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(view);
PHALCON_CONCAT_SVSVS(view, "`", schema_name, "`.`", view_name, "`");
} else {
PHALCON_INIT_NVAR(view);
PHALCON_CONCAT_SVS(view, "`", view_name, "`");
}
if (zend_is_true(if_exists)) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SV(sql, "DROP VIEW IF EXISTS ", view);
} else {
PHALCON_INIT_NVAR(sql);
PHALCON_CONCAT_SV(sql, "DROP VIEW ", view);
}
RETURN_CTOR(sql);
}
/**
* Generates SQL to drop a view
*
* @param string $viewName
* @param string $schemaName
* @param boolean $ifExists
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropView){
zval *view_name, *schema_name, *if_exists = NULL, *view = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &view_name, &schema_name, &if_exists);
if (!if_exists) {
if_exists = PHALCON_GLOBAL(z_true);
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(view);
PHALCON_CONCAT_SVSVS(view, "`", schema_name, "`.`", view_name, "`");
} else {
PHALCON_INIT_NVAR(view);
PHALCON_CONCAT_SVS(view, "`", view_name, "`");
}
if (zend_is_true(if_exists)) {
PHALCON_CONCAT_SV(return_value, "DROP VIEW IF EXISTS ", view);
} else {
PHALCON_CONCAT_SV(return_value, "DROP VIEW ", view);
}
PHALCON_MM_RESTORE();
}
/**
* Generates SQL to drop a table
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropTable){
zval *table_name, *schema_name, *if_exists = NULL, *table = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &table_name, &schema_name, &if_exists);
if (!if_exists) {
if_exists = PHALCON_GLOBAL(z_true);
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_VSV(table, schema_name, ".", table_name);
} else {
PHALCON_CPY_WRT(table, table_name);
}
if (zend_is_true(if_exists)) {
PHALCON_CONCAT_SV(return_value, "DROP TABLE IF EXISTS ", table);
} else {
PHALCON_CONCAT_SV(return_value, "DROP TABLE ", table);
}
PHALCON_MM_RESTORE();
}
/**
* Write hex string to the current position in the file pointer
*
* @return Phalcon\Binary\Writer
*/
PHP_METHOD(Phalcon_Binary_Writer, writeHexString){
zval *str, *length = NULL, *low_nibble = NULL, len = {}, format = {}, result = {};
phalcon_fetch_params(0, 1, 2, &str, &length, &low_nibble);
if (length && Z_TYPE_P(length) != IS_NULL) {
if (low_nibble && zend_is_true(low_nibble)) {
PHALCON_CONCAT_SV(&format, "h", length);
} else {
PHALCON_CONCAT_SV(&format, "H", length);
}
} else {
if (low_nibble && zend_is_true(low_nibble)) {
ZVAL_STRING(&format, "h*");
} else {
ZVAL_STRING(&format, "H*");
}
}
PHALCON_CALL_FUNCTIONW(&result, "pack", &format, str);
ZVAL_LONG(&len, Z_STRLEN(result));
PHALCON_CALL_METHODW(NULL, getThis(), "write", &result, &len);
RETURN_THISW();
}
/**
* Generates SQL to drop a table
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropTable){
zval *table_name, *schema_name, *if_exists = NULL, *table = NULL;
zval *sql = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &table_name, &schema_name, &if_exists);
if (!if_exists) {
PHALCON_INIT_VAR(if_exists);
ZVAL_BOOL(if_exists, 1);
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_VSV(table, schema_name, ".", table_name);
} else {
PHALCON_CPY_WRT(table, table_name);
}
if (zend_is_true(if_exists)) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SV(sql, "DROP TABLE IF EXISTS ", table);
} else {
PHALCON_INIT_NVAR(sql);
PHALCON_CONCAT_SV(sql, "DROP TABLE ", table);
}
RETURN_CTOR(sql);
}
/**
* Generates SQL to drop a table
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, dropTable){
zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *table = NULL;
zval *sql = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!if_exists) {
PHALCON_ALLOC_ZVAL_MM(if_exists);
ZVAL_BOOL(if_exists, 1);
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`");
} else {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_SVS(table, "`", table_name, "`");
}
if (zend_is_true(if_exists)) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SV(sql, "DROP TABLE IF EXISTS ", table);
} else {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SV(sql, "DROP TABLE ", table);
}
RETURN_CTOR(sql);
}
/**
* Returns the active version (string)
*
* @return string
*/
PHP_METHOD(Phalcon_Version, get){
zval *version, *major, *medium, *minor, *special, *special_number;
zval *result, *suffix = NULL, *final_version;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(version);
PHALCON_CALL_SELF(version, this_ptr, "_getversion");
PHALCON_INIT_VAR(major);
phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(medium);
phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(minor);
phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC);
PHALCON_INIT_VAR(special);
phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC);
PHALCON_INIT_VAR(special_number);
phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC);
PHALCON_INIT_VAR(result);
PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " ");
if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) {
PHALCON_INIT_VAR(suffix);
PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number);
goto ph_end_0;
}
if (phalcon_compare_strict_long(special, 2 TSRMLS_CC)) {
PHALCON_INIT_NVAR(suffix);
PHALCON_CONCAT_SV(suffix, "BETA ", special_number);
goto ph_end_0;
}
if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) {
PHALCON_INIT_NVAR(suffix);
PHALCON_CONCAT_SV(suffix, "RC ", special_number);
goto ph_end_0;
}
PHALCON_INIT_NVAR(suffix);
ZVAL_STRING(suffix, "", 1);
goto ph_end_0;
ph_end_0:
phalcon_concat_self(result, suffix TSRMLS_CC);
PHALCON_INIT_VAR(final_version);
PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result);
RETURN_CCTOR(final_version);
}
/**
* Returns the active version (string)
*
* <code>
* echo Phalcon\Version::get();
* </code>
*
* @return string
*/
PHP_METHOD(Phalcon_Version, get){
zval *version, *major, *medium, *minor, *special, *special_number;
zval *result, *suffix = NULL, *final_version;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(version);
PHALCON_CALL_SELF(version, this_ptr, "_getversion");
PHALCON_OBS_VAR(major);
phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC);
PHALCON_OBS_VAR(medium);
phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC);
PHALCON_OBS_VAR(minor);
phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC);
PHALCON_OBS_VAR(special);
phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC);
PHALCON_OBS_VAR(special_number);
phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC);
PHALCON_INIT_VAR(result);
PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " ");
switch (phalcon_get_intval(special)) {
case 1:
PHALCON_INIT_VAR(suffix);
PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number);
break;
case 2:
PHALCON_INIT_NVAR(suffix);
PHALCON_CONCAT_SV(suffix, "BETA ", special_number);
break;
case 3:
PHALCON_INIT_NVAR(suffix);
PHALCON_CONCAT_SV(suffix, "RC ", special_number);
break;
default:
PHALCON_INIT_NVAR(suffix);
ZVAL_STRING(suffix, "", 1);
break;
}
phalcon_concat_self(&result, suffix TSRMLS_CC);
PHALCON_INIT_VAR(final_version);
PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result);
RETURN_CCTOR(final_version);
}
/**
* Receives events generated in the models and dispatches them to a events-manager if available
* Notify the behaviors that are listening in the model
*
* @param string $eventName
* @param Phalcon\Mvc\CollectionInterface $model
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, notifyEvent){
zval *event_name, *model, *status = NULL, *events_manager;
zval *fire_event_name = NULL, *custom_events_manager;
zval *entity_name;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &event_name, &model);
PHALCON_INIT_VAR(status);
/**
* Dispatch events to the global events manager
*/
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(fire_event_name);
PHALCON_CONCAT_SV(fire_event_name, "collection:", event_name);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", fire_event_name, model);
if (PHALCON_IS_FALSE(status)) {
RETURN_CCTOR(status);
}
}
/**
* A model can has a specific events manager for it
*/
PHALCON_OBS_VAR(custom_events_manager);
phalcon_read_property_this(&custom_events_manager, this_ptr, SL("_customEventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(custom_events_manager) == IS_ARRAY) {
PHALCON_INIT_VAR(entity_name);
phalcon_get_class(entity_name, model, 1 TSRMLS_CC);
if (phalcon_array_isset(custom_events_manager, entity_name)) {
PHALCON_INIT_NVAR(fire_event_name);
PHALCON_CONCAT_SV(fire_event_name, "collection:", event_name);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, custom_events_manager, "fire", fire_event_name, model);
if (PHALCON_IS_FALSE(status)) {
RETURN_CCTOR(status);
}
}
}
RETURN_CCTOR(status);
}
/**
* Returns the active version (string)
*
* <code>
* echo Phalcon\Version::get();
* </code>
*
* @return string
*/
PHP_METHOD(Phalcon_Version, get){
zval *version = NULL, *major, *medium, *minor, *special, *special_number;
zval *result, *suffix;
PHALCON_MM_GROW();
PHALCON_CALL_SELF(&version, "_getversion");
PHALCON_OBS_VAR(major);
phalcon_array_fetch_long(&major, version, 0, PH_NOISY);
PHALCON_OBS_VAR(medium);
phalcon_array_fetch_long(&medium, version, 1, PH_NOISY);
PHALCON_OBS_VAR(minor);
phalcon_array_fetch_long(&minor, version, 2, PH_NOISY);
PHALCON_OBS_VAR(special);
phalcon_array_fetch_long(&special, version, 3, PH_NOISY);
PHALCON_OBS_VAR(special_number);
phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY);
PHALCON_INIT_VAR(result);
PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " ");
PHALCON_INIT_VAR(suffix);
switch (phalcon_get_intval(special)) {
case PHALCON_VERSION_ALPHA:
PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number);
break;
case PHALCON_VERSION_BETA:
PHALCON_CONCAT_SV(suffix, "BETA ", special_number);
break;
case PHALCON_VERSION_RC:
PHALCON_CONCAT_SV(suffix, "RC ", special_number);
break;
default:
ZVAL_STRING(suffix, "", 1);
break;
}
phalcon_concat_self(&result, suffix TSRMLS_CC);
phalcon_fast_trim(return_value, result, PHALCON_TRIM_BOTH TSRMLS_CC);
RETURN_MM();
}
/**
* Appends a NOT BETWEEN condition to the current conditions
*
*<code>
* $criteria->notBetweenWhere('price', 100.25, 200.50);
*</code>
*
* @param string $expr
* @param mixed $minimum
* @param mixed $maximum
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere){
zval *expr, *minimum, *maximum, *hidden_param, *one;
zval *next_hidden_param, *minimum_key, *maximum_key;
zval *conditions, *bind_params;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &expr, &minimum, &maximum);
PHALCON_OBS_VAR(hidden_param);
phalcon_read_property_this(&hidden_param, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(next_hidden_param);
phalcon_add_function(next_hidden_param, hidden_param, one TSRMLS_CC);
/**
* Minimum key with auto bind-params
*/
PHALCON_INIT_VAR(minimum_key);
PHALCON_CONCAT_SV(minimum_key, "phb", hidden_param);
/**
* Maximum key with auto bind-params
*/
PHALCON_INIT_VAR(maximum_key);
PHALCON_CONCAT_SV(maximum_key, "phb", next_hidden_param);
/**
* Create a standard BETWEEN condition with bind params
*/
PHALCON_INIT_VAR(conditions);
PHALCON_CONCAT_VSVSVS(conditions, expr, " NOT BETWEEN :", minimum_key, ": AND :", maximum_key, ":");
PHALCON_INIT_VAR(bind_params);
array_init_size(bind_params, 2);
phalcon_array_update_zval(&bind_params, minimum_key, &minimum, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&bind_params, maximum_key, &maximum, PH_COPY | PH_SEPARATE TSRMLS_CC);
/**
* Append the BETWEEN to the current conditions using and 'and'
*/
phalcon_call_method_p2_noret(this_ptr, "andwhere", conditions, bind_params);
PHALCON_SEPARATE(next_hidden_param);
phalcon_increment(next_hidden_param);
phalcon_update_property_this(this_ptr, SL("_hiddenParamNumber"), next_hidden_param TSRMLS_CC);
RETURN_THIS();
}
/**
* Gets HTTP header from request data
*
* @param string $header
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getHeader){
zval *header, *_SERVER, *server_value = NULL, *key;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &header) == FAILURE) {
RETURN_MM_NULL();
}
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (phalcon_array_isset(_SERVER, header)) {
PHALCON_OBS_VAR(server_value);
phalcon_array_fetch(&server_value, _SERVER, header, PH_NOISY_CC);
RETURN_CCTOR(server_value);
} else {
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_SV(key, "HTTP_", header);
if (phalcon_array_isset(_SERVER, key)) {
PHALCON_OBS_NVAR(server_value);
phalcon_array_fetch(&server_value, _SERVER, key, PH_NOISY_CC);
RETURN_CCTOR(server_value);
}
}
PHALCON_MM_RESTORE();
RETURN_EMPTY_STRING();
}
/**
* Reads meta-data from $_SESSION
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, read){
zval *key, *session, *prefix, *prefix_key;
zval *meta_data;
zval *r0, *r1 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(0, 1, 0, &key);
session = phalcon_get_global(SL("_SESSION"));
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "$PMM$", prefix);
if (phalcon_array_isset_fetch(&r0, session, prefix_key)) {
if (phalcon_array_isset(r0, key)) {
PHALCON_OBS_VAR(r1);
phalcon_array_fetch(&r1, session, prefix_key, PH_NOISY);
PHALCON_OBS_VAR(meta_data);
phalcon_array_fetch(&meta_data, r1, key, PH_NOISY);
RETURN_CCTOR(meta_data);
}
}
RETURN_MM_NULL();
}
/**
* Gets the active connection unique identifier. A mysqli object
*
* @param boolean $asString
* @return string
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, getConnectionId){
zval *as_string = NULL, *id_connection = NULL;
zval *t0 = NULL;
zval *r0 = NULL, *r1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &as_string) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!as_string) {
PHALCON_INIT_VAR(as_string);
ZVAL_BOOL(as_string, 0);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id_connection, t0);
if (zend_is_true(as_string)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "mysqli_thread_id", id_connection);
PHALCON_CONCAT_SV(r0, "Connection", r1);
RETURN_CTOR(r0);
} else {
RETURN_CHECK_CTOR(id_connection);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Translate\Adapter\Gettext constructor
*
* @param array $options
* @throws \Phalcon\Translate\Exception
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, __construct){
zval *options, *locale, *default_domain, *directory, *setting, *key = NULL, *value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Invalid options");
return;
}
if (!phalcon_array_isset_string_fetch(&locale, options, SS("locale"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"locale\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&default_domain, options, SS("defaultDomain"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"defaultDomain\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&directory, options, SS("directory"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"directory\" is required");
return;
}
phalcon_update_property_this(this_ptr, SL("_locale"), locale TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_defaultDomain"), default_domain TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC);
PHALCON_INIT_VAR(setting);
PHALCON_CONCAT_SV(setting, "LC_ALL=", locale);
PHALCON_CALL_FUNCTION(NULL, "putenv", setting);
setlocale(LC_ALL, Z_STRVAL_P(locale));
if (Z_TYPE_P(directory) == IS_ARRAY) {
phalcon_is_iterable(directory, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
bindtextdomain(Z_STRVAL_P(key), Z_STRVAL_P(value));
zend_hash_move_forward_ex(ah0, &hp0);
}
} else {
bindtextdomain(Z_STRVAL_P(default_domain), Z_STRVAL_P(directory));
}
textdomain(Z_STRVAL_P(default_domain));
PHALCON_MM_RESTORE();
}
/**
* Reads meta-data from $_SESSION
*
* @param string $key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, read){
zval *key, *session = NULL, *_SESSION, *prefix, *prefix_key;
zval *meta_data;
zval *r0 = NULL, *r1 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
phalcon_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC);
PHALCON_CPY_WRT(session, _SESSION);
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "$PMM$", prefix);
if (phalcon_array_isset(session, prefix_key)) {
PHALCON_OBS_VAR(r0);
phalcon_array_fetch(&r0, session, prefix_key, PH_NOISY_CC);
if (phalcon_array_isset(r0, key)) {
PHALCON_OBS_VAR(r1);
phalcon_array_fetch(&r1, session, prefix_key, PH_NOISY_CC);
PHALCON_OBS_VAR(meta_data);
phalcon_array_fetch(&meta_data, r1, key, PH_NOISY_CC);
RETURN_CCTOR(meta_data);
}
}
RETURN_MM_NULL();
}
/**
* Reads meta-data from $_SESSION
*
* @return array
*/
PHP_METHOD(Phalcon_Model_MetaData_Session, read){
zval *session = NULL, *key = NULL;
zval *g0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
phalcon_get_global(&g0, "_SESSION", sizeof("_SESSION") TSRMLS_CC);
PHALCON_CPY_WRT(session, g0);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_suffix", sizeof("_suffix")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_SV(r0, "$PMM$", t0);
PHALCON_CPY_WRT(key, r0);
eval_int = phalcon_array_isset(session, key);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch(&r1, session, key, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(r1);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_RETURN_CTOR(a0);
}
/**
* Reads parsed annotations from XCache
*
* @param string $key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, read){
zval *key, *prefixed_key, *prefixed_lower, *serialized;
zval *data;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_SV(prefixed_key, "_PHAN", key);
PHALCON_INIT_VAR(prefixed_lower);
phalcon_fast_strtolower(prefixed_lower, prefixed_key);
PHALCON_INIT_VAR(serialized);
phalcon_call_func_p1(serialized, "xcache_get", prefixed_lower);
if (Z_TYPE_P(serialized) == IS_STRING) {
PHALCON_INIT_VAR(data);
phalcon_unserialize(data, serialized TSRMLS_CC);
if (Z_TYPE_P(data) == IS_OBJECT) {
RETURN_CTOR(data);
}
}
RETURN_MM_NULL();
}
/**
* Gets HTTP header from request data
*
* @param string $header
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getHeader){
zval *header = NULL, *server_value = NULL, *key = NULL;
zval *g0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &header) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC);
eval_int = phalcon_array_isset(g0, header);
if (eval_int) {
PHALCON_INIT_VAR(server_value);
phalcon_array_fetch(&server_value, g0, header, PH_NOISY_CC);
RETURN_CCTOR(server_value);
} else {
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_SV(key, "HTTP_", header);
eval_int = phalcon_array_isset(g0, key);
if (eval_int) {
PHALCON_INIT_VAR(server_value);
phalcon_array_fetch(&server_value, g0, key, PH_NOISY_CC);
RETURN_CCTOR(server_value);
}
}
PHALCON_MM_RESTORE();
RETURN_STRING("", 1);
}
/**
* Generate SQL to rollback a savepoint
*
* @param string $name
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, rollbackSavepoint){
zval *name;
phalcon_fetch_params(0, 1, 0, &name);
PHALCON_CONCAT_SV(return_value, "ROLLBACK TO SAVEPOINT ", name);
return;
}
/**
* Generate SQL to release a savepoint
*
* @param string $name
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, releaseSavepoint){
zval *name;
phalcon_fetch_params(0, 1, 0, &name);
PHALCON_CONCAT_SV(return_value, "RELEASE SAVEPOINT ", name);
return;
}
/**
* Phalcon_Acl Constructor
*
* @param string $adapterName
* @param array $options
*/
PHP_METHOD(Phalcon_Acl, __construct){
zval *adapter_name = NULL, *options = NULL, *adapter_class = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *i0 = NULL, *i1 = NULL;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &adapter_name, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!adapter_name) {
PHALCON_INIT_VAR(adapter_name);
ZVAL_STRING(adapter_name, "Memory", 1);
}
if (!options) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(options, a0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SV(r0, "Phalcon_Acl_Adapter_", adapter_name);
PHALCON_CPY_WRT(adapter_class, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "class_exists", adapter_class);
if (!zend_is_true(r1)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_acl_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SVS(r2, "Adapter '", adapter_name, "' does not exist");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r2, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
ce0 = phalcon_fetch_class(adapter_class TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, ce0);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", options, PHALCON_CHECK);
phalcon_update_property_zval(this_ptr, SL("_adapter"), i1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Gets a value from the the internal related entity or from the default value
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Forms_Form, getValue){
zval *name, *entity, *method, *value = NULL, *data;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(entity);
phalcon_read_property(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
if (Z_TYPE_P(entity) == IS_OBJECT) {
/**
* Check if the entity has a getter
*/
PHALCON_INIT_VAR(method);
PHALCON_CONCAT_SV(method, "get", name);
if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD(value, entity, Z_STRVAL_P(method));
RETURN_CCTOR(value);
}
/**
* Check if the entity has a public property
*/
if (phalcon_isset_property_zval(entity, name TSRMLS_CC)) {
PHALCON_OBS_NVAR(value);
phalcon_read_property_zval(&value, entity, name, PH_NOISY_CC);
RETURN_CCTOR(value);
}
}
PHALCON_OBS_VAR(data);
phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (Z_TYPE_P(data) == IS_ARRAY) {
/**
* Check if the data is in the data array
*/
if (phalcon_array_isset(data, name)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, data, name, PH_NOISY_CC);
RETURN_CCTOR(value);
}
}
RETURN_MM_NULL();
}
/**
* Generates SQL to drop a table
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, dropTable){
zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *table = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!if_exists) {
PHALCON_INIT_VAR(if_exists);
ZVAL_BOOL(if_exists, 1);
}
if (zend_is_true(schema_name)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_VSV(r0, schema_name, ".", table_name);
PHALCON_CPY_WRT(table, r0);
} else {
PHALCON_CPY_WRT(table, table_name);
}
if (zend_is_true(if_exists)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SV(r1, "DROP TABLE IF EXISTS ", table);
RETURN_CTOR(r1);
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SV(r2, "DROP TABLE ", table);
RETURN_CTOR(r2);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon_Model_MetaData constructor
*
* @param string $adapter
* @param array $options
*/
PHP_METHOD(Phalcon_Model_MetaData, __construct){
zval *adapter = NULL, *options = NULL, *adapter_class = NULL, *adapter_object = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
zval *i0 = NULL, *i1 = NULL;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &adapter, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!options) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(options, a0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SV(r0, "Phalcon_Model_MetaData_", adapter);
PHALCON_CPY_WRT(adapter_class, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "class_exists", adapter_class);
if (zend_is_true(r1)) {
ce0 = phalcon_fetch_class(adapter_class TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, ce0);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", options, PHALCON_CHECK);
PHALCON_CPY_WRT(adapter_object, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, adapter_object, "read", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_metaData"), r2 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_adapter"), adapter_object TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_model_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "Meta-data adapter '", adapter, "' could not found");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", r3, PHALCON_CHECK);
phalcon_throw_exception(i1 TSRMLS_CC);
return;
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Db constructor
*
* @param stdClass $descriptor
*/
PHP_METHOD(Phalcon_Db, __construct){
zval *descriptor = NULL, *connection_consecutive = NULL;
zval *next_consecutive = NULL, *dialect_type = NULL, *dialect_class = NULL;
zval *dialect_object = NULL;
zval *t0 = NULL;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBSERVE_VAR(connection_consecutive);
phalcon_read_static_property(&connection_consecutive, SL("phalcon\\db"), SL("_connectionConsecutive") TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(next_consecutive);
phalcon_add_function(next_consecutive, connection_consecutive, t0 TSRMLS_CC);
phalcon_update_static_property(SL("phalcon\\db"), SL("_connectionConsecutive"), next_consecutive TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_connectionId"), connection_consecutive TSRMLS_CC);
eval_int = phalcon_array_isset_string(descriptor, SL("dialectClass")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dialect_type);
phalcon_read_property(&dialect_type, this_ptr, SL("_dialectType"), PH_NOISY_CC);
PHALCON_INIT_VAR(dialect_class);
PHALCON_CONCAT_SV(dialect_class, "phalcon\\db\\dialect\\", dialect_type);
} else {
PHALCON_INIT_VAR(dialect_class);
phalcon_array_fetch_string(&dialect_class, descriptor, SL("dialectClass"), PH_NOISY_CC);
}
ce0 = phalcon_fetch_class(dialect_class TSRMLS_CC);
PHALCON_INIT_VAR(dialect_object);
object_init_ex(dialect_object, ce0);
PHALCON_CALL_METHOD_NORETURN(dialect_object, "__construct", PH_CHECK);
phalcon_update_property_zval(this_ptr, SL("_dialect"), dialect_object TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_descriptor"), descriptor TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Gets HTTP header from request data
*
* @param string $header
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getHeader)
{
zval *header, *_SERVER, key = {};
phalcon_fetch_params(0, 1, 0, &header);
_SERVER = phalcon_get_global_str(SL("_SERVER"));
if (!phalcon_array_isset_fetch(return_value, _SERVER, header, 0)) {
PHALCON_CONCAT_SV(&key, "HTTP_", header);
if (phalcon_array_isset_fetch(return_value, _SERVER, &key, 0)) {
return;
}
}
RETURN_EMPTY_STRING();
}
/**
* Writes the meta-data to $_SESSION
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, write){
zval *key, *data, *prefix, *prefix_key, *_SESSION;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "$PMM$", prefix);
_SESSION = phalcon_get_global(SS("_SESSION") TSRMLS_CC);
phalcon_array_update_multi_2(&_SESSION, prefix_key, key, data, 0);
PHALCON_MM_RESTORE();
}
/**
* Sets an attached file to be sent at the end of the request
*
* @param string $filePath
* @param string $attachmentName
*/
PHP_METHOD(Phalcon_Http_Response, setFileToSend){
zval *file_path, *attachment_name = NULL, *attachment = NULL, *base_path = NULL;
zval *headers, *content_description, *content_disposition;
zval *content_transfer;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &file_path, &attachment_name, &attachment);
if (!attachment_name) {
PHALCON_INIT_VAR(attachment_name);
}
if (!attachment) {
PHALCON_INIT_VAR(attachment);
ZVAL_BOOL(attachment, 1);
}
if (Z_TYPE_P(attachment_name) != IS_STRING) {
PHALCON_INIT_VAR(base_path);
phalcon_call_func_p1(base_path, "basename", file_path);
} else {
PHALCON_CPY_WRT(base_path, attachment_name);
}
if (zend_is_true(attachment)) {
PHALCON_INIT_VAR(headers);
phalcon_call_method(headers, this_ptr, "getheaders");
PHALCON_INIT_VAR(content_description);
ZVAL_STRING(content_description, "Content-Description: File Transfer", 1);
phalcon_call_method_p1_noret(headers, "setraw", content_description);
PHALCON_INIT_VAR(content_disposition);
PHALCON_CONCAT_SV(content_disposition, "Content-Disposition: attachment; filename=", base_path);
phalcon_call_method_p1_noret(headers, "setraw", content_disposition);
PHALCON_INIT_VAR(content_transfer);
ZVAL_STRING(content_transfer, "Content-Transfer-Encoding: binary", 1);
phalcon_call_method_p1_noret(headers, "setraw", content_transfer);
}
phalcon_update_property_this(this_ptr, SL("_file"), file_path TSRMLS_CC);
RETURN_THIS();
}
/**
* Writes the meta-data to $_SESSION
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, write){
zval *key, *data, *prefix, *prefix_key, *_SESSION;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &key, &data);
prefix = phalcon_read_property(getThis(), SL("_prefix"), PH_NOISY);
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "$PMM$", prefix);
_SESSION = phalcon_get_global(SL("_SESSION"));
phalcon_array_update_multi_2(_SESSION, prefix_key, key, data, PH_COPY);
PHALCON_MM_RESTORE();
}
