/**
* Magic method to pass variables to the views
*
*<code>
* $this->view->products = $products;
*</code>
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, __set) {
zval *key_param = NULL, *value;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &key_param, &value);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
zephir_update_property_array(this_ptr, SL("_viewParams"), key, value TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Constructor
*
* @param string $message
* @param string $usage
*/
PHP_METHOD(Zend_Console_Exception_RuntimeException, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *usage_param = NULL;
zval *message = NULL, *usage = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &message_param, &usage_param);
zephir_get_strval(message, message_param);
if (!usage_param) {
ZEPHIR_INIT_VAR(usage);
ZVAL_STRING(usage, "", 1);
} else {
zephir_get_strval(usage, usage_param);
}
zephir_update_property_this(this_ptr, SL("usage"), usage TSRMLS_CC);
ZEPHIR_CALL_PARENT(NULL, zend_console_exception_runtimeexception_ce, this_ptr, "__construct", NULL, message);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Mvc\Micro\LazyLoader constructor
*/
PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __construct) {
zval *definition_param = NULL;
zval *definition = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &definition_param);
if (UNEXPECTED(Z_TYPE_P(definition_param) != IS_STRING && Z_TYPE_P(definition_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'definition' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(definition_param) == IS_STRING)) {
zephir_get_strval(definition, definition_param);
} else {
ZEPHIR_INIT_VAR(definition);
ZVAL_EMPTY_STRING(definition);
}
zephir_update_property_this(this_ptr, SL("_definition"), definition TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Sets views directory. Depending of your platform, always add a trailing slash or backslash
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, setViewsDir) {
zval *viewsDir_param = NULL;
zval *viewsDir = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &viewsDir_param);
if (unlikely(Z_TYPE_P(viewsDir_param) != IS_STRING && Z_TYPE_P(viewsDir_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'viewsDir' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(viewsDir_param) == IS_STRING)) {
zephir_get_strval(viewsDir, viewsDir_param);
} else {
ZEPHIR_INIT_VAR(viewsDir);
ZVAL_EMPTY_STRING(viewsDir);
}
zephir_update_property_this(this_ptr, SL("_viewsDir"), viewsDir TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Sets an element in the registry
*/
PHP_METHOD(Phalcon_Registry, offsetSet) {
zval *offset_param = NULL, *value;
zval *offset = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &offset_param, &value);
if (unlikely(Z_TYPE_P(offset_param) != IS_STRING && Z_TYPE_P(offset_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'offset' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(offset_param) == IS_STRING)) {
zephir_get_strval(offset, offset_param);
} else {
ZEPHIR_INIT_VAR(offset);
ZVAL_EMPTY_STRING(offset);
}
zephir_update_property_array(this_ptr, SL("_data"), offset, value TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Sets a value in the session bag
*
*<code>
* $user->set('name', 'Kimbra');
*</code>
*
* @param string property
* @param string value
*/
PHP_METHOD(Phalcon_Session_Bag, set) {
int ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *value, *_0, *_1, *_2, *_3;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &property_param, &value);
if (unlikely(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_data"), property, value TSRMLS_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_session"), PH_NOISY_CC);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _1, "set", NULL, 0, _2, _3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Sets the domain default to search within when calls are made to gettext()
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDefaultDomain) {
zval *domain_param = NULL;
zval *domain = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &domain_param);
if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(domain_param) == IS_STRING)) {
zephir_get_strval(domain, domain_param);
} else {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
}
zephir_update_property_this(this_ptr, SL("_defaultDomain"), domain TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Writes the log to the stream itself
*
* @param string message
* @param int type
* @param int time
* @param array $context
*/
PHP_METHOD(Phalcon_Logger_Adapter_Syslog, logInternal) {
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL;
zval *context = NULL;
int type, time, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *time_param = NULL, *context_param = NULL, *appliedFormat = NULL, *_0 = NULL, *_1, *_2, *_3, *_4;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &message_param, &type_param, &time_param, &context_param);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
time = zephir_get_intval(time_param);
zephir_get_arrval(context, context_param);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getformatter", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, type);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, time);
ZEPHIR_CALL_METHOD(&appliedFormat, _0, "format", NULL, message, _1, _2, context);
zephir_check_call_status();
if (Z_TYPE_P(appliedFormat) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "The formatted message is not valid", "phalcon/logger/adapter/syslog.zep", 99);
return;
}
zephir_array_fetch_long(&_3, appliedFormat, 0, PH_NOISY | PH_READONLY, "phalcon/logger/adapter/syslog.zep", 102 TSRMLS_CC);
zephir_array_fetch_long(&_4, appliedFormat, 1, PH_NOISY | PH_READONLY, "phalcon/logger/adapter/syslog.zep", 102 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(NULL, "syslog", &_5, _3, _4);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Session\Bag constructor
*/
PHP_METHOD(Phalcon_Session_Bag, __construct) {
zval *name_param = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Sets the default controller name
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, setDefaultController) {
zval *controllerName_param = NULL;
zval *controllerName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &controllerName_param);
if (UNEXPECTED(Z_TYPE_P(controllerName_param) != IS_STRING && Z_TYPE_P(controllerName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controllerName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(controllerName_param) == IS_STRING)) {
zephir_get_strval(controllerName, controllerName_param);
} else {
ZEPHIR_INIT_VAR(controllerName);
ZVAL_EMPTY_STRING(controllerName);
}
zephir_update_property_this(getThis(), SL("_defaultHandler"), controllerName TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Translate\Adapter\Gettext constructor
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *options_param = NULL;
zval *options = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
options = options_param;
if (!((zephir_function_exists_ex(SS("gettext") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "This class requires the gettext extension for PHP", "phalcon/translate/adapter/gettext.zep", 60);
return;
}
ZEPHIR_CALL_PARENT(NULL, phalcon_translate_adapter_gettext_ce, this_ptr, "__construct", &_0, 449, options);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "prepareoptions", NULL, 0, options);
zephir_check_call_status();
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();
}
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);
}
PHP_METHOD(Yb_Std, newInstanceOf) {
zend_class_entry *_1$$3, *_4$$5, *_7$$6, *_11$$7, *_16$$8, *_22$$9;
long c = 0;
int ZEPHIR_LAST_CALL_STATUS;
zval *args = NULL;
zval *className_param = NULL, *args_param = NULL, *a = NULL, *_28, *_0$$3 = NULL, *_2$$4, *_3$$5 = NULL, *_5$$5, *_6$$6 = NULL, *_8$$6, *_9$$6, *_10$$7 = NULL, *_12$$7, *_13$$7, *_14$$7, *_15$$8 = NULL, *_17$$8, *_18$$8, *_19$$8, *_20$$8, *_21$$9 = NULL, *_23$$9, *_24$$9, *_25$$9, *_26$$9, *_27$$9;
zval *className = NULL, *_29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &className_param, &args_param);
zephir_get_strval(className, className_param);
if (!args_param) {
ZEPHIR_INIT_VAR(args);
array_init(args);
} else {
zephir_get_arrval(args, args_param);
}
c = zephir_fast_count_int(args TSRMLS_CC);
if (c < 1) {
zephir_fetch_safe_class(_0$$3, className);
_1$$3 = zend_fetch_class(Z_STRVAL_P(_0$$3), Z_STRLEN_P(_0$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _1$$3);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0);
zephir_check_call_status();
}
RETURN_MM();
}
if (c > 5) {
ZEPHIR_INIT_VAR(_2$$4);
object_init_ex(_2$$4, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, _2$$4, "__construct", NULL, 16, className);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_METHOD(_2$$4, "newinstanceargs", NULL, 18, args);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_CALL_FUNCTION(&a, "array_values", NULL, 22, args);
zephir_check_call_status();
do {
if (c == 1) {
zephir_fetch_safe_class(_3$$5, className);
_4$$5 = zend_fetch_class(Z_STRVAL_P(_3$$5), Z_STRLEN_P(_3$$5), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _4$$5);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
zephir_array_fetch_long(&_5$$5, a, 0, PH_NOISY | PH_READONLY, "yb/std.zep", 396 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, _5$$5);
zephir_check_call_status();
}
RETURN_MM();
}
if (c == 2) {
zephir_fetch_safe_class(_6$$6, className);
_7$$6 = zend_fetch_class(Z_STRVAL_P(_6$$6), Z_STRLEN_P(_6$$6), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _7$$6);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
zephir_array_fetch_long(&_8$$6, a, 0, PH_NOISY | PH_READONLY, "yb/std.zep", 398 TSRMLS_CC);
zephir_array_fetch_long(&_9$$6, a, 1, PH_NOISY | PH_READONLY, "yb/std.zep", 398 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, _8$$6, _9$$6);
zephir_check_call_status();
}
RETURN_MM();
}
if (c == 3) {
zephir_fetch_safe_class(_10$$7, className);
_11$$7 = zend_fetch_class(Z_STRVAL_P(_10$$7), Z_STRLEN_P(_10$$7), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _11$$7);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
zephir_array_fetch_long(&_12$$7, a, 0, PH_NOISY | PH_READONLY, "yb/std.zep", 400 TSRMLS_CC);
zephir_array_fetch_long(&_13$$7, a, 1, PH_NOISY | PH_READONLY, "yb/std.zep", 400 TSRMLS_CC);
zephir_array_fetch_long(&_14$$7, a, 2, PH_NOISY | PH_READONLY, "yb/std.zep", 400 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, _12$$7, _13$$7, _14$$7);
zephir_check_call_status();
}
RETURN_MM();
}
if (c == 4) {
zephir_fetch_safe_class(_15$$8, className);
_16$$8 = zend_fetch_class(Z_STRVAL_P(_15$$8), Z_STRLEN_P(_15$$8), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _16$$8);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
zephir_array_fetch_long(&_17$$8, a, 0, PH_NOISY | PH_READONLY, "yb/std.zep", 402 TSRMLS_CC);
zephir_array_fetch_long(&_18$$8, a, 1, PH_NOISY | PH_READONLY, "yb/std.zep", 402 TSRMLS_CC);
zephir_array_fetch_long(&_19$$8, a, 2, PH_NOISY | PH_READONLY, "yb/std.zep", 402 TSRMLS_CC);
zephir_array_fetch_long(&_20$$8, a, 3, PH_NOISY | PH_READONLY, "yb/std.zep", 402 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, _17$$8, _18$$8, _19$$8, _20$$8);
zephir_check_call_status();
}
RETURN_MM();
}
if (c == 5) {
zephir_fetch_safe_class(_21$$9, className);
_22$$9 = zend_fetch_class(Z_STRVAL_P(_21$$9), Z_STRLEN_P(_21$$9), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _22$$9);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
zephir_array_fetch_long(&_23$$9, a, 0, PH_NOISY | PH_READONLY, "yb/std.zep", 404 TSRMLS_CC);
zephir_array_fetch_long(&_24$$9, a, 1, PH_NOISY | PH_READONLY, "yb/std.zep", 404 TSRMLS_CC);
zephir_array_fetch_long(&_25$$9, a, 2, PH_NOISY | PH_READONLY, "yb/std.zep", 404 TSRMLS_CC);
zephir_array_fetch_long(&_26$$9, a, 3, PH_NOISY | PH_READONLY, "yb/std.zep", 404 TSRMLS_CC);
zephir_array_fetch_long(&_27$$9, a, 4, PH_NOISY | PH_READONLY, "yb/std.zep", 404 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, _23$$9, _24$$9, _25$$9, _26$$9, _27$$9);
zephir_check_call_status();
}
RETURN_MM();
}
} while(0);
ZEPHIR_INIT_VAR(_28);
object_init_ex(_28, yb_exception_ce);
ZEPHIR_INIT_VAR(_29);
ZEPHIR_CONCAT_SV(_29, "Fail to fetch a new instance of class: ", className);
ZEPHIR_CALL_METHOD(NULL, _28, "__construct", NULL, 2, _29);
zephir_check_call_status();
zephir_throw_exception_debug(_28, "yb/std.zep", 407 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
PHP_METHOD(Yb_View_Redirect, run) {
zend_bool redirectDataAsQueries = 0, _7;
zval *redirectUrl = NULL, *_4 = NULL, *_11;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *data_param = NULL, *options_param = NULL, *_0 = NULL, *_2 = NULL, *_3 = NULL, *_5 = NULL, *_6 = NULL, _8$$4, *_9$$4, *_10$$4 = NULL;
zval *data = NULL, *options = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &data_param, &options_param);
zephir_get_arrval(data, data_param);
zephir_get_arrval(options, options_param);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "redirectUrl", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_CE_STATIC(&_0, yb_std_ce, "valueat", &_1, 5, options, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
zephir_get_strval(_4, _0);
ZEPHIR_CPY_WRT(redirectUrl, _4);
if (unlikely(zephir_fast_strlen_ev(redirectUrl) < 1)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(yb_view_exception_ce, "Missing option: redirectUrl", "yb/view/redirect.zep", 14);
return;
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "redirectDataAsQueries", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_BOOL(_3, 0);
ZEPHIR_CALL_CE_STATIC(&_6, yb_std_ce, "valueat", &_1, 5, options, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
redirectDataAsQueries = zephir_get_boolval(_6);
_7 = redirectDataAsQueries;
if (_7) {
_7 = zephir_fast_count_int(data TSRMLS_CC) > 0;
}
if (_7) {
ZEPHIR_SINIT_VAR(_8$$4);
ZVAL_STRING(&_8$$4, "?", 0);
ZEPHIR_INIT_VAR(_9$$4);
zephir_fast_strpos(_9$$4, redirectUrl, &_8$$4, 0 );
if (ZEPHIR_IS_FALSE_IDENTICAL(_9$$4)) {
zephir_concat_self_str(&redirectUrl, "?", sizeof("?")-1 TSRMLS_CC);
} else {
zephir_concat_self_str(&redirectUrl, "&", sizeof("&")-1 TSRMLS_CC);
}
ZEPHIR_CALL_FUNCTION(&_10$$4, "http_build_query", NULL, 99, data);
zephir_check_call_status();
zephir_concat_self(&redirectUrl, _10$$4 TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_11);
ZEPHIR_CONCAT_SV(_11, "Location: ", redirectUrl);
ZEPHIR_CALL_FUNCTION(NULL, "header", NULL, 93, _11);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param long lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, save) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *memcache = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp = NULL, *tt1 = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *keys = NULL, *isBuffering = NULL, *_0$$4, *_1$$16, *_2$$16 = NULL, *_3$$16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (!(zephir_is_true(keyName))) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
_0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_VV(lastKey, _0$$4, keyName);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/libmemcached.zep", 192);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(memcache);
zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
if (!(zephir_is_true(content))) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
}
if (!(zephir_is_true(lifetime))) {
ZEPHIR_OBS_VAR(tmp);
zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(tmp))) {
ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
if (zephir_is_numeric(cachedContent)) {
ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, cachedContent, tt1);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, preparedContent, tt1);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_1$$16);
object_init_ex(_1$$16, phalcon_cache_exception_ce);
ZEPHIR_CALL_METHOD(&_2$$16, memcache, "getresultcode", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3$$16);
ZEPHIR_CONCAT_SV(_3$$16, "Failed storing data in memcached, error code: ", _2$$16);
ZEPHIR_CALL_METHOD(NULL, _1$$16, "__construct", NULL, 9, _3$$16);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$16, "phalcon/cache/backend/libmemcached.zep", 238 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(specialKey);
if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/libmemcached.zep", 244);
return;
}
if (!ZEPHIR_IS_STRING(specialKey, "")) {
ZEPHIR_CALL_METHOD(&keys, memcache, "get", NULL, 0, specialKey);
zephir_check_call_status();
if (Z_TYPE_P(keys) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(keys);
array_init(keys);
}
if (!(zephir_array_isset(keys, lastKey))) {
zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, memcache, "set", NULL, 0, specialKey, keys);
zephir_check_call_status();
}
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Session\Adapter\Memcache constructor
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct) {
zephir_fcall_cache_entry *_11 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *lifetime, *_0 = NULL, *_1, *_3, *_5 = NULL;
zval *options = NULL, *_2, *_4, *_6, *_7, *_8, *_9, *_10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(options);
array_init(options);
} else {
zephir_get_arrval(options, options_param);
}
if (!(zephir_array_isset_string(options, SS("host")))) {
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "127.0.0.1", 1);
zephir_array_update_string(&options, SL("host"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("port")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 11211);
zephir_array_update_string(&options, SL("port"), &_0, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SS("persistent")))) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 0);
zephir_array_update_string(&options, SL("persistent"), &_0, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_VAR(lifetime);
if (zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_cache_backend_memcache_ce);
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3);
zephir_read_property_this(&_3, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_2, SL("lifetime"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 318, _2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 321, _1, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_memcache"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_4, this_ptr);
ZEPHIR_INIT_VAR(_5);
ZVAL_STRING(_5, "open", 1);
zephir_array_fast_append(_4, _5);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "close", 1);
zephir_array_fast_append(_6, _5);
ZEPHIR_INIT_VAR(_7);
zephir_create_array(_7, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_7, this_ptr);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "read", 1);
zephir_array_fast_append(_7, _5);
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_8, this_ptr);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "write", 1);
zephir_array_fast_append(_8, _5);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "destroy", 1);
zephir_array_fast_append(_9, _5);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "gc", 1);
zephir_array_fast_append(_10, _5);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 410, _4, _6, _7, _8, _9, _10);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", &_11, 411, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Initialize the metadata for certain table
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize) {
zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *key, *table, *schema, *strategy = NULL, *className = NULL, *metaData = NULL, *data = NULL, *modelMetadata = NULL, *modelColumnMap = NULL, *dependencyInjector = NULL, *keyName = NULL, *prefixKey = NULL, *_3, *_0$$8, *_1$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &model, &key, &table, &schema);
ZEPHIR_INIT_VAR(strategy);
ZVAL_NULL(strategy);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
ZEPHIR_OBS_VAR(metaData);
zephir_read_property_this(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(metaData, key))) {
ZEPHIR_INIT_VAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "meta-", key);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_metaData"), key, data TSRMLS_CC);
} else {
if ((zephir_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&modelMetadata, model, "metadata", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(modelMetadata) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0$$8);
object_init_ex(_0$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_1$$8);
ZEPHIR_CONCAT_SV(_1$$8, "Invalid meta-data for model ", className);
ZEPHIR_CALL_METHOD(NULL, _0$$8, "__construct", NULL, 9, _1$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$8, "phalcon/mvc/model/metadata.zep", 122 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&modelMetadata, strategy, "getmetadata", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_metaData"), key, modelMetadata TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelMetadata);
zephir_check_call_status();
}
}
}
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(keyName);
zephir_fast_strtolower(keyName, className);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (zephir_array_isset(_3, keyName)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_NVAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "map-", keyName);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, data TSRMLS_CC);
RETURN_MM_NULL();
}
if (Z_TYPE_P(strategy) != IS_OBJECT) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&modelColumnMap, strategy, "getcolumnmaps", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, modelColumnMap TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelColumnMap);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* 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();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int ZEPHIR_LAST_CALL_STATUS, _0$$5;
zval *pattern, pattern_sub, *paths = NULL, paths_sub, __$null, moduleName, controllerName, actionName, parts, routePaths, realClassName, namespaceName, pcrePattern, compiledPattern, extracted, _1$$10, _2$$19, _3$$19;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&pattern_sub);
ZVAL_UNDEF(&paths_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&moduleName);
ZVAL_UNDEF(&controllerName);
ZVAL_UNDEF(&actionName);
ZVAL_UNDEF(&parts);
ZVAL_UNDEF(&routePaths);
ZVAL_UNDEF(&realClassName);
ZVAL_UNDEF(&namespaceName);
ZVAL_UNDEF(&pcrePattern);
ZVAL_UNDEF(&compiledPattern);
ZVAL_UNDEF(&extracted);
ZVAL_UNDEF(&_1$$10);
ZVAL_UNDEF(&_2$$19);
ZVAL_UNDEF(&_3$$19);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = &paths_sub;
paths = &__$null;
}
if (Z_TYPE_P(pattern) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270);
return;
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(&moduleName);
ZVAL_NULL(&moduleName);
ZEPHIR_INIT_VAR(&controllerName);
ZVAL_NULL(&controllerName);
ZEPHIR_INIT_VAR(&actionName);
ZVAL_NULL(&actionName);
ZEPHIR_INIT_VAR(&parts);
zephir_fast_explode_str(&parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0$$5 = zephir_fast_count_int(&parts TSRMLS_CC);
if (_0$$5 == 3) {
ZEPHIR_OBS_NVAR(&moduleName);
zephir_array_fetch_long(&moduleName, &parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC);
ZEPHIR_OBS_NVAR(&controllerName);
zephir_array_fetch_long(&controllerName, &parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC);
ZEPHIR_OBS_NVAR(&actionName);
zephir_array_fetch_long(&actionName, &parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC);
break;
}
if (_0$$5 == 2) {
ZEPHIR_OBS_NVAR(&controllerName);
zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC);
ZEPHIR_OBS_NVAR(&actionName);
zephir_array_fetch_long(&actionName, &parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC);
break;
}
if (_0$$5 == 1) {
ZEPHIR_OBS_NVAR(&controllerName);
zephir_array_fetch_long(&controllerName, &parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(&routePaths);
array_init(&routePaths);
if (Z_TYPE_P(&moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(&controllerName) != IS_NULL) {
if (zephir_memnstr_str(&controllerName, SL("\\"), "test/router/route.zep", 310)) {
ZEPHIR_INIT_VAR(&realClassName);
zephir_get_class_ns(&realClassName, &controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&namespaceName);
zephir_get_ns_class(&namespaceName, &controllerName, 0 TSRMLS_CC);
if (zephir_is_true(&namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(&realClassName, &controllerName);
}
ZEPHIR_INIT_VAR(&_1$$10);
zephir_uncamelize(&_1$$10, &realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1$$10, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(&actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(&routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(&routePaths);
array_init(&routePaths);
}
if (Z_TYPE_P(&routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342);
return;
}
if (!(zephir_start_with_str(pattern, SL("#")))) {
if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) {
ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, 0, pattern);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&pcrePattern);
zephir_array_fetch_long(&pcrePattern, &extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_2$$19);
zephir_array_fetch_long(&_3$$19, &extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC);
zephir_fast_array_merge(&_2$$19, &routePaths, &_3$$19 TSRMLS_CC);
ZEPHIR_CPY_WRT(&routePaths, &_2$$19);
} else {
ZEPHIR_CPY_WRT(&pcrePattern, pattern);
}
ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, 0, &pcrePattern);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(&compiledPattern, pattern);
}
zephir_update_property_zval(this_ptr, SL("_pattern"), pattern);
zephir_update_property_zval(this_ptr, SL("_compiledPattern"), &compiledPattern);
zephir_update_property_zval(this_ptr, SL("_paths"), &routePaths);
ZEPHIR_MM_RESTORE();
}
/**
* Get an object from the container
*
* @param string offset
* @throws \Pdm\Di\Exception\ServiceNotFound
* @return mixed
*/
PHP_METHOD(Pdm_Di_Container, get) {
zend_class_entry *_3, *_4;
int ZEPHIR_LAST_CALL_STATUS;
zval *offset_param = NULL, *service, *className, *instance, *_0, *_1;
zval *offset = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &offset_param);
if (unlikely(Z_TYPE_P(offset_param) != IS_STRING && Z_TYPE_P(offset_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'offset' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(offset_param) == IS_STRING)) {
offset = offset_param;
} else {
ZEPHIR_INIT_VAR(offset);
ZVAL_EMPTY_STRING(offset);
}
ZEPHIR_OBS_VAR(service);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("container"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&service, _0, offset, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, pdm_di_exception_servicenotfound_ce);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VS(_2, offset, " is not defined.");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "pdm/di/container.zep", 142 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(service) == IS_STRING) {
_3 = zend_fetch_class(Z_STRVAL_P(service), Z_STRLEN_P(service), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(return_value, _3);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL);
zephir_check_call_status();
}
RETURN_MM();
}
if (Z_TYPE_P(service) == IS_ARRAY) {
ZEPHIR_OBS_VAR(className);
if (zephir_array_isset_string_fetch(&className, service, SS("className"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(instance);
_4 = zend_fetch_class(Z_STRVAL_P(className), Z_STRLEN_P(className), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(instance, _4);
if (zephir_has_constructor(instance TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, instance, "__construct", NULL, service);
zephir_check_call_status();
}
if (Z_TYPE_P(instance) == IS_OBJECT) {
if (zephir_instance_of_ev(instance, pdm_di_injectionawareinterface_ce TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, instance, "setdi", NULL, this_ptr);
zephir_check_call_status();
}
}
RETURN_CCTOR(instance);
}
}
if (Z_TYPE_P(service) == IS_OBJECT) {
if (zephir_instance_of_ev(service, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_RETURN_CALL_ZVAL_FUNCTION(service, NULL);
zephir_check_call_status();
RETURN_MM();
}
}
RETURN_CCTOR(service);
}
/**
* 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();
}
/**
* Create internal connection to redis
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) {
zend_bool _0, _1, _2, _5, _7;
zval *options = NULL, *redis = NULL, *persistent = NULL, *success = NULL, *host = NULL, *port = NULL, *auth = NULL, *index = NULL, *timeout = NULL, *_6, *_3$$6, *_4$$6;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(redis);
object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC));
if (zephir_has_constructor(redis TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(host);
_0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));
if (!(_0)) {
ZEPHIR_OBS_VAR(port);
_0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));
}
_1 = _0;
if (!(_1)) {
ZEPHIR_OBS_VAR(persistent);
_1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));
}
_2 = _1;
if (!(_2)) {
ZEPHIR_OBS_VAR(timeout);
_2 = !(zephir_array_isset_string_fetch(&timeout, options, SS("timeout"), 0 TSRMLS_CC));
}
if (_2) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 120);
return;
}
if (zephir_is_true(persistent)) {
ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, 0, host, port, timeout);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, 0, host, port, timeout);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_3$$6);
object_init_ex(_3$$6, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_CONCAT_SVSV(_4$$6, "Could not connect to the Redisd server ", host, ":", port);
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$6, "phalcon/cache/backend/redis.zep", 130 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(auth);
_5 = zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC);
if (_5) {
zephir_array_fetch_string(&_6, options, SL("auth"), PH_NOISY | PH_READONLY, "phalcon/cache/backend/redis.zep", 133 TSRMLS_CC);
_5 = !(ZEPHIR_IS_EMPTY(_6));
}
if (_5) {
ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, 0, auth);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed to authenticate with the Redisd server", "phalcon/cache/backend/redis.zep", 137);
return;
}
}
ZEPHIR_OBS_VAR(index);
_7 = zephir_array_isset_string_fetch(&index, options, SS("index"), 0 TSRMLS_CC);
if (_7) {
_7 = ZEPHIR_GT_LONG(index, 0);
}
if (_7) {
ZEPHIR_CALL_METHOD(&success, redis, "select", NULL, 0, index);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redis server selected database failed", "phalcon/cache/backend/redis.zep", 145);
return;
}
}
zephir_update_property_this(getThis(), SL("_redis"), redis TSRMLS_CC);
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();
}
/**
* Phalcon\Session\Adapter\Libmemcached constructor
*
* @throws \Phalcon\Session\Exception
*/
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) {
zephir_fcall_cache_entry *_13 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *servers = NULL, *client = NULL, *lifetime = NULL, *prefix = NULL, *statsKey = NULL, *persistentId = NULL, *_0 = NULL, *_1 = NULL, *_2, *_4, *_7 = NULL;
zval *options = NULL, *_3, *_5, *_6, *_8, *_9, *_10, *_11, *_12;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
zephir_get_arrval(options, options_param);
ZEPHIR_OBS_VAR(servers);
if (!(zephir_array_isset_string_fetch(&servers, options, SS("servers"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No servers given in options", "phalcon/session/adapter/libmemcached.zep", 76);
return;
}
ZEPHIR_OBS_VAR(client);
if (!(zephir_array_isset_string_fetch(&client, options, SS("client"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(client);
ZVAL_NULL(client);
}
ZEPHIR_OBS_VAR(lifetime);
if (!(zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(lifetime);
ZVAL_LONG(lifetime, 8600);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 2592000);
ZEPHIR_CALL_FUNCTION(&_1, "min", NULL, 436, lifetime, _0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_lifetime"), _1 TSRMLS_CC);
ZEPHIR_OBS_VAR(prefix);
if (!(zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(prefix);
ZVAL_NULL(prefix);
}
ZEPHIR_OBS_VAR(statsKey);
if (!(zephir_array_isset_string_fetch(&statsKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(statsKey);
ZVAL_STRING(statsKey, "", 1);
}
ZEPHIR_OBS_VAR(persistentId);
if (!(zephir_array_isset_string_fetch(&persistentId, options, SS("persistent_id"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(persistentId);
ZVAL_STRING(persistentId, "phalcon-session", 1);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_4);
zephir_read_property_this(&_4, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_3, SL("lifetime"), &_4, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 334, _3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5);
zephir_create_array(_5, 5, 0 TSRMLS_CC);
zephir_array_update_string(&_5, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("client"), &client, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_5, SL("persistent_id"), &persistentId, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 335, _2, _5);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_libmemcached"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_6);
zephir_create_array(_6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "open", 1);
zephir_array_fast_append(_6, _7);
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_8, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "close", 1);
zephir_array_fast_append(_8, _7);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "read", 1);
zephir_array_fast_append(_9, _7);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "write", 1);
zephir_array_fast_append(_10, _7);
ZEPHIR_INIT_VAR(_11);
zephir_create_array(_11, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_11, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "destroy", 1);
zephir_array_fast_append(_11, _7);
ZEPHIR_INIT_VAR(_12);
zephir_create_array(_12, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_12, this_ptr);
ZEPHIR_INIT_NVAR(_7);
ZVAL_STRING(_7, "gc", 1);
zephir_array_fast_append(_12, _7);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 437, _6, _8, _9, _10, _11, _12);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, this_ptr, "__construct", &_13, 438, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _0, ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(pattern) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270);
return;
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0 = zephir_fast_count_int(parts TSRMLS_CC);
if (_0 == 3) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC);
break;
}
if (_0 == 2) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC);
break;
}
if (_0 == 1) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if (Z_TYPE_P(moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(controllerName) != IS_NULL) {
if (zephir_memnstr_str(controllerName, SL("\\"), "test/router/route.zep", 310)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(namespaceName);
zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_1);
zephir_uncamelize(_1, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if (Z_TYPE_P(routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342);
return;
}
if (!(zephir_start_with_str(pattern, SL("#")))) {
if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) {
ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, pattern);
zephir_check_call_status();
ZEPHIR_OBS_VAR(pcrePattern);
zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_1);
zephir_array_fetch_long(&_2, extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC);
zephir_fast_array_merge(_1, &(routePaths), &(_2) TSRMLS_CC);
ZEPHIR_CPY_WRT(routePaths, _1);
} else {
ZEPHIR_CPY_WRT(pcrePattern, pattern);
}
ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, pcrePattern);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(compiledPattern, pattern);
}
zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Di\FactoryDefault\CLI constructor
*/
PHP_METHOD(Phalcon_Di_FactoryDefault_Cli, __construct) {
zval *_2 = NULL, *_3 = NULL, *_4 = NULL, _5 = zval_used_for_init;
zval *_1;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL, *_6 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_PARENT(NULL, phalcon_di_factorydefault_cli_ce, this_ptr, "__construct", &_0, 144);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 10, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "Phalcon\\CLI\\Router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_VAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("router"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "dispatcher", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\CLI\\Dispatcher", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("dispatcher"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "modelsManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("modelsManager"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\MetaData\\Memory", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("modelsMetadata"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("filter"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "escaper", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Escaper", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("escaper"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "annotations", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Annotations\\Adapter\\Memory", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("annotations"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "security", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Security", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("security"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "eventsManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Events\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("eventsManager"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_di_service_ce);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "transactionManager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Transaction\\Manager", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_BOOL(&_5, 1);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 139, _3, _4, &_5);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_array_update_string(&_1, SL("transactionManager"), &_2, PH_COPY | PH_SEPARATE);
zephir_update_property_this(this_ptr, SL("_services"), _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _1;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted, _0, *_2 = NULL, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
ZEPHIR_CPY_WRT(paths, ZEPHIR_GLOBAL(global_null));
}
if ((Z_TYPE_P(pattern) != IS_STRING)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The pattern must be string");
return;
}
if ((Z_TYPE_P(paths) != IS_NULL)) {
if ((Z_TYPE_P(paths) == IS_STRING)) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "::", 0);
ZEPHIR_INIT_VAR(parts);
zephir_call_func_p2(parts, "explode", &_0, paths);
do {
_1 = zephir_fast_count_int(parts TSRMLS_CC);
if ((_1 == 3)) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY TSRMLS_CC);
break;
}
if ((_1 == 2)) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY TSRMLS_CC);
break;
}
if ((_1 == 1)) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if ((Z_TYPE_P(moduleName) != IS_NULL)) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if ((Z_TYPE_P(controllerName) != IS_NULL)) {
if (zephir_memnstr_str(controllerName, SL("\\"), "test/router/route.zep", 313)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_call_func_p1(realClassName, "get_class_ns", controllerName);
ZEPHIR_INIT_VAR(namespaceName);
zephir_call_func_p1(namespaceName, "get_ns_class", controllerName);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_2);
zephir_uncamelize(_2, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_2, PH_COPY | PH_SEPARATE);
}
if ((Z_TYPE_P(actionName) != IS_NULL)) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if ((Z_TYPE_P(routePaths) != IS_ARRAY)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The route contains invalid paths");
return;
}
if (!(zephir_start_with_str(pattern, SL("#")))) {
if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 351)) {
ZEPHIR_INIT_VAR(extracted);
zephir_call_method_p1(extracted, this_ptr, "extractnamedparams", pattern);
ZEPHIR_OBS_VAR(pcrePattern);
zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_INIT_NVAR(_2);
zephir_array_fetch_long(&_3, extracted, 1, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_fast_array_merge(_2, &(routePaths), &(_3) TSRMLS_CC);
ZEPHIR_CPY_WRT(routePaths, _2);
} else {
ZEPHIR_CPY_WRT(pcrePattern, pattern);
}
ZEPHIR_INIT_VAR(compiledPattern);
zephir_call_method_p1(compiledPattern, this_ptr, "compilepattern", pcrePattern);
} else {
ZEPHIR_CPY_WRT(compiledPattern, pattern);
}
zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param long lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, save) {
int ZEPHIR_LAST_CALL_STATUS;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer = NULL, *prefixedKey = NULL, *lastKey = NULL, *prefix, *frontend, *redis = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp, *tt1 = NULL, *success = NULL, *options, *specialKey, *isBuffering = NULL, _0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer) {
stopBuffer = ZEPHIR_GLOBAL(global_true);
}
if (!(zephir_is_true(keyName))) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 5);
ZEPHIR_INIT_VAR(prefixedKey);
zephir_substr(prefixedKey, lastKey, 5 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
} else {
ZEPHIR_OBS_VAR(prefix);
zephir_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, prefix, keyName);
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_SV(lastKey, "_PHCR", prefixedKey);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/redis.zep", 185);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(redis);
zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);
if (Z_TYPE_P(redis) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(redis);
zephir_read_property_this(&redis, this_ptr, SL("_redis"), PH_NOISY_CC);
}
if (!(zephir_is_true(content))) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, cachedContent);
zephir_check_call_status();
}
if (!(zephir_is_true(lifetime))) {
ZEPHIR_OBS_VAR(tmp);
zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(tmp))) {
ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(tt1, tmp);
}
} else {
ZEPHIR_CPY_WRT(tt1, lifetime);
}
if (zephir_is_numeric(cachedContent)) {
ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, cachedContent);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, redis, "set", NULL, lastKey, preparedContent);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in redis", "phalcon/cache/backend/redis.zep", 231);
return;
}
ZEPHIR_CALL_METHOD(NULL, redis, "settimeout", NULL, lastKey, tt1);
zephir_check_call_status();
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
if (!(zephir_array_isset_string(options, SS("statsKey")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 239);
return;
}
ZEPHIR_OBS_VAR(specialKey);
zephir_array_fetch_string(&specialKey, options, SL("statsKey"), PH_NOISY, "phalcon/cache/backend/redis.zep", 242 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, redis, "sadd", NULL, specialKey, prefixedKey);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(stopBuffer)) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
zephir_update_property_this(this_ptr, SL("_started"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_SpectralNorm, Au) {
zephir_fcall_cache_entry *_11 = NULL, *_13 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_9 = NULL;
zend_bool _0, _3;
zval *n_param = NULL, *u, *v, *_6 = NULL, *_7 = NULL, *_8 = NULL, *_10 = NULL, *_12 = NULL;
int n, t, i, j, _1, _2, _4, _5, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &n_param, &u, &v);
n = zephir_get_intval(n_param);
if (!(zephir_instance_of_ev(u, spl_ce_SplFixedArray TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_STR(spl_ce_InvalidArgumentException, "Parameter 'u' must be an instance of 'SplFixedArray'");
return;
}
if (!(zephir_instance_of_ev(v, spl_ce_SplFixedArray TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_STR(spl_ce_InvalidArgumentException, "Parameter 'v' must be an instance of 'SplFixedArray'");
return;
}
_2 = (n - 1);
_1 = 0;
_0 = 0;
if ((_1 <= _2)) {
while (1) {
if (_0) {
_1++;
if (!((_1 <= _2))) {
break;
}
} else {
_0 = 1;
}
i = _1;
t = 0;
_5 = (n - 1);
_4 = 0;
_3 = 0;
if ((_4 <= _5)) {
while (1) {
if (_3) {
_4++;
if (!((_4 <= _5))) {
break;
}
} else {
_3 = 1;
}
j = _4;
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, i);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, j);
ZEPHIR_CALL_METHOD(&_6, this_ptr, "ax", &_9, _7, _8);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, j);
ZEPHIR_CALL_METHOD(&_10, u, "offsetget", &_11, _7);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_12);
mul_function(_12, _6, _10 TSRMLS_CC);
t += zephir_get_numberval(_12);
}
}
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, i);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, t);
ZEPHIR_CALL_METHOD(NULL, v, "offsetset", &_13, _7, _8);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
