void test_phalcon_alloc_zval(void)
{
startup_php(__func__);
zend_first_try {
zval* x;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
PHALCON_MM_RESTORE();
/* zvals allocated by PHALCON_ALLOC_ZVAL() should not be affected by PHALCON_MM_RESTORE() */
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
zval_ptr_dtor(&x);
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
/**
* $x[$a][$b][$c] = $v
*/
void phalcon_array_update_zval_zval_zval_multi_3(zval **arr, zval *index1, zval *index2, zval *index3, zval **value, int flags TSRMLS_DC){
zval *temp1 = NULL, *temp2 = NULL;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
phalcon_array_fetch(&temp2, temp1, index2, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_update_zval(&temp2, index3, value, PH_COPY TSRMLS_CC);
}
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
if (temp2 != NULL) {
zval_ptr_dtor(&temp2);
}
}
void test_phalcon_init_var(void)
{
startup_php(__func__);
zend_first_try {
zval* x;
zval* y;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
PHALCON_INIT_VAR(y);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(y), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(y), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(y), IS_NULL);
Z_ADDREF_P(y);
PHALCON_MM_RESTORE();
/* y has two references => should not be freed */
CU_ASSERT_EQUAL(_mem_block_check(y, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(y), 1);
zval_ptr_dtor(&y);
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
void test_phalcon_init_nvar(void)
{
startup_php(__func__);
zend_first_try {
zval* x = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_NVAR(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
ZVAL_LONG(x, 0x12345678ul);
PHALCON_INIT_NVAR(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
PHALCON_MM_RESTORE();
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
void test_phalcon_obs_nvar(void)
{
startup_php(__func__);
zend_first_try {
zval* x = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_NVAR(x);
ALLOC_INIT_ZVAL(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
PHALCON_OBS_NVAR(x);
ALLOC_INIT_ZVAL(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
PHALCON_MM_RESTORE();
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
/**
* $x[$a]["hello"][] = $v
*/
void phalcon_array_update_zval_string_append_multi_3(zval **arr, zval *index1, char *index2, uint index2_length, zval **value, int flags TSRMLS_DC){
zval *temp1 = NULL, *temp2 = NULL;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
phalcon_array_fetch_string(&temp2, temp1, index2, index2_length, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_string(&temp1, index2, index2_length, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_string(&temp1, index2, index2_length, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&temp2, *value, flags TSRMLS_CC);
}
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
if (temp2 != NULL) {
zval_ptr_dtor(&temp2);
}
}
/**
* $x[$a][$b]["str"] = $v
*/
void phalcon_array_update_string_zval_zval_multi_3(zval **arr, zval *index1, zval *index2, char *index3, uint index3_length, zval **value, int flags TSRMLS_DC){
zval *temp1, *temp2;
ALLOC_INIT_ZVAL(temp1);
ALLOC_INIT_ZVAL(temp2);
if (Z_TYPE_PP(arr) == IS_ARRAY) {
ALLOC_INIT_ZVAL(temp1);
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(temp1) == IS_ARRAY) {
ALLOC_INIT_ZVAL(temp2);
phalcon_array_fetch(&temp2, temp1, index2, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_update_string(&temp2, index3, index3_length, value, PH_COPY TSRMLS_CC);
zval_ptr_dtor(&temp1);
zval_ptr_dtor(&temp2);
}
void test_phalcon_cpy_wrt_ctor(void)
{
startup_php(__func__);
zend_first_try {
zval* dest;
zval* src;
PHALCON_MM_GROW();
/* dest is not observed by Phalcon */
MAKE_STD_ZVAL(dest);
ZVAL_STRING(dest, "R^itaM cha svAdhyAyapravachane cha", 1);
PHALCON_INIT_VAR(src);
ZVAL_STRING(src, "satyaM cha svAdhyAyapravachane cha", 1);
PHALCON_CPY_WRT_CTOR(dest, src);
CU_ASSERT_PTR_NOT_EQUAL(dest, src);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(src), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(dest), 1);
CU_ASSERT_EQUAL(Z_TYPE_P(src), IS_STRING);
CU_ASSERT_EQUAL(Z_ISREF_P(src), 0);
CU_ASSERT_EQUAL(Z_ISREF_P(dest), 0);
PHALCON_MM_RESTORE();
CU_ASSERT_EQUAL(_mem_block_check(dest, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_PTR_NOT_EQUAL(dest, src);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(dest), 1);
CU_ASSERT_STRING_EQUAL(Z_STRVAL_P(dest), "satyaM cha svAdhyAyapravachane cha");
zval_ptr_dtor(&dest);
PHALCON_MM_GROW();
/* dest will be observed by Phalcon */
dest = NULL;
PHALCON_INIT_VAR(src);
ZVAL_STRING(src, "satyaM cha svAdhyAyapravachane cha", 1);
PHALCON_CPY_WRT_CTOR(dest, src);
CU_ASSERT_PTR_NOT_EQUAL(dest, src);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(src), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(dest), 1);
CU_ASSERT_EQUAL(Z_TYPE_P(src), IS_STRING);
CU_ASSERT_EQUAL(Z_ISREF_P(src), 0);
CU_ASSERT_EQUAL(Z_ISREF_P(dest), 0);
PHALCON_MM_RESTORE();
/* At this point dest will be destroyed */
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
{
void *next;
zend_long i;
var_entries *var_hash = (*var_hashx)->first;
var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
#endif
while (var_hash) {
next = var_hash->next;
efree_size(var_hash, sizeof(var_entries));
var_hash = next;
}
while (var_dtor_hash) {
for (i = 0; i < var_dtor_hash->used_slots; i++) {
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy dtor(%p, %ld)\n", var_dtor_hash->data[i], Z_REFCOUNT_P(var_dtor_hash->data[i]));
#endif
zval_ptr_dtor(&var_dtor_hash->data[i]);
}
next = var_dtor_hash->next;
efree_size(var_dtor_hash, sizeof(var_dtor_entries));
var_dtor_hash = next;
}
}
void test_phalcon_init_nvar_pnull(void)
{
startup_php(__func__);
zend_first_try {
zval* x = NULL;
char* str = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_NVAR(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
str = (char*)estrdup("satyaM vada dharmaM chara svAdhyAyAnmA pramadaH");
ZVAL_STRING(x, str, 0);
PHALCON_INIT_NVAR_PNULL(x);
CU_ASSERT_EQUAL(_mem_block_check(str, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_NULL);
PHALCON_MM_RESTORE();
CU_ASSERT_EQUAL(_mem_block_check(str, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
efree(str);
x = NULL;
str = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_NVAR_PNULL(x);
str = (char*)estrdup("satyaM vada dharmaM chara svAdhyAyAnmA pramadaH");
ZVAL_STRING(x, str, 0);
PHALCON_MM_RESTORE();
CU_ASSERT_EQUAL(_mem_block_check(str, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
efree(str);
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
static inline void phalcon_config_adapter_ini_update_zval_directive(zval **arr, zval *section, zval *directive, zval **value, int flags TSRMLS_DC) {
zval *temp1 = NULL, *temp2 = NULL, *index = NULL;
int i, n;
n = zend_hash_num_elements(Z_ARRVAL_P(directive));
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, section, PH_SILENT);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, section, &temp1, PH_COPY | PH_CTOR);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, section, &temp1, PH_COPY);
}
for (i = 0; i < n - 1; i++) {
phalcon_array_fetch_long(&index, directive, i, PH_NOISY);
phalcon_array_fetch(&temp2, temp1, index, PH_SILENT);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index, &temp2, PH_COPY | PH_CTOR);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index, &temp2, PH_COPY);
}
zval_ptr_dtor(&index);
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
temp1 = temp2;
temp2 = NULL;
}
phalcon_array_fetch_long(&index, directive, n - 1, PH_NOISY);
phalcon_array_update_zval(&temp1, index, value, PH_COPY);
zval_ptr_dtor(&index);
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
}
}
PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
{
void *next;
zend_long i;
var_entries *var_hash = (*var_hashx)->first;
var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
zend_bool wakeup_failed = 0;
zval wakeup_name;
ZVAL_UNDEF(&wakeup_name);
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
#endif
while (var_hash) {
next = var_hash->next;
efree_size(var_hash, sizeof(var_entries));
var_hash = next;
}
while (var_dtor_hash) {
for (i = 0; i < var_dtor_hash->used_slots; i++) {
zval *zv = &var_dtor_hash->data[i];
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy dtor(%p, %ld)\n", var_dtor_hash->data[i], Z_REFCOUNT_P(var_dtor_hash->data[i]));
#endif
/* Perform delayed __wakeup calls */
if (Z_EXTRA_P(zv) == VAR_WAKEUP_FLAG) {
if (!wakeup_failed) {
zval retval;
if (Z_ISUNDEF(wakeup_name)) {
ZVAL_STRINGL(&wakeup_name, "__wakeup", sizeof("__wakeup") - 1);
}
BG(serialize_lock)++;
if (call_user_function_ex(CG(function_table), zv, &wakeup_name, &retval, 0, 0, 1, NULL) == FAILURE || Z_ISUNDEF(retval)) {
wakeup_failed = 1;
GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
}
BG(serialize_lock)--;
zval_ptr_dtor(&retval);
} else {
GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
}
}
i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC);
}
next = var_dtor_hash->next;
efree_size(var_dtor_hash, sizeof(var_dtor_entries));
var_dtor_hash = next;
}
zval_ptr_dtor_nogc(&wakeup_name);
}
/* This function should only be used as a copy constructor, i.e. it
* should only be called AFTER a zval has been copied to another
* location using ZVAL_COPY_VALUE. Do not call it before copying,
* otherwise a reference may be leaked. */
ZEND_API void zval_add_ref(zval *p)
{
if (Z_REFCOUNTED_P(p)) {
if (Z_ISREF_P(p) && Z_REFCOUNT_P(p) == 1) {
ZVAL_COPY(p, Z_REFVAL_P(p));
} else {
Z_ADDREF_P(p);
}
}
}
static zend_always_inline int apc_array_dup_element(apc_context_t *ctxt, HashTable *source, HashTable *target, uint32_t idx, Bucket *p, Bucket *q, int packed, int static_keys, int with_holes)
{
zval *data = &p->val;
if (with_holes) {
if (!packed && Z_TYPE_INFO_P(data) == IS_INDIRECT) {
data = Z_INDIRECT_P(data);
}
if (UNEXPECTED(Z_TYPE_INFO_P(data) == IS_UNDEF)) {
return 0;
}
} else if (!packed) {
/* INDIRECT element may point to UNDEF-ined slots */
if (Z_TYPE_INFO_P(data) == IS_INDIRECT) {
data = Z_INDIRECT_P(data);
if (UNEXPECTED(Z_TYPE_INFO_P(data) == IS_UNDEF)) {
return 0;
}
}
}
do {
if (Z_OPT_REFCOUNTED_P(data)) {
if (Z_ISREF_P(data) && Z_REFCOUNT_P(data) == 1 &&
(Z_TYPE_P(Z_REFVAL_P(data)) != IS_ARRAY ||
Z_ARRVAL_P(Z_REFVAL_P(data)) != source)) {
data = Z_REFVAL_P(data);
if (!Z_OPT_REFCOUNTED_P(data)) {
break;
}
}
}
} while (0);
my_copy_zval(&q->val, data, ctxt);
q->h = p->h;
if (packed) {
q->key = NULL;
} else {
uint32_t nIndex;
q->key = p->key;
if (!static_keys && q->key) {
if (ctxt->copy == APC_COPY_IN) {
q->key = apc_pstrcpy(q->key, ctxt->pool);
} else q->key = p->key;
}
nIndex = q->h | target->nTableMask;
Z_NEXT(q->val) = HT_HASH(target, nIndex);
HT_HASH(target, nIndex) = HT_IDX_TO_HASH(idx);
}
return 1;
}
static int zval_call_destructor(zval *zv) /* {{{ */
{
if (Z_TYPE_P(zv) == IS_INDIRECT) {
zv = Z_INDIRECT_P(zv);
}
if (Z_TYPE_P(zv) == IS_OBJECT && Z_REFCOUNT_P(zv) == 1) {
return ZEND_HASH_APPLY_REMOVE;
} else {
return ZEND_HASH_APPLY_KEEP;
}
}
/**
* Phalcon\Mvc\Router\Route constructor
*
* @param string $pattern
* @param array $paths
* @param array|string $httpMethods
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, __construct){
zval *pattern, *paths = NULL, *http_methods = NULL, *unique_id = NULL;
zval *route_id = NULL;
int separate = 0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &pattern, &paths, &http_methods);
if (!paths) {
paths = PHALCON_GLOBAL(z_null);
}
if (!http_methods) {
http_methods = PHALCON_GLOBAL(z_null);
}
/**
* Configure the route (extract parameters, paths, etc)
*/
PHALCON_CALL_METHOD(NULL, this_ptr, "reconfigure", pattern, paths);
/**
* Update the HTTP method constraints
*/
phalcon_update_property_this(this_ptr, SL("_methods"), http_methods TSRMLS_CC);
/**
* Get the unique Id from the static member _uniqueId
*/
unique_id = phalcon_fetch_static_property_ce(phalcon_mvc_router_route_ce, SL("_uniqueId") TSRMLS_CC);
if (Z_REFCOUNT_P(unique_id) > 1) {
PHALCON_INIT_VAR(unique_id);
separate = 1;
}
if (Z_TYPE_P(unique_id) == IS_NULL) {
ZVAL_LONG(unique_id, 0);
}
PHALCON_CPY_WRT_CTOR(route_id, unique_id); /* route_id is now separated from unique_id */
phalcon_update_property_this(this_ptr, SL("_id"), route_id TSRMLS_CC);
/* increment_function() will increment the value of the static property as well */
increment_function(unique_id);
if (separate) {
phalcon_update_static_property_ce(phalcon_mvc_router_route_ce, SL("_uniqueId"), unique_id TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
void test_phalcon_separate_param(void)
{
startup_php(__func__);
zend_first_try {
zval* x;
zval* orig;
PHALCON_MM_GROW();
MAKE_STD_ZVAL(x);
ZVAL_LONG(x, 0xB61964F6l);
Z_ADDREF_P(x);
Z_ADDREF_P(x);
Z_ADDREF_P(x);
orig = x;
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 4);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
PHALCON_SEPARATE_PARAM(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_PTR_NOT_EQUAL(x, orig);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 4);
CU_ASSERT_EQUAL(Z_ISREF_P(orig), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_LONG);
CU_ASSERT_EQUAL(Z_LVAL_P(x), 0xB61964F6l);
CU_ASSERT_EQUAL(Z_TYPE_P(x), Z_TYPE_P(orig));
CU_ASSERT_EQUAL(Z_LVAL_P(x), Z_LVAL_P(orig));
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 3);
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 2);
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 1);
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
PHALCON_MM_RESTORE();
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
static inline void zend_clone_zval(zval *src, int bind)
{
void *ptr;
if (Z_IMMUTABLE_P(src)) {
return;
}
switch (Z_TYPE_P(src)) {
case IS_STRING:
case IS_CONSTANT:
Z_STR_P(src) = zend_clone_str(Z_STR_P(src));
break;
case IS_ARRAY:
if (Z_ARR_P(src) != &EG(symbol_table)) {
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_ARR_P(src))) != NULL) {
Z_ARR_P(src) = ptr;
} else {
zend_array *old = Z_ARR_P(src);
Z_ARR_P(src) = emalloc(sizeof(zend_array));
Z_ARR_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_ARR_P(src));
}
zend_hash_clone_zval(Z_ARRVAL_P(src), old, 0);
}
}
break;
case IS_REFERENCE:
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_REF_P(src))) != NULL) {
Z_REF_P(src) = ptr;
} else {
zend_reference *old = Z_REF_P(src);
ZVAL_NEW_REF(src, &old->val);
Z_REF_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_REF_P(src));
}
zend_clone_zval(Z_REFVAL_P(src), bind);
}
break;
case IS_CONSTANT_AST:
if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_AST_P(src))) != NULL) {
Z_AST_P(src) = ptr;
} else {
zend_ast_ref *old = Z_AST_P(src);
ZVAL_NEW_AST(src, old->ast);
Z_AST_P(src)->gc = old->gc;
if (bind && Z_REFCOUNT_P(src) > 1) {
accel_xlat_set(old, Z_AST_P(src));
}
Z_ASTVAL_P(src) = zend_ast_clone(Z_ASTVAL_P(src));
}
break;
}
}
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);
}
}
/**
* $x[$a][] = 1
*/
void phalcon_array_update_append_multi_2(zval **arr, zval *index1, zval *value, int flags TSRMLS_DC){
zval *temp;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_zval(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_zval(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&temp, value, flags TSRMLS_CC);
zval_ptr_dtor(&temp);
}
}
/**
* Updates multi-dimensional arrays with one long index and other string
*
* $foo[10]["lol"] = $x
*/
void phalcon_array_update_long_string_multi_2(zval **arr, long index1, char *index2, uint index2_length, zval **value, int flags TSRMLS_DC){
zval *temp;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch_long(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_long(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_long(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_update_string(&temp, index2, index2_length, value, flags | PH_COPY TSRMLS_CC);
zval_ptr_dtor(&temp);
}
}
static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
{
char *cmd;
size_t cmd_len;
zval *ret_code=NULL, *ret_array=NULL;
int ret;
ZEND_PARSE_PARAMETERS_START(1, (mode ? 2 : 3))
Z_PARAM_STRING(cmd, cmd_len)
Z_PARAM_OPTIONAL
if (!mode) {
Z_PARAM_ZVAL_DEREF(ret_array)
}
Z_PARAM_ZVAL_DEREF(ret_code)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (!cmd_len) {
php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
RETURN_FALSE;
}
if (strlen(cmd) != cmd_len) {
php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack");
RETURN_FALSE;
}
if (!ret_array) {
ret = php_exec(mode, cmd, NULL, return_value);
} else {
if (Z_TYPE_P(ret_array) != IS_ARRAY) {
zval_ptr_dtor(ret_array);
array_init(ret_array);
} else if (Z_REFCOUNT_P(ret_array) > 1) {
zval_ptr_dtor(ret_array);
ZVAL_ARR(ret_array, zend_array_dup(Z_ARR_P(ret_array)));
}
ret = php_exec(2, cmd, ret_array, return_value);
}
if (ret_code) {
zval_ptr_dtor(ret_code);
ZVAL_LONG(ret_code, ret);
}
}
/**
* Updates multi-dimensional arrays with two long indices
*
* $foo[10][4] = $x
*/
void phalcon_array_update_long_long_multi_2(zval **arr, long index1, long index2, zval **value, int flags TSRMLS_DC){
zval *temp;
ALLOC_INIT_ZVAL(temp);
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch_long(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_long(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_long(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_update_long(&temp, index2, value, flags | PH_COPY TSRMLS_CC);
}
zval_ptr_dtor(&temp);
}
zval result, op2_tmp;
ZVAL_BOOL(&op2_tmp, op2);
is_equal_function(&result, op1, &op2_tmp TSRMLS_CC);
bool_result = Z_BVAL(result);
return bool_result;
}
}
return 0;
}
/**
* Do add function keeping ref_count and is_ref
*/
int phalcon_add_function_ex(zval *result, zval *op1, zval *op2 TSRMLS_DC){
int status;
int ref_count = Z_REFCOUNT_P(result);
int is_ref = Z_ISREF_P(result);
status = add_function(result, op1, op2 TSRMLS_CC);
Z_SET_REFCOUNT_P(result, ref_count);
Z_SET_ISREF_TO_P(result, is_ref);
return status;
}
void phalcon_negate(zval *z TSRMLS_DC) {
while (1) {
switch (Z_TYPE_P(z)) {
case IS_LONG:
case IS_BOOL:
ZVAL_LONG(z, -Z_LVAL_P(z));
return;
/**
* 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
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon_Db_Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, describeReferences){
zval *table = NULL, *schema = NULL, *sql = NULL, *references = NULL, *describe = NULL;
zval *reference = NULL, *constraint_name = NULL, *reference_objects = NULL;
zval *array_reference = NULL, *name = 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;
zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *i0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
ZVAL_NULL(schema);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db_dialect_mysql", "describereferences", table, schema);
PHALCON_CPY_WRT(sql, r0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(references, a0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(describe, r1);
if (phalcon_valid_foreach(describe TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_4:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_4;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
phalcon_array_fetch_string(&r2, reference, SL("CONSTRAINT_NAME"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(constraint_name, r2);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_INIT_VAR(r3);
phalcon_array_fetch_string(&r3, reference, SL("REFERENCED_TABLE_SCHEMA"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedSchema"), &r3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_string(&r4, reference, SL("REFERENCED_TABLE_NAME"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedTable"), &r4, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a2);
array_init(a2);
phalcon_array_update_string(&a1, SL("columns"), &a2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a3);
array_init(a3);
phalcon_array_update_string(&a1, SL("referencedColumns"), &a3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update(&references, constraint_name, &a1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_string(&r5, reference, SL("COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch_string(&t2, t1, SL("columns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t2, r5, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_array_fetch_string(&r6, reference, SL("REFERENCED_COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch(&t3, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) == IS_ARRAY) {
PHALCON_INIT_VAR(t4);
phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t4) > 1) {
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t4) != IS_ARRAY) {
convert_to_array(t4);
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t4, r6, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_4;
fee_321f_4:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(a4);
array_init(a4);
PHALCON_CPY_WRT(reference_objects, a4);
if (phalcon_valid_foreach(references TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_321f_5:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_321f_5;
} else {
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
}
PHALCON_INIT_VAR(array_reference);
ZVAL_ZVAL(array_reference, *hd, 1, 0);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_db_reference_ce);
PHALCON_INIT_VAR(a5);
array_init(a5);
PHALCON_INIT_VAR(r7);
phalcon_array_fetch_string(&r7, array_reference, SL("referencedSchema"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedSchema"), &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r8);
phalcon_array_fetch_string(&r8, array_reference, SL("referencedTable"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedTable"), &r8, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch_string(&r9, array_reference, SL("columns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("columns"), &r9, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r10);
phalcon_array_fetch_string(&r10, array_reference, SL("referencedColumns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedColumns"), &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", name, a5, PHALCON_CHECK);
phalcon_array_update(&reference_objects, name, &i0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_321f_5;
fee_321f_5:
if(0){}
} else {
return;
}
RETURN_CTOR(reference_objects);
}
/**
* Writes the log to the stream itself
*
* @param string $message
* @param int $type
* @param int $time
* @param array $context
* @see http://www.firephp.org/Wiki/Reference/Protocol
*/
PHP_METHOD(Phalcon_Logger_Adapter_Firephp, logInternal){
zval *message, *type, *time, *context, *formatter = NULL, *applied_format = NULL;
zval *initialized, *index;
sapi_header_line h = { NULL, 0, 0 };
smart_str str = { NULL, 0, 0 };
int size, offset;
int separate_index = 0;
size_t num_bytes;
const int chunk = 4500;
/* If headers has already been sent, we can do nothing. Exit early. */
if (SG(headers_sent)) {
RETURN_FALSE;
}
PHALCON_MM_GROW();
phalcon_fetch_params(1, 4, 0, &message, &type, &time, &context);
PHALCON_CALL_METHOD(&formatter, this_ptr, "getformatter");
initialized = phalcon_fetch_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_initialized") TSRMLS_CC);
if (!zend_is_true(initialized)) {
/**
* Send the required initialization headers.
* Use Zend API here so that the user can see the progress and because
* if we delegate this to Phalcon and there will be a fatal errors,
* chances are that the headers will never ne sent.
*/
h.line = "X-Wf-Protocol-1: http://meta.wildfirehq.org/Protocol/JsonStream/0.2";
h.line_len = sizeof("X-Wf-Protocol-1: http://meta.wildfirehq.org/Protocol/JsonStream/0.2")-1;
sapi_header_op(SAPI_HEADER_REPLACE, &h TSRMLS_CC);
h.line = "X-Wf-1-Plugin-1: http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3";
h.line_len = sizeof("X-Wf-1-Plugin-1: http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3")-1;
sapi_header_op(SAPI_HEADER_REPLACE, &h TSRMLS_CC);
h.line = "X-Wf-1-Structure-1: http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1";
h.line_len = sizeof("X-Wf-1-Structure-1: http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1")-1;
sapi_header_op(SAPI_HEADER_REPLACE, &h TSRMLS_CC);
ZVAL_TRUE(initialized); /* This will also update the property because "initialized" was not separated */
}
PHALCON_CALL_METHOD(&applied_format, formatter, "format", message, type, time, context);
convert_to_string(applied_format);
index = phalcon_fetch_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index") TSRMLS_CC);
assert(Z_TYPE_P(index) == IS_LONG);
if (Z_REFCOUNT_P(index) > 1) {
PHALCON_INIT_VAR(index);
separate_index = 1;
}
size = Z_STRLEN_P(applied_format);
offset = 0;
/**
* We need to send the data in chunks not exceeding 5,000 bytes.
* Allocate the smart string once to avoid performance penalties.
*/
smart_str_alloc4(&str, (uint)(size > chunk ? chunk : size), 0, num_bytes);
while (size > 0) {
smart_str_appends(&str, "X-Wf-1-1-1-");
smart_str_append_long(&str, Z_RESVAL_P(index));
smart_str_appends(&str, ": ");
num_bytes = size > chunk ? chunk : size;
if (offset) {
/* This is not the first chunk, prepend the payload with "|" */
smart_str_appendc(&str, '|');
}
/* Grab the chunk from the encoded string */
smart_str_appendl(&str, Z_STRVAL_P(applied_format) + offset, num_bytes);
size -= num_bytes;
offset += num_bytes;
if (size) {
/* If we have more data to send, append "|/" */
smart_str_appendl(&str, "|\\", 2);
}
smart_str_0(&str); /* Not strictly necessary but just to be safe */
/* Send the result */
h.line = str.c;
h.line_len = str.len;
sapi_header_op(SAPI_HEADER_REPLACE, &h TSRMLS_CC);
ZVAL_LONG(index, Z_RESVAL_P(index)+1);
/**
* Do not free and then reallocate memory. Just pretend the string
* is empty. We will take care of deallocation later.
*/
str.len = 0;
}
if (separate_index) {
phalcon_update_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index"), index TSRMLS_CC);
}
/* Deallocate the smnart string if it is not empty */
if (str.c) {
smart_str_free(&str);
}
PHALCON_MM_RESTORE();
}
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();
}
PHP_METHOD(air_view, render){
AIR_INIT_THIS;
char *tpl_str;
int tpl_len = 0;
zend_bool ret_res = 0;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sb", &tpl_str, &tpl_len, &ret_res) == FAILURE)
{
RETURN_FALSE;
}
smart_str ss_path = {0};
if(tpl_str[0] != '/'){
zval *root_path = NULL;
MAKE_STD_ZVAL(root_path);
if(zend_get_constant(ZEND_STRL("ROOT_PATH"), root_path) == FAILURE){
php_error_docref(NULL TSRMLS_CC, E_ERROR, "ROOT_PATH not defined");
}
smart_str_appendl(&ss_path, Z_STRVAL_P(root_path), Z_STRLEN_P(root_path));
smart_str_appendc(&ss_path, '/');
if(root_path != NULL){
zval_ptr_dtor(&root_path);
}
zval *tmp = NULL;
zval **tmp_pp;
zval *config = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_config"), 0 TSRMLS_CC);
if(config != NULL && Z_TYPE_P(config) == IS_ARRAY
&& zend_hash_find(Z_ARRVAL_P(config), ZEND_STRL("path"), (void **)&tmp_pp) == SUCCESS){
smart_str_appendl(&ss_path, Z_STRVAL_PP(tmp_pp), Z_STRLEN_PP(tmp_pp));
}else{
zval *app_conf;
zval *view_conf;
if(air_config_get(NULL, ZEND_STRS("app"), &app_conf TSRMLS_CC) == FAILURE){
AIR_NEW_EXCEPTION(1, "@error config: app");
}
zval *app_path = NULL;
if(air_config_get(app_conf, ZEND_STRS("path"), &app_path) == FAILURE){
AIR_NEW_EXCEPTION(1, "@error config: app.path");
}
zval *view_path = NULL;
if(air_config_get_path(app_conf, ZEND_STRS("view.path"), &view_path) == FAILURE){
AIR_NEW_EXCEPTION(1, "@view config not found");
}
smart_str_appendl(&ss_path, Z_STRVAL_P(app_path), Z_STRLEN_P(app_path));
smart_str_appendc(&ss_path, '/');
smart_str_appendl(&ss_path, Z_STRVAL_P(view_path), Z_STRLEN_P(view_path));
}
smart_str_appendc(&ss_path, '/');
}
smart_str_appendl(&ss_path, tpl_str, tpl_len);
smart_str_0(&ss_path);
//php_printf("full view path: %s\n", ss_path.c);
//构造运行时所需基本变量
HashTable *origin_symbol_table = NULL;
zval *output_handler = NULL;
long chunk_size = 0;
long flags = PHP_OUTPUT_HANDLER_STDFLAGS;
zval *view_ret = NULL;
//尝试缓存当前符号表
if(EG(active_symbol_table)){
origin_symbol_table = EG(active_symbol_table);
}
if (ret_res) {
MAKE_STD_ZVAL(view_ret);
if(php_output_start_user(output_handler, chunk_size, flags TSRMLS_CC) == FAILURE)
{
php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to create buffer");
RETURN_FALSE;
}
}
ALLOC_HASHTABLE(EG(active_symbol_table));
zval *data = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_data"), 0 TSRMLS_CC);
zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);
//将当前的模板变量放到符号表去
ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), "var", 4, data, Z_REFCOUNT_P(data) + 1, PZVAL_IS_REF(data));
if(air_loader_include_file(ss_path.c TSRMLS_CC) == FAILURE){
air_throw_exception_ex(1, "tpl %s render failed!\n", ss_path.c);
return ;
}
if(ret_res){
php_output_get_contents(view_ret TSRMLS_CC);
php_output_discard(TSRMLS_C);
RETVAL_ZVAL(view_ret, 1, 0);
zval_ptr_dtor(&view_ret);
}
zend_hash_destroy(EG(active_symbol_table));
FREE_HASHTABLE(EG(active_symbol_table));
EG(active_symbol_table) = origin_symbol_table;
smart_str_free(&ss_path);
}
/**
* Phalcon_Config_Adapter_Ini constructor
*
* @param string $filePath
* @return Phalcon_Config_Adapter_Ini
*
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct){
zval *file_path = NULL, *config = NULL, *ini_config = NULL, *directives = NULL;
zval *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL;
zval *a0 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &file_path) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(config, a0);
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 1);
PHALCON_INIT_VAR(ini_config);
PHALCON_CALL_FUNC_PARAMS_2(ini_config, "parse_ini_file", file_path, c0);
if (Z_TYPE_P(ini_config) == IS_BOOL && !Z_BVAL_P(ini_config)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_config_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "basename", file_path);
PHALCON_CONCAT_SVS(r0, "Configuration file ", r1, " can't be loaded");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r0, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
if (phalcon_valid_foreach(ini_config TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(ini_config);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_b840_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_b840_0;
} else {
PHALCON_INIT_VAR(section);
PHALCON_GET_FOREACH_KEY(section, ah0, hp0);
}
PHALCON_INIT_VAR(directives);
ZVAL_ZVAL(directives, *hd, 1, 0);
if (phalcon_valid_foreach(directives TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(directives);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_b840_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_b840_1;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, ".", 1);
PHALCON_INIT_VAR(r2);
phalcon_fast_strpos(r2, key, c1 TSRMLS_CC);
if (Z_TYPE_P(r2) != IS_BOOL || (Z_TYPE_P(r2) == IS_BOOL && Z_BVAL_P(r2))) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, ".", 1);
PHALCON_INIT_VAR(r3);
phalcon_fast_explode(r3, c2, key TSRMLS_CC);
PHALCON_CPY_WRT(directive_parts, r3);
if (Z_TYPE_P(config) == IS_ARRAY) {
PHALCON_INIT_VAR(t0);
phalcon_array_fetch(&t0, config, section, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t0) > 1) {
phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_long(&r4, directive_parts, 0, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(t0) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, t0, r4, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_long(&r5, directive_parts, 1, PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t1, r5, &value, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_b840_1;
fee_b840_1:
if(0){}
} else {
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_b840_0;
fee_b840_0:
if(0){}
} else {
return;
}
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon_Config_Adapter_Ini", "__construct", config);
PHALCON_MM_RESTORE();
}
