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