/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences){
zval *table = NULL, *schema = NULL, *dialect = NULL, *sql = NULL, *empty_arr = NULL, *references = NULL;
zval *fetch_assoc = NULL, *describe = NULL, *reference = NULL, *constraint_name = NULL, *constraint_id = NULL;
zval *referenced_schema = NULL, *referenced_table = NULL;
zval *reference_array = NULL, *column_name = NULL, *referenced_columns = NULL;
zval *reference_objects = NULL, *array_reference = NULL;
zval *name = NULL, *columns = NULL, *definition = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
PHALCON_INIT_VAR(references);
array_init(references);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(reference);
PHALCON_INIT_VAR(constraint_id);
PHALCON_INIT_VAR(constraint_name);
phalcon_array_fetch_string(&constraint_id, reference, SL("id"), PH_NOISY_CC);
PHALCON_CONCAT_SV(constraint_name, "foreign_key_", constraint_id);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(referenced_schema);
ZVAL_STRING(referenced_schema, "main", 1);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, reference, SL("table"), PH_NOISY_CC);
PHALCON_INIT_VAR(reference_array);
array_init(reference_array);
phalcon_array_update_string(&reference_array, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("columns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedColumns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&references, constraint_name, &reference_array, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, reference, SL("from"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t0);
phalcon_array_fetch(&t0, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t0) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t0) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch_string(&t1, t0, SL("columns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t1, column_name, 0 TSRMLS_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, reference, SL("to"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch(&t2, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t2) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch_string(&t3, t2, SL("referencedColumns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t3, referenced_columns, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_valid_foreach(references TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto ph_cycle_end_1;
}
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(array_reference);
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC);
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC);
PHALCON_INIT_VAR(definition);
array_init(definition);
phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition, PH_CHECK);
phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
RETURN_CTOR(reference_objects);}
/**
* Builds a HTML A tag using framework conventions
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, linkTo){
zval *parameters = NULL, *text = NULL, *params = NULL, *action = NULL, *url = NULL, *internal_url = NULL;
zval *code = NULL, *value = NULL, *key = NULL, *attribute = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &text) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!text) {
PHALCON_ALLOC_ZVAL_MM(text);
ZVAL_NULL(text);
} else {
PHALCON_SEPARATE_PARAM(text);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, text, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(action);
ZVAL_STRING(action, "", 1);
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("action")+1);
}
}
PHALCON_INIT_VAR(text);
ZVAL_STRING(text, "", 1);
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_INIT_VAR(text);
phalcon_array_fetch_long(&text, params, 1, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SL("text")+1);
if (eval_int) {
PHALCON_INIT_VAR(text);
phalcon_array_fetch_string(&text, params, SL("text"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("text")+1);
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_INIT_VAR(internal_url);
PHALCON_CALL_METHOD_PARAMS_1(internal_url, url, "get", action, PH_NO_CHECK);
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<a href=\"", internal_url, "\"");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_1;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_SVSVS(attribute, " ", key, "=\"", value, "\"");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_1;
fee_9b93_1:
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVS(r0, ">", text, "</a>");
phalcon_concat_self(&code, r0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Builds a HTML TEXTAREA tag
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, textArea){
zval *parameters = NULL, *params = NULL, *id = NULL, *content = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &r0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_string(params, SL("name")+1);
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(r1)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_string(params, SL("id")+1);
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(params, SL("value")+1);
if (eval_int) {
PHALCON_INIT_VAR(content);
phalcon_array_fetch_string(&content, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("value")+1);
} else {
PHALCON_INIT_VAR(content);
PHALCON_CALL_SELF_PARAMS_1(content, this_ptr, "getvalue", id);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<textarea ", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_4:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_4;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "=\"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_4;
fee_9b93_4:
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SVS(r2, ">", content, "</textarea>");
phalcon_concat_self(&code, r2 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
*
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param boolean $automaticQuotes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *automatic_quotes = NULL, *i = NULL, *update_values = NULL, *update_sql = NULL;
zval *field = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &automatic_quotes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!where_condition) {
PHALCON_INIT_VAR(where_condition);
ZVAL_NULL(where_condition);
}
if (!automatic_quotes) {
PHALCON_INIT_VAR(automatic_quotes);
ZVAL_BOOL(automatic_quotes, 0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, fields TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_count(r1, values TSRMLS_CC);
PHALCON_INIT_VAR(r2);
is_not_equal_function(r2, r0, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values to update is not the same as fields");
return;
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(update_values, a0);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "UPDATE ", table, " SET ");
PHALCON_CPY_WRT(update_sql, r3);
if (phalcon_valid_foreach(fields TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e7f0_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e7f0_2;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
if (zend_is_true(automatic_quotes)) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, values, i, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(r4) == IS_OBJECT) {
PHALCON_INIT_VAR(r5);
phalcon_array_fetch(&r5, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_instance_of(r6, r5, phalcon_db_rawvalue_ce TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch(&r9, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(r8, r9, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1(r7, this_ptr, "escapestring", r8, PHALCON_NO_CHECK);
phalcon_array_update(&values, i, &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
goto fes_e7f0_2;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_INIT_VAR(r11);
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "escapestring", r12, PHALCON_NO_CHECK);
PHALCON_CONCAT_SVS(r10, "'", r11, "'");
phalcon_array_update(&values, i, &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
phalcon_array_fetch(&r14, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VSV(r13, field, " = ", r14);
phalcon_array_append(&update_values, r13, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e7f0_2;
fee_e7f0_2:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, update_values TSRMLS_CC);
phalcon_concat_self(&update_sql, r15 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
PHALCON_INIT_VAR(r16);
is_not_equal_function(r16, where_condition, t0 TSRMLS_CC);
if (zend_is_true(r16)) {
PHALCON_ALLOC_ZVAL_MM(r17);
PHALCON_CONCAT_SV(r17, " WHERE ", where_condition);
phalcon_concat_self(&update_sql, r17 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD_PARAMS_1(r18, this_ptr, "query", update_sql, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r18);
}
/**
* Constructor for Phalcon\Session\Adapter\Memcache
*
* @param array $options
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){
zval *options;
zval *host, *port, *lifetime, *persistent, *prefix;
zval *frontend_data, *memcache, *option;
zval *callable_open , *callable_close , *callable_read , *callable_write , *callable_destroy , *callable_gc;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The options must be an array");
return;
}
if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "No session host given in options");
return;
}
if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) {
PHALCON_INIT_VAR(port);
ZVAL_LONG(port, 11211);
}
if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) {
PHALCON_INIT_VAR(lifetime);
ZVAL_LONG(lifetime, 8600);
}
phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) {
PHALCON_INIT_VAR(persistent);
ZVAL_FALSE(persistent);
}
if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) {
PHALCON_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
}
/* create memcache instance */
PHALCON_INIT_VAR(option);
array_init_size(option, 1);
phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY);
PHALCON_INIT_VAR(frontend_data);
object_init_ex(frontend_data, phalcon_cache_frontend_data_ce);
PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option);
PHALCON_INIT_NVAR(option);
array_init_size(option, 3);
phalcon_array_update_string(&option, SL("host"), host, PH_COPY);
phalcon_array_update_string(&option, SL("port"), port, PH_COPY);
phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY);
phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY);
PHALCON_INIT_VAR(memcache);
object_init_ex(memcache, phalcon_cache_backend_memcache_ce);
PHALCON_CALL_METHOD(NULL, memcache, "__construct", frontend_data, option);
phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC);
/* open callback */
PHALCON_INIT_VAR(callable_open);
array_init_size(callable_open, 2);
phalcon_array_append(&callable_open, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_open, SL("open"), 0);
/* close callback */
PHALCON_INIT_VAR(callable_close);
array_init_size(callable_close, 2);
phalcon_array_append(&callable_close, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_close, SL("close"), 0);
/* read callback */
PHALCON_INIT_VAR(callable_read);
array_init_size(callable_read, 2);
phalcon_array_append(&callable_read, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_read, SL("read"), 0);
/* write callback */
PHALCON_INIT_VAR(callable_write);
array_init_size(callable_write, 2);
phalcon_array_append(&callable_write, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_write, SL("write"), 0);
/* destroy callback */
PHALCON_INIT_VAR(callable_destroy);
array_init_size(callable_destroy, 2);
phalcon_array_append(&callable_destroy, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_destroy, SL("destroy"), 0);
/* gc callback */
PHALCON_INIT_VAR(callable_gc);
array_init_size(callable_gc, 2);
phalcon_array_append(&callable_gc, this_ptr, PH_COPY);
phalcon_array_append_string(&callable_gc, SL("gc"), 0);
PHALCON_CALL_FUNCTION(NULL, "session_set_save_handler", callable_open, callable_close, callable_read, callable_write, callable_destroy, callable_gc);
PHALCON_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", options);
PHALCON_MM_RESTORE();
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Router_Rewrite, handle){
zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
ZVAL_NULL(uri);
} else {
PHALCON_SEPARATE_PARAM(uri);
}
if (!zend_is_true(uri)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(uri, r0);
}
if (zend_is_true(uri)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_explode(r1, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r1);
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_filter_alphanum(r3, r2);
phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_filter_alphanum(r5, r4);
phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t1)) {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, parts TSRMLS_CC);
PHALCON_CPY_WRT(number_parts, r6);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 2);
fs_ef57_0:
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, i, number_parts TSRMLS_CC);
if (!zend_is_true(r7)) {
goto fe_ef57_0;
}
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ef57_0;
fe_ef57_0:
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return \stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval show = {}, config = {}, items = {}, page_number = {}, rowcount = {}, page = {}, last_show_page = {}, start = {}, possible_pages = {}, total_pages = {};
zval page_items = {}, maximum_pages = {}, next = {}, additional_page = {}, before = {}, remainder = {}, pages_total = {};
long int i, i_show;
phalcon_return_property(&show, getThis(), SL("_limitRows"));
phalcon_return_property(&config, getThis(), SL("_config"));
phalcon_return_property(&page_number, getThis(), SL("_page"));
i_show = phalcon_get_intval(&show);
phalcon_array_fetch_str(&items, &config, SL("data"), PH_NOISY);
if (Z_TYPE(page_number) == IS_NULL || PHALCON_LT(&show, &PHALCON_GLOBAL(z_zero))) {
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
}
phalcon_fast_count(&rowcount, &items);
object_init(&page);
phalcon_sub_function(&last_show_page, &page_number, &PHALCON_GLOBAL(z_one));
mul_function(&start, &show, &last_show_page);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (unlikely(Z_TYPE(possible_pages)) != IS_DOUBLE) {
convert_to_double(&possible_pages);
}
ZVAL_LONG(&total_pages, (long int)ceil(Z_DVAL(possible_pages)));
if (Z_TYPE(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
array_init(&page_items);
if (PHALCON_GT(&rowcount, &PHALCON_GLOBAL(z_zero))) {
/**
* Seek to the desired position
*/
if (PHALCON_LT(&start, &rowcount)) {
PHALCON_CALL_METHODW(NULL, &items, "seek", &start);
} else {
PHALCON_CALL_METHODW(NULL, &items, "rewind");
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
PHALCON_CPY_WRT_CTOR(&start, &PHALCON_GLOBAL(z_zero));
}
/**
* The record must be iterable
*/
for (i=1; ; ++i) {
zval valid = {}, current = {};
PHALCON_CALL_METHODW(&valid, &items, "valid");
if (!PHALCON_IS_NOT_FALSE(&valid)) {
break;
}
PHALCON_CALL_METHODW(¤t, &items, "current");
phalcon_array_append(&page_items, ¤t, PH_COPY);
if (i >= i_show) {
break;
}
}
}
phalcon_update_property_zval(&page, SL("items"), &page_items);
phalcon_add_function(&maximum_pages, &start, &show);
if (PHALCON_LT(&maximum_pages, &rowcount)) {
phalcon_add_function(&next, &page_number, &PHALCON_GLOBAL(z_one));
} else if (PHALCON_IS_EQUAL(&maximum_pages, &rowcount)) {
PHALCON_CPY_WRT_CTOR(&next, &rowcount);
} else {
phalcon_div_function(&possible_pages, &rowcount, &show);
phalcon_add_function(&additional_page, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&next, phalcon_get_intval(&additional_page));
}
if (PHALCON_GT(&next, &total_pages)) {
PHALCON_CPY_WRT_CTOR(&next, &total_pages);
}
phalcon_update_property_zval(&page, SL("next"), &next);
if (PHALCON_GT(&page_number, &PHALCON_GLOBAL(z_one))) {
phalcon_sub_function(&before, &page_number, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CPY_WRT_CTOR(&before, &PHALCON_GLOBAL(z_one));
}
phalcon_update_property_zval(&page, SL("first"), &PHALCON_GLOBAL(z_one));
phalcon_update_property_zval(&page, SL("before"), &before);
phalcon_update_property_zval(&page, SL("current"), &page_number);
mod_function(&remainder, &rowcount, &show);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (!PHALCON_IS_LONG(&remainder, 0)) {
phalcon_add_function(&next, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&pages_total, phalcon_get_intval(&next));
} else {
PHALCON_CPY_WRT_CTOR(&pages_total, &possible_pages);
}
phalcon_update_property_zval(&page, SL("last"), &pages_total);
phalcon_update_property_zval(&page, SL("total_pages"), &pages_total);
phalcon_update_property_zval(&page, SL("total_items"), &rowcount);
RETURN_CTORW(&page);
}
/**
* Perform the automatic rendering returning the output as a string
*
* <code>
* $template = $this->view->getRender('products', 'show', array('products' => $products));
* </code>
*
* @param string $controllerName
* @param string $actionName
* @param array $params
* @param mixed $configCallback
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View, getRender){
zval *controller_name, *action_name, *params = NULL;
zval *config_callback = NULL, *view, *status, *content;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 2, &controller_name, &action_name, ¶ms, &config_callback);
if (!params) {
PHALCON_INIT_VAR(params);
} else {
PHALCON_SEPARATE_PARAM(params);
}
if (!config_callback) {
PHALCON_INIT_VAR(config_callback);
}
/**
* We must to clone the current view to keep the old state
*/
PHALCON_INIT_VAR(view);
if (phalcon_clone(view, this_ptr TSRMLS_CC) == FAILURE) {
return;
}
/**
* The component must be reset to its defaults
*/
PHALCON_CALL_METHOD_NORETURN(view, "reset");
/**
* Set the render variables
*/
if (Z_TYPE_P(params) == IS_ARRAY) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setvars", params);
}
/**
* Perform extra configurations over the cloned object
*/
if (Z_TYPE_P(config_callback) == IS_OBJECT) {
PHALCON_INIT_NVAR(params);
array_init_size(params, 1);
phalcon_array_append(¶ms, view, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, config_callback, params);
}
/**
* Start the output buffering
*/
PHALCON_CALL_METHOD_NORETURN(view, "start");
/**
* Perform the render passing only the controller and action
*/
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(view, "render", controller_name, action_name);
/**
* Stop the output buffering
*/
PHALCON_CALL_FUNC_NORETURN("ob_end_clean");
/**
* Get the processed content
*/
PHALCON_INIT_VAR(content);
PHALCON_CALL_METHOD(content, view, "getcontent");
RETURN_CCTOR(content);
}
/**
* Validates the form
*
* @param array $data
* @param object $entity
* @return boolean
*/
PHP_METHOD(Phalcon_Forms_Form, isValid){
zval *data = NULL, *entity = NULL, *elements, *not_failed = NULL, *messages;
zval *element = NULL, *validators = NULL, *name = NULL, *prepared_validators = NULL;
zval *validator = NULL, *scope = NULL, *validation = NULL, *element_messages = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &data, &entity) == FAILURE) {
RETURN_MM_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
} else {
PHALCON_SEPARATE_PARAM(data);
}
if (!entity) {
PHALCON_INIT_VAR(entity);
}
PHALCON_OBS_VAR(elements);
phalcon_read_property(&elements, this_ptr, SL("_elements"), PH_NOISY_CC);
if (Z_TYPE_P(elements) == IS_ARRAY) {
/**
* If the user doesn't pass an entity we use the one in this_ptr->_entity
*/
if (Z_TYPE_P(entity) == IS_OBJECT) {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "bind", data, entity);
}
/**
* If the data is not an array use the one passed previously
*/
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_OBS_NVAR(data);
phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC);
}
PHALCON_INIT_VAR(not_failed);
ZVAL_BOOL(not_failed, 1);
PHALCON_INIT_VAR(messages);
array_init(messages);
if (!phalcon_is_iterable(elements, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(element);
PHALCON_INIT_NVAR(validators);
PHALCON_CALL_METHOD(validators, element, "getvalidators");
if (Z_TYPE_P(validators) == IS_ARRAY) {
if (phalcon_fast_count_ev(validators TSRMLS_CC)) {
/**
* Element's name
*/
PHALCON_INIT_NVAR(name);
PHALCON_CALL_METHOD(name, element, "getname");
/**
* Prepare the validators
*/
PHALCON_INIT_NVAR(prepared_validators);
array_init(prepared_validators);
if (!phalcon_is_iterable(validators, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(validator);
PHALCON_INIT_NVAR(scope);
array_init_size(scope, 2);
phalcon_array_append(&scope, name, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&scope, validator, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&prepared_validators, scope, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Create an implicit validation
*/
PHALCON_INIT_NVAR(validation);
object_init_ex(validation, phalcon_validation_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validation, "__construct", prepared_validators);
PHALCON_INIT_NVAR(element_messages);
PHALCON_CALL_METHOD_PARAMS_2(element_messages, validation, "validate", data, entity);
if (phalcon_fast_count_ev(element_messages TSRMLS_CC)) {
PHALCON_INIT_NVAR(name);
PHALCON_CALL_METHOD(name, element, "getname");
phalcon_array_update_zval(&messages, name, &element_messages, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(not_failed);
ZVAL_BOOL(not_failed, 0);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* If the validation fails
*/
if (!zend_is_true(not_failed)) {
phalcon_update_property_zval(this_ptr, SL("_messages"), messages TSRMLS_CC);
}
/**
* Return the validation status
*/
RETURN_NCTOR(not_failed);
}
PHALCON_MM_RESTORE();
}
/**
* Transforms an intermediate representation for a expression into a database system valid expression
*
* @param array $expression
* @param string $escapeChar
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, getSqlExpression){
zval *expression, *escape_char = NULL, *type, *name = NULL, *escaped_name = NULL;
zval *domain, *escaped_domain = NULL, *value = NULL, *operator = NULL;
zval *left = NULL, *expression_left = NULL, *right = NULL, *expression_right = NULL;
zval *expression_group, *sql_arguments, *arguments;
zval *argument = NULL, *argument_expression = NULL, *arguments_joined;
zval *sql_items, *items, *item = NULL, *item_expression = NULL;
zval *list_expression, *exception_message;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &expression, &escape_char);
if (!escape_char) {
PHALCON_INIT_VAR(escape_char);
} else {
PHALCON_SEPARATE_PARAM(escape_char);
}
if (PHALCON_GLOBAL(db).escape_identifiers) {
if (Z_TYPE_P(escape_char) == IS_NULL) {
PHALCON_OBS_NVAR(escape_char);
phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC);
}
}
if (Z_TYPE_P(expression) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression");
return;
}
if (!phalcon_array_isset_string(expression, SS("type"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression");
return;
}
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, expression, SL("type"), PH_NOISY);
/**
* Resolve qualified expressions
*/
if (PHALCON_IS_STRING(type, "qualified")) {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(escaped_name);
PHALCON_CONCAT_VVV(escaped_name, escape_char, name, escape_char);
} else {
PHALCON_CPY_WRT(escaped_name, name);
}
/**
* A domain could be a table/schema
*/
if (phalcon_array_isset_string(expression, SS("domain"))) {
PHALCON_OBS_VAR(domain);
phalcon_array_fetch_string(&domain, expression, SL("domain"), PH_NOISY);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(escaped_domain);
PHALCON_CONCAT_VVVSV(escaped_domain, escape_char, domain, escape_char, ".", escaped_name);
} else {
PHALCON_INIT_NVAR(escaped_domain);
PHALCON_CONCAT_VSV(escaped_domain, domain, ".", escaped_name);
}
RETURN_CTOR(escaped_domain);
}
RETURN_CCTOR(escaped_name);
}
/**
* Resolve literal expressions
*/
if (PHALCON_IS_STRING(type, "literal")) {
PHALCON_OBS_VAR(value);
phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY);
RETURN_CCTOR(value);
}
/**
* Resolve binary operations expressions
*/
if (PHALCON_IS_STRING(type, "binary-op")) {
PHALCON_OBS_VAR(operator);
phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY);
PHALCON_OBS_VAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY);
PHALCON_INIT_VAR(expression_left);
phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_OBS_VAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY);
PHALCON_INIT_VAR(expression_right);
phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_CONCAT_VSVSV(return_value, expression_left, " ", operator, " ", expression_right);
RETURN_MM();
}
/**
* Resolve unary operations expressions
*/
if (PHALCON_IS_STRING(type, "unary-op")) {
PHALCON_OBS_NVAR(operator);
phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY);
/**
* Some unary operators uses the left operand...
*/
if (phalcon_array_isset_string(expression, SS("left"))) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY);
PHALCON_INIT_NVAR(expression_left);
phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_CONCAT_VV(return_value, expression_left, operator);
RETURN_MM();
}
/**
* ...Others uses the right operand
*/
if (phalcon_array_isset_string(expression, SS("right"))) {
PHALCON_OBS_NVAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY);
PHALCON_INIT_NVAR(expression_right);
phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_CONCAT_VV(return_value, operator, expression_right);
RETURN_MM();
}
}
/**
* Resolve placeholder
*/
if (PHALCON_IS_STRING(type, "placeholder")) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY);
RETURN_CCTOR(value);
}
/**
* Resolve parentheses
*/
if (PHALCON_IS_STRING(type, "parentheses")) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY);
PHALCON_INIT_NVAR(expression_left);
phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_INIT_VAR(expression_group);
PHALCON_CONCAT_SVS(expression_group, "(", expression_left, ")");
RETURN_CTOR(expression_group);
}
/**
* Resolve function calls
*/
if (PHALCON_IS_STRING(type, "functionCall")) {
PHALCON_OBS_NVAR(name);
phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY);
PHALCON_INIT_VAR(sql_arguments);
array_init(sql_arguments);
if (phalcon_array_isset_string(expression, SS("arguments"))) {
PHALCON_OBS_VAR(arguments);
phalcon_array_fetch_string(&arguments, expression, SL("arguments"), PH_NOISY);
phalcon_is_iterable(arguments, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
PHALCON_INIT_NVAR(argument_expression);
phalcon_call_method_p2(argument_expression, this_ptr, "getsqlexpression", argument, escape_char);
phalcon_array_append(&sql_arguments, argument_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(arguments_joined);
phalcon_fast_join_str(arguments_joined, SL(", "), sql_arguments TSRMLS_CC);
PHALCON_CONCAT_VSVS(return_value, name, "(", arguments_joined, ")");
RETURN_MM();
} else {
PHALCON_CONCAT_VS(return_value, name, "()");
RETURN_MM();
}
}
/**
* Resolve lists
*/
if (PHALCON_IS_STRING(type, "list")) {
PHALCON_INIT_VAR(sql_items);
array_init(sql_items);
PHALCON_OBS_VAR(items);
phalcon_array_fetch_long(&items, expression, 0, PH_NOISY);
phalcon_is_iterable(items, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(item);
PHALCON_INIT_NVAR(item_expression);
phalcon_call_method_p2(item_expression, this_ptr, "getsqlexpression", item, escape_char);
phalcon_array_append(&sql_items, item_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(list_expression);
phalcon_fast_join_str(list_expression, SL(", "), sql_items TSRMLS_CC);
PHALCON_CONCAT_SVS(return_value, "(", list_expression, ")");
RETURN_MM();
}
/**
* Resolve *
*/
if (PHALCON_IS_STRING(type, "all")) {
RETURN_MM_STRING("*", 1);
}
/**
* Resolve CAST of values
*/
if (PHALCON_IS_STRING(type, "cast")) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY);
PHALCON_INIT_NVAR(expression_left);
phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_OBS_NVAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY);
PHALCON_INIT_NVAR(expression_right);
phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_CONCAT_SVSVS(return_value, "CAST(", expression_left, " AS ", expression_right, ")");
RETURN_MM();
}
/**
* Resolve CONVERT of values encodings
*/
if (PHALCON_IS_STRING(type, "convert")) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY);
PHALCON_INIT_NVAR(expression_left);
phalcon_call_method_p2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_OBS_NVAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY);
PHALCON_INIT_NVAR(expression_right);
phalcon_call_method_p2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_CONCAT_SVSVS(return_value, "CONVERT(", expression_left, " USING ", expression_right, ")");
RETURN_MM();
}
/**
* Expression type wasn't found
*/
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Invalid SQL expression type '", type, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message);
return;
}
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, select){
zval *definition, *escape_char = NULL, *columns, *selected_columns;
zval *column = NULL, *column_item = NULL, *column_sql = NULL, *column_domain = NULL;
zval *column_domain_sql = NULL, *column_alias = NULL, *column_alias_sql = NULL;
zval *columns_sql = NULL, *tables, *selected_tables;
zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins;
zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL;
zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL;
zval *join_conditions = NULL, *where_conditions;
zval *where_expression, *group_items, *group_fields;
zval *group_field = NULL, *group_expression = NULL, *group_sql;
zval *group_clause, *having_conditions, *having_expression;
zval *order_fields, *order_items, *order_item = NULL;
zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL;
zval *order_sql_item_type = NULL, *order_sql, *limit_value;
zval *number, *offset;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &definition);
if (Z_TYPE_P(definition) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SELECT definition");
return;
}
if (!phalcon_array_isset_string(definition, SS("tables"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'tables' is required in the definition array");
return;
}
if (!phalcon_array_isset_string(definition, SS("columns"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array");
return;
}
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_OBS_VAR(escape_char);
phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(escape_char);
}
PHALCON_OBS_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY);
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(column);
/**
* Escape column name
*/
PHALCON_OBS_NVAR(column_item);
phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY);
if (Z_TYPE_P(column_item) == IS_ARRAY) {
PHALCON_INIT_NVAR(column_sql);
phalcon_call_method_p2(column_sql, this_ptr, "getsqlexpression", column_item, escape_char);
} else {
if (PHALCON_IS_STRING(column_item, "*")) {
PHALCON_CPY_WRT(column_sql, column_item);
} else {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_sql);
PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char);
} else {
PHALCON_CPY_WRT(column_sql, column_item);
}
}
}
/**
* Escape column domain
*/
if (phalcon_array_isset_long(column, 1)) {
PHALCON_OBS_NVAR(column_domain);
phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY);
if (zend_is_true(column_domain)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql);
} else {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
/**
* Escape column alias
*/
if (phalcon_array_isset_long(column, 2)) {
PHALCON_OBS_NVAR(column_alias);
phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY);
if (zend_is_true(column_alias)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " AS ", escape_char, column_alias, escape_char);
} else {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " AS ", column_alias);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(columns_sql);
phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC);
} else {
PHALCON_CPY_WRT(columns_sql, columns);
}
/**
* Check and escape tables
*/
PHALCON_OBS_VAR(tables);
phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY);
if (Z_TYPE_P(tables) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_tables);
array_init(selected_tables);
phalcon_is_iterable(tables, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(table);
PHALCON_INIT_NVAR(sql_table);
phalcon_call_method_p2(sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(tables_sql);
phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC);
} else {
PHALCON_CPY_WRT(tables_sql, tables);
}
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVSV(sql, "SELECT ", columns_sql, " FROM ", tables_sql);
/**
* Check for joins
*/
if (phalcon_array_isset_string(definition, SS("joins"))) {
PHALCON_OBS_VAR(joins);
phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY);
phalcon_is_iterable(joins, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HVALUE(join);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY);
PHALCON_OBS_NVAR(table);
phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY);
PHALCON_INIT_NVAR(sql_table);
phalcon_call_method_p2(sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
PHALCON_INIT_NVAR(sql_join);
PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table);
/**
* Check if the join has conditions
*/
if (phalcon_array_isset_string(join, SS("conditions"))) {
PHALCON_OBS_NVAR(join_conditions_array);
phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY);
if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) {
PHALCON_INIT_NVAR(join_expressions);
array_init(join_expressions);
phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(join_condition);
PHALCON_INIT_NVAR(join_expression);
phalcon_call_method_p2(join_expression, this_ptr, "getsqlexpression", join_condition, escape_char);
phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah3, &hp3);
}
PHALCON_INIT_NVAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC);
PHALCON_SCONCAT_SVS(sql_join, " ON ", join_conditions, " ");
}
}
phalcon_concat_self(&sql, sql_join TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Check for a WHERE clause
*/
if (phalcon_array_isset_string(definition, SS("where"))) {
PHALCON_OBS_VAR(where_conditions);
phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY);
if (Z_TYPE_P(where_conditions) == IS_ARRAY) {
PHALCON_INIT_VAR(where_expression);
phalcon_call_method_p2(where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression);
} else {
PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions);
}
}
/**
* Check for a GROUP clause
*/
if (phalcon_array_isset_string(definition, SS("group"))) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
PHALCON_OBS_VAR(group_fields);
phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY);
phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HVALUE(group_field);
PHALCON_INIT_NVAR(group_expression);
phalcon_call_method_p2(group_expression, this_ptr, "getsqlexpression", group_field, escape_char);
phalcon_array_append(&group_items, group_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(group_sql);
phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC);
PHALCON_INIT_VAR(group_clause);
PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql);
phalcon_concat_self(&sql, group_clause TSRMLS_CC);
/**
* Check for a HAVING clause
*/
if (phalcon_array_isset_string(definition, SS("having"))) {
PHALCON_OBS_VAR(having_conditions);
phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY);
PHALCON_INIT_VAR(having_expression);
phalcon_call_method_p2(having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression);
}
}
/**
* Check for a ORDER clause
*/
if (phalcon_array_isset_string(definition, SS("order"))) {
PHALCON_OBS_VAR(order_fields);
phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY);
PHALCON_INIT_VAR(order_items);
array_init(order_items);
phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0);
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_HVALUE(order_item);
PHALCON_OBS_NVAR(order_expression);
phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY);
PHALCON_INIT_NVAR(order_sql_item);
phalcon_call_method_p2(order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char);
/**
* In the numeric 1 position could be a ASC/DESC clause
*/
if (phalcon_array_isset_long(order_item, 1)) {
PHALCON_OBS_NVAR(sql_order_type);
phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY);
PHALCON_INIT_NVAR(order_sql_item_type);
PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type);
} else {
PHALCON_CPY_WRT(order_sql_item_type, order_sql_item);
}
phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE);
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_VAR(order_sql);
phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql);
}
/**
* Check for a LIMIT condition
*/
if (phalcon_array_isset_string(definition, SS("limit"))) {
PHALCON_OBS_VAR(limit_value);
phalcon_array_fetch_string(&limit_value, definition, SL("limit"), PH_NOISY);
if (Z_TYPE_P(limit_value) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit_value, SL("number"), PH_NOISY);
/**
* Check for a OFFSET condition
*/
if (phalcon_array_isset_string(limit_value, SS("offset"))) {
PHALCON_OBS_VAR(offset);
phalcon_array_fetch_string(&offset, limit_value, SL("offset"), PH_NOISY);
PHALCON_SCONCAT_SVSV(sql, " LIMIT ", number, " OFFSET ", offset);
} else {
PHALCON_SCONCAT_SV(sql, " LIMIT ", number);
}
} else {
PHALCON_SCONCAT_SV(sql, " LIMIT ", limit_value);
}
}
RETURN_CTOR(sql);
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name, *pattern, *is_phalcon_class;
zval *namespace_separator, *prepare_uri_class;
zval *class_reflection, *is_internal = NULL, *lower_class_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *function_reflection, *prepared_function_name;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *one;
zval *file, *line, *show_files, *lines, *number_lines;
zval *show_file_fragment, *seven, *before_line;
zval *first_line = NULL, *five, *after_line, *last_line = NULL;
zval *comment_pattern, *utf8, *ent_compat, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0, *ce1;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &n, &trace);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY_CC);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^Phalcon/", 1);
PHALCON_INIT_VAR(is_phalcon_class);
#if HAVE_BUNDLED_PCRE
phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC);
#else
phalcon_call_func_p2(is_phalcon_class, "preg_match", pattern, class_name);
#endif
/**
* We assume that classes starting by Phalcon are framework's classes
*/
if (zend_is_true(is_phalcon_class)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/**
* Prepare the class name according to the Phalcon's conventions
*/
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name TSRMLS_CC);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else {
ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(class_reflection);
object_init_ex(class_reflection, ce0);
if (phalcon_has_constructor(class_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(class_reflection, "__construct", class_name);
}
/**
* Check if classes are PHP's classes
*/
PHALCON_INIT_VAR(is_internal);
phalcon_call_method(is_internal, class_reflection, "isinternal");
if (zend_is_true(is_internal)) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name TSRMLS_CC);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY_CC);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY_CC);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY_CC);
/**
* Check if the function exists
*/
if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) {
ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(function_reflection);
object_init_ex(function_reflection, ce1);
if (phalcon_has_constructor(function_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(function_reflection, "__construct", function_name);
}
PHALCON_INIT_NVAR(is_internal);
phalcon_call_method(is_internal, function_reflection, "isinternal");
/**
* Internal functions links to the PHP documentation
*/
if (zend_is_true(is_internal)) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name TSRMLS_CC);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY_CC);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_INIT_NVAR(dumped_argument);
phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY_CC);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY_CC);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_INIT_VAR(lines);
phalcon_call_func_p1(lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take seven lines back to the current exception's line, @TODO add an option for
* this
*/
PHALCON_INIT_VAR(seven);
ZVAL_LONG(seven, 7);
PHALCON_INIT_VAR(before_line);
sub_function(before_line, line, seven TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT(first_line, one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take five lines after the current exception's line, @TODO add an option for this
*/
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, five TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT(first_line, one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
/**
* We assume the file is utf-8 encoded, @TODO add an option for this
*/
PHALCON_INIT_VAR(utf8);
ZVAL_STRING(utf8, "UTF-8", 1);
/**
* Don't escape quotes
*/
PHALCON_INIT_VAR(ent_compat);
ZVAL_LONG(ent_compat, 2);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (1) {
if (PHALCON_LE(i, last_line)) {
} else {
break;
}
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
sub_function(line_position, i, one TSRMLS_CC);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY_CC);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
#if HAVE_BUNDLED_PCRE
phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC);
#else
phalcon_call_func_p2(is_comment, "preg_match", comment_pattern, current_line);
#endif
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line TSRMLS_CC);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line TSRMLS_CC);
PHALCON_INIT_NVAR(escaped_line);
phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
PHALCON_SEPARATE(i);
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Produces a recursive representation of an array
*
* @param array $argument
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump){
zval *argument, *n = NULL, *number_arguments, *one, *dump;
zval *v = NULL, *k = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL;
zval *class_name = NULL, *joined_dump;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &argument, &n);
if (!n) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
PHALCON_INIT_VAR(number_arguments);
phalcon_fast_count(number_arguments, argument TSRMLS_CC);
if (PHALCON_LT_LONG(n, 3)) {
if (PHALCON_GT_LONG(number_arguments, 0)) {
if (PHALCON_LT_LONG(number_arguments, 10)) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(dump);
array_init(dump);
phalcon_is_iterable(argument, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(k, ah0, hp0);
PHALCON_GET_HVALUE(v);
if (PHALCON_IS_SCALAR(v)) {
if (PHALCON_IS_STRING(v, "")) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => (empty string)");
} else {
PHALCON_INIT_NVAR(escaped_string);
phalcon_call_method_p1(escaped_string, this_ptr, "_escapestring", v);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", escaped_string);
}
phalcon_array_append(&dump, var_dump, PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, n, one TSRMLS_CC);
PHALCON_INIT_NVAR(array_dump);
phalcon_call_method_p2(array_dump, this_ptr, "_getarraydump", v, next);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Array(", array_dump, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, v, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Object(", class_name, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => null");
phalcon_array_append(&dump, var_dump, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", v);
phalcon_array_append(&dump, var_dump, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_dump);
phalcon_fast_join_str(joined_dump, SL(", "), dump TSRMLS_CC);
RETURN_CTOR(joined_dump);
}
RETURN_NCTOR(number_arguments);
}
}
RETURN_MM_NULL();
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *link_format, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name;
zval *namespace_separator, *prepare_uri_class;
zval *lower_class_name, *prepared_function_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *z_one;
zval *file, *line, *show_files, *lines = NULL, *number_lines;
zval *show_file_fragment, *before_context, *before_line;
zval *first_line = NULL, *after_context, *after_line, *last_line = NULL;
zval *comment_pattern, *charset, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL, *formatted_file = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &n, &trace, &link_format);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
zend_class_entry *class_ce;
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
class_ce = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_SILENT TSRMLS_CC);
if (!class_ce) {
/* Unable to load the class, should never happen */
}
else if (is_phalcon_class(class_ce)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/* Prepare the class name according to the Phalcon's conventions */
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name);
/* Generate a link to the official docs */
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else if (class_ce->type == ZEND_INTERNAL_CLASS) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name);
/* Generate a link to the official docs */
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
zend_function *func;
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
convert_to_string(function_name);
/**
* Check if the function exists
*/
if (phalcon_fetch_function(&func, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name) TSRMLS_CC) == SUCCESS) {
/**
* Internal functions links to the PHP documentation
*/
if (func->type == ZEND_INTERNAL_FUNCTION) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_CALL_METHOD(&dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
z_one = PHALCON_GLOBAL(z_one);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY);
PHALCON_CALL_METHOD(&formatted_file, getThis(), "getfilelink", file, line, link_format);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", formatted_file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY TSRMLS_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_CALL_FUNCTION(&lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY TSRMLS_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take lines back to the current exception's line
*/
before_context = phalcon_fetch_nproperty_this(getThis(), SL("_beforeContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(before_line);
phalcon_sub_function(before_line, line, before_context);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT_CTOR(first_line, z_one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take lines after the current exception's line
*/
after_context = phalcon_fetch_nproperty_this(getThis(), SL("_afterContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, after_context);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT_CTOR(first_line, z_one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
charset = phalcon_fetch_static_property_ce(phalcon_debug_ce, SL("_charset") TSRMLS_CC);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (PHALCON_LE(i, last_line)) {
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
phalcon_sub_function(line_position, i, z_one);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, NULL, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
RETURN_MM_ON_FAILURE(phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC));
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line);
PHALCON_INIT_NVAR(escaped_line);
phalcon_htmlentities(escaped_line, spaced_current_line, NULL, charset TSRMLS_CC);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Generates SQL to add the table creation options
*
* @param array $definition
* @return array
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){
zval *definition = NULL, *table_options = NULL, *engine = NULL, *auto_increment = NULL;
zval *table_collation = NULL, *collation_parts = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *c0 = NULL, *c1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(table_options, a0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r0, "ENGINE", strlen("ENGINE")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, r1, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(engine, r2);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, r3, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SV(r5, "ENGINE=", engine);
phalcon_array_append(&table_options, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_string(&r6, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r6, "AUTO_INCREMENT", strlen("AUTO_INCREMENT")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, r7, "AUTO_INCREMENT", strlen("AUTO_INCREMENT"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(auto_increment, r8);
if (zend_is_true(auto_increment)) {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_SV(r9, "AUTO_INCREMENT=", auto_increment);
phalcon_array_append(&table_options, r9, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_array_fetch_string(&r10, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r10, "TABLE_COLLATION", strlen("TABLE_COLLATION")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r11);
phalcon_array_fetch_string(&r11, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r12);
phalcon_array_fetch_string(&r12, r11, "TABLE_COLLATION", strlen("TABLE_COLLATION"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(table_collation, r12);
if (zend_is_true(table_collation)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "_", 1);
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_fast_explode(r13, c0, table_collation TSRMLS_CC);
PHALCON_CPY_WRT(collation_parts, r13);
PHALCON_ALLOC_ZVAL_MM(r14);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_array_fetch_long(&r15, collation_parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_SV(r14, "DEFAULT CHARSET=", r15);
phalcon_array_append(&table_options, r14, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r16);
PHALCON_CONCAT_SV(r16, "COLLATE=", table_collation);
phalcon_array_append(&table_options, r16, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r17);
phalcon_fast_count(r17, table_options TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, " ", 1);
PHALCON_ALLOC_ZVAL_MM(r18);
phalcon_fast_join(r18, c1, table_options TSRMLS_CC);
PHALCON_RETURN_DZVAL(r18);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHP_METHOD(Phalcon_Request, _getQualityHeader){
zval *server_index = NULL, *name = NULL, *http_server = NULL, *parts = NULL;
zval *returned_parts = NULL, *part = NULL, *header_parts = NULL, *quality = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *a0 = NULL, *a1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &server_index, &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "getserver", server_index, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(http_server, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/,\\s*/", 1);
PHALCON_CALL_FUNC_PARAMS_2(r1, "preg_split", c0, http_server, 0x048);
PHALCON_CPY_WRT(parts, r1);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(returned_parts, a0);
if (phalcon_valid_foreach(parts TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9aea_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9aea_1;
}
PHALCON_INIT_VAR(part);
ZVAL_ZVAL(part, *hd, 1, 0);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, ";", 1);
PHALCON_INIT_VAR(r2);
phalcon_fast_explode(r2, c1, part TSRMLS_CC);
PHALCON_CPY_WRT(header_parts, r2);
eval_int = phalcon_array_isset_long(header_parts, 1);
if (eval_int) {
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_long(&r4, header_parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(c2);
ZVAL_LONG(c2, 2);
PHALCON_CALL_FUNC_PARAMS_2(r3, "substr", r4, c2, 0x002);
PHALCON_CPY_WRT(quality, r3);
} else {
PHALCON_INIT_VAR(quality);
ZVAL_DOUBLE(quality, 1);
}
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_long(&r5, header_parts, 0, PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&a1, name, &r5, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_string(&a1, "quality", strlen("quality"), &quality, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_append(&returned_parts, a1, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9aea_1;
fee_9aea_1:
if(0){}
} else {
return;
}
PHALCON_RETURN_CTOR(returned_parts);
}
/**
* Generates SQL to create a table in MySQL
*
* @param string $tableName
* @param string $schemaName
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){
zval *table_name = NULL, *schema_name = NULL, *definition = NULL;
zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *column = NULL;
zval *column_line = NULL, *index = NULL, *index_name = NULL, *column_list = NULL;
zval *reference = NULL, *reference_sql = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL;
zval *r28 = NULL, *r29 = NULL, *r30 = NULL, *r31 = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (zend_is_true(schema_name)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVSVS(r0, "`", schema_name, "`.`", table_name, "`");
PHALCON_CPY_WRT(table, r0);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SVS(r1, "`", table_name, "`");
PHALCON_CPY_WRT(table, r1);
}
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 0);
eval_int = phalcon_array_isset_string(definition, "options", strlen("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r2, "temporary", strlen("temporary")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, r3, "temporary", strlen("temporary"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 1);
}
}
}
if (zend_is_true(temporary)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SVS(r5, "CREATE TEMPORARY TABLE ", table, " (\n\t");
PHALCON_CPY_WRT(sql, r5);
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CONCAT_SVS(r6, "CREATE TABLE ", table, " (\n\t");
PHALCON_CPY_WRT(sql, r6);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(create_lines, a0);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, definition, "columns", strlen("columns"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r7 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(r7);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_52be_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_52be_2;
}
PHALCON_INIT_VAR(column);
ZVAL_ZVAL(column, *hd, 1, 0);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD(r9, column, "getname", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r10);
PHALCON_CALL_SELF_PARAMS_1(r10, this_ptr, "getcolumndefinition", column);
PHALCON_CONCAT_SVSV(r8, "`", r9, "` ", r10);
PHALCON_CPY_WRT(column_line, r8);
PHALCON_INIT_VAR(r11);
PHALCON_CALL_METHOD(r11, column, "isnotnull", PHALCON_NO_CHECK);
if (zend_is_true(r11)) {
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " NOT NULL", 1);
phalcon_concat_self(&column_line, t0 TSRMLS_CC);
}
PHALCON_INIT_VAR(r12);
PHALCON_CALL_METHOD(r12, column, "isautoincrement", PHALCON_NO_CHECK);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, " AUTO_INCREMENT", 1);
phalcon_concat_self(&column_line, t1 TSRMLS_CC);
}
phalcon_array_append(&create_lines, column_line, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_2;
fee_52be_2:
if(0){}
} else {
return;
}
eval_int = phalcon_array_isset_string(definition, "indexes", strlen("indexes")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_array_fetch_string(&r13, definition, "indexes", strlen("indexes"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r13 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(r13);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_52be_3:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_52be_3;
}
PHALCON_INIT_VAR(index);
ZVAL_ZVAL(index, *hd, 1, 0);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD(r14, index, "getname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(index_name, r14);
PHALCON_INIT_VAR(r15);
PHALCON_INIT_VAR(r16);
PHALCON_CALL_METHOD(r16, index, "getcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r15, this_ptr, "getcolumnlist", r16);
PHALCON_CPY_WRT(column_list, r15);
if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) {
PHALCON_INIT_VAR(r17);
PHALCON_CONCAT_SVS(r17, "PRIMARY KEY (", column_list, ")");
phalcon_array_append(&create_lines, r17, PHALCON_SEPARATE_PLZ TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r18);
PHALCON_CONCAT_SVSVS(r18, "KEY `", index_name, "` (", column_list, ")");
phalcon_array_append(&create_lines, r18, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_52be_3;
fee_52be_3:
if(0){}
} else {
return;
}
}
eval_int = phalcon_array_isset_string(definition, "references", strlen("references")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r19);
phalcon_array_fetch_string(&r19, definition, "references", strlen("references"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r19 TSRMLS_CC)) {
ah2 = Z_ARRVAL_P(r19);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_52be_4:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_52be_4;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(r20);
PHALCON_INIT_VAR(r21);
PHALCON_CALL_METHOD(r21, reference, "getname", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r22);
PHALCON_INIT_VAR(r23);
PHALCON_CALL_METHOD(r23, reference, "getcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r22, this_ptr, "getcolumnlist", r23);
PHALCON_CONCAT_SVSV(r20, "CONSTRAINT `", r21, "` FOREIGN KEY (", r22);
PHALCON_CPY_WRT(reference_sql, r20);
PHALCON_INIT_VAR(r24);
PHALCON_INIT_VAR(r25);
PHALCON_CALL_METHOD(r25, reference, "getreferencedtable", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r26);
PHALCON_INIT_VAR(r27);
PHALCON_CALL_METHOD(r27, reference, "getreferencedcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r26, this_ptr, "getcolumnlist", r27);
PHALCON_CONCAT_SVSVS(r24, ") REFERENCES `", r25, "`(", r26, ")");
phalcon_concat_self(&reference_sql, r24 TSRMLS_CC);
phalcon_array_append(&create_lines, reference_sql, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_52be_4;
fee_52be_4:
if(0){}
} else {
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r28);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ",\n\t", 1);
PHALCON_ALLOC_ZVAL_MM(r29);
phalcon_fast_join(r29, c0, create_lines TSRMLS_CC);
PHALCON_CONCAT_VS(r28, r29, "\n)");
phalcon_concat_self(&sql, r28 TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, "options", strlen("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r30);
PHALCON_ALLOC_ZVAL_MM(r31);
PHALCON_CALL_SELF_PARAMS_1(r31, this_ptr, "_gettableoptions", definition);
PHALCON_CONCAT_SV(r30, " ", r31);
phalcon_concat_self(&sql, r30 TSRMLS_CC);
}
PHALCON_RETURN_CTOR(sql);
}
/**
* Internal handler to call a queue of events
*
* @param \SplPriorityQueue $queue
* @param Phalcon\Events\Event $event
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fireQueue){
zval *queue, *event, *status = NULL, *arguments = NULL, *event_name;
zval *source, *data, *cancelable, *collect, *iterator;
zval *handler = NULL, *is_stopped = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &queue, &event);
if (unlikely(Z_TYPE_P(queue) != IS_ARRAY)) {
if (Z_TYPE_P(queue) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The SplPriorityQueue is not valid");
return;
}
}
if (unlikely(Z_TYPE_P(event) != IS_OBJECT)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event is not valid");
return;
}
PHALCON_INIT_VAR(status);
PHALCON_INIT_VAR(arguments);
/**
* Get the event type
*/
PHALCON_INIT_VAR(event_name);
phalcon_call_method(event_name, event, "gettype");
if (unlikely(Z_TYPE_P(event_name) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event type not valid");
return;
}
/**
* Get the object who triggered the event
*/
PHALCON_INIT_VAR(source);
phalcon_call_method(source, event, "getsource");
/**
* Get extra data passed to the event
*/
PHALCON_INIT_VAR(data);
phalcon_call_method(data, event, "getdata");
/**
* Tell if the event is cancelable
*/
PHALCON_INIT_VAR(cancelable);
phalcon_call_method(cancelable, event, "getcancelable");
/**
* Responses need to be traced?
*/
PHALCON_OBS_VAR(collect);
phalcon_read_property_this(&collect, this_ptr, SL("_collect"), PH_NOISY_CC);
if (Z_TYPE_P(queue) == IS_OBJECT) {
/**
* We need to clone the queue before iterate over it
*/
PHALCON_INIT_VAR(iterator);
if (phalcon_clone(iterator, queue TSRMLS_CC) == FAILURE) {
return;
}
/**
* Move the queue to the top
*/
phalcon_call_method_noret(iterator, "top");
while (1) {
PHALCON_INIT_NVAR(r0);
phalcon_call_method(r0, iterator, "valid");
if (zend_is_true(r0)) {
} else {
break;
}
/**
* Get the current data
*/
PHALCON_INIT_NVAR(handler);
phalcon_call_method(handler, iterator, "current");
/**
* Only handler objects are valid
*/
if (likely(Z_TYPE_P(handler) == IS_OBJECT)) {
/**
* Check if the event is a closure
*/
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
/**
* Create the closure arguments
*/
if (Z_TYPE_P(arguments) == IS_NULL) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 3);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
}
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
/**
* Trace the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
} else {
/**
* Check if the listener has implemented an event with the same name
*/
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_zval_p3(status, handler, event_name, event, source, data);
/**
* Collect the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
}
}
}
/**
* Move the queue to the next handler
*/
phalcon_call_method_noret(iterator, "next");
}
} else {
phalcon_is_iterable(queue, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(handler);
/**
* Only handler objects are valid
*/
if (likely(Z_TYPE_P(handler) == IS_OBJECT)) {
/**
* Check if the event is a closure
*/
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
/**
* Create the closure arguments
*/
if (Z_TYPE_P(arguments) == IS_NULL) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 3);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
}
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
/**
* Trace the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
} else {
/**
* Check if the listener has implemented an event with the same name
*/
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_zval_p3(status, handler, event_name, event, source, data);
/**
* Collect the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
RETURN_CCTOR(status);
}
/**
* Fires a event in the events manager causing that the acive listeners will be notified about it
*
* @param string $eventType
* @param object $source
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type = NULL, *source = NULL, *colon = NULL, *event_parts = NULL;
zval *exception_message = NULL, *exception = NULL, *type = NULL, *event_name = NULL;
zval *status = NULL, *events = NULL, *fire_events = NULL, *handler = NULL, *event = NULL;
zval *class_name = NULL, *arguments = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_type, &source) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(colon);
ZVAL_STRING(colon, ":", 1);
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC);
eval_int = phalcon_array_isset_long(event_parts, 1);
if (!eval_int) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_events_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(status);
ZVAL_NULL(status);
PHALCON_INIT_VAR(events);
phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC);
eval_int = phalcon_array_isset(events, type);
if (eval_int) {
PHALCON_INIT_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC);
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
PHALCON_INIT_VAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(event, "__construct", event_name, source, PH_CHECK);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, handler TSRMLS_CC);
if (PHALCON_COMPARE_STRING(class_name, "Closure")) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_FUNC_PARAMS_2(status, "call_user_func_array", handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, handler, Z_STRVAL_P(event_name), event, source, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
RETURN_CCTOR(status);
}
/**
* Attach a listener to the events manager
*
* @param string $eventType
* @param object $handler
* @param int $priority
*/
PHP_METHOD(Phalcon_Events_Manager, attach){
zval *event_type, *handler, *priority = NULL, *events = NULL;
zval *enable_priorities, *priority_queue = NULL;
zval *mode;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &event_type, &handler, &priority);
if (!priority) {
PHALCON_INIT_VAR(priority);
ZVAL_LONG(priority, 100);
}
if (unlikely(Z_TYPE_P(event_type) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
if (unlikely(Z_TYPE_P(handler) != IS_OBJECT)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event handler must be an Object");
return;
}
PHALCON_OBS_VAR(events);
phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
PHALCON_INIT_NVAR(events);
array_init(events);
}
if (!phalcon_array_isset(events, event_type)) {
PHALCON_OBS_VAR(enable_priorities);
phalcon_read_property_this(&enable_priorities, this_ptr, SL("_enablePriorities"), PH_NOISY_CC);
if (zend_is_true(enable_priorities)) {
/**
* Create a SplPriorityQueue to store the events with priorities
*/
PHALCON_INIT_VAR(priority_queue);
object_init_ex(priority_queue, spl_ce_SplPriorityQueue);
if (phalcon_has_constructor(priority_queue TSRMLS_CC)) {
phalcon_call_method_noret(priority_queue, "__construct");
}
/**
* Extract only the Data
*/
PHALCON_INIT_VAR(mode);
ZVAL_LONG(mode, 1);
/**
* Set extraction flags
*/
phalcon_call_method_p1_noret(priority_queue, "setextractflags", mode);
/**
* Append the events to the queue
*/
phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(priority_queue);
array_init(priority_queue);
}
} else {
/**
* Get the current SplPriorityQueue
*/
PHALCON_OBS_NVAR(priority_queue);
phalcon_array_fetch(&priority_queue, events, event_type, PH_NOISY_CC);
}
/**
* Insert the handler in the queue
*/
if (unlikely(Z_TYPE_P(priority_queue) == IS_OBJECT)) {
phalcon_call_method_p2_noret(priority_queue, "insert", handler, priority);
} else {
phalcon_array_append(&priority_queue, handler, PH_SEPARATE TSRMLS_CC);
/**
* Append the events to the queue
*/
phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts = NULL;
zval *value = NULL, *key = NULL, *dsn = NULL, *options = NULL, *persistent = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
zval *c0 = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!descriptor) {
PHALCON_ALLOC_ZVAL_MM(descriptor);
ZVAL_NULL(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_INIT_VAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
eval_int = phalcon_array_isset_string(descriptor, SL("username")+1);
if (eval_int) {
PHALCON_INIT_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SL("username")+1);
} else {
PHALCON_INIT_VAR(username);
ZVAL_NULL(username);
}
eval_int = phalcon_array_isset_string(descriptor, SL("password")+1);
if (eval_int) {
PHALCON_INIT_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SL("password")+1);
} else {
PHALCON_INIT_VAR(password);
ZVAL_NULL(password);
}
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
if (!phalcon_valid_foreach(descriptor TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(descriptor);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CONCAT_VSV(r0, key, "=", value);
phalcon_array_append(&dsn_parts, r0, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_0;
fee_7f5d_0:
if(0){}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ";", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_join(r1, c0, dsn_parts TSRMLS_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, t0, ":", r1);
PHALCON_INIT_VAR(options);
array_init(options);
add_index_long(options, 3, 0);
add_index_long(options, 8, 2);
add_index_long(options, 10, 1);
eval_int = phalcon_array_isset_string(descriptor, SL("persistent")+1);
if (eval_int) {
PHALCON_INIT_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY_CC);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, 12, 1, PH_SEPARATE TSRMLS_CC);
}
}
ce0 = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, ce0);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(i0, "__construct", dsn, username, password, options, PH_CHECK);
phalcon_update_property_zval(this_ptr, SL("_pdo"), i0 TSRMLS_CC);
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Db\\Adapter\\Pdo", "__construct", descriptor);
PHALCON_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *one, *zero, *show, *config, *items, *page_number = NULL;
zval *smaller, *n, *page, *last_show_page, *start;
zval *last_page, *possible_pages = NULL, *total_pages;
zval *compare = NULL, *page_items, *i, *valid = NULL, *current = NULL, *maximum_pages;
zval *next = NULL, *additional_page, *before = NULL, *remainder;
zval *pages_total = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_OBS_VAR(show);
phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_OBS_VAR(config);
phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_OBS_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
PHALCON_OBS_VAR(page_number);
phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_CPY_WRT(page_number, one);
}
PHALCON_INIT_VAR(smaller);
is_smaller_function(smaller, show, zero TSRMLS_CC);
if (PHALCON_IS_TRUE(smaller)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(n);
phalcon_fast_count(n, items TSRMLS_CC);
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(last_show_page);
sub_function(last_show_page, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, last_show_page TSRMLS_CC);
PHALCON_INIT_VAR(last_page);
sub_function(last_page, n, one TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, last_page, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages);
if (Z_TYPE_P(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_CPY_WRT(page_number, zero);
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, start, zero TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(page_items);
array_init(page_items);
is_smaller_function(compare, zero, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
/**
* Seek to the desired position
*/
is_smaller_or_equal_function(compare, start, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start);
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one);
PHALCON_CPY_WRT(page_number, one);
}
/**
* The record must be iterable
*/
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 1);
while (1) {
PHALCON_INIT_NVAR(r0);
PHALCON_CALL_METHOD(r0, items, "valid");
PHALCON_CPY_WRT(valid, r0);
if (PHALCON_IS_NOT_FALSE(valid)) {
} else {
break;
}
PHALCON_INIT_NVAR(current);
PHALCON_CALL_METHOD(current, items, "current");
phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(compare);
is_smaller_or_equal_function(compare, show, i TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
break;
}
PHALCON_SEPARATE(i);
increment_function(i);
}
}
phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC);
phalcon_update_property_zval(page, SL("first"), one TSRMLS_CC);
PHALCON_INIT_VAR(maximum_pages);
phalcon_add_function(maximum_pages, start, show TSRMLS_CC);
is_smaller_function(compare, maximum_pages, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, one TSRMLS_CC);
} else {
is_equal_function(compare, maximum_pages, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CPY_WRT(next, n);
} else {
div_function(possible_pages, n, show TSRMLS_CC);
PHALCON_INIT_VAR(additional_page);
phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC);
PHALCON_INIT_NVAR(next);
PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page);
}
}
is_smaller_function(compare, total_pages, next TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CPY_WRT(next, total_pages);
}
phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC);
is_smaller_function(compare, one, page_number TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_INIT_VAR(before);
sub_function(before, page_number, one TSRMLS_CC);
} else {
PHALCON_CPY_WRT(before, one);
}
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
PHALCON_INIT_VAR(remainder);
mod_function(remainder, n, show TSRMLS_CC);
div_function(possible_pages, n, show TSRMLS_CC);
if (!PHALCON_IS_LONG(remainder, 0)) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(pages_total);
PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", next);
} else {
PHALCON_CPY_WRT(pages_total, possible_pages);
}
phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC);
RETURN_CTOR(page);
}
/**
* Produces a recursive representation of an array
*
* @param array $argument
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump) {
zval *argument, *n = NULL, *number_arguments, *dump;
zval *v = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL;
zval *class_name = NULL, *joined_dump;
zend_string *str_key;
ulong idx;
PHALCON_MM_GROW();
phalcon_fetch_params(0, 1, 1, &argument, &n);
if (!n) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
PHALCON_INIT_VAR(number_arguments);
phalcon_fast_count(number_arguments, argument);
if (PHALCON_LT_LONG(n, 3)) {
if (PHALCON_GT_LONG(number_arguments, 0)) {
if (PHALCON_LT_LONG(number_arguments, 10)) {
PHALCON_INIT_VAR(dump);
array_init(dump);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(argument), idx, str_key, v) {
zval tmp;
if (str_key) {
ZVAL_STR(&tmp, str_key);
} else {
ZVAL_LONG(&tmp, idx);
}
if (PHALCON_IS_SCALAR(v)) {
if (PHALCON_IS_STRING(v, "")) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => (empty string)");
} else {
PHALCON_CALL_METHOD(&escaped_string, getThis(), "_escapestring", v);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", escaped_string);
}
phalcon_array_append(dump, var_dump, PH_COPY);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, n, &PHALCON_GLOBAL(z_one));
PHALCON_CALL_METHOD(&array_dump, getThis(), "_getarraydump", v, next);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Array(", array_dump, ")");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(v);
PHALCON_INIT_NVAR(class_name);
ZVAL_NEW_STR(class_name, ce->name);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Object(", class_name, ")");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => null");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", v);
phalcon_array_append(dump, var_dump, PH_COPY);
}
}
ZEND_HASH_FOREACH_END();
PHALCON_INIT_VAR(joined_dump);
phalcon_fast_join_str(joined_dump, SL(", "), dump);
RETURN_CTOR(joined_dump);
}
RETURN_NCTOR(number_arguments);
}
/**
* The meta-data is obtained by reading the column descriptions from the database information schema
*
* @param Phalcon\Mvc\ModelInterface $model
* @param Phalcon\DiInterface $dependencyInjector
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getMetaData){
zval *model, *dependency_injector, *class_name;
zval *schema = NULL, *table = NULL, *read_connection = NULL, *exists = NULL;
zval *complete_table = NULL, *exception_message = NULL;
zval *columns = NULL, *attributes, *primary_keys, *non_primary_keys;
zval *numeric_typed, *not_null, *field_types;
zval *field_bind_types, *automatic_default;
zval *identity_field = NULL, *column = NULL, *field_name = NULL, *feature = NULL;
zval *type = NULL, *bind_type = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &model, &dependency_injector);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
PHALCON_CALL_METHOD(&schema, model, "getschema");
PHALCON_CALL_METHOD(&table, model, "getsource");
/**
* Check if the mapped table exists on the database
*/
PHALCON_CALL_METHOD(&read_connection, model, "getreadconnection");
PHALCON_CALL_METHOD(&exists, read_connection, "tableexists", table, schema);
if (!zend_is_true(exists)) {
if (zend_is_true(schema)) {
PHALCON_INIT_VAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
/**
* The table not exists
*/
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Try to describe the table
*/
PHALCON_CALL_METHOD(&columns, read_connection, "describecolumns", table, schema);
if (!phalcon_fast_count_ev(columns TSRMLS_CC)) {
if (zend_is_true(schema)) {
PHALCON_INIT_NVAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
/**
* The table not exists
*/
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Initialize meta-data
*/
PHALCON_INIT_VAR(attributes);
array_init(attributes);
PHALCON_INIT_VAR(primary_keys);
array_init(primary_keys);
PHALCON_INIT_VAR(non_primary_keys);
array_init(non_primary_keys);
PHALCON_INIT_VAR(numeric_typed);
array_init(numeric_typed);
PHALCON_INIT_VAR(not_null);
array_init(not_null);
PHALCON_INIT_VAR(field_types);
array_init(field_types);
PHALCON_INIT_VAR(field_bind_types);
array_init(field_bind_types);
PHALCON_INIT_VAR(automatic_default);
array_init(automatic_default);
PHALCON_INIT_VAR(identity_field);
ZVAL_FALSE(identity_field);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(column);
PHALCON_CALL_METHOD(&field_name, column, "getname");
phalcon_array_append(&attributes, field_name, PH_SEPARATE);
/**
* To mark fields as primary keys
*/
PHALCON_CALL_METHOD(&feature, column, "isprimary");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(&primary_keys, field_name, PH_SEPARATE);
} else {
phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE);
}
/**
* To mark fields as numeric
*/
PHALCON_CALL_METHOD(&feature, column, "isnumeric");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE);
}
/**
* To mark fields as not null
*/
PHALCON_CALL_METHOD(&feature, column, "isnotnull");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(¬_null, field_name, PH_SEPARATE);
}
/**
* To mark fields as identity columns
*/
PHALCON_CALL_METHOD(&feature, column, "isautoincrement");
if (PHALCON_IS_TRUE(feature)) {
PHALCON_CPY_WRT(identity_field, field_name);
}
/**
* To get the internal types
*/
PHALCON_CALL_METHOD(&type, column, "gettype");
phalcon_array_update_zval(&field_types, field_name, type, PH_COPY);
/**
* To mark how the fields must be escaped
*/
PHALCON_CALL_METHOD(&bind_type, column, "getbindtype");
phalcon_array_update_zval(&field_bind_types, field_name, bind_type, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Create an array using the MODELS_* constants as indexes
*/
array_init_size(return_value, 10);
phalcon_array_update_long(&return_value, 0, attributes, PH_COPY);
phalcon_array_update_long(&return_value, 1, primary_keys, PH_COPY);
phalcon_array_update_long(&return_value, 2, non_primary_keys, PH_COPY);
phalcon_array_update_long(&return_value, 3, not_null, PH_COPY);
phalcon_array_update_long(&return_value, 4, field_types, PH_COPY);
phalcon_array_update_long(&return_value, 5, numeric_typed, PH_COPY);
phalcon_array_update_long(&return_value, 8, identity_field, PH_COPY);
phalcon_array_update_long(&return_value, 9, field_bind_types, PH_COPY);
phalcon_array_update_long(&return_value, 10, automatic_default, PH_COPY);
phalcon_array_update_long(&return_value, 11, automatic_default, PH_COPY);
PHALCON_MM_RESTORE();
}
/**
* Builds HTML IMG tags
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, image){
zval *parameters = NULL, *params = NULL, *first_param = NULL, *url = NULL, *src = NULL;
zval *code = NULL, *value = NULL, *key = NULL, *attribute = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("src")+1);
if (!eval_int) {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, params, SL("src"), PH_NOISY_CC);
PHALCON_INIT_VAR(src);
PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", r0, PH_NO_CHECK);
phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<img", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_8:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_8;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_SVSVS(attribute, " ", key, "=\"", value, "\"");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_8;
fee_9b93_8:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "/>", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines){
zval *engines = NULL, *dependency_injector, *registered_engines;
zval *php_engine, *arguments, *engine_service = NULL;
zval *extension = NULL, *engine_object = NULL, *exception_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY TSRMLS_CC);
/**
* If the engines aren't initialized 'engines' is false
*/
if (PHALCON_IS_FALSE(engines)) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(engines);
array_init(engines);
PHALCON_OBS_VAR(registered_engines);
phalcon_read_property_this(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(registered_engines) != IS_ARRAY) {
/**
* We use Phalcon\Mvc\View\Engine\Php as default
*/
PHALCON_INIT_VAR(php_engine);
object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce);
PHALCON_CALL_METHOD(NULL, php_engine, "__construct", this_ptr, dependency_injector);
/**
* Use .phtml as extension for the PHP engine
*/
phalcon_array_update_string(&engines, SL(".phtml"), php_engine, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services");
return;
}
/**
* Arguments for instantiated engines
*/
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 2);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE);
phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE);
phalcon_is_iterable(registered_engines, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(extension, ah0, hp0);
PHALCON_GET_HVALUE(engine_service);
if (Z_TYPE_P(engine_service) == IS_OBJECT) {
/**
* Engine can be a closure
*/
if (instanceof_function(Z_OBJCE_P(engine_service), zend_ce_closure TSRMLS_CC)) {
PHALCON_INIT_NVAR(engine_object);/**/
PHALCON_CALL_USER_FUNC_ARRAY(engine_object, engine_service, arguments);
} else {
PHALCON_CPY_WRT(engine_object, engine_service);
}
} else {
/**
* Engine can be a string representing a service in the DI
*/
if (Z_TYPE_P(engine_service) == IS_STRING) {
PHALCON_CALL_METHOD(&engine_object, dependency_injector, "getshared", engine_service, arguments);
PHALCON_VERIFY_INTERFACE(engine_object, phalcon_mvc_view_engineinterface_ce);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid template engine registration for extension: ", extension);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
phalcon_array_update_zval(&engines, extension, engine_object, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY TSRMLS_CC);
}
RETURN_CCTOR(engines);
}
/**
* Builds a HTML input[type="submit"] tag
*
* @param array $params
* @return string
*/
PHP_METHOD(Phalcon_Tag, submitButton){
zval *parameters = NULL, *params = NULL, *value = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("value")+1);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("value")+1);
} else {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(value);
ZVAL_STRING(value, "", 1);
}
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<input type=\"submit\" value=\"", value, "\" ");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_3;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "=\"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_3;
fee_9b93_3:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " />", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*
* @param string $text
* @param string $key
* @param int $options
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decrypt){
zval *source, *key = NULL, *options = NULL, handler = {}, arguments = {}, value = {}, text = {}, encrypt_key = {}, encrypt_options = {};
zval method = {}, iv_size = {}, iv = {}, text_to_decipher = {};
phalcon_fetch_params(0, 1, 2, &source, &key, &options);
if (phalcon_function_exists_ex(SL("openssl_encrypt")) == FAILURE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_crypt_exception_ce, "openssl extension is required");
return;
}
phalcon_read_property(&handler, getThis(), SL("_beforeDecrypt"), PH_NOISY);
if (phalcon_is_callable(&handler)) {
PHALCON_SEPARATE_PARAM(source);
array_init_size(&arguments, 1);
phalcon_array_append(&arguments, source, PH_COPY);
PHALCON_CALL_USER_FUNC_ARRAYW(&value, &handler, &arguments);
source = &value;
}
/* Do not use make_printable_zval() here: we need the conversion with type juggling */
if (Z_TYPE_P(source) != IS_STRING) {
phalcon_cast(&text, source, IS_STRING);
} else {
PHALCON_CPY_WRT_CTOR(&text, source);
}
if (!key || Z_TYPE_P(key) == IS_NULL) {
phalcon_return_property(&encrypt_key, getThis(), SL("_key"));
} else {
PHALCON_CPY_WRT_CTOR(&encrypt_key, key);
if (Z_TYPE(encrypt_key) != IS_STRING) {
convert_to_string(&encrypt_key);
}
}
if (!options || Z_TYPE_P(options) == IS_NULL) {
phalcon_return_property(&encrypt_options, getThis(), SL("_options"));
} else {
PHALCON_CPY_WRT_CTOR(&encrypt_options, options);
}
phalcon_read_property(&method, getThis(), SL("_method"), PH_NOISY);
PHALCON_CALL_FUNCTIONW(&iv_size, "openssl_cipher_iv_length", &method);
if (Z_LVAL(iv_size) <= 0) {
ZVAL_NULL(&iv);
PHALCON_CPY_WRT_CTOR(&text_to_decipher, &text);
} else {
phalcon_substr(&iv, &text, 0, Z_LVAL(iv_size));
phalcon_substr(&text_to_decipher, &text, Z_LVAL(iv_size), 0);
}
PHALCON_CALL_FUNCTIONW(return_value, "openssl_decrypt", &text_to_decipher, &method, &encrypt_key, &encrypt_options, &iv);
if (unlikely(Z_TYPE_P(return_value) != IS_STRING)) {
convert_to_string(return_value);
}
phalcon_read_property(&handler, getThis(), SL("_afterDecrypt"), PH_NOISY);
if (phalcon_is_callable(&handler)) {
array_init_size(&arguments, 1);
phalcon_array_append(&arguments, return_value, PH_COPY);
PHALCON_CALL_USER_FUNC_ARRAYW(&value, &handler, &arguments);
RETURN_CTORW(&value);
}
}
/**
* Builds a HTML FORM tag
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, form){
zval *parameters = NULL, *params = NULL, *dispatcher = NULL, *dispatch_params = NULL;
zval *action_parameters = NULL, *action = NULL, *controller_name = NULL;
zval *action_name = NULL, *url = NULL, *form_action = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(dispatcher);
PHALCON_CALL_SELF(dispatcher, this_ptr, "getdispatcherservice");
PHALCON_INIT_VAR(dispatch_params);
PHALCON_CALL_METHOD(dispatch_params, dispatcher, "getparams", PH_NO_CHECK);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_INIT_VAR(action_parameters);
phalcon_fast_join(action_parameters, c0, dispatch_params TSRMLS_CC);
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
eval_int = phalcon_array_isset_string(params, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(controller_name);
PHALCON_CALL_METHOD(controller_name, dispatcher, "getcontrollername", PH_NO_CHECK);
PHALCON_INIT_VAR(action_name);
PHALCON_CALL_METHOD(action_name, dispatcher, "getactionname", PH_NO_CHECK);
PHALCON_INIT_VAR(action);
PHALCON_CONCAT_VSV(action, controller_name, "/", action_name);
}
} else {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC);
}
eval_int = phalcon_array_isset_string(params, SL("method")+1);
if (!eval_int) {
phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
if (zend_is_true(action_parameters)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, url, "get", action, PH_NO_CHECK);
PHALCON_CPY_WRT(action, r0);
} else {
PHALCON_INIT_VAR(form_action);
PHALCON_CONCAT_VSV(form_action, action, "/", action_parameters);
PHALCON_INIT_VAR(action);
PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", form_action, PH_NO_CHECK);
}
eval_int = phalcon_array_isset_string(params, SL("parameters")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, params, SL("parameters"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SV(r2, "?", r1);
phalcon_concat_self(&action, r2 TSRMLS_CC);
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<form action=\"", action, "\" ");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_5:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_5;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "= \"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_5;
fee_9b93_5:
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_VS(r3, code, ">");
RETURN_CTOR(r3);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){
zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *column_type = NULL;
zval *status = NULL, *matches = NULL, *pattern = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL, *dialect = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *status2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_ALLOC_ZVAL_MM(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
ZVAL_NULL(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(field);
PHALCON_INIT_VAR(definition);
array_init(definition);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_INIT_VAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 0);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 1);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("varchar") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
PHALCON_INIT_VAR(status2);
phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC);
phalcon_fast_strpos_str(status2, column_type, SL("decimal") TSRMLS_CC);
if ( (PHALCON_IS_NOT_FALSE(status)) || (PHALCON_IS_NOT_FALSE(status2)) ) {
add_assoc_long_ex(definition, SS("type"), 3);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 5);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 4);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 6);
phalcon_array_update_string_long(&definition, SL("size"), 2147483647, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 7);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 64); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
add_assoc_long_ex(definition, SS("type"), 5);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("(") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
PHALCON_INIT_VAR(matches);
array_init(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_FUNC_PARAMS_3(r0, "preg_match", pattern, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(r0)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_long(&r1, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &r1, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}else {
phalcon_array_update_string_bool(&definition, SL("primary"), 0, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(r0);
phalcon_fast_strpos_str(r0, column_type, SL("integer") TSRMLS_CC);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, definition, SL("primary"), PH_NOISY_CC);
if ((PHALCON_IS_NOT_FALSE(r0)) && (PHALCON_IS_NOT_FALSE(r1))) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC);
PHALCON_INIT_VAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);}
