size 34 TSRM/TSRM.c size_t size; size 215 TSRM/TSRM.c TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor) size 219 TSRM/TSRM.c TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size)); size 238 TSRM/TSRM.c resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size; size 253 TSRM/TSRM.c p->storage[j] = (void *) malloc(resource_types_table[j].size); size 292 TSRM/TSRM.c (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size); size 758 TSRM/TSRM.c int size; size 762 TSRM/TSRM.c size = vfprintf(tsrm_error_file, format, args); size 766 TSRM/TSRM.c return size; size 111 TSRM/TSRM.h TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor); size 58 TSRM/tsrm_config_common.h # define tsrm_do_alloca_ex(size, limit, use_heap) \ size 59 TSRM/tsrm_config_common.h ((use_heap = ((size) > (limit))) ? malloc(size) : alloca(size)) size 60 TSRM/tsrm_config_common.h # define tsrm_do_alloca(size, use_heap) \ size 61 TSRM/tsrm_config_common.h tsrm_do_alloca_ex(size, TSRM_ALLOCA_MAX_SIZE, use_heap) size 591 TSRM/tsrm_win32.c TSRM_API int shmget(int key, int size, int flags) size 598 TSRM/tsrm_win32.c if (size < 0) { size 610 TSRM/tsrm_win32.c shm_handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, shm_segment); size 630 TSRM/tsrm_win32.c shm->descriptor->shm_segsz = size; size 642 TSRM/tsrm_win32.c if (NULL != shm->descriptor && (shm->descriptor->shm_perm.key != key || size > shm->descriptor->shm_segsz)) { size 104 TSRM/tsrm_win32.h TSRM_API int shmget(int key, int size, int flags); size 202 Zend/zend.h # define do_alloca_ex(size, limit, use_heap) \ size 203 Zend/zend.h ((use_heap = (UNEXPECTED((size) > (limit)))) ? emalloc(size) : alloca(size)) size 204 Zend/zend.h # define do_alloca(size, use_heap) \ size 205 Zend/zend.h do_alloca_ex(size, ZEND_ALLOCA_MAX_SIZE, use_heap) size 687 Zend/zend.h #define STR_REALLOC(ptr, size) \ size 688 Zend/zend.h ptr = (char *) erealloc(ptr, size); size 627 Zend/zend_API.c fci->size = 0; size 1009 Zend/zend_API.c ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC) /* {{{ */ size 1013 Zend/zend_API.c _zend_hash_init(Z_ARRVAL_P(arg), size, ZVAL_PTR_DTOR, 0 ZEND_FILE_LINE_RELAY_CC); size 3255 Zend/zend_API.c fci->size = sizeof(*fci); size 44 Zend/zend_API.h size_t size; size 234 Zend/zend_API.h #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0) size 364 Zend/zend_API.h #define array_init_size(arg, size) _array_init((arg), (size) ZEND_FILE_LINE_CC) size 368 Zend/zend_API.h ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC); size 153 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_mmap_realloc(zend_mm_storage *storage, zend_mm_segment* segment, size_t size) size 159 Zend/zend_alloc.c ret = (zend_mm_segment*)mremap(segment, segment->size, segment, size, MREMAP_MAYMOVE); size 161 Zend/zend_alloc.c ret = (zend_mm_segment*)mremap(segment, segment->size, size, MREMAP_MAYMOVE); size 165 Zend/zend_alloc.c ret = storage->handlers->_alloc(storage, size); size 167 Zend/zend_alloc.c memcpy(ret, segment, size > segment->size ? segment->size : size); size 178 Zend/zend_alloc.c munmap((void*)segment, segment->size); size 185 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_mmap_anon_alloc(zend_mm_storage *storage, size_t size) size 187 Zend/zend_alloc.c zend_mm_segment *ret = (zend_mm_segment*)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); size 220 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_mmap_zero_alloc(zend_mm_storage *storage, size_t size) size 222 Zend/zend_alloc.c zend_mm_segment *ret = (zend_mm_segment*)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, zend_mm_dev_zero_fd, 0); size 264 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_win32_alloc(zend_mm_storage *storage, size_t size) size 266 Zend/zend_alloc.c return (zend_mm_segment*) HeapAlloc((HANDLE)storage->data, HEAP_NO_SERIALIZE, size); size 274 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_win32_realloc(zend_mm_storage *storage, zend_mm_segment* segment, size_t size) size 276 Zend/zend_alloc.c return (zend_mm_segment*) HeapReAlloc((HANDLE)storage->data, HEAP_NO_SERIALIZE, segment, size); size 285 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_malloc_alloc(zend_mm_storage *storage, size_t size) size 287 Zend/zend_alloc.c return (zend_mm_segment*)malloc(size); size 290 Zend/zend_alloc.c static zend_mm_segment* zend_mm_mem_malloc_realloc(zend_mm_storage *storage, zend_mm_segment *ptr, size_t size) size 292 Zend/zend_alloc.c return (zend_mm_segment*)realloc(ptr, size); size 321 Zend/zend_alloc.c # define ZEND_MM_STORAGE_ALLOC(size) heap->storage->handlers->_alloc(heap->storage, size) size 322 Zend/zend_alloc.c # define ZEND_MM_STORAGE_REALLOC(ptr, size) heap->storage->handlers->_realloc(heap->storage, ptr, size) size 351 Zend/zend_alloc.c size_t size; size 360 Zend/zend_alloc.c size_t size; size 429 Zend/zend_alloc.c size_t size; size 502 Zend/zend_alloc.c #define ZEND_MM_BLOCK(b, type, size) do { \ size 503 Zend/zend_alloc.c size_t _size = (size); \ size 539 Zend/zend_alloc.c #define ZEND_MM_TRUE_SIZE(size) ((size<ZEND_MM_MIN_SIZE)?(ZEND_MM_ALIGNED_MIN_HEADER_SIZE):(ZEND_MM_ALIGNED_SIZE(size+ZEND_MM_ALIGNED_HEADER_SIZE+END_MAGIC_SIZE))) size 613 Zend/zend_alloc.c (((char*)(ZEND_MM_DATA_OF(block))) + ((zend_mm_block*)(block))->debug.size) size 619 Zend/zend_alloc.c ((zend_mm_block*)(block))->debug.size = (__size); \ size 632 Zend/zend_alloc.c ((zend_mm_block*)(block))->debug.size = (_size) size 661 Zend/zend_alloc.c static void *_zend_mm_alloc_int(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(2); size 663 Zend/zend_alloc.c static void *_zend_mm_realloc_int(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(3); size 729 Zend/zend_alloc.c size_t size; size 734 Zend/zend_alloc.c size = ZEND_MM_FREE_BLOCK_SIZE(mm_block); size 735 Zend/zend_alloc.c if (EXPECTED(!ZEND_MM_SMALL_SIZE(size))) { size 738 Zend/zend_alloc.c index = ZEND_MM_LARGE_BUCKET_INDEX(size); size 749 Zend/zend_alloc.c for (m = size << (ZEND_MM_NUM_BUCKETS - index); ; m <<= 1) { size 752 Zend/zend_alloc.c if (ZEND_MM_FREE_BLOCK_SIZE(prev) != size) { size 774 Zend/zend_alloc.c index = ZEND_MM_BUCKET_INDEX(size); size 927 Zend/zend_alloc.c heap->real_size -= segment->size; size 941 Zend/zend_alloc.c size_t size = ZEND_MM_BLOCK_SIZE(mm_block); size 945 Zend/zend_alloc.c heap->cached -= size; size 949 Zend/zend_alloc.c size += ZEND_MM_FREE_BLOCK_SIZE(mm_block); size 953 Zend/zend_alloc.c size += ZEND_MM_FREE_BLOCK_SIZE(next_block); size 956 Zend/zend_alloc.c ZEND_MM_BLOCK(mm_block, ZEND_MM_FREE_BLOCK, size); size 977 Zend/zend_alloc.c static void zend_mm_random(unsigned char *buf, size_t size) /* {{{ */ size 999 Zend/zend_alloc.c BOOL ret = CryptGenRandom(hCryptProv, size, buf); size 1002 Zend/zend_alloc.c while (i < size && buf[i] != 0) { size 1005 Zend/zend_alloc.c if (i == size) { size 1015 Zend/zend_alloc.c if (read(fd, buf, size) == size) { size 1016 Zend/zend_alloc.c while (i < size && buf[i] != 0) { size 1019 Zend/zend_alloc.c if (i == size) { size 1028 Zend/zend_alloc.c while (i < size) { size 1120 Zend/zend_alloc.c heap->size = 0; size 1252 Zend/zend_alloc.c (char*)q > (char*)segment + segment->size || size 1288 Zend/zend_alloc.c (char*)q > (char*)segment + segment->size || size 1300 Zend/zend_alloc.c leak.size = p->debug.size; size 1438 Zend/zend_alloc.c zend_debug_alloc_output("OK (allocated on %s:%d, %d bytes)\n", p->debug.filename, p->debug.lineno, (int)p->debug.size); size 1572 Zend/zend_alloc.c (char*)q > (char*)segment + segment->size || size 1631 Zend/zend_alloc.c size_t size, true_size, min_size, max_size; size 1635 Zend/zend_alloc.c size = 0; size 1637 Zend/zend_alloc.c true_size = ZEND_MM_TRUE_SIZE(size); size 1639 Zend/zend_alloc.c min_size = size; size 1641 Zend/zend_alloc.c size++; size 1643 Zend/zend_alloc.c true_size = ZEND_MM_TRUE_SIZE(size); size 1647 Zend/zend_alloc.c max_size = size-1; size 1651 Zend/zend_alloc.c max_size = size-1; size 1654 Zend/zend_alloc.c size++; size 1718 Zend/zend_alloc.c heap->real_size = heap->segments_list->size; size 1719 Zend/zend_alloc.c heap->real_peak = heap->segments_list->size; size 1724 Zend/zend_alloc.c heap->size = 0; size 1729 Zend/zend_alloc.c size_t block_size = heap->segments_list->size - ZEND_MM_ALIGNED_SEGMENT_SIZE - ZEND_MM_ALIGNED_HEADER_SIZE; size 1750 Zend/zend_alloc.c size_t size) size 1782 Zend/zend_alloc.c size); size 1793 Zend/zend_alloc.c size); size 1880 Zend/zend_alloc.c static void *_zend_mm_alloc_int(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1883 Zend/zend_alloc.c size_t true_size = ZEND_MM_TRUE_SIZE(size); size 1899 Zend/zend_alloc.c if (UNEXPECTED(true_size < size)) { size 1913 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(best_fit, size, 1, 0); size 1976 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %lu bytes)", heap->limit, __zend_filename, __zend_lineno, size); size 1978 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %lu bytes)", heap->limit, size); size 1992 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %ld) at %s:%d (tried to allocate %lu bytes)", heap->real_size, __zend_filename, __zend_lineno, size); size 1994 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %ld) (tried to allocate %lu bytes)", heap->real_size, size); size 2004 Zend/zend_alloc.c segment->size = segment_size; size 2047 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(best_fit, size, 1, 1); size 2049 Zend/zend_alloc.c heap->size += true_size; size 2050 Zend/zend_alloc.c if (heap->peak < heap->size) { size 2051 Zend/zend_alloc.c heap->peak = heap->size; size 2064 Zend/zend_alloc.c size_t size; size 2075 Zend/zend_alloc.c size = ZEND_MM_BLOCK_SIZE(mm_block); size 2079 Zend/zend_alloc.c memset(ZEND_MM_DATA_OF(mm_block), 0x5a, mm_block->debug.size); size 2083 Zend/zend_alloc.c if (EXPECTED(ZEND_MM_SMALL_SIZE(size)) && EXPECTED(heap->cached < ZEND_MM_CACHE_SIZE)) { size 2084 Zend/zend_alloc.c size_t index = ZEND_MM_BUCKET_INDEX(size); size 2089 Zend/zend_alloc.c heap->cached += size; size 2101 Zend/zend_alloc.c heap->size -= size; size 2103 Zend/zend_alloc.c next_block = ZEND_MM_BLOCK_AT(mm_block, size); size 2106 Zend/zend_alloc.c size += ZEND_MM_FREE_BLOCK_SIZE(next_block); size 2111 Zend/zend_alloc.c size += ZEND_MM_FREE_BLOCK_SIZE(mm_block); size 2114 Zend/zend_alloc.c ZEND_MM_IS_GUARD_BLOCK(ZEND_MM_BLOCK_AT(mm_block, size))) { size 2117 Zend/zend_alloc.c ZEND_MM_BLOCK(mm_block, ZEND_MM_FREE_BLOCK, size); size 2123 Zend/zend_alloc.c static void *_zend_mm_realloc_int(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2134 Zend/zend_alloc.c return _zend_mm_alloc_int(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2140 Zend/zend_alloc.c true_size = ZEND_MM_TRUE_SIZE(size); size 2144 Zend/zend_alloc.c if (UNEXPECTED(true_size < size)) { size 2168 Zend/zend_alloc.c heap->size += (true_size - orig_size); size 2170 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(mm_block, size, 0, 0); size 2190 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(best_fit, size, 1, 0); size 2195 Zend/zend_alloc.c memcpy(ptr, p, mm_block->debug.size); size 2250 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(mm_block, size, 0, 0); size 2251 Zend/zend_alloc.c heap->size = heap->size + true_size - orig_size; size 2252 Zend/zend_alloc.c if (heap->peak < heap->size) { size 2253 Zend/zend_alloc.c heap->peak = heap->size; size 2280 Zend/zend_alloc.c heap->real_size + segment_size - segment_copy->size > heap->limit) { size 2289 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %ld bytes)", heap->limit, __zend_filename, __zend_lineno, size); size 2291 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %ld bytes)", heap->limit, size); size 2304 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %ld) at %s:%d (tried to allocate %ld bytes)", heap->real_size, __zend_filename, __zend_lineno, size); size 2306 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %ld) (tried to allocate %ld bytes)", heap->real_size, size); size 2310 Zend/zend_alloc.c heap->real_size += segment_size - segment->size; size 2315 Zend/zend_alloc.c segment->size = segment_size; size 2348 Zend/zend_alloc.c ZEND_MM_SET_DEBUG_INFO(mm_block, size, 1, 1); size 2350 Zend/zend_alloc.c heap->size = heap->size + true_size - orig_size; size 2351 Zend/zend_alloc.c if (heap->peak < heap->size) { size 2352 Zend/zend_alloc.c heap->peak = heap->size; size 2359 Zend/zend_alloc.c ptr = _zend_mm_alloc_int(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2361 Zend/zend_alloc.c memcpy(ptr, p, mm_block->debug.size); size 2370 Zend/zend_alloc.c ZEND_API void *_zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2372 Zend/zend_alloc.c return _zend_mm_alloc_int(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2380 Zend/zend_alloc.c ZEND_API void *_zend_mm_realloc(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2382 Zend/zend_alloc.c return _zend_mm_realloc_int(heap, ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2395 Zend/zend_alloc.c return mm_block->debug.size; size 2422 Zend/zend_alloc.c ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2427 Zend/zend_alloc.c return AG(mm_heap)->_malloc(size); size 2429 Zend/zend_alloc.c return _zend_mm_alloc_int(AG(mm_heap), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2443 Zend/zend_alloc.c ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2448 Zend/zend_alloc.c return AG(mm_heap)->_realloc(ptr, size); size 2450 Zend/zend_alloc.c return _zend_mm_realloc_int(AG(mm_heap), ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2463 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2471 Zend/zend_alloc.c "rm"(size), size 2475 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2483 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2499 Zend/zend_alloc.c "rm"(size), size 2504 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2512 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2520 Zend/zend_alloc.c "r"(size), size 2525 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2533 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2541 Zend/zend_alloc.c "r"(size), size 2545 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2553 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2555 Zend/zend_alloc.c zend_ulong64 res = (zend_ulong64)nmemb * (zend_ulong64)size + (zend_ulong64)offset; size 2558 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2566 Zend/zend_alloc.c static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2568 Zend/zend_alloc.c size_t res = nmemb * size + offset; size 2569 Zend/zend_alloc.c double _d = (double)nmemb * (double)size + (double)offset; size 2573 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2581 Zend/zend_alloc.c ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2583 Zend/zend_alloc.c return emalloc_rel(safe_address(nmemb, size, offset)); size 2586 Zend/zend_alloc.c ZEND_API void *_safe_malloc(size_t nmemb, size_t size, size_t offset) size 2588 Zend/zend_alloc.c return pemalloc(safe_address(nmemb, size, offset), 1); size 2591 Zend/zend_alloc.c ZEND_API void *_safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2593 Zend/zend_alloc.c return erealloc_rel(ptr, safe_address(nmemb, size, offset)); size 2596 Zend/zend_alloc.c ZEND_API void *_safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset) size 2598 Zend/zend_alloc.c return perealloc(ptr, safe_address(nmemb, size, offset), 1); size 2602 Zend/zend_alloc.c ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2610 Zend/zend_alloc.c p = _safe_emalloc(nmemb, size, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2615 Zend/zend_alloc.c memset(p, 0, size * nmemb); size 2699 Zend/zend_alloc.c size_t usage = AG(mm_heap)->size; size 42 Zend/zend_alloc.h #define ZEND_MM_ALIGNED_SIZE(size) (((size) + ZEND_MM_ALIGNMENT - 1) & ZEND_MM_ALIGNMENT_MASK) size 46 Zend/zend_alloc.h size_t size; size 57 Zend/zend_alloc.h ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1); size 58 Zend/zend_alloc.h ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; size 59 Zend/zend_alloc.h ZEND_API void *_safe_malloc(size_t nmemb, size_t size, size_t offset) ZEND_ATTRIBUTE_MALLOC; size 61 Zend/zend_alloc.h ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE2(1,2); size 62 Zend/zend_alloc.h ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2); size 63 Zend/zend_alloc.h ZEND_API void *_safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 64 Zend/zend_alloc.h ZEND_API void *_safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset); size 70 Zend/zend_alloc.h #define emalloc(size) _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 71 Zend/zend_alloc.h #define safe_emalloc(nmemb, size, offset) _safe_emalloc((nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 73 Zend/zend_alloc.h #define ecalloc(nmemb, size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 74 Zend/zend_alloc.h #define erealloc(ptr, size) _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 75 Zend/zend_alloc.h #define safe_erealloc(ptr, nmemb, size, offset) _safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 76 Zend/zend_alloc.h #define erealloc_recoverable(ptr, size) _erealloc((ptr), (size), 1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 82 Zend/zend_alloc.h #define emalloc_rel(size) _emalloc((size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 83 Zend/zend_alloc.h #define safe_emalloc_rel(nmemb, size, offset) _safe_emalloc((nmemb), (size), (offset) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 85 Zend/zend_alloc.h #define ecalloc_rel(nmemb, size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 86 Zend/zend_alloc.h #define erealloc_rel(ptr, size) _erealloc((ptr), (size), 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 87 Zend/zend_alloc.h #define erealloc_recoverable_rel(ptr, size) _erealloc((ptr), (size), 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 88 Zend/zend_alloc.h #define safe_erealloc_rel(ptr, nmemb, size, offset) _safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 122 Zend/zend_alloc.h #define pemalloc(size, persistent) ((persistent)?__zend_malloc(size):emalloc(size)) size 123 Zend/zend_alloc.h #define safe_pemalloc(nmemb, size, offset, persistent) ((persistent)?_safe_malloc(nmemb, size, offset):safe_emalloc(nmemb, size, offset)) size 125 Zend/zend_alloc.h #define pecalloc(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc((nmemb), (size))) size 126 Zend/zend_alloc.h #define perealloc(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc((ptr), (size))) size 127 Zend/zend_alloc.h #define safe_perealloc(ptr, nmemb, size, offset, persistent) ((persistent)?_safe_realloc((ptr), (nmemb), (size), (offset)):safe_erealloc((ptr), (nmemb), (size), (offset))) size 128 Zend/zend_alloc.h #define perealloc_recoverable(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_recoverable((ptr), (size))) size 132 Zend/zend_alloc.h #define pemalloc_rel(size, persistent) ((persistent)?__zend_malloc(size):emalloc_rel(size)) size 134 Zend/zend_alloc.h #define pecalloc_rel(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc_rel((nmemb), (size))) size 135 Zend/zend_alloc.h #define perealloc_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_rel((ptr), (size))) size 136 Zend/zend_alloc.h #define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size))) size 195 Zend/zend_alloc.h ZEND_API void *_zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; size 197 Zend/zend_alloc.h ZEND_API void *_zend_mm_realloc(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 200 Zend/zend_alloc.h #define zend_mm_alloc(heap, size) _zend_mm_alloc((heap), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 202 Zend/zend_alloc.h #define zend_mm_realloc(heap, p, size) _zend_mm_realloc((heap), (p), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 205 Zend/zend_alloc.h #define zend_mm_alloc_rel(heap, size) _zend_mm_alloc((heap), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 207 Zend/zend_alloc.h #define zend_mm_realloc_rel(heap, p, size) _zend_mm_realloc((heap), (p), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 214 Zend/zend_alloc.h size_t size; size 223 Zend/zend_alloc.h zend_mm_segment* (*_alloc)(zend_mm_storage *storage, size_t size); size 224 Zend/zend_alloc.h zend_mm_segment* (*_realloc)(zend_mm_storage *storage, zend_mm_segment *ptr, size_t size); size 3367 Zend/zend_compile.c #define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \ size 3368 Zend/zend_compile.c if (UNEXPECTED(offset - buf + size >= length)) { \ size 3369 Zend/zend_compile.c length += size + 1; \ size 31 Zend/zend_dynamic_array.c ZEND_API int zend_dynamic_array_init(dynamic_array *da, unsigned int element_size, unsigned int size) size 34 Zend/zend_dynamic_array.c da->allocated = size; size 36 Zend/zend_dynamic_array.c da->array = (char *) emalloc(size*element_size); size 33 Zend/zend_dynamic_array.h ZEND_API int zend_dynamic_array_init(dynamic_array *da, unsigned int element_size, unsigned int size); size 697 Zend/zend_exceptions.c fci.size = sizeof(fci); size 235 Zend/zend_execute.h static zend_always_inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC) size 239 Zend/zend_execute.h size = (size + (sizeof(void*) - 1)) / sizeof(void*); size 245 Zend/zend_execute.h if (UNEXPECTED(size + extra + ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*) > size 247 Zend/zend_execute.h zend_vm_stack_extend(size TSRMLS_CC); size 257 Zend/zend_execute.h ZEND_VM_STACK_GROW_IF_NEEDED((int)size); size 260 Zend/zend_execute.h EG(argument_stack)->top += size; size 607 Zend/zend_execute_API.c fci.size = sizeof(fci); size 646 Zend/zend_execute_API.c switch (fci->size) { size 988 Zend/zend_execute_API.c fcall_info.size = sizeof(fcall_info); size 745 Zend/zend_hash.c ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size) size 761 Zend/zend_hash.c zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &new_entry); size 763 Zend/zend_hash.c zend_hash_index_update(target, p->h, p->pData, size, &new_entry); size 776 Zend/zend_hash.c ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC) size 788 Zend/zend_hash.c if (_zend_hash_quick_add_or_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t, mode ZEND_FILE_LINE_RELAY_CC)==SUCCESS && pCopyConstructor) { size 792 Zend/zend_hash.c if ((mode==HASH_UPDATE || !zend_hash_index_exists(target, p->h)) && zend_hash_index_update(target, p->h, p->pData, size, &t)==SUCCESS && pCopyConstructor) { size 813 Zend/zend_hash.c ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam) size 824 Zend/zend_hash.c if (zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t)==SUCCESS && pCopyConstructor) { size 217 Zend/zend_hash.h ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size); size 218 Zend/zend_hash.h ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC); size 219 Zend/zend_hash.h ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam); size 224 Zend/zend_hash.h #define zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite) \ size 225 Zend/zend_hash.h _zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite ZEND_FILE_LINE_CC) size 278 Zend/zend_ini_scanner.c size_t size; size 280 Zend/zend_ini_scanner.c if (zend_stream_fixup(fh, &buf, &size TSRMLS_CC) == FAILURE) { size 289 Zend/zend_ini_scanner.c yy_scan_buffer(buf, size TSRMLS_CC); size 47 Zend/zend_interfaces.c fci.size = sizeof(fci); size 483 Zend/zend_language_scanner.c size_t size, offset = 0; size 492 Zend/zend_language_scanner.c if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) { size 508 Zend/zend_language_scanner.c if (size != -1) { size 511 Zend/zend_language_scanner.c SCNG(script_org_size) = size; size 522 Zend/zend_language_scanner.c size = SCNG(script_filtered_size); size 526 Zend/zend_language_scanner.c yy_scan_buffer(buf, size TSRMLS_CC); size 656 Zend/zend_language_scanner.c size_t size; size 666 Zend/zend_language_scanner.c size = Z_STRLEN_P(str); size 670 Zend/zend_language_scanner.c SCNG(script_org_size) = size; size 681 Zend/zend_language_scanner.c size = SCNG(script_filtered_size); size 685 Zend/zend_language_scanner.c yy_scan_buffer(buf, size TSRMLS_CC); size 26 Zend/zend_llist.c ZEND_API void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent) size 31 Zend/zend_llist.c l->size = size; size 39 Zend/zend_llist.c zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent); size 49 Zend/zend_llist.c memcpy(tmp->data, element, l->size); size 57 Zend/zend_llist.c zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent); size 67 Zend/zend_llist.c memcpy(tmp->data, element, l->size); size 162 Zend/zend_llist.c zend_llist_init(dst, src->size, src->dtor, src->persistent); size 41 Zend/zend_llist.h size_t size; size 50 Zend/zend_llist.h ZEND_API void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent); size 74 Zend/zend_modules.h unsigned short size; size 186 Zend/zend_multibyte.c size_t size = 0; size 193 Zend/zend_multibyte.c if (FAILURE == zend_multibyte_parse_encoding_list(new_value, new_value_length, &list, &size, 1 TSRMLS_CC)) { size 197 Zend/zend_multibyte.c if (size == 0) { size 202 Zend/zend_multibyte.c if (FAILURE == zend_multibyte_set_script_encoding(list, size TSRMLS_CC)) { size 34 Zend/zend_objects_API.c objects->size = init_size; size 116 Zend/zend_objects_API.c if (EG(objects_store).top == EG(objects_store).size) { size 117 Zend/zend_objects_API.c EG(objects_store).size <<= 1; size 118 Zend/zend_objects_API.c EG(objects_store).object_buckets = (zend_object_store_bucket *) erealloc(EG(objects_store).object_buckets, EG(objects_store).size * sizeof(zend_object_store_bucket)); size 54 Zend/zend_objects_API.h zend_uint size; size 46 Zend/zend_opcode.c static void op_array_alloc_ops(zend_op_array *op_array, zend_uint size) size 48 Zend/zend_opcode.c op_array->opcodes = erealloc(op_array->opcodes, size * sizeof(zend_op)); size 33 Zend/zend_stack.c ZEND_API int zend_stack_push(zend_stack *stack, const void *element, int size) size 42 Zend/zend_stack.c stack->elements[stack->top] = (void *) emalloc(size); size 43 Zend/zend_stack.c memcpy(stack->elements[stack->top], element, size); size 35 Zend/zend_stack.h ZEND_API int zend_stack_push(zend_stack *stack, const void *element, int size); size 31 Zend/zend_static_allocator.c inline static char *block_allocate(Block *block, zend_uint size) size 34 Zend/zend_static_allocator.c if ((block->pos += size) >= block->end) { size 53 Zend/zend_static_allocator.c char *static_allocator_allocate(StaticAllocator *sa, zend_uint size) size 57 Zend/zend_static_allocator.c retval = block_allocate(&sa->Blocks[sa->current_block], size); size 63 Zend/zend_static_allocator.c block_init(&sa->Blocks[sa->current_block], (size > ALLOCATOR_BLOCK_SIZE) ? size : ALLOCATOR_BLOCK_SIZE); size 64 Zend/zend_static_allocator.c retval = block_allocate(&sa->Blocks[sa->current_block], size); size 44 Zend/zend_static_allocator.h char *static_allocator_allocate(StaticAllocator *sa, zend_uint size); size 183 Zend/zend_stream.c size_t size; size 222 Zend/zend_stream.c size = zend_stream_fsize(file_handle TSRMLS_CC); size 223 Zend/zend_stream.c if (size == (size_t)-1) { size 230 Zend/zend_stream.c if (old_type == ZEND_HANDLE_FP && !file_handle->handle.stream.isatty && size) { size 235 Zend/zend_stream.c size != 0 && size 236 Zend/zend_stream.c ((size - 1) % page_size) <= page_size - ZEND_MMAP_AHEAD) { size 238 Zend/zend_stream.c *buf = mmap(0, size + ZEND_MMAP_AHEAD, PROT_READ, MAP_PRIVATE, fileno(file_handle->handle.fp), 0); size 245 Zend/zend_stream.c size -= offset; size 248 Zend/zend_stream.c file_handle->handle.stream.mmap.len = size; size 255 Zend/zend_stream.c file_handle->handle.stream.mmap.buf = *buf = safe_emalloc(1, size, ZEND_MMAP_AHEAD); size 256 Zend/zend_stream.c file_handle->handle.stream.mmap.len = zend_stream_read(file_handle, *buf, size TSRMLS_CC); size 260 Zend/zend_stream.c size = 0; size 262 Zend/zend_stream.c while ((read = zend_stream_read(file_handle, *buf + size, remain TSRMLS_CC)) > 0) { size 263 Zend/zend_stream.c size += read; size 267 Zend/zend_stream.c *buf = safe_erealloc(*buf, size, 2, 0); size 268 Zend/zend_stream.c remain = size; size 272 Zend/zend_stream.c file_handle->handle.stream.mmap.len = size; size 273 Zend/zend_stream.c if (size && remain < ZEND_MMAP_AHEAD) { size 274 Zend/zend_stream.c *buf = safe_erealloc(*buf, size, 1, ZEND_MMAP_AHEAD); size 43 Zend/zend_string.c size_t size = 1024 * 1024; size 46 Zend/zend_string.c CG(interned_strings_start) = valloc(size); size 48 Zend/zend_string.c CG(interned_strings_start) = malloc(size); size 53 Zend/zend_string.c CG(interned_strings_end) = CG(interned_strings_start) + size; size 267 Zend/zend_ts_hash.c ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size) size 271 Zend/zend_ts_hash.c zend_hash_copy(TS_HASH(target), TS_HASH(source), pCopyConstructor, tmp, size); size 276 Zend/zend_ts_hash.c ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size) size 279 Zend/zend_ts_hash.c zend_hash_copy(target, TS_HASH(source), pCopyConstructor, tmp, size); size 283 Zend/zend_ts_hash.c ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite) size 287 Zend/zend_ts_hash.c zend_hash_merge(TS_HASH(target), TS_HASH(source), pCopyConstructor, tmp, size, overwrite); size 292 Zend/zend_ts_hash.c ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam) size 296 Zend/zend_ts_hash.c zend_hash_merge_ex(TS_HASH(target), TS_HASH(source), pCopyConstructor, size, pMergeSource, pParam); size 99 Zend/zend_ts_hash.h ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size); size 100 Zend/zend_ts_hash.h ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size); size 101 Zend/zend_ts_hash.h ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite); size 102 Zend/zend_ts_hash.h ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam); size 563 Zend/zend_virtual_cwd.c CWD_API char *virtual_getcwd(char *buf, size_t size TSRMLS_DC) /* {{{ */ size 573 Zend/zend_virtual_cwd.c if (length > size-1) { size 673 Zend/zend_virtual_cwd.c long size = sizeof(realpath_cache_bucket) + path_len + 1; size 678 Zend/zend_virtual_cwd.c size += realpath_len + 1; size 682 Zend/zend_virtual_cwd.c if (CWDG(realpath_cache_size) + size <= CWDG(realpath_cache_size_limit)) { size 683 Zend/zend_virtual_cwd.c realpath_cache_bucket *bucket = malloc(size); size 716 Zend/zend_virtual_cwd.c CWDG(realpath_cache_size) += size; size 157 Zend/zend_virtual_cwd.h CWD_API char *virtual_getcwd(char *buf, size_t size TSRMLS_DC); size 260 Zend/zend_virtual_cwd.h #define VCWD_GETCWD(buff, size) virtual_getcwd(buff, size TSRMLS_CC) size 292 Zend/zend_virtual_cwd.h #define VCWD_GETCWD(buff, size) getcwd(buff, size) size 48 ext/bcmath/libbcmath/src/div.c _one_mult (num, size, digit, result) size 50 ext/bcmath/libbcmath/src/div.c int size, digit; size 57 ext/bcmath/libbcmath/src/div.c memset (result, 0, size); size 61 ext/bcmath/libbcmath/src/div.c memcpy (result, num, size); size 65 ext/bcmath/libbcmath/src/div.c nptr = (unsigned char *) (num+size-1); size 66 ext/bcmath/libbcmath/src/div.c rptr = (unsigned char *) (result+size-1); size 69 ext/bcmath/libbcmath/src/div.c while (size-- > 0) size 61 ext/bcmath/libbcmath/src/output.c bc_out_long (val, size, space, out_char) size 63 ext/bcmath/libbcmath/src/output.c int size, space; size 76 ext/bcmath/libbcmath/src/output.c while (size > len) size 79 ext/bcmath/libbcmath/src/output.c size--; size 545 ext/bz2/bz2.c unsigned __int64 size = 0; size 547 ext/bz2/bz2.c unsigned long long size = 0; size 572 ext/bz2/bz2.c size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32; size 573 ext/bz2/bz2.c dest = safe_erealloc(dest, 1, bzs.avail_out+1, (size_t) size ); size 574 ext/bz2/bz2.c bzs.next_out = dest + size; size 578 ext/bz2/bz2.c size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32; size 579 ext/bz2/bz2.c dest = safe_erealloc(dest, 1, (size_t) size, 1); size 580 ext/bz2/bz2.c dest[size] = '\0'; size 581 ext/bz2/bz2.c RETVAL_STRINGL(dest, (int) size, 0); size 54 ext/bz2/bz2_filter.c static void *php_bz2_alloc(void *opaque, int items, int size) size 56 ext/bz2/bz2_filter.c return (void *)safe_pemalloc(items, size, 0, ((php_bz2_filter_data*)opaque)->persistent); size 482 ext/com_dotnet/com_persist.c ULARGE_INTEGER size; size 489 ext/com_dotnet/com_persist.c res = IPersistStreamInit_GetSizeMax(helper->ipsi, &size); size 493 ext/com_dotnet/com_persist.c res = IPersistStream_GetSizeMax(helper->ips, &size); size 504 ext/com_dotnet/com_persist.c RETURN_LONG((LONG)size.QuadPart); size 1287 ext/curl/interface.c static size_t curl_write_nothing(char *data, size_t size, size_t nmemb, void *ctx) size 1289 ext/curl/interface.c return size * nmemb; size 1295 ext/curl/interface.c static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) size 1299 ext/curl/interface.c size_t length = size * nmemb; size 1304 ext/curl/interface.c fprintf(stderr, "data = %s, size = %d, nmemb = %d, ctx = %x\n", data, size, nmemb, ctx); size 1312 ext/curl/interface.c return fwrite(data, size, nmemb, t->fp); size 1335 ext/curl/interface.c fci.size = sizeof(fci); size 1402 ext/curl/interface.c fci.size = sizeof(fci); size 1481 ext/curl/interface.c fci.size = sizeof(fci); size 1520 ext/curl/interface.c static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) size 1529 ext/curl/interface.c length = fread(data, size, nmemb, t->fp); size 1550 ext/curl/interface.c ZVAL_LONG(zlength, (int) size * nmemb); size 1556 ext/curl/interface.c fci.size = sizeof(fci); size 1577 ext/curl/interface.c length = MIN((int) (size * nmemb), Z_STRLEN_P(retval_ptr)); size 1596 ext/curl/interface.c static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx) size 1600 ext/curl/interface.c size_t length = size * nmemb; size 1614 ext/curl/interface.c return fwrite(data, size, nmemb, t->fp); size 1633 ext/curl/interface.c fci.size = sizeof(fci); size 215 ext/dba/dba_cdb.c # define cdb_file_read(fildes, buf, size) php_stream_read(fildes, buf, size) size 217 ext/dba/dba_cdb.c # define cdb_file_read(fildes, buf, size) read(fildes, buf, size) size 39 ext/dba/dba_db1.c #define DB1_GKEY DBT gkey; gkey.data = (char *) key; gkey.size = keylen size 105 ext/dba/dba_db1.c if (newlen) *newlen = gval.size; size 106 ext/dba/dba_db1.c return estrndup(gval.data, gval.size); size 118 ext/dba/dba_db1.c gval.size = vallen; size 150 ext/dba/dba_db1.c if (newlen) *newlen = gkey.size; size 151 ext/dba/dba_db1.c return estrndup(gkey.data, gkey.size); size 166 ext/dba/dba_db1.c if (newlen) *newlen = gkey.size; size 167 ext/dba/dba_db1.c return estrndup(gkey.data, gkey.size); size 40 ext/dba/dba_db2.c gkey.size = keylen size 109 ext/dba/dba_db2.c if (newlen) *newlen = gval.size; size 110 ext/dba/dba_db2.c return estrndup(gval.data, gval.size); size 120 ext/dba/dba_db2.c gval.size = vallen; size 179 ext/dba/dba_db2.c if (newlen) *newlen = gkey.size; size 180 ext/dba/dba_db2.c return estrndup(gkey.data, gkey.size); size 49 ext/dba/dba_db3.c gkey.data = (char *) key; gkey.size = keylen size 132 ext/dba/dba_db3.c if (newlen) *newlen = gval.size; size 133 ext/dba/dba_db3.c new = estrndup(gval.data, gval.size); size 146 ext/dba/dba_db3.c gval.size = vallen; size 204 ext/dba/dba_db3.c nkey = estrndup(gkey.data, gkey.size); size 205 ext/dba/dba_db3.c if (newlen) *newlen = gkey.size; size 67 ext/dba/dba_db4.c gkey.data = (char *) key; gkey.size = keylen size 173 ext/dba/dba_db4.c if (newlen) *newlen = gval.size; size 174 ext/dba/dba_db4.c new = estrndup(gval.data, gval.size); size 190 ext/dba/dba_db4.c gval.size = vallen; size 260 ext/dba/dba_db4.c nkey = estrndup(gkey.data, gkey.size); size 261 ext/dba/dba_db4.c if (newlen) *newlen = gkey.size; size 108 ext/dba/libflatfile/flatfile.c size_t size = key_datum.dsize; size 130 ext/dba/libflatfile/flatfile.c if (size == num && !memcmp(buf, key, size)) { size 164 ext/dba/libflatfile/flatfile.c size_t size = key_datum.dsize; size 178 ext/dba/libflatfile/flatfile.c if (size == num) { size 179 ext/dba/libflatfile/flatfile.c if (!memcmp(buf, key, size)) { size 312 ext/dba/libinifile/inifile.c static int inifile_truncate(inifile *dba, size_t size TSRMLS_DC) size 316 ext/dba/libinifile/inifile.c if ((res=php_stream_truncate_set_size(dba->fp, size)) != 0) { size 320 ext/dba/libinifile/inifile.c php_stream_seek(dba->fp, size, SEEK_SET); size 1746 ext/dom/document.c int size, format, saveempty = 0; size 1791 ext/dom/document.c xmlDocDumpFormatMemory(docp, &mem, &size, format); size 1795 ext/dom/document.c if (!size) { size 1798 ext/dom/document.c RETVAL_STRINGL(mem, size, 1); size 2268 ext/dom/document.c int size = 0, format; size 2303 ext/dom/document.c size += one_size; size 2305 ext/dom/document.c size = -1; size 2310 ext/dom/document.c size = htmlNodeDump(buf, docp, node); size 2312 ext/dom/document.c if (size >= 0) { size 2317 ext/dom/document.c RETVAL_STRINGL((const char*) mem, size, 1); size 2326 ext/dom/document.c htmlDocDumpMemoryFormat(docp, &mem, &size, format); size 2328 ext/dom/document.c htmlDocDumpMemory(docp, &mem, &size); size 2330 ext/dom/document.c if (!size) { size 2333 ext/dom/document.c RETVAL_STRINGL((const char*) mem, size, 1); size 180 ext/dom/xpath.c fci.size = sizeof(fci); size 636 ext/ereg/ereg.c int err, size, copts = 0; size 677 ext/ereg/ereg.c size = subs[0].rm_so; size 680 ext/ereg/ereg.c add_next_index_stringl(return_value, strp, size, 1); size 703 ext/ereg/ereg.c size = endp - strp; size 705 ext/ereg/ereg.c add_next_index_stringl(return_value, strp, size, 1); size 1464 ext/ereg/regex/regcomp.c enlarge(p, size) size 1466 ext/ereg/regex/regcomp.c register sopno size; size 1470 ext/ereg/regex/regcomp.c if (p->ssize >= size) size 1473 ext/ereg/regex/regcomp.c sp = (sop *)realloc(p->strip, size*sizeof(sop)); size 1479 ext/ereg/regex/regcomp.c p->ssize = size; size 1483 ext/exif/exif.c size_t size; size 1495 ext/exif/exif.c size_t size; size 1502 ext/exif/exif.c size_t size; size 1598 ext/exif/exif.c static int exif_file_sections_add(image_info_type *ImageInfo, int type, size_t size, uchar *data) size 1607 ext/exif/exif.c ImageInfo->file.list[count].size = 0; size 1609 ext/exif/exif.c if (!size) { size 1612 ext/exif/exif.c data = safe_emalloc(size, 1, 0); size 1616 ext/exif/exif.c ImageInfo->file.list[count].size = size; size 1624 ext/exif/exif.c static int exif_file_sections_realloc(image_info_type *ImageInfo, int section_index, size_t size TSRMLS_DC) size 1635 ext/exif/exif.c tmp = safe_erealloc(ImageInfo->file.list[section_index].data, 1, size, 0); size 1637 ext/exif/exif.c ImageInfo->file.list[section_index].size = size; size 2446 ext/exif/exif.c if (!ImageInfo->read_thumbnail || !ImageInfo->Thumbnail.offset || !ImageInfo->Thumbnail.size) { size 2473 ext/exif/exif.c new_data = safe_erealloc(ImageInfo->Thumbnail.data, 1, ImageInfo->Thumbnail.size, new_size); size 2475 ext/exif/exif.c memmove(ImageInfo->Thumbnail.data + new_move, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 2476 ext/exif/exif.c ImageInfo->Thumbnail.size += new_size; size 2536 ext/exif/exif.c if (ImageInfo->Thumbnail.size >= 65536 size 2537 ext/exif/exif.c || ImageInfo->Thumbnail.size <= 0 size 2544 ext/exif/exif.c if ((ImageInfo->Thumbnail.offset + ImageInfo->Thumbnail.size) > length) { size 2548 ext/exif/exif.c ImageInfo->Thumbnail.data = estrndup(offset + ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size); size 2699 ext/exif/exif.c &xp_field->size, size 2705 ext/exif/exif.c xp_field->size = exif_process_string_raw(&xp_field->value, szValuePtr, ByteCount); size 2707 ext/exif/exif.c return xp_field->size; size 2937 ext/exif/exif.c ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, format, ImageInfo->motorola_intel TSRMLS_CC); size 2943 ext/exif/exif.c ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, format, ImageInfo->motorola_intel TSRMLS_CC); size 3163 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail size: 0x%04X", ImageInfo->Thumbnail.size); size 3166 ext/exif/exif.c && ImageInfo->Thumbnail.size size 3272 ext/exif/exif.c size_t fpos, size, got, itemlen; size 3358 ext/exif/exif.c size = ImageInfo->FileSize - fpos; size 3359 ext/exif/exif.c sn = exif_file_sections_add(ImageInfo, M_PSEUDO, size, NULL); size 3361 ext/exif/exif.c got = php_stream_read(ImageInfo->infile, (char*)Data, size); size 3362 ext/exif/exif.c if (got != size) { size 3452 ext/exif/exif.c if (pos>=ImageInfo->Thumbnail.size) size 3455 ext/exif/exif.c if (pos>=ImageInfo->Thumbnail.size) size 3462 ext/exif/exif.c if (pos+3>=ImageInfo->Thumbnail.size) size 3470 ext/exif/exif.c if (pos+length>=ImageInfo->Thumbnail.size) { size 3623 ext/exif/exif.c if (ImageInfo->FileSize >= dir_offset + ImageInfo->file.list[sn].size) { size 3678 ext/exif/exif.c && ImageInfo->Thumbnail.size size 3683 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "%s THUMBNAIL @0x%04X + 0x%04X", ImageInfo->Thumbnail.data ? "Ignore" : "Read", ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size); size 3686 ext/exif/exif.c ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0); size 3688 ext/exif/exif.c fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 3689 ext/exif/exif.c if (fgot < ImageInfo->Thumbnail.size) { size 3717 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "%s THUMBNAIL @0x%04X + 0x%04X", ImageInfo->Thumbnail.data ? "Ignore" : "Read", ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size); size 3719 ext/exif/exif.c if (!ImageInfo->Thumbnail.data && ImageInfo->Thumbnail.offset && ImageInfo->Thumbnail.size && ImageInfo->read_thumbnail) { size 3720 ext/exif/exif.c ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0); size 3722 ext/exif/exif.c fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 3723 ext/exif/exif.c if (fgot < ImageInfo->Thumbnail.size) { size 3734 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error in TIFF: filesize(x%04X) less than size of IFD(x%04X)", ImageInfo->FileSize, dir_offset+ImageInfo->file.list[sn].size); size 4040 ext/exif/exif.c if (ImageInfo.Thumbnail.size) { size 4043 ext/exif/exif.c exif_iif_add_tag(&ImageInfo, SECTION_THUMBNAIL, "THUMBNAIL", TAG_NONE, TAG_FMT_UNDEFINED, ImageInfo.Thumbnail.size, ImageInfo.Thumbnail.data TSRMLS_CC); size 4114 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Thumbnail data %d %d %d, %d x %d", ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size, ImageInfo.Thumbnail.filetype, ImageInfo.Thumbnail.width, ImageInfo.Thumbnail.height); size 4116 ext/exif/exif.c if (!ImageInfo.Thumbnail.data || !ImageInfo.Thumbnail.size) { size 4122 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Returning thumbnail(%d)", ImageInfo.Thumbnail.size); size 4125 ext/exif/exif.c ZVAL_STRINGL(return_value, ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size, 1); size 470 ext/fileinfo/libmagic/cdf.c cdf_count_chain(const cdf_sat_t *sat, cdf_secid_t sid, size_t size) size 473 ext/fileinfo/libmagic/cdf.c cdf_secid_t maxsector = (cdf_secid_t)((sat->sat_len * size) size 1101 ext/fileinfo/libmagic/cdf.c cdf_dump_sat(const char *prefix, const cdf_sat_t *sat, size_t size) size 1103 ext/fileinfo/libmagic/cdf.c size_t i, j, s = size / sizeof(cdf_secid_t); size 58 ext/fileinfo/libmagic/tar.h char size[12]; size 160 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 162 ext/filter/filter.c for (i = 0; i < size; ++i) { size 332 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 334 ext/filter/filter.c for (i = 0; i < size; ++i) { size 340 ext/filter/filter.c for (i = 0; i < size; ++i) { size 891 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 898 ext/filter/filter.c for (i = 0; i < size; ++i) { size 909 ext/filter/filter.c int size = sizeof(filter_list) / sizeof(filter_list_entry); size 916 ext/filter/filter.c for (i = 0; i < size; ++i) { size 127 ext/ftp/ftp.c socklen_t size; size 148 ext/ftp/ftp.c size = sizeof(ftp->localaddr); size 149 ext/ftp/ftp.c memset(&ftp->localaddr, 0, size); size 150 ext/ftp/ftp.c if (getsockname(ftp->fd, (struct sockaddr*) &ftp->localaddr, &size) != 0) { size 619 ext/ftp/ftp.c ftp_alloc(ftpbuf_t *ftp, const long size, char **response) size 623 ext/ftp/ftp.c if (ftp == NULL || size <= 0) { size 627 ext/ftp/ftp.c snprintf(buffer, sizeof(buffer) - 1, "%ld", size); size 891 ext/ftp/ftp.c long size; size 927 ext/ftp/ftp.c size = 0; size 931 ext/ftp/ftp.c if (FTP_BUFSIZE - size < 2) { size 932 ext/ftp/ftp.c if (my_send(ftp, data->fd, data->buf, size) != size) { size 936 ext/ftp/ftp.c size = 0; size 941 ext/ftp/ftp.c size++; size 945 ext/ftp/ftp.c size++; size 948 ext/ftp/ftp.c if (size && my_send(ftp, data->fd, data->buf, size) != size) { size 1101 ext/ftp/ftp.c int size; size 1116 ext/ftp/ftp.c size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s %s\r\n", cmd, args); size 1122 ext/ftp/ftp.c size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s\r\n", cmd); size 1130 ext/ftp/ftp.c if (my_send(ftp, ftp->fd, data, size) != size) { size 1142 ext/ftp/ftp.c long size, rcvd; size 1146 ext/ftp/ftp.c size = FTP_BUFSIZE; size 1156 ext/ftp/ftp.c size -= rcvd; size 1180 ext/ftp/ftp.c if ((rcvd = my_recv(ftp, ftp->fd, data, size)) < 1) { size 1183 ext/ftp/ftp.c } while (size); size 1232 ext/ftp/ftp.c long size, sent; size 1235 ext/ftp/ftp.c size = len; size 1236 ext/ftp/ftp.c while (size) { size 1251 ext/ftp/ftp.c sent = SSL_write(ftp->ssl_handle, buf, size); size 1253 ext/ftp/ftp.c sent = SSL_write(ftp->data->ssl_handle, buf, size); size 1256 ext/ftp/ftp.c sent = send(s, buf, size, 0); size 1265 ext/ftp/ftp.c size -= sent; size 1375 ext/ftp/ftp.c socklen_t size; size 1405 ext/ftp/ftp.c size = php_sockaddr_size(&ftp->pasvaddr); size 1408 ext/ftp/ftp.c if (php_connect_nonb(fd, (struct sockaddr*) &ftp->pasvaddr, size, &tv) == -1) { size 1424 ext/ftp/ftp.c size = php_sockaddr_size(&addr); size 1426 ext/ftp/ftp.c if (bind(fd, (struct sockaddr*) &addr, size) != 0) { size 1431 ext/ftp/ftp.c if (getsockname(fd, (struct sockaddr*) &addr, &size) != 0) { size 1494 ext/ftp/ftp.c socklen_t size; size 1504 ext/ftp/ftp.c size = sizeof(addr); size 1505 ext/ftp/ftp.c data->fd = my_accept(ftp, data->listener, (struct sockaddr*) &addr, &size); size 1615 ext/ftp/ftp.c size_t size, rcvd; size 1654 ext/ftp/ftp.c size = 0; size 1658 ext/ftp/ftp.c if (rcvd == -1 || rcvd > ((size_t)(-1))-size) { size 1664 ext/ftp/ftp.c size += rcvd; size 1677 ext/ftp/ftp.c ret = safe_emalloc((lines + 1), sizeof(char*), size); size 1883 ext/ftp/ftp.c long size; size 1892 ext/ftp/ftp.c size = 0; size 1898 ext/ftp/ftp.c size++; size 1902 ext/ftp/ftp.c size++; size 1905 ext/ftp/ftp.c if (FTP_BUFSIZE - size < 2) { size 1906 ext/ftp/ftp.c if (my_send(ftp, ftp->data->fd, ftp->data->buf, size) != size) { size 1913 ext/ftp/ftp.c if (size && my_send(ftp, ftp->data->fd, ftp->data->buf, size) != size) { size 151 ext/ftp/ftp.h int ftp_alloc(ftpbuf_t *ftp, const long size, char **response); size 109 ext/ftp/php_ftp.c ZEND_ARG_INFO(0, size) size 634 ext/ftp/php_ftp.c long size, ret; size 637 ext/ftp/php_ftp.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &z_ftp, &size, &zresponse) == FAILURE) { size 643 ext/ftp/php_ftp.c ret = ftp_alloc(ftp, size, zresponse ? &response : NULL); size 694 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 703 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 715 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 723 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 767 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 781 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 3428 ext/gd/gd.c static gdFontPtr php_find_gd_font(int size TSRMLS_DC) size 3433 ext/gd/gd.c switch (size) { size 3450 ext/gd/gd.c font = zend_list_find(size - 5, &ind_type); size 3452 ext/gd/gd.c if (size < 1) { size 3538 ext/gd/gd.c int ch = 0, col, x, y, size, i, l = 0; size 3559 ext/gd/gd.c size = SIZE; size 3561 ext/gd/gd.c font = php_find_gd_font(size TSRMLS_CC); size 4136 ext/gd/gd.c long _fg, _bg, x, y, size, space = 0, aa_steps = 4, width = 0; size 4152 ext/gd/gd.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrlllll|lldl", &img, &str, &str_len, &fnt, &size, &_fg, &_bg, &x, &y, &space, &width, &angle, &aa_steps) == FAILURE) { size 4215 ext/gd/gd.c str_path = T1_GetCharOutline(*f_ind, str[0], size, transform); size 4229 ext/gd/gd.c char_path = T1_GetMoveOutline(*f_ind, add_width, 0, 0, size, transform); size 4232 ext/gd/gd.c char_path = T1_GetCharOutline(*f_ind, str[i], size, transform); size 4237 ext/gd/gd.c str_img = T1_AASetString(*f_ind, str, str_len, space, T1_KERNING, size, transform); size 59 ext/gd/gdcache.c int size, size 68 ext/gd/gdcache.c head->size = size; size 123 ext/gd/gdcache.c if (i < head->size) { /* cache still growing - add new elem */ size 68 ext/gd/gdcache.h int size; size 78 ext/gd/gdcache.h int size, size 369 ext/gd/libgd/gd.h gdImagePtr gdImageCreateFromJpegPtr (int size, void *data); size 370 ext/gd/libgd/gd.h gdImagePtr gdImageCreateFromJpegPtrEx (int size, void *data, int ignore_warning); size 373 ext/gd/libgd/gd.h gdImagePtr gdImageCreateFromWebpPtr (int size, void *data); size 606 ext/gd/libgd/gd.h void *gdImageWBMPPtr(gdImagePtr im, int *size, int fg); size 616 ext/gd/libgd/gd.h void *gdImageJpegPtr(gdImagePtr im, int *size, int quality); size 638 ext/gd/libgd/gd.h void* gdImagePngPtr(gdImagePtr im, int *size); size 641 ext/gd/libgd/gd.h void* gdImageGdPtr(gdImagePtr im, int *size); size 642 ext/gd/libgd/gd.h void *gdImagePngPtrEx(gdImagePtr im, int *size, int level, int basefilter); size 645 ext/gd/libgd/gd.h void* gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size); size 754 ext/gd/libgd/gd.h gdIOCtx *gdNewDynamicCtxEx(int size, void *data, int freeFlag); size 756 ext/gd/libgd/gd.h void* gdDPExtractData(struct gdIOCtx* ctx, int *size); size 155 ext/gd/libgd/gd_gd.c gdImagePtr gdImageCreateFromGdPtr (int size, void *data) size 158 ext/gd/libgd/gd_gd.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 272 ext/gd/libgd/gd_gd.c void *gdImageGdPtr (gdImagePtr im, int *size) size 277 ext/gd/libgd/gd_gd.c rv = gdDPExtractData(out, size); size 45 ext/gd/libgd/gd_gd2.c int size; size 150 ext/gd/libgd/gd_gd2.c if (gdGetInt(&cidx[i].size, in) != 1) { size 239 ext/gd/libgd/gd_gd2.c gdImagePtr gdImageCreateFromGd2Ptr (int size, void *data) size 242 ext/gd/libgd/gd_gd2.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 280 ext/gd/libgd/gd_gd2.c if (chunkIdx[i].size > compMax) { size 281 ext/gd/libgd/gd_gd2.c compMax = chunkIdx[i].size; size 311 ext/gd/libgd/gd_gd2.c if (!_gd2ReadChunk(chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *) chunkBuf, &chunkLen, in)) { size 390 ext/gd/libgd/gd_gd2.c gdImagePtr gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, int w, int h) size 393 ext/gd/libgd/gd_gd2.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 469 ext/gd/libgd/gd_gd2.c if (chunkIdx[i].size > compMax) { size 470 ext/gd/libgd/gd_gd2.c compMax = chunkIdx[i].size; size 547 ext/gd/libgd/gd_gd2.c if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *)chunkBuf, &chunkLen, in)) { size 771 ext/gd/libgd/gd_gd2.c chunkIdx[chunkNum++].size = compLen; size 772 ext/gd/libgd/gd_gd2.c GD2_DBG(php_gd_error("Chunk %d size %d offset %d", chunkNum, chunkIdx[chunkNum - 1].size, chunkIdx[chunkNum - 1].offset)); size 790 ext/gd/libgd/gd_gd2.c GD2_DBG(php_gd_error("Chunk %d size %d offset %d", x, chunkIdx[x].size, chunkIdx[x].offset)); size 792 ext/gd/libgd/gd_gd2.c gdPutInt(chunkIdx[x].size, out); size 819 ext/gd/libgd/gd_gd2.c void *gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size) size 825 ext/gd/libgd/gd_gd2.c rv = gdDPExtractData(out, size); size 100 ext/gd/libgd/gd_gif_out.c void * gdImageGifPtr (gdImagePtr im, int *size) size 105 ext/gd/libgd/gd_gif_out.c rv = gdDPExtractData (out, size); size 122 ext/gd/libgd/gd_io.c int gdPutBuf (const void *buf, int size, gdIOCtx * ctx) size 125 ext/gd/libgd/gd_io.c return (ctx->putBuf) (ctx, buf, size); size 129 ext/gd/libgd/gd_io.c int gdGetBuf (void *buf, int size, gdIOCtx * ctx) size 131 ext/gd/libgd/gd_io.c return (ctx->getBuf) (ctx, buf, size); size 49 ext/gd/libgd/gd_io_dp.c static int appendDynamic (dynamicPtr * dp, const void *src, int size); size 95 ext/gd/libgd/gd_io_dp.c void * gdDPExtractData (struct gdIOCtx *ctx, int *size) size 107 ext/gd/libgd/gd_io_dp.c *size = dp->logicalSize; size 110 ext/gd/libgd/gd_io_dp.c *size = 0; size 198 ext/gd/libgd/gd_io_dp.c dynamicPutbuf (struct gdIOCtx *ctx, const void *buf, int size) size 203 ext/gd/libgd/gd_io_dp.c appendDynamic (dctx->dp, buf, size); size 207 ext/gd/libgd/gd_io_dp.c return size; size 293 ext/gd/libgd/gd_io_dp.c static int appendDynamic (dynamicPtr * dp, const void *src, int size) size 303 ext/gd/libgd/gd_io_dp.c bytesNeeded = dp->pos + size; size 317 ext/gd/libgd/gd_io_dp.c memcpy((void *) (tmp + (dp->pos)), src, size); size 318 ext/gd/libgd/gd_io_dp.c dp->pos += size; size 77 ext/gd/libgd/gd_io_file.c static int filePutbuf (gdIOCtx * ctx, const void *buf, int size) size 82 ext/gd/libgd/gd_io_file.c return fwrite(buf, 1, size, fctx->f); size 86 ext/gd/libgd/gd_io_file.c static int fileGetbuf (gdIOCtx * ctx, void *buf, int size) size 91 ext/gd/libgd/gd_io_file.c return fread(buf, 1, size, fctx->f); size 45 ext/gd/libgd/gd_io_ss.c static int sinkPutbuf (gdIOCtx * ctx, const void *buf, int size); size 79 ext/gd/libgd/gd_io_ss.c static int sourceGetbuf (gdIOCtx * ctx, void *buf, int size) size 86 ext/gd/libgd/gd_io_ss.c res = ((lctx->src->source) (lctx->src->context, buf, size)); size 116 ext/gd/libgd/gd_io_ss.c static int sinkPutbuf (gdIOCtx * ctx, const void *buf, int size) size 123 ext/gd/libgd/gd_io_ss.c res = (lctx->snk->sink) (lctx->snk->context, buf, size); size 151 ext/gd/libgd/gd_jpeg.c void *gdImageJpegPtr (gdImagePtr im, int *size, int quality) size 156 ext/gd/libgd/gd_jpeg.c rv = gdDPExtractData (out, size); size 291 ext/gd/libgd/gd_jpeg.c gdImagePtr gdImageCreateFromJpegPtr (int size, void *data) size 293 ext/gd/libgd/gd_jpeg.c return gdImageCreateFromJpegPtrEx(size, data, 1); size 296 ext/gd/libgd/gd_jpeg.c gdImagePtr gdImageCreateFromJpegPtrEx (int size, void *data, int ignore_warning) size 299 ext/gd/libgd/gd_jpeg.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 103 ext/gd/libgd/gd_png.c gdImagePtr gdImageCreateFromPngPtr (int size, void *data) size 106 ext/gd/libgd/gd_png.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 434 ext/gd/libgd/gd_png.c void * gdImagePngPtr (gdImagePtr im, int *size) size 439 ext/gd/libgd/gd_png.c rv = gdDPExtractData(out, size); size 445 ext/gd/libgd/gd_png.c void * gdImagePngPtrEx (gdImagePtr im, int *size, int level, int basefilter) size 450 ext/gd/libgd/gd_png.c rv = gdDPExtractData(out, size); size 179 ext/gd/libgd/gd_wbmp.c gdImagePtr gdImageCreateFromWBMPPtr (int size, void *data) size 182 ext/gd/libgd/gd_wbmp.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 201 ext/gd/libgd/gd_wbmp.c void * gdImageWBMPPtr (gdImagePtr im, int *size, int fg) size 206 ext/gd/libgd/gd_wbmp.c rv = gdDPExtractData(out, size); size 37 ext/gd/libgd/gd_webp.c gdImagePtr gdImageCreateFromWebpPtr (int size, void *data) size 45 ext/gd/libgd/gd_webp.c ret = WebPDecode(data, size, &Y, &U, &V, &width, &height); size 71 ext/gd/libgd/gd_webp.c size_t size = 0, n; size 75 ext/gd/libgd/gd_webp.c temp = gdRealloc(filedata, size+GD_WEBP_ALLOC_STEP); size 78 ext/gd/libgd/gd_webp.c read = temp + size; size 90 ext/gd/libgd/gd_webp.c size += n; size 94 ext/gd/libgd/gd_webp.c ret = WebPDecode(filedata, size, &Y, &U, &V, &width, &height); size 122 ext/gd/libgd/gd_webp.c void * gdImageWebpPtr (gdImagePtr im, int *size) size 127 ext/gd/libgd/gd_webp.c rv = gdDPExtractData(out, size); size 133 ext/gd/libgd/gd_webp.c void * gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization) size 138 ext/gd/libgd/gd_webp.c rv = gdDPExtractData(out, size); size 58 ext/gd/libgd/gdcache.c int size, size 67 ext/gd/libgd/gdcache.c head->size = size; size 122 ext/gd/libgd/gdcache.c if (i < head->size) size 67 ext/gd/libgd/gdcache.h int size; size 77 ext/gd/libgd/gdcache.h int size, size 981 ext/gd/libgd/gdft.c penf.y -= (long)(face->size->metrics.height * linespace); size 15 ext/gd/libgd/gdhelpers.h #define gdCalloc(nmemb, size) ecalloc(nmemb, size) size 16 ext/gd/libgd/gdhelpers.h #define gdMalloc(size) emalloc(size) size 17 ext/gd/libgd/gdhelpers.h #define gdRealloc(ptr, size) erealloc(ptr, size) size 1085 ext/gmp/gmp.c int gmp_import_export_validate(long size, long options, int *order, int *endian TSRMLS_DC) size 1087 ext/gmp/gmp.c if (size < 1) { size 1089 ext/gmp/gmp.c "Word size must be positive, %ld given", size); size 1133 ext/gmp/gmp.c long size = 1; size 1138 ext/gmp/gmp.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &data, &data_len, &size, &options) == FAILURE) { size 1142 ext/gmp/gmp.c if (gmp_import_export_validate(size, options, &order, &endian TSRMLS_CC) == FAILURE) { size 1146 ext/gmp/gmp.c if ((data_len % size) != 0) { size 1154 ext/gmp/gmp.c mpz_import(gmpnumber, data_len / size, order, size, endian, 0, data); size 1163 ext/gmp/gmp.c long size = 1; size 1169 ext/gmp/gmp.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ll", &gmpnumber_arg, &size, &options) == FAILURE) { size 1173 ext/gmp/gmp.c if (gmp_import_export_validate(size, options, &order, &endian TSRMLS_CC) == FAILURE) { size 1182 ext/gmp/gmp.c size_t bits_per_word = size * 8; size 1184 ext/gmp/gmp.c size_t out_len = count * size; size 1187 ext/gmp/gmp.c mpz_export(out_string, NULL, order, size, endian, 0, gmpnumber); size 83 ext/imap/php_imap.c static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md); size 88 ext/imap/php_imap.c char *cpytxt(SIZEDTEXT *dst, char *text, unsigned long size); size 96 ext/imap/php_imap.c void *fs_get(size_t size); size 1484 ext/imap/php_imap.c limits.text.size = mailbox_size; size 2696 ext/imap/php_imap.c src.size = 0; size 2698 ext/imap/php_imap.c dest.size = 0; size 2707 ext/imap/php_imap.c RETVAL_STRINGL(dest.data, dest.size, 1); size 3324 ext/imap/php_imap.c if (body->size.lines) { size 3325 ext/imap/php_imap.c add_property_long(return_value, "lines", body->size.lines); size 3327 ext/imap/php_imap.c if (body->size.bytes) { size 3328 ext/imap/php_imap.c add_property_long(return_value, "bytes", body->size.bytes); size 3637 ext/imap/php_imap.c bod->contents.text.size = Z_STRLEN_PP(pvalue); size 3641 ext/imap/php_imap.c bod->contents.text.size = 0; size 3645 ext/imap/php_imap.c bod->size.lines = Z_LVAL_PP(pvalue); size 3649 ext/imap/php_imap.c bod->size.bytes = Z_LVAL_PP(pvalue); size 3750 ext/imap/php_imap.c bod->contents.text.size = Z_STRLEN_PP(pvalue); size 3754 ext/imap/php_imap.c bod->contents.text.size = 0; size 3758 ext/imap/php_imap.c bod->size.lines = Z_LVAL_PP(pvalue); size 3762 ext/imap/php_imap.c bod->size.bytes = Z_LVAL_PP(pvalue); size 4574 ext/imap/php_imap.c if (body->size.lines) { size 4575 ext/imap/php_imap.c add_property_long(arg, "lines", body->size.lines); size 4578 ext/imap/php_imap.c if (body->size.bytes) { size 4579 ext/imap/php_imap.c add_property_long(arg, "bytes", body->size.bytes); size 4804 ext/imap/php_imap.c static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md) /* {{{ */ size 4813 ext/imap/php_imap.c while (size) { size 4816 ext/imap/php_imap.c if (size > GETS_FETCH_SIZE) { size 4818 ext/imap/php_imap.c size -=GETS_FETCH_SIZE; size 4820 ext/imap/php_imap.c read = size; size 4821 ext/imap/php_imap.c size = 0; size 4834 ext/imap/php_imap.c char *buf = pemalloc(size + 1, 1); size 4836 ext/imap/php_imap.c if (f(stream, size, buf)) { size 4837 ext/imap/php_imap.c buf[size] = '\0'; size 53 ext/imap/php_imap.h #define LSIZE text.size size 60 ext/imap/php_imap.h #define LSIZE size size 540 ext/interbase/ibase_blobs.c int size; size 565 ext/interbase/ibase_blobs.c for (size = 0; (b = php_stream_read(stream, bl_data, sizeof(bl_data))); size += b) { size 772 ext/intl/grapheme/grapheme_string.c grapheme_extract_count_iter(UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len) size 777 ext/intl/grapheme/grapheme_string.c while ( size ) { size 784 ext/intl/grapheme/grapheme_string.c size--; size 814 ext/intl/grapheme/grapheme_string.c long size; /* maximum number of grapheme clusters, bytes, or characters (based on extract_type) to return */ size 824 ext/intl/grapheme/grapheme_string.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|llz", (char **)&str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) { size 859 ext/intl/grapheme/grapheme_string.c if ( size > INT32_MAX || size < 0) { size 863 ext/intl/grapheme/grapheme_string.c if (size == 0) { size 893 ext/intl/grapheme/grapheme_string.c if ( -1 != grapheme_ascii_check(pstr, size + 1 < str_len ? size + 1 : str_len ) ) { size 894 ext/intl/grapheme/grapheme_string.c long nsize = ( size < str_len ? size : str_len ); size 931 ext/intl/grapheme/grapheme_string.c ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, pstr, str_len); size 31 ext/intl/intl_common.h # define eumalloc(size) (UChar*)safe_emalloc(size, sizeof(UChar), 0) size 35 ext/intl/intl_common.h # define eurealloc(ptr, size) (UChar*)erealloc((ptr), size * sizeof(UChar)) size 273 ext/libxml/libxml.c libxml_globals->entity_loader.fci.size = 0; size 279 ext/libxml/libxml.c if (fci->size > 0) { size 284 ext/libxml/libxml.c fci->size = 0; size 585 ext/libxml/libxml.c if (fci->size == 0) { size 1118 ext/libxml/libxml.c if (fci.size > 0) { /* argument not null */ size 2690 ext/mbstring/libmbfl/mbfl/mbfilter.c int f, n, s, r, d, size, *mapelm; size 2692 ext/mbstring/libmbfl/mbfl/mbfilter.c size = pc->mapsize; size 2695 ext/mbstring/libmbfl/mbfl/mbfilter.c while (n < size) { size 2736 ext/mbstring/libmbfl/mbfl/mbfilter.c int f, n, s, r, d, size, *mapelm; size 2780 ext/mbstring/libmbfl/mbfl/mbfilter.c size = pc->mapsize; size 2781 ext/mbstring/libmbfl/mbfl/mbfilter.c while (n < size) { size 2862 ext/mbstring/libmbfl/mbfl/mbfilter.c size = pc->mapsize; size 2863 ext/mbstring/libmbfl/mbfl/mbfilter.c while (n < size) { size 2914 ext/mbstring/libmbfl/mbfl/mbfilter.c int f, n, s, r, d, size, *mapelm; size 2916 ext/mbstring/libmbfl/mbfl/mbfilter.c size = pc->mapsize; size 2919 ext/mbstring/libmbfl/mbfl/mbfilter.c while (n < size) { size 695 ext/mbstring/mbstring.c int size, bauto, ret = SUCCESS; size 728 ext/mbstring/mbstring.c size = n + MBSTRG(default_detect_order_list_size); size 730 ext/mbstring/mbstring.c list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent); size 773 ext/mbstring/mbstring.c } while (n < size && p2 != NULL); size 816 ext/mbstring/mbstring.c int i, n, size, bauto, ret = SUCCESS; size 824 ext/mbstring/mbstring.c size = i + MBSTRG(default_detect_order_list_size); size 825 ext/mbstring/mbstring.c list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent); size 1233 ext/mbstring/mbstring.c size_t size; size 1244 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(new_value, new_value_length, &list, &size, 1 TSRMLS_CC)) { size 1252 ext/mbstring/mbstring.c MBSTRG(detect_order_list_size) = size; size 1261 ext/mbstring/mbstring.c size_t size; size 1267 ext/mbstring/mbstring.c if (SUCCESS == php_mb_parse_encoding_list(get_input_encoding(TSRMLS_C), strlen(get_input_encoding(TSRMLS_C))+1, &list, &size, 1 TSRMLS_CC)) { size 1269 ext/mbstring/mbstring.c MBSTRG(http_input_list_size) = size; size 1277 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(new_value, new_value_length, &list, &size, 1 TSRMLS_CC)) { size 1285 ext/mbstring/mbstring.c MBSTRG(http_input_list_size) = size; size 1933 ext/mbstring/mbstring.c size_t size = 0; size 1936 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_array(*arg1, &list, &size, 0 TSRMLS_CC)) { size 1945 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_PP(arg1), Z_STRLEN_PP(arg1), &list, &size, 0 TSRMLS_CC)) { size 1962 ext/mbstring/mbstring.c MBSTRG(current_detect_order_list_size) = size; size 2977 ext/mbstring/mbstring.c size_t size; size 3010 ext/mbstring/mbstring.c size = 0; size 3011 ext/mbstring/mbstring.c php_mb_parse_encoding_list(_from_encodings, strlen(_from_encodings), &list, &size, 0 TSRMLS_CC); size 3012 ext/mbstring/mbstring.c if (size == 1) { size 3015 ext/mbstring/mbstring.c } else if (size > 1) { size 3017 ext/mbstring/mbstring.c from_encoding = mbfl_identify_encoding2(&string, list, size, MBSTRG(strict_detection)); size 3066 ext/mbstring/mbstring.c size_t size, l, n; size 3119 ext/mbstring/mbstring.c ret = php_mb_convert_encoding(arg_str, str_len, arg_new, _from_encodings, &size TSRMLS_CC); size 3121 ext/mbstring/mbstring.c RETVAL_STRINGL(ret, size, 0); /* the string is already strdup()'ed */ size 3216 ext/mbstring/mbstring.c size_t size; size 3224 ext/mbstring/mbstring.c size = 0; size 3228 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_array(encoding_list, &list, &size, 0 TSRMLS_CC)) { size 3232 ext/mbstring/mbstring.c size = 0; size 3238 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_P(encoding_list), Z_STRLEN_P(encoding_list), &list, &size, 0 TSRMLS_CC)) { size 3242 ext/mbstring/mbstring.c size = 0; size 3247 ext/mbstring/mbstring.c if (size <= 0) { size 3256 ext/mbstring/mbstring.c if (size > 0 && list != NULL) { size 3260 ext/mbstring/mbstring.c size = MBSTRG(current_detect_order_list_size); size 3267 ext/mbstring/mbstring.c ret = mbfl_identify_encoding2(&string, elist, size, strict); size 157 ext/mbstring/oniguruma/onigposix.h ONIG_EXTERN size_t regerror P_((int code, const regex_t* reg, char* buf, size_t size)); size 815 ext/mbstring/oniguruma/oniguruma.h int onig_set_match_stack_limit_size P_((unsigned int size)); size 139 ext/mbstring/oniguruma/regcomp.c onig_bbuf_init(BBuf* buf, int size) size 141 ext/mbstring/oniguruma/regcomp.c if (size <= 0) { size 142 ext/mbstring/oniguruma/regcomp.c size = 0; size 146 ext/mbstring/oniguruma/regcomp.c buf->p = (UChar* )xmalloc(size); size 150 ext/mbstring/oniguruma/regcomp.c buf->alloc = size; size 159 ext/mbstring/oniguruma/regcomp.c unset_addr_list_init(UnsetAddrList* uslist, int size) size 163 ext/mbstring/oniguruma/regcomp.c p = (UnsetAddr* )xmalloc(sizeof(UnsetAddr)* size); size 166 ext/mbstring/oniguruma/regcomp.c uslist->alloc = size; size 182 ext/mbstring/oniguruma/regcomp.c int size; size 185 ext/mbstring/oniguruma/regcomp.c size = uslist->alloc * 2; size 186 ext/mbstring/oniguruma/regcomp.c p = (UnsetAddr* )xrealloc(uslist->us, sizeof(UnsetAddr) * size); size 188 ext/mbstring/oniguruma/regcomp.c uslist->alloc = size; size 844 ext/mbstring/oniguruma/regenc.c int size; size 847 ext/mbstring/oniguruma/regenc.c size = sizeof(OnigCodePoint*) * new_size; size 849 ext/mbstring/oniguruma/regenc.c list = (const OnigCodePoint** )xmalloc(size); size 852 ext/mbstring/oniguruma/regenc.c list = (const OnigCodePoint** )xrealloc((void* )list, size); size 352 ext/mbstring/oniguruma/regexec.c unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\ size 354 ext/mbstring/oniguruma/regexec.c if (size > 0 && offset < size && size < STATE_CHECK_BUFF_MAX_SIZE) {\ size 355 ext/mbstring/oniguruma/regexec.c if (size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) \ size 356 ext/mbstring/oniguruma/regexec.c (msa).state_check_buff = (void* )xmalloc(size);\ size 358 ext/mbstring/oniguruma/regexec.c (msa).state_check_buff = (void* )xalloca(size);\ size 360 ext/mbstring/oniguruma/regexec.c (size_t )(size - (offset))); \ size 361 ext/mbstring/oniguruma/regexec.c (msa).state_check_buff_size = size;\ size 421 ext/mbstring/oniguruma/regexec.c onig_set_match_stack_limit_size(unsigned int size) size 423 ext/mbstring/oniguruma/regexec.c MatchStackLimitSize = size; size 44 ext/mbstring/oniguruma/reggnu.c re_adjust_startpos(regex_t* reg, const char* string, int size, size 47 ext/mbstring/oniguruma/reggnu.c if (startpos > 0 && ONIGENC_MBC_MAXLEN(reg->enc) != 1 && startpos < size) { size 64 ext/mbstring/oniguruma/reggnu.c re_match(regex_t* reg, const char* str, int size, int pos, size 67 ext/mbstring/oniguruma/reggnu.c return onig_match(reg, (UChar* )str, (UChar* )(str + size), size 72 ext/mbstring/oniguruma/reggnu.c re_search(regex_t* bufp, const char* string, int size, int startpos, int range, size 75 ext/mbstring/oniguruma/reggnu.c return onig_search(bufp, (UChar* )string, (UChar* )(string + size), size 82 ext/mbstring/oniguruma/reggnu.c re_compile_pattern(const char* pattern, int size, regex_t* reg, char* ebuf) size 87 ext/mbstring/oniguruma/reggnu.c r = onig_compile(reg, (UChar* )pattern, (UChar* )(pattern + size), &einfo); size 98 ext/mbstring/oniguruma/reggnu.c re_recompile_pattern(const char* pattern, int size, regex_t* reg, char* ebuf) size 109 ext/mbstring/oniguruma/reggnu.c r = onig_recompile(reg, (UChar* )pattern, (UChar* )(pattern + size), size 349 ext/mbstring/oniguruma/regint.h #define BBUF_INIT(buf,size) onig_bbuf_init((BBuf* )(buf), (size)) size 363 ext/mbstring/oniguruma/regint.h #define BBUF_ENSURE_SIZE(buf,size) do{\ size 365 ext/mbstring/oniguruma/regint.h while (new_alloc < (unsigned int )(size)) { new_alloc *= 2; }\ size 773 ext/mbstring/oniguruma/regint.h extern int onig_bbuf_init P_((BBuf* buf, int size)); size 785 ext/mbstring/oniguruma/regint.h extern hash_table_type* onig_st_init_strend_table_with_size P_((int size)); size 350 ext/mbstring/oniguruma/regparse.c onig_st_init_strend_table_with_size(int size) size 358 ext/mbstring/oniguruma/regparse.c onig_st_init_table_with_size(&hashType, size); size 1751 ext/mbstring/oniguruma/regparse.c int size = (n - high) * 2 * SIZE_CODE_POINT; size 1754 ext/mbstring/oniguruma/regparse.c BBUF_MOVE_RIGHT(bbuf, from_pos, to_pos, size); size 73 ext/mbstring/oniguruma/regposerr.c size_t size) size 93 ext/mbstring/oniguruma/regposerr.c if (buf != NULL && size > 0) { size 94 ext/mbstring/oniguruma/regposerr.c strncpy(buf, s, size - 1); size 95 ext/mbstring/oniguruma/regposerr.c buf[size - 1] = '\0'; size 104 ext/mbstring/oniguruma/st.c new_size(size) size 105 ext/mbstring/oniguruma/st.c int size; size 111 ext/mbstring/oniguruma/st.c if ((1<<i) > size) return 1<<i; size 121 ext/mbstring/oniguruma/st.c if (newsize > size) return primes[i]; size 142 ext/mbstring/oniguruma/st.c st_init_table_with_size(type, size) size 144 ext/mbstring/oniguruma/st.c int size; size 155 ext/mbstring/oniguruma/st.c size = new_size(size); /* round up to prime number */ size 160 ext/mbstring/oniguruma/st.c tbl->num_bins = size; size 161 ext/mbstring/oniguruma/st.c tbl->bins = (st_table_entry **)Calloc(size, sizeof(st_table_entry*)); size 180 ext/mbstring/oniguruma/st.c st_init_numtable_with_size(size) size 181 ext/mbstring/oniguruma/st.c int size; size 183 ext/mbstring/oniguruma/st.c return st_init_table_with_size(&type_numhash, size); size 193 ext/mbstring/oniguruma/st.c st_init_strtable_with_size(size) size 194 ext/mbstring/oniguruma/st.c int size; size 196 ext/mbstring/oniguruma/st.c return st_init_table_with_size(&type_strhash, size); size 103 ext/mbstring/ucgendat/ucgendat.c ac_uint2 size; size 122 ext/mbstring/ucgendat/ucgendat.c ac_uint2 size; size 256 ext/mbstring/ucgendat/ucgendat.c if (rlp->used == rlp->size) { size 257 ext/mbstring/ucgendat/ucgendat.c if (rlp->size == 0) size 263 ext/mbstring/ucgendat/ucgendat.c sizeof(ac_uint4) * (rlp->size + 8)); size 264 ext/mbstring/ucgendat/ucgendat.c rlp->size += 8; size 364 ext/mbstring/ucgendat/ucgendat.c if (rlp->used == rlp->size) { size 365 ext/mbstring/ucgendat/ucgendat.c if (rlp->size == 0) size 371 ext/mbstring/ucgendat/ucgendat.c sizeof(ac_uint4) * (rlp->size + 8)); size 372 ext/mbstring/ucgendat/ucgendat.c rlp->size += 8; size 450 ext/mbstring/ucgendat/ucgendat.c ac_uint4 i, j, size; size 504 ext/mbstring/ucgendat/ucgendat.c size = dectmp_size + (4 - (dectmp_size & 3)); size 505 ext/mbstring/ucgendat/ucgendat.c if ((*pdecomps)[i].size < size) { size 506 ext/mbstring/ucgendat/ucgendat.c if ((*pdecomps)[i].size == 0) size 508 ext/mbstring/ucgendat/ucgendat.c malloc(sizeof(ac_uint4) * size); size 512 ext/mbstring/ucgendat/ucgendat.c sizeof(ac_uint4) * size); size 513 ext/mbstring/ucgendat/ucgendat.c (*pdecomps)[i].size = size; size 236 ext/mcrypt/mcrypt.c ZEND_ARG_INFO(0, size) size 1426 ext/mcrypt/mcrypt.c long size; size 1429 ext/mcrypt/mcrypt.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &size, &source) == FAILURE) { size 1433 ext/mcrypt/mcrypt.c if (size <= 0 || size >= INT_MAX) { size 1438 ext/mcrypt/mcrypt.c iv = ecalloc(size + 1, 1); size 1444 ext/mcrypt/mcrypt.c if (php_win32_get_random_bytes(iv_b, (size_t) size) == FAILURE){ size 1449 ext/mcrypt/mcrypt.c n = size; size 1463 ext/mcrypt/mcrypt.c while (read_bytes < size) { size 1464 ext/mcrypt/mcrypt.c n = read(*fd, iv + read_bytes, size - read_bytes); size 1472 ext/mcrypt/mcrypt.c if (n < size) { size 1479 ext/mcrypt/mcrypt.c n = size; size 1480 ext/mcrypt/mcrypt.c while (size) { size 1481 ext/mcrypt/mcrypt.c iv[--size] = (char) (255.0 * php_rand(TSRMLS_C) / RAND_MAX); size 2172 ext/mysql/php_mysql.c fci.size = sizeof(fci); size 1303 ext/mysqli/mysqli.c fci.size = sizeof(fci); size 405 ext/mysqli/mysqli_api.c int size; size 406 ext/mysqli/mysqli_api.c char *p= emalloc(size= var_cnt * (sizeof(char) + sizeof(VAR_BUFFER))); size 409 ext/mysqli/mysqli_api.c memset(p, 0, size); size 77 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D) size 97 ext/mysqlnd/mysqlnd_alloc.c ret = _emalloc(REAL_SIZE(size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 105 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret); size 108 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 109 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMOUNT, size); size 117 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D) size 137 ext/mysqlnd/mysqlnd_alloc.c ret = (persistent) ? __zend_malloc(REAL_SIZE(size)) : _emalloc(REAL_SIZE(size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 145 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p persistent=%u", size, ret, persistent); size 150 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 151 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size); size 160 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) size 181 ext/mysqlnd/mysqlnd_alloc.c ret = _ecalloc(nmemb, REAL_SIZE(size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 190 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret); size 192 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 193 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMOUNT, size); size 201 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D) size 220 ext/mysqlnd/mysqlnd_alloc.c ret = (persistent) ? __zend_calloc(nmemb, REAL_SIZE(size)) : _ecalloc(nmemb, REAL_SIZE(size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 228 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret); size 233 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 234 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size); size 391 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D) size 411 ext/mysqlnd/mysqlnd_alloc.c ret = malloc(REAL_SIZE(size)); size 419 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret); size 421 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 422 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMOUNT, size); size 430 ext/mysqlnd/mysqlnd_alloc.c void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) size 450 ext/mysqlnd/mysqlnd_alloc.c ret = calloc(nmemb, REAL_SIZE(size)); size 458 ext/mysqlnd/mysqlnd_alloc.c TRACE_ALLOC_INF_FMT("size=%lu ptr=%p", size, ret); size 460 ext/mysqlnd/mysqlnd_alloc.c *(size_t *) ret = size; size 461 ext/mysqlnd/mysqlnd_alloc.c MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMOUNT, size); size 647 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_emalloc(size_t size MYSQLND_MEM_D) size 649 ext/mysqlnd/mysqlnd_alloc.c return emalloc(size); size 655 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D) size 657 ext/mysqlnd/mysqlnd_alloc.c return pemalloc(size, persistent); size 663 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) size 665 ext/mysqlnd/mysqlnd_alloc.c return ecalloc(nmemb, size); size 671 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D) size 673 ext/mysqlnd/mysqlnd_alloc.c return pecalloc(nmemb, size, persistent); size 711 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_malloc(size_t size MYSQLND_MEM_D) size 713 ext/mysqlnd/mysqlnd_alloc.c return malloc(size); size 719 ext/mysqlnd/mysqlnd_alloc.c static void * mysqlnd_zend_mm_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) size 721 ext/mysqlnd/mysqlnd_alloc.c return calloc(nmemb, size); size 34 ext/mysqlnd/mysqlnd_alloc.h void * (*m_emalloc)(size_t size MYSQLND_MEM_D); size 35 ext/mysqlnd/mysqlnd_alloc.h void * (*m_pemalloc)(size_t size, zend_bool persistent MYSQLND_MEM_D); size 36 ext/mysqlnd/mysqlnd_alloc.h void * (*m_ecalloc)(unsigned int nmemb, size_t size MYSQLND_MEM_D); size 37 ext/mysqlnd/mysqlnd_alloc.h void * (*m_pecalloc)(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D); size 42 ext/mysqlnd/mysqlnd_alloc.h void * (*m_malloc)(size_t size MYSQLND_MEM_D); size 43 ext/mysqlnd/mysqlnd_alloc.h void * (*m_calloc)(unsigned int nmemb, size_t size MYSQLND_MEM_D); size 46 ext/mysqlnd/mysqlnd_alloc.h char * (*m_pestrndup)(const char * const ptr, size_t size, zend_bool persistent MYSQLND_MEM_D); size 55 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D); size 56 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D); size 57 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D); size 58 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D); size 63 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D); size 64 ext/mysqlnd/mysqlnd_alloc.h PHPAPI void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D); size 67 ext/mysqlnd/mysqlnd_alloc.h PHPAPI char * _mysqlnd_pestrndup(const char * const ptr, size_t size, zend_bool persistent MYSQLND_MEM_D); size 73 ext/mysqlnd/mysqlnd_alloc.h #define mnd_emalloc(size) mysqlnd_allocator.m_emalloc((size) MYSQLND_MEM_C) size 74 ext/mysqlnd/mysqlnd_alloc.h #define mnd_pemalloc(size, pers) mysqlnd_allocator.m_pemalloc((size), (pers) MYSQLND_MEM_C) size 75 ext/mysqlnd/mysqlnd_alloc.h #define mnd_ecalloc(nmemb, size) mysqlnd_allocator.m_ecalloc((nmemb), (size) MYSQLND_MEM_C) size 76 ext/mysqlnd/mysqlnd_alloc.h #define mnd_pecalloc(nmemb, size, p) mysqlnd_allocator.m_pecalloc((nmemb), (size), (p) MYSQLND_MEM_C) size 81 ext/mysqlnd/mysqlnd_alloc.h #define mnd_malloc(size) mysqlnd_allocator.m_malloc((size) MYSQLND_MEM_C) size 82 ext/mysqlnd/mysqlnd_alloc.h #define mnd_calloc(nmemb, size) mysqlnd_allocator.m_calloc((nmemb), (size) MYSQLND_MEM_C) size 85 ext/mysqlnd/mysqlnd_alloc.h #define mnd_pestrndup(ptr, size, pers) mysqlnd_allocator.m_pestrndup((ptr), (size), (pers) MYSQLND_MEM_C) size 38 ext/mysqlnd/mysqlnd_block_alloc.c if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) { size 43 ext/mysqlnd/mysqlnd_block_alloc.c pool->free_size += chunk->size; size 57 ext/mysqlnd/mysqlnd_block_alloc.c mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC) size 63 ext/mysqlnd/mysqlnd_block_alloc.c if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) { size 68 ext/mysqlnd/mysqlnd_block_alloc.c if ((chunk->size + pool->free_size) < size) { size 70 ext/mysqlnd/mysqlnd_block_alloc.c new_ptr = mnd_malloc(size); size 74 ext/mysqlnd/mysqlnd_block_alloc.c memcpy(new_ptr, chunk->ptr, chunk->size); size 76 ext/mysqlnd/mysqlnd_block_alloc.c pool->free_size += chunk->size; size 77 ext/mysqlnd/mysqlnd_block_alloc.c chunk->size = size; size 82 ext/mysqlnd/mysqlnd_block_alloc.c pool->free_size += (chunk->size - size); size 86 ext/mysqlnd/mysqlnd_block_alloc.c if (chunk->size >= size) { size 90 ext/mysqlnd/mysqlnd_block_alloc.c new_ptr = mnd_malloc(size); size 94 ext/mysqlnd/mysqlnd_block_alloc.c memcpy(new_ptr, chunk->ptr, chunk->size); size 96 ext/mysqlnd/mysqlnd_block_alloc.c chunk->size = size; size 102 ext/mysqlnd/mysqlnd_block_alloc.c zend_uchar *new_ptr = mnd_realloc(chunk->ptr, size); size 115 ext/mysqlnd/mysqlnd_block_alloc.c MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, unsigned int size TSRMLS_DC) size 124 ext/mysqlnd/mysqlnd_block_alloc.c chunk->size = size; size 131 ext/mysqlnd/mysqlnd_block_alloc.c if (size > pool->free_size) { size 133 ext/mysqlnd/mysqlnd_block_alloc.c chunk->ptr = mnd_malloc(size); size 143 ext/mysqlnd/mysqlnd_block_alloc.c pool->free_size -= size; size 544 ext/mysqlnd/mysqlnd_net.c ret->size = ret->len = count; size 51 ext/mysqlnd/mysqlnd_structs.h MYSQLND_MEMORY_POOL_CHUNK* (*get_chunk)(MYSQLND_MEMORY_POOL * pool, unsigned int size TSRMLS_DC); size 59 ext/mysqlnd/mysqlnd_structs.h unsigned int size; size 60 ext/mysqlnd/mysqlnd_structs.h enum_func_status (*resize_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC); size 280 ext/mysqlnd/mysqlnd_structs.h size_t size; size 45 ext/mysqlnd/mysqlnd_wireprotocol.c if ((buf_size) < (packet)->header.size) { \ size 47 ext/mysqlnd/mysqlnd_wireprotocol.c (buf_size), (packet)->header.size, (packet)->header.size - (buf_size)); \ size 50 ext/mysqlnd/mysqlnd_wireprotocol.c if (FAIL == conn->net->data->m.receive_ex((conn)->net, (buf), (packet)->header.size, (conn)->stats, ((conn)->error_info) TSRMLS_CC)) { \ size 58 ext/mysqlnd/mysqlnd_wireprotocol.c MYSQLND_HEADER_SIZE + (packet)->header.size, \ size 65 ext/mysqlnd/mysqlnd_wireprotocol.c if ((size_t)(p - begin) > packet->header.size) { \ size 291 ext/mysqlnd/mysqlnd_wireprotocol.c header->size = uint3korr(buffer); size 295 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_INF_FMT("HEADER: prot_packet_no=%u size=%3u", header->packet_no, header->size); size 312 ext/mysqlnd/mysqlnd_wireprotocol.c net->packet_no, header->packet_no, header->size); size 315 ext/mysqlnd/mysqlnd_wireprotocol.c net->packet_no, header->packet_no, header->size); size 339 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size < sizeof(buf)) { size 344 ext/mysqlnd/mysqlnd_wireprotocol.c buf[packet->header.size] = '\0'; size 352 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 400 ext/mysqlnd/mysqlnd_wireprotocol.c if ((size_t) (p - buf) < packet->header.size) { size 410 ext/mysqlnd/mysqlnd_wireprotocol.c if ((size_t) (p - buf) < packet->header.size) { size 449 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("GREET packet %d bytes shorter than expected", p - begin - packet->header.size); size 451 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 664 ext/mysqlnd/mysqlnd_wireprotocol.c buf[packet->header.size] = '\0'; size 672 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 680 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf)) { size 685 ext/mysqlnd/mysqlnd_wireprotocol.c packet->new_auth_protocol_data_len = packet->header.size - (size_t) (p - buf); size 710 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (i = php_mysqlnd_net_field_length(&p))) { size 725 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 727 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 827 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 850 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (i = php_mysqlnd_net_field_length(&p))) { size 866 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 868 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 917 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 929 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > 1) { size 949 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("EOF packet %d bytes shorter than expected", p - begin - packet->header.size); size 951 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 1070 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 1091 ext/mysqlnd/mysqlnd_wireprotocol.c len = packet->header.size - 1; size 1118 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (len = php_mysqlnd_net_field_length(&p))) { size 1142 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("RSET_HEADER packet %d bytes shorter than expected", p - begin - packet->header.size); size 1144 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 1212 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 1218 ext/mysqlnd/mysqlnd_wireprotocol.c } else if (EODATA_MARKER == *p && packet->header.size < 8) { size 1294 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && size 1373 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("RSET field packet %d bytes shorter than expected", p - begin - packet->header.size); size 1375 ext/mysqlnd/mysqlnd_wireprotocol.c "shorter than expected", p - begin - packet->header.size); size 1423 ext/mysqlnd/mysqlnd_wireprotocol.c *data_size += header.size; size 1439 ext/mysqlnd/mysqlnd_wireprotocol.c if (!header.size) { size 1455 ext/mysqlnd/mysqlnd_wireprotocol.c p = (*buffer)->ptr + (*data_size - header.size); size 1458 ext/mysqlnd/mysqlnd_wireprotocol.c if (PASS != (ret = conn->net->data->m.receive_ex(conn->net, p, header.size, conn->stats, conn->error_info TSRMLS_CC))) { size 1464 ext/mysqlnd/mysqlnd_wireprotocol.c if (header.size < MYSQLND_MAX_PACKET_SIZE) { size 1820 ext/mysqlnd/mysqlnd_wireprotocol.c MYSQLND_HEADER_SIZE + packet->header.size, size 1825 ext/mysqlnd/mysqlnd_wireprotocol.c packet->header.size = data_size; size 1928 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message = mnd_emalloc(packet->header.size + 1); size 1929 ext/mysqlnd/mysqlnd_wireprotocol.c memcpy(packet->message, buf, packet->header.size); size 1930 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message[packet->header.size] = '\0'; size 1931 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message_len = packet->header.size; size 1975 ext/mysqlnd/mysqlnd_wireprotocol.c data_size = packet->header.size; size 2026 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("PREPARE packet %d bytes shorter than expected", p - begin - packet->header.size); size 2028 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 2071 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size == 1 && buf[0] == EODATA_MARKER && packet->server_capabilities & CLIENT_SECURE_CONNECTION) { size 2078 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 2086 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->response_code == 0xFE && packet->header.size > (size_t) (p - buf)) { size 2090 ext/mysqlnd/mysqlnd_wireprotocol.c packet->new_auth_protocol_data_len = packet->header.size - (size_t) (p - buf); size 2101 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("CHANGE_USER packet %d bytes shorter than expected", p - begin - packet->header.size); size 2103 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 2183 ext/mysqlnd/mysqlnd_wireprotocol.c packet->public_key_len = packet->header.size - (p - buf); size 2191 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 2193 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 61 ext/mysqlnd/mysqlnd_wireprotocol.h size_t size; size 1005 ext/oci8/oci8.c PHP_FALIAS(size, oci_lob_size, arginfo_oci_lob_size_method) size 1031 ext/oci8/oci8.c PHP_FALIAS(size, oci_collection_size, arginfo_oci_collection_size_method) size 244 ext/oci8/oci8_collection.c int php_oci_collection_size(php_oci_collection *collection, sb4 *size TSRMLS_DC) size 249 ext/oci8/oci8_collection.c PHP_OCI_CALL_RETURN(errstatus, OCICollSize, (connection->env, connection->err, collection->collection, (sb4 *)size)); size 1720 ext/oci8/oci8_interface.c long size; size 1722 ext/oci8/oci8_interface.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &z_statement, &size) == FAILURE) { size 1728 ext/oci8/oci8_interface.c if (size < 0) { size 1733 ext/oci8/oci8_interface.c if (php_oci_statement_set_prefetch(statement, (ub4)size TSRMLS_CC)) { size 2336 ext/oci8/oci8_interface.c sb4 size = 0; size 2351 ext/oci8/oci8_interface.c if (php_oci_collection_size(collection, &size TSRMLS_CC)) { size 2354 ext/oci8/oci8_interface.c RETURN_LONG(size); size 448 ext/oci8/php_oci8_int.h int php_oci_collection_size(php_oci_collection *collection, sb4 *size TSRMLS_DC); size 687 ext/opcache/ZendAccelerator.c static accel_time_t zend_get_file_handle_timestamp_win(zend_file_handle *file_handle, size_t *size) size 722 ext/opcache/ZendAccelerator.c if (size) { size 723 ext/opcache/ZendAccelerator.c *size = (size_t)(((unsigned __int64)fdata.nFileSizeHigh) << 32 + (unsigned __int64)fdata.nFileSizeLow); size 731 ext/opcache/ZendAccelerator.c static accel_time_t zend_get_file_handle_timestamp(zend_file_handle *file_handle, size_t *size TSRMLS_DC) size 745 ext/opcache/ZendAccelerator.c if (size) { size 746 ext/opcache/ZendAccelerator.c *size = tmpbuf->st_size; size 753 ext/opcache/ZendAccelerator.c res = zend_get_file_handle_timestamp_win(file_handle, size); size 827 ext/opcache/ZendAccelerator.c if (size) { size 828 ext/opcache/ZendAccelerator.c *size = statbuf.st_size; size 906 ext/opcache/ZendAccelerator.c size_t size = persistent_script->size; size 912 ext/opcache/ZendAccelerator.c size -= (signed char*)persistent_script - mem; size 918 ext/opcache/ZendAccelerator.c size -= sizeof(*persistent_script); size 920 ext/opcache/ZendAccelerator.c if (size > 0) { size 921 ext/opcache/ZendAccelerator.c checksum = zend_adler32(checksum, mem, size); size 1195 ext/opcache/ZendAccelerator.c new_persistent_script->size = memory_used; size 1201 ext/opcache/ZendAccelerator.c if ((char*)new_persistent_script->mem + new_persistent_script->size != (char*)ZCG(mem)) { size 1203 ext/opcache/ZendAccelerator.c ((char*)new_persistent_script->mem + new_persistent_script->size < (char*)ZCG(mem)) ? ACCEL_LOG_ERROR : ACCEL_LOG_WARNING, size 1207 ext/opcache/ZendAccelerator.c (char *)new_persistent_script->mem + new_persistent_script->size, size 1233 ext/opcache/ZendAccelerator.c new_persistent_script->dynamic_members.memory_consumption = ZEND_ALIGNED_SIZE(new_persistent_script->size); size 1342 ext/opcache/ZendAccelerator.c size_t size = 0; size 1347 ext/opcache/ZendAccelerator.c timestamp = zend_get_file_handle_timestamp(file_handle, ZCG(accel_directives).max_file_size > 0 ? &size : NULL TSRMLS_CC); size 1364 ext/opcache/ZendAccelerator.c if (ZCG(accel_directives).max_file_size > 0 && size > (size_t)ZCG(accel_directives).max_file_size) { size 201 ext/opcache/ZendAccelerator.h size_t size; /* size of used shared memory */ size 56 ext/opcache/shared_alloc_mmap.c shared_segment->size = requested_size; size 63 ext/opcache/shared_alloc_mmap.c munmap(shared_segment->p, shared_segment->size); size 75 ext/opcache/shared_alloc_posix.c shared_segment->common.size = requested_size; size 82 ext/opcache/shared_alloc_posix.c munmap(shared_segment->common.p, shared_segment->common.size); size 122 ext/opcache/shared_alloc_shm.c shared_segments[i].common.size = allocate_size; size 363 ext/opcache/shared_alloc_win32.c shared_segment->size = requested_size; size 63 ext/opcache/zend_accelerator_blacklist.c blacklist->size = ZEND_BLACKLIST_BLOCK_SIZE; size 69 ext/opcache/zend_accelerator_blacklist.c blacklist->entries = (zend_blacklist_entry *) calloc(sizeof(zend_blacklist_entry), blacklist->size); size 234 ext/opcache/zend_accelerator_blacklist.c if (blacklist->pos == blacklist->size) { size 235 ext/opcache/zend_accelerator_blacklist.c blacklist->size += ZEND_BLACKLIST_BLOCK_SIZE; size 236 ext/opcache/zend_accelerator_blacklist.c blacklist->entries = (zend_blacklist_entry *) realloc(blacklist->entries, sizeof(zend_blacklist_entry)*blacklist->size); size 35 ext/opcache/zend_accelerator_blacklist.h int size; size 146 ext/opcache/zend_accelerator_module.c long size; size 157 ext/opcache/zend_accelerator_module.c size = atoi(new_value); size 160 ext/opcache/zend_accelerator_module.c if (size < MIN_ACCEL_FILES || size > MAX_ACCEL_FILES) { size 164 ext/opcache/zend_accelerator_module.c if (size < MIN_ACCEL_FILES) { size 165 ext/opcache/zend_accelerator_module.c size = MIN_ACCEL_FILES; size 170 ext/opcache/zend_accelerator_module.c if (size > MAX_ACCEL_FILES) { size 171 ext/opcache/zend_accelerator_module.c size = MAX_ACCEL_FILES; size 185 ext/opcache/zend_accelerator_module.c *p = size; size 891 ext/opcache/zend_accelerator_util_funcs.c static int zend_hash_unique_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor, uint size, int ignore_dups, void **fail_data, void **conflict_data) size 899 ext/opcache/zend_accelerator_util_funcs.c if (zend_hash_quick_add(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t) == SUCCESS) { size 907 ext/opcache/zend_accelerator_util_funcs.c if (zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t) == SUCCESS) { size 920 ext/opcache/zend_accelerator_util_funcs.c if (!zend_hash_index_exists(target, p->h) && zend_hash_index_update(target, p->h, p->pData, size, &t) == SUCCESS) { size 31 ext/opcache/zend_persist.c #define zend_accel_store(p, size) \ size 32 ext/opcache/zend_persist.c (p = _zend_shared_memdup((void*)p, size, 1 TSRMLS_CC)) size 33 ext/opcache/zend_persist.c #define zend_accel_memdup(p, size) \ size 34 ext/opcache/zend_persist.c _zend_shared_memdup((void*)p, size, 0 TSRMLS_CC) size 225 ext/opcache/zend_persist.c op_array->size = op_array->last; size 107 ext/opcache/zend_shared_alloc.c static void copy_shared_segments(void *to, void *from, int count, int size) size 116 ext/opcache/zend_shared_alloc.c memcpy(shared_segments_to_p, shared_segments_from_p, size); size 117 ext/opcache/zend_shared_alloc.c shared_segments_to_p = ((char *)shared_segments_to_p + size); size 118 ext/opcache/zend_shared_alloc.c shared_segments_from_p = ((char *)shared_segments_from_p + size); size 279 ext/opcache/zend_shared_alloc.c size_t block_size = ZSMMG(shared_segments)[i]->size - ZSMMG(shared_segments)[i]->pos; size 291 ext/opcache/zend_shared_alloc.c zend_accel_error(ACCEL_LOG_WARNING, "Not enough free shared space to allocate %ld bytes (%ld bytes free)", (long)size, (long)ZSMMG(shared_free)); \ size 297 ext/opcache/zend_shared_alloc.c void *zend_shared_alloc(size_t size) size 300 ext/opcache/zend_shared_alloc.c unsigned int block_size = ZEND_ALIGNED_SIZE(size); size 313 ext/opcache/zend_shared_alloc.c if (ZSMMG(shared_segments)[i]->size - ZSMMG(shared_segments)[i]->pos >= block_size) { /* found a valid block */ size 326 ext/opcache/zend_shared_alloc.c int zend_shared_memdup_size(void *source, size_t size) size 335 ext/opcache/zend_shared_alloc.c return ZEND_ALIGNED_SIZE(size); size 338 ext/opcache/zend_shared_alloc.c void *_zend_shared_memdup(void *source, size_t size, zend_bool free_source TSRMLS_DC) size 347 ext/opcache/zend_shared_alloc.c ZCG(mem) = (void*)(((char*)ZCG(mem)) + ZEND_ALIGNED_SIZE(size)); size 348 ext/opcache/zend_shared_alloc.c memcpy(retval, source, size); size 491 ext/opcache/zend_shared_alloc.c mprotect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->size, mode); size 73 ext/opcache/zend_shared_alloc.h size_t size; size 124 ext/opcache/zend_shared_alloc.h void *zend_shared_alloc(size_t size); size 127 ext/opcache/zend_shared_alloc.h void *_zend_shared_memdup(void *p, size_t size, zend_bool free_source TSRMLS_DC); size 128 ext/opcache/zend_shared_alloc.h int zend_shared_memdup_size(void *p, size_t size); size 142 ext/opcache/zend_shared_alloc.h #define ZEND_ALIGNED_SIZE(size) \ size 143 ext/opcache/zend_shared_alloc.h ((size + PLATFORM_ALIGNMENT - 1) & ~(PLATFORM_ALIGNMENT - 1)) size 9007 ext/pcre/pcrelib/pcre_compile.c size_t size; size 9339 ext/pcre/pcrelib/pcre_compile.c size = sizeof(REAL_PCRE) + size 9344 ext/pcre/pcrelib/pcre_compile.c re = (REAL_PCRE *)(PUBL(malloc))(size); size 9358 ext/pcre/pcrelib/pcre_compile.c re->size = (int)size; size 110 ext/pcre/pcrelib/pcre_fullinfo.c *((size_t *)where) = re->size; size 114 ext/pcre/pcrelib/pcre_fullinfo.c *((size_t *)where) = (study == NULL)? 0 : study->size; size 336 ext/pcre/pcrelib/pcre_get.c int stringnumber, char *buffer, int size) size 340 ext/pcre/pcrelib/pcre_get.c int stringnumber, PCRE_UCHAR16 *buffer, int size) size 344 ext/pcre/pcrelib/pcre_get.c int stringnumber, PCRE_UCHAR32 *buffer, int size) size 352 ext/pcre/pcrelib/pcre_get.c if (size < yield + 1) return PCRE_ERROR_NOMEMORY; size 392 ext/pcre/pcrelib/pcre_get.c char *buffer, int size) size 397 ext/pcre/pcrelib/pcre_get.c PCRE_UCHAR16 *buffer, int size) size 402 ext/pcre/pcrelib/pcre_get.c PCRE_UCHAR32 *buffer, int size) size 408 ext/pcre/pcrelib/pcre_get.c return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size); size 410 ext/pcre/pcrelib/pcre_get.c return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size); size 412 ext/pcre/pcrelib/pcre_get.c return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size); size 454 ext/pcre/pcrelib/pcre_get.c int size = sizeof(pcre_uchar *); size 460 ext/pcre/pcrelib/pcre_get.c size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1); size 462 ext/pcre/pcrelib/pcre_get.c stringlist = (pcre_uchar **)(PUBL(malloc))(size); size 2331 ext/pcre/pcrelib/pcre_internal.h pcre_uint32 size; /* Total that was malloced */ size 2357 ext/pcre/pcrelib/pcre_internal.h pcre_uint32 size; /* Total that was malloced */ size 2392 ext/pcre/pcrelib/pcre_internal.h #define REAL_PCRE_SIZE(re) (((REAL_PCRE*)re)->size) size 2400 ext/pcre/pcrelib/pcre_internal.h pcre_uint32 size; /* Total that was malloced */ size 55 ext/pcre/pcrelib/pcre_jit_compile.c #define SLJIT_MALLOC(size, allocator_data) (PUBL(malloc))(size) size 1066 ext/pcre/pcrelib/pcre_jit_compile.c int space, size, bracketlen; size 1072 ext/pcre/pcrelib/pcre_jit_compile.c size = 0; size 1147 ext/pcre/pcrelib/pcre_jit_compile.c size = 1; size 1152 ext/pcre/pcrelib/pcre_jit_compile.c size = -2; size 1157 ext/pcre/pcrelib/pcre_jit_compile.c size = -2; size 1162 ext/pcre/pcrelib/pcre_jit_compile.c size = -(2 + IMM2_SIZE); size 1167 ext/pcre/pcrelib/pcre_jit_compile.c size = 1; size 1173 ext/pcre/pcrelib/pcre_jit_compile.c size = 1; size 1179 ext/pcre/pcrelib/pcre_jit_compile.c size = 1 + IMM2_SIZE; size 1184 ext/pcre/pcrelib/pcre_jit_compile.c size = 1 + IMM2_SIZE; size 1189 ext/pcre/pcrelib/pcre_jit_compile.c size += 1 + 32 / sizeof(pcre_uchar); size 1190 ext/pcre/pcrelib/pcre_jit_compile.c space = get_class_iterator_size(cc + size); size 1195 ext/pcre/pcrelib/pcre_jit_compile.c size = GET(cc, 1); size 1196 ext/pcre/pcrelib/pcre_jit_compile.c space = get_class_iterator_size(cc + size); size 1214 ext/pcre/pcrelib/pcre_jit_compile.c if (size != 0) size 1216 ext/pcre/pcrelib/pcre_jit_compile.c if (size < 0) size 1218 ext/pcre/pcrelib/pcre_jit_compile.c cc += -size; size 1224 ext/pcre/pcrelib/pcre_jit_compile.c cc += size; size 1549 ext/pcre/pcrelib/pcre_jit_compile.c int size; size 1554 ext/pcre/pcrelib/pcre_jit_compile.c size = 0; size 1652 ext/pcre/pcrelib/pcre_jit_compile.c size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar); size 1654 ext/pcre/pcrelib/pcre_jit_compile.c size = 1 + 32 / (int)sizeof(pcre_uchar); size 1657 ext/pcre/pcrelib/pcre_jit_compile.c private_data_length += get_class_iterator_size(cc + size); size 1658 ext/pcre/pcrelib/pcre_jit_compile.c cc += size; size 1676 ext/pcre/pcrelib/pcre_jit_compile.c int count, size; size 1865 ext/pcre/pcrelib/pcre_jit_compile.c size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar); size 1867 ext/pcre/pcrelib/pcre_jit_compile.c size = 1 + 32 / (int)sizeof(pcre_uchar); size 1870 ext/pcre/pcrelib/pcre_jit_compile.c switch(get_class_iterator_size(cc + size)) size 1887 ext/pcre/pcrelib/pcre_jit_compile.c cc += size; size 2111 ext/pcre/pcrelib/pcre_jit_compile.c static SLJIT_INLINE void allocate_stack(compiler_common *common, int size) size 2116 ext/pcre/pcrelib/pcre_jit_compile.c OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw)); size 2127 ext/pcre/pcrelib/pcre_jit_compile.c static SLJIT_INLINE void free_stack(compiler_common *common, int size) size 2130 ext/pcre/pcrelib/pcre_jit_compile.c OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw)); size 2133 ext/pcre/pcrelib/pcre_jit_compile.c static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size) size 2141 ext/pcre/pcrelib/pcre_jit_compile.c result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data); size 5866 ext/pcre/pcrelib/pcre_jit_compile.c int size; size 5876 ext/pcre/pcrelib/pcre_jit_compile.c size = 1; size 5879 ext/pcre/pcrelib/pcre_jit_compile.c size += GET_EXTRALEN(cc[1]); size 5884 ext/pcre/pcrelib/pcre_jit_compile.c size = 1; size 5889 ext/pcre/pcrelib/pcre_jit_compile.c size = 0; size 5891 ext/pcre/pcrelib/pcre_jit_compile.c size += GET_EXTRALEN(cc[1]); size 5896 ext/pcre/pcrelib/pcre_jit_compile.c size = 0; size 5899 ext/pcre/pcrelib/pcre_jit_compile.c size = 0; size 5901 ext/pcre/pcrelib/pcre_jit_compile.c cc += 1 + size; size 5902 ext/pcre/pcrelib/pcre_jit_compile.c context.length += IN_UCHARS(size); size 5904 ext/pcre/pcrelib/pcre_jit_compile.c while (size > 0 && context.length <= 128); size 5929 ext/pcre/pcrelib/pcre_jit_compile.c #define PUSH_BACKTRACK(size, ccstart, error) \ size 5932 ext/pcre/pcrelib/pcre_jit_compile.c backtrack = sljit_alloc_memory(compiler, (size)); \ size 5935 ext/pcre/pcrelib/pcre_jit_compile.c memset(backtrack, 0, size); \ size 5942 ext/pcre/pcrelib/pcre_jit_compile.c #define PUSH_BACKTRACK_NOVALUE(size, ccstart) \ size 5945 ext/pcre/pcrelib/pcre_jit_compile.c backtrack = sljit_alloc_memory(compiler, (size)); \ size 5948 ext/pcre/pcrelib/pcre_jit_compile.c memset(backtrack, 0, size); \ size 8249 ext/pcre/pcrelib/pcre_jit_compile.c int size; size 8257 ext/pcre/pcrelib/pcre_jit_compile.c size = BACKTRACK_AS(then_trap_backtrack)->framesize; size 8258 ext/pcre/pcrelib/pcre_jit_compile.c size = 3 + (size < 0 ? 0 : size); size 8261 ext/pcre/pcrelib/pcre_jit_compile.c allocate_stack(common, size); size 8262 ext/pcre/pcrelib/pcre_jit_compile.c if (size > 3) size 8263 ext/pcre/pcrelib/pcre_jit_compile.c OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw)); size 8266 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start); size 8267 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap); size 8268 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0); size 8270 ext/pcre/pcrelib/pcre_jit_compile.c size = BACKTRACK_AS(then_trap_backtrack)->framesize; size 8271 ext/pcre/pcrelib/pcre_jit_compile.c if (size >= 0) size 8272 ext/pcre/pcrelib/pcre_jit_compile.c init_frame(common, cc, ccend, size - 1, 0, FALSE); size 9450 ext/pcre/pcrelib/pcre_jit_compile.c int size; size 9458 ext/pcre/pcrelib/pcre_jit_compile.c size = CURRENT_AS(then_trap_backtrack)->framesize; size 9459 ext/pcre/pcrelib/pcre_jit_compile.c size = 3 + (size < 0 ? 0 : size); size 9461 ext/pcre/pcrelib/pcre_jit_compile.c OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3)); size 9462 ext/pcre/pcrelib/pcre_jit_compile.c free_stack(common, size); size 10584 ext/pcre/pcrelib/pcre_jit_compile.c sljit_uw size = 0; size 10587 ext/pcre/pcrelib/pcre_jit_compile.c size += executable_sizes[i]; size 10588 ext/pcre/pcrelib/pcre_jit_compile.c return (int)size; size 1584 ext/pcre/pcrelib/pcre_study.c study->size = sizeof(pcre_study_data); size 206 ext/pcre/pcrelib/sljit/sljitConfigInternal.h #define SLJIT_MALLOC(size, allocator_data) malloc(size) size 532 ext/pcre/pcrelib/sljit/sljitConfigInternal.h SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size); size 535 ext/pcre/pcrelib/sljit/sljitConfigInternal.h #define SLJIT_MALLOC_EXEC(size) sljit_malloc_exec(size) size 84 ext/pcre/pcrelib/sljit/sljitExecAllocator.c static SLJIT_INLINE void* alloc_chunk(sljit_uw size) size 86 ext/pcre/pcrelib/sljit/sljitExecAllocator.c return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); size 89 ext/pcre/pcrelib/sljit/sljitExecAllocator.c static SLJIT_INLINE void free_chunk(void* chunk, sljit_uw size) size 91 ext/pcre/pcrelib/sljit/sljitExecAllocator.c SLJIT_UNUSED_ARG(size); size 97 ext/pcre/pcrelib/sljit/sljitExecAllocator.c static SLJIT_INLINE void* alloc_chunk(sljit_uw size) size 102 ext/pcre/pcrelib/sljit/sljitExecAllocator.c retval = mmap(NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0); size 108 ext/pcre/pcrelib/sljit/sljitExecAllocator.c retval = mmap(NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, dev_zero, 0); size 114 ext/pcre/pcrelib/sljit/sljitExecAllocator.c static SLJIT_INLINE void free_chunk(void* chunk, sljit_uw size) size 116 ext/pcre/pcrelib/sljit/sljitExecAllocator.c munmap(chunk, size); size 128 ext/pcre/pcrelib/sljit/sljitExecAllocator.c sljit_uw size; size 136 ext/pcre/pcrelib/sljit/sljitExecAllocator.c sljit_uw size; size 144 ext/pcre/pcrelib/sljit/sljitExecAllocator.c #define ALIGN_SIZE(size) (((size) + sizeof(struct block_header) + 7) & ~7) size 150 ext/pcre/pcrelib/sljit/sljitExecAllocator.c static SLJIT_INLINE void sljit_insert_free_block(struct free_block *free_block, sljit_uw size) size 152 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->header.size = 0; size 153 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->size = size; size 175 ext/pcre/pcrelib/sljit/sljitExecAllocator.c SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size) size 183 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (size < sizeof(struct free_block)) size 184 ext/pcre/pcrelib/sljit/sljitExecAllocator.c size = sizeof(struct free_block); size 185 ext/pcre/pcrelib/sljit/sljitExecAllocator.c size = ALIGN_SIZE(size); size 189 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (free_block->size >= size) { size 190 ext/pcre/pcrelib/sljit/sljitExecAllocator.c chunk_size = free_block->size; size 191 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (chunk_size > size + 64) { size 193 ext/pcre/pcrelib/sljit/sljitExecAllocator.c chunk_size -= size; size 194 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->size = chunk_size; size 197 ext/pcre/pcrelib/sljit/sljitExecAllocator.c AS_BLOCK_HEADER(header, size)->prev_size = size; size 202 ext/pcre/pcrelib/sljit/sljitExecAllocator.c size = chunk_size; size 204 ext/pcre/pcrelib/sljit/sljitExecAllocator.c allocated_size += size; size 205 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header->size = size; size 212 ext/pcre/pcrelib/sljit/sljitExecAllocator.c chunk_size = (size + sizeof(struct block_header) + CHUNK_SIZE - 1) & CHUNK_MASK; size 223 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (chunk_size > size + 64) { size 225 ext/pcre/pcrelib/sljit/sljitExecAllocator.c allocated_size += size; size 226 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header->size = size; size 227 ext/pcre/pcrelib/sljit/sljitExecAllocator.c chunk_size -= size; size 229 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block = AS_FREE_BLOCK(header, size); size 230 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->header.prev_size = size; size 237 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header->size = chunk_size; size 240 ext/pcre/pcrelib/sljit/sljitExecAllocator.c next_header->size = 1; size 253 ext/pcre/pcrelib/sljit/sljitExecAllocator.c allocated_size -= header->size; size 260 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (SLJIT_UNLIKELY(!free_block->header.size)) { size 261 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->size += header->size; size 262 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header = AS_BLOCK_HEADER(free_block, free_block->size); size 263 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header->prev_size = free_block->size; size 267 ext/pcre/pcrelib/sljit/sljitExecAllocator.c sljit_insert_free_block(free_block, header->size); size 270 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header = AS_BLOCK_HEADER(free_block, free_block->size); size 271 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (SLJIT_UNLIKELY(!header->size)) { size 272 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_block->size += ((struct free_block*)header)->size; size 274 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header = AS_BLOCK_HEADER(free_block, free_block->size); size 275 ext/pcre/pcrelib/sljit/sljitExecAllocator.c header->prev_size = free_block->size; size 279 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (SLJIT_UNLIKELY(!free_block->header.prev_size && header->size == 1)) { size 281 ext/pcre/pcrelib/sljit/sljitExecAllocator.c if (total_size - free_block->size > (allocated_size * 3 / 2)) { size 282 ext/pcre/pcrelib/sljit/sljitExecAllocator.c total_size -= free_block->size; size 284 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_chunk(free_block, free_block->size + sizeof(struct block_header)); size 302 ext/pcre/pcrelib/sljit/sljitExecAllocator.c AS_BLOCK_HEADER(free_block, free_block->size)->size == 1) { size 303 ext/pcre/pcrelib/sljit/sljitExecAllocator.c total_size -= free_block->size; size 305 ext/pcre/pcrelib/sljit/sljitExecAllocator.c free_chunk(free_block, free_block->size + sizeof(struct block_header)); size 486 ext/pcre/pcrelib/sljit/sljitLir.c static void* ensure_buf(struct sljit_compiler *compiler, sljit_uw size) size 491 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_ASSERT(size <= 256); size 492 ext/pcre/pcrelib/sljit/sljitLir.c if (compiler->buf->used_size + size <= (BUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) { size 494 ext/pcre/pcrelib/sljit/sljitLir.c compiler->buf->used_size += size; size 501 ext/pcre/pcrelib/sljit/sljitLir.c new_frag->used_size = size; size 505 ext/pcre/pcrelib/sljit/sljitLir.c static void* ensure_abuf(struct sljit_compiler *compiler, sljit_uw size) size 510 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_ASSERT(size <= 256); size 511 ext/pcre/pcrelib/sljit/sljitLir.c if (compiler->abuf->used_size + size <= (ABUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) { size 513 ext/pcre/pcrelib/sljit/sljitLir.c compiler->abuf->used_size += size; size 520 ext/pcre/pcrelib/sljit/sljitLir.c new_frag->used_size = size; size 524 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_si size) size 529 ext/pcre/pcrelib/sljit/sljitLir.c if (size <= 0 || size > 128) size 531 ext/pcre/pcrelib/sljit/sljitLir.c size = (size + 7) & ~7; size 533 ext/pcre/pcrelib/sljit/sljitLir.c if (size <= 0 || size > 64) size 535 ext/pcre/pcrelib/sljit/sljitLir.c size = (size + 3) & ~3; size 537 ext/pcre/pcrelib/sljit/sljitLir.c return ensure_abuf(compiler, size); size 593 ext/pcre/pcrelib/sljit/sljitLir.c label->size = compiler->size; size 615 ext/pcre/pcrelib/sljit/sljitLir.c const_->addr = compiler->size; size 914 ext/pcre/pcrelib/sljit/sljitLir.c CHECK_ARGUMENT(compiler->size > 0); size 1131 ext/pcre/pcrelib/sljit/sljitLir.c void *instruction, sljit_si size) size 1142 ext/pcre/pcrelib/sljit/sljitLir.c CHECK_ARGUMENT(size > 0 && size < 16); size 1144 ext/pcre/pcrelib/sljit/sljitLir.c CHECK_ARGUMENT((size == 2 && (((sljit_sw)instruction) & 0x1) == 0) size 1145 ext/pcre/pcrelib/sljit/sljitLir.c || (size == 4 && (((sljit_sw)instruction) & 0x3) == 0)); size 1147 ext/pcre/pcrelib/sljit/sljitLir.c CHECK_ARGUMENT(size == 4 && (((sljit_sw)instruction) & 0x3) == 0); size 1154 ext/pcre/pcrelib/sljit/sljitLir.c for (i = 0; i < size; i++) size 1730 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_si size) size 1733 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_UNUSED_ARG(size); size 1866 ext/pcre/pcrelib/sljit/sljitLir.c void *instruction, sljit_si size) size 1870 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_UNUSED_ARG(size); size 281 ext/pcre/pcrelib/sljit/sljitLir.h sljit_uw size; size 325 ext/pcre/pcrelib/sljit/sljitLir.h sljit_uw size; size 451 ext/pcre/pcrelib/sljit/sljitLir.h SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_si size); size 1219 ext/pcre/pcrelib/sljit/sljitLir.h void *instruction, sljit_si size); size 138 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 139 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->last_label->size += compiler->cpool_fill + (CONST_POOL_ALIGNMENT - 1) + 1; size 144 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 150 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 159 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 171 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092))) size 176 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 189 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092))) size 221 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 227 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->cpool_diff = compiler->size; size 234 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (SLJIT_UNLIKELY((compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092)) || compiler->cpool_fill >= CPOOL_SIZE)) size 240 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 247 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->cpool_diff = compiler->size; size 254 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4088))) size 262 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c SLJIT_ASSERT(compiler->cpool_diff == CONST_POOL_EMPTY || compiler->size - compiler->cpool_diff < MAX_DIFFERENCE(4092)); size 379 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->size++; size 407 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)(code_ptr + 2)); size 432 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)code_ptr); size 563 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c sljit_uw size; size 584 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c size = compiler->size + (compiler->patches << 1); size 586 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c size += compiler->cpool_fill + CONST_POOL_ALIGNMENT - 1; size 588 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c size = compiler->size; size 590 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c code = (sljit_uw*)SLJIT_MALLOC_EXEC(size * sizeof(sljit_uw)); size 610 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (label && label->size == 0) { size 612 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c label->size = 0; size 637 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (label && label->size == word_count) { size 640 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c label->size = code_ptr - code; size 650 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c SLJIT_ASSERT(!label || label->size >= word_count); size 665 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (label && label->size == word_count) { size 668 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c label->size = (code_ptr + 1) - code; size 792 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c SLJIT_ASSERT(code_ptr - code <= (sljit_si)size); size 832 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c sljit_si size, i, tmp; size 853 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c size = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 1); size 854 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c local_size = ((size + local_size + 7) & ~7) - size; size 873 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c sljit_si size; size 879 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c size = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 1); size 880 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c compiler->local_size = ((size + local_size + 7) & ~7) - size; size 1987 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c void *instruction, sljit_si size) size 1990 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 2391 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 2420 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c jump->addr = compiler->size; size 2430 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c jump->addr = compiler->size; size 2436 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c jump->addr = compiler->size; size 2474 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c jump->addr = compiler->size; size 132 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c compiler->size++; size 168 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c target_addr = (sljit_uw)(code + jump->u.label->size); size 225 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); size 241 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c SLJIT_ASSERT(!label || label->size >= word_count); size 244 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c if (label && label->size == word_count) { size 246 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c label->size = code_ptr - code; size 265 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c if (label && label->size == word_count) { size 267 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c label->size = code_ptr - code; size 274 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size); size 1528 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c void *instruction, sljit_si size) size 1531 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 1871 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 1900 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c jump->addr = compiler->size; size 1935 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c jump->addr = compiler->size; size 1963 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c jump->addr = compiler->size; size 192 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c compiler->size++; size 202 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c compiler->size += 2; size 239 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)(code_ptr + 2)) >> 1; size 359 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c code = (sljit_uh*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_uh)); size 375 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c SLJIT_ASSERT(!label || label->size >= half_count); size 378 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c if (label && label->size == half_count) { size 380 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c label->size = code_ptr - code; size 399 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c if (label && label->size == half_count) { size 401 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c label->size = code_ptr - code; size 408 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size); size 1134 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c sljit_si size, i, tmp; size 1155 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c size = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 2); size 1156 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c local_size = ((size + local_size + 7) & ~7) - size; size 1179 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c sljit_si size; size 1185 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c size = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 2); size 1186 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c compiler->local_size = ((size + local_size + 7) & ~7) - size; size 1539 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c void *instruction, sljit_si size) size 1542 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 1544 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c if (size == 2) size 1905 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 1936 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c jump->addr = compiler->size; size 1971 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c jump->addr = compiler->size; size 211 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c compiler->size++; size 240 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c target_addr = (sljit_uw)(code + jump->u.label->size); size 377 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); size 391 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_ASSERT(!label || label->size >= word_count); size 395 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c if (label && label->size == word_count) { size 398 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c label->size = code_ptr - code; size 422 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c if (label && label->size == word_count) { size 424 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c label->size = code_ptr - code; size 431 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size); size 1264 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c void *instruction, sljit_si size) size 1267 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 1584 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 1702 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c jump->addr = compiler->size; size 1709 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c jump->addr = compiler->size; size 1849 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c jump->addr = compiler->size; size 1932 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c jump->addr = compiler->size; size 1999 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c jump->addr = compiler->size; size 244 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c compiler->size++; size 266 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c target_addr = (sljit_uw)(code + jump->u.label->size); size 337 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c compiler->size += (compiler->size & 0x1) + (sizeof(struct sljit_function_context) / sizeof(sljit_ins)); size 339 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c compiler->size += (sizeof(struct sljit_function_context) / sizeof(sljit_ins)); size 342 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); size 356 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c SLJIT_ASSERT(!label || label->size >= word_count); size 360 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c if (label && label->size == word_count) { size 363 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c label->size = code_ptr - code; size 418 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c if (label && label->size == word_count) { size 420 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c label->size = code_ptr - code; size 428 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size - (sizeof(struct sljit_function_context) / sizeof(sljit_ins))); size 430 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size); size 1672 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c void *instruction, sljit_si size) size 1675 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 2059 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 2158 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c jump->addr = compiler->size; size 2202 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c jump->addr = compiler->size; size 193 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c compiler->size++; size 212 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c target_addr = (sljit_uw)(code + jump->u.label->size); size 289 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); size 303 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c SLJIT_ASSERT(!label || label->size >= word_count); size 307 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c if (label && label->size == word_count) { size 310 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c label->size = code_ptr - code; size 334 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c if (label && label->size == word_count) { size 336 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c label->size = code_ptr - code; size 343 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c SLJIT_ASSERT(code_ptr - code <= (sljit_si)compiler->size); size 930 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c void *instruction, sljit_si size) size 933 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 1224 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 1329 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c jump->addr = compiler->size; size 1366 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c jump->addr = compiler->size; size 8371 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c #define BITFIELD(start, size) ((start) | (((1 << (size)) - 1) << 6)) size 335 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c compiler->size++; size 346 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c compiler->size++; size 357 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c compiler->size++; size 916 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c target_addr = (sljit_uw)(code + jump->u.label->size); size 1014 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c code = (sljit_ins *)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); size 1028 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c SLJIT_ASSERT(!label || label->size >= word_count); size 1032 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c if (label && label->size == word_count) { size 1035 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c label->size = code_ptr - code; size 1062 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c if (label && label->size == word_count) { size 1064 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c label->size = code_ptr - code; size 1071 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size); size 2306 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 2374 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c jump->addr = compiler->size; size 2377 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c jump->addr = compiler->size; size 2391 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c jump->addr = compiler->size; size 2474 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c jump->addr = compiler->size; size 2481 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c jump->addr = compiler->size; size 2555 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c void *instruction, sljit_si size) size 2558 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 70 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c sljit_si size; size 80 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size = 1 + (scratches > 7 ? (scratches - 7) : 0) + (saveds <= 3 ? saveds : 3); size 82 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size += (args > 0 ? (args * 2) : 0) + (args > 2 ? 2 : 0); size 84 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size += (args > 0 ? (2 + args * 3) : 0); size 86 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 89 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c INC_SIZE(size); size 210 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c sljit_si size; size 236 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size = 2 + (compiler->scratches > 7 ? (compiler->scratches - 7) : 0) + size 240 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size += 2; size 243 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size += 2; size 245 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 248 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c INC_SIZE(size); size 274 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, sljit_si size, size 282 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c sljit_si flags = size & ~0xf; size 297 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c size &= 0xf; size 298 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c inst_size = size; size 362 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c buf_ptr = inst + size; size 94 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c sljit_si i, tmp, size, saved_register_size; size 108 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size = reg_map[i] >= 8 ? 2 : 1; size 109 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 111 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c INC_SIZE(size); size 118 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size = reg_map[i] >= 8 ? 2 : 1; size 119 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 121 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c INC_SIZE(size); size 128 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size = args * 3; size 129 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 132 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c INC_SIZE(size); size 258 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c sljit_si i, tmp, size; size 300 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size = reg_map[i] >= 8 ? 2 : 1; size 301 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 303 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c INC_SIZE(size); size 311 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size = reg_map[i] >= 8 ? 2 : 1; size 312 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 314 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c INC_SIZE(size); size 346 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, sljit_si size, size 355 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c sljit_si flags = size & ~0xf; size 372 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c size &= 0xf; size 373 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c inst_size = size; size 472 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c buf_ptr = inst + size; size 259 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c #define INC_SIZE(s) (*inst++ = (s), compiler->size += (s)) size 401 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c label_addr = (sljit_uw)(code + jump->u.label->size); size 466 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c code = (sljit_ub*)SLJIT_MALLOC_EXEC(compiler->size); size 496 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c label->size = code_ptr - code; size 558 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c SLJIT_ASSERT(code_ptr <= code + compiler->size); size 726 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c sljit_si size; size 816 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c size = (!compiler->mode32 || op >= SLJIT_UDIVMOD) ? 3 : 2; size 818 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c size = (!compiler->mode32) ? 3 : 2; size 820 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 822 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c INC_SIZE(size); size 2241 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c void *instruction, sljit_si size) size 2246 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c CHECK(check_sljit_emit_op_custom(compiler, instruction, size)); size 2248 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c inst = (sljit_ub*)ensure_buf(compiler, 1 + size); size 2250 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c INC_SIZE(size); size 2251 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c SLJIT_MEMMOVE(inst, instruction, size); size 2538 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c if (compiler->last_label && compiler->last_label->size == compiler->size) size 2578 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c compiler->size += (type >= SLJIT_JUMP) ? 5 : 6; size 2580 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c compiler->size += (type >= SLJIT_JUMP) ? (10 + 3) : (2 + 10 + 3); size 2636 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c compiler->size += 5; size 2638 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c compiler->size += 10 + 3; size 471 ext/pdo/pdo_dbh.c fci.size = sizeof(zend_fcall_info); size 748 ext/pdo/pdo_stmt.c fci->size = sizeof(zend_fcall_info); size 821 ext/pdo/pdo_stmt.c if (stmt->fetch.cls.fci.size && stmt->fetch.cls.fci.params) { size 825 ext/pdo/pdo_stmt.c stmt->fetch.cls.fci.size = 0; size 959 ext/pdo/pdo_stmt.c if (!stmt->fetch.cls.fci.size) { size 1002 ext/pdo/pdo_stmt.c if (!stmt->fetch.func.fci.size) { size 328 ext/pdo_sqlite/sqlite_driver.c fc->fci.size = sizeof(fc->fci); size 492 ext/pdo_sqlite/sqlite_driver.c collation->fc.fci.size = sizeof(collation->fc.fci); size 380 ext/pgsql/pgsql.c ZEND_ARG_INFO(0, size) size 2792 ext/pgsql/pgsql.c fci.size = sizeof(fci); size 3811 ext/pgsql/pgsql.c size_t size; size 3816 ext/pgsql/pgsql.c if (zend_parse_parameters(argc TSRMLS_CC, "rl", &pgsql_id, &size) == FAILURE) { size 3824 ext/pgsql/pgsql.c result = lo_truncate64((PGconn *)pgsql->conn, pgsql->lofd, size); size 3826 ext/pgsql/pgsql.c result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size); size 3829 ext/pgsql/pgsql.c result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size); size 234 ext/phar/func_interceptors.c int size = 0; size 314 ext/phar/func_interceptors.c size = php_stream_passthru(stream); size 316 ext/phar/func_interceptors.c RETURN_LONG(size); size 137 ext/phar/pharzip.h char size[2]; size 142 ext/phar/pharzip.h char size[2]; /* TSize Short total data size for this block */ size 177 ext/phar/pharzip.h char size[2]; /* size of data 2 bytes */ size 211 ext/phar/tar.c php_uint32 sum1, sum2, size, old; size 266 ext/phar/tar.c size = entry.uncompressed_filesize = entry.compressed_filesize = size 267 ext/phar/tar.c phar_tar_number(hdr->size, sizeof(hdr->size)); size 271 ext/phar/tar.c size = (size+511)&~511; size 278 ext/phar/tar.c if (size > 511) { size 288 ext/phar/tar.c read = php_stream_read(fp, buf, size); size 289 ext/phar/tar.c if (read != size) { size 305 ext/phar/tar.c if (FAILURE == phar_verify_signature(fp, php_stream_tell(fp) - size - 512, myphar->sig_flags, buf + 8, size - 8, fname, &myphar->signature, &myphar->sig_len, error TSRMLS_CC)) { size 315 ext/phar/tar.c if (((hdr->typeflag == '\0') || (hdr->typeflag == TAR_FILE)) && size > 0) { size 382 ext/phar/tar.c size = ((size+511)&~511) - size; size 385 ext/phar/tar.c php_stream_seek(fp, size, SEEK_CUR); size 524 ext/phar/tar.c if (size > 511) { size 533 ext/phar/tar.c read = php_stream_read(fp, buf, size); size 535 ext/phar/tar.c if (read == size) { size 536 ext/phar/tar.c buf[size] = '\0'; size 537 ext/phar/tar.c if (!phar_validate_alias(buf, size)) { size 538 ext/phar/tar.c if (size > 50) { size 554 ext/phar/tar.c actual_alias = pestrndup(buf, size, myphar->is_persistent); size 556 ext/phar/tar.c myphar->alias_len = size; size 569 ext/phar/tar.c size = (size+511)&~511; size 571 ext/phar/tar.c if (((hdr->typeflag == '\0') || (hdr->typeflag == TAR_FILE)) && size > 0) { size 574 ext/phar/tar.c php_stream_seek(fp, size, SEEK_CUR); size 750 ext/phar/tar.c if (FAILURE == phar_tar_octal(header.size, entry->uncompressed_filesize, sizeof(header.size)-1)) { size 46 ext/phar/tar.h char size[12]; /* length of file in bytes */ size 70 ext/phar/tar.h char size[12]; /* length of file in bytes */ size 57 ext/phar/zip.c php_stream_seek(fp, PHAR_GET_16(h.header.size), SEEK_CUR); size 58 ext/phar/zip.c len -= PHAR_GET_16(h.header.size) + 4; size 70 ext/phar/zip.c if (PHAR_GET_16(h.unix3.size) > sizeof(h.unix3) - 4) { size 72 ext/phar/zip.c php_stream_seek(fp, PHAR_GET_16(h.unix3.size) - sizeof(h.unix3.size), SEEK_CUR); size 170 ext/phar/zip.c long size; size 177 ext/phar/zip.c size = php_stream_tell(fp); size 179 ext/phar/zip.c if (size > sizeof(locator) + 65536) { size 181 ext/phar/zip.c size = sizeof(locator) + 65536; size 182 ext/phar/zip.c if (FAILURE == php_stream_seek(fp, -size, SEEK_END)) { size 193 ext/phar/zip.c if (!php_stream_read(fp, buf, size)) { size 201 ext/phar/zip.c while ((p=(char *) memchr(p + 1, 'P', (size_t) (size - (p + 1 - buf)))) != NULL) { size 202 ext/phar/zip.c if ((p - buf) + sizeof(locator) <= size && !memcmp(p + 1, "K\5\6", 3)) { size 229 ext/phar/zip.c if (PHAR_GET_16(locator.comment_len) != size - (metadata - buf)) { size 802 ext/phar/zip.c PHAR_SET_16(perms.size, sizeof(perms) - 4); size 593 ext/readline/readline_cli.c size_t size = 4096, pos = 0, len; size 594 ext/readline/readline_cli.c char *code = emalloc(size); size 651 ext/readline/readline_cli.c if (pos + len + 2 > size) { size 652 ext/readline/readline_cli.c size = pos + len + 2; size 653 ext/readline/readline_cli.c code = erealloc(code, size); size 1430 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 1946 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 2013 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 2946 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 3055 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 4299 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 4404 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 48 ext/shmop/php_shmop.h int size; size 53 ext/shmop/shmop.c ZEND_ARG_INFO(0, size) size 159 ext/shmop/shmop.c long key, mode, size; size 166 ext/shmop/shmop.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) { size 188 ext/shmop/shmop.c shmop->size = size; size 192 ext/shmop/shmop.c shmop->size = size; size 205 ext/shmop/shmop.c if (shmop->shmflg & IPC_CREAT && shmop->size < 1) { size 210 ext/shmop/shmop.c shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg); size 227 ext/shmop/shmop.c shmop->size = shm.shm_segsz; size 254 ext/shmop/shmop.c if (start < 0 || start > shmop->size) { size 259 ext/shmop/shmop.c if (count < 0 || start > (INT_MAX - count) || start + count > shmop->size) { size 265 ext/shmop/shmop.c bytes = count ? count : shmop->size - start; size 307 ext/shmop/shmop.c RETURN_LONG(shmop->size); size 333 ext/shmop/shmop.c if (offset < 0 || offset > shmop->size) { size 338 ext/shmop/shmop.c writesize = (data_len < shmop->size - offset) ? data_len : shmop->size - offset; size 34 ext/soap/php_xml.h xmlDocPtr soap_xmlParseMemory(const void *buf, size_t size); size 923 ext/soap/soap.c fci.size = sizeof(fci); size 1501 ext/soap/soap.c int num_params = 0, size, i, call_status = 0; size 1934 ext/soap/soap.c xmlDocDumpMemory(doc_return, &buf, &size); size 1936 ext/soap/soap.c if (size == 0) { size 1951 ext/soap/soap.c snprintf(cont_len, sizeof(cont_len), "Content-Length: %d", size); size 1954 ext/soap/soap.c php_write(buf, size TSRMLS_CC); size 2068 ext/soap/soap.c int size; size 2077 ext/soap/soap.c xmlDocDumpMemory(doc_return, &buf, &size); size 2096 ext/soap/soap.c snprintf(cont_len, sizeof(cont_len), "Content-Length: %d", size); size 2105 ext/soap/soap.c php_write(buf, size TSRMLS_CC); size 569 ext/sockets/conversions.c socklen_t size = INET_ADDRSTRLEN; size 572 ext/sockets/conversions.c Z_STRVAL_P(zv) = ecalloc(1, size); size 575 ext/sockets/conversions.c if (inet_ntop(AF_INET, addr, Z_STRVAL_P(zv), size) == NULL) { size 627 ext/sockets/conversions.c socklen_t size = INET6_ADDRSTRLEN; size 630 ext/sockets/conversions.c Z_STRVAL_P(zv) = ecalloc(1, size); size 633 ext/sockets/conversions.c if (inet_ntop(AF_INET6, addr, Z_STRVAL_P(zv), size) == NULL) { size 904 ext/sockets/conversions.c data_len = entry->size; size 989 ext/sockets/conversions.c if (CMSG_LEN(entry->size) > cmsg->cmsg_len) { size 992 ext/sockets/conversions.c (long)CMSG_LEN(entry->size), (long)cmsg->cmsg_len); size 630 ext/sockets/multicast.c ULONG size; size 641 ext/sockets/multicast.c size = 4 * (sizeof *addr_table); size 642 ext/sockets/multicast.c addr_table = emalloc(size); size 644 ext/sockets/multicast.c retval = GetIpAddrTable(addr_table, &size, 0); size 647 ext/sockets/multicast.c addr_table = emalloc(size); size 670 ext/sockets/multicast.c ULONG size; size 681 ext/sockets/multicast.c size = 4 * (sizeof *addr_table); size 682 ext/sockets/multicast.c addr_table = emalloc(size); size 684 ext/sockets/multicast.c retval = GetIpAddrTable(addr_table, &size, 0); size 687 ext/sockets/multicast.c addr_table = emalloc(size); size 756 ext/sockets/multicast.c int size = 0, size 766 ext/sockets/multicast.c size += 5 * sizeof(struct ifreq); size 767 ext/sockets/multicast.c buf = ecalloc(size, 1); size 768 ext/sockets/multicast.c if_conf.ifc_len = size; size 98 ext/sockets/sendrecvmsg.c entry.size = sizev; \ size 302 ext/sockets/sendrecvmsg.c if (entry->var_el_size > 0 && n > (LONG_MAX - (long)entry->size - size 310 ext/sockets/sendrecvmsg.c RETURN_LONG((long)CMSG_SPACE(entry->size + n * entry->var_el_size)); size 369 ext/sockets/sendrecvmsg.c socklen_t size; size 378 ext/sockets/sendrecvmsg.c size = sizeof(struct in6_pktinfo); size 386 ext/sockets/sendrecvmsg.c buffer = ecalloc(1, size); size 387 ext/sockets/sendrecvmsg.c res = getsockopt(php_sock->bsd_socket, level, optname, buffer, &size); size 27 ext/sockets/sendrecvmsg.h socklen_t size; /* size of native structure */ size 2120 ext/spl/spl_directory.c fci.size = sizeof(fci); size 2970 ext/spl/spl_directory.c long size; size 2972 ext/spl/spl_directory.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) { size 2986 ext/spl/spl_directory.c RETURN_BOOL(0 == php_stream_truncate_set_size(intern->u.file.stream, size)); size 3076 ext/spl/spl_directory.c ZEND_ARG_INFO(0, size) size 65 ext/spl/spl_engine.h fci.size = sizeof(zend_fcall_info); size 46 ext/spl/spl_fixedarray.c long size; size 78 ext/spl/spl_fixedarray.c static void spl_fixedarray_init(spl_fixedarray *array, long size TSRMLS_DC) /* {{{ */ size 80 ext/spl/spl_fixedarray.c if (size > 0) { size 81 ext/spl/spl_fixedarray.c array->size = 0; /* reset size in case ecalloc() fails */ size 82 ext/spl/spl_fixedarray.c array->elements = ecalloc(size, sizeof(zval *)); size 83 ext/spl/spl_fixedarray.c array->size = size; size 86 ext/spl/spl_fixedarray.c array->size = 0; size 91 ext/spl/spl_fixedarray.c static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /* {{{ */ size 93 ext/spl/spl_fixedarray.c if (size == array->size) { size 99 ext/spl/spl_fixedarray.c if (array->size == 0) { size 100 ext/spl/spl_fixedarray.c spl_fixedarray_init(array, size TSRMLS_CC); size 105 ext/spl/spl_fixedarray.c if (size == 0) { size 108 ext/spl/spl_fixedarray.c for (i = 0; i < array->size; i++) { size 118 ext/spl/spl_fixedarray.c } else if (size > array->size) { size 119 ext/spl/spl_fixedarray.c array->elements = safe_erealloc(array->elements, size, sizeof(zval *), 0); size 120 ext/spl/spl_fixedarray.c memset(array->elements + array->size, '\0', sizeof(zval *) * (size - array->size)); size 124 ext/spl/spl_fixedarray.c for (i = size; i < array->size; i++) { size 129 ext/spl/spl_fixedarray.c array->elements = erealloc(array->elements, sizeof(zval *) * size); size 132 ext/spl/spl_fixedarray.c array->size = size; size 139 ext/spl/spl_fixedarray.c for (i = 0; i < from->size; i++) { size 157 ext/spl/spl_fixedarray.c *n = intern->array->size; size 176 ext/spl/spl_fixedarray.c for (i = 0; i < intern->array->size; i++) { size 185 ext/spl/spl_fixedarray.c if (j > intern->array->size) { size 186 ext/spl/spl_fixedarray.c for (i = intern->array->size; i < j; ++i) { size 202 ext/spl/spl_fixedarray.c for (i = 0; i < intern->array->size; i++) { size 208 ext/spl/spl_fixedarray.c if (intern->array->size > 0 && intern->array->elements) { size 248 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, other->array->size TSRMLS_CC); size 361 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 421 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 467 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 508 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 569 ext/spl/spl_fixedarray.c *count = intern->array->size; size 584 ext/spl/spl_fixedarray.c long size = 0; size 586 ext/spl/spl_fixedarray.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &size) == FAILURE) { size 590 ext/spl/spl_fixedarray.c if (size < 0) { size 603 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, size TSRMLS_CC); size 622 ext/spl/spl_fixedarray.c int size = zend_hash_num_elements(intern_ht); size 625 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, size TSRMLS_CC); size 652 ext/spl/spl_fixedarray.c RETURN_LONG(intern->array->size); size 673 ext/spl/spl_fixedarray.c for (; i < intern->array->size; i++) { size 786 ext/spl/spl_fixedarray.c RETURN_LONG(intern->array->size); size 798 ext/spl/spl_fixedarray.c long size; size 800 ext/spl/spl_fixedarray.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) { size 804 ext/spl/spl_fixedarray.c if (size < 0) { size 814 ext/spl/spl_fixedarray.c spl_fixedarray_resize(intern->array, size TSRMLS_CC); size 920 ext/spl/spl_fixedarray.c if (iterator->object->current >= 0 && iterator->object->array && iterator->object->current < iterator->object->array->size) { size 1016 ext/spl/spl_fixedarray.c RETURN_BOOL(intern->current >= 0 && intern->array && intern->current < intern->array->size); size 1093 ext/spl/spl_fixedarray.c ZEND_ARG_INFO(0, size) size 943 ext/sqlite3/libsqlite/sqlite3.c int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); size 10732 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); size 16543 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){ size 16544 ext/sqlite3/libsqlite/sqlite3.c return id->pMethods->xTruncate(id, size); size 17077 ext/sqlite3/libsqlite/sqlite3.c (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) size 18006 ext/sqlite3/libsqlite/sqlite3.c u32 size, hash; size 18010 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[i-1].u.hdr.size4x/4; size 18011 ext/sqlite3/libsqlite/sqlite3.c assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); size 18012 ext/sqlite3/libsqlite/sqlite3.c assert( size>=2 ); size 18013 ext/sqlite3/libsqlite/sqlite3.c if( size <= MX_SMALL ){ size 18014 ext/sqlite3/libsqlite/sqlite3.c memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]); size 18016 ext/sqlite3/libsqlite/sqlite3.c hash = size % N_HASH; size 18040 ext/sqlite3/libsqlite/sqlite3.c u32 size, hash; size 18044 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[i-1].u.hdr.size4x/4; size 18045 ext/sqlite3/libsqlite/sqlite3.c assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); size 18046 ext/sqlite3/libsqlite/sqlite3.c assert( size>=2 ); size 18047 ext/sqlite3/libsqlite/sqlite3.c if( size <= MX_SMALL ){ size 18048 ext/sqlite3/libsqlite/sqlite3.c memsys3LinkIntoList(i, &mem3.aiSmall[size-2]); size 18050 ext/sqlite3/libsqlite/sqlite3.c hash = size % N_HASH; size 18154 ext/sqlite3/libsqlite/sqlite3.c u32 iNext, prev, size, i, x; size 18159 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[i-1].u.hdr.size4x; size 18160 ext/sqlite3/libsqlite/sqlite3.c assert( (size&1)==0 ); size 18161 ext/sqlite3/libsqlite/sqlite3.c if( (size&2)==0 ){ size 18169 ext/sqlite3/libsqlite/sqlite3.c size = i + size/4 - prev; size 18171 ext/sqlite3/libsqlite/sqlite3.c mem3.aPool[prev-1].u.hdr.size4x = size*4 | x; size 18172 ext/sqlite3/libsqlite/sqlite3.c mem3.aPool[prev+size-1].u.hdr.prevSize = size; size 18176 ext/sqlite3/libsqlite/sqlite3.c size /= 4; size 18178 ext/sqlite3/libsqlite/sqlite3.c if( size>mem3.szMaster ){ size 18180 ext/sqlite3/libsqlite/sqlite3.c mem3.szMaster = size; size 18277 ext/sqlite3/libsqlite/sqlite3.c u32 size, x; size 18282 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[i-1].u.hdr.size4x/4; size 18283 ext/sqlite3/libsqlite/sqlite3.c assert( i+size<=mem3.nPool+1 ); size 18285 ext/sqlite3/libsqlite/sqlite3.c mem3.aPool[i+size-1].u.hdr.prevSize = size; size 18286 ext/sqlite3/libsqlite/sqlite3.c mem3.aPool[i+size-1].u.hdr.size4x &= ~2; size 18292 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize; size 18293 ext/sqlite3/libsqlite/sqlite3.c mem3.iMaster -= size; size 18294 ext/sqlite3/libsqlite/sqlite3.c mem3.szMaster += size; size 18431 ext/sqlite3/libsqlite/sqlite3.c u32 size; size 18444 ext/sqlite3/libsqlite/sqlite3.c for(i=1; i<=mem3.nPool; i+=size/4){ size 18445 ext/sqlite3/libsqlite/sqlite3.c size = mem3.aPool[i-1].u.hdr.size4x; size 18446 ext/sqlite3/libsqlite/sqlite3.c if( size/4<=1 ){ size 18451 ext/sqlite3/libsqlite/sqlite3.c if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){ size 18456 ext/sqlite3/libsqlite/sqlite3.c if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){ size 18461 ext/sqlite3/libsqlite/sqlite3.c if( size&1 ){ size 18462 ext/sqlite3/libsqlite/sqlite3.c fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8); size 18464 ext/sqlite3/libsqlite/sqlite3.c fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8, size 18819 ext/sqlite3/libsqlite/sqlite3.c u32 size, iLogsize; size 18833 ext/sqlite3/libsqlite/sqlite3.c size = 1<<iLogsize; size 18834 ext/sqlite3/libsqlite/sqlite3.c assert( iBlock+size-1<(u32)mem5.nBlock ); size 18837 ext/sqlite3/libsqlite/sqlite3.c mem5.aCtrl[iBlock+size-1] |= CTRL_FREE; size 18839 ext/sqlite3/libsqlite/sqlite3.c assert( mem5.currentOut>=(size*mem5.szAtom) ); size 18841 ext/sqlite3/libsqlite/sqlite3.c mem5.currentOut -= size*mem5.szAtom; size 18849 ext/sqlite3/libsqlite/sqlite3.c iBuddy = iBlock - size; size 18851 ext/sqlite3/libsqlite/sqlite3.c iBuddy = iBlock + size; size 18866 ext/sqlite3/libsqlite/sqlite3.c size *= 2; size 18872 ext/sqlite3/libsqlite/sqlite3.c memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size); size 54217 ext/sqlite3/libsqlite/sqlite3.c int size; /* Size of a cell */ size 54259 ext/sqlite3/libsqlite/sqlite3.c size = cellSizePtr(pPage, &src[pc]); size 54260 ext/sqlite3/libsqlite/sqlite3.c cbrk -= size; size 54266 ext/sqlite3/libsqlite/sqlite3.c if( cbrk<iCellFirst || pc+size>usableSize ){ size 54270 ext/sqlite3/libsqlite/sqlite3.c assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); size 54271 ext/sqlite3/libsqlite/sqlite3.c testcase( cbrk+size==usableSize ); size 54272 ext/sqlite3/libsqlite/sqlite3.c testcase( pc+size==usableSize ); size 54279 ext/sqlite3/libsqlite/sqlite3.c memcpy(&temp[x], &data[x], (cbrk+size) - x); size 54282 ext/sqlite3/libsqlite/sqlite3.c memcpy(&data[cbrk], &src[pc], size); size 54319 ext/sqlite3/libsqlite/sqlite3.c int size; /* Size of the free slot */ size 54329 ext/sqlite3/libsqlite/sqlite3.c size = get2byte(&aData[pc+2]); size 54330 ext/sqlite3/libsqlite/sqlite3.c if( size>=nByte ){ size 54331 ext/sqlite3/libsqlite/sqlite3.c int x = size - nByte; size 54345 ext/sqlite3/libsqlite/sqlite3.c }else if( size+pc > usableSize ){ size 54698 ext/sqlite3/libsqlite/sqlite3.c u16 next, size; size 54708 ext/sqlite3/libsqlite/sqlite3.c size = get2byte(&data[pc+2]); size 54709 ext/sqlite3/libsqlite/sqlite3.c if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){ size 54714 ext/sqlite3/libsqlite/sqlite3.c nFree = nFree + size; size 61830 ext/sqlite3/libsqlite/sqlite3.c u32 size = 65536; size 61832 ext/sqlite3/libsqlite/sqlite3.c size = cellSizePtr(pPage, &data[pc]); size 61834 ext/sqlite3/libsqlite/sqlite3.c if( (int)(pc+size-1)>=usableSize ){ size 61839 ext/sqlite3/libsqlite/sqlite3.c btreeHeapInsert(heap, (pc<<16)|(pc+size-1)); size 61847 ext/sqlite3/libsqlite/sqlite3.c int size, j; size 61849 ext/sqlite3/libsqlite/sqlite3.c size = get2byte(&data[i+2]); size 61850 ext/sqlite3/libsqlite/sqlite3.c assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */ size 61851 ext/sqlite3/libsqlite/sqlite3.c btreeHeapInsert(heap, (i<<16)|(i+size-1)); size 61859 ext/sqlite3/libsqlite/sqlite3.c assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */ size 80763 ext/sqlite3/libsqlite/sqlite3.c static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ size 80767 ext/sqlite3/libsqlite/sqlite3.c rc = sqlite3OsTruncate(p->pReal, size); size 80768 ext/sqlite3/libsqlite/sqlite3.c }else if( size<p->iSize ){ size 80769 ext/sqlite3/libsqlite/sqlite3.c p->iSize = size; size 81044 ext/sqlite3/libsqlite/sqlite3.c static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ size 81047 ext/sqlite3/libsqlite/sqlite3.c assert(size==0); size 81048 ext/sqlite3/libsqlite/sqlite3.c UNUSED_PARAMETER(size); size 104014 ext/sqlite3/libsqlite/sqlite3.c int size = sqlite3AbsInt32(sqlite3Atoi(zRight)); size 104016 ext/sqlite3/libsqlite/sqlite3.c sqlite3VdbeAddOp2(v, OP_Integer, size, 1); size 104019 ext/sqlite3/libsqlite/sqlite3.c pDb->pSchema->cache_size = size; size 104040 ext/sqlite3/libsqlite/sqlite3.c int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0; size 104041 ext/sqlite3/libsqlite/sqlite3.c returnSingleInt(pParse, "page_size", size); size 104316 ext/sqlite3/libsqlite/sqlite3.c int size = sqlite3Atoi(zRight); size 104317 ext/sqlite3/libsqlite/sqlite3.c pDb->pSchema->cache_size = size; size 105710 ext/sqlite3/libsqlite/sqlite3.c int size; size 105859 ext/sqlite3/libsqlite/sqlite3.c size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); size 105860 ext/sqlite3/libsqlite/sqlite3.c if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } size 105861 ext/sqlite3/libsqlite/sqlite3.c pDb->pSchema->cache_size = size; size 736 ext/sqlite3/libsqlite/sqlite3.h int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); size 715 ext/sqlite3/sqlite3.c fc->fci.size = sizeof(fc->fci); size 888 ext/sqlite3/sqlite3.c collation->fci.fci.size = (sizeof(collation->fci.fci)); size 1098 ext/sqlite3/sqlite3.c size_t size; size 1112 ext/sqlite3/sqlite3.c if (sqlite3_stream->position + count >= sqlite3_stream->size) { size 1113 ext/sqlite3/sqlite3.c count = sqlite3_stream->size - sqlite3_stream->position; size 1163 ext/sqlite3/sqlite3.c if (sqlite3_stream->position + (size_t)(offset) > sqlite3_stream->size) { size 1164 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1175 ext/sqlite3/sqlite3.c if (sqlite3_stream->size < (size_t)(offset)) { size 1176 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1187 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1190 ext/sqlite3/sqlite3.c } else if (sqlite3_stream->size < (size_t)(-offset)) { size 1195 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size + offset; size 1216 ext/sqlite3/sqlite3.c ssb->sb.st_size = sqlite3_stream->size; size 1260 ext/sqlite3/sqlite3.c sqlite3_stream->size = sqlite3_blob_bytes(blob); size 4336 ext/standard/array.c long size, current = 0; size 4346 ext/standard/array.c if (zend_parse_parameters(argc TSRMLS_CC, "al|b", &input, &size, &preserve_keys) == FAILURE) { size 4350 ext/standard/array.c if (size < 1) { size 4357 ext/standard/array.c if (size > num_in) { size 4358 ext/standard/array.c size = num_in > 0 ? num_in : 1; size 4361 ext/standard/array.c array_init_size(return_value, ((num_in - 1) / size) + 1); size 4368 ext/standard/array.c array_init_size(chunk, size); size 4390 ext/standard/array.c if (!(++current % size)) { size 595 ext/standard/basic_functions.c ZEND_ARG_INFO(0, size) size 1185 ext/standard/basic_functions.c ZEND_ARG_INFO(0, size) size 4008 ext/standard/basic_functions.c int size; size 4014 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, &dummybuf, 0); size 4020 ext/standard/basic_functions.c if (size == 0) { size 4025 ext/standard/basic_functions.c ptr = emalloc(size); size 4026 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, ptr, size); size 4027 ext/standard/basic_functions.c if (size == 0) { size 387 ext/standard/crypt_blowfish.c static int BF_decode(BF_word *dst, const char *src, int size) size 390 ext/standard/crypt_blowfish.c unsigned char *end = dptr + size; size 414 ext/standard/crypt_blowfish.c static void BF_encode(char *dst, const BF_word *src, int size) size 417 ext/standard/crypt_blowfish.c const unsigned char *end = sptr + size; size 655 ext/standard/crypt_blowfish.c char *output, int size, size 675 ext/standard/crypt_blowfish.c if (size < 7 + 22 + 31 + 1) { size 786 ext/standard/crypt_blowfish.c static int _crypt_output_magic(const char *setting, char *output, int size) size 788 ext/standard/crypt_blowfish.c if (size < 3) size 822 ext/standard/crypt_blowfish.c char *output, int size) size 839 ext/standard/crypt_blowfish.c _crypt_output_magic(setting, output, size); size 840 ext/standard/crypt_blowfish.c retval = BF_crypt(key, setting, output, size, 16); size 881 ext/standard/crypt_blowfish.c _crypt_output_magic(setting, output, size); size 888 ext/standard/crypt_blowfish.c const char *input, int size, char *output, int output_size) size 890 ext/standard/crypt_blowfish.c if (size < 16 || output_size < 7 + 22 + 1 || size 22 ext/standard/crypt_blowfish.h extern int _crypt_output_magic(const char *setting, char *output, int size); size 25 ext/standard/crypt_blowfish.h char *output, int size); size 29 ext/standard/crypt_blowfish.h const char *input, int size, char *output, int output_size); size 20 ext/standard/crypt_sha256.c # define ALIGNED(size) __attribute__ ((__aligned__ (size))) size 22 ext/standard/crypt_sha256.c # define ALIGNED(size) size 19 ext/standard/crypt_sha512.c # define ALIGNED(size) __attribute__ ((__aligned__ (size))) size 21 ext/standard/crypt_sha512.c # define ALIGNED(size) size 1366 ext/standard/file.c int size = 0; size 1380 ext/standard/file.c size = php_stream_passthru(stream); size 1382 ext/standard/file.c RETURN_LONG(size); size 1421 ext/standard/file.c int size; size 1430 ext/standard/file.c size = php_stream_passthru(stream); size 1431 ext/standard/file.c RETURN_LONG(size); size 1508 ext/standard/file.c long size; size 1511 ext/standard/file.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &fp, &size) == FAILURE) { size 1522 ext/standard/file.c RETURN_BOOL(0 == php_stream_truncate_set_size(stream, size)); size 60 ext/standard/formatted_print.c php_sprintf_appendchar(char **buffer, int *pos, int *size, char add TSRMLS_DC) size 62 ext/standard/formatted_print.c if ((*pos + 1) >= *size) { size 63 ext/standard/formatted_print.c *size <<= 1; size 64 ext/standard/formatted_print.c PRINTF_DEBUG(("%s(): ereallocing buffer to %d bytes\n", get_active_function_name(TSRMLS_C), *size)); size 65 ext/standard/formatted_print.c *buffer = erealloc(*buffer, *size); size 74 ext/standard/formatted_print.c php_sprintf_appendstring(char **buffer, int *pos, int *size, char *add, size 91 ext/standard/formatted_print.c *buffer, *pos, *size, add, min_width, padding, alignment)); size 100 ext/standard/formatted_print.c if (req_size > *size) { size 101 ext/standard/formatted_print.c while (req_size > *size) { size 102 ext/standard/formatted_print.c if(*size > INT_MAX/2) { size 105 ext/standard/formatted_print.c *size <<= 1; size 107 ext/standard/formatted_print.c PRINTF_DEBUG(("sprintf ereallocing buffer to %d bytes\n", *size)); size 108 ext/standard/formatted_print.c *buffer = erealloc(*buffer, *size); size 134 ext/standard/formatted_print.c php_sprintf_appendint(char **buffer, int *pos, int *size, long number, size 143 ext/standard/formatted_print.c *buffer, pos, size, number, width, padding, alignment)); size 170 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0, size 178 ext/standard/formatted_print.c php_sprintf_appenduint(char **buffer, int *pos, int *size, size 187 ext/standard/formatted_print.c *buffer, pos, size, number, width, padding, alignment)); size 203 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0, size 211 ext/standard/formatted_print.c int *size, double number, size 230 ext/standard/formatted_print.c *buffer, pos, size, number, width, padding, alignment, fmt)); size 240 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, "NaN", 3, 0, padding, size 247 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, "INF", 3, 0, padding, size 306 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, s, width, 0, padding, size 313 ext/standard/formatted_print.c php_sprintf_append2n(char **buffer, int *pos, int *size, long number, size 323 ext/standard/formatted_print.c *buffer, pos, size, number, width, padding, alignment, n, size 336 ext/standard/formatted_print.c php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0, size 392 ext/standard/formatted_print.c int argc, size = 240, inpos = 0, outpos = 0, temppos; size 436 ext/standard/formatted_print.c result = emalloc(size); size 447 ext/standard/formatted_print.c php_sprintf_appendchar(&result, &outpos, &size, format[inpos++] TSRMLS_CC); size 449 ext/standard/formatted_print.c php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC); size 580 ext/standard/formatted_print.c php_sprintf_appendstring(&result, &outpos, &size, size 594 ext/standard/formatted_print.c php_sprintf_appendint(&result, &outpos, &size, size 602 ext/standard/formatted_print.c php_sprintf_appenduint(&result, &outpos, &size, size 614 ext/standard/formatted_print.c php_sprintf_appenddouble(&result, &outpos, &size, size 624 ext/standard/formatted_print.c php_sprintf_appendchar(&result, &outpos, &size, size 630 ext/standard/formatted_print.c php_sprintf_append2n(&result, &outpos, &size, size 638 ext/standard/formatted_print.c php_sprintf_append2n(&result, &outpos, &size, size 646 ext/standard/formatted_print.c php_sprintf_append2n(&result, &outpos, &size, size 654 ext/standard/formatted_print.c php_sprintf_append2n(&result, &outpos, &size, size 661 ext/standard/formatted_print.c php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC); size 1186 ext/standard/html.c e = s - 1 + c->data.multicodepoint_table[0].leading_entry.size; size 1584 ext/standard/html.c num_entries = mcpr[0].leading_entry.size; size 1102 ext/standard/html_tables.h unsigned size; /* number of remaining entries in the table */ size 151 ext/standard/image.c int size; size 159 ext/standard/image.c size = (((unsigned int)dim[ 3]) << 24) + (((unsigned int)dim[ 2]) << 16) + (((unsigned int)dim[ 1]) << 8) + ((unsigned int) dim[ 0]); size 160 ext/standard/image.c if (size == 12) { size 165 ext/standard/image.c } else if (size > 12 && (size <= 64 || size == 108 || size == 124)) { size 888 ext/standard/image.c int size; size 904 ext/standard/image.c size = php_ifd_get32s(a+4, 1); size 905 ext/standard/image.c if (size < 0) { size 908 ext/standard/image.c if ((size & 1) == 1) { size 909 ext/standard/image.c size++; size 912 ext/standard/image.c if (size < 9 || php_stream_read(stream, a, 9) != 9) { size 927 ext/standard/image.c if (php_stream_seek(stream, size, SEEK_CUR)) { size 187 ext/standard/md5.c static const void *body(PHP_MD5_CTX *ctx, const void *data, size_t size) size 284 ext/standard/md5.c } while (size -= 64); size 305 ext/standard/md5.c PHPAPI void PHP_MD5Update(PHP_MD5_CTX *ctx, const void *data, size_t size) size 311 ext/standard/md5.c if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) { size 314 ext/standard/md5.c ctx->hi += size >> 29; size 321 ext/standard/md5.c if (size < free) { size 322 ext/standard/md5.c memcpy(&ctx->buffer[used], data, size); size 328 ext/standard/md5.c size -= free; size 332 ext/standard/md5.c if (size >= 64) { size 333 ext/standard/md5.c data = body(ctx, data, size & ~(size_t)0x3f); size 334 ext/standard/md5.c size &= 0x3f; size 337 ext/standard/md5.c memcpy(ctx->buffer, data, size); size 52 ext/standard/md5.h PHPAPI void PHP_MD5Update(PHP_MD5_CTX *ctx, const void *data, size_t size); size 94 ext/standard/pack.c static void php_pack(zval **val, int size, int *map, char *output) size 102 ext/standard/pack.c for (i = 0; i < size; i++) { size 547 ext/standard/pack.c static long php_unpack(char *data, int size, int issigned, int *map) size 555 ext/standard/pack.c for (i = 0; i < size; i++) { size 602 ext/standard/pack.c int size=0; size 639 ext/standard/pack.c size = -1; size 643 ext/standard/pack.c size = 0; size 649 ext/standard/pack.c size = arg; size 655 ext/standard/pack.c size = (arg > 0) ? (arg + (arg % 2)) / 2 : arg; size 663 ext/standard/pack.c size = 1; size 671 ext/standard/pack.c size = 2; size 677 ext/standard/pack.c size = sizeof(int); size 685 ext/standard/pack.c size = 4; size 694 ext/standard/pack.c size = 8; size 704 ext/standard/pack.c size = sizeof(float); size 709 ext/standard/pack.c size = sizeof(double); size 719 ext/standard/pack.c if (size != 0 && size != -1 && size < 0) { size 738 ext/standard/pack.c if (size != 0 && size != -1 && INT_MAX - size + 1 < inputpos) { size 744 ext/standard/pack.c if ((inputpos + size) <= inputlen) { size 751 ext/standard/pack.c if ((size >= 0) && (len > size)) { size 752 ext/standard/pack.c len = size; size 755 ext/standard/pack.c size = len; size 766 ext/standard/pack.c if ((size >= 0) && (len > size)) { size 767 ext/standard/pack.c len = size; size 770 ext/standard/pack.c size = len; size 794 ext/standard/pack.c if ((size >= 0) && (len > size)) { size 795 ext/standard/pack.c len = size; size 798 ext/standard/pack.c size = len; size 821 ext/standard/pack.c if (size >= 0 && len > (size * 2)) { size 822 ext/standard/pack.c len = size * 2; size 985 ext/standard/pack.c if (inputpos < size) { size 986 ext/standard/pack.c inputpos = -size; size 1006 ext/standard/pack.c inputpos += size; size 1008 ext/standard/pack.c if (size != -1) { /* only print warning if not working with * */ size 1017 ext/standard/pack.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough input, need %d, have %d", type, size, inputlen - inputpos); size 1095 ext/standard/pack.c int size = sizeof(Z_LVAL(val)); size 1099 ext/standard/pack.c byte_map[0] = size - 1; size 1102 ext/standard/pack.c int_map[i] = size - (sizeof(int) - i); size 1105 ext/standard/pack.c machine_endian_short_map[0] = size - 2; size 1106 ext/standard/pack.c machine_endian_short_map[1] = size - 1; size 1107 ext/standard/pack.c big_endian_short_map[0] = size - 2; size 1108 ext/standard/pack.c big_endian_short_map[1] = size - 1; size 1109 ext/standard/pack.c little_endian_short_map[0] = size - 1; size 1110 ext/standard/pack.c little_endian_short_map[1] = size - 2; size 1112 ext/standard/pack.c machine_endian_long_map[0] = size - 4; size 1113 ext/standard/pack.c machine_endian_long_map[1] = size - 3; size 1114 ext/standard/pack.c machine_endian_long_map[2] = size - 2; size 1115 ext/standard/pack.c machine_endian_long_map[3] = size - 1; size 1116 ext/standard/pack.c big_endian_long_map[0] = size - 4; size 1117 ext/standard/pack.c big_endian_long_map[1] = size - 3; size 1118 ext/standard/pack.c big_endian_long_map[2] = size - 2; size 1119 ext/standard/pack.c big_endian_long_map[3] = size - 1; size 1120 ext/standard/pack.c little_endian_long_map[0] = size - 1; size 1121 ext/standard/pack.c little_endian_long_map[1] = size - 2; size 1122 ext/standard/pack.c little_endian_long_map[2] = size - 3; size 1123 ext/standard/pack.c little_endian_long_map[3] = size - 4; size 1126 ext/standard/pack.c machine_endian_longlong_map[0] = size - 8; size 1127 ext/standard/pack.c machine_endian_longlong_map[1] = size - 7; size 1128 ext/standard/pack.c machine_endian_longlong_map[2] = size - 6; size 1129 ext/standard/pack.c machine_endian_longlong_map[3] = size - 5; size 1130 ext/standard/pack.c machine_endian_longlong_map[4] = size - 4; size 1131 ext/standard/pack.c machine_endian_longlong_map[5] = size - 3; size 1132 ext/standard/pack.c machine_endian_longlong_map[6] = size - 2; size 1133 ext/standard/pack.c machine_endian_longlong_map[7] = size - 1; size 1134 ext/standard/pack.c big_endian_longlong_map[0] = size - 8; size 1135 ext/standard/pack.c big_endian_longlong_map[1] = size - 7; size 1136 ext/standard/pack.c big_endian_longlong_map[2] = size - 6; size 1137 ext/standard/pack.c big_endian_longlong_map[3] = size - 5; size 1138 ext/standard/pack.c big_endian_longlong_map[4] = size - 4; size 1139 ext/standard/pack.c big_endian_longlong_map[5] = size - 3; size 1140 ext/standard/pack.c big_endian_longlong_map[6] = size - 2; size 1141 ext/standard/pack.c big_endian_longlong_map[7] = size - 1; size 1142 ext/standard/pack.c little_endian_longlong_map[0] = size - 1; size 1143 ext/standard/pack.c little_endian_longlong_map[1] = size - 2; size 1144 ext/standard/pack.c little_endian_longlong_map[2] = size - 3; size 1145 ext/standard/pack.c little_endian_longlong_map[3] = size - 4; size 1146 ext/standard/pack.c little_endian_longlong_map[4] = size - 5; size 1147 ext/standard/pack.c little_endian_longlong_map[5] = size - 6; size 1148 ext/standard/pack.c little_endian_longlong_map[6] = size - 7; size 1149 ext/standard/pack.c little_endian_longlong_map[7] = size - 8; size 45 ext/tidy/tidy.c #define FIX_BUFFER(bptr) do { if ((bptr)->size) { (bptr)->bp[(bptr)->size-1] = '\0'; } } while(0) size 620 ext/tidy/tidy.c RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0, 1); size 767 ext/tidy/tidy.c ZVAL_STRINGL(out, (char *) output.bp, output.size ? output.size-1 : 0, 1); size 801 ext/tidy/tidy.c ZVAL_STRINGL(out, (char *) buf.bp, buf.size-1, 1); size 824 ext/tidy/tidy.c if (output.size) { size 829 ext/tidy/tidy.c ZVAL_STRINGL(temp, (char*)output.bp, output.size-1, TRUE); size 835 ext/tidy/tidy.c if (obj->ptdoc->errbuf->size) { size 840 ext/tidy/tidy.c ZVAL_STRINGL(temp, (char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1, TRUE); size 862 ext/tidy/tidy.c ADD_PROPERTY_STRINGL(obj->std.properties, value, buf.bp, buf.size ? buf.size-1 : 0); size 1201 ext/tidy/tidy.c output_context->out.used = outbuf.size ? outbuf.size-1 : 0; size 1247 ext/tidy/tidy.c RETURN_STRINGL((char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1, 1); size 1264 ext/tidy/tidy.c RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0, 1); size 187 ext/wddx/wddx.c static int wddx_stack_push(wddx_stack *stack, void *element, int size) size 193 ext/wddx/wddx.c stack->elements[stack->top] = (void *) emalloc(size); size 194 ext/wddx/wddx.c memcpy(stack->elements[stack->top], element, size); size 59 ext/xml/expat_compat.h void *(*malloc_fcn)(size_t size); size 60 ext/xml/expat_compat.h void *(*realloc_fcn)(void *ptr, size_t size); size 520 ext/xml/xml.c fci.size = sizeof(fci); size 136 ext/xmlrpc/libxmlrpc/queue.c q->size = 0; size 199 ext/xmlrpc/libxmlrpc/queue.c return(!q || q->size == 0); size 218 ext/xmlrpc/libxmlrpc/queue.c return q ? q->size : 0; size 301 ext/xmlrpc/libxmlrpc/queue.c if(q->size == 0) { size 311 ext/xmlrpc/libxmlrpc/queue.c q->size++; size 351 ext/xmlrpc/libxmlrpc/queue.c if(q->size == 0) { size 364 ext/xmlrpc/libxmlrpc/queue.c q->size++; size 402 ext/xmlrpc/libxmlrpc/queue.c q->size--; size 404 ext/xmlrpc/libxmlrpc/queue.c if(q->size == 0) size 444 ext/xmlrpc/libxmlrpc/queue.c q->size--; size 446 ext/xmlrpc/libxmlrpc/queue.c if(q->size == 0) size 560 ext/xmlrpc/libxmlrpc/queue.c q->size--; size 793 ext/xmlrpc/libxmlrpc/queue.c index = malloc(q->size * sizeof(q->cursor->data)); size 797 ext/xmlrpc/libxmlrpc/queue.c posn_index = malloc(q->size * sizeof(q->cursor)); size 806 ext/xmlrpc/libxmlrpc/queue.c for(i=0; i < q->size; i++) { size 814 ext/xmlrpc/libxmlrpc/queue.c QuickSort(index, 0, q->size - 1, Comp); size 859 ext/xmlrpc/libxmlrpc/queue.c hi = q->size - 1; size 39 ext/xmlrpc/libxmlrpc/queue.h int size, sorted, item_deleted; size 118 ext/xmlrpc/libxmlrpc/simplestring.c string->size = SIMPLESTRING_INCR; size 121 ext/xmlrpc/libxmlrpc/simplestring.c string->size = 0; size 198 ext/xmlrpc/libxmlrpc/simplestring.c if(target->len + add_len + 1 > target->size) { size 201 ext/xmlrpc/libxmlrpc/simplestring.c int incr = target->size * 2; size 207 ext/xmlrpc/libxmlrpc/simplestring.c target->size = target->str ? newsize : 0; size 54 ext/xmlrpc/libxmlrpc/simplestring.h int size; /* size of allocated buffer */ size 279 ext/xmlrpc/libxmlrpc/xml_element.c static int xml_elem_writefunc(int (*fptr)(void *data, const char *text, int size), const char *text, void *data, int len) size 376 ext/xmlrpc/libxmlrpc/xml_element.c static void xml_element_serialize(xml_element *el, int (*fptr)(void *data, const char *text, int size), void *data, XML_ELEM_OUTPUT_OPTIONS options, int depth) size 502 ext/xmlrpc/libxmlrpc/xml_element.c static int file_out_fptr(void *f, const char *text, int size) size 509 ext/xmlrpc/libxmlrpc/xml_element.c static int simplestring_out_fptr(void *f, const char *text, int size) size 513 ext/xmlrpc/libxmlrpc/xml_element.c simplestring_addn(buf, text, size); size 79 ext/xmlrpc/libxmlrpc/xml_to_soap.c unsigned long size; size 2138 ext/xmlrpc/libxmlrpc/xmlrpc.c int size = 0; size 2140 ext/xmlrpc/libxmlrpc/xmlrpc.c size = Q_Size(value->v->q); size 2142 ext/xmlrpc/libxmlrpc/xmlrpc.c return size; size 307 ext/xsl/xsltprocessor.c fci.size = sizeof(fci); size 236 ext/zip/lib/zip.h zip_uint64_t size; /* size of file (uncompressed) */ size 314 ext/zip/lib/zip_close.c st.comp_size = st.size; size 327 ext/zip/lib/zip_close.c de->uncomp_size = st.size; size 330 ext/zip/lib/zip_close.c if (( ((de->comp_method == ZIP_CM_DEFLATE || ZIP_CM_IS_DEFAULT(de->comp_method)) && st.size > MAX_DEFLATE_SIZE_32) size 371 ext/zip/lib/zip_close.c if (de->comp_method != ZIP_CM_STORE && ((st.valid & ZIP_STAT_SIZE) == 0 || st.size != 0)) { size 428 ext/zip/lib/zip_close.c de->uncomp_size = st.size; size 527 ext/zip/lib/zip_close.c zip_int64_t size; size 533 ext/zip/lib/zip_close.c if ((size=_zip_cdir_write(za, filelist, survivors, out)) < 0) size 544 ext/zip/lib/zip_close.c if (_zip_filerange_crc(out, cd_start, size, &crc, &za->error) < 0) size 123 ext/zip/lib/zip_dirent.c cd->size = cd->offset = 0; size 135 ext/zip/lib/zip_dirent.c zip_uint64_t offset, size; size 162 ext/zip/lib/zip_dirent.c size = (zip_uint64_t)off - offset; size 176 ext/zip/lib/zip_dirent.c _zip_write8(size, fp); size 181 ext/zip/lib/zip_dirent.c _zip_write8(offset+size, fp); size 191 ext/zip/lib/zip_dirent.c _zip_write4(size >= ZIP_UINT32_MAX ? ZIP_UINT32_MAX : (zip_uint32_t)size, fp); size 205 ext/zip/lib/zip_dirent.c return (zip_int64_t)size; size 334 ext/zip/lib/zip_dirent.c zip_uint32_t size; size 338 ext/zip/lib/zip_dirent.c size = LENTRYSIZE; size 340 ext/zip/lib/zip_dirent.c size = CDENTRYSIZE; size 342 ext/zip/lib/zip_dirent.c if (leftp && (*leftp < size)) { size 353 ext/zip/lib/zip_dirent.c if ((fread(buf, 1, size, fp)<size)) { size 408 ext/zip/lib/zip_dirent.c size += filename_len+ef_len+comment_len; size 410 ext/zip/lib/zip_dirent.c if (leftp && (*leftp < size)) { size 505 ext/zip/lib/zip_dirent.c *leftp -= size; size 543 ext/zip/lib/zip_dirent.c zip_int32_t size; size 549 ext/zip/lib/zip_dirent.c size = local ? LENTRYSIZE : CDENTRYSIZE; size 563 ext/zip/lib/zip_dirent.c size += _zip_read2(&p); size 566 ext/zip/lib/zip_dirent.c return size; size 52 ext/zip/lib/zip_extra_field.c if ((def=_zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) { size 141 ext/zip/lib/zip_extra_field.c *lenp = ef->size; size 142 ext/zip/lib/zip_extra_field.c if (ef->size > 0) size 172 ext/zip/lib/zip_extra_field.c if (tt->id == from->id && tt->size == from->size && memcmp(tt->data, from->data, tt->size) == 0) { size 192 ext/zip/lib/zip_extra_field.c _zip_ef_new(zip_uint16_t id, zip_uint16_t size, const zip_uint8_t *data, zip_flags_t flags) size 202 ext/zip/lib/zip_extra_field.c ef->size = size; size 203 ext/zip/lib/zip_extra_field.c if (size > 0) { size 204 ext/zip/lib/zip_extra_field.c if ((ef->data=(zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) { size 293 ext/zip/lib/zip_extra_field.c zip_uint16_t size; size 295 ext/zip/lib/zip_extra_field.c size = 0; size 298 ext/zip/lib/zip_extra_field.c size += 4+ef->size; size 301 ext/zip/lib/zip_extra_field.c return size; size 312 ext/zip/lib/zip_extra_field.c _zip_write2(ef->size, f); size 313 ext/zip/lib/zip_extra_field.c if (ef->size > 0) size 314 ext/zip/lib/zip_extra_field.c fwrite(ef->data, ef->size, 1, f); size 140 ext/zip/lib/zip_extra_field_api.c *lenp = ef->size; size 141 ext/zip/lib/zip_extra_field_api.c if (ef->size > 0) size 298 ext/zip/lib/zip_extra_field_api.c new_len -= ef->size + 4; size 57 ext/zip/lib/zip_file_get_offset.c zip_int32_t size; size 67 ext/zip/lib/zip_file_get_offset.c if ((size=_zip_dirent_size(za->zp, ZIP_EF_LOCAL, error)) < 0) size 70 ext/zip/lib/zip_file_get_offset.c if (offset+(zip_uint32_t)size > ZIP_OFF_MAX) { size 75 ext/zip/lib/zip_file_get_offset.c return offset + (zip_uint32_t)size; size 239 ext/zip/lib/zip_open.c if ((zip_uint64_t)cd->offset+(zip_uint64_t)cd->size > (zip_uint64_t)buf_offset + (zip_uint64_t)(eocd-buf)) { size 282 ext/zip/lib/zip_open.c left = (zip_uint64_t)cd->size; size 390 ext/zip/lib/zip_open.c if (_zip_filerange_crc(za->zp, cdir->offset, cdir->size, &crc_got, NULL) < 0) size 603 ext/zip/lib/zip_open.c zip_uint64_t i, nentry, size, offset; size 622 ext/zip/lib/zip_open.c size = _zip_read4(&cdp); size 625 ext/zip/lib/zip_open.c if (size > ZIP_OFF_MAX || offset > ZIP_OFF_MAX || offset+size > ZIP_OFF_MAX) { size 630 ext/zip/lib/zip_open.c if (offset+size > (zip_uint64_t)(buf_offset + (eocd-buf))) { size 636 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && offset+size != (zip_uint64_t)(buf_offset + (eocd-buf))) { size 644 ext/zip/lib/zip_open.c cd->size = (off_t)size; size 661 ext/zip/lib/zip_open.c zip_uint64_t size, nentry, i; size 704 ext/zip/lib/zip_open.c size = _zip_read8(&cdp); size 706 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && size+eocd_offset+12 != (zip_uint64_t)(buf_offset+(eocd64loc-buf))) { size 722 ext/zip/lib/zip_open.c size = _zip_read8(&cdp); size 725 ext/zip/lib/zip_open.c if (size > ZIP_OFF_MAX || offset > ZIP_OFF_MAX || offset+size > ZIP_OFF_MAX) { size 729 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && offset+size != eocd_offset) { size 738 ext/zip/lib/zip_open.c cd->size = (off_t)size; size 126 ext/zip/lib/zip_source_buffer.c st->size = (zip_uint64_t)(z->end - z->data); size 127 ext/zip/lib/zip_source_buffer.c st->comp_size = st->size; size 45 ext/zip/lib/zip_source_crc.c zip_uint64_t size; size 72 ext/zip/lib/zip_source_crc.c ctx->size = 0; size 93 ext/zip/lib/zip_source_crc.c ctx->size = 0; size 118 ext/zip/lib/zip_source_crc.c if ((st.valid & ZIP_STAT_SIZE) && st.size != ctx->size) { size 127 ext/zip/lib/zip_source_crc.c ctx->size += (zip_uint64_t)n; size 144 ext/zip/lib/zip_source_crc.c st->size = ctx->size; size 146 ext/zip/lib/zip_source_crc.c st->comp_size = ctx->size; size 46 ext/zip/lib/zip_source_deflate.c zip_uint64_t size; size 146 ext/zip/lib/zip_source_deflate.c ctx->size = ctx->zstr.total_in; size 291 ext/zip/lib/zip_source_deflate.c st->comp_size = ctx->size; size 360 ext/zip/lib/zip_source_deflate.c if (st->comp_size > 0 && st->size > 0) size 361 ext/zip/lib/zip_source_deflate.c st->comp_size = st->size; size 221 ext/zip/lib/zip_source_filep.c st->size = (zip_uint64_t)z->len; size 225 ext/zip/lib/zip_source_filep.c st->size = (zip_uint64_t)fst.st_size; size 132 ext/zip/lib/zip_source_window.c st->size = ctx->len; size 80 ext/zip/lib/zip_source_zip_new.c if ((start > 0 || len > 0) && (start+len < start || start+len > st.size)) { size 118 ext/zip/lib/zip_source_zip_new.c st2.size = len ? len : st.size-start; size 119 ext/zip/lib/zip_source_zip_new.c st2.comp_size = st2.size; size 125 ext/zip/lib/zip_source_zip_new.c if ((src=_zip_source_file_or_p(za, NULL, srcza->zp, offset+start, (zip_int64_t)st2.size, 0, &st2)) == NULL) size 162 ext/zip/lib/zip_source_zip_new.c if ((s2=zip_source_window(za, src, start, len ? len : st.size-start)) == NULL) { size 65 ext/zip/lib/zip_stat_index.c st->size = de->uncomp_size; size 48 ext/zip/lib/zip_stat_init.c st->size = 0; size 344 ext/zip/lib/zipint.h off_t size; /* size of central directory */ size 353 ext/zip/lib/zipint.h zip_uint16_t size; /* data size */ size 443 ext/zip/php_zip.c add_ascii_assoc_long(return_value, "size", (long) (sb)->size); \ size 1443 ext/zip/php_zip.c RETURN_LONG((long) (zr_rsrc->sb.size)); size 2759 ext/zip/php_zip.c if (sb.size < 1) { size 2764 ext/zip/php_zip.c len = sb.size; size 169 ext/zip/zip_stream.c ssb->sb.st_size = sb.size; size 42 ext/zlib/php_zlib.h size_t size; size 53 ext/zlib/zlib.c static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size) size 55 ext/zlib/zlib.c return (voidpf)safe_emalloc(items, size, 0); size 141 ext/zlib/zlib.c output_context->out.size = PHP_ZLIB_BUFFER_SIZE_GUESS(output_context->in.used); size 142 ext/zlib/zlib.c output_context->out.data = emalloc(output_context->out.size); size 148 ext/zlib/zlib.c ctx->Z.avail_out = output_context->out.size; size 169 ext/zlib/zlib.c output_context->out.used = output_context->out.size - ctx->Z.avail_out; size 365 ext/zlib/zlib.c buffer.size = (max && (max < Z->avail_in)) ? max : Z->avail_in; size 368 ext/zlib/zlib.c if ((max && (max <= buffer.used)) || !(buffer.aptr = erealloc_recoverable(buffer.data, buffer.size))) { size 372 ext/zlib/zlib.c Z->avail_out = buffer.free = buffer.size - buffer.used; size 375 ext/zlib/zlib.c fprintf(stderr, "\n%3d: %3d PRIOR: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out); size 382 ext/zlib/zlib.c fprintf(stderr, "%3d: %3d AFTER: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out); size 384 ext/zlib/zlib.c buffer.size += (buffer.size >> 3) + 1; size 621 ext/zlib/zlib.c int size; size 637 ext/zlib/zlib.c size = php_stream_passthru(stream); size 639 ext/zlib/zlib.c RETURN_LONG(size); size 41 ext/zlib/zlib_filter.c static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size) size 43 ext/zlib/zlib_filter.c return (voidpf)safe_pemalloc(items, size, 0, ((php_zlib_filter_data*)opaque)->persistent); size 158 main/alloca.c alloca (size) size 159 main/alloca.c size_t size; size 199 main/alloca.c if (size == 0) size 205 main/alloca.c register pointer new = malloc (sizeof (header) + size); size 347 main/alloca.c long *block, size; size 374 main/alloca.c size = trailer->this_size; size 375 main/alloca.c if (block == 0 || size == 0) size 378 main/alloca.c if ((block <= address) && (address < (block + size))) size 421 main/alloca.c long size, pseg, this_segment, stack; size 444 main/alloca.c size = ssptr->sssize; size 446 main/alloca.c this_segment = stkl - size; size 461 main/alloca.c size = ssptr->sssize; size 463 main/alloca.c this_segment = stkl - size; size 476 main/alloca.c fprintf (stderr, "%011o %011o\n", pseg, size); size 480 main/alloca.c size = ssptr->sssize; size 482 main/alloca.c result += size; size 739 main/main.c PHPAPI int php_write(void *buf, uint size TSRMLS_DC) size 741 main/main.c return PHPWRITE(buf, size); size 752 main/main.c int size; size 756 main/main.c size = vspprintf(&buffer, 0, format, args); size 757 main/main.c ret = PHPWRITE(buffer, size); size 1021 main/main.c PHPAPI void php_html_puts(const char *str, uint size TSRMLS_DC) size 1023 main/main.c zend_html_puts(str, size TSRMLS_CC); size 1500 main/main.c snprintf(memory_leak_buf, 512, "%s(%d) : Freeing 0x%.8lX (%zu bytes), script=%s\n", t->filename, t->lineno, (zend_uintptr_t)t->addr, t->size, SAFE_FILENAME(SG(request_info).path_translated)); size 69 main/mergesort.c static void setup(u_char *list1, u_char *list2, size_t n, size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC); size 70 main/mergesort.c static void insertionsort(u_char *a, size_t n, size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC); size 105 main/mergesort.c PHPAPI int php_mergesort(void *base, size_t nmemb, size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC) size 113 main/mergesort.c if (size < PSIZE / 2) { /* Pointers must fit into 2 * size. */ size 126 main/mergesort.c if (!(size % ISIZE) && !(((char *)base - (char *)0) % ISIZE)) size 129 main/mergesort.c if ((list2 = malloc(nmemb * size + PSIZE)) == NULL) size 133 main/mergesort.c setup(list1, list2, nmemb, size, cmp TSRMLS_CC); size 134 main/mergesort.c last = list2 + nmemb * size; size 157 main/mergesort.c while ((b += size) < t && cmp(q, b TSRMLS_CC) >sense) size 163 main/mergesort.c EXPONENTIAL: for (i = size; ; i <<= 1) size 165 main/mergesort.c if ((p = t - size) > b && size 173 main/mergesort.c if (i == size) size 178 main/mergesort.c while (t > b+size) { size 179 main/mergesort.c i = (((t - b) / size) >> 1) * size; size 186 main/mergesort.c FASTCASE: while (i > size) size 194 main/mergesort.c i = size; size 229 main/mergesort.c last = list2 + nmemb*size; size 232 main/mergesort.c memmove(list2, list1, nmemb*size); size 242 main/mergesort.c i = size; \ size 246 main/mergesort.c a -= size; \ size 251 main/mergesort.c i = size; \ size 265 main/mergesort.c static void setup(u_char *list1, u_char *list2, size_t n, size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC) size 270 main/mergesort.c size2 = size*2; size 272 main/mergesort.c insertionsort(list1, n, size, cmp TSRMLS_CC); size 273 main/mergesort.c *EVAL(list2) = (u_char*) list2 + n*size; size 281 main/mergesort.c insertionsort(list1 + (n - i) * size, i, size, cmp TSRMLS_CC); size 282 main/mergesort.c last = list1 + size * (n - i); size 283 main/mergesort.c *EVAL(list2 + (last - list1)) = list2 + n * size; size 288 main/mergesort.c sense = (cmp(f1, f1 + size TSRMLS_CC) > 0); size 293 main/mergesort.c if ((cmp(f2, f2+ size TSRMLS_CC) > 0) != sense) size 301 main/mergesort.c swap (f1, f1 + size); size 306 main/mergesort.c if ((cmp(f2-size, f2 TSRMLS_CC) > 0) != sense) { size 309 main/mergesort.c reverse(f1, f2-size); size 314 main/mergesort.c reverse (f1, f2-size); size 316 main/mergesort.c if (f2 < last || cmp(f2 - size, f2 TSRMLS_CC) > 0) size 319 main/mergesort.c p2 = *EVAL(p2) = list2 + n*size; size 325 main/mergesort.c if (cmp (f1, f1 + size TSRMLS_CC) > 0) size 326 main/mergesort.c swap(f1, f1 + size); size 336 main/mergesort.c static void insertionsort(u_char *a, size_t n, size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC) size 341 main/mergesort.c for (ai = a+size; --n >= 1; ai += size) size 342 main/mergesort.c for (t = ai; t > a; t -= size) { size 343 main/mergesort.c u = t - size; size 815 main/output.c static inline void php_output_context_feed(php_output_context *context, char *data, size_t size, size_t used, zend_bool free) size 823 main/output.c context->in.size = size; size 837 main/output.c context->in.size = context->out.size; size 841 main/output.c context->out.size = 0; size 851 main/output.c context->out.size = context->in.size; size 856 main/output.c context->in.size = 0; size 884 main/output.c handler->size = chunk_size; size 886 main/output.c handler->buffer.size = PHP_OUTPUT_HANDLER_INITBUF_SIZE(chunk_size); size 887 main/output.c handler->buffer.data = emalloc(handler->buffer.size); size 900 main/output.c if ((handler->buffer.size - handler->buffer.used) <= buf->used) { size 901 main/output.c size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(handler->size); size 902 main/output.c size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(buf->used - (handler->buffer.size - handler->buffer.used)); size 905 main/output.c handler->buffer.data = erealloc(handler->buffer.data, handler->buffer.size + grow_max); size 906 main/output.c handler->buffer.size += grow_max; size 912 main/output.c if (handler->size && (handler->buffer.used >= handler->size)) { size 945 main/output.c handler->buffer.size, size 1003 main/output.c php_output_context_feed(context, handler->buffer.data, handler->buffer.size, handler->buffer.used, 0); size 1033 main/output.c handler->buffer.size = 0; size 1206 main/output.c add_assoc_long(entry, "chunk_size", (long) handler->size); size 1207 main/output.c add_assoc_long(entry, "buffer_size", (long) handler->buffer.size); size 111 main/php.h #define PHP_STRLCPY(dst, src, size, src_size) \ size 115 main/php.h if (src_size >= size) \ size 116 main/php.h php_str_len = size - 1; \ size 283 main/php.h PHPAPI int php_write(void *buf, uint size TSRMLS_DC); size 337 main/php.h PHPAPI int php_mergesort(void *base, size_t nmemb, register size_t size, int (*cmp)(const void *, const void * TSRMLS_DC) TSRMLS_DC); size 424 main/php_ini.c int size; size 431 main/php_ini.c size = GetEnvironmentVariableA("PHPRC", &dummybuf, 0); size 436 main/php_ini.c if (size == 0) { size 439 main/php_ini.c size = GetEnvironmentVariableA("PHPRC", phprc_path, size); size 440 main/php_ini.c if (size == 0) { size 95 main/php_output.h size_t size; size 134 main/php_output.h size_t size; size 300 main/php_streams.h PHPAPI void _php_stream_fill_read_buffer(php_stream *stream, size_t size TSRMLS_DC); size 301 main/php_streams.h #define php_stream_fill_read_buffer(stream, size) _php_stream_fill_read_buffer((stream), (size) TSRMLS_CC) size 364 main/php_streams.h #define php_stream_set_chunk_size(stream, size) _php_stream_set_option((stream), PHP_STREAM_OPTION_SET_CHUNK_SIZE, (size), NULL TSRMLS_CC) size 419 main/php_streams.h #define php_stream_truncate_set_size(stream, size) _php_stream_truncate_set_size((stream), (size) TSRMLS_CC) size 63 main/streams/cast.c static int stream_cookie_reader(void *cookie, char *buffer, int size) size 68 main/streams/cast.c ret = php_stream_read((php_stream*)cookie, buffer, size); size 72 main/streams/cast.c static int stream_cookie_writer(void *cookie, const char *buffer, int size) size 76 main/streams/cast.c return php_stream_write((php_stream *)cookie, (char *)buffer, size); size 96 main/streams/cast.c static ssize_t stream_cookie_reader(void *cookie, char *buffer, size_t size) size 101 main/streams/cast.c ret = php_stream_read(((php_stream *)cookie), buffer, size); size 105 main/streams/cast.c static ssize_t stream_cookie_writer(void *cookie, const char *buffer, size_t size) size 109 main/streams/cast.c return php_stream_write(((php_stream *)cookie), (char *)buffer, size); size 24 main/streams/php_streams_int.h #define emalloc_rel_orig(size) \ size 26 main/streams/php_streams_int.h ? _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_RELAY_CC) \ size 27 main/streams/php_streams_int.h : _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC) ) size 29 main/streams/php_streams_int.h #define erealloc_rel_orig(ptr, size) \ size 31 main/streams/php_streams_int.h ? _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_RELAY_CC) \ size 32 main/streams/php_streams_int.h : _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC) ) size 34 main/streams/php_streams_int.h #define pemalloc_rel_orig(size, persistent) ((persistent) ? malloc((size)) : emalloc_rel_orig((size))) size 35 main/streams/php_streams_int.h #define perealloc_rel_orig(ptr, size, persistent) ((persistent) ? realloc((ptr), (size)) : erealloc_rel_orig((ptr), (size))) size 37 main/streams/php_streams_int.h # define pemalloc_rel_orig(size, persistent) pemalloc((size), (persistent)) size 38 main/streams/php_streams_int.h # define perealloc_rel_orig(ptr, size, persistent) perealloc((ptr), (size), (persistent)) size 39 main/streams/php_streams_int.h # define emalloc_rel_orig(size) emalloc((size)) size 579 main/streams/plain_wrapper.c size_t size; size 615 main/streams/plain_wrapper.c size = *(size_t *)ptrparam; size 617 main/streams/plain_wrapper.c size = BUFSIZ; size 624 main/streams/plain_wrapper.c return setvbuf(data->file, NULL, _IOLBF, size); size 627 main/streams/plain_wrapper.c return setvbuf(data->file, NULL, _IOFBF, size); size 754 main/streams/plain_wrapper.c size = GetFileSize(hfile, NULL); size 755 main/streams/plain_wrapper.c if (range->length == 0 && range->offset > 0 && range->offset < size) { size 756 main/streams/plain_wrapper.c range->length = size - range->offset; size 758 main/streams/plain_wrapper.c if (range->length == 0 || range->length > size) { size 759 main/streams/plain_wrapper.c range->length = size; size 761 main/streams/plain_wrapper.c if (range->offset >= size) { size 762 main/streams/plain_wrapper.c range->offset = size; size 571 main/streams/streams.c PHPAPI void _php_stream_fill_read_buffer(php_stream *stream, size_t size TSRMLS_DC) size 588 main/streams/streams.c while (!stream->eof && !err_flag && (stream->writepos - stream->readpos < (off_t)size)) { size 674 main/streams/streams.c if (stream->writepos - stream->readpos < (off_t)size) { size 703 main/streams/streams.c PHPAPI size_t _php_stream_read(php_stream *stream, char *buf, size_t size TSRMLS_DC) size 707 main/streams/streams.c while (size > 0) { size 716 main/streams/streams.c if (toread > size) { size 717 main/streams/streams.c toread = size; size 722 main/streams/streams.c size -= toread; size 728 main/streams/streams.c if (size == 0) { size 733 main/streams/streams.c toread = stream->ops->read(stream, buf, size TSRMLS_CC); size 739 main/streams/streams.c php_stream_fill_read_buffer(stream, size); size 742 main/streams/streams.c if (toread > size) { size 743 main/streams/streams.c toread = size; size 754 main/streams/streams.c size -= toread; size 305 main/streams/userspace.c fci.size = sizeof(fci); size 914 main/streams/userspace.c STAT_PROP_ENTRY(size); size 198 sapi/apache2filter/sapi_apache2.c ctx->finfo.st_size = ctx->r->finfo.size; size 234 sapi/apache2handler/sapi_apache2.c ctx->finfo.st_size = ctx->r->finfo.size; size 20 sapi/fpm/fpm/fpm_shm.c void *fpm_shm_alloc(size_t size) /* {{{ */ size 24 sapi/fpm/fpm/fpm_shm.c mem = mmap(0, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0); size 28 sapi/fpm/fpm/fpm_shm.c zlog(ZLOG_SYSERROR, "unable to allocate %zu bytes in shared memory: %s", size, strerror(errno)); size 34 sapi/fpm/fpm/fpm_shm.c zlog(ZLOG_SYSERROR, "unable to allocate %zu bytes in shared memory", size); size 38 sapi/fpm/fpm/fpm_shm.c memset(mem, 0, size); size 39 sapi/fpm/fpm/fpm_shm.c fpm_shm_size += size; size 44 sapi/fpm/fpm/fpm_shm.c int fpm_shm_free(void *mem, size_t size) /* {{{ */ size 51 sapi/fpm/fpm/fpm_shm.c if (munmap(mem, size) == -1) { size 56 sapi/fpm/fpm/fpm_shm.c if (fpm_shm_size - size > 0) { size 57 sapi/fpm/fpm/fpm_shm.c fpm_shm_size -= size; size 8 sapi/fpm/fpm/fpm_shm.h void *fpm_shm_alloc(size_t size); size 9 sapi/fpm/fpm/fpm_shm.h int fpm_shm_free(void *mem, size_t size); size 8 sapi/fpm/fpm/fpm_str.h static inline char *str_purify_filename(char *dst, char *src, size_t size) /* {{{ */ size 13 sapi/fpm/fpm/fpm_str.h end = dst + size - 1; size 378 sapi/litespeed/lsapilib.c static inline int allocateBuf( LSAPI_Request * pReq, int size ) size 380 sapi/litespeed/lsapilib.c char * pBuf = (char *)realloc( pReq->m_pReqBuf, size ); size 384 sapi/litespeed/lsapilib.c pReq->m_reqBufSize = size; size 405 sapi/litespeed/lsapilib.c static int allocateRespHeaderBuf( LSAPI_Request * pReq, int size ) size 407 sapi/litespeed/lsapilib.c char * p = (char *)realloc( pReq->m_pRespHeaderBuf, size ); size 412 sapi/litespeed/lsapilib.c pReq->m_pRespHeaderBufEnd = p + size; size 1676 sapi/litespeed/lsapilib.c ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size ) size 1680 sapi/litespeed/lsapilib.c ret = sendfile( fdIn, fdOut, *off, size, NULL, &written, 0 ); size 1691 sapi/litespeed/lsapilib.c ssize_t gsendfile( int fdOut, int fdIn, off_t* off, size_t size ) size 1694 sapi/litespeed/lsapilib.c off_t len = size; size 1707 sapi/litespeed/lsapilib.c ssize_t gsendfile( int fdOut, int fdIn, off_t *off, size_t size ) size 1715 sapi/litespeed/lsapilib.c vec[n].sfv_len = size; size 1734 sapi/litespeed/lsapilib.c ssize_t gsendfile( int fdOut, int fdIn, off_t * off, size_t size ) size 1736 sapi/litespeed/lsapilib.c return sendfile( fdOut, fdIn, off, size, NULL, 0 ); size 1740 sapi/litespeed/lsapilib.c ssize_t LSAPI_sendfile_r( LSAPI_Request * pReq, int fdIn, off_t* off, size_t size ) size 1754 sapi/litespeed/lsapilib.c size + LSAPI_PACKET_HEADER_LEN ); size 1760 sapi/litespeed/lsapilib.c return gsendfile( pReq->m_fd, fdIn, off, size ); size 2630 sapi/litespeed/lsapilib.c int size = 4096; size 2633 sapi/litespeed/lsapilib.c size = (g_prefork_server->m_iMaxChildren + g_prefork_server->m_iExtraChildren ) * sizeof( lsapi_child_status ) * 2; size 2634 sapi/litespeed/lsapilib.c size = (size + 4095 ) / 4096 * 4096; size 2635 sapi/litespeed/lsapilib.c pBuf =( char*) mmap( NULL, size, PROT_READ | PROT_WRITE, size 2642 sapi/litespeed/lsapilib.c memset( pBuf, 0, size ); size 2645 sapi/litespeed/lsapilib.c g_prefork_server->m_pChildrenStatusEnd = (lsapi_child_status *)pBuf + size / sizeof( lsapi_child_status ); size 184 sapi/litespeed/lsapilib.h ssize_t LSAPI_sendfile_r( LSAPI_Request * pReq, int fdIn, off_t* off, size_t size ); size 332 sapi/litespeed/lsapilib.h static inline ssize_t LSAPI_sendfile( int fdIn, off_t* off, size_t size ) size 334 sapi/litespeed/lsapilib.h return LSAPI_sendfile_r(&g_req, fdIn, off, size ); size 872 sapi/phpdbg/phpdbg.c socklen_t size = sizeof(address); size 876 sapi/phpdbg/phpdbg.c memset(&address, 0, size); size 878 sapi/phpdbg/phpdbg.c (*listen)[0], (struct sockaddr *) &address, &size); size 885 sapi/phpdbg/phpdbg.c memset(&address, 0, size); size 887 sapi/phpdbg/phpdbg.c (*listen)[1], (struct sockaddr *) &address, &size); size 939 sapi/phpdbg/phpdbg.c void *phpdbg_malloc_wrapper(size_t size) /* {{{ */ size 941 sapi/phpdbg/phpdbg.c return zend_mm_alloc(phpdbg_mm_get_heap(), size); size 949 sapi/phpdbg/phpdbg.c void *phpdbg_realloc_wrapper(void *ptr, size_t size) /* {{{ */ size 951 sapi/phpdbg/phpdbg.c return zend_mm_realloc(phpdbg_mm_get_heap(), ptr, size); size 56 sapi/phpdbg/phpdbg_help.c unsigned int size = 0; size 67 sapi/phpdbg/phpdbg_help.c size += bold_escape_len - 2; size 70 sapi/phpdbg/phpdbg_help.c size += prompt_escape_len - 2; size 76 sapi/phpdbg/phpdbg_help.c size += (p-text)+1; size 78 sapi/phpdbg/phpdbg_help.c new = emalloc(size); size 130 sapi/phpdbg/phpdbg_help.c if ((q-new)>size) { size 131 sapi/phpdbg/phpdbg_help.c phpdbg_error("Output overrun of %lu bytes", ((q-new) - size)); size 93 sapi/phpdbg/phpdbg_prompt.c fci.size = sizeof(zend_fcall_info); size 550 sapi/phpdbg/phpdbg_prompt.c fci.size = sizeof(fci); size 36 sapi/phpdbg/phpdbg_watch.c size_t size; size 42 sapi/phpdbg/phpdbg_watch.c #define MEMDUMP_SIZE(size) (sizeof(phpdbg_watch_memdump) - sizeof(void *) + (size)) size 56 sapi/phpdbg/phpdbg_watch.c if ((char *)phpdbg_get_page_boundary(watch->addr.ptr) > (char *)addr || (char *)phpdbg_get_page_boundary(watch->addr.ptr) + phpdbg_get_total_page_size(watch->addr.ptr, watch->size) < (char *)addr) { size 68 sapi/phpdbg/phpdbg_watch.c m = mprotect(phpdbg_get_page_boundary(watch->addr.ptr), phpdbg_get_total_page_size(watch->addr.ptr, watch->size), access); size 87 sapi/phpdbg/phpdbg_watch.c void phpdbg_create_addr_watchpoint(void *addr, size_t size, phpdbg_watchpoint_t *watch) { size 89 sapi/phpdbg/phpdbg_watch.c watch->size = size; size 511 sapi/phpdbg/phpdbg_watch.c size_t size; size 526 sapi/phpdbg/phpdbg_watch.c size = phpdbg_get_total_page_size(watch->addr.ptr, watch->size); size 529 sapi/phpdbg/phpdbg_watch.c mprotect(page, size, PROT_READ | PROT_WRITE); size 531 sapi/phpdbg/phpdbg_watch.c dump = malloc(MEMDUMP_SIZE(size)); size 533 sapi/phpdbg/phpdbg_watch.c dump->size = size; size 535 sapi/phpdbg/phpdbg_watch.c memcpy(&dump->data, page, size); size 563 sapi/phpdbg/phpdbg_watch.c mprotect(dump->page, dump->size, PROT_READ); size 588 sapi/phpdbg/phpdbg_watch.c phpdbg_btree_position pos = phpdbg_btree_find_between(&PHPDBG_G(watchpoint_tree), (zend_ulong)dump->page, (zend_ulong)dump->page + dump->size); size 600 sapi/phpdbg/phpdbg_watch.c if ((size_t)watch->addr.ptr < (size_t)dump->page || (size_t)watch->addr.ptr + watch->size > (size_t)dump->page + dump->size) { size 631 sapi/phpdbg/phpdbg_watch.c if (memcmp(oldPtr, watch->addr.ptr, watch->size) != SUCCESS) { size 783 sapi/phpdbg/phpdbg_watch.c if ((size_t)watch->addr.ptr + watch->size > (size_t)ptr) { size 76 sapi/phpdbg/phpdbg_watch.h size_t size; size 89 sapi/phpdbg/phpdbg_watch.h void phpdbg_create_addr_watchpoint(void *addr, size_t size, phpdbg_watchpoint_t *watch); size 108 sapi/phpdbg/phpdbg_watch.h static zend_always_inline size_t phpdbg_get_total_page_size(void *addr, size_t size) { size 109 sapi/phpdbg/phpdbg_watch.h return (size_t)phpdbg_get_page_boundary((void *)((size_t)addr + size - 1)) - (size_t)phpdbg_get_page_boundary(addr) + phpdbg_pagesize; size 24 sapi/phpdbg/phpdbg_win.c int mprotect(void *addr, size_t size, int protection) { size 26 sapi/phpdbg/phpdbg_win.c return (int)VirtualProtect(addr, size, protection == (PROT_READ | PROT_WRITE) ? PAGE_READWRITE : PAGE_READONLY, &var); size 31 sapi/phpdbg/phpdbg_win.h int mprotect(void *addr, size_t size, int protection); size 541 sapi/roxen/roxen.c for(i = 0; i < indices->size; i++) { size 35 win32/sockets.c int size = sizeof(address); size 58 win32/sockets.c if(getsockname(sock[0], (struct sockaddr *)&address, &size) != 0) { size 76 win32/sockets.c redirect = accept(sock[0],(struct sockaddr*)&address, &size); size 80 win32/winutil.c PHPAPI int php_win32_get_random_bytes(unsigned char *buf, size_t size) { /* {{{ */ size 118 win32/winutil.c ret = CryptGenRandom(hCryptProv, size, buf); size 23 win32/winutil.h PHPAPI php_win32_get_random_bytes(unsigned char *buf, size_t size);