/**
* Phalcon_Acl_Role description
*
* @param string $name
* @param string $description
*/
PHP_METHOD(Phalcon_Acl_Role, __construct){
zval *v0 = NULL, *v1 = NULL;
zval *i0 = NULL;
zval *p0[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_STRING(v1, "", 1);
}
if (PHALCON_COMPARE_STRING(v0, "*")) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_acl_exception_class_entry);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "Role name cannot be \"*\"", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p0, PHALCON_CALL_CHECK);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
phalcon_update_property_zval(this_ptr, "_name", strlen("_name"), v0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_description", strlen("_description"), v1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Throws a zval object as exception
*/
void zephir_throw_exception_debug(zval *object, const char *file, zend_uint line)
{
zend_class_entry *default_exception_ce;
int ZEPHIR_LAST_CALL_STATUS = 0;
zval curline;
zval object_copy;
ZVAL_UNDEF(&curline);
ZEPHIR_MM_GROW();
if (Z_TYPE_P(object) != IS_OBJECT) {
ZVAL_COPY_VALUE(&object_copy, object);
object_init_ex(object, zend_exception_get_default());
ZEPHIR_CALL_METHOD(NULL, object, "__construct", NULL, 0, &object_copy);
zval_ptr_dtor(&object_copy);
}
Z_ADDREF_P(object);
if (line > 0) {
ZEPHIR_CALL_METHOD(&curline, object, "getline", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(&curline, 0)) {
default_exception_ce = zend_exception_get_default();
zend_update_property_string(default_exception_ce, object, SL("file"), file);
zend_update_property_long(default_exception_ce, object, SL("line"), line);
}
}
if (ZEPHIR_LAST_CALL_STATUS != FAILURE) {
zend_throw_exception_object(object);
}
ZEPHIR_MM_RESTORE();
}
/**
* Handles user-defined error
*
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onShutdown){
zval *error = NULL, *message, *type, *file, *line, *exception;
zend_class_entry *default_exception_ce;
PHALCON_MM_GROW();
PHALCON_CALL_FUNCTION(&error, "error_get_last");
if (
phalcon_array_isset_string_fetch(&message, error, SS("message")) &&
phalcon_array_isset_string_fetch(&type, error, SS("type")) &&
phalcon_array_isset_string_fetch(&file, error, SS("file")) &&
phalcon_array_isset_string_fetch(&line, error, SS("line"))
) {
default_exception_ce = zend_get_error_exception(TSRMLS_C);
ALLOC_INIT_ZVAL(exception);
object_init_ex(exception, default_exception_ce);
PHALCON_CALL_METHOD(NULL, exception, "__construct", message, PHALCON_GLOBAL(z_zero), type, file, line);
zend_throw_exception_object(exception TSRMLS_CC);
}
RETURN_MM_TRUE;
}
/* {{{ proto string Glib::userSpecialDir(int user_dir_type)
Returns the full path of a special directory using its logical id.
One of Glib::USER_DIRECTORY_* constants is supposed to be used as parameter
*/
PHP_METHOD(Glib, userSpecialDir)
{
long dir_type;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &dir_type) == FAILURE) {
return;
}
if (dir_type < 0 || dir_type >= G_USER_N_DIRECTORIES) {
zval *exception;
MAKE_STD_ZVAL(exception);
object_init_ex(exception, glib_ce_exception);
zend_update_property_string(glib_ce_exception, exception, "message", sizeof("message")-1, "invalid user-directory type" TSRMLS_CC);
zend_throw_exception_object(exception TSRMLS_CC);
return;
}
const char *retval = g_get_user_special_dir(dir_type);
if (NULL == retval) {
RETURN_NULL();
}
RETURN_STRING(retval, 1);
}
void ctypes_exception(char * message, int errorno TSRMLS_DC)
{
zval * tc_ex;
MAKE_STD_ZVAL(tc_ex);
object_init_ex(tc_ex, class_ce);
zend_update_property_string(class_ce, tc_ex, "message", sizeof("message") - 1,
message TSRMLS_CC);
zend_throw_exception_object(tc_ex TSRMLS_CC);
}
/**
* Throws an exception with a single string parameter
*/
void zephir_throw_exception_string(zend_class_entry *ce, const char *message, zend_uint message_len)
{
zval object, msg;
int ZEPHIR_LAST_CALL_STATUS = 0;
object_init_ex(&object, ce);
ZVAL_STRINGL(&msg, message, message_len);
ZEPHIR_CALL_METHOD(NULL, &object, "__construct", NULL, 0, &msg);
if (ZEPHIR_LAST_CALL_STATUS != FAILURE) {
zend_throw_exception_object(&object);
}
zval_ptr_dtor(&msg);
}
void php_mysqli_throw_sql_exception(char *sqlstate, int errorno TSRMLS_DC, char *format, ...)
{
zval *sql_ex;
va_list arg;
char *message;
va_start(arg, format);
vspprintf(&message, 0, format, arg);
va_end(arg);;
#if WANT_EXCEPTIONS
if (!(MyG(report_mode) & MYSQLI_REPORT_STRICT))
#endif
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "(%s/%d): %s", sqlstate, errorno, message);
efree(message);
return;
}
#if WANT_EXCEPTIONS
MAKE_STD_ZVAL(sql_ex);
object_init_ex(sql_ex, mysqli_exception_class_entry);
if (message) {
zend_update_property_string(mysqli_exception_class_entry, sql_ex, "message", sizeof("message") - 1,
message TSRMLS_CC);
}
if (sqlstate) {
zend_update_property_string(mysqli_exception_class_entry, sql_ex, "sqlstate", sizeof("sqlstate") - 1,
sqlstate TSRMLS_CC);
} else {
zend_update_property_string(mysqli_exception_class_entry, sql_ex, "sqlstate", sizeof("sqlstate") - 1,
"00000" TSRMLS_CC);
}
efree(message);
zend_update_property_long(mysqli_exception_class_entry, sql_ex, "code", sizeof("code") - 1, errorno TSRMLS_CC);
zend_throw_exception_object(sql_ex TSRMLS_CC);
#endif
}
/**
* Handles user-defined error
*
* @param int $severity
* @param string $message
* @param string $file
* @param string $line
* @param array $context
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onUserDefinedError){
zval *severity, *message, *file = NULL, *line = NULL, *context = NULL, *e, *previous = NULL, *exception;
zend_class_entry *default_exception_ce;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 3, &severity, &message, &file, &line, &context);
if (!file) {
file = PHALCON_GLOBAL(z_null);
}
if (!line) {
line = PHALCON_GLOBAL(z_null);
}
if (context && Z_TYPE_P(context) == IS_ARRAY) {
if (
phalcon_array_isset_string_fetch(&e, context, SS("e")) &&
Z_TYPE_P(e) == IS_OBJECT &&
instanceof_function_ex(Z_OBJCE_P(e), zend_exception_get_default(TSRMLS_C), 1 TSRMLS_CC)
) {
PHALCON_CPY_WRT(previous, e);
} else {
previous = PHALCON_GLOBAL(z_null);
}
} else {
previous = PHALCON_GLOBAL(z_null);
}
default_exception_ce = zend_get_error_exception(TSRMLS_C);
ALLOC_INIT_ZVAL(exception);
object_init_ex(exception, default_exception_ce);
PHALCON_CALL_METHOD(NULL, exception, "__construct", message, PHALCON_GLOBAL(z_zero), severity, file, line, previous);
zend_throw_exception_object(exception TSRMLS_CC);
RETURN_MM_TRUE;
}
/** {{{ ze_error
*/
PHP_ZOEEY_API void ze_error(int type TSRMLS_DC, const char * name, ... ) {
va_list ap ;
int len = 0;
char * buf = NULL;
char * msg = NULL;
if (EG(exception)) {
zend_throw_exception_object(EG(exception) TSRMLS_CC);
return;
}
va_start(ap, name);
len = vspprintf(&buf, 0, name, ap);
va_end(ap);
spprintf(&msg, 0, INI_STR("errors_doc_url"), buf);
php_error(type, msg);
efree(msg);
efree(buf);
}
/**
* Throws an exception with a single string parameter + debug info
*/
void zephir_throw_exception_string_debug(zend_class_entry *ce, const char *message, zend_uint message_len, const char *file, zend_uint line)
{
zval object, msg;
int ZEPHIR_LAST_CALL_STATUS = 0;
zend_class_entry *default_exception_ce;
object_init_ex(&object, ce);
ZVAL_STRINGL(&msg, message, message_len);
ZEPHIR_CALL_METHOD(NULL, &object, "__construct", NULL, 0, &msg);
if (line > 0) {
default_exception_ce = zend_exception_get_default();
zend_update_property_string(default_exception_ce, &object, "file", sizeof("file")-1, file);
zend_update_property_long(default_exception_ce, &object, "line", sizeof("line")-1, line);
}
if (ZEPHIR_LAST_CALL_STATUS != FAILURE) {
zend_throw_exception_object(&object);
}
zval_ptr_dtor(&msg);
}
/**
* Throws an exception with a string format as parameter
*/
void zephir_throw_exception_format(zend_class_entry *ce, const char *format, ...)
{
zval object, msg;
int ZEPHIR_LAST_CALL_STATUS = 0, len;
char *buffer;
va_list args;
object_init_ex(&object, ce);
va_start(args, format);
len = vspprintf(&buffer, 0, format, args);
va_end(args);
ZVAL_STRINGL(&msg, buffer, len);
efree(buffer);
ZEPHIR_CALL_METHOD(NULL, &object, "__construct", NULL, 0, &msg);
if (ZEPHIR_LAST_CALL_STATUS != FAILURE) {
zend_throw_exception_object(&object);
}
zval_ptr_dtor(&msg);
}
void php_mysqli_throw_sql_exception(char *sqlstate, int errorno, char *format, ...)
{
zval sql_ex;
va_list arg;
char *message;
va_start(arg, format);
vspprintf(&message, 0, format, arg);
va_end(arg);;
if (!(MyG(report_mode) & MYSQLI_REPORT_STRICT)) {
php_error_docref(NULL, E_WARNING, "(%s/%d): %s", sqlstate, errorno, message);
efree(message);
return;
}
object_init_ex(&sql_ex, mysqli_exception_class_entry);
if (message) {
zend_update_property_string(mysqli_exception_class_entry, &sql_ex, "message", sizeof("message") - 1,
message);
}
if (sqlstate) {
zend_update_property_string(mysqli_exception_class_entry, &sql_ex, "sqlstate", sizeof("sqlstate") - 1,
sqlstate);
} else {
zend_update_property_string(mysqli_exception_class_entry, &sql_ex, "sqlstate", sizeof("sqlstate") - 1,
"00000");
}
efree(message);
zend_update_property_long(mysqli_exception_class_entry, &sql_ex, "code", sizeof("code") - 1, errorno);
zend_throw_exception_object(&sql_ex);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL;
zval *v7 = NULL, *v8 = NULL, *v9 = NULL, *v10 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL, *t12 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL;
zval *r28 = NULL;
zval *i0 = NULL, *i1 = NULL, *i2 = NULL;
zval *a0 = NULL;
zval *p2[] = { NULL }, *p3[] = { NULL }, *p4[] = { NULL }, *p5[] = { NULL };
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_limitRows", sizeof("_limitRows")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v0, t0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_config", sizeof("_config")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, t1, "data", strlen("data"), PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v1, r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_page", sizeof("_page")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v2, t2);
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "count", v1, 0x008);
PHALCON_CPY_WRT(v3, r1);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(v4, i0);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r2);
sub_function(r2, v2, t3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
mul_function(r3, v0, r2 TSRMLS_CC);
PHALCON_CPY_WRT(v5, r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 1);
PHALCON_ALLOC_ZVAL_MM(r5);
sub_function(r5, v3, t4 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
div_function(r6, r5, v0 TSRMLS_CC);
Z_ADDREF_P(r6);
PHALCON_CALL_FUNC_PARAMS_1(r4, "ceil", r6, 0x00D);
Z_DELREF_P(r6);
PHALCON_CPY_WRT(v6, r4);
if (Z_TYPE_P(v1) != IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p2[0]);
ZVAL_STRING(p2[0], "Invalid data for paginator", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p2, PHALCON_CALL_CHECK);
zend_throw_exception_object(i1 TSRMLS_CC);
Z_ADDREF_P(i1);
PHALCON_MM_RESTORE();
return;
}
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 0);
}
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 0);
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, v5, t5 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_ALLOC_ZVAL_MM(i2);
object_init_ex(i2, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p3[0]);
ZVAL_STRING(p3[0], "The start page number is zero or less", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p3, PHALCON_CALL_CHECK);
zend_throw_exception_object(i2 TSRMLS_CC);
Z_ADDREF_P(i2);
PHALCON_MM_RESTORE();
return;
}
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_update_property_zval(v4, "items", strlen("items"), a0 TSRMLS_CC);
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 0);
PHALCON_INIT_VAR(r8);
is_smaller_function(r8, t6, v3 TSRMLS_CC);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(r9);
is_smaller_or_equal_function(r9, v5, v3 TSRMLS_CC);
if (zend_is_true(r9)) {
Z_ADDREF_P(v5);
p4[0] = v5;
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p4, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p4[0]);
} else {
PHALCON_INIT_VAR(p5[0]);
ZVAL_LONG(p5[0], 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p5, PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_INIT_VAR(v7);
ZVAL_LONG(v7, 1);
ws_e435_0:
PHALCON_INIT_VAR(r10);
PHALCON_CALL_METHOD(r10, v1, "valid", PHALCON_CALL_DEFAULT);
if (!zend_is_true(r10)) {
goto we_e435_0;
}
PHALCON_INIT_VAR(r11);
PHALCON_CALL_METHOD(r11, v1, "current", PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, v4, "items", sizeof("items")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(r11);
phalcon_array_append(t7, r11 TSRMLS_CC);
phalcon_update_property_zval(v4, "items", strlen("items"), t7 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
is_smaller_or_equal_function(r12, v0, v7 TSRMLS_CC);
if (zend_is_true(r12)) {
goto we_e435_0;
}
PHALCON_SEPARATE(v7);
increment_function(v7);
goto ws_e435_0;
we_e435_0:
if(0) { };
}
phalcon_update_property_long(v4, "first", strlen("first"), 1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_add_function(r13, v5, v0 TSRMLS_CC);
PHALCON_INIT_VAR(r14);
is_smaller_function(r14, r13, v3 TSRMLS_CC);
if (zend_is_true(r14)) {
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_add_function(r15, v2, t8 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r15);
} else {
PHALCON_ALLOC_ZVAL_MM(r16);
phalcon_add_function(r16, v5, v0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r17);
is_equal_function(r17, r16, v3 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_CPY_WRT(v8, v3);
} else {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_ALLOC_ZVAL_MM(r19);
div_function(r19, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r18, "intval", r19, 0x00E);
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 1);
PHALCON_ALLOC_ZVAL_MM(r20);
phalcon_add_function(r20, r18, t9 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r20);
}
}
PHALCON_INIT_VAR(r21);
is_smaller_function(r21, v6, v8 TSRMLS_CC);
if (zend_is_true(r21)) {
PHALCON_CPY_WRT(v8, v6);
}
phalcon_update_property_zval(v4, "next", strlen("next"), v8 TSRMLS_CC);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 1);
PHALCON_INIT_VAR(r22);
is_smaller_function(r22, t10, v2 TSRMLS_CC);
if (zend_is_true(r22)) {
PHALCON_INIT_VAR(t11);
ZVAL_LONG(t11, 1);
PHALCON_ALLOC_ZVAL_MM(r23);
sub_function(r23, v2, t11 TSRMLS_CC);
PHALCON_CPY_WRT(v9, r23);
} else {
PHALCON_INIT_VAR(v9);
ZVAL_LONG(v9, 1);
}
phalcon_update_property_zval(v4, "before", strlen("before"), v9 TSRMLS_CC);
phalcon_update_property_zval(v4, "current", strlen("current"), v2 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r24);
mod_function(r24, v3, v0 TSRMLS_CC);
if (zend_is_true(r24)) {
PHALCON_ALLOC_ZVAL_MM(r25);
PHALCON_ALLOC_ZVAL_MM(r26);
div_function(r26, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r25, "intval", r26, 0x00E);
PHALCON_INIT_VAR(t12);
ZVAL_LONG(t12, 1);
PHALCON_ALLOC_ZVAL_MM(r27);
phalcon_add_function(r27, r25, t12 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r27);
} else {
PHALCON_ALLOC_ZVAL_MM(r28);
div_function(r28, v3, v0 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r28);
}
phalcon_update_property_zval(v4, "last", strlen("last"), v10 TSRMLS_CC);
phalcon_update_property_zval(v4, "total_pages", strlen("total_pages"), v10 TSRMLS_CC);
PHALCON_RETURN_CTOR(v4);
}
/**
* Rollbacks the transaction
*
* @param string $rollbackMessage
* @param Phalcon_Model_Base $rollbackRecord
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, rollback){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *i0 = NULL;
zval *p2[] = { NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v0) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v0);
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_NULL(v1);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (!PHALCON_COMPARE_STRING(t0, "")) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t1);
PHALCON_SEPARATE_ARRAY(a0);
add_next_index_zval(a0, t1);
add_next_index_stringl(a0, "notifyRollback", strlen("notifyRollback"), 1);
Z_ADDREF_P(a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
Z_ADDREF_P(this_ptr);
PHALCON_SEPARATE_ARRAY(a1);
add_next_index_zval(a1, this_ptr);
Z_ADDREF_P(a1);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1, 0x001);
Z_DELREF_P(a0);
Z_DELREF_P(a1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CALL_METHOD(r0, t2, "rollback", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v2, r0);
PHALCON_INIT_VAR(t3);
ZVAL_BOOL(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, v2, t3 TSRMLS_CC);
if (zend_is_true(r1)) {
if (PHALCON_COMPARE_STRING(v0, "")) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "Transaction aborted", 1);
}
if (zend_is_true(v1)) {
phalcon_update_property_zval(this_ptr, "_rollbackRecord", strlen("_rollbackRecord"), v1 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_transaction_failed_class_entry);
Z_ADDREF_P(v0);
p2[0] = v0;
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_rollbackRecord", sizeof("_rollbackRecord")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t4);
p2[1] = t4;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 2, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
Z_DELREF_P(p2[1]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
static zval * php_yar_client_parse_response(char *ret, size_t len, int throw_exception TSRMLS_DC) /* {{{ */ {
zval *retval, *response;
yar_header_t *header;
char *err_msg;
MAKE_STD_ZVAL(retval);
ZVAL_FALSE(retval);
if (!(header = php_yar_protocol_parse(&ret, &len, &err_msg TSRMLS_CC))) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, YAR_ERR_PROTOCOL, "%s", err_msg);
if (YAR_G(debug)) {
php_yar_debug_client("0: malformed response '%s'", ret);
}
efree(err_msg);
return retval;
}
if (!len || !header->body_len) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, 0, "server responsed empty body");
return retval;
}
if (YAR_G(debug)) {
php_yar_debug_client("%ld: server responsed: packager '%s', len '%ld', content '%s'", header->id, ret, len - 8, ret + 8);
}
if (!(response = php_yar_packager_unpack(ret, len, &err_msg TSRMLS_CC))) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, YAR_ERR_PACKAGER, "%s", err_msg);
efree(err_msg);
return retval;
}
if (response && IS_ARRAY == Z_TYPE_P(response)) {
zval **ppzval;
uint status;
HashTable *ht = Z_ARRVAL_P(response);
if (zend_hash_find(ht, ZEND_STRS("s"), (void **)&ppzval) == FAILURE) {
}
convert_to_long(*ppzval);
status = Z_LVAL_PP(ppzval);
if (status == YAR_ERR_OKEY) {
if (zend_hash_find(ht, ZEND_STRS("o"), (void **)&ppzval) == SUCCESS) {
PHPWRITE(Z_STRVAL_PP(ppzval), Z_STRLEN_PP(ppzval));
}
} else if (status == YAR_ERR_EXCEPTION) {
if (zend_hash_find(ht, ZEND_STRS("e"), (void **)&ppzval) == SUCCESS) {
if (throw_exception) {
zval *ex, **property;
MAKE_STD_ZVAL(ex);
object_init_ex(ex, yar_server_exception_ce);
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("message"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("message"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("code"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("code"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("file"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("file"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("line"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("line"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("_type"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("_type"), *property TSRMLS_CC);
}
zend_throw_exception_object(ex TSRMLS_CC);
} else {
zval **msg, **code;
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("message"), (void **)&msg) == SUCCESS
&& zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("code"), (void **)&code) == SUCCESS) {
convert_to_string_ex(msg);
convert_to_long_ex(code);
php_yar_client_trigger_error(0 TSRMLS_CC, Z_LVAL_PP(code), "server threw an exception with message `%s`", Z_STRVAL_PP(msg));
}
}
}
} else if (zend_hash_find(ht, ZEND_STRS("e"), (void **)&ppzval) == SUCCESS
&& IS_STRING == Z_TYPE_PP(ppzval)) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, status, "%s", Z_STRVAL_PP(ppzval));
}
if (zend_hash_find(ht, ZEND_STRS("r"), (void **)&ppzval) == SUCCESS) {
ZVAL_ZVAL(retval, *ppzval, 1, 0);
}
zval_ptr_dtor(&response);
} else if (response) {
zval_ptr_dtor(&response);
}
return retval;
} /* }}} */
static void dic_optimizer_get_handler(INTERNAL_FUNCTION_PARAMETERS)
{
char *id, should_free = 1;
zend_ulong id_hash;
int id_len, i;
long oninvalid, exception_on_invalid_reference_const;
zval **found_service, **alias, **method_in_map = NULL, *this_services, *this_aliases, *this_methodMap, *this_loading;
zend_function *method = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &id, &id_len, &oninvalid) == FAILURE) {
return;
}
if (strcasecmp(id, "service_container") == 0) {
RETURN_THIS;
}
this_services = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_SERVICES_KEY, sizeof(SYMFONY_DIC_TOKEN_SERVICES_KEY) - 1, 0 TSRMLS_CC);
this_aliases = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_ALIASES_KEY, sizeof(SYMFONY_DIC_TOKEN_ALIASES_KEY) - 1, 0 TSRMLS_CC);
this_loading = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_LOADING_KEY, sizeof(SYMFONY_DIC_TOKEN_LOADING_KEY) - 1, 0 TSRMLS_CC);
this_methodMap = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_METHODMAP_KEY, sizeof(SYMFONY_DIC_TOKEN_METHODMAP_KEY) - 1, 0 TSRMLS_CC);
if (!SYMFONY_DIC_G(cache_done)) {
zval invalidBehavior;
zend_class_entry **exception_ce;
zend_get_constant_ex("self::EXCEPTION_ON_INVALID_REFERENCE", sizeof("self::EXCEPTION_ON_INVALID_REFERENCE") - 1, &invalidBehavior, Z_OBJCE_P(getThis()), 0 TSRMLS_CC);
SYMFONY_DIC_G(invalid_behavior) = Z_LVAL(invalidBehavior);
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(ServiceCircularReferenceException) = *exception_ce;
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(ServiceNotFoundException) = *exception_ce;
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(InactiveScopeException) = *exception_ce;
SYMFONY_DIC_G(cache_done) = 1;
}
exception_on_invalid_reference_const = SYMFONY_DIC_G(invalid_behavior);
if (ZEND_NUM_ARGS() <= 1) {
oninvalid = exception_on_invalid_reference_const;
}
if (IS_INTERNED(id)) {
id_hash = INTERNED_HASH(id);
} else {
id_hash = zend_inline_hash_func(id, id_len + 1);
}
id = estrndup(id, id_len); /* zend_str_tolower will change it otherwise */
for (i = 0; i <= 1; i++, zend_str_tolower(id, id_len), id_hash = zend_inline_hash_func(id, id_len + 1)) {
if (zend_hash_quick_find(Z_ARRVAL_P(this_aliases), id, id_len + 1, id_hash, (void **)&alias) == SUCCESS) {
should_free = 0;
efree(id);
id = Z_STRVAL_PP(alias);
id_len = Z_STRLEN_PP(alias);
id_hash = zend_inline_hash_func(id, id_len + 1);
}
if (zend_hash_quick_find(Z_ARRVAL_P(this_services), id, id_len + 1, id_hash, (void **)&found_service) == SUCCESS) {
RETVAL_ZVAL_FAST(*found_service);
goto free_and_return;
}
}
if (zend_hash_quick_exists(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash)) {
zval *ServiceCircularReferenceException;
ALLOC_INIT_ZVAL(ServiceCircularReferenceException); /* ctor_args */
object_init_ex(ServiceCircularReferenceException, SYMFONY_DIC_G(ServiceCircularReferenceException));
zend_throw_exception_object(ServiceCircularReferenceException TSRMLS_CC);
goto free_and_return;
}
zend_hash_quick_find(Z_ARRVAL_P(this_methodMap), id, id_len + 1, id_hash, (void **)&method_in_map);
if (!method_in_map) {
char *new_id;
for (i=0; i < id_len; i++) {
if (id[i] == '_') {
memmove(&id[i], &id[i + 1], --id_len);
}
}
php_strtr(id, id_len, ".\\", "__", 2);
id_len = spprintf(&new_id, 0, "get%sservice", id);
efree(id);
id = new_id;
id_hash = zend_inline_hash_func(id, id_len + 1);
zend_hash_quick_find(&Z_OBJCE_P(getThis())->function_table, id, id_len + 1, id_hash, (void **)&method);
if (!method) {
if (oninvalid == exception_on_invalid_reference_const) {
zval *ServiceNotFoundException;
ALLOC_INIT_ZVAL(ServiceNotFoundException);
object_init_ex(ServiceNotFoundException, SYMFONY_DIC_G(ServiceNotFoundException));
zend_throw_exception_object(ServiceNotFoundException TSRMLS_CC); /* ctor_args */
}
goto free_and_return;
}
} else {
char *method_name_lc;
method_name_lc = zend_str_tolower_dup(Z_STRVAL_PP(method_in_map), Z_STRLEN_PP(method_in_map));
zend_hash_find(&Z_OBJCE_P(getThis())->function_table, method_name_lc, Z_STRLEN_PP(method_in_map) + 1, (void **)&method);
efree(method_name_lc);
}
zend_fcall_info fci = {0};
zend_fcall_info_cache fcic = {0};
zval *loading, *result;
ALLOC_INIT_ZVAL(loading); ZVAL_BOOL(loading, 1);
zend_hash_quick_add(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash, &loading, sizeof(zval *), NULL);
fcic.called_scope = Z_OBJCE_P(getThis());
fcic.calling_scope = Z_OBJCE_P(getThis());
fcic.function_handler = method;
fcic.initialized = 1;
fcic.object_ptr = getThis();
fci.retval_ptr_ptr = &result;
fci.size = sizeof(zend_fcall_info);
zend_call_function(&fci, &fcic TSRMLS_CC);
zend_hash_quick_del(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash);
if (!EG(exception)) {
RETVAL_ZVAL_FAST(result);
} else {
zend_hash_quick_del(Z_ARRVAL_P(this_services), id, id_len, id_hash);
if (instanceof_function(Z_OBJCE_P(EG(exception)), SYMFONY_DIC_G(InactiveScopeException) TSRMLS_CC) && oninvalid == exception_on_invalid_reference_const) {
EG(exception) = NULL;
}
}
zval_ptr_dtor(&result);
free_and_return:
if (should_free) { efree(id); }
return;
}
/**
* Internal filter function
*
* @parammixed $value
* @paramarray $filters
* @param boolean $silent
* @returnmixed
*/
PHP_METHOD(Phalcon_Filter, _filter){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *i0 = NULL;
zval *p2[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_BOOL(v2, 0);
}
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "extraspaces", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, v1, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
Z_ADDREF_P(v0);
PHALCON_CALL_FUNC_PARAMS_1(r1, "trim", v0, 0x020);
Z_DELREF_P(v0);
PHALCON_RETURN_DZVAL(r1);
}
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, "striptags", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, v1, t1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
Z_ADDREF_P(v0);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strip_tags", v0, 0x03E);
Z_DELREF_P(v0);
PHALCON_RETURN_DZVAL(r3);
}
if (!zend_is_true(v2)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_exception_class_entry);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_BOTH(r4, "Filter ", v1, " is not supported");
Z_ADDREF_P(r4);
p2[0] = r4;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
} else {
PHALCON_RETURN_CHECK_CTOR(v0);
}
se_e618_3:
if(0) { };
PHALCON_MM_RESTORE();
RETURN_NULL();
}
void sapnwrfc_throw_connection_exception(RFC_ERROR_INFO error_info, char *msg, ...)
{
va_list args;
zend_string *message;
zval info;
zval ex;
va_start(args, msg);
message = vstrpprintf(0, msg, args);
va_end(args);
array_init(&info);
zend_replace_error_handling(EH_THROW, sapnwrfc_connection_exception_ce, NULL);
object_init_ex(&ex, sapnwrfc_connection_exception_ce);
zend_update_property_string(sapnwrfc_connection_exception_ce, &ex, "message", sizeof("message") - 1, ZSTR_VAL(message));
zend_update_property_long(sapnwrfc_connection_exception_ce, &ex, "code", sizeof("code") - 1, error_info.code);
// populate errorInfo array
add_assoc_long(&info, "code", error_info.code);
add_assoc_str(&info, "key", sapuc_to_zend_string(error_info.key));
add_assoc_str(&info, "message", sapuc_to_zend_string(error_info.message));
switch(error_info.group) {
case LOGON_FAILURE: // Error message raised when logon fails
case COMMUNICATION_FAILURE: // Problems with the network connection (or backend broke down and killed the connection)
case EXTERNAL_RUNTIME_FAILURE: // Problems in the RFC runtime of the external program (i.e "this" library)
// no additional properties, just the generic one's from above
break;
case ABAP_APPLICATION_FAILURE: // ABAP Exception raised in ABAP function modules
case ABAP_RUNTIME_FAILURE: // ABAP Message raised in ABAP function modules or in ABAP runtime of the backend (e.g Kernel)
case EXTERNAL_APPLICATION_FAILURE: // Problems in the external program (e.g in the external server implementation)
case EXTERNAL_AUTHORIZATION_FAILURE: // Problems raised in the authorization check handler provided by the external server implementation
add_assoc_str(&info, "abapMsgClass", sapuc_to_zend_string(error_info.abapMsgClass));
add_assoc_str(&info, "abapMsgType", sapuc_to_zend_string(error_info.abapMsgType));
add_assoc_str(&info, "abapMsgNumber", sapuc_to_zend_string(error_info.abapMsgNumber));
add_assoc_str(&info, "abapMsgV1", sapuc_to_zend_string(error_info.abapMsgV1));
add_assoc_str(&info, "abapMsgV2", sapuc_to_zend_string(error_info.abapMsgV2));
add_assoc_str(&info, "abapMsgV3", sapuc_to_zend_string(error_info.abapMsgV3));
add_assoc_str(&info, "abapMsgV4", sapuc_to_zend_string(error_info.abapMsgV4));
break;
case RFC_OK:
zend_error(E_ERROR, "Internal error: exception handler called for RFC_OK");
zend_replace_error_handling(EH_NORMAL, NULL, NULL);
zend_string_release(message);
return;
default:
zend_error(E_ERROR, "Internal error: unknown error group");
zend_replace_error_handling(EH_NORMAL, NULL, NULL);
zend_string_release(message);
return;
}
zend_update_property(sapnwrfc_connection_exception_ce, &ex, "errorInfo", sizeof("errorInfo") - 1, &info);
zval_ptr_dtor(&info);
zend_string_release(message);
zend_throw_exception_object(&ex);
zend_replace_error_handling(EH_NORMAL, NULL, NULL);
}
/**
* Phalcon_Db_Column constructor
*
* @param string $columnName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Column, __construct){
zval *v0 = NULL, *v1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL;
zval *i0 = NULL, *i1 = NULL, *i2 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *p0[] = { NULL }, *p1[] = { NULL }, *p2[] = { NULL };
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, "_columnName", strlen("_columnName"), v0 TSRMLS_CC);
eval_int = phalcon_array_isset_string(v1, "type", strlen("type")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, v1, "type", strlen("type"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_type", strlen("_type"), r0 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_exception_class_entry);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "Column type is required", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p0, PHALCON_CALL_CHECK);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
eval_int = phalcon_array_isset_string(v1, "notNull", strlen("notNull")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, v1, "notNull", strlen("notNull"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_notNull", strlen("_notNull"), r1 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(v1, "size", strlen("size")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, v1, "size", strlen("size"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_size", strlen("_size"), r2 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(v1, "scale", strlen("scale")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 3);
PHALCON_ALLOC_ZVAL_MM(r3);
is_equal_function(r3, t0, t1 TSRMLS_CC);
if (zend_is_true(r3)) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, v1, "scale", strlen("scale"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_scale", strlen("_scale"), r4 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_db_exception_class_entry);
PHALCON_INIT_VAR(p1[0]);
ZVAL_STRING(p1[0], "Column type does not support scale parameter", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p1, PHALCON_CALL_CHECK);
zend_throw_exception_object(i1 TSRMLS_CC);
Z_ADDREF_P(i1);
PHALCON_MM_RESTORE();
return;
}
}
eval_int = phalcon_array_isset_string(v1, "unsigned", strlen("unsigned")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_array_fetch_string(&r5, v1, "unsigned", strlen("unsigned"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_unsigned", strlen("_unsigned"), r5 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(v1, "autoIncrement", strlen("autoIncrement")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 0);
PHALCON_ALLOC_ZVAL_MM(r6);
is_equal_function(r6, t2, t3 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, v1, "autoIncrement", strlen("autoIncrement"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_autoIncrement", strlen("_autoIncrement"), r7 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(i2);
object_init_ex(i2, phalcon_db_exception_class_entry);
PHALCON_INIT_VAR(p2[0]);
ZVAL_STRING(p2[0], "Column type cannot be auto-increment", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p2, PHALCON_CALL_CHECK);
zend_throw_exception_object(i2 TSRMLS_CC);
Z_ADDREF_P(i2);
PHALCON_MM_RESTORE();
return;
}
}
eval_int = phalcon_array_isset_string(v1, "first", strlen("first")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, v1, "first", strlen("first"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_first", strlen("_first"), r8 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(v1, "after", strlen("after")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r9);
phalcon_array_fetch_string(&r9, v1, "after", strlen("after"), PHALCON_NOISY_FETCH TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_after", strlen("_after"), r9 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Internal sanizite wrapper to filter_var
*
* @param mixed $value
* @param mixed $filters
* @param boolean $silent
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, _sanitize){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *a0 = NULL;
zval *i0 = NULL;
zval *p3[] = { NULL, NULL, NULL }, *p4[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_BOOL(v2, 0);
}
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "email", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, v1, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 517);
PHALCON_CALL_FUNC_PARAMS_2(r1, "filter_var", v0, t1, 0x03D);
PHALCON_RETURN_DZVAL(r1);
}
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "int", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, v1, t2 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 519);
PHALCON_CALL_FUNC_PARAMS_2(r3, "filter_var", v0, t3, 0x03D);
PHALCON_RETURN_DZVAL(r3);
}
PHALCON_INIT_VAR(t4);
ZVAL_STRING(t4, "string", 1);
PHALCON_ALLOC_ZVAL_MM(r4);
is_equal_function(r4, v1, t4 TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 513);
PHALCON_CALL_FUNC_PARAMS_2(r5, "filter_var", v0, t5, 0x03D);
PHALCON_RETURN_DZVAL(r5);
}
PHALCON_INIT_VAR(t6);
ZVAL_STRING(t6, "float", 1);
PHALCON_ALLOC_ZVAL_MM(r6);
is_equal_function(r6, v1, t6 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
p3[0] = v0;
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 520);
p3[1] = t7;
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 4096);
Z_ADDREF_P(t8);
PHALCON_SEPARATE_ARRAY(a0);
add_assoc_zval(a0, "flags", t8);
p3[2] = a0;
PHALCON_CALL_FUNC_PARAMS(r7, "filter_var", 3, p3, 0x03D);
PHALCON_RETURN_DZVAL(r7);
}
if (!zend_is_true(v2)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_exception_class_entry);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_BOTH(r8, "Sanitize filter ", v1, " is not supported");
Z_ADDREF_P(r8);
p4[0] = r8;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p4, PHALCON_CALL_CHECK);
Z_DELREF_P(p4[0]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
} else {
PHALCON_RETURN_CHECK_CTOR(v0);
}
se_e618_2:
if(0) { };
PHALCON_MM_RESTORE();
RETURN_NULL();
}
