/**
* Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
* This method registers a shutdown function to rollback active connections
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get) {
zval *_2$$4;
int ZEPHIR_LAST_CALL_STATUS;
zval *autoBegin_param = NULL, *_0, *_4, *_1$$3, *_3$$4;
zend_bool autoBegin;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &autoBegin_param);
if (!autoBegin_param) {
autoBegin = 1;
} else {
autoBegin = zephir_get_boolval(autoBegin_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_rollbackPendent"), PH_NOISY_CC);
if (zephir_is_true(_1$$3)) {
ZEPHIR_INIT_VAR(_2$$4);
zephir_create_array(_2$$4, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_2$$4, this_ptr);
ZEPHIR_INIT_VAR(_3$$4);
ZVAL_STRING(_3$$4, "rollbackPendent", 1);
zephir_array_fast_append(_2$$4, _3$$4);
ZEPHIR_CALL_FUNCTION(NULL, "register_shutdown_function", NULL, 351, _2$$4);
zephir_check_call_status();
}
if (1) {
zephir_update_property_this(this_ptr, SL("_initialized"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_initialized"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
}
ZEPHIR_INIT_VAR(_4);
if (autoBegin) {
ZVAL_BOOL(_4, 1);
} else {
ZVAL_BOOL(_4, 0);
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getorcreatetransaction", NULL, 0, _4);
zephir_check_call_status();
RETURN_MM();
}
/**
* Adds default messages to validators
*/
PHP_METHOD(Phalcon_Validation, setDefaultMessages) {
zval *messages_param = NULL, *defaultMessages, *_0;
zval *messages = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &messages_param);
if (!messages_param) {
ZEPHIR_INIT_VAR(messages);
array_init(messages);
} else {
zephir_get_arrval(messages, messages_param);
}
ZEPHIR_INIT_VAR(defaultMessages);
zephir_create_array(defaultMessages, 23, 0 TSRMLS_CC);
add_assoc_stringl_ex(defaultMessages, SS("Alnum"), SL("Field :field must contain only letters and numbers"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Alpha"), SL("Field :field must contain only letters"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Between"), SL("Field :field must be within the range of :min to :max"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Confirmation"), SL("Field :field must be the same as :with"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Digit"), SL("Field :field must be numeric"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Email"), SL("Field :field must be an email address"), 1);
add_assoc_stringl_ex(defaultMessages, SS("ExclusionIn"), SL("Field :field must not be a part of list: :domain"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileEmpty"), SL("Field :field must not be empty"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileIniSize"), SL("File :field exceeds the maximum file size"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileMaxResolution"), SL("File :field must not exceed :max resolution"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileMinResolution"), SL("File :field must be at least :min resolution"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileSize"), SL("File :field exceeds the size of :max"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileType"), SL("File :field must be of type: :types"), 1);
add_assoc_stringl_ex(defaultMessages, SS("FileValid"), SL("Field :field is not valid"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Identical"), SL("Field :field does not have the expected value"), 1);
add_assoc_stringl_ex(defaultMessages, SS("InclusionIn"), SL("Field :field must be a part of list: :domain"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Numericality"), SL("Field :field does not have a valid numeric format"), 1);
add_assoc_stringl_ex(defaultMessages, SS("PresenceOf"), SL("Field :field is required"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Regex"), SL("Field :field does not match the required format"), 1);
add_assoc_stringl_ex(defaultMessages, SS("TooLong"), SL("Field :field must not exceed :max characters long"), 1);
add_assoc_stringl_ex(defaultMessages, SS("TooShort"), SL("Field :field must be at least :min characters long"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Uniqueness"), SL("Field :field must be unique"), 1);
add_assoc_stringl_ex(defaultMessages, SS("Url"), SL("Field :field must be a url"), 1);
ZEPHIR_INIT_VAR(_0);
zephir_fast_array_merge(_0, &(defaultMessages), &(messages) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_defaultMessages"), _0 TSRMLS_CC);
RETURN_MM_MEMBER(this_ptr, "_defaultMessages");
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addResource) {
zval *_0;
zval *handler_param = NULL, *prefix_param = NULL;
zval *handler = NULL, *prefix = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &handler_param, &prefix_param);
if (unlikely(Z_TYPE_P(handler_param) != IS_STRING && Z_TYPE_P(handler_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'handler' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(handler_param) == IS_STRING)) {
zephir_get_strval(handler, handler_param);
} else {
ZEPHIR_INIT_VAR(handler);
ZVAL_EMPTY_STRING(handler);
}
if (!prefix_param) {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
} else {
if (unlikely(Z_TYPE_P(prefix_param) != IS_STRING && Z_TYPE_P(prefix_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'prefix' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(prefix_param) == IS_STRING)) {
zephir_get_strval(prefix, prefix_param);
} else {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
}
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0, prefix);
zephir_array_fast_append(_0, handler);
zephir_update_property_array_append(this_ptr, SL("_handlers"), _0 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_processed"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_THIS();
}
PHP_METHOD(Test_NativeArray, testArray16) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_assoc_double_ex(&a, SL("hello1"), 1.0);
add_assoc_double_ex(&a, SL("hello2"), 2.0);
add_assoc_double_ex(&a, SL("hello3"), 3.0);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_Issue1521, test) {
zval _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
zephir_create_array(&_0, 2, 0 TSRMLS_CC);
add_assoc_stringl_ex(&_0, SL("merchantNumber"), SL("0818217122"));
add_assoc_stringl_ex(&_0, SL("zero"), SL("0"));
zephir_update_property_zval(this_ptr, SL("params"), &_0);
RETURN_MM_MEMBER(getThis(), "params");
}
PHP_METHOD(Test_NativeArray, testArray18) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(&a, SL("hello1"), SL("a"));
add_assoc_stringl_ex(&a, SL("hello2"), SL("b"));
add_assoc_stringl_ex(&a, SL("hello3"), SL("c"));
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, testArray22) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_index_long(&a, 0, 4);
add_index_long(&a, 1, 5);
add_index_long(&a, 2, 6);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, testArray29) {
long b = 0;
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
b = 1;
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 1, 0 TSRMLS_CC);
add_index_stringl(&a, b, SL("hello"));
RETURN_CCTOR(&a);
}
void zephir_init_static_properties_Ansi_Color(TSRMLS_D) {
zval *_1;
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_update_static_property_ce(ansi_color_ce, SL("_fg_arr"), &_0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
add_index_long(_1, 1, 1);
zephir_update_static_property_ce(ansi_color_ce, SL("_bg_arr"), &_1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
void zephir_init_static_properties_Cake_Core_Configure(TSRMLS_D) {
zval *_1;
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_update_static_property_ce(cake_core_configure_ce, SL("_engines"), &_0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
add_assoc_long_ex(_1, SS("debug"), 0);
zephir_update_static_property_ce(cake_core_configure_ce, SL("_values"), &_1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_NativeArray, testArray13) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_index_stringl(&a, 1, SL("hello1"));
add_index_stringl(&a, 2, SL("hello2"));
add_index_stringl(&a, 3, SL("hello3"));
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_Fibonnaci, fibArray) {
int i = 0, n = 0, k = 0, j = 0;
zval fib, a, b, c, _0;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&fib);
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&b);
ZVAL_UNDEF(&c);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&fib);
zephir_create_array(&fib, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_0);
ZVAL_LONG(&_0, 0);
zephir_array_fast_append(&fib, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_LONG(&_0, 1);
zephir_array_fast_append(&fib, &_0);
i = 2;
n = 10;
while (1) {
if (!(i < n)) {
break;
}
k = (i - 1);
j = (i - 2);
zephir_array_fetch_long(&a, &fib, k, PH_NOISY | PH_READONLY, "test/fibonnaci.zep", 51 TSRMLS_CC);
zephir_array_fetch_long(&b, &fib, j, PH_NOISY | PH_READONLY, "test/fibonnaci.zep", 52 TSRMLS_CC);
ZEPHIR_INIT_NVAR(&c);
zephir_add_function(&c, &a, &b);
zephir_array_update_long(&fib, i, &c, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
i++;
}
RETURN_CCTOR(fib);
}
PHP_METHOD(Test_NativeArray, testArray5) {
zval __$null, a;
zval *this_ptr = getThis();
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
zephir_array_fast_append(&a, &__$null);
zephir_array_fast_append(&a, &__$null);
zephir_array_fast_append(&a, &__$null);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, testArray17) {
zval __$null, a;
zval *this_ptr = getThis();
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
zephir_array_update_string(&a, SL("hello1"), &__$null, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&a, SL("hello2"), &__$null, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&a, SL("hello3"), &__$null, PH_COPY | PH_SEPARATE);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, testArray21) {
zval __$null, a;
zval *this_ptr = getThis();
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
zephir_array_update_long(&a, 0, &__$null, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&a, 1, &__$null, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&a, 2, &__$null, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_Vars, testVarExport) {
zval __$false, a, ar, ret, _0, _1, _2;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_BOOL(&__$false, 0);
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&ar);
ZVAL_UNDEF(&ret);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
ZVAL_STRING(&a, "hello");
ZEPHIR_INIT_VAR(&ar);
zephir_create_array(&ar, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_0);
ZVAL_LONG(&_0, 1);
zephir_array_fast_append(&ar, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "world");
zephir_array_fast_append(&ar, &_0);
zephir_array_fast_append(&ar, &__$false);
ZEPHIR_INIT_VAR(&_1);
ZEPHIR_CPY_WRT(&_1, &ar);
zephir_var_export(&_1 TSRMLS_CC);
ZEPHIR_INIT_VAR(&ret);
zephir_var_export_ex(&ret, &ar TSRMLS_CC);
ZEPHIR_INIT_VAR(&_2);
ZEPHIR_CPY_WRT(&_2, &a);
zephir_var_export(&_2 TSRMLS_CC);
ZEPHIR_INIT_NVAR(&ret);
zephir_var_export_ex(&ret, &a TSRMLS_CC);
RETURN_CCTOR(ret);
}
/**
* Appends a NOT BETWEEN condition to the current conditions
*
*<code>
* $criteria->notBetweenWhere('price', 100.25, 200.50);
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere) {
zval *_1;
int ZEPHIR_LAST_CALL_STATUS;
zval *expr_param = NULL, *minimum, *maximum, *hiddenParam = NULL, *nextHiddenParam = NULL, *minimumKey = NULL, *maximumKey = NULL, *_0;
zval *expr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &expr_param, &minimum, &maximum);
if (unlikely(Z_TYPE_P(expr_param) != IS_STRING && Z_TYPE_P(expr_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'expr' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(expr_param) == IS_STRING)) {
zephir_get_strval(expr, expr_param);
} else {
ZEPHIR_INIT_VAR(expr);
ZVAL_EMPTY_STRING(expr);
}
ZEPHIR_OBS_VAR(hiddenParam);
zephir_read_property_this(&hiddenParam, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(nextHiddenParam);
ZVAL_LONG(nextHiddenParam, (zephir_get_numberval(hiddenParam) + 1));
ZEPHIR_INIT_VAR(minimumKey);
ZEPHIR_CONCAT_SV(minimumKey, "ACP", hiddenParam);
ZEPHIR_INIT_VAR(maximumKey);
ZEPHIR_CONCAT_SV(maximumKey, "ACP", nextHiddenParam);
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_VSVSVS(_0, expr, " NOT BETWEEN :", minimumKey, ": AND :", maximumKey, ":");
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 2, 0 TSRMLS_CC);
zephir_array_update_zval(&_1, minimumKey, &minimum, PH_COPY);
zephir_array_update_zval(&_1, maximumKey, &maximum, PH_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, _0, _1);
zephir_check_call_status();
ZEPHIR_SEPARATE(nextHiddenParam);
zephir_increment(nextHiddenParam);
zephir_update_property_this(this_ptr, SL("_hiddenParamNumber"), nextHiddenParam TSRMLS_CC);
RETURN_THIS();
}
PHP_METHOD(Test_NativeArray, testMultipleArrayAppend3) {
zval _2;
zval __$null, __$false, a, b, _0, _1, _3;
zval *this_ptr = getThis();
ZVAL_NULL(&__$null);
ZVAL_BOOL(&__$false, 0);
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&b);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
array_init(&a);
ZEPHIR_INIT_VAR(&b);
ZVAL_STRING(&b, "y");
zephir_array_update_multi(&a, &__$null TSRMLS_CC, SL("lsz"), 4, 0, SL("hello"), &b);
ZEPHIR_INIT_VAR(&_0);
ZVAL_LONG(&_0, 100);
zephir_array_update_multi(&a, &_0 TSRMLS_CC, SL("lsza"), 5, 0, SL("hello"), &b);
zephir_array_update_multi(&a, &__$false TSRMLS_CC, SL("lsza"), 5, 0, SL("hello"), &b);
ZEPHIR_INIT_VAR(&_1);
ZVAL_DOUBLE(&_1, 1.2);
zephir_array_update_multi(&a, &_1 TSRMLS_CC, SL("lsza"), 5, 0, SL("hello"), &b);
ZEPHIR_INIT_VAR(&_2);
zephir_create_array(&_2, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_3);
ZVAL_LONG(&_3, 1);
zephir_array_fast_append(&_2, &_3);
ZEPHIR_INIT_NVAR(&_3);
ZVAL_LONG(&_3, 2);
zephir_array_fast_append(&_2, &_3);
ZEPHIR_INIT_NVAR(&_3);
ZVAL_LONG(&_3, 3);
zephir_array_fast_append(&_2, &_3);
zephir_array_update_multi(&a, &_2 TSRMLS_CC, SL("lsza"), 5, 0, SL("hello"), &b);
RETURN_CCTOR(&a);
}
PHP_METHOD(Owl_Http_Response_Json, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_1;
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, owl_std_arraybag_ce);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_1, SS("Content-Type"), SL("application/json"), 1);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 3, _1);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("headers"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Cake_Core_Functions, pluginSplit) {
zend_bool dotAppend;
zval *name_param = NULL, *dotAppend_param = NULL, *plugin_param = NULL, _0, *_1, *parts, *_2;
zval *name = NULL, *plugin = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &name_param, &dotAppend_param, &plugin_param);
zephir_get_strval(name, name_param);
if (!dotAppend_param) {
dotAppend = 0;
} else {
dotAppend = zephir_get_boolval(dotAppend_param);
}
if (!plugin_param) {
ZEPHIR_INIT_VAR(plugin);
ZVAL_EMPTY_STRING(plugin);
} else {
zephir_get_strval(plugin, plugin_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, ".", 0);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strpos(_1, name, &_0, 0 );
if (!ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("."), name, 2 TSRMLS_CC);
if (dotAppend) {
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, ".", 1);
zephir_array_update_long(&parts, 0, &_2, PH_COPY | PH_SEPARATE, "cake/Core/Functions.zep", 12);
}
RETURN_CCTOR(parts);
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, plugin);
zephir_array_fast_append(return_value, name);
RETURN_MM();
}
/**
* Phalcon\Assets\Inline\Css
*
* @param string content
* @param boolean filter
* @param array attributes
*/
PHP_METHOD(Phalcon_Assets_Inline_Css, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zend_bool filter;
zval *content_param = NULL, *filter_param = NULL, *attributes = NULL, *_1, *_2;
zval *content = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &content_param, &filter_param, &attributes);
zephir_get_strval(content, content_param);
if (!filter_param) {
filter = 1;
} else {
filter = zephir_get_boolval(filter_param);
}
if (!attributes) {
ZEPHIR_CPY_WRT(attributes, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(attributes);
}
if (Z_TYPE_P(attributes) == IS_NULL) {
ZEPHIR_INIT_NVAR(attributes);
zephir_create_array(attributes, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(attributes, SS("type"), SL("text/css"), 1);
}
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "css", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
if (filter) {
ZVAL_BOOL(_2, 1);
} else {
ZVAL_BOOL(_2, 0);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_assets_inline_css_ce, this_ptr, "__construct", &_0, 104, _1, content, _2, attributes);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Listen for uncaught exceptions
*/
PHP_METHOD(Phalcon_Debug, listenExceptions) {
zval *_1;
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0, this_ptr);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "onUncaughtException", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_CALL_FUNCTION(NULL, "set_exception_handler", NULL, 155, _0);
zephir_check_call_status();
RETURN_THIS();
}
/**
* Unregisters this instance as an autoloader.
*/
PHP_METHOD(Xpl_ClassLoader, unregister) {
zval *_1;
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0, this_ptr);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "loadClass", 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_unregister", NULL, 54, _0);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Adds the validators to a field
*/
PHP_METHOD(Phalcon_Validation, rules) {
HashTable *_1;
HashPosition _0;
zval *validators = NULL, *_3 = NULL;
zval *field_param = NULL, *validators_param = NULL, *validator = NULL, **_2;
zval *field = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &field_param, &validators_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
validators = validators_param;
zephir_is_iterable(validators, &_1, &_0, 0, 0, "phalcon/validation.zep", 175);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(validator, _2);
if (zephir_instance_of_ev(validator, phalcon_validation_validatorinterface_ce TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, field);
zephir_array_fast_append(_3, validator);
zephir_update_property_array_append(this_ptr, SL("_validators"), _3 TSRMLS_CC);
}
}
RETURN_THIS();
}
PHP_METHOD(Test_NativeArray, testArray4) {
zval __$false, __$true, a;
zval *this_ptr = getThis();
ZVAL_BOOL(&__$false, 0);
ZVAL_BOOL(&__$true, 1);
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
zephir_array_fast_append(&a, &__$false);
zephir_array_fast_append(&a, &__$true);
zephir_array_fast_append(&a, &__$false);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, testArrayAccess2) {
zval a, b;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&b);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_assoc_long_ex(&a, SL("a"), 1);
add_assoc_long_ex(&a, SL("b"), 2);
add_assoc_long_ex(&a, SL("c"), 3);
zephir_array_fetch_string(&b, &a, SL("a"), PH_NOISY | PH_READONLY, "test/nativearray.zep", 255 TSRMLS_CC);
RETURN_CTOR(&b);
}
PHP_METHOD(Test_NativeArray, testArray30) {
zval b;
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&b);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&b);
ZVAL_STRING(&b, "hello");
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(&a, Z_STRVAL_P(&b), Z_STRLEN_P(&b), SL("hello"));
RETURN_CCTOR(&a);
}
PHP_METHOD(PhalconPlus_Db_UnitOfWork, update) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool assign, _0;
zval *initial_data = NULL, *_1;
zval *name, *model, *initial_data_param = NULL, *assign_param = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 2, &name, &model, &initial_data_param, &assign_param);
if (!initial_data_param) {
ZEPHIR_INIT_VAR(initial_data);
array_init(initial_data);
} else {
zephir_get_arrval(initial_data, initial_data_param);
}
if (!assign_param) {
assign = 1;
} else {
assign = zephir_get_boolval(assign_param);
}
_0 = !(ZEPHIR_IS_EMPTY(initial_data));
if (_0) {
_0 = assign == 1;
}
if (_0) {
ZEPHIR_CALL_METHOD(NULL, model, "assign", NULL, 0, initial_data);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "detach", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(_1, SS("method"), SL("update"), 1);
zephir_array_update_string(&_1, SL("name"), &name, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_1, SL("initial_data"), &initial_data, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "attach", NULL, 0, model, _1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_NativeArray, testArrayAppend1) {
zval _1;
zval __$null, a, _0;
zval *this_ptr = getThis();
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
array_init(&a);
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "hello");
zephir_array_append(&a, &_0, PH_SEPARATE, "test/nativearray.zep", 402);
zephir_array_append(&a, &__$null, PH_SEPARATE, "test/nativearray.zep", 402);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_BOOL(&_0, 0);
zephir_array_append(&a, &_0, PH_SEPARATE, "test/nativearray.zep", 402);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_DOUBLE(&_0, 1.10);
zephir_array_append(&a, &_0, PH_SEPARATE, "test/nativearray.zep", 402);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_LONG(&_0, 5);
zephir_array_append(&a, &_0, PH_SEPARATE, "test/nativearray.zep", 402);
ZEPHIR_INIT_VAR(&_1);
zephir_create_array(&_1, 3, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_LONG(&_0, 1);
zephir_array_fast_append(&_1, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_LONG(&_0, 2);
zephir_array_fast_append(&_1, &_0);
ZEPHIR_INIT_NVAR(&_0);
ZVAL_LONG(&_0, 3);
zephir_array_fast_append(&_1, &_0);
zephir_array_append(&a, &_1, PH_SEPARATE, "test/nativearray.zep", 402);
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_NativeArray, Issue1159) {
zval myvar, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&myvar);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&myvar);
ZVAL_LONG(&myvar, 1);
ZEPHIR_INIT_VAR(&_0);
zephir_create_array(&_0, 1, 0 TSRMLS_CC);
zephir_array_fast_append(&_0, &myvar);
ZEPHIR_CPY_WRT(&myvar, &_0);
RETURN_CCTOR(&myvar);
}
