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