/**
* Sets the path for a domain
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDirectory) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL;
HashTable *_1;
HashPosition _0;
zval *directory, *key = NULL, *value = NULL, **_2, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &directory);
zephir_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC);
if (Z_TYPE_P(directory) == IS_ARRAY) {
if (zephir_fast_count_int(directory TSRMLS_CC)) {
zephir_is_iterable(directory, &_1, &_0, 0, 0, "phalcon/translate/adapter/gettext.zep", 180);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(key, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, key, value);
zephir_check_call_status();
}
}
} else {
ZEPHIR_CALL_METHOD(&_4, this_ptr, "getdefaultdomain", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 423, _4, directory);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Flow, testFor2) {
HashTable *_2;
HashPosition _1;
double c;
zval *v = NULL, *k = NULL, *b, *_0 = NULL, **_3;
ZEPHIR_MM_GROW();
c = (double) (0);
ZEPHIR_INIT_VAR(b);
zephir_create_array(b, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 4);
zephir_array_fast_append(b, _0);
zephir_is_iterable(b, &_2, &_1, 0, 0, "test/flow.zep", 453);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(k, _2, _1);
ZEPHIR_GET_HVALUE(v, _3);
c += zephir_get_numberval(k);
}
RETURN_MM_DOUBLE(c);
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *_18;
HashTable *_7;
HashPosition _6;
zend_bool param, _11, _14;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta, *body = NULL, *backtrace = NULL, *encoded, *len, *lastTrace = NULL, *_0 = NULL, *_1 = NULL, *_2, *backtraceItem = NULL, *key = NULL, _3, _4, *_5, **_8, *_9, *_10, *_12, *_13, *_15, *_16, *_17;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_0, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
zephir_get_strval(message, _0);
}
ZEPHIR_INIT_VAR(meta);
zephir_create_array(meta, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, type);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettypestring", NULL, 0, _1);
zephir_check_call_status();
zephir_array_update_string(&meta, SL("Type"), &_0, PH_COPY | PH_SEPARATE);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_2)) {
param = 0;
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_GET_CONSTANT(_1, "PHP_VERSION");
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "5.3.6", 0);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "<", 0);
ZEPHIR_CALL_FUNCTION(&_0, "version_compare", NULL, 248, _1, &_3, &_4);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
param = (2) ? 1 : 0;
}
ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 150, (param ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
Z_SET_ISREF_P(backtrace);
ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 170, backtrace);
Z_UNSET_ISREF_P(backtrace);
zephir_check_call_status();
if (zephir_array_isset_string(lastTrace, SS("file"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 133 TSRMLS_CC);
zephir_array_update_string(&meta, SL("File"), &_5, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string(lastTrace, SS("line"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 137 TSRMLS_CC);
zephir_array_update_string(&meta, SL("Line"), &_5, PH_COPY | PH_SEPARATE);
}
zephir_is_iterable(backtrace, &_7, &_6, 1, 0, "phalcon/logger/formatter/firephp.zep", 146);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(key, _7, _6);
ZEPHIR_GET_HVALUE(backtraceItem, _8);
zephir_array_unset_string(&backtraceItem, SS("object"), PH_SEPARATE);
zephir_array_unset_string(&backtraceItem, SS("args"), PH_SEPARATE);
zephir_array_update_zval(&backtrace, key, &backtraceItem, PH_COPY | PH_SEPARATE);
}
}
_9 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (zephir_is_true(_9)) {
zephir_array_update_string(&meta, SL("Label"), &message, PH_COPY | PH_SEPARATE);
}
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_11 = !zephir_is_true(_10);
if (_11) {
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_11 = !zephir_is_true(_12);
}
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_14 = zephir_is_true(_13);
if (_14) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_14 = !zephir_is_true(_15);
}
if (_11) {
ZEPHIR_CPY_WRT(body, message);
} else if (_14) {
ZEPHIR_INIT_NVAR(body);
ZVAL_STRING(body, "", 1);
} else {
ZEPHIR_INIT_NVAR(body);
array_init(body);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_16)) {
zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE);
}
_17 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (!(zephir_is_true(_17))) {
zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_INIT_VAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, meta);
zephir_array_fast_append(_18, body);
ZEPHIR_INIT_VAR(encoded);
zephir_json_encode(encoded, &(encoded), _18, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(len);
ZVAL_LONG(len, zephir_fast_strlen_ev(encoded));
ZEPHIR_CONCAT_VSVS(return_value, len, "|", encoded, "|");
RETURN_MM();
}
/**
* Unregisters one or all listeners for an event.
*
* @param string|\Xpl\Event\Event event Event ID or object.
* @param callable callback [Optional] Callback to remove. If no callback is given,
* then all of the event's listeners are removed.
* @return \Xpl\Event\Manager
*
* @throws \InvalidArgumentException if event is not a string or Event instance.
*/
PHP_METHOD(Xpl_Event_Manager, off) {
HashTable *_6$$8;
HashPosition _5$$8;
int ZEPHIR_LAST_CALL_STATUS;
zval *event, *callback = NULL, *id = NULL, *listeners = NULL, *_4, *_0$$4, *_1$$5, *_2$$5, *_3$$5, *i$$8 = NULL, *listener$$8 = NULL, **_7$$8, *_8$$9 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &event, &callback);
if (!callback) {
callback = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(event) == IS_STRING) {
ZEPHIR_CPY_WRT(id, event);
} else if (zephir_instance_of_ev(event, xpl_event_event_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_0$$4);
zephir_read_property(&_0$$4, event, SL("id"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(id, _0$$4);
} else {
ZEPHIR_INIT_VAR(_1$$5);
object_init_ex(_1$$5, spl_ce_InvalidArgumentException);
ZEPHIR_INIT_VAR(_2$$5);
zephir_gettype(_2$$5, event TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$5);
ZEPHIR_CONCAT_SV(_3$$5, "Event must be string or instance of Event, given: ", _2$$5);
ZEPHIR_CALL_METHOD(NULL, _1$$5, "__construct", NULL, 5, _3$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$5, "xpl/event/manager.zep", 118 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(listeners);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("listeners"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&listeners, _4, id, 0 TSRMLS_CC)) {
if (Z_TYPE_P(callback) == IS_NULL) {
zephir_array_unset(&listeners, id, PH_SEPARATE);
} else {
zephir_is_iterable(listeners, &_6$$8, &_5$$8, 1, 0, "xpl/event/manager.zep", 137);
for (
; zephir_hash_get_current_data_ex(_6$$8, (void**) &_7$$8, &_5$$8) == SUCCESS
; zephir_hash_move_forward_ex(_6$$8, &_5$$8)
) {
ZEPHIR_GET_HMKEY(i$$8, _6$$8, _5$$8);
ZEPHIR_GET_HVALUE(listener$$8, _7$$8);
ZEPHIR_OBS_NVAR(_8$$9);
zephir_read_property(&_8$$9, listener$$8, SL("callback"), PH_NOISY_CC);
if (ZEPHIR_IS_EQUAL(callback, _8$$9)) {
zephir_array_unset(&listeners, i$$8, PH_SEPARATE);
}
}
zend_hash_destroy(_6$$8);
FREE_HASHTABLE(_6$$8);
}
zephir_update_property_array(this_ptr, SL("listeners"), id, listeners TSRMLS_CC);
}
RETURN_THIS();
}
/**
* 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_Mysql, describeColumns) {
zephir_fcall_cache_entry *_17 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_10 = NULL;
HashTable *_5;
HashPosition _4;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns, *columnType = NULL, *field = NULL, *definition = NULL, *oldColumn = NULL, *sizePattern, *matches = NULL, *matchOne = NULL, *matchTwo = NULL, *columnName, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7 = NULL, *_8 = NULL, *_9 = NULL, *_11 = NULL, *_12, *_13, *_14, *_15 = NULL, *_16;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
zephir_get_strval(table, table_param);
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
ZEPHIR_INIT_VAR(sizePattern);
ZVAL_STRING(sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#", 1);
ZEPHIR_INIT_VAR(columns);
array_init(columns);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 271);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 1, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 115 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("enum"), "phalcon/db/adapter/pdo/mysql.zep", 122)) {
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 5);
zephir_array_update_string(&definition, SL("type"), &_3, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("int"), "phalcon/db/adapter/pdo/mysql.zep", 130)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 0);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("varchar"), "phalcon/db/adapter/pdo/mysql.zep", 140)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("datetime"), "phalcon/db/adapter/pdo/mysql.zep", 148)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 4);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("decimal"), "phalcon/db/adapter/pdo/mysql.zep", 156)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 3);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 32);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("char"), "phalcon/db/adapter/pdo/mysql.zep", 166)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("date"), "phalcon/db/adapter/pdo/mysql.zep", 174)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 1);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("text"), "phalcon/db/adapter/pdo/mysql.zep", 182)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("float"), "phalcon/db/adapter/pdo/mysql.zep", 190)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 7);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 3);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("("), "phalcon/db/adapter/pdo/mysql.zep", 207)) {
ZEPHIR_INIT_NVAR(matches);
ZVAL_NULL(matches);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&_9, "preg_match", &_10, sizePattern, columnType, matches);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
if (zephir_is_true(_9)) {
ZEPHIR_OBS_NVAR(matchOne);
if (zephir_array_isset_long_fetch(&matchOne, matches, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, zephir_get_intval(matchOne));
zephir_array_update_string(&definition, SL("size"), &_8, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(matchTwo);
if (zephir_array_isset_long_fetch(&matchTwo, matches, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_LONG(_11, zephir_get_intval(matchTwo));
zephir_array_update_string(&definition, SL("scale"), &_11, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_memnstr_str(columnType, SL("unsigned"), "phalcon/db/adapter/pdo/mysql.zep", 222)) {
zephir_array_update_string(&definition, SL("unsigned"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_12, field, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 238 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_12, "PRI")) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_13, field, 2, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 245 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_13, "NO")) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_14, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 252 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_14, "auto_increment")) {
zephir_array_update_string(&definition, SL("autoIncrement"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_long(&_15, field, 4, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 259 TSRMLS_CC);
if (Z_TYPE_P(_15) != IS_NULL) {
zephir_array_fetch_long(&_16, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 260 TSRMLS_CC);
zephir_array_update_string(&definition, SL("default"), &_16, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 0, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 266 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_7);
object_init_ex(_7, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", &_17, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _7, PH_SEPARATE, "phalcon/db/adapter/pdo/mysql.zep", 267);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}
PHP_METHOD(Yb_Std, groupIndexedValues) {
HashTable *_1;
HashPosition _0;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *groupKey = NULL, *indexKey = NULL, *valueKey = NULL;
zval *data_param = NULL, *groupKey_param = NULL, *indexKey_param = NULL, *valueKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *groupValue = NULL, *indexValue = NULL, *valueValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL, *_8$$6 = NULL, *_9$$6 = NULL, *_10$$7 = NULL, *_11$$7 = NULL;
zval *data = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &data_param, &groupKey_param, &indexKey_param, &valueKey_param);
zephir_get_arrval(data, data_param);
zephir_get_strval(groupKey, groupKey_param);
zephir_get_strval(indexKey, indexKey_param);
zephir_get_strval(valueKey, valueKey_param);
ZEPHIR_INIT_VAR(arr);
array_init(arr);
zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 359);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(k, _1, _0);
ZEPHIR_GET_HVALUE(v, _2);
if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) {
ZEPHIR_INIT_NVAR(_3$$4);
object_init_ex(_3$$4, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_4$$4);
ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k);
ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$4, "yb/std.zep", 344 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(groupValue);
if (unlikely(!(zephir_array_isset_fetch(&groupValue, v, groupKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_6$$5);
object_init_ex(_6$$5, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of group at: ", k);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/std.zep", 347 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(indexValue);
if (unlikely(!(zephir_array_isset_fetch(&indexValue, v, indexKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_8$$6);
object_init_ex(_8$$6, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_9$$6);
ZEPHIR_CONCAT_SV(_9$$6, "Cannot find value of index at: ", k);
ZEPHIR_CALL_METHOD(NULL, _8$$6, "__construct", &_5, 2, _9$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_8$$6, "yb/std.zep", 350 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(valueValue);
if (unlikely(!(zephir_array_isset_fetch(&valueValue, v, valueKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_10$$7);
object_init_ex(_10$$7, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_11$$7);
ZEPHIR_CONCAT_SV(_11$$7, "Cannot find value of value at: ", k);
ZEPHIR_CALL_METHOD(NULL, _10$$7, "__construct", &_5, 2, _11$$7);
zephir_check_call_status();
zephir_throw_exception_debug(_10$$7, "yb/std.zep", 353 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_array_update_multi(&arr, &valueValue TSRMLS_CC, SL("zz"), 2, groupValue, indexValue);
}
RETURN_CCTOR(arr);
}
/**
* Handles routing information received from the rewrite engine
*
*<code>
* //Read the info from the rewrite engine
* $router->handle();
*
* //Manually passing an URL
* $router->handle('/posts/edit/1');
*</code>
*
* @param string uri
*/
PHP_METHOD(Test_Router, handle) {
zephir_nts_static zephir_fcall_cache_entry *_12 = NULL;
HashTable *_2, *_9;
HashPosition _1, _8;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri = NULL, *realUri = NULL, *request = NULL, *currentHostName = NULL, *routeFound = NULL, *parts = NULL, *params, *matches, *notFoundPaths, *vnamespace, *module, *controller, *action, *paramsStr, *strParams = NULL, *paramsMerge = NULL, *route = NULL, *methods = NULL, *dependencyInjector = NULL, *hostname = NULL, *regexHostName = NULL, *matched = NULL, *pattern = NULL, *handledUri = NULL, *beforeMatch = NULL, *paths = NULL, *converters = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *_0, **_3, *_4, *_5 = NULL, *_6 = NULL, *_7 = NULL, **_10, _11, *_13, *_14, *_15, *_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_is_true(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_removeExtraSlashes"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_METHOD(&handledUri, this_ptr, "doremoveextraslashes", NULL, realUri);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(handledUri, realUri);
}
ZEPHIR_INIT_VAR(request);
ZVAL_NULL(request);
ZEPHIR_INIT_VAR(currentHostName);
ZVAL_NULL(currentHostName);
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 1);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_backwards_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&methods, route, "gethttpmethods", NULL);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&_6, request, "ismethod", NULL, methods);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE(_6)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&hostname, route, "gethostname", NULL);
zephir_check_call_status();
if (Z_TYPE_P(hostname) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(¤tHostName, request, "gethttphost", NULL);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_NULL) {
continue;
}
ZEPHIR_INIT_NVAR(matched);
if (zephir_memnstr_str(hostname, SL("("), "test/router.zep", 381)) {
if (zephir_memnstr_str(hostname, SL("#"), "test/router.zep", 382)) {
ZEPHIR_INIT_NVAR(regexHostName);
ZEPHIR_CONCAT_SVS(regexHostName, "#^", hostname, "$#");
} else {
ZEPHIR_CPY_WRT(regexHostName, hostname);
}
ZEPHIR_INIT_NVAR(_7);
zephir_preg_match(matched, &(matched), regexHostName, currentHostName, _7, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(matched, ZEPHIR_IS_EQUAL(currentHostName, hostname));
}
if (!(zephir_is_true(matched))) {
continue;
}
}
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(routeFound);
if (zephir_memnstr_str(pattern, SL("^"), "test/router.zep", 400)) {
zephir_preg_match(routeFound, &(routeFound), pattern, handledUri, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, handledUri));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (zephir_is_callable(beforeMatch TSRMLS_CC)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "Before-Match callback is not callable in matched route");
return;
}
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL);
zephir_check_call_status();
zephir_is_iterable(paths, &_9, &_8, 0, 0);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(part, _9, _8);
ZEPHIR_GET_HVALUE(position, _10);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
if (!(zephir_is_true(routeFound))) {
ZEPHIR_OBS_VAR(notFoundPaths);
zephir_read_property_this(¬FoundPaths, this_ptr, SL("_notFoundPaths"), PH_NOISY_CC);
if (Z_TYPE_P(notFoundPaths) != IS_NULL) {
ZEPHIR_CPY_WRT(parts, notFoundPaths);
ZEPHIR_INIT_BNVAR(routeFound);
ZVAL_BOOL(routeFound, 1);
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_VAR(vnamespace);
if (zephir_array_isset_string_fetch(&vnamespace, parts, SS("namespace"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(vnamespace))) {
zephir_update_property_this(this_ptr, SL("_namespace"), vnamespace TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("namespace"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(module);
if (zephir_array_isset_string_fetch(&module, parts, SS("module"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(module))) {
zephir_update_property_this(this_ptr, SL("_module"), module TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(controller);
if (zephir_array_isset_string_fetch(&controller, parts, SS("controller"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(controller))) {
zephir_update_property_this(this_ptr, SL("_controller"), controller TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("controller"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(action);
if (zephir_array_isset_string_fetch(&action, parts, SS("action"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(action))) {
zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(paramsStr);
if (zephir_array_isset_string_fetch(¶msStr, parts, SS("params"), 0 TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 1);
ZEPHIR_CALL_FUNCTION(&strParams, "substr", &_12, paramsStr, &_11);
zephir_check_call_status();
if (zephir_is_true(strParams)) {
ZEPHIR_INIT_BNVAR(params);
zephir_fast_explode_str(params, SL("/"), strParams, LONG_MAX TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_VAR(paramsMerge);
zephir_fast_array_merge(paramsMerge, &(params), &(parts) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(paramsMerge, parts);
}
zephir_update_property_this(this_ptr, SL("_params"), paramsMerge TSRMLS_CC);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _14 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _15 TSRMLS_CC);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _16 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) {
zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL;
HashTable *_2, *_5;
HashPosition _1, _4;
int dirtyState, ZEPHIR_LAST_CALL_STATUS;
zval *row, *hydrateMode, *alias = NULL, *activeRow = NULL, *type = NULL, *columnTypes, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *_0, **_3, **_6, *_7 = NULL, *_9, *_10 = NULL, _12 = zval_used_for_init, _13 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
RETURN_CCTOR(row);
}
if (Z_TYPE_P(row) != IS_ARRAY) {
zephir_update_property_this(this_ptr, SL("_activeRow"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_INIT_NVAR(activeRow);
object_init_ex(activeRow, phalcon_mvc_model_row_ce);
if (zephir_has_constructor(activeRow TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0);
zephir_check_call_status();
}
break;
}
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
ZEPHIR_INIT_NVAR(activeRow);
array_init(activeRow);
break;
}
ZEPHIR_INIT_NVAR(activeRow);
object_init(activeRow);
break;
} while(0);
ZEPHIR_OBS_VAR(columnTypes);
zephir_read_property_this(&columnTypes, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
dirtyState = 0;
zephir_is_iterable(columnTypes, &_2, &_1, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 235);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(alias, _2, _1);
ZEPHIR_GET_HVALUE(column, _3);
if (Z_TYPE_P(column) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 136);
return;
}
ZEPHIR_OBS_NVAR(type);
zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 139 TSRMLS_CC);
if (ZEPHIR_IS_STRING(type, "object")) {
ZEPHIR_OBS_NVAR(source);
zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 145 TSRMLS_CC);
ZEPHIR_OBS_NVAR(attributes);
zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 146 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnMap);
zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 147 TSRMLS_CC);
ZEPHIR_INIT_NVAR(rowModel);
array_init(rowModel);
zephir_is_iterable(attributes, &_5, &_4, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 165);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(attribute, _6);
ZEPHIR_OBS_NVAR(columnValue);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "_", source, "_", attribute);
zephir_array_fetch(&columnValue, row, _7, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 158 TSRMLS_CC);
zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE);
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_OBS_NVAR(keepSnapshots);
if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(keepSnapshots);
ZVAL_BOOL(keepSnapshots, 0);
}
zephir_array_fetch_string(&_9, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_10);
ZVAL_LONG(_10, dirtyState);
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_8, 0, _9, rowModel, columnMap, _10, keepSnapshots);
zephir_check_call_status();
break;
}
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_11, 0, rowModel, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 194 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(sqlAlias);
if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(value);
zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC);
}
if (zephir_array_isset_string(column, SS("balias"))) {
ZEPHIR_CPY_WRT(attribute, alias);
} else {
ZEPHIR_SINIT_NVAR(_12);
ZVAL_STRING(&_12, "_", 0);
ZEPHIR_SINIT_NVAR(_13);
ZVAL_STRING(&_13, "", 0);
ZEPHIR_INIT_NVAR(attribute);
zephir_fast_str_replace(&attribute, &_12, &_13, alias TSRMLS_CC);
}
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE);
break;
}
zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC);
break;
} while(0);
}
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
PHP_METHOD(Test_FortyTwo, proof) {
zend_bool _5;
HashTable *_3;
HashPosition _2;
zval *_0;
int i, j, _6, _7;
zval *box, *side = NULL, *_1, **_4, *_8;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(box);
array_init_size(box, 19);
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, 10);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 24);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 8);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 8);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 15);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 19);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 19);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 17);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 6);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 6);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 16);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 20);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 20);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 13);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 9);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 9);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 11);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 22);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 22);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 2);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 18);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 18);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 4);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 20);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 5);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 21);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 16);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 16);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 3);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 23);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 23);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 7);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 12);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 12);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 25);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 5);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 24);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 7);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 11);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 11);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 27);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 4);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
ZEPHIR_INIT_BNVAR(_0);
array_init_size(_0, 5);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 11);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 27);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 4);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(box, _0);
zephir_is_iterable(box, &_3, &_2, 0, 0);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(side, _4);
j = 0;
_7 = 2;
_6 = 0;
_5 = 0;
if ((_6 <= _7)) {
while (1) {
if (_5) {
_6++;
if (!((_6 <= _7))) {
break;
}
} else {
_5 = 1;
}
i = _6;
zephir_array_fetch_long(&_8, side, i, PH_NOISY | PH_READONLY TSRMLS_CC);
j += zephir_get_numberval(_8);
}
}
if ((j != 42)) {
ZEPHIR_THROW_EXCEPTION_STR(test_exception_ce, "not true");
return;
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) {
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool notExists, mustClean, _7, _9;
zval *path_param = NULL, *params, *eventsManager, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath, *_0 = NULL, *_1 = NULL, *_2, **_5, *_6 = NULL, _8 = zval_used_for_init, *_10 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
RETURN_MM_NULL();
}
}
notExists = 1;
mustClean = 1;
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(viewsDirPath);
ZEPHIR_CONCAT_VV(viewsDirPath, _2, path);
ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 261);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_VV(_6, viewsDirPath, extension);
if ((zephir_file_exists(_6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7 = zephir_is_true(extension);
if (_7) {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_LONG(&_8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, viewsDirPath, zephir_get_intval(&_8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7 = ZEPHIR_IS_EQUAL(_1, extension);
}
_9 = _7;
if (_9) {
_9 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_9) {
ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath);
} else {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZVAL_STRING(viewEnginePath, "", 1);
}
}
if (zephir_is_true(viewEnginePath)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", &_11, 0, _10, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
continue;
}
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, (mustClean ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_12, 0, _10, this_ptr);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/mvc/view/simple.zep", 262 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* 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) {
zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL;
HashTable *_2;
HashPosition _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *engines = NULL, *dependencyInjector, *registeredEngines, *arguments, *extension = NULL, *engineService = NULL, *engineObject = NULL, *_0 = NULL, **_3, *_5 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(engines)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(engines);
array_init(engines);
ZEPHIR_OBS_VAR(registeredEngines);
zephir_read_property_this(®isteredEngines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registeredEngines) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_mvc_view_engine_php_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 370, this_ptr, dependencyInjector);
zephir_check_call_status();
zephir_array_update_string(&engines, SL(".phtml"), &_0, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services", "phalcon/mvc/view/simple.zep", 139);
return;
}
ZEPHIR_INIT_VAR(arguments);
zephir_create_array(arguments, 2, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, this_ptr);
zephir_array_fast_append(arguments, dependencyInjector);
zephir_is_iterable(registeredEngines, &_2, &_1, 0, 0, "phalcon/mvc/view/simple.zep", 171);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(extension, _2, _1);
ZEPHIR_GET_HVALUE(engineService, _3);
if (Z_TYPE_P(engineService) == IS_OBJECT) {
if (zephir_instance_of_ev(engineService, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(engineObject);
ZEPHIR_CALL_USER_FUNC_ARRAY(engineObject, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(engineObject, engineService);
}
} else {
if (Z_TYPE_P(engineService) == IS_STRING) {
ZEPHIR_CALL_METHOD(&engineObject, dependencyInjector, "getshared", &_4, 0, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SV(_5, "Invalid template engine registration for extension: ", extension);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_6, 9, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/mvc/view/simple.zep", 165 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_array_update_zval(&engines, extension, &engineObject, PH_COPY | PH_SEPARATE);
}
}
zephir_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts"));
* </code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns) {
zephir_fcall_cache_entry *_16 = NULL, *_20 = NULL, *_21 = NULL;
zend_bool _9;
HashTable *_5;
HashPosition _4;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns, *columnType = NULL, *field = NULL, *definition = NULL, *oldColumn = NULL, *sizePattern, *matches = NULL, *matchOne = NULL, *matchTwo = NULL, *columnName, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7 = NULL, *_8 = NULL, *_10, *_11 = NULL, *_12, *_13, _14 = zval_used_for_init, *_15 = NULL, *_17, *_18, *_19 = NULL;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
zephir_get_strval(table, table_param);
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
ZEPHIR_INIT_VAR(sizePattern);
ZVAL_STRING(sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#", 1);
ZEPHIR_INIT_VAR(columns);
array_init(columns);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 291);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 2, PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 108 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("tinyint(1)"), "phalcon/db/adapter/pdo/sqlite.zep", 115)) {
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 8);
zephir_array_update_string(&definition, SL("type"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("bindType"), &_7, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(columnType);
ZVAL_STRING(columnType, "boolean", 1);
break;
}
if (zephir_memnstr_str(columnType, SL("bigint"), "phalcon/db/adapter/pdo/sqlite.zep", 125)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 14);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
_9 = zephir_memnstr_str(columnType, SL("int"), "phalcon/db/adapter/pdo/sqlite.zep", 135);
if (!(_9)) {
_9 = zephir_memnstr_str(columnType, SL("INT"), "phalcon/db/adapter/pdo/sqlite.zep", 135);
}
if (_9) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 0);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
zephir_array_fetch_long(&_10, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 141 TSRMLS_CC);
if (zephir_is_true(_10)) {
zephir_array_update_string(&definition, SL("autoIncrement"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
break;
}
if (zephir_memnstr_str(columnType, SL("varchar"), "phalcon/db/adapter/pdo/sqlite.zep", 150)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("date"), "phalcon/db/adapter/pdo/sqlite.zep", 158)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 1);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("timestamp"), "phalcon/db/adapter/pdo/sqlite.zep", 166)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 1);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("decimal"), "phalcon/db/adapter/pdo/sqlite.zep", 174)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 3);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 32);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("char"), "phalcon/db/adapter/pdo/sqlite.zep", 184)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("datetime"), "phalcon/db/adapter/pdo/sqlite.zep", 192)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 4);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("text"), "phalcon/db/adapter/pdo/sqlite.zep", 200)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("float"), "phalcon/db/adapter/pdo/sqlite.zep", 208)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 7);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 3);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("enum"), "phalcon/db/adapter/pdo/sqlite.zep", 218)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("("), "phalcon/db/adapter/pdo/sqlite.zep", 233)) {
ZEPHIR_INIT_NVAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_NVAR(_8);
zephir_preg_match(_8, sizePattern, columnType, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_8)) {
ZEPHIR_OBS_NVAR(matchOne);
if (zephir_array_isset_long_fetch(&matchOne, matches, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_LONG(_11, zephir_get_intval(matchOne));
zephir_array_update_string(&definition, SL("size"), &_11, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(matchTwo);
if (zephir_array_isset_long_fetch(&matchTwo, matches, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_LONG(_11, zephir_get_intval(matchTwo));
zephir_array_update_string(&definition, SL("scale"), &_11, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_memnstr_str(columnType, SL("unsigned"), "phalcon/db/adapter/pdo/sqlite.zep", 248)) {
zephir_array_update_string(&definition, SL("unsigned"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_10, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 264 TSRMLS_CC);
if (zephir_is_true(_10)) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_12, field, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 271 TSRMLS_CC);
if (zephir_is_true(_12)) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_13, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 279 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_14);
ZVAL_STRING(&_14, "null", 0);
ZEPHIR_CALL_FUNCTION(&_15, "strcasecmp", &_16, 19, _13, &_14);
zephir_check_call_status();
_9 = !ZEPHIR_IS_LONG(_15, 0);
if (_9) {
zephir_array_fetch_long(&_17, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 279 TSRMLS_CC);
_9 = !ZEPHIR_IS_STRING(_17, "");
}
if (_9) {
zephir_array_fetch_long(&_18, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 280 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "/^'|'$/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_8);
ZVAL_STRING(_8, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_19, "preg_replace", &_20, 29, _7, _8, _18);
zephir_check_temp_parameter(_7);
zephir_check_temp_parameter(_8);
zephir_check_call_status();
zephir_array_update_string(&definition, SL("default"), &_19, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 1, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 286 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_7);
object_init_ex(_7, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", &_21, 140, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _7, PH_SEPARATE, "phalcon/db/adapter/pdo/sqlite.zep", 287);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}
/**
* Lists table references
*
* @param string table
* @param string schema
* @return Phalcon\Db\ReferenceInterface[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences) {
zephir_fcall_cache_entry *_16 = NULL;
zval *_11 = NULL;
HashTable *_5, *_13;
HashPosition _4, _12;
int ZEPHIR_LAST_CALL_STATUS;
zval *table, *schema = NULL, *references, *reference = NULL, *arrayReference = NULL, *constraintName = NULL, *referenceObjects, *name = NULL, *referencedSchema = NULL, *referencedTable = NULL, *columns = NULL, *referencedColumns = NULL, *number = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7, *_8, *_9, *_10, **_14, *_15 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(references);
array_init(references);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describereferences", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 373);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(number, _5, _4);
ZEPHIR_GET_HVALUE(reference, _6);
ZEPHIR_INIT_NVAR(constraintName);
ZEPHIR_CONCAT_SV(constraintName, "foreign_key_", number);
if (!(zephir_array_isset(references, constraintName))) {
ZEPHIR_INIT_NVAR(referencedSchema);
ZVAL_NULL(referencedSchema);
ZEPHIR_OBS_NVAR(referencedTable);
zephir_array_fetch_long(&referencedTable, reference, 2, PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 352 TSRMLS_CC);
ZEPHIR_INIT_NVAR(columns);
array_init(columns);
ZEPHIR_INIT_NVAR(referencedColumns);
array_init(referencedColumns);
} else {
zephir_array_fetch(&_7, references, constraintName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 356 TSRMLS_CC);
ZEPHIR_OBS_NVAR(referencedSchema);
zephir_array_fetch_string(&referencedSchema, _7, SL("referencedSchema"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 356 TSRMLS_CC);
zephir_array_fetch(&_8, references, constraintName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 357 TSRMLS_CC);
ZEPHIR_OBS_NVAR(referencedTable);
zephir_array_fetch_string(&referencedTable, _8, SL("referencedTable"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 357 TSRMLS_CC);
zephir_array_fetch(&_9, references, constraintName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 358 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch_string(&columns, _9, SL("columns"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 358 TSRMLS_CC);
zephir_array_fetch(&_10, references, constraintName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 359 TSRMLS_CC);
ZEPHIR_OBS_NVAR(referencedColumns);
zephir_array_fetch_string(&referencedColumns, _10, SL("referencedColumns"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 359 TSRMLS_CC);
}
zephir_array_fetch_long(&_7, reference, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 362 TSRMLS_CC);
zephir_array_append(&columns, _7, PH_SEPARATE, "phalcon/db/adapter/pdo/sqlite.zep", 362);
zephir_array_fetch_long(&_8, reference, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 363 TSRMLS_CC);
zephir_array_append(&referencedColumns, _8, PH_SEPARATE, "phalcon/db/adapter/pdo/sqlite.zep", 363);
ZEPHIR_INIT_NVAR(_11);
zephir_create_array(_11, 4, 0 TSRMLS_CC);
zephir_array_update_string(&_11, SL("referencedSchema"), &referencedSchema, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_11, SL("referencedTable"), &referencedTable, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_11, SL("columns"), &columns, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_11, SL("referencedColumns"), &referencedColumns, PH_COPY | PH_SEPARATE);
zephir_array_update_zval(&references, constraintName, &_11, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_VAR(referenceObjects);
array_init(referenceObjects);
zephir_is_iterable(references, &_13, &_12, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 383);
for (
; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS
; zephir_hash_move_forward_ex(_13, &_12)
) {
ZEPHIR_GET_HMKEY(name, _13, _12);
ZEPHIR_GET_HVALUE(arrayReference, _14);
ZEPHIR_INIT_NVAR(_3);
object_init_ex(_3, phalcon_db_reference_ce);
ZEPHIR_INIT_NVAR(_11);
zephir_create_array(_11, 4, 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_string(&_15, arrayReference, SL("referencedSchema"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 376 TSRMLS_CC);
zephir_array_update_string(&_11, SL("referencedSchema"), &_15, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_string(&_15, arrayReference, SL("referencedTable"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 377 TSRMLS_CC);
zephir_array_update_string(&_11, SL("referencedTable"), &_15, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_string(&_15, arrayReference, SL("columns"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 378 TSRMLS_CC);
zephir_array_update_string(&_11, SL("columns"), &_15, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_string(&_15, arrayReference, SL("referencedColumns"), PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 380 TSRMLS_CC);
zephir_array_update_string(&_11, SL("referencedColumns"), &_15, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", &_16, 16, name, _11);
zephir_check_call_status();
zephir_array_update_zval(&referenceObjects, name, &_3, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(referenceObjects);
}
/**
* Lists table indexes
*
* @param string table
* @param string schema
* @return Phalcon\Db\IndexInterface[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) {
zephir_fcall_cache_entry *_17 = NULL;
HashTable *_5, *_11, *_15;
HashPosition _4, _10, _14;
int ZEPHIR_LAST_CALL_STATUS;
zval *table, *schema = NULL, *indexes, *index = NULL, *keyName = NULL, *indexObjects, *name = NULL, *indexColumns = NULL, *columns = NULL, *describe_index = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7 = NULL, *_8, *_9 = NULL, **_12, *_13, **_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(indexes);
array_init(indexes);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describeindexes", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 323);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(index, _6);
ZEPHIR_OBS_NVAR(keyName);
zephir_array_fetch_long(&keyName, index, 1, PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 309 TSRMLS_CC);
if (!(zephir_array_isset(indexes, keyName))) {
ZEPHIR_INIT_NVAR(columns);
array_init(columns);
} else {
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch(&columns, indexes, keyName, PH_NOISY, "phalcon/db/adapter/pdo/sqlite.zep", 313 TSRMLS_CC);
}
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_9, _8, "describeindex", NULL, 0, keyName);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_7, this_ptr, "fetchall", NULL, 0, _9, _3);
zephir_check_call_status();
zephir_is_iterable(_7, &_11, &_10, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 320);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HVALUE(describe_index, _12);
zephir_array_fetch_long(&_13, describe_index, 2, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/sqlite.zep", 317 TSRMLS_CC);
zephir_array_append(&columns, _13, PH_SEPARATE, "phalcon/db/adapter/pdo/sqlite.zep", 317);
}
zephir_array_update_zval(&indexes, keyName, &columns, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_VAR(indexObjects);
array_init(indexObjects);
zephir_is_iterable(indexes, &_15, &_14, 0, 0, "phalcon/db/adapter/pdo/sqlite.zep", 328);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HMKEY(name, _15, _14);
ZEPHIR_GET_HVALUE(indexColumns, _16);
ZEPHIR_INIT_NVAR(_3);
object_init_ex(_3, phalcon_db_index_ce);
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", &_17, 15, name, indexColumns);
zephir_check_call_status();
zephir_array_update_zval(&indexObjects, name, &_3, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(indexObjects);
}
/**
* Sanitizes a value with a specified single or set of filters
*/
PHP_METHOD(Phalcon_Filter, sanitize) {
zephir_fcall_cache_entry *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1, *_5, *_10;
HashPosition _0, _4, _9;
zend_bool noRecursive, _3;
zval *value = NULL, *filters, *noRecursive_param = NULL, *filter = NULL, *arrayValue = NULL, *itemKey = NULL, *itemValue = NULL, *sanitizedValue, **_2, **_6, *_7 = NULL, **_11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &value, &filters, &noRecursive_param);
ZEPHIR_SEPARATE_PARAM(value);
if (!noRecursive_param) {
noRecursive = 0;
} else {
noRecursive = zephir_get_boolval(noRecursive_param);
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (Z_TYPE_P(value) != IS_NULL) {
zephir_is_iterable(filters, &_1, &_0, 0, 0, "phalcon/filter.zep", 107);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(filter, _2);
_3 = Z_TYPE_P(value) == IS_ARRAY;
if (_3) {
_3 = !noRecursive;
}
if (_3) {
ZEPHIR_INIT_NVAR(arrayValue);
array_init(arrayValue);
zephir_is_iterable(value, &_5, &_4, 0, 0, "phalcon/filter.zep", 102);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(itemKey, _5, _4);
ZEPHIR_GET_HVALUE(itemValue, _6);
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, itemValue, filter);
zephir_check_call_status();
zephir_array_update_zval(&arrayValue, itemKey, &_7, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CPY_WRT(value, arrayValue);
} else {
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, value, filter);
zephir_check_call_status();
ZEPHIR_CPY_WRT(value, _7);
}
}
}
RETVAL_ZVAL(value, 1, 0);
RETURN_MM();
}
_3 = Z_TYPE_P(value) == IS_ARRAY;
if (_3) {
_3 = !noRecursive;
}
if (_3) {
ZEPHIR_INIT_VAR(sanitizedValue);
array_init(sanitizedValue);
zephir_is_iterable(value, &_10, &_9, 0, 0, "phalcon/filter.zep", 119);
for (
; zephir_hash_get_current_data_ex(_10, (void**) &_11, &_9) == SUCCESS
; zephir_hash_move_forward_ex(_10, &_9)
) {
ZEPHIR_GET_HMKEY(itemKey, _10, _9);
ZEPHIR_GET_HVALUE(itemValue, _11);
ZEPHIR_CALL_METHOD(&_7, this_ptr, "_sanitize", &_8, itemValue, filters);
zephir_check_call_status();
zephir_array_update_zval(&sanitizedValue, itemKey, &_7, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(sanitizedValue);
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_sanitize", &_8, value, filters);
zephir_check_call_status();
RETURN_MM();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) {
HashTable *_5, *_8$$5;
HashPosition _4, _7$$5;
zephir_fcall_cache_entry *_12 = NULL, *_16 = NULL, *_17 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *filePath_param = NULL, *iniConfig = NULL, _0, *config = NULL, *section = NULL, *sections = NULL, *directives = NULL, *path = NULL, *lastValue = NULL, **_6, *_1$$3, *_2$$3, *_3$$3, **_9$$5, *_10$$6 = NULL, *_13$$7 = NULL, _14$$7 = zval_used_for_init, *_15$$8 = NULL;
zval *filePath = NULL, *_11$$6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &filePath_param);
if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) {
zephir_get_strval(filePath, filePath_param);
} else {
ZEPHIR_INIT_VAR(filePath);
ZVAL_EMPTY_STRING(filePath);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 1);
ZEPHIR_CALL_FUNCTION(&iniConfig, "parse_ini_file", NULL, 134, filePath, ZEPHIR_GLOBAL(global_true), &_0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(iniConfig)) {
ZEPHIR_INIT_VAR(_1$$3);
object_init_ex(_1$$3, phalcon_config_exception_ce);
ZEPHIR_INIT_VAR(_2$$3);
zephir_basename(_2$$3, filePath TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_CONCAT_SVS(_3$$3, "Configuration file ", _2$$3, " can't be loaded");
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _3$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$3, "phalcon/config/adapter/ini.zep", 67 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(config);
array_init(config);
zephir_is_iterable(iniConfig, &_5, &_4, 0, 0, "phalcon/config/adapter/ini.zep", 88);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(section, _5, _4);
ZEPHIR_GET_HVALUE(directives, _6);
if (Z_TYPE_P(directives) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(sections);
array_init(sections);
zephir_is_iterable(directives, &_8$$5, &_7$$5, 0, 0, "phalcon/config/adapter/ini.zep", 80);
for (
; zephir_hash_get_current_data_ex(_8$$5, (void**) &_9$$5, &_7$$5) == SUCCESS
; zephir_hash_move_forward_ex(_8$$5, &_7$$5)
) {
ZEPHIR_GET_HMKEY(path, _8$$5, _7$$5);
ZEPHIR_GET_HVALUE(lastValue, _9$$5);
zephir_get_strval(_11$$6, path);
ZEPHIR_CALL_METHOD(&_10$$6, this_ptr, "_parseinistring", &_12, 0, _11$$6, lastValue);
zephir_check_call_status();
zephir_array_append(§ions, _10$$6, PH_SEPARATE, "phalcon/config/adapter/ini.zep", 78);
}
if (zephir_fast_count_int(sections TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_13$$7);
ZEPHIR_SINIT_NVAR(_14$$7);
ZVAL_STRING(&_14$$7, "array_merge_recursive", 0);
ZEPHIR_CALL_USER_FUNC_ARRAY(_13$$7, &_14$$7, sections);
zephir_check_call_status();
zephir_array_update_zval(&config, section, &_13$$7, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CALL_METHOD(&_15$$8, this_ptr, "_cast", &_16, 135, directives);
zephir_check_call_status();
zephir_array_update_zval(&config, section, &_15$$8, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_ini_ce, this_ptr, "__construct", &_17, 19, config);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Outputs a message formatting it with HTML
*
*<code>
* $flash->outputMessage('error', message);
*</code>
*
* @param string|array message
* @return string|void
*/
PHP_METHOD(Phalcon_Flash, outputMessage) {
HashTable *_3$$8;
HashPosition _2$$8;
zend_bool automaticHtml = 0, implicitFlush = 0;
zval *type_param = NULL, *message, *content = NULL, *cssClasses = NULL, *classes = NULL, *typeClasses = NULL, *eol = NULL, *msg = NULL, *htmlMessage = NULL, *_0 = NULL, *_1$$5, **_4$$8;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &message);
zephir_get_strval(type, type_param);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
automaticHtml = zephir_get_boolval(_0);
if (automaticHtml == 1) {
ZEPHIR_OBS_VAR(classes);
zephir_read_property_this(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(typeClasses);
if (zephir_array_isset_fetch(&typeClasses, classes, type, 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(cssClasses);
if (Z_TYPE_P(typeClasses) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_1$$5);
zephir_fast_join_str(_1$$5, SL(" "), typeClasses TSRMLS_CC);
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", _1$$5, "\"");
} else {
ZEPHIR_CONCAT_SVS(cssClasses, " class=\"", typeClasses, "\"");
}
} else {
ZEPHIR_INIT_NVAR(cssClasses);
ZVAL_STRING(cssClasses, "", 1);
}
ZEPHIR_INIT_VAR(eol);
ZEPHIR_GET_CONSTANT(eol, "PHP_EOL");
}
ZEPHIR_OBS_NVAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
implicitFlush = zephir_get_boolval(_0);
if (Z_TYPE_P(message) == IS_ARRAY) {
if (implicitFlush == 0) {
ZEPHIR_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
zephir_is_iterable(message, &_3$$8, &_2$$8, 0, 0, "phalcon/flash.zep", 204);
for (
; zephir_hash_get_current_data_ex(_3$$8, (void**) &_4$$8, &_2$$8) == SUCCESS
; zephir_hash_move_forward_ex(_3$$8, &_2$$8)
) {
ZEPHIR_GET_HVALUE(msg, _4$$8);
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", msg, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, msg);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_concat_self(&content, htmlMessage TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
}
}
if (implicitFlush == 0) {
RETURN_CCTOR(content);
}
} else {
if (automaticHtml == 1) {
ZEPHIR_INIT_NVAR(htmlMessage);
ZEPHIR_CONCAT_SVSVSV(htmlMessage, "<div", cssClasses, ">", message, "</div>", eol);
} else {
ZEPHIR_CPY_WRT(htmlMessage, message);
}
if (implicitFlush == 1) {
zend_print_zval(htmlMessage, 0);
} else {
zephir_update_property_array_append(this_ptr, SL("_messages"), htmlMessage TSRMLS_CC);
RETURN_CCTOR(htmlMessage);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Gets the column name in SQLite
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) {
zephir_nts_static zephir_fcall_cache_entry *_7 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *column, *columnSql, *type = NULL, *typeValues = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *value = NULL, *valueSql, **_5, _6 = zval_used_for_init, _8 = zval_used_for_init, *_9, *_10 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &column);
ZEPHIR_INIT_VAR(columnSql);
ZVAL_STRING(columnSql, "", 1);
ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL);
zephir_check_call_status();
if (Z_TYPE_P(type) == IS_STRING) {
zephir_concat_self(&columnSql, type TSRMLS_CC);
ZEPHIR_CALL_METHOD(&type, column, "gettypereference", NULL);
zephir_check_call_status();
}
do {
if (ZEPHIR_IS_LONG(type, 0)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("INT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 1)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 2)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("VARCHAR") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "(", _0, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 3)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, column, "getscale", NULL);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVSVS(_1, "(", _0, ",", _2, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 4)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 5)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_0, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVS(_1, "(", _0, ")");
zephir_concat_self(&columnSql, _1 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 6)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(type, 7)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_EMPTY(columnSql)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Unrecognized SQLite data type", "phalcon/db/dialect/sqlite.zep", 112);
return;
}
ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(typeValues))) {
if (Z_TYPE_P(typeValues) == IS_ARRAY) {
ZEPHIR_INIT_VAR(valueSql);
ZVAL_STRING(valueSql, "", 1);
zephir_is_iterable(typeValues, &_4, &_3, 0, 0, "phalcon/db/dialect/sqlite.zep", 123);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(value, _5);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_0, "addcslashes", &_7, value, &_6);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SVS(_1, "\"", _0, "\", ");
zephir_concat_self(&valueSql, _1 TSRMLS_CC);
}
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, 0);
ZEPHIR_SINIT_VAR(_8);
ZVAL_LONG(&_8, -2);
ZEPHIR_INIT_VAR(_9);
zephir_substr(_9, valueSql, 0 , -2 , 0);
ZEPHIR_INIT_VAR(_10);
ZEPHIR_CONCAT_SVS(_10, "(", _9, ")");
zephir_concat_self(&columnSql, _10 TSRMLS_CC);
} else {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_STRING(&_8, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_2, "addcslashes", &_7, typeValues, &_8);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_10);
ZEPHIR_CONCAT_SVS(_10, "(\"", _2, "\")");
zephir_concat_self(&columnSql, _10 TSRMLS_CC);
}
}
} while(0);
RETURN_CCTOR(columnSql);
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate) {
HashTable *_2$$5, *_22$$16;
HashPosition _1$$5, _21$$16;
zend_class_entry *_33;
zephir_fcall_cache_entry *_6 = NULL, *_12 = NULL, *_31 = NULL;
int ZEPHIR_LAST_CALL_STATUS, number = 0;
zval *record, *field = NULL, *dependencyInjector = NULL, *metaData = NULL, *message = NULL, *bindTypes = NULL, *bindDataTypes = NULL, *columnMap = NULL, *conditions = NULL, *bindParams = NULL, *composeField = NULL, *columnField = NULL, *bindType = NULL, *primaryField = NULL, *attributeField = NULL, *params = NULL, *className = NULL, *replacePairs = NULL, *_0 = NULL, *_19 = NULL, *_32 = NULL, **_3$$5, *_4$$8 = NULL, *_5$$8 = NULL, *_7$$10 = NULL, *_8$$10 = NULL, _9$$6 = zval_used_for_init, *_10$$6 = NULL, *_11$$6 = NULL, *_13$$13, *_14$$13, *_15$$15, *_16$$15, *_17$$11, *_18$$11 = NULL, *_20$$16 = NULL, **_23$$16, *_24$$20 = NULL, *_25$$20 = NULL, *_26$$22 = NULL, *_27$$22 = NULL, _28$$19 = zval_used_for_init, *_29$$19 = NULL, *_30$$19 = NULL, *_34$$24 = NULL, *_36$$24 = NULL, *_35$$25;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_CALL_METHOD(&dependencyInjector, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bindTypes);
array_init(bindTypes);
ZEPHIR_CALL_METHOD(&bindDataTypes, metaData, "getbindtypes", NULL, 0, record);
zephir_check_call_status();
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
number = 0;
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 127);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(composeField, _3$$5);
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, composeField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_4$$8);
object_init_ex(_4$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_5$$8);
ZEPHIR_CONCAT_SVS(_5$$8, "Column '", composeField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _4$$8, "__construct", &_6, 9, _5$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$8, "phalcon/mvc/model/validator/uniqueness.zep", 104 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, composeField);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7$$10);
object_init_ex(_7$$10, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8$$10);
ZEPHIR_CONCAT_SVS(_8$$10, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_6, 9, _8$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/validator/uniqueness.zep", 114 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_SINIT_NVAR(_9$$6);
ZVAL_LONG(&_9$$6, number);
ZEPHIR_INIT_LNVAR(_10$$6);
ZEPHIR_CONCAT_SVSV(_10$$6, "[", composeField, "] = ?", &_9$$6);
zephir_array_append(&conditions, _10$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 120);
ZEPHIR_CALL_METHOD(&_11$$6, record, "readattribute", &_12, 0, composeField);
zephir_check_call_status();
zephir_array_append(&bindParams, _11$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 121);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 122);
number++;
}
} else {
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, field, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_13$$13);
object_init_ex(_13$$13, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_14$$13);
ZEPHIR_CONCAT_SVS(_14$$13, "Column '", field, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _13$$13, "__construct", &_6, 9, _14$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_13$$13, "phalcon/mvc/model/validator/uniqueness.zep", 134 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, field);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_15$$15);
object_init_ex(_15$$15, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_16$$15);
ZEPHIR_CONCAT_SVS(_16$$15, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _15$$15, "__construct", &_6, 9, _16$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_15$$15, "phalcon/mvc/model/validator/uniqueness.zep", 144 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_17$$11);
ZEPHIR_CONCAT_SVS(_17$$11, "[", field, "] = ?0");
zephir_array_append(&conditions, _17$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 150);
ZEPHIR_CALL_METHOD(&_18$$11, record, "readattribute", NULL, 0, field);
zephir_check_call_status();
zephir_array_append(&bindParams, _18$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 151);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 152);
number++;
}
ZEPHIR_CALL_METHOD(&_19, record, "getoperationmade", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_19, 2)) {
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_CALL_METHOD(&_20$$16, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_20$$16, &_22$$16, &_21$$16, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 197);
for (
; zephir_hash_get_current_data_ex(_22$$16, (void**) &_23$$16, &_21$$16) == SUCCESS
; zephir_hash_move_forward_ex(_22$$16, &_21$$16)
) {
ZEPHIR_GET_HVALUE(primaryField, _23$$16);
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_24$$20);
object_init_ex(_24$$20, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_25$$20);
ZEPHIR_CONCAT_SVS(_25$$20, "Column '", primaryField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _24$$20, "__construct", &_6, 9, _25$$20);
zephir_check_call_status();
zephir_throw_exception_debug(_24$$20, "phalcon/mvc/model/validator/uniqueness.zep", 174 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(attributeField);
if (!(zephir_array_isset_fetch(&attributeField, columnMap, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_26$$22);
object_init_ex(_26$$22, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_27$$22);
ZEPHIR_CONCAT_SVS(_27$$22, "Column '", primaryField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _26$$22, "__construct", &_6, 9, _27$$22);
zephir_check_call_status();
zephir_throw_exception_debug(_26$$22, "phalcon/mvc/model/validator/uniqueness.zep", 182 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(attributeField, primaryField);
}
ZEPHIR_SINIT_NVAR(_28$$19);
ZVAL_LONG(&_28$$19, number);
ZEPHIR_INIT_LNVAR(_29$$19);
ZEPHIR_CONCAT_SVSV(_29$$19, "[", attributeField, "] <> ?", &_28$$19);
zephir_array_append(&conditions, _29$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 191);
ZEPHIR_CALL_METHOD(&_30$$19, record, "readattribute", &_31, 0, primaryField);
zephir_check_call_status();
zephir_array_append(&bindParams, _30$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 192);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 193);
number++;
}
}
ZEPHIR_INIT_VAR(params);
array_init(params);
zephir_array_update_string(¶ms, SL("di"), &dependencyInjector, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_join_str(_0, SL(" AND "), conditions TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bind"), &bindParams, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bindTypes"), &bindTypes, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
_33 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_32, _33, "count", NULL, 0, params);
zephir_check_call_status();
if (!ZEPHIR_IS_LONG(_32, 0)) {
ZEPHIR_INIT_VAR(_34$$24);
ZVAL_STRING(_34$$24, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_35$$25);
zephir_fast_join_str(_35$$25, SL(", "), field TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":fields"), &_35$$25, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of fields: :fields are already present in another record", 1);
}
} else {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &field, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field: ':field' is already present in another record", 1);
}
}
ZEPHIR_CALL_FUNCTION(&_36$$24, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_34$$24);
ZVAL_STRING(_34$$24, "Unique", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _36$$24, field, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Produce the routing parameters from the rewrite information
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) {
zephir_fcall_cache_entry *_9 = NULL, *_17 = NULL, *_18 = NULL;
HashTable *_2, *_7, *_11, *_15;
HashPosition _1, _6, _10, _14;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri_param = NULL, *realUri = NULL, *annotationsService = NULL, *handlers, *controllerSuffix, *scope = NULL, *prefix = NULL, *dependencyInjector = NULL, *handler = NULL, *controllerName = NULL, *lowerControllerName = NULL, *namespaceName = NULL, *moduleName = NULL, *sufixed = NULL, *handlerAnnotations = NULL, *classAnnotations = NULL, *annotations = NULL, *annotation = NULL, *methodAnnotations = NULL, *lowercased = NULL, *method = NULL, *collection = NULL, *_0, **_3, *_4, *_5 = NULL, **_8, **_12, *_13 = NULL, **_16;
zval *uri = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri_param);
if (!uri_param) {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
} else {
if (unlikely(Z_TYPE_P(uri_param) != IS_STRING && Z_TYPE_P(uri_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'uri' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(uri_param) == IS_STRING)) {
zephir_get_strval(uri, uri_param);
} else {
ZEPHIR_INIT_VAR(uri);
ZVAL_EMPTY_STRING(uri);
}
}
if (!(!(!uri) && Z_STRLEN_P(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_processed"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(annotationsService);
ZVAL_NULL(annotationsService);
ZEPHIR_OBS_VAR(handlers);
zephir_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
ZEPHIR_OBS_VAR(controllerSuffix);
zephir_read_property_this(&controllerSuffix, this_ptr, SL("_controllerSuffix"), PH_NOISY_CC);
zephir_is_iterable(handlers, &_2, &_1, 0, 0, "phalcon/mvc/router/annotations.zep", 208);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(prefix);
zephir_array_fetch_long(&prefix, scope, 0, PH_NOISY, "phalcon/mvc/router/annotations.zep", 117 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(prefix))) {
if (!(zephir_start_with(realUri, prefix, NULL))) {
continue;
}
}
if (Z_TYPE_P(annotationsService) != IS_OBJECT) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service", "phalcon/mvc/router/annotations.zep", 129);
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "annotations", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&annotationsService, dependencyInjector, "getshared", NULL, 0, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_OBS_NVAR(handler);
zephir_array_fetch_long(&handler, scope, 1, PH_NOISY, "phalcon/mvc/router/annotations.zep", 138 TSRMLS_CC);
if (zephir_memnstr_str(handler, SL("\\"), "phalcon/mvc/router/annotations.zep", 140)) {
ZEPHIR_INIT_NVAR(controllerName);
zephir_get_class_ns(controllerName, handler, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
zephir_get_ns_class(namespaceName, handler, 0 TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(controllerName, handler);
ZEPHIR_INIT_NVAR(lowerControllerName);
zephir_uncamelize(lowerControllerName, controllerName);
ZEPHIR_INIT_NVAR(namespaceName);
ZVAL_NULL(namespaceName);
}
zephir_update_property_this(this_ptr, SL("_routePrefix"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_isset_long_fetch(&moduleName, scope, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(sufixed);
ZEPHIR_CONCAT_VV(sufixed, handler, controllerSuffix);
ZEPHIR_CALL_METHOD(&handlerAnnotations, annotationsService, "get", NULL, 0, sufixed);
zephir_check_call_status();
if (Z_TYPE_P(handlerAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&classAnnotations, handlerAnnotations, "getclassannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(classAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&annotations, classAnnotations, "getannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_7, &_6, 0, 0, "phalcon/mvc/router/annotations.zep", 187);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(annotation, _8);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", &_9, 0, controllerName, annotation);
zephir_check_call_status();
}
}
}
ZEPHIR_CALL_METHOD(&methodAnnotations, handlerAnnotations, "getmethodsannotations", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(methodAnnotations) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(lowercased);
zephir_uncamelize(lowercased, handler);
zephir_is_iterable(methodAnnotations, &_11, &_10, 0, 0, "phalcon/mvc/router/annotations.zep", 203);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HMKEY(method, _11, _10);
ZEPHIR_GET_HVALUE(collection, _12);
if (Z_TYPE_P(collection) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_13, collection, "getannotations", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_13, &_15, &_14, 0, 0, "phalcon/mvc/router/annotations.zep", 201);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HVALUE(annotation, _16);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "processactionannotation", &_17, 0, moduleName, namespaceName, lowerControllerName, method, annotation);
zephir_check_call_status();
}
}
}
}
}
}
}
}
if (1) {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", &_18, 361, realUri);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Renders a view using the template engine
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, render) {
HashTable *_1;
HashPosition _0;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool mustClean;
zval *templatePath_param = NULL, *params, *mustClean_param = NULL, *compiler = NULL, *compiledTemplatePath = NULL, *key = NULL, *value = NULL, **_2, *_3 = NULL, *_4, *_5 = NULL;
zval *templatePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &templatePath_param, ¶ms, &mustClean_param);
if (unlikely(Z_TYPE_P(templatePath_param) != IS_STRING && Z_TYPE_P(templatePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'templatePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(templatePath_param) == IS_STRING)) {
zephir_get_strval(templatePath, templatePath_param);
} else {
ZEPHIR_INIT_VAR(templatePath);
ZVAL_EMPTY_STRING(templatePath);
}
if (!mustClean_param) {
mustClean = 0;
} else {
mustClean = zephir_get_boolval(mustClean_param);
}
if (mustClean) {
ZEPHIR_CALL_FUNCTION(NULL, "ob_clean", NULL, 371);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&compiler, this_ptr, "getcompiler", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, compiler, "compile", NULL, 0, templatePath);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&compiledTemplatePath, compiler, "getcompiledtemplatepath", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(params) == IS_ARRAY) {
zephir_is_iterable(params, &_1, &_0, 0, 0, "phalcon/mvc/view/engine/volt.zep", 118);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(key, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_CPY_WRT(_3, value);
if (zephir_set_symbol(key, _3 TSRMLS_CC) == FAILURE){
return;
}
}
}
if (zephir_require_zval(compiledTemplatePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
if (mustClean) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_view"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&_5, "ob_get_contents", NULL, 117);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _4, "setcontent", NULL, 0, _5);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Checks for annotations in the public methods of the controller
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) {
zephir_fcall_cache_entry *_7 = NULL, *_11 = NULL;
HashTable *_5, *_9;
HashPosition _4, _8;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool isRoute, _12;
zval *module_param = NULL, *namespaceName_param = NULL, *controller_param = NULL, *action_param = NULL, *annotation, *name = NULL, *actionName, *routePrefix, *paths = NULL, *value = NULL, *uri = NULL, *route = NULL, *methods = NULL, *converts = NULL, *param = NULL, *convert = NULL, *conversorParam = NULL, *routeName = NULL, *beforeMatch = NULL, *_0, *_1, _2, *_3 = NULL, **_6, **_10;
zval *module = NULL, *namespaceName = NULL, *controller = NULL, *action = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 5, 0, &module_param, &namespaceName_param, &controller_param, &action_param, &annotation);
if (unlikely(Z_TYPE_P(module_param) != IS_STRING && Z_TYPE_P(module_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'module' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(module_param) == IS_STRING)) {
zephir_get_strval(module, module_param);
} else {
ZEPHIR_INIT_VAR(module);
ZVAL_EMPTY_STRING(module);
}
if (unlikely(Z_TYPE_P(namespaceName_param) != IS_STRING && Z_TYPE_P(namespaceName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'namespaceName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(namespaceName_param) == IS_STRING)) {
zephir_get_strval(namespaceName, namespaceName_param);
} else {
ZEPHIR_INIT_VAR(namespaceName);
ZVAL_EMPTY_STRING(namespaceName);
}
if (unlikely(Z_TYPE_P(controller_param) != IS_STRING && Z_TYPE_P(controller_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controller' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(controller_param) == IS_STRING)) {
zephir_get_strval(controller, controller_param);
} else {
ZEPHIR_INIT_VAR(controller);
ZVAL_EMPTY_STRING(controller);
}
if (unlikely(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(action_param) == IS_STRING)) {
zephir_get_strval(action, action_param);
} else {
ZEPHIR_INIT_VAR(action);
ZVAL_EMPTY_STRING(action);
}
isRoute = 0;
ZEPHIR_INIT_VAR(methods);
ZVAL_NULL(methods);
ZEPHIR_CALL_METHOD(&name, annotation, "getname", NULL, 0);
zephir_check_call_status();
do {
if (ZEPHIR_IS_STRING(name, "Route")) {
isRoute = 1;
break;
}
if (ZEPHIR_IS_STRING(name, "Get")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "GET", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Post")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Put")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Delete")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "DELETE", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Options")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
break;
}
} while(0);
if (isRoute == 1) {
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
zephir_fast_str_replace(&_0, _1, &_2, action TSRMLS_CC);
ZEPHIR_INIT_VAR(actionName);
zephir_fast_strtolower(actionName, _0);
ZEPHIR_OBS_VAR(routePrefix);
zephir_read_property_this(&routePrefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "paths", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&paths, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(paths) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(paths);
array_init(paths);
}
if (!(ZEPHIR_IS_EMPTY(module))) {
zephir_array_update_string(&paths, SL("module"), &module, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(namespaceName))) {
zephir_array_update_string(&paths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&paths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 0);
ZEPHIR_CALL_METHOD(&value, annotation, "getargument", NULL, 0, _3);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (!ZEPHIR_IS_STRING(value, "/")) {
ZEPHIR_INIT_VAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, value);
} else {
if (Z_TYPE_P(routePrefix) != IS_NULL) {
ZEPHIR_CPY_WRT(uri, routePrefix);
} else {
ZEPHIR_CPY_WRT(uri, value);
}
}
} else {
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, actionName);
}
ZEPHIR_CALL_METHOD(&route, this_ptr, "add", NULL, 0, uri, paths);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "methods", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&methods, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(methods) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
}
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "converts", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_5, &_4, 0, 0, "phalcon/mvc/router/annotations.zep", 354);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(param, _5, _4);
ZEPHIR_GET_HVALUE(convert, _6);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_7, 0, param, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "conversors", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_9, &_8, 0, 0, "phalcon/mvc/router/annotations.zep", 364);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(conversorParam, _9, _8);
ZEPHIR_GET_HVALUE(convert, _10);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_11, 0, conversorParam, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "beforeMatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&beforeMatch, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
_12 = Z_TYPE_P(beforeMatch) == IS_ARRAY;
if (!(_12)) {
_12 = Z_TYPE_P(beforeMatch) == IS_STRING;
}
if (_12) {
ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, 0, beforeMatch);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "name", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&routeName, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(routeName) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "setname", NULL, 0, routeName);
zephir_check_call_status();
}
RETURN_MM_BOOL(1);
}
ZEPHIR_MM_RESTORE();
}
/**
* Listens for notifications from the models manager
*/
PHP_METHOD(Phalcon_Mvc_Collection_Behavior_SoftDelete, notify) {
HashTable *_5$$7;
HashPosition _4$$7;
zephir_fcall_cache_entry *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *type_param = NULL, *model, *options = NULL, *value = NULL, *field = NULL, *updateModel = NULL, *message = NULL, *_0$$3, *_1$$3 = NULL, *_2$$6 = NULL, *_3$$7 = NULL, **_6$$7;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &model);
if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(type_param) == IS_STRING)) {
zephir_get_strval(type, type_param);
} else {
ZEPHIR_INIT_VAR(type);
ZVAL_EMPTY_STRING(type);
}
if (ZEPHIR_IS_STRING(type, "beforeDelete")) {
ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(value);
if (!(zephir_array_isset_string_fetch(&value, options, SS("value"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'value' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 51);
return;
}
ZEPHIR_OBS_VAR(field);
if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'field' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 58);
return;
}
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_BOOL(_0$$3, 1);
ZEPHIR_CALL_METHOD(NULL, model, "skipoperation", NULL, 0, _0$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1$$3, model, "readattribute", NULL, 0, field);
zephir_check_call_status();
if (!ZEPHIR_IS_EQUAL(_1$$3, value)) {
ZEPHIR_INIT_VAR(updateModel);
if (zephir_clone(updateModel, model TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_CALL_METHOD(NULL, updateModel, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$6, updateModel, "save", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_2$$6))) {
ZEPHIR_CALL_METHOD(&_3$$7, updateModel, "getmessages", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_3$$7, &_5$$7, &_4$$7, 0, 0, "phalcon/mvc/collection/behavior/softdelete.zep", 90);
for (
; zephir_hash_get_current_data_ex(_5$$7, (void**) &_6$$7, &_4$$7) == SUCCESS
; zephir_hash_move_forward_ex(_5$$7, &_4$$7)
) {
ZEPHIR_GET_HVALUE(message, _6$$7);
ZEPHIR_CALL_METHOD(NULL, model, "appendmessage", &_7, 0, message);
zephir_check_call_status();
}
RETURN_MM_BOOL(0);
}
ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Handles routing information received from command-line arguments
*
* @param array arguments
*/
PHP_METHOD(Phalcon_Cli_Router, handle) {
zephir_fcall_cache_entry *_18 = NULL;
zval *_15 = NULL;
zval *_5 = NULL, *_10 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3, *_7;
HashPosition _2, _6;
zend_bool _0;
zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
if (Z_TYPE_P(arguments) != IS_ARRAY) {
_0 = Z_TYPE_P(arguments) != IS_STRING;
if (_0) {
_0 = Z_TYPE_P(arguments) != IS_NULL;
}
if (_0) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_backwards_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(route, _4);
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0);
zephir_check_call_status();
if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) {
ZEPHIR_INIT_NVAR(routeFound);
zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(routeFound);
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232);
return;
}
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_5, arguments);
zephir_array_fast_append(_5, route);
zephir_array_fast_append(_5, this_ptr);
ZEPHIR_INIT_NVAR(routeFound);
ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5);
zephir_check_call_status();
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(part, _7, _6);
ZEPHIR_GET_HVALUE(position, _8);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_5, matchPosition);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_10);
zephir_create_array(_10, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_10, position);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC);
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC);
RETURN_THIS();
}
} else {
ZEPHIR_CPY_WRT(parts, arguments);
}
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(taskName);
ZVAL_NULL(taskName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_OBS_NVAR(moduleName);
if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(moduleName);
zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(taskName);
if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(taskName);
zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(actionName);
if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_NVAR(params);
if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(params) != IS_ARRAY) {
zephir_get_strval(_15, params);
ZEPHIR_SINIT_VAR(_16);
ZVAL_LONG(&_16, 1);
ZEPHIR_INIT_VAR(strParams);
zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (zephir_is_true(strParams)) {
ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 121);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(params);
zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(params);
array_init(params);
}
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _9);
} else {
ZEPHIR_CPY_WRT(params, parts);
}
} else {
ZEPHIR_CPY_WRT(params, parts);
}
zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Validate a set of data according to a set of rules
*
* @param array|object data
* @param object entity
* @return \Phalcon\Validation\Message\Group
*/
PHP_METHOD(Phalcon_Validation, validate) {
zend_bool _0$$7;
HashTable *_2, *_10$$16;
HashPosition _1, _9$$16;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL, *entity = NULL, *validators = NULL, *messages = NULL, *scope = NULL, *field = NULL, *validator = NULL, *status = NULL, *combinedFieldsValidators = NULL, **_3, *_4$$10 = NULL, *_6$$10 = NULL, *_7$$14 = NULL, *_8$$14 = NULL, **_11$$16, *_12$$17 = NULL, *_13$$17 = NULL, *_14$$21 = NULL, *_15$$21 = NULL, *_16$$23;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &data, &entity);
if (!data) {
data = ZEPHIR_GLOBAL(global_null);
}
if (!entity) {
entity = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(validators);
zephir_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(combinedFieldsValidators);
zephir_read_property_this(&combinedFieldsValidators, this_ptr, SL("_combinedFieldsValidators"), PH_NOISY_CC);
if (Z_TYPE_P(validators) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There are no validators to validate", "phalcon/validation.zep", 94);
return;
}
zephir_update_property_this(this_ptr, SL("_values"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_INIT_VAR(messages);
object_init_ex(messages, phalcon_validation_message_group_ce);
ZEPHIR_CALL_METHOD(NULL, messages, "__construct", NULL, 3);
zephir_check_call_status();
if (Z_TYPE_P(entity) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setentity", NULL, 0, entity);
zephir_check_call_status();
}
if ((zephir_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, data, entity, messages);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
RETURN_CCTOR(status);
}
}
zephir_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC);
if (Z_TYPE_P(data) != IS_NULL) {
_0$$7 = Z_TYPE_P(data) == IS_ARRAY;
if (!(_0$$7)) {
_0$$7 = Z_TYPE_P(data) == IS_OBJECT;
}
if (_0$$7) {
zephir_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
} else {
zephir_var_dump(&data TSRMLS_CC);
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Invalid data to validate", "phalcon/validation.zep", 128);
return;
}
}
zephir_is_iterable(validators, &_2, &_1, 0, 0, "phalcon/validation.zep", 162);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 135);
return;
}
ZEPHIR_OBS_NVAR(field);
zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 138 TSRMLS_CC);
ZEPHIR_OBS_NVAR(validator);
zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 139 TSRMLS_CC);
if (Z_TYPE_P(validator) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 142);
return;
}
ZEPHIR_CALL_METHOD(&_4$$10, this_ptr, "prechecking", &_5, 0, field, validator);
zephir_check_call_status();
if (zephir_is_true(_4$$10)) {
continue;
}
ZEPHIR_CALL_METHOD(&_6$$10, validator, "validate", NULL, 0, this_ptr, field);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_6$$10)) {
ZEPHIR_INIT_NVAR(_8$$14);
ZVAL_STRING(_8$$14, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_7$$14, validator, "getoption", NULL, 0, _8$$14);
zephir_check_temp_parameter(_8$$14);
zephir_check_call_status();
if (zephir_is_true(_7$$14)) {
break;
}
}
}
if (!(ZEPHIR_IS_EMPTY(combinedFieldsValidators))) {
zephir_is_iterable(combinedFieldsValidators, &_10$$16, &_9$$16, 0, 0, "phalcon/validation.zep", 191);
for (
; zephir_hash_get_current_data_ex(_10$$16, (void**) &_11$$16, &_9$$16) == SUCCESS
; zephir_hash_move_forward_ex(_10$$16, &_9$$16)
) {
ZEPHIR_GET_HVALUE(scope, _11$$16);
if (Z_TYPE_P(scope) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 165);
return;
}
ZEPHIR_OBS_NVAR(field);
zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 168 TSRMLS_CC);
ZEPHIR_OBS_NVAR(validator);
zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 169 TSRMLS_CC);
if (Z_TYPE_P(validator) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 172);
return;
}
ZEPHIR_CALL_METHOD(&_12$$17, this_ptr, "prechecking", &_5, 0, field, validator);
zephir_check_call_status();
if (zephir_is_true(_12$$17)) {
continue;
}
ZEPHIR_CALL_METHOD(&_13$$17, validator, "validate", NULL, 0, this_ptr, field);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$17)) {
ZEPHIR_INIT_NVAR(_15$$21);
ZVAL_STRING(_15$$21, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_14$$21, validator, "getoption", NULL, 0, _15$$21);
zephir_check_temp_parameter(_15$$21);
zephir_check_call_status();
if (zephir_is_true(_14$$21)) {
break;
}
}
}
}
if ((zephir_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS)) {
_16$$23 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, data, entity, _16$$23);
zephir_check_call_status();
}
RETURN_MM_MEMBER(this_ptr, "_messages");
}
/**
* Create/Returns a new transaction or an existing one
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) {
HashTable *_2$$5;
HashPosition _1$$5;
int ZEPHIR_LAST_CALL_STATUS;
zval *autoBegin_param = NULL, *dependencyInjector = NULL, *transaction = NULL, *transactions = NULL, *_0, *_5, *_6, **_3$$5, *_4$$7 = NULL;
zend_bool autoBegin;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &autoBegin_param);
if (!autoBegin_param) {
autoBegin = 1;
} else {
autoBegin = zephir_get_boolval(autoBegin_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 188);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(transactions);
zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC);
if (Z_TYPE_P(transactions) == IS_ARRAY) {
zephir_is_iterable(transactions, &_2$$5, &_1$$5, 0, 1, "phalcon/mvc/model/transaction/manager.zep", 200);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_backwards_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(transaction, _3$$5);
if (Z_TYPE_P(transaction) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_4$$7);
ZVAL_BOOL(_4$$7, 0);
ZEPHIR_CALL_METHOD(NULL, transaction, "setisnewtransaction", NULL, 0, _4$$7);
zephir_check_call_status();
RETURN_CCTOR(transaction);
}
}
}
}
ZEPHIR_INIT_NVAR(transaction);
object_init_ex(transaction, phalcon_mvc_model_transaction_ce);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_service"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_6);
if (autoBegin) {
ZVAL_BOOL(_6, 1);
} else {
ZVAL_BOOL(_6, 0);
}
ZEPHIR_CALL_METHOD(NULL, transaction, "__construct", NULL, 352, dependencyInjector, _6, _5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", NULL, 353, this_ptr);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_number") TSRMLS_CC));
RETURN_CCTOR(transaction);
}
/**
* Executes the event listeners; sorts, calls, and returns result.
*
* @param \Xpl\Event\Event event Event object.
* @param array listeners Array of Listener objects.
* @param array args Callback arguments.
* @return array Array of event callback results.
*/
PHP_METHOD(Xpl_Event_Manager, execute) {
HashTable *_3;
HashPosition _2;
zephir_fcall_cache_entry *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *listeners = NULL, *args = NULL, *_0, *_8;
zval *event, *listeners_param = NULL, *args_param = NULL, *results = NULL, *listener = NULL, *value = NULL, *_1, **_4, *_9 = NULL, *_5$$4 = NULL, *_6$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &event, &listeners_param, &args_param);
ZEPHIR_SEPARATE_PARAM(event);
listeners = listeners_param;
if (!args_param) {
ZEPHIR_INIT_VAR(args);
array_init(args);
} else {
args = args_param;
}
ZEPHIR_INIT_VAR(results);
array_init(results);
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0, this_ptr);
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("sortFunction"), PH_NOISY_CC);
zephir_array_fast_append(_0, _1);
ZEPHIR_MAKE_REF(listeners);
ZEPHIR_CALL_FUNCTION(NULL, "usort", NULL, 85, listeners, _0);
ZEPHIR_UNREF(listeners);
zephir_check_call_status();
ZEPHIR_MAKE_REF(args);
ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 80, args, event);
ZEPHIR_UNREF(args);
zephir_check_call_status();
zephir_is_iterable(listeners, &_3, &_2, 0, 0, "xpl/event/manager.zep", 427);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(listener, _4);
ZEPHIR_CALL_ZVAL_FUNCTION(&value, listener, NULL, 0, args);
zephir_check_call_status();
zephir_array_append(&results, value, PH_SEPARATE, "xpl/event/manager.zep", 408);
if (Z_TYPE_P(value) != IS_NULL) {
ZEPHIR_OBS_NVAR(_5$$4);
zephir_read_property(&_5$$4, event, SL("value"), PH_NOISY_CC);
if (!ZEPHIR_IS_IDENTICAL(value, _5$$4)) {
zephir_update_property_zval(event, SL("value"), value TSRMLS_CC);
}
}
ZEPHIR_INIT_NVAR(value);
ZVAL_NULL(value);
ZEPHIR_CALL_METHOD(&_6$$3, event, "ispropagationstopped", &_7, 105);
zephir_check_call_status();
if (zephir_is_true(_6$$3)) {
break;
}
}
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_update_string(&_8, SL("event"), &event, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_8, SL("result"), &results, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_9, event, "getid", NULL, 0);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("completed"), _9, _8 TSRMLS_CC);
RETURN_CCTOR(results);
}
/**
* Resolves an annotation expression
*
* @param array expr
* @return mixed
*/
PHP_METHOD(Phalcon_Annotations_Annotation, getExpression) {
HashTable *_2$$7;
HashPosition _1$$7;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *expr_param = NULL, *value = NULL, *item = NULL, *resolvedItem = NULL, *arrayValue = NULL, *name = NULL, *type = NULL, *_0$$7, **_3$$7, *_4$$8, *_6$$12, *_7$$12;
zval *expr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &expr_param);
expr = expr_param;
ZEPHIR_OBS_VAR(type);
zephir_array_fetch_string(&type, expr, SL("type"), PH_NOISY, "phalcon/annotations/annotation.zep", 96 TSRMLS_CC);
do {
if (ZEPHIR_IS_LONG(type, 301) || ZEPHIR_IS_LONG(type, 302) || ZEPHIR_IS_LONG(type, 303) || ZEPHIR_IS_LONG(type, 307)) {
ZEPHIR_OBS_VAR(value);
zephir_array_fetch_string(&value, expr, SL("value"), PH_NOISY, "phalcon/annotations/annotation.zep", 103 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(type, 304)) {
ZEPHIR_INIT_NVAR(value);
ZVAL_NULL(value);
break;
}
if (ZEPHIR_IS_LONG(type, 305)) {
ZEPHIR_INIT_NVAR(value);
ZVAL_BOOL(value, 0);
break;
}
if (ZEPHIR_IS_LONG(type, 306)) {
ZEPHIR_INIT_NVAR(value);
ZVAL_BOOL(value, 1);
break;
}
if (ZEPHIR_IS_LONG(type, 308)) {
ZEPHIR_INIT_VAR(arrayValue);
array_init(arrayValue);
zephir_array_fetch_string(&_0$$7, expr, SL("items"), PH_NOISY | PH_READONLY, "phalcon/annotations/annotation.zep", 120 TSRMLS_CC);
zephir_is_iterable(_0$$7, &_2$$7, &_1$$7, 0, 0, "phalcon/annotations/annotation.zep", 128);
for (
; zephir_hash_get_current_data_ex(_2$$7, (void**) &_3$$7, &_1$$7) == SUCCESS
; zephir_hash_move_forward_ex(_2$$7, &_1$$7)
) {
ZEPHIR_GET_HVALUE(item, _3$$7);
zephir_array_fetch_string(&_4$$8, item, SL("expr"), PH_NOISY | PH_READONLY, "phalcon/annotations/annotation.zep", 121 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_5, 87, _4$$8);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(name);
if (zephir_array_isset_string_fetch(&name, item, SS("name"), 0 TSRMLS_CC)) {
zephir_array_update_zval(&arrayValue, name, &resolvedItem, PH_COPY | PH_SEPARATE);
} else {
zephir_array_append(&arrayValue, resolvedItem, PH_SEPARATE, "phalcon/annotations/annotation.zep", 125);
}
}
RETURN_CCTOR(arrayValue);
}
if (ZEPHIR_IS_LONG(type, 300)) {
object_init_ex(return_value, phalcon_annotations_annotation_ce);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 88, expr);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_INIT_VAR(_6$$12);
object_init_ex(_6$$12, phalcon_annotations_exception_ce);
ZEPHIR_INIT_VAR(_7$$12);
ZEPHIR_CONCAT_SVS(_7$$12, "The expression ", type, " is unknown");
ZEPHIR_CALL_METHOD(NULL, _6$$12, "__construct", NULL, 9, _7$$12);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$12, "phalcon/annotations/annotation.zep", 134 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
RETURN_CCTOR(value);
}
PHP_METHOD(Phalcon_Validation_Validator_Uniqueness, isUniqueness) {
zval *_32$$16 = NULL, *_44$$20 = NULL, *_58$$25 = NULL;
zend_bool _11$$7, _18$$12;
zend_class_entry *_78;
HashTable *_2, *_8, *_24$$13, *_29$$15, *_41$$19, *_50$$22, *_55$$24, *_68$$27;
HashPosition _1, _7, _23$$13, _28$$15, _40$$19, _49$$22, _54$$24, _67$$27;
zephir_fcall_cache_entry *_5 = NULL, *_12 = NULL, *_14 = NULL;
int ZEPHIR_LAST_CALL_STATUS, index = 0;
zval *validation, *field = NULL, *value = NULL, *values = NULL, *convert = NULL, *record = NULL, *attribute = NULL, *except = NULL, *params = NULL, *metaData = NULL, *primaryField = NULL, *className = NULL, *singleField = NULL, *fieldExcept = NULL, *singleExcept = NULL, *notInValues = NULL, *exceptConditions = NULL, *_0 = NULL, **_3, **_9, *_63 = NULL, *_76, *_77 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_10$$7 = NULL, *_13$$7 = NULL, _15$$10 = zval_used_for_init, *_16$$10 = NULL, *_17$$11 = NULL, *_19$$12, _20$$12, _21$$12, *_22$$12 = NULL, **_25$$13, *_26$$14 = NULL, *_27$$14 = NULL, **_30$$15, *_33$$15 = NULL, *_34$$15 = NULL, _31$$16 = zval_used_for_init, _35$$17 = zval_used_for_init, *_36$$17 = NULL, *_37$$18 = NULL, *_38$$18, *_39$$18, **_42$$19, *_45$$19, *_46$$19, _43$$20 = zval_used_for_init, _47$$21, *_48$$21, **_51$$22, *_52$$23 = NULL, *_53$$23 = NULL, **_56$$24, *_59$$24 = NULL, *_60$$24 = NULL, _57$$25 = zval_used_for_init, _61$$26 = zval_used_for_init, *_62$$26 = NULL, *_64$$27 = NULL, *_65$$27, *_66$$27 = NULL, **_69$$27, *_70$$28 = NULL, _71$$28 = zval_used_for_init, *_72$$28 = NULL, *_73$$28 = NULL, *_74$$29, *_75$$29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_SEPARATE_PARAM(field);
ZEPHIR_INIT_VAR(exceptConditions);
array_init(exceptConditions);
index = 0;
ZEPHIR_INIT_VAR(params);
zephir_create_array(params, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
array_init(_0);
zephir_array_update_string(¶ms, SL("bind"), &_0, PH_COPY | PH_SEPARATE);
if (Z_TYPE_P(field) != IS_ARRAY) {
ZEPHIR_CPY_WRT(singleField, field);
ZEPHIR_INIT_NVAR(field);
array_init(field);
zephir_array_append(&field, singleField, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 156);
}
ZEPHIR_INIT_VAR(values);
array_init(values);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "convert", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&convert, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
zephir_is_iterable(field, &_2, &_1, 0, 0, "phalcon/validation/validator/uniqueness.zep", 166);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(singleField, _3);
ZEPHIR_CALL_METHOD(&_4$$4, validation, "getvalue", &_5, 0, singleField);
zephir_check_call_status();
zephir_array_update_zval(&values, singleField, &_4$$4, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(convert) != IS_NULL) {
ZEPHIR_CALL_ZVAL_FUNCTION(&_6$$5, convert, NULL, 0, values);
zephir_check_call_status();
ZEPHIR_CPY_WRT(values, _6$$5);
if (!(Z_TYPE_P(values) == IS_ARRAY)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Value conversion must return an array", "phalcon/validation/validator/uniqueness.zep", 170);
return;
}
}
zephir_is_iterable(field, &_8, &_7, 0, 0, "phalcon/validation/validator/uniqueness.zep", 200);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(singleField, _9);
ZEPHIR_INIT_NVAR(fieldExcept);
ZVAL_NULL(fieldExcept);
ZEPHIR_INIT_NVAR(notInValues);
array_init(notInValues);
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "model", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&record, this_ptr, "getoption", NULL, 0, _10$$7);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, values, singleField, PH_NOISY, "phalcon/validation/validator/uniqueness.zep", 178 TSRMLS_CC);
_11$$7 = ZEPHIR_IS_EMPTY(record);
if (!(_11$$7)) {
_11$$7 = Z_TYPE_P(record) != IS_OBJECT;
}
if (_11$$7) {
ZEPHIR_CALL_METHOD(&record, validation, "getentity", &_12, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(record)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Model of record must be set to property \"model\"", "phalcon/validation/validator/uniqueness.zep", 184);
return;
}
}
ZEPHIR_INIT_NVAR(_10$$7);
ZVAL_STRING(_10$$7, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_13$$7, this_ptr, "getoption", NULL, 0, _10$$7, singleField);
zephir_check_temp_parameter(_10$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _13$$7);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
ZEPHIR_SINIT_NVAR(_15$$10);
ZVAL_LONG(&_15$$10, index);
ZEPHIR_INIT_LNVAR(_16$$10);
ZEPHIR_CONCAT_VSV(_16$$10, attribute, " = ?", &_15$$10);
zephir_array_update_multi(¶ms, &_16$$10 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &value TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
} else {
ZEPHIR_INIT_LNVAR(_17$$11);
ZEPHIR_CONCAT_VS(_17$$11, attribute, " IS NULL");
zephir_array_update_multi(¶ms, &_17$$11 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
}
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "except", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&except, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(except)) {
_18$$12 = Z_TYPE_P(except) == IS_ARRAY;
if (_18$$12) {
ZEPHIR_INIT_VAR(_19$$12);
zephir_array_keys(_19$$12, except TSRMLS_CC);
ZEPHIR_SINIT_VAR(_20$$12);
ZVAL_LONG(&_20$$12, 0);
ZEPHIR_SINIT_VAR(_21$$12);
ZVAL_LONG(&_21$$12, (zephir_fast_count_int(except TSRMLS_CC) - 1));
ZEPHIR_CALL_FUNCTION(&_22$$12, "range", NULL, 446, &_20$$12, &_21$$12);
zephir_check_call_status();
_18$$12 = !ZEPHIR_IS_IDENTICAL(_19$$12, _22$$12);
}
if (_18$$12) {
zephir_is_iterable(except, &_24$$13, &_23$$13, 0, 0, "phalcon/validation/validator/uniqueness.zep", 219);
for (
; zephir_hash_get_current_data_ex(_24$$13, (void**) &_25$$13, &_23$$13) == SUCCESS
; zephir_hash_move_forward_ex(_24$$13, &_23$$13)
) {
ZEPHIR_GET_HMKEY(singleField, _24$$13, _23$$13);
ZEPHIR_GET_HVALUE(fieldExcept, _25$$13);
ZEPHIR_INIT_NVAR(_27$$14);
ZVAL_STRING(_27$$14, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_26$$14, this_ptr, "getoption", NULL, 0, _27$$14, singleField);
zephir_check_temp_parameter(_27$$14);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _26$$14);
zephir_check_call_status();
if (Z_TYPE_P(fieldExcept) == IS_ARRAY) {
zephir_is_iterable(fieldExcept, &_29$$15, &_28$$15, 0, 0, "phalcon/validation/validator/uniqueness.zep", 212);
for (
; zephir_hash_get_current_data_ex(_29$$15, (void**) &_30$$15, &_28$$15) == SUCCESS
; zephir_hash_move_forward_ex(_29$$15, &_28$$15)
) {
ZEPHIR_GET_HVALUE(singleExcept, _30$$15);
ZEPHIR_SINIT_NVAR(_31$$16);
ZVAL_LONG(&_31$$16, index);
ZEPHIR_INIT_LNVAR(_32$$16);
ZEPHIR_CONCAT_SV(_32$$16, "?", &_31$$16);
zephir_array_append(¬InValues, _32$$16, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 208);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_33$$15);
zephir_fast_join_str(_33$$15, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_34$$15);
ZEPHIR_CONCAT_VSVS(_34$$15, attribute, " NOT IN (", _33$$15, ")");
zephir_array_append(&exceptConditions, _34$$15, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 212);
} else {
ZEPHIR_SINIT_NVAR(_35$$17);
ZVAL_LONG(&_35$$17, index);
ZEPHIR_INIT_LNVAR(_36$$17);
ZEPHIR_CONCAT_VSV(_36$$17, attribute, " <> ?", &_35$$17);
zephir_array_append(&exceptConditions, _36$$17, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 214);
zephir_array_update_multi(¶ms, &fieldExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
} else if (zephir_fast_count_int(field TSRMLS_CC) == 1) {
zephir_array_fetch_long(&_38$$18, field, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 220 TSRMLS_CC);
ZEPHIR_INIT_VAR(_39$$18);
ZVAL_STRING(_39$$18, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_37$$18, this_ptr, "getoption", NULL, 0, _39$$18, _38$$18);
zephir_check_temp_parameter(_39$$18);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _37$$18);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_41$$19, &_40$$19, 0, 0, "phalcon/validation/validator/uniqueness.zep", 227);
for (
; zephir_hash_get_current_data_ex(_41$$19, (void**) &_42$$19, &_40$$19) == SUCCESS
; zephir_hash_move_forward_ex(_41$$19, &_40$$19)
) {
ZEPHIR_GET_HVALUE(singleExcept, _42$$19);
ZEPHIR_SINIT_NVAR(_43$$20);
ZVAL_LONG(&_43$$20, index);
ZEPHIR_INIT_LNVAR(_44$$20);
ZEPHIR_CONCAT_SV(_44$$20, "?", &_43$$20);
zephir_array_append(¬InValues, _44$$20, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 223);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_VAR(_45$$19);
zephir_fast_join_str(_45$$19, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_VAR(_46$$19);
ZEPHIR_CONCAT_VSVS(_46$$19, attribute, " NOT IN (", _45$$19, ")");
zephir_array_append(&exceptConditions, _46$$19, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 227);
} else {
ZEPHIR_SINIT_VAR(_47$$21);
ZVAL_LONG(&_47$$21, index);
ZEPHIR_INIT_VAR(_48$$21);
ZEPHIR_CONCAT_VSV(_48$$21, attribute, " <> ?", &_47$$21);
zephir_array_update_multi(¶ms, &_48$$21 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
} else if (zephir_fast_count_int(field TSRMLS_CC) > 1) {
zephir_is_iterable(field, &_50$$22, &_49$$22, 0, 0, "phalcon/validation/validator/uniqueness.zep", 249);
for (
; zephir_hash_get_current_data_ex(_50$$22, (void**) &_51$$22, &_49$$22) == SUCCESS
; zephir_hash_move_forward_ex(_50$$22, &_49$$22)
) {
ZEPHIR_GET_HVALUE(singleField, _51$$22);
ZEPHIR_INIT_NVAR(_53$$23);
ZVAL_STRING(_53$$23, "attribute", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_52$$23, this_ptr, "getoption", NULL, 0, _53$$23, singleField);
zephir_check_temp_parameter(_53$$23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&attribute, this_ptr, "getcolumnnamereal", &_14, 0, record, _52$$23);
zephir_check_call_status();
if (Z_TYPE_P(except) == IS_ARRAY) {
zephir_is_iterable(except, &_55$$24, &_54$$24, 0, 0, "phalcon/validation/validator/uniqueness.zep", 242);
for (
; zephir_hash_get_current_data_ex(_55$$24, (void**) &_56$$24, &_54$$24) == SUCCESS
; zephir_hash_move_forward_ex(_55$$24, &_54$$24)
) {
ZEPHIR_GET_HVALUE(singleExcept, _56$$24);
ZEPHIR_SINIT_NVAR(_57$$25);
ZVAL_LONG(&_57$$25, index);
ZEPHIR_INIT_LNVAR(_58$$25);
ZEPHIR_CONCAT_SV(_58$$25, "?", &_57$$25);
zephir_array_append(¬InValues, _58$$25, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 238);
zephir_array_update_multi(¶ms, &singleExcept TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
ZEPHIR_INIT_NVAR(_59$$24);
zephir_fast_join_str(_59$$24, SL(","), notInValues TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_60$$24);
ZEPHIR_CONCAT_VSVS(_60$$24, attribute, " NOT IN (", _59$$24, ")");
zephir_array_append(&exceptConditions, _60$$24, PH_SEPARATE, "phalcon/validation/validator/uniqueness.zep", 242);
} else {
ZEPHIR_SINIT_NVAR(_61$$26);
ZVAL_LONG(&_61$$26, index);
ZEPHIR_INIT_LNVAR(_62$$26);
ZEPHIR_CONCAT_VSV(_62$$26, attribute, " <> ?", &_61$$26);
zephir_array_update_multi(¶ms, &_62$$26 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
zephir_array_update_multi(¶ms, &except TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
}
}
ZEPHIR_CALL_METHOD(&_63, record, "getdirtystate", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_63, 0)) {
ZEPHIR_CALL_METHOD(&_64$$27, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_65$$27);
ZVAL_STRING(_65$$27, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, _64$$27, "getshared", NULL, 0, _65$$27);
zephir_check_temp_parameter(_65$$27);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_66$$27, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_66$$27, &_68$$27, &_67$$27, 0, 0, "phalcon/validation/validator/uniqueness.zep", 263);
for (
; zephir_hash_get_current_data_ex(_68$$27, (void**) &_69$$27, &_67$$27) == SUCCESS
; zephir_hash_move_forward_ex(_68$$27, &_67$$27)
) {
ZEPHIR_GET_HVALUE(primaryField, _69$$27);
ZEPHIR_CALL_METHOD(&_70$$28, this_ptr, "getcolumnnamereal", &_14, 0, record, primaryField);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_71$$28);
ZVAL_LONG(&_71$$28, index);
ZEPHIR_INIT_LNVAR(_72$$28);
ZEPHIR_CONCAT_VSV(_72$$28, _70$$28, " <> ?", &_71$$28);
zephir_array_update_multi(¶ms, &_72$$28 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
ZEPHIR_CALL_METHOD(&_73$$28, record, "readattribute", NULL, 0, primaryField);
zephir_check_call_status();
zephir_array_update_multi(¶ms, &_73$$28 TSRMLS_CC, SL("sa"), 3, SL("bind"));
index++;
}
}
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(exceptConditions))) {
ZEPHIR_INIT_VAR(_74$$29);
zephir_fast_join_str(_74$$29, SL(" OR "), exceptConditions TSRMLS_CC);
ZEPHIR_INIT_VAR(_75$$29);
ZEPHIR_CONCAT_SVS(_75$$29, "(", _74$$29, ")");
zephir_array_update_multi(¶ms, &_75$$29 TSRMLS_CC, SL("sa"), 3, SL("conditions"));
}
ZEPHIR_INIT_NVAR(_0);
zephir_array_fetch_string(&_76, params, SL("conditions"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/uniqueness.zep", 269 TSRMLS_CC);
zephir_fast_join_str(_0, SL(" AND "), _76 TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
_78 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_77, _78, "count", NULL, 0, params);
zephir_check_call_status();
RETURN_MM_BOOL(ZEPHIR_IS_LONG(_77, 0));
}
/**
* We have to cast values manually because parse_ini_file() has a poor implementation.
*
* @param mixed ini The array casted by `parse_ini_file`
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, _cast) {
zend_bool _5$$5, _6$$5, _8$$5, _9$$5;
HashTable *_1$$3;
HashPosition _0$$3;
zephir_fcall_cache_entry *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *ini, *key = NULL, *val = NULL, **_2$$3, *_3$$4 = NULL, *_7$$5, *_10$$5, *_11$$9, *_12$$9, _13$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &ini);
ZEPHIR_SEPARATE_PARAM(ini);
if (Z_TYPE_P(ini) == IS_ARRAY) {
zephir_is_iterable(ini, &_1$$3, &_0$$3, 1, 0, "phalcon/config/adapter/ini.zep", 134);
for (
; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zephir_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3);
ZEPHIR_GET_HVALUE(val, _2$$3);
ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "_cast", &_4, 135, val);
zephir_check_call_status();
zephir_array_update_zval(&ini, key, &_3$$4, PH_COPY | PH_SEPARATE);
}
zend_hash_destroy(_1$$3);
FREE_HASHTABLE(_1$$3);
}
if (Z_TYPE_P(ini) == IS_STRING) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "true");
if (!(_5$$5)) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "yes");
}
_6$$5 = _5$$5;
if (!(_6$$5)) {
ZEPHIR_INIT_VAR(_7$$5);
zephir_fast_strtolower(_7$$5, ini);
_6$$5 = ZEPHIR_IS_STRING_IDENTICAL(_7$$5, "on");
}
if (_6$$5) {
RETURN_MM_BOOL(1);
}
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "false");
if (!(_8$$5)) {
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "no");
}
_9$$5 = _8$$5;
if (!(_9$$5)) {
ZEPHIR_INIT_VAR(_10$$5);
zephir_fast_strtolower(_10$$5, ini);
_9$$5 = ZEPHIR_IS_STRING_IDENTICAL(_10$$5, "off");
}
if (_9$$5) {
RETURN_MM_BOOL(0);
}
if (ZEPHIR_IS_STRING_IDENTICAL(ini, "null")) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(ini)) {
ZEPHIR_INIT_VAR(_11$$9);
ZEPHIR_INIT_VAR(_12$$9);
ZEPHIR_SINIT_VAR(_13$$9);
ZVAL_STRING(&_13$$9, "/[.]+/", 0);
zephir_preg_match(_12$$9, &_13$$9, ini, _11$$9, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_12$$9)) {
RETURN_MM_DOUBLE(zephir_get_doubleval(ini));
} else {
RETURN_MM_LONG(zephir_get_intval(ini));
}
}
}
RETVAL_ZVAL(ini, 1, 0);
RETURN_MM();
}
