PHP_METHOD(Configman_BaseServiceConfig, getService) {
int ZEPHIR_LAST_CALL_STATUS;
zend_class_entry *_1;
zval *service_param = NULL, *service_class_name, *upcase_service, *_0 = NULL;
zval *service = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &service_param);
zephir_get_strval(service, service_param);
ZEPHIR_INIT_VAR(upcase_service);
zephir_ucfirst(upcase_service, service);
ZEPHIR_INIT_VAR(service_class_name);
ZEPHIR_CONCAT_SVSVS(service_class_name, "\\Configman\\Service\\", upcase_service, "\\", upcase_service, "Config");
zephir_fetch_safe_class(_0, service_class_name);
_1 = zend_fetch_class(Z_STRVAL_P(_0), Z_STRLEN_P(_0), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _1);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, service);
zephir_check_call_status();
}
RETURN_MM();
}
/**
* Escapes a column/table/schema name
*
* @param string|array identifier
* @return string
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, escapeIdentifier) {
zval *identifier, *domain, *name;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &identifier);
if (Z_TYPE_P(identifier) == IS_ARRAY) {
ZEPHIR_OBS_VAR(domain);
zephir_array_fetch_long(&domain, identifier, 0, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 63 TSRMLS_CC);
ZEPHIR_OBS_VAR(name);
zephir_array_fetch_long(&name, identifier, 1, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 64 TSRMLS_CC);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_SVSVS(return_value, "`", domain, "`.`", name, "`");
RETURN_MM();
}
ZEPHIR_CONCAT_VSV(return_value, domain, ".", name);
RETURN_MM();
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_SVS(return_value, "`", identifier, "`");
RETURN_MM();
}
RETVAL_ZVAL(identifier, 1, 0);
RETURN_MM();
}
/**
* Generates SQL to query foreign keys on a table
*
* @param string table
* @param string schema
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, describeReferences) {
zval *table, *schema = NULL, *sql, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(sql);
ZVAL_STRING(sql, "SELECT tc.table_name as TABLE_NAME, kcu.column_name as COLUMN_NAME, tc.constraint_name as CONSTRAINT_NAME, tc.table_catalog as REFERENCED_TABLE_SCHEMA, ccu.table_name AS REFERENCED_TABLE_NAME, ccu.column_name AS REFERENCED_COLUMN_NAME FROM information_schema.table_constraints AS tc JOIN information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name JOIN information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name WHERE constraint_type = 'FOREIGN KEY' AND ", 1);
if (zephir_is_true(schema)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVSVS(_0, "tc.table_schema = '", schema, "' AND tc.table_name='", table, "'");
zephir_concat_self(&sql, _0 TSRMLS_CC);
} else {
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "tc.table_name='", table, "'");
zephir_concat_self(&sql, _0 TSRMLS_CC);
}
RETURN_CCTOR(sql);
}
/**
* Generates the SQL for LIMIT clause
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, limit) {
int limit, offset = 0;
zval *sqlQuery_param = NULL, *number, *_0 = NULL, *_1, _2 = zval_used_for_init, *_3, _4 = zval_used_for_init, _6;
zval *sqlQuery = NULL, *_5, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &sqlQuery_param, &number);
if (unlikely(Z_TYPE_P(sqlQuery_param) != IS_STRING && Z_TYPE_P(sqlQuery_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlQuery' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sqlQuery_param) == IS_STRING)) {
zephir_get_strval(sqlQuery, sqlQuery_param);
} else {
ZEPHIR_INIT_VAR(sqlQuery);
ZVAL_EMPTY_STRING(sqlQuery);
}
if (Z_TYPE_P(number) == IS_ARRAY) {
if (zephir_array_isset_long(number, 1)) {
ZEPHIR_INIT_VAR(_0);
zephir_array_fetch_long(&_1, number, 1, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 51 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "'", 0);
zephir_fast_trim(_0, _1, &_2, ZEPHIR_TRIM_BOTH TSRMLS_CC);
offset = zephir_get_intval(_0);
}
ZEPHIR_INIT_NVAR(_0);
zephir_array_fetch_long(&_1, number, 0, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 54 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRING(&_2, "'", 0);
zephir_fast_trim(_0, _1, &_2, ZEPHIR_TRIM_BOTH TSRMLS_CC);
limit = (zephir_get_intval(_0) + offset);
} else {
ZEPHIR_INIT_VAR(_3);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "'", 0);
zephir_fast_trim(_3, number, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC);
limit = zephir_get_intval(_3);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, limit);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVSVS(_5, "SELECT * FROM (SELECT Z1.*, ROWNUM PHALCON_RN FROM (", sqlQuery, ") Z1 WHERE ROWNUM <= ", &_4, ")");
ZEPHIR_CPY_WRT(sqlQuery, _5);
if (offset != 0) {
ZEPHIR_SINIT_VAR(_6);
ZVAL_LONG(&_6, offset);
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SV(_7, " WHERE PHALCON_RN >= ", &_6);
zephir_concat_self(&sqlQuery, _7 TSRMLS_CC);
}
RETURN_CTOR(sqlQuery);
}
/**
* Produces an string representation of a variable
*/
PHP_METHOD(Phalcon_Debug, _getVarDump) {
zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *variable, *className, *dumpedObject = NULL, *dump, *_0 = NULL, *_2 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &variable);
ZEPHIR_CALL_FUNCTION(&_0, "is_scalar", &_1, variable);
zephir_check_call_status();
if (zephir_is_true(_0)) {
if (Z_TYPE_P(variable) == IS_BOOL) {
if (zephir_is_true(variable)) {
RETURN_MM_STRING("true", 1);
} else {
RETURN_MM_STRING("false", 1);
}
}
if (Z_TYPE_P(variable) == IS_STRING) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_escapestring", NULL, variable);
zephir_check_call_status();
RETURN_MM();
}
RETVAL_ZVAL(variable, 1, 0);
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_OBJECT) {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, variable, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(dump);
if ((zephir_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&dumpedObject, variable, "dump", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, dumpedObject);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(dump, "Object(", className, ": ", _2, ")");
} else {
ZEPHIR_CONCAT_SVS(dump, "Object(", className, ")</span>");
}
RETURN_CCTOR(dump);
}
if (Z_TYPE_P(variable) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_2, this_ptr, "_getarraydump", &_3, variable);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "Array(", _2, ")");
RETURN_MM();
}
if (Z_TYPE_P(variable) == IS_NULL) {
RETURN_MM_STRING("null", 1);
}
zephir_gettype(return_value, variable TSRMLS_CC);
RETURN_MM();
}
/**
* Generates SQL to delete an index from a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, dropIndex) {
zval *tableName_param = NULL, *schemaName_param = NULL, *indexName_param = NULL, *sql = NULL;
zval *tableName = NULL, *schemaName = NULL, *indexName = NULL, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &tableName_param, &schemaName_param, &indexName_param);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
if (unlikely(Z_TYPE_P(indexName_param) != IS_STRING && Z_TYPE_P(indexName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'indexName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(indexName_param) == IS_STRING)) {
zephir_get_strval(indexName, indexName_param);
} else {
ZEPHIR_INIT_VAR(indexName);
ZVAL_EMPTY_STRING(indexName);
}
ZEPHIR_INIT_VAR(sql);
if (schemaName && Z_STRLEN_P(schemaName)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVSVS(_0, "DROP INDEX \"", schemaName, "\".\"", indexName, "\"");
ZEPHIR_CPY_WRT(sql, _0);
} else {
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "DROP INDEX \"", indexName, "\"");
ZEPHIR_CPY_WRT(sql, _0);
}
RETURN_CCTOR(sql);
}
/**
* Generates SQL to query foreign keys on a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, describeReferences) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *table_param = NULL, *schema_param = NULL, *sql, *_0 = NULL, *_2 = NULL, *_3 = NULL;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(sql);
ZVAL_STRING(sql, "SELECT AC.TABLE_NAME, CC.COLUMN_NAME, AC.CONSTRAINT_NAME, AC.R_OWNER, RCC.TABLE_NAME R_TABLE_NAME, RCC.COLUMN_NAME R_COLUMN_NAME FROM ALL_CONSTRAINTS AC JOIN ALL_CONS_COLUMNS CC ON AC.CONSTRAINT_NAME = CC.CONSTRAINT_NAME JOIN ALL_CONS_COLUMNS RCC ON AC.R_OWNER = RCC.OWNER AND AC.R_CONSTRAINT_NAME = RCC.CONSTRAINT_NAME WHERE AC.CONSTRAINT_TYPE='R' ", 1);
if (!ZEPHIR_IS_STRING(schema, "")) {
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, schema);
zephir_check_call_status();
ZEPHIR_CALL_CE_STATIC(&_2, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVSVS(_3, "AND AC.OWNER='", _0, "' AND AC.TABLE_NAME = '", _2, "'");
zephir_concat_self(&sql, _3 TSRMLS_CC);
} else {
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_SVS(_3, "AND AC.TABLE_NAME = '", _0, "'");
zephir_concat_self(&sql, _3 TSRMLS_CC);
}
RETURN_CCTOR(sql);
}
/**
* Generates a link to the current version documentation
*/
PHP_METHOD(Phalcon_Debug, getVersion) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_0 = NULL, *_1 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmajorversion", NULL);
zephir_check_call_status();
ZEPHIR_CALL_CE_STATIC(&_1, phalcon_version_ce, "get", &_2);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "<div class=\"version\">Phalcon Framework <a target=\"_new\" href=\"http://docs.phalconphp.com/en/", _0, "/\">", _1, "</a></div>");
RETURN_MM();
}
PHP_METHOD(PocketMine_Math_Vector2, __toString) {
zval *_1 = NULL, *_3 = NULL;
zval *_0, *_2;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("x"), PH_NOISY_CC);
zephir_get_strval(_1, _0);
ZEPHIR_OBS_VAR(_2);
zephir_read_property_this(&_2, this_ptr, SL("y"), PH_NOISY_CC);
zephir_get_strval(_3, _2);
ZEPHIR_CONCAT_SVSVS(return_value, "Vector2(x=", _1, ",y=", _3, ")");
RETURN_MM();
}
/**
* Escapes a column/table/schema name
*
*<code>
* $escapedTable = $connection->escapeIdentifier('robots');
* $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
*</code>
*
* @param string identifier
* @return string
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, escapeIdentifier) {
zval *identifier, *_0, *_1;
zephir_fetch_params(0, 1, 0, &identifier);
if (Z_TYPE_P(identifier) == IS_ARRAY) {
zephir_array_fetch_long(&_0, identifier, 0, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo.zep", 377 TSRMLS_CC);
zephir_array_fetch_long(&_1, identifier, 1, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo.zep", 377 TSRMLS_CC);
ZEPHIR_CONCAT_SVSVS(return_value, "\"", _0, "\".\"", _1, "\"");
return;
}
ZEPHIR_CONCAT_SVS(return_value, "\"", identifier, "\"");
return;
}
/**
* Generates SQL checking for the existence of a schema.table
*
* <code>
* echo $dialect->tableExists("posts", "blog");
* echo $dialect->tableExists("posts");
* </code>
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, tableExists) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *tableName_param = NULL, *schemaName_param = NULL, *_0 = NULL, *_2 = NULL;
zval *tableName = NULL, *schemaName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &tableName_param, &schemaName_param);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (!schemaName_param) {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
} else {
zephir_get_strval(schemaName, schemaName_param);
}
if (!ZEPHIR_IS_STRING(schemaName, "")) {
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, tableName);
zephir_check_call_status();
ZEPHIR_CALL_CE_STATIC(&_2, phalcon_text_ce, "upper", &_1, 144, schemaName);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END RET FROM ALL_TABLES WHERE TABLE_NAME='", _0, "' AND OWNER = '", _2, "'");
RETURN_MM();
}
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, tableName);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END RET FROM ALL_TABLES WHERE TABLE_NAME='", _0, "'");
RETURN_MM();
}
/**
* Generates SQL describing a table
*
* <code>
* print_r($dialect->describeColumns("posts"));
* </code>
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, describeColumns) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *table_param = NULL, *schema_param = NULL, *_0 = NULL, *_2 = NULL;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
if (!ZEPHIR_IS_STRING(schema, "")) {
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_CALL_CE_STATIC(&_2, phalcon_text_ce, "upper", &_1, 144, schema);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "SELECT TC.COLUMN_NAME, TC.DATA_TYPE, TC.DATA_LENGTH, TC.DATA_PRECISION, TC.DATA_SCALE, TC.NULLABLE, C.CONSTRAINT_TYPE, TC.DATA_DEFAULT, CC.POSITION FROM ALL_TAB_COLUMNS TC LEFT JOIN (ALL_CONS_COLUMNS CC JOIN ALL_CONSTRAINTS C ON (CC.CONSTRAINT_NAME = C.CONSTRAINT_NAME AND CC.TABLE_NAME = C.TABLE_NAME AND CC.OWNER = C.OWNER AND C.CONSTRAINT_TYPE = 'P')) ON TC.TABLE_NAME = CC.TABLE_NAME AND TC.COLUMN_NAME = CC.COLUMN_NAME WHERE TC.TABLE_NAME = '", _0, "' AND TC.OWNER = '", _2, "' ORDER BY TC.COLUMN_ID");
RETURN_MM();
}
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "SELECT TC.COLUMN_NAME, TC.DATA_TYPE, TC.DATA_LENGTH, TC.DATA_PRECISION, TC.DATA_SCALE, TC.NULLABLE, C.CONSTRAINT_TYPE, TC.DATA_DEFAULT, CC.POSITION FROM ALL_TAB_COLUMNS TC LEFT JOIN (ALL_CONS_COLUMNS CC JOIN ALL_CONSTRAINTS C ON (CC.CONSTRAINT_NAME = C.CONSTRAINT_NAME AND CC.TABLE_NAME = C.TABLE_NAME AND CC.OWNER = C.OWNER AND C.CONSTRAINT_TYPE = 'P')) ON TC.TABLE_NAME = CC.TABLE_NAME AND TC.COLUMN_NAME = CC.COLUMN_NAME WHERE TC.TABLE_NAME = '", _0, "' ORDER BY TC.COLUMN_ID");
RETURN_MM();
}
/**
* Generates SQL to query indexes on a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, describeIndexes) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *table_param = NULL, *schema_param = NULL, *_0 = NULL, *_2 = NULL;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
if (!ZEPHIR_IS_STRING(schema, "")) {
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_CALL_CE_STATIC(&_2, phalcon_text_ce, "upper", &_1, 144, schema);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "SELECT I.TABLE_NAME, 0 AS C0, I.INDEX_NAME, IC.COLUMN_POSITION, IC.COLUMN_NAME FROM ALL_INDEXES I JOIN ALL_IND_COLUMNS IC ON I.INDEX_NAME = IC.INDEX_NAME WHERE I.TABLE_NAME = '", _0, "' AND IC.INDEX_OWNER = '", _2, "'");
RETURN_MM();
}
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_text_ce, "upper", &_1, 144, table);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "SELECT I.TABLE_NAME, 0 AS C0, I.INDEX_NAME, IC.COLUMN_POSITION, IC.COLUMN_NAME FROM ALL_INDEXES I JOIN ALL_IND_COLUMNS IC ON I.INDEX_NAME = IC.INDEX_NAME WHERE I.TABLE_NAME = '", _0, "'");
RETURN_MM();
}
/**
* Generates a SQL describing a table
*
* <code>print_r(dialect->describeColumns("posts") ?></code>
*
* @param string table
* @param string schema
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, describeColumns) {
zval *table, *schema = NULL, *sql;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(schema)) {
ZEPHIR_CONCAT_SVSVS(sql, "SELECT DISTINCT c.column_name AS Field, c.data_type AS Type, c.character_maximum_length AS Size, c.numeric_precision AS NumericSize, c.numeric_scale AS NumericScale, c.is_nullable AS Null, CASE WHEN pkc.column_name NOTNULL THEN 'PRI' ELSE '' END AS Key, CASE WHEN c.data_type LIKE '%int%' AND c.column_default LIKE '%nextval%' THEN 'auto_increment' ELSE '' END AS Extra, c.ordinal_position AS Position, c.column_default FROM information_schema.columns c LEFT JOIN ( SELECT kcu.column_name, kcu.table_name, kcu.table_schema FROM information_schema.table_constraints tc INNER JOIN information_schema.key_column_usage kcu on (kcu.constraint_name = tc.constraint_name and kcu.table_name=tc.table_name and kcu.table_schema=tc.table_schema) WHERE tc.constraint_type='PRIMARY KEY') pkc ON (c.column_name=pkc.column_name AND c.table_schema = pkc.table_schema AND c.table_name=pkc.table_name) WHERE c.table_schema='", schema, "' AND c.table_name='", table, "' ORDER BY c.ordinal_position");
} else {
ZEPHIR_CONCAT_SVS(sql, "SELECT DISTINCT c.column_name AS Field, c.data_type AS Type, c.character_maximum_length AS Size, c.numeric_precision AS NumericSize, c.numeric_scale AS NumericScale, c.is_nullable AS Null, CASE WHEN pkc.column_name NOTNULL THEN 'PRI' ELSE '' END AS Key, CASE WHEN c.data_type LIKE '%int%' AND c.column_default LIKE '%nextval%' THEN 'auto_increment' ELSE '' END AS Extra, c.ordinal_position AS Position, c.column_default FROM information_schema.columns c LEFT JOIN ( SELECT kcu.column_name, kcu.table_name, kcu.table_schema FROM information_schema.table_constraints tc INNER JOIN information_schema.key_column_usage kcu on (kcu.constraint_name = tc.constraint_name and kcu.table_name=tc.table_name and kcu.table_schema=tc.table_schema) WHERE tc.constraint_type='PRIMARY KEY') pkc ON (c.column_name=pkc.column_name AND c.table_schema = pkc.table_schema AND c.table_name=pkc.table_name) WHERE c.table_schema='public' AND c.table_name='", table, "' ORDER BY c.ordinal_position");
}
RETURN_CCTOR(sql);
}
/**
* Generates SQL checking for the existence of a schema.view
*
* @param string viewName
* @param string schemaName
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, viewExists) {
zval *viewName, *schemaName = NULL, *sql;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &viewName, &schemaName);
if (!schemaName) {
schemaName = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(schemaName)) {
ZEPHIR_CONCAT_SVSVS(sql, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END FROM pg_views WHERE viewname='", viewName, "' AND schemaname='", schemaName, "'");
} else {
ZEPHIR_CONCAT_SVS(sql, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END FROM pg_views WHERE viewname='", viewName, "'");
}
RETURN_CCTOR(sql);
}
/**
* Generates SQL checking for the existence of a schema.table
*
* <code>echo dialect->tableExists("posts", "blog")</code>
* <code>echo dialect->tableExists("posts")</code>
*
* @param string tableName
* @param string schemaName
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, tableExists) {
zval *tableName, *schemaName = NULL, *sql;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &tableName, &schemaName);
if (!schemaName) {
schemaName = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(schemaName)) {
ZEPHIR_CONCAT_SVSVS(sql, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END FROM information_schema.tables WHERE table_schema = '", schemaName, "' AND table_name='", tableName, "'");
} else {
ZEPHIR_CONCAT_SVS(sql, "SELECT CASE WHEN COUNT(*) > 0 THEN 1 ELSE 0 END FROM information_schema.tables WHERE table_schema = 'public' AND table_name='", tableName, "'");
}
RETURN_CCTOR(sql);
}
/**
* Appends a condition to the current conditions using an OR operator
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere) {
int ZEPHIR_LAST_CALL_STATUS;
zval *conditions_param = NULL, *bindParams = NULL, *bindTypes = NULL, *currentConditions = NULL, *_0, *_1$$3;
zval *conditions = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &conditions_param, &bindParams, &bindTypes);
if (unlikely(Z_TYPE_P(conditions_param) != IS_STRING && Z_TYPE_P(conditions_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'conditions' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(conditions_param) == IS_STRING)) {
zephir_get_strval(conditions, conditions_param);
} else {
ZEPHIR_INIT_VAR(conditions);
ZVAL_EMPTY_STRING(conditions);
}
if (!bindParams) {
bindParams = ZEPHIR_GLOBAL(global_null);
}
if (!bindTypes) {
bindTypes = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(currentConditions);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(¤tConditions, _0, SS("conditions"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_1$$3);
ZEPHIR_CONCAT_SVSVS(_1$$3, "(", currentConditions, ") OR (", conditions, ")");
zephir_get_strval(conditions, _1$$3);
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "where", NULL, 0, conditions, bindParams, bindTypes);
zephir_check_call_status();
RETURN_MM();
}
/**
* Transforms an intermediate representation for a expression into a database system valid expression
*
* @param array expression
* @param string escapeChar
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, getSqlExpression) {
zephir_fcall_cache_entry *_10 = NULL;
HashTable *_7, *_13;
HashPosition _6, _12;
int ZEPHIR_LAST_CALL_STATUS;
zval *escapeChar = NULL, *_1 = NULL;
zval *expression, *escapeChar_param = NULL, *type, *domain, *operator, *left = NULL, *right = NULL, *name = NULL, *sqlItems, *escapedName = NULL, *sqlArguments, *arguments, *argument = NULL, *item = NULL, *_0, *_2, *_3, *_4, *_5 = NULL, **_8, *_9 = NULL, *_11 = NULL, **_14, *_15, *_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &expression, &escapeChar_param);
if (!escapeChar_param) {
ZEPHIR_INIT_VAR(escapeChar);
ZVAL_EMPTY_STRING(escapeChar);
} else {
zephir_get_strval(escapeChar, escapeChar_param);
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) {
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC);
zephir_get_strval(_1, _0);
ZEPHIR_CPY_WRT(escapeChar, _1);
}
}
if (Z_TYPE_P(expression) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 176);
return;
}
ZEPHIR_OBS_VAR(type);
if (!(zephir_array_isset_string_fetch(&type, expression, SS("type"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 180);
return;
}
if (ZEPHIR_IS_STRING(type, "qualified")) {
ZEPHIR_OBS_VAR(name);
zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_INIT_VAR(escapedName);
ZEPHIR_CONCAT_VVV(escapedName, escapeChar, name, escapeChar);
} else {
ZEPHIR_CPY_WRT(escapedName, name);
}
ZEPHIR_OBS_VAR(domain);
if (zephir_array_isset_string_fetch(&domain, expression, SS("domain"), 0 TSRMLS_CC)) {
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVVSV(return_value, escapeChar, domain, escapeChar, ".", escapedName);
RETURN_MM();
} else {
ZEPHIR_CONCAT_VSV(return_value, domain, ".", escapedName);
RETURN_MM();
}
}
RETURN_CCTOR(escapedName);
}
if (ZEPHIR_IS_STRING(type, "literal")) {
zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
RETURN_CTOR(_2);
}
if (ZEPHIR_IS_STRING(type, "binary-op")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", NULL, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", NULL, _3, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_4, expression, SL("op"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CONCAT_VSVSV(return_value, left, " ", _4, " ", right);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "unary-op")) {
ZEPHIR_OBS_VAR(operator);
zephir_array_fetch_string(&operator, expression, SL("op"), PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(left);
if (zephir_array_isset_string_fetch(&left, expression, SS("left"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, left, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, _5, operator);
RETURN_MM();
}
ZEPHIR_OBS_NVAR(right);
if (zephir_array_isset_string_fetch(&right, expression, SS("right"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, right, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, _5, operator);
RETURN_MM();
}
}
if (ZEPHIR_IS_STRING(type, "placeholder")) {
zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
RETURN_CTOR(_2);
}
if (ZEPHIR_IS_STRING(type, "parentheses")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, _2, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "(", _5, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "functionCall")) {
ZEPHIR_OBS_NVAR(name);
zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC);
ZEPHIR_INIT_VAR(sqlArguments);
array_init(sqlArguments);
ZEPHIR_OBS_VAR(arguments);
if (zephir_array_isset_string_fetch(&arguments, expression, SS("arguments"), 0 TSRMLS_CC)) {
zephir_is_iterable(arguments, &_7, &_6, 0, 0);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(argument, _8);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "getsqlexpression", &_10, argument, escapeChar);
zephir_check_call_status();
zephir_array_append(&sqlArguments, _9, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(_11);
zephir_fast_join_str(_11, SL(", "), sqlArguments TSRMLS_CC);
ZEPHIR_CONCAT_VSVS(return_value, name, "(", _11, ")");
RETURN_MM();
} else {
ZEPHIR_CONCAT_VS(return_value, name, "()");
RETURN_MM();
}
}
if (ZEPHIR_IS_STRING(type, "list")) {
ZEPHIR_INIT_VAR(sqlItems);
array_init(sqlItems);
zephir_array_fetch_long(&_2, expression, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_is_iterable(_2, &_13, &_12, 0, 0);
for (
; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS
; zephir_hash_move_forward_ex(_13, &_12)
) {
ZEPHIR_GET_HVALUE(item, _14);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", &_10, item, escapeChar);
zephir_check_call_status();
zephir_array_append(&sqlItems, _5, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_11);
zephir_fast_join_str(_11, SL(", "), sqlItems TSRMLS_CC);
ZEPHIR_CONCAT_SVS(return_value, "(", _11, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "all")) {
RETURN_MM_STRING("*", 1);
}
if (ZEPHIR_IS_STRING(type, "cast")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "CAST(", left, " AS ", right, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "convert")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "CONVERT(", left, " USING ", right, ")");
RETURN_MM();
}
ZEPHIR_INIT_VAR(_15);
object_init_ex(_15, pdm_db_exception_ce);
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "Invalid SQL expression type '", type, "'");
ZEPHIR_CALL_METHOD(NULL, _15, "__construct", NULL, _16);
zephir_check_call_status();
zephir_throw_exception_debug(_15, "pdm/db/abstractdialect.zep", 287 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Dispatches a handle action taking into account the routing parameters
*
* @return object
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch) {
zval *_18 = NULL;
zephir_fcall_cache_entry *_4 = NULL, *_5 = NULL, *_8 = NULL, *_10 = NULL, *_11 = NULL, *_12 = NULL, *_13 = NULL, *_14 = NULL, *_16 = NULL, *_19 = NULL;
zval *value, *handler = NULL, *dependencyInjector = NULL, *namespaceName = NULL, *handlerName = NULL, *actionName = NULL, *camelizedClass = NULL, *params = NULL, *eventsManager = NULL, *handlerSuffix, *actionSuffix, *handlerClass = NULL, *status = NULL, *actionMethod = NULL, *e = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_6, *_7 = NULL, *_9 = NULL, *_15 = NULL, *_17;
int numberDispatches, ZEPHIR_LAST_CALL_STATUS;
zend_bool hasService, wasFresh = 0;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "A dependency injection container is required to access related dispatching services", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:beforeDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, eventsManager, "fire", NULL, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_VAR(value);
ZVAL_NULL(value);
ZEPHIR_INIT_VAR(handler);
ZVAL_NULL(handler);
numberDispatches = 0;
ZEPHIR_OBS_VAR(handlerSuffix);
zephir_read_property_this(&handlerSuffix, this_ptr, SL("_handlerSuffix"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(actionSuffix);
zephir_read_property_this(&actionSuffix, this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_finished"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
while (1) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (!(!(zephir_is_true(_0)))) {
break;
}
numberDispatches++;
if (numberDispatches == 256) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Dispatcher has detected a cyclic routing causing stability problems", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, 1);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", &_4, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
break;
}
zephir_update_property_this(this_ptr, SL("_finished"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
ZEPHIR_OBS_NVAR(namespaceName);
zephir_read_property_this(&namespaceName, this_ptr, SL("_namespaceName"), PH_NOISY_CC);
if (!(zephir_is_true(namespaceName))) {
ZEPHIR_OBS_NVAR(namespaceName);
zephir_read_property_this(&namespaceName, this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespaceName"), namespaceName TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(handlerName);
zephir_read_property_this(&handlerName, this_ptr, SL("_handlerName"), PH_NOISY_CC);
if (!(zephir_is_true(handlerName))) {
ZEPHIR_OBS_NVAR(handlerName);
zephir_read_property_this(&handlerName, this_ptr, SL("_defaultHandler"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_handlerName"), handlerName TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_actionName"), PH_NOISY_CC);
if (!(zephir_is_true(actionName))) {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_actionName"), actionName TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:beforeDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, eventsManager, "fire", &_5, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_3)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
if (!(zephir_memnstr_str(handlerName, SL("\\"), "phalcon/dispatcher.zep", 390))) {
ZEPHIR_INIT_NVAR(camelizedClass);
zephir_camelize(camelizedClass, handlerName);
} else {
ZEPHIR_CPY_WRT(camelizedClass, handlerName);
}
if (zephir_is_true(namespaceName)) {
ZEPHIR_INIT_NVAR(handlerClass);
if (zephir_end_with_str(namespaceName, SL("\\"))) {
ZEPHIR_CONCAT_VVV(handlerClass, namespaceName, camelizedClass, handlerSuffix);
} else {
ZEPHIR_CONCAT_VSVV(handlerClass, namespaceName, "\\", camelizedClass, handlerSuffix);
}
} else {
ZEPHIR_INIT_NVAR(handlerClass);
ZEPHIR_CONCAT_VV(handlerClass, camelizedClass, handlerSuffix);
}
ZEPHIR_CALL_METHOD(&_7, dependencyInjector, "has", &_8, handlerClass);
zephir_check_call_status();
hasService = zephir_get_boolval(_7);
if (!(hasService)) {
hasService = zephir_class_exists(handlerClass, 1 TSRMLS_CC);
}
if (!(hasService)) {
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_VS(_9, handlerClass, " handler class cannot be loaded");
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 2);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_10, _9, _1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
break;
}
ZEPHIR_CALL_METHOD(&handler, dependencyInjector, "getshared", &_11, handlerClass);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7, dependencyInjector, "wasfreshinstance", &_12);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_7)) {
wasFresh = 1;
}
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Invalid handler returned from the services container", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, 3);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_13, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
break;
}
zephir_update_property_this(this_ptr, SL("_activeHandler"), handler TSRMLS_CC);
ZEPHIR_OBS_NVAR(params);
zephir_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (Z_TYPE_P(params) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Action parameters must be an Array", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, 4);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_14, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
break;
}
ZEPHIR_INIT_NVAR(actionMethod);
ZEPHIR_CONCAT_VV(actionMethod, actionName, actionSuffix);
if (!((zephir_method_exists(handler, actionMethod TSRMLS_CC) == SUCCESS))) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:beforeNotFoundAction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_15, eventsManager, "fire", &_5, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "Action '", actionName, "' was not found on handler '", handlerName, "'");
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 5);
ZEPHIR_CALL_METHOD(&status, this_ptr, "_throwdispatchexception", &_16, _9, _1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
_17 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_17)) {
continue;
}
}
break;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:beforeExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_15, eventsManager, "fire", &_5, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
if ((zephir_method_exists_ex(handler, SS("beforeexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_15, handler, "beforeexecuteroute", NULL, this_ptr);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
if (wasFresh == 1) {
if ((zephir_method_exists_ex(handler, SS("initialize") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, handler, "initialize", NULL);
zephir_check_call_status();
}
if (zephir_is_true(eventsManager)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:afterInitialize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_15, eventsManager, "fire", &_5, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
}
/* try_start_1: */
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_INIT_NVAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, handler);
zephir_array_fast_append(_18, actionMethod);
ZEPHIR_CALL_USER_FUNC_ARRAY(_1, _18, params);
zephir_check_call_status_or_jump(try_end_1);
zephir_update_property_this(this_ptr, SL("_returnedValue"), _1 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_lastHandler"), handler TSRMLS_CC);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_CALL_METHOD(&_15, this_ptr, "_handleexception", &_19, e);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
} else {
zephir_throw_exception_debug(e, "phalcon/dispatcher.zep", 550 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "dispatch:afterExecuteRoute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_15, eventsManager, "fire", &_5, _2, this_ptr, value);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "dispatch:afterDispatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_5, _2, this_ptr);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
if ((zephir_method_exists_ex(handler, SS("afterexecuteroute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_15, handler, "afterexecuteroute", NULL, this_ptr, value);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_15)) {
continue;
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_finished"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
continue;
}
}
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "dispatch:afterDispatchLoop", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_5, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
RETURN_CCTOR(handler);
}
/**
* Appends a condition to the current conditions using an OR operator
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere) {
zval *conditions_param = NULL, *bindParams = NULL, *bindTypes = NULL, *currentBindParams = NULL, *mergedParams = NULL, *mergedParamsTypes = NULL, *currentBindTypes = NULL, *params = NULL, *currentConditions = NULL, *_0$$3, *_1$$3, *_2$$4, *_3$$5, *_4$$8;
zval *conditions = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &conditions_param, &bindParams, &bindTypes);
if (unlikely(Z_TYPE_P(conditions_param) != IS_STRING && Z_TYPE_P(conditions_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'conditions' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(conditions_param) == IS_STRING)) {
zephir_get_strval(conditions, conditions_param);
} else {
ZEPHIR_INIT_VAR(conditions);
ZVAL_EMPTY_STRING(conditions);
}
if (!bindParams) {
bindParams = ZEPHIR_GLOBAL(global_null);
}
if (!bindTypes) {
bindTypes = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(params);
zephir_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(currentConditions);
if (zephir_array_isset_string_fetch(¤tConditions, params, SS("conditions"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0$$3);
ZEPHIR_CONCAT_SVSVS(_0$$3, "(", currentConditions, ") OR (", conditions, ")");
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "conditions", 1);
zephir_update_property_array(this_ptr, SL("_params"), _1$$3, _0$$3 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_2$$4);
ZVAL_STRING(_2$$4, "conditions", 1);
zephir_update_property_array(this_ptr, SL("_params"), _2$$4, conditions TSRMLS_CC);
}
if (Z_TYPE_P(bindParams) == IS_ARRAY) {
ZEPHIR_OBS_VAR(currentBindParams);
if (zephir_array_isset_string_fetch(¤tBindParams, params, SS("bind"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(mergedParams);
zephir_fast_array_merge(mergedParams, &(currentBindParams), &(bindParams) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParams, bindParams);
}
ZEPHIR_INIT_VAR(_3$$5);
ZVAL_STRING(_3$$5, "bind", 1);
zephir_update_property_array(this_ptr, SL("_params"), _3$$5, mergedParams TSRMLS_CC);
}
if (Z_TYPE_P(bindTypes) == IS_ARRAY) {
ZEPHIR_OBS_VAR(currentBindTypes);
if (zephir_array_isset_string_fetch(¤tBindTypes, params, SS("bindTypes"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(mergedParamsTypes);
zephir_fast_array_merge(mergedParamsTypes, &(currentBindTypes), &(bindTypes) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParamsTypes, bindTypes);
}
ZEPHIR_INIT_VAR(_4$$8);
ZVAL_STRING(_4$$8, "bindTypes", 1);
zephir_update_property_array(this_ptr, SL("_params"), _4$$8, mergedParamsTypes TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput) {
zend_bool _6$$4, _7$$7;
HashTable *_4$$3;
HashPosition _3$$3;
zend_class_entry *_2$$3;
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL;
zval *modelName = NULL, *operator = NULL, *_12$$10;
zval *dependencyInjector, *modelName_param = NULL, *data_param = NULL, *operator_param = NULL, *attribute = NULL, *conditions = NULL, *field = NULL, *value = NULL, *type = NULL, *metaData = NULL, *model = NULL, *dataTypes = NULL, *bind = NULL, *criteria = NULL, *columnMap = NULL, *_0$$3, *_1$$3 = NULL, **_5$$3, *_8$$9 = NULL, *_9$$9 = NULL, *_10$$8 = NULL, *_11$$10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &dependencyInjector, &modelName_param, &data_param, &operator_param);
if (unlikely(Z_TYPE_P(modelName_param) != IS_STRING && Z_TYPE_P(modelName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'modelName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(modelName_param) == IS_STRING)) {
zephir_get_strval(modelName, modelName_param);
} else {
ZEPHIR_INIT_VAR(modelName);
ZVAL_EMPTY_STRING(modelName);
}
data = data_param;
if (!operator_param) {
ZEPHIR_INIT_VAR(operator);
ZVAL_STRING(operator, "AND", 1);
} else {
if (unlikely(Z_TYPE_P(operator_param) != IS_STRING && Z_TYPE_P(operator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'operator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(operator_param) == IS_STRING)) {
zephir_get_strval(operator, operator_param);
} else {
ZEPHIR_INIT_VAR(operator);
ZVAL_EMPTY_STRING(operator);
}
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
if (zephir_fast_count_int(data TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_STRING(_0$$3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0$$3);
zephir_check_temp_parameter(_0$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(model);
zephir_fetch_safe_class(_1$$3, modelName);
_2$$3 = zend_fetch_class(Z_STRVAL_P(_1$$3), Z_STRLEN_P(_1$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(model, _2$$3);
if (zephir_has_constructor(model TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, model, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&dataTypes, metaData, "getdatatypes", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bind);
array_init(bind);
zephir_is_iterable(data, &_4$$3, &_3$$3, 0, 0, "phalcon/mvc/model/criteria.zep", 747);
for (
; zephir_hash_get_current_data_ex(_4$$3, (void**) &_5$$3, &_3$$3) == SUCCESS
; zephir_hash_move_forward_ex(_4$$3, &_3$$3)
) {
ZEPHIR_GET_HMKEY(field, _4$$3, _3$$3);
ZEPHIR_GET_HVALUE(value, _5$$3);
_6$$4 = Z_TYPE_P(columnMap) == IS_ARRAY;
if (_6$$4) {
_6$$4 = (zephir_fast_count_int(columnMap TSRMLS_CC)) ? 1 : 0;
}
if (_6$$4) {
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch(&attribute, columnMap, field, PH_NOISY, "phalcon/mvc/model/criteria.zep", 724 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(attribute, field);
}
ZEPHIR_OBS_NVAR(type);
if (zephir_array_isset_fetch(&type, dataTypes, attribute, 0 TSRMLS_CC)) {
_7$$7 = Z_TYPE_P(value) != IS_NULL;
if (_7$$7) {
_7$$7 = !ZEPHIR_IS_STRING_IDENTICAL(value, "");
}
if (_7$$7) {
if (ZEPHIR_IS_LONG(type, 2)) {
ZEPHIR_INIT_LNVAR(_8$$9);
ZEPHIR_CONCAT_SVSVS(_8$$9, "[", field, "] LIKE :", field, ":");
zephir_array_append(&conditions, _8$$9, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 736);
ZEPHIR_INIT_LNVAR(_9$$9);
ZEPHIR_CONCAT_SVS(_9$$9, "%", value, "%");
zephir_array_update_zval(&bind, field, &_9$$9, PH_COPY | PH_SEPARATE);
continue;
}
ZEPHIR_INIT_LNVAR(_10$$8);
ZEPHIR_CONCAT_SVSVS(_10$$8, "[", field, "] = :", field, ":");
zephir_array_append(&conditions, _10$$8, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 743);
zephir_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE);
}
}
}
}
ZEPHIR_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
if (zephir_has_constructor(criteria TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, criteria, "__construct", NULL, 0);
zephir_check_call_status();
}
if (zephir_fast_count_int(conditions TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_11$$10);
ZEPHIR_INIT_VAR(_12$$10);
ZEPHIR_CONCAT_SVS(_12$$10, " ", operator, " ");
zephir_fast_join(_11$$10, _12$$10, conditions TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, criteria, "where", NULL, 306, _11$$10);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, criteria, "bind", NULL, 307, bind);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, criteria, "setmodelname", NULL, 300, modelName);
zephir_check_call_status();
RETURN_CCTOR(criteria);
}
PHP_METHOD(PhalconPlus_Enum_Sys, getModuleConfigPath) {
zval *_0, *_4, *_7$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_6 = NULL;
zval *moduleDir_param = NULL, *confPrefix = NULL, *confPath = NULL, *_1 = NULL, _2, _3, *_5 = NULL, *_9 = NULL, *_8$$3 = NULL, *_10$$4, *_11$$4, *_12$$4;
zval *moduleDir = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &moduleDir_param);
zephir_get_strval(moduleDir, moduleDir_param);
ZEPHIR_INIT_VAR(confPrefix);
ZVAL_STRING(confPrefix, "", 1);
ZEPHIR_INIT_VAR(confPath);
ZVAL_STRING(confPath, "", 1);
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "/", 0);
zephir_fast_trim(_1, moduleDir, &_2, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "app", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "config", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "/", 0);
ZEPHIR_INIT_NVAR(confPrefix);
zephir_fast_join(confPrefix, &_3, _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_4, confPrefix);
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_GET_CONSTANT(_1, "APP_RUN_ENV");
zephir_array_fast_append(_4, _1);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, ".php", 1);
zephir_array_fast_append(_4, _1);
ZEPHIR_INIT_NVAR(confPath);
zephir_fast_join_str(confPath, SL(""), _4 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_5, "is_file", &_6, 44, confPath);
zephir_check_call_status();
if (!(zephir_is_true(_5))) {
ZEPHIR_INIT_VAR(_7$$3);
zephir_create_array(_7$$3, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_7$$3, confPrefix);
ZEPHIR_INIT_VAR(_8$$3);
ZVAL_STRING(_8$$3, "config", 1);
zephir_array_fast_append(_7$$3, _8$$3);
ZEPHIR_INIT_NVAR(_8$$3);
ZVAL_STRING(_8$$3, ".php", 1);
zephir_array_fast_append(_7$$3, _8$$3);
ZEPHIR_INIT_NVAR(confPath);
zephir_fast_join_str(confPath, SL(""), _7$$3 TSRMLS_CC);
}
ZEPHIR_CALL_FUNCTION(&_9, "is_file", &_6, 44, confPath);
zephir_check_call_status();
if (!(zephir_is_true(_9))) {
ZEPHIR_INIT_VAR(_10$$4);
object_init_ex(_10$$4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_11$$4);
ZEPHIR_GET_CONSTANT(_11$$4, "APP_RUN_ENV");
ZEPHIR_INIT_VAR(_12$$4);
ZEPHIR_CONCAT_SVSVS(_12$$4, "Module Config file not exists: ", confPath, " & ", _11$$4, ".php");
ZEPHIR_CALL_METHOD(NULL, _10$$4, "__construct", NULL, 7, _12$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_10$$4, "phalconplus/Enum/Sys.zep", 143 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_CCTOR(confPath);
}
/**
* Gets the column name in SQLite
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) {
HashTable *_13$$41;
HashPosition _12$$41;
zephir_fcall_cache_entry *_17 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *column, *columnSql = NULL, *type = NULL, *typeValues = NULL, *_0$$8 = NULL, *_1$$8, *_2$$10 = NULL, *_3$$10 = NULL, *_4$$10, *_5$$16 = NULL, *_6$$16, *_7$$24 = NULL, *_8$$27 = NULL, *_9$$39, *_10$$39 = NULL, *_11$$39, *value$$41 = NULL, *valueSql$$41 = NULL, **_14$$41, _19$$41, _20$$41, *_21$$41, *_22$$41, _15$$42 = zval_used_for_init, *_16$$42 = NULL, *_18$$42 = NULL, _23$$43, *_24$$43 = NULL, *_25$$43;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &column);
ZEPHIR_INIT_VAR(columnSql);
ZVAL_STRING(columnSql, "", 1);
ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(type) == IS_STRING) {
zephir_concat_self(&columnSql, type TSRMLS_CC);
ZEPHIR_CALL_METHOD(&type, column, "gettypereference", NULL, 0);
zephir_check_call_status();
}
do {
if (ZEPHIR_IS_LONG(type, 0)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("INTEGER") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 1)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 2)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("VARCHAR") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0$$8, column, "getsize", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1$$8);
ZEPHIR_CONCAT_SVS(_1$$8, "(", _0$$8, ")");
zephir_concat_self(&columnSql, _1$$8 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 3)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_2$$10, column, "getsize", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3$$10, column, "getscale", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4$$10);
ZEPHIR_CONCAT_SVSVS(_4$$10, "(", _2$$10, ",", _3$$10, ")");
zephir_concat_self(&columnSql, _4$$10 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 4)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DATETIME") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 17)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 5)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5$$16, column, "getsize", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6$$16);
ZEPHIR_CONCAT_SVS(_6$$16, "(", _5$$16, ")");
zephir_concat_self(&columnSql, _6$$16 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 6)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 8)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TINYINT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 7)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 9)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DOUBLE") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_7$$24, column, "isunsigned", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_7$$24)) {
zephir_concat_self_str(&columnSql, SL(" UNSIGNED") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 14)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("BIGINT") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_8$$27, column, "isunsigned", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_8$$27)) {
zephir_concat_self_str(&columnSql, SL(" UNSIGNED") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 10)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TINYBLOB") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 11)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("BLOB") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 12)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("MEDIUMBLOB") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 13)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("LONGBLOB") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_EMPTY(columnSql)) {
ZEPHIR_INIT_VAR(_9$$39);
object_init_ex(_9$$39, phalcon_db_exception_ce);
ZEPHIR_CALL_METHOD(&_10$$39, column, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$39);
ZEPHIR_CONCAT_SV(_11$$39, "Unrecognized SQLite data type at column ", _10$$39);
ZEPHIR_CALL_METHOD(NULL, _9$$39, "__construct", NULL, 9, _11$$39);
zephir_check_call_status();
zephir_throw_exception_debug(_9$$39, "phalcon/db/dialect/sqlite.zep", 169 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL, 0);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(typeValues))) {
if (Z_TYPE_P(typeValues) == IS_ARRAY) {
ZEPHIR_INIT_VAR(valueSql$$41);
ZVAL_STRING(valueSql$$41, "", 1);
zephir_is_iterable(typeValues, &_13$$41, &_12$$41, 0, 0, "phalcon/db/dialect/sqlite.zep", 180);
for (
; zephir_hash_get_current_data_ex(_13$$41, (void**) &_14$$41, &_12$$41) == SUCCESS
; zephir_hash_move_forward_ex(_13$$41, &_12$$41)
) {
ZEPHIR_GET_HVALUE(value$$41, _14$$41);
ZEPHIR_SINIT_NVAR(_15$$42);
ZVAL_STRING(&_15$$42, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_16$$42, "addcslashes", &_17, 153, value$$41, &_15$$42);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_18$$42);
ZEPHIR_CONCAT_SVS(_18$$42, "\"", _16$$42, "\", ");
zephir_concat_self(&valueSql$$41, _18$$42 TSRMLS_CC);
}
ZEPHIR_SINIT_VAR(_19$$41);
ZVAL_LONG(&_19$$41, 0);
ZEPHIR_SINIT_VAR(_20$$41);
ZVAL_LONG(&_20$$41, -2);
ZEPHIR_INIT_VAR(_21$$41);
zephir_substr(_21$$41, valueSql$$41, 0 , -2 , 0);
ZEPHIR_INIT_VAR(_22$$41);
ZEPHIR_CONCAT_SVS(_22$$41, "(", _21$$41, ")");
zephir_concat_self(&columnSql, _22$$41 TSRMLS_CC);
} else {
ZEPHIR_SINIT_VAR(_23$$43);
ZVAL_STRING(&_23$$43, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_24$$43, "addcslashes", &_17, 153, typeValues, &_23$$43);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_25$$43);
ZEPHIR_CONCAT_SVS(_25$$43, "(\"", _24$$43, "\")");
zephir_concat_self(&columnSql, _25$$43 TSRMLS_CC);
}
}
} while(0);
RETURN_CCTOR(columnSql);
}
/**
* Gets the column name in SQLite
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) {
zephir_nts_static zephir_fcall_cache_entry *_7 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *column, *columnSql, *type = NULL, *typeValues = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *value = NULL, *valueSql, **_5, _6 = zval_used_for_init, _8 = zval_used_for_init, *_9, *_10 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &column);
ZEPHIR_INIT_VAR(columnSql);
ZVAL_STRING(columnSql, "", 1);
ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL);
zephir_check_call_status();
if (Z_TYPE_P(type) == IS_STRING) {
zephir_concat_self(&columnSql, type TSRMLS_CC);
ZEPHIR_CALL_METHOD(&type, column, "gettypereference", NULL);
zephir_check_call_status();
}
do {
if (ZEPHIR_IS_LONG(type, 0)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("INT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 1)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 2)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("VARCHAR") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "(", _0, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 3)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, column, "getscale", NULL);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVSVS(_1, "(", _0, ",", _2, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 4)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 5)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVS(_1, "(", _0, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 6)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 7)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_EMPTY(columnSql)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Unrecognized SQLite data type", "phalcon/db/dialect/sqlite.zep", 112);
return;
}
ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(typeValues))) {
if (Z_TYPE_P(typeValues) == IS_ARRAY) {
ZEPHIR_INIT_VAR(valueSql);
ZVAL_STRING(valueSql, "", 1);
zephir_is_iterable(typeValues, &_4, &_3, 0, 0, "phalcon/db/dialect/sqlite.zep", 123);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(value, _5);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_0, "addcslashes", &_7, value, &_6);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVS(_1, "\"", _0, "\", ");
zephir_concat_self(&valueSql, _1 TSRMLS_CC);
}
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, 0);
ZEPHIR_SINIT_VAR(_8);
ZVAL_LONG(&_8, -2);
ZEPHIR_INIT_VAR(_9);
zephir_substr(_9, valueSql, 0 , -2 , 0);
ZEPHIR_INIT_VAR(_10);
ZEPHIR_CONCAT_SVS(_10, "(", _9, ")");
zephir_concat_self(&columnSql, _10 TSRMLS_CC);
} else {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_STRING(&_8, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_2, "addcslashes", &_7, typeValues, &_8);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_10);
ZEPHIR_CONCAT_SVS(_10, "(\"", _2, "\")");
zephir_concat_self(&columnSql, _10 TSRMLS_CC);
}
}
} while(0);
RETURN_CCTOR(columnSql);
}
/**
* Gets the column name in Oracle
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, getColumnDefinition) {
int ZEPHIR_LAST_CALL_STATUS;
zval *column, *columnSql = NULL, *size = NULL, *scale = NULL, *type = NULL, *_0, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &column);
ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&size, column, "getsize", NULL, 0);
zephir_check_call_status();
do {
if (ZEPHIR_IS_LONG(type, 0)) {
ZEPHIR_INIT_VAR(columnSql);
ZVAL_STRING(columnSql, "INTEGER", 1);
break;
}
if (ZEPHIR_IS_LONG(type, 1)) {
ZEPHIR_INIT_NVAR(columnSql);
ZVAL_STRING(columnSql, "DATE", 1);
break;
}
if (ZEPHIR_IS_LONG(type, 2)) {
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_SVS(columnSql, "VARCHAR2(", size, ")");
break;
}
if (ZEPHIR_IS_LONG(type, 3)) {
ZEPHIR_CALL_METHOD(&scale, column, "getscale", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_SVSVS(columnSql, "NUMBER(", size, ",", scale, ")");
break;
}
if (ZEPHIR_IS_LONG(type, 4)) {
ZEPHIR_INIT_NVAR(columnSql);
ZVAL_STRING(columnSql, "TIMESTAMP", 1);
break;
}
if (ZEPHIR_IS_LONG(type, 17)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 5)) {
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_SVS(columnSql, "CHAR(", size, ")");
break;
}
if (ZEPHIR_IS_LONG(type, 6)) {
ZEPHIR_INIT_NVAR(columnSql);
ZVAL_STRING(columnSql, "TEXT", 1);
break;
}
if (ZEPHIR_IS_LONG(type, 7)) {
ZEPHIR_CALL_METHOD(&scale, column, "getscale", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_SVSVS(columnSql, "FLOAT(", size, ",", scale, ")");
break;
}
if (ZEPHIR_IS_LONG(type, 8)) {
ZEPHIR_INIT_NVAR(columnSql);
ZVAL_STRING(columnSql, "TINYINT(1)", 1);
break;
}
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_db_exception_ce);
ZEPHIR_CALL_METHOD(&_1, column, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SV(_2, "Unrecognized Oracle data type at column ", _1);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 9, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/db/dialect/oracle.zep", 125 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
RETURN_CCTOR(columnSql);
}
PHP_METHOD(Xs_FieldMeta, getCustomTokenizer) {
zend_class_entry *_15, *_17;
int ZEPHIR_LAST_CALL_STATUS;
zval *name = NULL, *arg = NULL, *_7 = NULL, *_9 = NULL, *_11 = NULL;
zval *tokenizer = NULL, *m = NULL, *_0, *_1, *_2, *_3, _4, *_5 = NULL, *_6, *_8 = NULL, *_10, *_12 = NULL, *_13 = NULL, *_14 = NULL, *_16 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(m);
ZVAL_NULL(m);
ZEPHIR_OBS_VAR(tokenizer);
_0 = zephir_fetch_static_property_ce(xs_fieldmeta_ce, SL("tokenizers") TSRMLS_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&tokenizer, _0, _1, 0 TSRMLS_CC)) {
RETURN_CCTOR(tokenizer);
}
ZEPHIR_INIT_VAR(_2);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "/^([^\\(]+)\\((.*)\\)$/", 0);
zephir_preg_match(_2, &_4, _3, m, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_2)) {
ZEPHIR_INIT_VAR(_5);
zephir_array_fetch_long(&_6, m, 1, PH_NOISY | PH_READONLY, "xs/fieldmeta.zep", 125 TSRMLS_CC);
zephir_ucfirst(_5, _6);
zephir_get_strval(_7, _5);
ZEPHIR_INIT_VAR(name);
ZEPHIR_CONCAT_SSV(name, "Xs", "\\Tokenizer", _7);
ZEPHIR_OBS_VAR(_8);
zephir_array_fetch_long(&_8, m, 2, PH_NOISY, "xs/fieldmeta.zep", 126 TSRMLS_CC);
zephir_get_strval(_9, _8);
ZEPHIR_CPY_WRT(arg, _9);
} else {
ZEPHIR_INIT_NVAR(_5);
_10 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC);
zephir_ucfirst(_5, _10);
zephir_get_strval(_11, _5);
ZEPHIR_INIT_NVAR(name);
ZEPHIR_CONCAT_SSV(name, "Xs", "\\Tokenizer", _11);
ZEPHIR_INIT_NVAR(arg);
ZVAL_EMPTY_STRING(arg);
}
if (unlikely(!(zephir_class_exists(name, zephir_is_true(ZEPHIR_GLOBAL(global_true)) TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_5);
object_init_ex(_5, xs_exception_ce);
_10 = zephir_fetch_nproperty_this(this_ptr, SL("name"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_12);
ZEPHIR_CONCAT_SVSVS(_12, "Undefined custom tokenizer ", name, " for field `", _10, "`");
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 4, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_5, "xs/fieldmeta.zep", 133 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_NVAR(tokenizer);
if (zephir_fast_strlen_ev(arg) > 0) {
zephir_fetch_safe_class(_14, name);
_15 = zend_fetch_class(Z_STRVAL_P(_14), Z_STRLEN_P(_14), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(tokenizer, _15);
if (zephir_has_constructor(tokenizer TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, tokenizer, "__construct", NULL, 0, arg);
zephir_check_call_status();
}
} else {
zephir_fetch_safe_class(_16, name);
_17 = zend_fetch_class(Z_STRVAL_P(_16), Z_STRLEN_P(_16), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(tokenizer, _17);
if (zephir_has_constructor(tokenizer TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, tokenizer, "__construct", NULL, 0);
zephir_check_call_status();
}
}
if (unlikely(!((zephir_instance_of_ev(tokenizer, xs_tokenizer_ce TSRMLS_CC))))) {
ZEPHIR_INIT_NVAR(_5);
object_init_ex(_5, xs_exception_ce);
_10 = zephir_fetch_nproperty_this(this_ptr, SL("name"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_12);
ZEPHIR_CONCAT_VSVS(_12, name, " for field `", _10, "` does not implement Tokenizer interface");
ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 4, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_5, "xs/fieldmeta.zep", 143 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(_8);
zephir_read_property_this(&_8, this_ptr, SL("tokenizer"), PH_NOISY_CC);
zephir_update_static_property_array_multi_ce(xs_fieldmeta_ce, SL("tokenizers"), &tokenizer TSRMLS_CC, SL("z"), 1, _8);
RETURN_CCTOR(tokenizer);
}
/**
* Generates SQL to add a column to a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addColumn) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *tableName_param = NULL, *schemaName_param = NULL, *column, *sql = NULL, *defaultValue = NULL, *_1 = NULL, *_2 = NULL, *_3, _4, *_5 = NULL, *_7;
zval *tableName = NULL, *schemaName = NULL, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &tableName_param, &schemaName_param, &column);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
ZEPHIR_INIT_VAR(sql);
if (schemaName && Z_STRLEN_P(schemaName)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVSVS(_0, "ALTER TABLE \"", schemaName, "\".\"", tableName, "\" ADD COLUMN ");
ZEPHIR_CPY_WRT(sql, _0);
} else {
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "ALTER TABLE \"", tableName, "\" ADD COLUMN ");
ZEPHIR_CPY_WRT(sql, _0);
}
ZEPHIR_CALL_METHOD(&_1, column, "getname", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, this_ptr, "getcolumndefinition", NULL, column);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVSV(_3, "\"", _1, "\" ", _2);
zephir_concat_self(&sql, _3 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(defaultValue))) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_5, "addcslashes", &_6, defaultValue, &_4);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SVS(_7, " DEFAULT \"", _5, "\"");
zephir_concat_self(&sql, _7 TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5, column, "isnotnull", NULL);
zephir_check_call_status();
if (zephir_is_true(_5)) {
zephir_concat_self_str(&sql, SL(" NOT NULL") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5, column, "isautoincrement", NULL);
zephir_check_call_status();
if (zephir_is_true(_5)) {
zephir_concat_self_str(&sql, SL(" PRIMARY KEY AUTOINCREMENT") TSRMLS_CC);
}
RETURN_CCTOR(sql);
}
/**
* Handles uncaught exceptions
*/
PHP_METHOD(Phalcon_Debug, onUncaughtException) {
HashTable *_12$$5, *_17$$5, *_24$$5, *_31$$5, *_37$$13;
HashPosition _11$$5, _16$$5, _23$$5, _30$$5, _36$$13;
zephir_fcall_cache_entry *_15 = NULL, *_21 = NULL, *_27 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *exception, *_REQUEST, *_SERVER, *obLevel = NULL, *className = NULL, *escapedMessage = NULL, *html = NULL, *showBackTrace = NULL, *dataVars = NULL, *n = NULL, *traceItem = NULL, *keyRequest = NULL, *value = NULL, *keyServer = NULL, *keyFile = NULL, *keyVar = NULL, *dataVar = NULL, *_0, *_2 = NULL, *_3 = NULL, *_4, *_5 = NULL, *_6, *_7 = NULL, *_8 = NULL, *_9, *_42 = NULL, *_43, *_1$$4 = NULL, *_10$$5 = NULL, **_13$$5, **_18$$5, **_25$$5, *_29$$5 = NULL, **_32$$5, *_34$$5 = NULL, *_35$$5, *_14$$7 = NULL, *_19$$9 = NULL, *_20$$10 = NULL, *_22$$10 = NULL, *_26$$11 = NULL, *_28$$11 = NULL, *_33$$12 = NULL, **_38$$13, *_39$$14 = NULL, *_40$$14, *_41$$14 = NULL;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
zephir_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC);
zephir_fetch_params(1, 1, 0, &exception);
ZEPHIR_CALL_FUNCTION(&obLevel, "ob_get_level", NULL, 168);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(obLevel, 0)) {
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 128);
zephir_check_call_status();
}
_0 = zephir_fetch_static_property_ce(phalcon_debug_ce, SL("_isActive") TSRMLS_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_METHOD(&_1$$4, exception, "getmessage", NULL, 0);
zephir_check_call_status();
zend_print_zval(_1$$4, 0);
RETURN_MM_NULL();
}
zephir_update_static_property_ce(phalcon_debug_ce, SL("_isActive"), &ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, exception, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_2, exception, "getmessage", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&escapedMessage, this_ptr, "_escapestring", NULL, 0, _2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(html);
ZEPHIR_CONCAT_SVSVS(html, "<html><head><title>", className, ": ", escapedMessage, "</title>");
ZEPHIR_CALL_METHOD(&_3, this_ptr, "getcsssources", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_VS(_4, _3, "</head><body>");
zephir_concat_self(&html, _4 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getversion", NULL, 0);
zephir_check_call_status();
zephir_concat_self(&html, _5 TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC);
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SVSVS(_6, "<h1>", className, ": ", escapedMessage, "</h1>");
zephir_concat_self(&html, _6 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_7, exception, "getfile", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_8, exception, "getline", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "<span class=\"error-file\">", _7, " (", _8, ")</span>");
zephir_concat_self(&html, _9 TSRMLS_CC);
zephir_concat_self_str(&html, SL("</div>") TSRMLS_CC);
ZEPHIR_OBS_VAR(showBackTrace);
zephir_read_property_this(&showBackTrace, this_ptr, SL("_showBackTrace"), PH_NOISY_CC);
if (zephir_is_true(showBackTrace)) {
ZEPHIR_OBS_VAR(dataVars);
zephir_read_property_this(&dataVars, this_ptr, SL("_data"), PH_NOISY_CC);
zephir_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC);
if (Z_TYPE_P(dataVars) == IS_ARRAY) {
zephir_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</ul>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_10$$5, exception, "gettrace", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_10$$5, &_12$$5, &_11$$5, 0, 0, "phalcon/debug.zep", 659);
for (
; zend_hash_get_current_data_ex(_12$$5, (void**) &_13$$5, &_11$$5) == SUCCESS
; zend_hash_move_forward_ex(_12$$5, &_11$$5)
) {
ZEPHIR_GET_HMKEY(n, _12$$5, _11$$5);
ZEPHIR_GET_HVALUE(traceItem, _13$$5);
ZEPHIR_CALL_METHOD(&_14$$7, this_ptr, "showtraceitem", &_15, 169, n, traceItem);
zephir_check_call_status();
zephir_concat_self(&html, _14$$7 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(_REQUEST, &_17$$5, &_16$$5, 0, 0, "phalcon/debug.zep", 673);
for (
; zend_hash_get_current_data_ex(_17$$5, (void**) &_18$$5, &_16$$5) == SUCCESS
; zend_hash_move_forward_ex(_17$$5, &_16$$5)
) {
ZEPHIR_GET_HMKEY(keyRequest, _17$$5, _16$$5);
ZEPHIR_GET_HVALUE(value, _18$$5);
if (Z_TYPE_P(value) != IS_ARRAY) {
ZEPHIR_INIT_LNVAR(_19$$9);
ZEPHIR_CONCAT_SVSVS(_19$$9, "<tr><td class=\"key\">", keyRequest, "</td><td>", value, "</td></tr>");
zephir_concat_self(&html, _19$$9 TSRMLS_CC);
} else {
ZEPHIR_CALL_FUNCTION(&_20$$10, "print_r", &_21, 170, value, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$10);
ZEPHIR_CONCAT_SVSVS(_22$$10, "<tr><td class=\"key\">", keyRequest, "</td><td>", _20$$10, "</td></tr>");
zephir_concat_self(&html, _22$$10 TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(_SERVER, &_24$$5, &_23$$5, 0, 0, "phalcon/debug.zep", 683);
for (
; zend_hash_get_current_data_ex(_24$$5, (void**) &_25$$5, &_23$$5) == SUCCESS
; zend_hash_move_forward_ex(_24$$5, &_23$$5)
) {
ZEPHIR_GET_HMKEY(keyServer, _24$$5, _23$$5);
ZEPHIR_GET_HVALUE(value, _25$$5);
ZEPHIR_CALL_METHOD(&_26$$11, this_ptr, "_getvardump", &_27, 0, value);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_28$$11);
ZEPHIR_CONCAT_SVSVS(_28$$11, "<tr><td class=\"key\">", keyServer, "</td><td>", _26$$11, "</td></tr>");
zephir_concat_self(&html, _28$$11 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_29$$5, "get_included_files", NULL, 171);
zephir_check_call_status();
zephir_is_iterable(_29$$5, &_31$$5, &_30$$5, 0, 0, "phalcon/debug.zep", 693);
for (
; zend_hash_get_current_data_ex(_31$$5, (void**) &_32$$5, &_30$$5) == SUCCESS
; zend_hash_move_forward_ex(_31$$5, &_30$$5)
) {
ZEPHIR_GET_HMKEY(keyFile, _31$$5, _30$$5);
ZEPHIR_GET_HVALUE(value, _32$$5);
ZEPHIR_INIT_LNVAR(_33$$12);
ZEPHIR_CONCAT_SVSVS(_33$$12, "<tr><td>", keyFile, "</th><td>", value, "</td></tr>");
zephir_concat_self(&html, _33$$12 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_34$$5, "memory_get_usage", NULL, 172, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
ZEPHIR_INIT_VAR(_35$$5);
ZEPHIR_CONCAT_SVS(_35$$5, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", _34$$5, "</td></tr>");
zephir_concat_self(&html, _35$$5 TSRMLS_CC);
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
if (Z_TYPE_P(dataVars) == IS_ARRAY) {
zephir_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
zephir_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
zephir_is_iterable(dataVars, &_37$$13, &_36$$13, 0, 0, "phalcon/debug.zep", 711);
for (
; zend_hash_get_current_data_ex(_37$$13, (void**) &_38$$13, &_36$$13) == SUCCESS
; zend_hash_move_forward_ex(_37$$13, &_36$$13)
) {
ZEPHIR_GET_HMKEY(keyVar, _37$$13, _36$$13);
ZEPHIR_GET_HVALUE(dataVar, _38$$13);
zephir_array_fetch_long(&_40$$14, dataVar, 0, PH_NOISY | PH_READONLY, "phalcon/debug.zep", 709 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_39$$14, this_ptr, "_getvardump", &_27, 0, _40$$14);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_41$$14);
ZEPHIR_CONCAT_SVSVS(_41$$14, "<tr><td class=\"key\">", keyVar, "</td><td>", _39$$14, "</td></tr>");
zephir_concat_self(&html, _41$$14 TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
}
zephir_concat_self_str(&html, SL("</div>") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_42, this_ptr, "getjssources", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_43);
ZEPHIR_CONCAT_VS(_43, _42, "</div></body></html>");
zephir_concat_self(&html, _43 TSRMLS_CC);
zend_print_zval(html, 0);
zephir_update_static_property_ce(phalcon_debug_ce, SL("_isActive"), &ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_MM_BOOL(1);
}
/**
* Shows a backtrace item
*/
PHP_METHOD(Phalcon_Debug, showTraceItem) {
zend_bool _40$$24;
HashTable *_18$$14;
HashPosition _17$$14;
zval *_1, *_26$$16 = NULL;
zephir_fcall_cache_entry *_21 = NULL, *_47 = NULL;
zval *trace = NULL;
zval *n_param = NULL, *trace_param = NULL, *className = NULL, *prepareInternalClass = NULL, *preparedFunctionName = NULL, *html = NULL, *classReflection = NULL, *prepareUriClass = NULL, *functionName = NULL, *functionReflection = NULL, *traceArgs = NULL, *arguments = NULL, *argument = NULL, *filez = NULL, *line = NULL, *showFiles = NULL, *lines = NULL, *numberLines = NULL, *showFileFragment = NULL, *beforeLine = NULL, *afterLine = NULL, *lastLine = NULL, *linePosition = NULL, *currentLine = NULL, *classNameWithLink = NULL, *functionNameWithLink = NULL, _0, *_16, *_2$$3, *_3$$3, _4$$3, *_11$$3, *_12$$3, _5$$4, _6$$4, *_7$$5 = NULL, *_8$$6, _9$$6, _10$$6, *_13$$10 = NULL, _14$$11, _15$$11, **_19$$14, *_23$$14, *_24$$14, *_20$$15 = NULL, *_22$$15 = NULL, *_25$$16, *_27$$16, _28$$18, _29$$18, *_30$$18, _31$$23, *_32$$23, *_33$$26 = NULL, *_34$$26 = NULL, *_35$$26 = NULL, _36$$26 = zval_used_for_init, *_37$$27 = NULL, _38$$27 = zval_used_for_init, _39$$27 = zval_used_for_init, *_41$$29 = NULL, _42$$29 = zval_used_for_init, _43$$29 = zval_used_for_init, _44$$29 = zval_used_for_init, _45$$29 = zval_used_for_init, *_46$$29 = NULL;
int n, ZEPHIR_LAST_CALL_STATUS, firstLine = 0, i = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n_param, &trace_param);
n = zephir_get_intval(n_param);
trace = trace_param;
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, n);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", &_0, "</td><td>");
ZEPHIR_CPY_WRT(html, _1);
ZEPHIR_OBS_VAR(className);
if (zephir_array_isset_string_fetch(&className, trace, SS("class"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_STRING(&_4$$3, "/^Phalcon/", 0);
zephir_preg_match(_3$$3, &_4$$3, className, _2$$3, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_3$$3)) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "\\", 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_STRING(&_6$$4, "/", 0);
ZEPHIR_INIT_VAR(prepareUriClass);
zephir_fast_str_replace(&prepareUriClass, &_5$$4, &_6$$4, className TSRMLS_CC);
ZEPHIR_INIT_VAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"//api.phalconphp.com/class/", prepareUriClass, ".html\">", className, "</a>");
} else {
ZEPHIR_INIT_VAR(classReflection);
object_init_ex(classReflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, classReflection, "__construct", NULL, 91, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7$$5, classReflection, "isinternal", NULL, 163);
zephir_check_call_status();
if (zephir_is_true(_7$$5)) {
ZEPHIR_INIT_VAR(_8$$6);
zephir_fast_strtolower(_8$$6, className);
ZEPHIR_SINIT_VAR(_9$$6);
ZVAL_STRING(&_9$$6, "_", 0);
ZEPHIR_SINIT_VAR(_10$$6);
ZVAL_STRING(&_10$$6, "-", 0);
ZEPHIR_INIT_VAR(prepareInternalClass);
zephir_fast_str_replace(&prepareInternalClass, &_9$$6, &_10$$6, _8$$6 TSRMLS_CC);
ZEPHIR_INIT_NVAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/class.", prepareInternalClass, ".php\">", className, "</a>");
} else {
ZEPHIR_CPY_WRT(classNameWithLink, className);
}
}
ZEPHIR_INIT_VAR(_11$$3);
ZEPHIR_CONCAT_SVS(_11$$3, "<span class=\"error-class\">", classNameWithLink, "</span>");
zephir_concat_self(&html, _11$$3 TSRMLS_CC);
zephir_array_fetch_string(&_12$$3, trace, SL("type"), PH_NOISY | PH_READONLY, "phalcon/debug.zep", 386 TSRMLS_CC);
zephir_concat_self(&html, _12$$3 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(functionName);
zephir_array_fetch_string(&functionName, trace, SL("function"), PH_NOISY, "phalcon/debug.zep", 392 TSRMLS_CC);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
} else {
if ((zephir_function_exists(functionName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_VAR(functionReflection);
object_init_ex(functionReflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, functionReflection, "__construct", NULL, 82, functionName);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_13$$10, functionReflection, "isinternal", NULL, 164);
zephir_check_call_status();
if (zephir_is_true(_13$$10)) {
ZEPHIR_SINIT_VAR(_14$$11);
ZVAL_STRING(&_14$$11, "_", 0);
ZEPHIR_SINIT_VAR(_15$$11);
ZVAL_STRING(&_15$$11, "-", 0);
ZEPHIR_INIT_VAR(preparedFunctionName);
zephir_fast_str_replace(&preparedFunctionName, &_14$$11, &_15$$11, functionName TSRMLS_CC);
ZEPHIR_INIT_NVAR(functionNameWithLink);
ZEPHIR_CONCAT_SVSVS(functionNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/function.", preparedFunctionName, ".php\">", functionName, "</a>");
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
}
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "<span class=\"error-function\">", functionNameWithLink, "</span>");
zephir_concat_self(&html, _16 TSRMLS_CC);
ZEPHIR_OBS_VAR(traceArgs);
if (zephir_array_isset_string_fetch(&traceArgs, trace, SS("args"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(arguments);
array_init(arguments);
zephir_is_iterable(traceArgs, &_18$$14, &_17$$14, 0, 0, "phalcon/debug.zep", 441);
for (
; zend_hash_get_current_data_ex(_18$$14, (void**) &_19$$14, &_17$$14) == SUCCESS
; zend_hash_move_forward_ex(_18$$14, &_17$$14)
) {
ZEPHIR_GET_HVALUE(argument, _19$$14);
ZEPHIR_CALL_METHOD(&_20$$15, this_ptr, "_getvardump", &_21, 0, argument);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$15);
ZEPHIR_CONCAT_SVS(_22$$15, "<span class=\"error-parameter\">", _20$$15, "</span>");
zephir_array_append(&arguments, _22$$15, PH_SEPARATE, "phalcon/debug.zep", 435);
}
ZEPHIR_INIT_VAR(_23$$14);
zephir_fast_join_str(_23$$14, SL(", "), arguments TSRMLS_CC);
ZEPHIR_INIT_VAR(_24$$14);
ZEPHIR_CONCAT_SVS(_24$$14, "(", _23$$14, ")");
zephir_concat_self(&html, _24$$14 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(filez);
if (zephir_array_isset_string_fetch(&filez, trace, SS("file"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_25$$16);
zephir_array_fetch_string(&_25$$16, trace, SL("line"), PH_NOISY, "phalcon/debug.zep", 449 TSRMLS_CC);
zephir_get_strval(_26$$16, _25$$16);
ZEPHIR_CPY_WRT(line, _26$$16);
ZEPHIR_INIT_VAR(_27$$16);
ZEPHIR_CONCAT_SVSVS(_27$$16, "<br/><div class=\"error-file\">", filez, " (", line, ")</div>");
zephir_concat_self(&html, _27$$16 TSRMLS_CC);
ZEPHIR_OBS_VAR(showFiles);
zephir_read_property_this(&showFiles, this_ptr, SL("_showFiles"), PH_NOISY_CC);
if (zephir_is_true(showFiles)) {
ZEPHIR_CALL_FUNCTION(&lines, "file", NULL, 165, filez);
zephir_check_call_status();
ZEPHIR_INIT_VAR(numberLines);
ZVAL_LONG(numberLines, zephir_fast_count_int(lines TSRMLS_CC));
ZEPHIR_OBS_VAR(showFileFragment);
zephir_read_property_this(&showFileFragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
if (zephir_is_true(showFileFragment)) {
ZEPHIR_INIT_VAR(beforeLine);
ZVAL_LONG(beforeLine, (zephir_get_numberval(line) - 7));
if (ZEPHIR_LT_LONG(beforeLine, 1)) {
firstLine = 1;
} else {
firstLine = zephir_get_numberval(beforeLine);
}
ZEPHIR_INIT_VAR(afterLine);
ZVAL_LONG(afterLine, (zephir_get_numberval(line) + 5));
if (ZEPHIR_GT(afterLine, numberLines)) {
ZEPHIR_CPY_WRT(lastLine, numberLines);
} else {
ZEPHIR_CPY_WRT(lastLine, afterLine);
}
ZEPHIR_SINIT_VAR(_28$$18);
ZVAL_LONG(&_28$$18, firstLine);
ZEPHIR_SINIT_VAR(_29$$18);
ZVAL_LONG(&_29$$18, firstLine);
ZEPHIR_INIT_VAR(_30$$18);
ZEPHIR_CONCAT_SVSVSVS(_30$$18, "<pre class=\"prettyprint highlight:", &_28$$18, ":", line, " linenums:", &_29$$18, "\">");
zephir_concat_self(&html, _30$$18 TSRMLS_CC);
} else {
firstLine = 1;
ZEPHIR_CPY_WRT(lastLine, numberLines);
ZEPHIR_SINIT_VAR(_31$$23);
ZVAL_LONG(&_31$$23, firstLine);
ZEPHIR_INIT_VAR(_32$$23);
ZEPHIR_CONCAT_SVSVS(_32$$23, "<pre class=\"prettyprint highlight:", &_31$$23, ":", line, " linenums error-scroll\">");
zephir_concat_self(&html, _32$$23 TSRMLS_CC);
}
i = firstLine;
while (1) {
if (!(ZEPHIR_GE_LONG(lastLine, i))) {
break;
}
ZEPHIR_INIT_NVAR(linePosition);
ZVAL_LONG(linePosition, (i - 1));
ZEPHIR_OBS_NVAR(currentLine);
zephir_array_fetch(¤tLine, lines, linePosition, PH_NOISY, "phalcon/debug.zep", 522 TSRMLS_CC);
if (zephir_is_true(showFileFragment)) {
if (i == firstLine) {
ZEPHIR_INIT_NVAR(_33$$26);
ZEPHIR_INIT_NVAR(_34$$26);
ZEPHIR_INIT_NVAR(_35$$26);
zephir_fast_trim(_35$$26, currentLine, NULL , ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_36$$26);
ZVAL_STRING(&_36$$26, "#\\*\\/#", 0);
zephir_preg_match(_34$$26, &_36$$26, _35$$26, _33$$26, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_34$$26)) {
ZEPHIR_INIT_NVAR(_37$$27);
ZEPHIR_SINIT_NVAR(_38$$27);
ZVAL_STRING(&_38$$27, "* /", 0);
ZEPHIR_SINIT_NVAR(_39$$27);
ZVAL_STRING(&_39$$27, " ", 0);
zephir_fast_str_replace(&_37$$27, &_38$$27, &_39$$27, currentLine TSRMLS_CC);
ZEPHIR_CPY_WRT(currentLine, _37$$27);
}
}
}
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\n");
if (!(_40$$24)) {
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\r\n");
}
if (_40$$24) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_41$$29);
ZEPHIR_SINIT_NVAR(_42$$29);
ZVAL_STRING(&_42$$29, "\t", 0);
ZEPHIR_SINIT_NVAR(_43$$29);
ZVAL_STRING(&_43$$29, " ", 0);
zephir_fast_str_replace(&_41$$29, &_42$$29, &_43$$29, currentLine TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_44$$29);
ZVAL_LONG(&_44$$29, 2);
ZEPHIR_SINIT_NVAR(_45$$29);
ZVAL_STRING(&_45$$29, "UTF-8", 0);
ZEPHIR_CALL_FUNCTION(&_46$$29, "htmlentities", &_47, 158, _41$$29, &_44$$29, &_45$$29);
zephir_check_call_status();
zephir_concat_self(&html, _46$$29 TSRMLS_CC);
}
i++;
}
zephir_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CCTOR(html);
}
/**
* Checks if a role has access to a resource
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, _allowOrDeny) {
HashTable *_5, *_9;
HashPosition _4, _8;
int ZEPHIR_LAST_CALL_STATUS;
zval *roleName_param = NULL, *resourceName_param = NULL, *access, *action, *defaultAccess, *accessList, *accessName = NULL, *accessKey = NULL, *accessKeyAll = NULL, *internalAccess, *_0, *_1 = NULL, *_3, **_6, *_7 = NULL, **_10, *_11;
zval *roleName = NULL, *resourceName = NULL, *_2 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &roleName_param, &resourceName_param, &access, &action);
zephir_get_strval(roleName, roleName_param);
zephir_get_strval(resourceName, resourceName_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(_0, roleName))) {
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SVS(_2, "Role '", roleName, "' does not exist in ACL");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/acl/adapter/memory.zep", 357 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(_3, resourceName))) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_acl_exception_ce);
ZEPHIR_INIT_LNVAR(_2);
ZEPHIR_CONCAT_SVS(_2, "Resource '", resourceName, "' does not exist in ACL");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/acl/adapter/memory.zep", 361 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(defaultAccess);
zephir_read_property_this(&defaultAccess, this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(accessList);
zephir_read_property_this(&accessList, this_ptr, SL("_accessList"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(internalAccess);
zephir_read_property_this(&internalAccess, this_ptr, SL("_access"), PH_NOISY_CC);
if (Z_TYPE_P(access) == IS_ARRAY) {
zephir_is_iterable(access, &_5, &_4, 0, 0, "phalcon/acl/adapter/memory.zep", 377);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(accessName, _6);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSV(accessKey, resourceName, "!", accessName);
if (!(zephir_array_isset(accessList, accessKey))) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_acl_exception_ce);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSVS(_7, "Access '", accessName, "' does not exist in resource '", resourceName, "'");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _7);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/acl/adapter/memory.zep", 373 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_is_iterable(access, &_9, &_8, 0, 0, "phalcon/acl/adapter/memory.zep", 390);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HVALUE(accessName, _10);
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, roleName, "!", resourceName, "!", accessName);
zephir_update_property_array(this_ptr, SL("_access"), accessKey, action TSRMLS_CC);
if (!ZEPHIR_IS_STRING(accessName, "*")) {
ZEPHIR_INIT_LNVAR(_2);
ZEPHIR_CONCAT_VSVS(_2, roleName, "!", resourceName, "!*");
ZEPHIR_CPY_WRT(accessKeyAll, _2);
if (zephir_array_isset(internalAccess, accessKeyAll)) {
zephir_update_property_array(this_ptr, SL("_access"), accessKeyAll, defaultAccess TSRMLS_CC);
}
}
}
} else {
if (!ZEPHIR_IS_STRING(access, "*")) {
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSV(accessKey, resourceName, "!", access);
if (!(zephir_array_isset(accessList, accessKey))) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_acl_exception_ce);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSVS(_7, "Access '", access, "' does not exist in resource '", resourceName, "'");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _7);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/acl/adapter/memory.zep", 395 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_INIT_NVAR(accessKey);
ZEPHIR_CONCAT_VSVSV(accessKey, roleName, "!", resourceName, "!", access);
zephir_update_property_array(this_ptr, SL("_access"), accessKey, action TSRMLS_CC);
if (!ZEPHIR_IS_STRING(access, "*")) {
ZEPHIR_INIT_LNVAR(_2);
ZEPHIR_CONCAT_VSVS(_2, roleName, "!", resourceName, "!*");
ZEPHIR_CPY_WRT(accessKey, _2);
if (!(zephir_array_isset(internalAccess, accessKey))) {
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
zephir_update_property_array(this_ptr, SL("_access"), accessKey, _11 TSRMLS_CC);
}
}
}
ZEPHIR_MM_RESTORE();
}
