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(); }