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