/**
* Commits the transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, commit){
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
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, "notifyCommit", strlen("notifyCommit"), 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, "commit", PHALCON_CALL_DEFAULT);
PHALCON_RETURN_DZVAL(r0);
}
/**
* Shows a HTML warning message
*
*
*
*
* @param string $message
* @param string $classes
* @return string
*/
PHP_METHOD(Phalcon_Flash, warning){
zval *v0 = NULL, *v1 = NULL;
zval *r0 = NULL;
zval *p0[] = { NULL, 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, "warningMessage", 1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
Z_ADDREF_P(v0);
p0[0] = v0;
Z_ADDREF_P(v1);
p0[1] = v1;
PHALCON_CALL_SELF_PARAMS(r0, this_ptr, "_showmessage", 2, p0);
Z_DELREF_P(p0[0]);
Z_DELREF_P(p0[1]);
PHALCON_RETURN_DZVAL(r0);
}
/* {{{ php_autoglobal_merge
*/
static void php_autoglobal_merge(HashTable *dest, HashTable *src)
{
zval *src_entry, *dest_entry;
zend_string *string_key;
zend_ulong num_key;
int globals_check = (dest == (&EG(symbol_table)));
ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
if (Z_TYPE_P(src_entry) != IS_ARRAY
|| (string_key && (dest_entry = zend_hash_find(dest, string_key)) == NULL)
|| (string_key == NULL && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)
|| Z_TYPE_P(dest_entry) != IS_ARRAY) {
if (Z_REFCOUNTED_P(src_entry)) {
Z_ADDREF_P(src_entry);
}
if (string_key) {
if (!globals_check || string_key->len != sizeof("GLOBALS") - 1
|| memcmp(string_key->val, "GLOBALS", sizeof("GLOBALS") - 1)) {
zend_hash_update(dest, string_key, src_entry);
} else if (Z_REFCOUNTED_P(src_entry)) {
Z_DELREF_P(src_entry);
}
} else {
zend_hash_index_update(dest, num_key, src_entry);
}
} else {
SEPARATE_ZVAL(dest_entry);
php_autoglobal_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry));
}
} ZEND_HASH_FOREACH_END();
}
PHP_METHOD(Money, __construct)
{
long amount;
zval *currency, *currency_obj;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz", &amount, ¤cy) == FAILURE) {
return;
}
switch(Z_TYPE_P(currency)) {
case IS_OBJECT:
if (!instanceof_function(currency_ce, Z_OBJCE_P(currency))) {
zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency object", 0);
return;
}
break;
case IS_STRING:
ALLOC_INIT_ZVAL(currency_obj);
object_init_ex(currency_obj, currency_ce);
zend_update_property_stringl(currency_ce, currency_obj, CURRENCY_PROP_CURRENCYCODE_WS, Z_STRVAL_P(currency), Z_STRLEN_P(currency));
currency = currency_obj;
Z_DELREF_P(currency);
break;
default:
zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency value", 0);
return;
}
zend_update_property_long(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_AMOUNT_WS, amount);
zend_update_property(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_CURRENCY_WS, currency);
}
static void json_path_append_zval(json_path_object *intern, json_path *path, zval *zv)
{
if (path->collection_stack.len > 0) {
json_path_stack_elem *stack_elem = simple_vector_get_last(
&intern->path_stack, json_path_stack_elem);
zval *outer_zv = *simple_vector_get_last(
&path->collection_stack, zval *);
zval_add_ref(&zv);
if (stack_elem->type == TYPE_ARRAY) {
add_next_index_zval(outer_zv, zv);
} else {
if (intern->objects_as_arrays) {
add_assoc_zval_ex(outer_zv, stack_elem->key,
stack_elem->key_len+1, zv);
} else {
add_property_zval_ex(outer_zv,
(stack_elem->key_len ? stack_elem->key : "_empty_"),
(stack_elem->key_len ? stack_elem->key_len+1 : sizeof("_empty_")),
zv);
Z_DELREF_P(zv);
}
}
}
static PHP_METHOD(Hello, addProperties) {
zval *obj;
obj = getThis();
/*add zval property*/
zval *arr;
MAKE_STD_ZVAL(arr);
array_init(arr);
add_assoc_string(arr, "e", "hello", 1);
add_index_string(arr, 1, "hello1111", 1);
add_property_zval_ex(obj, "persons", strlen("persons")+1, arr TSRMLS_CC);
Z_DELREF_P(arr);
/*add double property*/
add_property_double(obj, "d", 10.5);
/*add bool property*/
add_property_bool(obj, "b", 1);
/*add string property*/
char *str = "hello str";
add_property_string(obj, "str", str, 1);
/*add long property*/
add_property_long(obj, "l", 12);
}
PHP_METHOD(Phalcon_Internal_TestParent, smp6){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *p0[] = { NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &v0, &v1, &v2, &v3) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 10);
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, t0, v1 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
mul_function(r1, v2, v3 TSRMLS_CC);
PHALCON_RETURN_CTOR(r1);
} else {
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 30);
PHALCON_INIT_VAR(r2);
is_smaller_function(r2, v2, t1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
mul_function(r3, v1, v3 TSRMLS_CC);
PHALCON_RETURN_CTOR(r3);
} else {
PHALCON_ALLOC_ZVAL_MM(r4);
Z_ADDREF_P(v1);
p0[0] = v1;
Z_ADDREF_P(v2);
p0[1] = v2;
PHALCON_CALL_METHOD_PARAMS(r4, v0, "mp7", 2, p0, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p0[0]);
Z_DELREF_P(p0[1]);
PHALCON_RETURN_DZVAL(r4);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHP_METHOD(Util, checkMapField) {
zval* val;
long key_type, value_type;
const zend_class_entry* klass = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zll|C", &val, &key_type,
&value_type, &klass) == FAILURE) {
return;
}
if (Z_TYPE_P(val) == IS_ARRAY) {
HashTable* table = Z_ARRVAL_P(val);
HashPosition pointer;
zval key, *map_field;
void* value;
map_field_create_with_type(map_field_type, to_fieldtype(key_type),
to_fieldtype(value_type), klass,
&map_field TSRMLS_CC);
Map* intern =
(Map*)zend_object_store_get_object(map_field TSRMLS_CC);
for (zend_hash_internal_pointer_reset_ex(table, &pointer);
zend_hash_get_current_data_ex(table, (void**)&value, &pointer) ==
SUCCESS;
zend_hash_move_forward_ex(table, &pointer)) {
zend_hash_get_current_key_zval_ex(table, &key, &pointer);
map_field_handlers->write_dimension(map_field, &key,
*(zval**)value TSRMLS_CC);
}
Z_DELREF_P(map_field);
RETURN_ZVAL(map_field, 1, 0);
} else if (Z_TYPE_P(val) == IS_OBJECT) {
if (!instanceof_function(Z_OBJCE_P(val), map_field_type TSRMLS_CC)) {
zend_error(E_USER_ERROR, "Given value is not an instance of %s.",
map_field_type->name);
return;
}
Map* intern = (Map*)zend_object_store_get_object(val TSRMLS_CC);
if (to_fieldtype(key_type) != intern->key_type) {
zend_error(E_USER_ERROR, "Incorrect map field key type.");
return;
}
if (to_fieldtype(value_type) != intern->value_type) {
zend_error(E_USER_ERROR, "Incorrect map field value type.");
return;
}
if (klass != NULL && intern->msg_ce != klass) {
zend_error(E_USER_ERROR, "Expect a map field of %s, but %s is given.",
klass->name, intern->msg_ce->name);
return;
}
RETURN_ZVAL(val, 1, 0);
} else {
zend_error(E_USER_ERROR, "Incorrect map field type.");
return;
}
}
zend_execute_data *sw_zend_create_execute_data_from_op_array(zend_op_array *op_array, zend_bool nested TSRMLS_DC)
{
zend_execute_data *execute_data;
size_t execute_data_size = ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data));
size_t CVs_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval **) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2));
size_t Ts_size = ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T;
size_t call_slots_size = ZEND_MM_ALIGNED_SIZE(sizeof(call_slot)) * op_array->nested_calls;
size_t stack_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * op_array->used_stack;
size_t total_size = execute_data_size + Ts_size + CVs_size + call_slots_size + stack_size;
execute_data = zend_vm_stack_alloc(total_size TSRMLS_CC);
execute_data = (zend_execute_data*)((char*)execute_data + Ts_size);
execute_data->prev_execute_data = EG(current_execute_data);
memset(EX_CV_NUM(execute_data, 0), 0, sizeof(zval **) * op_array->last_var);
execute_data->call_slots = (call_slot*)((char *)execute_data + execute_data_size + CVs_size);
execute_data->op_array = op_array;
EG(argument_stack)->top = zend_vm_stack_frame_base(execute_data);
execute_data->object = NULL;
execute_data->current_this = NULL;
execute_data->old_error_reporting = NULL;
execute_data->symbol_table = EG(active_symbol_table);
execute_data->call = NULL;
EG(current_execute_data) = execute_data;
execute_data->nested = nested;
if (!op_array->run_time_cache && op_array->last_cache_slot) {
op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*));
}
if (op_array->this_var != -1 && EG(This)) {
Z_ADDREF_P(EG(This)); /* For $this pointer */
if (!EG(active_symbol_table)) {
SW_EX_CV(op_array->this_var) = (zval **) SW_EX_CV_NUM(execute_data, op_array->last_var + op_array->this_var);
*SW_EX_CV(op_array->this_var) = EG(This);
} else {
if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void **) EX_CV_NUM(execute_data, op_array->this_var))==FAILURE) {
Z_DELREF_P(EG(This));
}
}
}
execute_data->opline = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
EG(opline_ptr) = &(execute_data->opline);
execute_data->function_state.function = (zend_function *) op_array;
execute_data->function_state.arguments = NULL;
return execute_data;
}
PHP_METHOD(Util, checkRepeatedField) {
zval* val;
long type;
const zend_class_entry* klass = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl|C", &val, &type,
&klass) == FAILURE) {
return;
}
if (Z_TYPE_P(val) == IS_ARRAY) {
HashTable* table = Z_ARRVAL_P(val);
HashPosition pointer;
void* memory;
zval* repeated_field;
repeated_field_create_with_type(repeated_field_type, to_fieldtype(type),
klass, &repeated_field TSRMLS_CC);
RepeatedField* intern =
(RepeatedField*)zend_object_store_get_object(repeated_field TSRMLS_CC);
for (zend_hash_internal_pointer_reset_ex(table, &pointer);
zend_hash_get_current_data_ex(table, (void**)&memory, &pointer) ==
SUCCESS;
zend_hash_move_forward_ex(table, &pointer)) {
repeated_field_handlers->write_dimension(repeated_field, NULL,
*(zval**)memory TSRMLS_CC);
}
Z_DELREF_P(repeated_field);
RETURN_ZVAL(repeated_field, 1, 0);
} else if (Z_TYPE_P(val) == IS_OBJECT) {
if (!instanceof_function(Z_OBJCE_P(val), repeated_field_type TSRMLS_CC)) {
zend_error(E_USER_ERROR, "Given value is not an instance of %s.",
repeated_field_type->name);
return;
}
RepeatedField* intern =
(RepeatedField*)zend_object_store_get_object(val TSRMLS_CC);
if (to_fieldtype(type) != intern->type) {
zend_error(E_USER_ERROR, "Incorrect repeated field type.");
return;
}
if (klass != NULL && intern->msg_ce != klass) {
zend_error(E_USER_ERROR,
"Expect a repeated field of %s, but %s is given.", klass->name,
intern->msg_ce->name);
return;
}
RETURN_ZVAL(val, 1, 0);
} else {
zend_error(E_USER_ERROR, "Incorrect repeated field type.");
return;
}
}
/* {{{ dba_close_pe_rsrc_deleter */
int dba_close_pe_rsrc_deleter(zval *el, void *pDba)
{
if (Z_RES_P(el)->ptr == pDba) {
if (Z_DELREF_P(el) == 0) {
return ZEND_HASH_APPLY_REMOVE;
} else {
return ZEND_HASH_APPLY_KEEP | ZEND_HASH_APPLY_STOP;
}
} else {
return ZEND_HASH_APPLY_KEEP;
}
}
static void zend_generator_cleanup_unfinished_execution(zend_generator *generator) /* {{{ */
{
zend_execute_data *execute_data = generator->execute_data;
zend_op_array *op_array = &execute_data->func->op_array;
if (generator->send_target) {
if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
generator->send_target = NULL;
}
/* Manually free loop variables, as execution couldn't reach their
* SWITCH_FREE / FREE opcodes. */
{
/* -1 required because we want the last run opcode, not the
* next to-be-run one. */
uint32_t op_num = execute_data->opline - op_array->opcodes - 1;
int i;
for (i = 0; i < op_array->last_brk_cont; ++i) {
zend_brk_cont_element *brk_cont = op_array->brk_cont_array + i;
if (brk_cont->start < 0) {
continue;
} else if ((uint32_t)brk_cont->start > op_num) {
break;
} else if (brk_cont->brk >= 0 && (uint32_t)brk_cont->brk > op_num) {
zend_op *brk_opline = op_array->opcodes + brk_cont->brk;
if (brk_opline->opcode == ZEND_FREE) {
zval *var = EX_VAR(brk_opline->op1.var);
zval_ptr_dtor_nogc(var);
} else if (brk_opline->opcode == ZEND_FE_FREE) {
zval *var = EX_VAR(brk_opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
}
zval_ptr_dtor_nogc(var);
}
}
}
}
/* If yield was used as a function argument there may be active
* method calls those objects need to be freed */
while (execute_data->call) {
if (Z_OBJ(execute_data->call->This)) {
OBJ_RELEASE(Z_OBJ(execute_data->call->This));
}
execute_data->call = execute_data->call->prev_execute_data;
}
}
/**
* Sanitize and Filter a value with a specified single or set of filters
*
* @param mixed $value
* @param array $filters
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, sanitizeAndFilter){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *p0[] = { NULL, NULL, NULL }, *p1[] = { NULL, NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
Z_ADDREF_P(v0);
p0[0] = v0;
Z_ADDREF_P(v1);
p0[1] = v1;
PHALCON_INIT_VAR(p0[2]);
ZVAL_BOOL(p0[2], 1);
PHALCON_CALL_METHOD_PARAMS(r0, this_ptr, "sanitize", 3, p0, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p0[0]);
Z_DELREF_P(p0[1]);
PHALCON_CPY_WRT(v2, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
Z_ADDREF_P(v2);
p1[0] = v2;
Z_ADDREF_P(v1);
p1[1] = v1;
PHALCON_INIT_VAR(p1[2]);
ZVAL_BOOL(p1[2], 1);
PHALCON_CALL_METHOD_PARAMS(r1, this_ptr, "filter", 3, p1, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p1[0]);
Z_DELREF_P(p1[1]);
PHALCON_CPY_WRT(v2, r1);
PHALCON_RETURN_CHECK_CTOR(v2);
}
static zend_always_inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref TSRMLS_DC)
{
if (!Z_DELREF_P(z)) {
Z_SET_REFCOUNT_P(z, 1);
Z_UNSET_ISREF_P(z);
should_free->var = z;
/* should_free->is_var = 1; */
} else {
should_free->var = 0;
if (unref && Z_ISREF_P(z) && Z_REFCOUNT_P(z) == 1) {
Z_UNSET_ISREF_P(z);
}
GC_ZVAL_CHECK_POSSIBLE_ROOT(z);
}
}
/* Dont pass-by-ref */
static zval *
fetch_var_arg (zval * arg, int *is_arg_new)
{
if (Z_ISREF_P(arg))
{
// We dont separate since we don't own one of ARG's references.
arg = zvp_clone_ex (arg);
*is_arg_new = 1;
// It seems we get incorrect refcounts without this.
// TODO This decreases the refcount to zero, which seems wrong,
// but gives the right answer. We should look at how zend does
// this.
Z_DELREF_P(arg);
}
return arg;
}
static int32_t qb_transfer_arguments_from_generator(qb_interpreter_context *cxt) {
USE_TSRM
zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
if(cxt->function->sent_variable->address) {
if(generator->send_target) {
#if PHP_MINOR_VERSION > 5 || PHP_RELEASE_VERSION > 7
zval *value = *generator->send_target;
Z_DELREF_P(value);
#else
zval *value = &generator->send_target->tmp_var;
#endif
if(!qb_transfer_value_from_zval(cxt->function->local_storage, cxt->function->sent_variable->address, value, QB_TRANSFER_CAN_BORROW_MEMORY)) {
return FALSE;
}
}
}
return TRUE;
}
/**
* Paginator Exception
*
* @param string $message
*/
PHP_METHOD(Phalcon_Paginator_Exception, __construct){
zval *v0 = NULL;
zval *p0[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &v0) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
Z_ADDREF_P(v0);
p0[0] = v0;
PHALCON_CALL_PARENT_PARAMS_NORETURN(this_ptr, "Phalcon_Paginator_Exception", "__construct", 1, p0);
Z_DELREF_P(p0[0]);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHP_METHOD(Phalcon_Internal_TestDummy, f1){
zval *v0 = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
zval *p0[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &v0) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_d1", sizeof("_d1")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(v0);
p0[0] = v0;
PHALCON_CALL_METHOD_PARAMS(r0, t0, "t12", 1, p0, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p0[0]);
PHALCON_RETURN_DZVAL(r0);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Between, validate){
zval *validator, *attribute, *value = NULL, *allow_empty, *minimum, *maximum, *label;
zval *pairs, *valid = NULL, *message_str, *prepared = NULL, *message, *code;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_OBS_VAR(allow_empty);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), phalcon_interned_allowEmpty TSRMLS_CC));
if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) {
RETURN_MM_TRUE;
}
PHALCON_OBS_VAR(minimum);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &minimum, getThis(), "minimum" TSRMLS_CC));
PHALCON_OBS_VAR(maximum);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &maximum, getThis(), "maximum" TSRMLS_CC));
PHALCON_CALL_SELF(&valid, "valid", value, minimum, maximum);
if (PHALCON_IS_FALSE(valid)) {
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
PHALCON_ALLOC_GHOST_ZVAL(pairs);
array_init_size(pairs, 3);
Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label);
Z_ADDREF_P(minimum); add_assoc_zval_ex(pairs, SS(":min"), minimum);
Z_ADDREF_P(maximum); add_assoc_zval_ex(pairs, SS(":max"), maximum);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "Between" TSRMLS_CC));
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "Between", code TSRMLS_CC);
Z_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Restore a memory stack applying GC to all observed variables
*/
static void zephir_memory_restore_stack_common(zend_zephir_globals_def *g)
{
size_t i;
zephir_memory_entry *prev, *active_memory;
zephir_symbol_table *active_symbol_table;
zval *ptr;
#ifndef ZEPHIR_RELEASE
int show_backtrace = 0;
#endif
active_memory = g->active_memory;
assert(active_memory != NULL);
if (EXPECTED(!CG(unclean_shutdown))) {
/* Clean active symbol table */
if (g->active_symbol_table) {
active_symbol_table = g->active_symbol_table;
if (active_symbol_table->scope == active_memory) {
zend_execute_data *ex = EG(current_execute_data);
//zend_hash_destroy(EG(current_execute_data)->symbol_table);
//FREE_HASHTABLE(EG(current_execute_data)->symbol_table);
//EG(current_execute_data)->symbol_table = active_symbol_table->symbol_table;
ex->symbol_table = active_symbol_table->symbol_table;
g->active_symbol_table = active_symbol_table->prev;
efree(active_symbol_table);
}
}
/* Check for non freed hash key zvals, mark as null to avoid string freeing */
for (i = 0; i < active_memory->hash_pointer; ++i) {
assert(active_memory->hash_addresses[i] != NULL);
if (!Z_REFCOUNTED_P(active_memory->hash_addresses[i])) continue;
if (Z_REFCOUNT_P(active_memory->hash_addresses[i]) <= 1) {
ZVAL_NULL(active_memory->hash_addresses[i]);
} else {
zval_copy_ctor(active_memory->hash_addresses[i]);
}
}
#ifndef ZEPHIR_RELEASE
for (i = 0; i < active_memory->pointer; ++i) {
if (active_memory->addresses[i] != NULL) {
zval *var = active_memory->addresses[i];
if (Z_TYPE_P(var) > IS_CALLABLE) {
fprintf(stderr, "%s: observed variable #%d (%p) has invalid type %u [%s]\n", __func__, (int)i, var, Z_TYPE_P(var), active_memory->func);
show_backtrace = 1;
}
if (!Z_REFCOUNTED_P(var)) {
continue;
}
if (Z_REFCOUNT_P(var) == 0) {
fprintf(stderr, "%s: observed variable #%d (%p) has 0 references, type=%d [%s]\n", __func__, (int)i, var, Z_TYPE_P(var), active_memory->func);
show_backtrace = 1;
}
else if (Z_REFCOUNT_P(var) >= 1000000) {
fprintf(stderr, "%s: observed variable #%d (%p) has too many references (%u), type=%d [%s]\n", __func__, (int)i, var, Z_REFCOUNT_P(var), Z_TYPE_P(var), active_memory->func);
show_backtrace = 1;
}
#if 0
/* Skip this check, PDO does return variables with is_ref = 1 and refcount = 1*/
else if (Z_REFCOUNT_PP(var) == 1 && Z_ISREF_PP(var)) {
fprintf(stderr, "%s: observed variable #%d (%p) is a reference with reference count = 1, type=%d [%s]\n", __func__, (int)i, *var, Z_TYPE_PP(var), active_memory->func);
}
#endif
}
}
#endif
/* Traverse all zvals allocated, reduce the reference counting or free them */
for (i = 0; i < active_memory->pointer; ++i) {
ptr = active_memory->addresses[i];
if (EXPECTED(ptr != NULL)) {
if (!Z_REFCOUNTED_P(ptr)) continue;
if (Z_REFCOUNT_P(ptr) == 1) {
zval_ptr_dtor(ptr);
} else {
Z_DELREF_P(ptr);
}
}
}
}
#ifndef ZEPHIR_RELEASE
active_memory->func = NULL;
#endif
prev = active_memory->prev;
if (active_memory >= g->end_memory || active_memory < g->start_memory) {
#ifndef ZEPHIR_RELEASE
assert(g->active_memory->permanent == 0);
#endif
assert(prev != NULL);
if (active_memory->hash_addresses != NULL) {
efree(active_memory->hash_addresses);
}
if (active_memory->addresses != NULL) {
efree(active_memory->addresses);
}
efree(g->active_memory);
g->active_memory = prev;
prev->next = NULL;
} else {
#ifndef ZEPHIR_RELEASE
assert(g->active_memory->permanent == 1);
#endif
active_memory->pointer = 0;
active_memory->hash_pointer = 0;
g->active_memory = prev;
}
#ifndef ZEPHIR_RELEASE
if (g->active_memory) {
zephir_memory_entry *f = g->active_memory;
if (f >= g->start_memory && f < g->end_memory - 1) {
assert(f->permanent == 1);
assert(f->next != NULL);
if (f > g->start_memory) {
assert(f->prev != NULL);
}
}
}
if (show_backtrace == 1) {
zephir_print_backtrace();
}
#endif
}
/**
* 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);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate){
zval *validator, *attribute, *value = NULL, *allow_empty, *valid = NULL;
zval *label, *domain, *joined_domain, *pairs, *message_str, *message, *code;
zval *prepared = NULL;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_OBS_VAR(allow_empty);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), phalcon_interned_allowEmpty TSRMLS_CC));
if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) {
RETURN_MM_TRUE;
}
/* A domain is an array with a list of valid values */
PHALCON_OBS_VAR(domain);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &domain, getThis(), phalcon_interned_domain TSRMLS_CC));
if (Z_TYPE_P(domain) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array");
return;
}
PHALCON_CALL_SELF(&valid, "valid", value, domain);
if (PHALCON_IS_FALSE(valid)) {
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
ALLOC_INIT_ZVAL(joined_domain);
phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC);
PHALCON_ALLOC_GHOST_ZVAL(pairs);
array_init_size(pairs, 2);
Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label);
add_assoc_zval_ex(pairs, SS(":domain"), joined_domain);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "InclusionIn" TSRMLS_CC));
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "InclusionIn", code TSRMLS_CC);
Z_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* 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();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*
* @param string $filePath
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct){
zval *file_path, *process_sections, *ini_config;
zval *exception_message, *config, *directives = NULL;
zval *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL, *left_part = NULL;
zval *right_part = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &file_path);
PHALCON_INIT_VAR(process_sections);
ZVAL_BOOL(process_sections, 1);
/**
* Use the standard parse_ini_file
*/
PHALCON_INIT_VAR(ini_config);
phalcon_call_func_p2(ini_config, "parse_ini_file", file_path, process_sections);
/**
* Check if the file had errors
*/
if (PHALCON_IS_FALSE(ini_config)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Configuration file ", file_path, " can't be loaded");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_config_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(config);
array_init(config);
phalcon_is_iterable(ini_config, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(section, ah0, hp0);
PHALCON_GET_HVALUE(directives);
if (unlikely(Z_TYPE_P(directives) != IS_ARRAY)) {
Z_ADDREF_P(directives);
if (phalcon_array_update_zval(&config, section, &directives, 0 TSRMLS_CC) != SUCCESS) {
Z_DELREF_P(directives);
}
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
phalcon_is_iterable(directives, &ah1, &hp1, 0, 0);
if (zend_hash_num_elements(ah1) == 0) {
phalcon_array_update_zval(&config, section, &directives, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HKEY(key, ah1, hp1);
PHALCON_GET_HVALUE(value);
if (phalcon_memnstr_str(key, SL(".") TSRMLS_CC)) {
PHALCON_INIT_NVAR(directive_parts);
phalcon_fast_explode_str(directive_parts, SL("."), key TSRMLS_CC);
PHALCON_OBS_NVAR(left_part);
phalcon_array_fetch_long(&left_part, directive_parts, 0, PH_NOISY_CC);
PHALCON_OBS_NVAR(right_part);
phalcon_array_fetch_long(&right_part, directive_parts, 1, PH_NOISY_CC);
phalcon_array_update_zval_zval_zval_multi_3(&config, section, left_part, right_part, &value, 0 TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, 0 TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Calls the Phalcon\Config constructor
*/
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Config\\Adapter\\Ini", "__construct", config);
PHALCON_MM_RESTORE();
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){
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;
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL;
zval *v7 = NULL, *v8 = NULL, *v9 = NULL;
zval *i0 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
zval *p4[] = { NULL }, *p9[] = { NULL }, *p11[] = { NULL }, *p13[] = { NULL }, *p15[] = { NULL, NULL, NULL }, *p16[] = { NULL, NULL, NULL };
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_CALL_DEFAULT);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_CALL_DEFAULT);
PHALCON_ALLOC_ZVAL_MM(i0);
phalcon_clone(i0, r1 TSRMLS_CC);
PHALCON_CPY_WRT(v0, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v1, r2);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(v2, a0);
if (Z_TYPE_P(v1) == IS_ARRAY) {
if (Z_TYPE_P(v1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah0 = Z_ARRVAL_P(v1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_d73d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_d73d_0;
}
PHALCON_INIT_VAR(v3);
ZVAL_ZVAL(v3, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
Z_ADDREF_P(v3);
p4[0] = v3;
PHALCON_CALL_METHOD_PARAMS(r4, v0, "readattribute", 1, p4, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p4[0]);
Z_ADDREF_P(r4);
PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x01F);
Z_DELREF_P(r4);
PHALCON_CPY_WRT(v4, r3);
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_VBOTH(r5, v3, "='", v4);
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_RIGHT(r6, r5, "'");
Z_ADDREF_P(r6);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r6 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_d73d_0;
fee_d73d_0:
if(0){ };
}
} else {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_METHOD(r8, this_ptr, "getvalue", PHALCON_CALL_DEFAULT);
Z_ADDREF_P(r8);
PHALCON_CALL_FUNC_PARAMS_1(r7, "addslashes", r8, 0x01F);
Z_DELREF_P(r8);
PHALCON_CPY_WRT(v4, r7);
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_VBOTH(r9, v1, "='", v4);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CONCAT_RIGHT(r10, r9, "'");
Z_ADDREF_P(r10);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r10 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, v0, "getmanager", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v5, r11);
PHALCON_ALLOC_ZVAL_MM(r12);
PHALCON_CALL_METHOD(r12, v5, "getmetadata", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v6, r12);
PHALCON_ALLOC_ZVAL_MM(r13);
Z_ADDREF_P(v0);
p9[0] = v0;
PHALCON_CALL_METHOD_PARAMS(r13, v6, "getprimarykeyattributes", 1, p9, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p9[0]);
PHALCON_CPY_WRT(v7, r13);
if (Z_TYPE_P(v7) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah1 = Z_ARRVAL_P(v7);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_d73d_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_d73d_1;
}
PHALCON_INIT_VAR(v8);
ZVAL_ZVAL(v8, *hd, 1, 0);
PHALCON_INIT_VAR(r15);
PHALCON_INIT_VAR(r16);
Z_ADDREF_P(v8);
p11[0] = v8;
PHALCON_CALL_METHOD_PARAMS(r16, v0, "readattribute", 1, p11, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p11[0]);
Z_ADDREF_P(r16);
PHALCON_CALL_FUNC_PARAMS_1(r15, "addslashes", r16, 0x01F);
Z_DELREF_P(r16);
PHALCON_INIT_VAR(r14);
PHALCON_CONCAT_VBOTH(r14, v8, "<>'", r15);
PHALCON_INIT_VAR(r17);
PHALCON_CONCAT_RIGHT(r17, r14, "'");
Z_ADDREF_P(r17);
PHALCON_SEPARATE_ARRAY(v2);
phalcon_array_append(v2, r17 TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_d73d_1;
fee_d73d_1:
if(0){ };
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_CALL_FUNC_PARAMS_2(r18, "join", c0, v2, 0x00F);
PHALCON_CPY_WRT(v2, r18);
PHALCON_ALLOC_ZVAL_MM(r19);
Z_ADDREF_P(v2);
p13[0] = v2;
PHALCON_CALL_STATIC_ZVAL_PARAMS(r19, v0, "count", 1, p13);
Z_DELREF_P(p13[0]);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r20);
is_smaller_function(r20, t0, r19 TSRMLS_CC);
if (zend_is_true(r20)) {
PHALCON_ALLOC_ZVAL_MM(r21);
PHALCON_CALL_METHOD(r21, this_ptr, "getoptions", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v9, r21);
eval_int = phalcon_array_isset_string(v9, "message", strlen("message")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r22);
phalcon_array_fetch_string(&r22, v9, "message", strlen("message"), PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(r22);
p15[0] = r22;
Z_ADDREF_P(v1);
p15[1] = v1;
PHALCON_INIT_VAR(p15[2]);
ZVAL_STRING(p15[2], "unique", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p15, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p15[0]);
Z_DELREF_P(p15[1]);
} else {
PHALCON_ALLOC_ZVAL_MM(r23);
PHALCON_CONCAT_BOTH(r23, "Value of field '", v1, "' is already present in another record");
Z_ADDREF_P(r23);
p16[0] = r23;
Z_ADDREF_P(v1);
p16[1] = v1;
PHALCON_INIT_VAR(p16[2]);
ZVAL_STRING(p16[2], "unique", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p16, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p16[0]);
Z_DELREF_P(p16[1]);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Appends a message to the validator
*
* @param string $message
* @param string $field
* @param string $type
*/
PHP_METHOD(Phalcon_Model_Validator, appendMessage){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *i0 = NULL;
zval *p0[] = { NULL, NULL, NULL }, *p2[] = { NULL, NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_STRING(v1, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v1);
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_STRING(v2, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v2);
}
if (PHALCON_COMPARE_STRING(v1, "")) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_fieldName", sizeof("_fieldName")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v1, t0);
}
if (PHALCON_COMPARE_STRING(v2, "")) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "Validator", 1);
PHALCON_INIT_VAR(p0[1]);
ZVAL_STRING(p0[1], "", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "get_class", this_ptr, 0x049);
p0[2] = r1;
PHALCON_CALL_FUNC_PARAMS(r0, "str_replace", 3, p0, 0x01A);
PHALCON_CPY_WRT(v2, r0);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_model_message_class_entry);
Z_ADDREF_P(v0);
p2[0] = v0;
Z_ADDREF_P(v1);
p2[1] = v1;
Z_ADDREF_P(v2);
p2[2] = v2;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 3, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
Z_DELREF_P(p2[1]);
Z_DELREF_P(p2[2]);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_messages", sizeof("_messages")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(i0);
phalcon_array_append(t1, i0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_messages", strlen("_messages"), t1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Sanizites a value with a specified single or set of filters
*
* @param mixed $value
* @param mixed $filters
* @param boolean $silent
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, sanitize){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *p0[] = { NULL, NULL, NULL }, *p1[] = { NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
zval **hd;
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);
}
if (Z_TYPE_P(v1) == IS_ARRAY) {
PHALCON_CPY_WRT(v3, v0);
if (Z_TYPE_P(v0) != IS_NULL) {
if (Z_TYPE_P(v1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah0 = Z_ARRVAL_P(v1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e618_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e618_0;
}
PHALCON_INIT_VAR(v4);
ZVAL_ZVAL(v4, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
Z_ADDREF_P(v3);
p0[0] = v3;
Z_ADDREF_P(v4);
p0[1] = v4;
Z_ADDREF_P(v2);
p0[2] = v2;
PHALCON_CALL_METHOD_PARAMS(r0, this_ptr, "_sanitize", 3, p0, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p0[0]);
Z_DELREF_P(p0[1]);
Z_DELREF_P(p0[2]);
PHALCON_CPY_WRT(v3, r0);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e618_0;
fee_e618_0:
if(0){ };
}
}
PHALCON_RETURN_CHECK_CTOR(v3);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
Z_ADDREF_P(v0);
p1[0] = v0;
Z_ADDREF_P(v1);
p1[1] = v1;
Z_ADDREF_P(v2);
p1[2] = v2;
PHALCON_CALL_METHOD_PARAMS(r1, this_ptr, "_sanitize", 3, p1, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p1[0]);
Z_DELREF_P(p1[1]);
Z_DELREF_P(p1[2]);
PHALCON_RETURN_DZVAL(r1);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Confirmation, validate){
zval *validator, *attribute, *with_attribute;
zval *value = NULL, *with_value = NULL, *message_str, *message, *code;
zval *label, *with_label, *pairs, *prepared = NULL;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_OBS_VAR(with_attribute);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &with_attribute, getThis(), "with" TSRMLS_CC));
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_CALL_METHOD(&with_value, validator, "getvalue", with_attribute);
if (!PHALCON_IS_EQUAL(value, with_value)) {
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
PHALCON_OBS_VAR(with_label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &with_label, getThis(), phalcon_interned_label TSRMLS_CC));
if (!zend_is_true(with_label)) {
PHALCON_CALL_METHOD(&with_label, validator, "getlabel", with_attribute);
if (!zend_is_true(with_label)) {
PHALCON_CPY_WRT(with_label, with_attribute);
}
}
PHALCON_ALLOC_GHOST_ZVAL(pairs);
array_init_size(pairs, 2);
Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label);
Z_ADDREF_P(with_label); add_assoc_zval_ex(pairs, SS(":with"), with_label);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "Confirmation" TSRMLS_CC));
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "Confirmation", code TSRMLS_CC);
Z_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *message, *type, *type_str = NULL, *timestamp;
zval *payload, *body, *backtrace, *meta, *encoded;
zval *show_backtrace;
smart_str result = { NULL, 0, 0 };
int i;
Bucket *p;
phalcon_fetch_params(0, 3, 0, &message, &type, ×tamp);
/**
* We intentionally do not use Phalcon's MM for better performance.
* All variables allocated with PHALCON_ALLOC_ZVAL() will have
* their reference count set to 1 and therefore they can be nicely
* put into the result array; when that array will be destroyed,
* all inserted variables will be automatically destroyed, too
* and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P
*/
PHALCON_ALLOC_ZVAL(type_str);
phalcon_call_method_p1(type_str, this_ptr, "gettypestring", type);
phalcon_read_property_this(&show_backtrace, getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC);
Z_DELREF_P(show_backtrace);
/**
* Get the backtrace. This differs for differemt PHP versions.
* 5.3.6+ allows us to skip the function arguments which will save some memory
* For 5.4+ there is an extra argument.
*/
PHALCON_ALLOC_ZVAL(backtrace);
if (zend_is_true(show_backtrace)) {
#if PHP_VERSION_ID < 50306
zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC);
#elif PHP_VERSION_ID < 50400
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC);
#else
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC);
#endif
if (Z_TYPE_P(backtrace) == IS_ARRAY) {
HashPosition pos;
HashTable *ht = Z_ARRVAL_P(backtrace);
zval **ppzval;
int found = 0;
ulong idx;
char *key;
uint key_len;
/**
* At this point we know that the backtrace is the array.
* Again, we intentionally do not use Phalcon's API because we know
* that we are working with the array / hash table and thus we can
* save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks
*/
for (
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS;
) {
zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos);
zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos);
zend_hash_move_forward_ex(ht, &pos);
if (Z_TYPE_PP(ppzval) == IS_ARRAY) {
/**
* Here we need to skip the latest calls into Phalcon's core.
* Calls to Zend internal functions will have "file" index not set.
* We remove these entries from the array.
*/
if (!found && !zend_hash_exists(Z_ARRVAL_PP(ppzval), SS("file"))) {
zend_hash_index_del(ht, idx);
}
else {
/**
* Remove args and object indices. They usually give
* too much information; this is not suitable to send
* in the HTTP headers
*/
zend_hash_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"));
zend_hash_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"));
found = 1;
}
}
}
/**
* Now we need to renumber the hash table because we removed several
* heading elements. If we don't do this, json_encode() will convert
* this array to a JavaScript object which is an unwanted side effect
*/
p = ht->pListHead;
i = 0;
while (p != NULL) {
p->nKeyLength = 0;
p->h = i++;
p = p->pListNext;
}
ht->nNextFreeElement = i;
zend_hash_rehash(ht);
}
}
/**
* The result will looks like this:
*
* array(
* array('Type' => 'message type', 'Label' => 'message'),
* array('backtrace' => array(backtrace goes here)
* )
*/
MAKE_STD_ZVAL(payload);
array_init_size(payload, 2);
PHALCON_ALLOC_ZVAL(meta);
array_init_size(meta, 4);
add_assoc_zval_ex(meta, SS("Type"), type_str);
Z_ADDREF_P(message);
add_assoc_zval_ex(meta, SS("Label"), message);
if (Z_TYPE_P(backtrace) == IS_ARRAY) {
zval **ppzval;
if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) {
zval **file = NULL, **line = NULL;
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file);
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line);
if (likely(file != NULL)) {
Z_ADDREF_PP(file);
add_assoc_zval_ex(meta, SS("File"), *file);
}
if (likely(line != NULL)) {
Z_ADDREF_PP(line);
add_assoc_zval_ex(meta, SS("Line"), *line);
}
}
}
MAKE_STD_ZVAL(body);
array_init_size(body, 1);
if (zend_is_true(show_backtrace)) {
add_assoc_zval_ex(body, SS("backtrace"), backtrace);
}
else {
zval_ptr_dtor(&backtrace);
}
add_next_index_zval(payload, meta);
add_next_index_zval(payload, body);
/**
* Convert everything to JSON
*/
ALLOC_INIT_ZVAL(encoded);
phalcon_json_encode(encoded, payload, 0 TSRMLS_CC);
/**
* As promised, kill the payload and all associated elements
*/
zval_ptr_dtor(&payload);
/**
* We don't want to use Phalcon's concatenation API because it
* requires the memory manager. Therefore we fall back to using smart strings.
* smart_str_alloc4() will allocate all required memory amount (plus some more)
* in one go and this allows us to avoid performance penalties due to
* memory reallocations.
*/
smart_str_alloc4(&result, Z_STRLEN_P(encoded) + 2 + 5, 0, i);
/**
* The format is:
*
* <size>|[meta,body]|
*
* Meta and body are contained in encoded inside the array, as required
* by the protocol specification
* @see http://www.firephp.org/Wiki/Reference/Protocol
*/
smart_str_append_long(&result, Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_0(&result);
/* We don't need the JSON message anymore */
zval_ptr_dtor(&encoded);
/* Do not free the samrt string because we steal its data for zval */
RETURN_STRINGL(result.c, result.len, 0);
}
PHP_METHOD(Phalcon_Test, nice){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *index;
uint index_len;
ulong num;
int htype;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &v0) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
add_assoc_long_ex(a0, "hello1", strlen("hello1")+1, 1);
add_assoc_long_ex(a0, "hello2", strlen("hello2")+1, 2);
add_assoc_long_ex(a0, "hello3", strlen("hello3")+1, 3);
PHALCON_CPY_WRT(v1, a0);
if (Z_TYPE_P(v1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(v1), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_2ebb_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_2ebb_0;
} else {
PHALCON_INIT_VAR(v3);
htype = zend_hash_get_current_key_ex(ah0, &index, &index_len, &num, 0, &hp0);
if (htype == HASH_KEY_IS_STRING) {
ZVAL_STRINGL(v3, index, index_len-1, 1);
} else {
if (htype == HASH_KEY_IS_LONG) {
ZVAL_LONG(v3, num);
}
}
}
PHALCON_INIT_VAR(v2);
ZVAL_ZVAL(v2, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
phalcon_array_fetch(&r0, v1, v3, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 100);
PHALCON_INIT_VAR(r1);
phalcon_add_function(r1, r0, t0 TSRMLS_CC);
Z_ADDREF_P(r1);
if (Z_REFCOUNT_P(v1) > 1) {
zval *new_zv;
Z_DELREF_P(v1);
ALLOC_ZVAL(new_zv);
INIT_PZVAL_COPY(new_zv, v1);
v1 = new_zv;
zval_copy_ctor(new_zv);
}
phalcon_array_update(v1, v3, r1 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_2ebb_0;
fee_2ebb_0:
zend_hash_destroy(ah0);
efree(ah0);
}
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("print_r", v1, 0x015);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
