size 38 TSRM/TSRM.c size_t size; size 219 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 223 TSRM/TSRM.c TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size)); size 242 TSRM/TSRM.c resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size; size 257 TSRM/TSRM.c p->storage[j] = (void *) malloc(resource_types_table[j].size); size 299 TSRM/TSRM.c (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size); size 765 TSRM/TSRM.c int size; size 769 TSRM/TSRM.c size = vfprintf(tsrm_error_file, format, args); size 773 TSRM/TSRM.c return size; size 108 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 641 TSRM/tsrm_win32.c shm->descriptor->shm_segsz = size; size 653 TSRM/tsrm_win32.c if (NULL != shm->descriptor && (shm->descriptor->shm_perm.key != key || size > shm->descriptor->shm_segsz)) { size 108 TSRM/tsrm_win32.h TSRM_API int shmget(int key, int size, int flags); size 702 Zend/zend_API.c fci->size = 0; size 1059 Zend/zend_API.c ZEND_API int _array_init(zval *arg, uint32_t size ZEND_FILE_LINE_DC) /* {{{ */ size 1062 Zend/zend_API.c _zend_hash_init(Z_ARRVAL_P(arg), size, ZVAL_PTR_DTOR, 0 ZEND_FILE_LINE_RELAY_CC); size 3419 Zend/zend_API.c fci->size = sizeof(*fci); size 45 Zend/zend_API.h size_t size; size 243 Zend/zend_API.h #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0) size 376 Zend/zend_API.h #define array_init_size(arg, size) _array_init((arg), (size) ZEND_FILE_LINE_CC) size 380 Zend/zend_API.h ZEND_API int _array_init(zval *arg, uint32_t size ZEND_FILE_LINE_DC); size 1218 Zend/zend_API.h dest_fci->size = 0; size 148 Zend/zend_alloc.c #define ZEND_MM_ALIGNED_OFFSET(size, alignment) \ size 149 Zend/zend_alloc.c (((size_t)(size)) & ((alignment) - 1)) size 150 Zend/zend_alloc.c #define ZEND_MM_ALIGNED_BASE(size, alignment) \ size 151 Zend/zend_alloc.c (((size_t)(size)) & ~((alignment) - 1)) size 152 Zend/zend_alloc.c #define ZEND_MM_SIZE_TO_NUM(size, alignment) \ size 153 Zend/zend_alloc.c (((size_t)(size) + ((alignment) - 1)) / (alignment)) size 247 Zend/zend_alloc.c size_t size; /* current memory usage */ size 317 Zend/zend_alloc.c size_t size; size 327 Zend/zend_alloc.c #define _BIN_DATA_SIZE(num, size, elements, pages, x, y) size, size 332 Zend/zend_alloc.c #define _BIN_DATA_ELEMENTS(num, size, elements, pages, x, y) elements, size 337 Zend/zend_alloc.c #define _BIN_DATA_PAGES(num, size, elements, pages, x, y) pages, size 380 Zend/zend_alloc.c size_t size) size 392 Zend/zend_alloc.c size); size 428 Zend/zend_alloc.c static void *zend_mm_mmap_fixed(void *addr, size_t size) size 431 Zend/zend_alloc.c return VirtualAlloc(addr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); size 434 Zend/zend_alloc.c void *ptr = mmap(addr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON /*| MAP_POPULATE | MAP_HUGETLB*/, -1, 0); size 442 Zend/zend_alloc.c if (munmap(ptr, size) != 0) { size 453 Zend/zend_alloc.c static void *zend_mm_mmap(size_t size) size 456 Zend/zend_alloc.c void *ptr = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); size 469 Zend/zend_alloc.c if (zend_mm_use_huge_pages && size == ZEND_MM_CHUNK_SIZE) { size 470 Zend/zend_alloc.c ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_HUGETLB, -1, 0); size 477 Zend/zend_alloc.c ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); size 489 Zend/zend_alloc.c static void zend_mm_munmap(void *addr, size_t size) size 498 Zend/zend_alloc.c if (munmap(addr, size) != 0) { size 588 Zend/zend_alloc.c static zend_always_inline int zend_mm_bitset_find_zero(zend_mm_bitset *bitset, int size) size 598 Zend/zend_alloc.c } while (i < size); size 602 Zend/zend_alloc.c static zend_always_inline int zend_mm_bitset_find_one(zend_mm_bitset *bitset, int size) size 612 Zend/zend_alloc.c } while (i < size); size 616 Zend/zend_alloc.c static zend_always_inline int zend_mm_bitset_find_zero_and_set(zend_mm_bitset *bitset, int size) size 628 Zend/zend_alloc.c } while (i < size); size 751 Zend/zend_alloc.c static void *zend_mm_chunk_alloc_int(size_t size, size_t alignment) size 753 Zend/zend_alloc.c void *ptr = zend_mm_mmap(size); size 759 Zend/zend_alloc.c madvise(ptr, size, MADV_HUGEPAGE); size 766 Zend/zend_alloc.c zend_mm_munmap(ptr, size); size 767 Zend/zend_alloc.c ptr = zend_mm_mmap(size + alignment - REAL_PAGE_SIZE); size 770 Zend/zend_alloc.c zend_mm_munmap(ptr, size + alignment - REAL_PAGE_SIZE); size 771 Zend/zend_alloc.c ptr = zend_mm_mmap_fixed((void*)((char*)ptr + (alignment - offset)), size); size 774 Zend/zend_alloc.c zend_mm_munmap(ptr, size); size 787 Zend/zend_alloc.c zend_mm_munmap((char*)ptr + size, alignment - REAL_PAGE_SIZE); size 790 Zend/zend_alloc.c madvise(ptr, size, MADV_HUGEPAGE); size 797 Zend/zend_alloc.c static void *zend_mm_chunk_alloc(zend_mm_heap *heap, size_t size, size_t alignment) size 801 Zend/zend_alloc.c void *ptr = heap->storage->handlers.chunk_alloc(heap->storage, size, alignment); size 806 Zend/zend_alloc.c return zend_mm_chunk_alloc_int(size, alignment); size 809 Zend/zend_alloc.c static void zend_mm_chunk_free(zend_mm_heap *heap, void *addr, size_t size) size 813 Zend/zend_alloc.c heap->storage->handlers.chunk_free(heap->storage, addr, size); size 817 Zend/zend_alloc.c zend_mm_munmap(addr, size); size 879 Zend/zend_alloc.c static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 883 Zend/zend_alloc.c static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 885 Zend/zend_alloc.c static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 893 Zend/zend_alloc.c static void *zend_mm_alloc_pages(zend_mm_heap *heap, int pages_count, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1029 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->limit, __zend_filename, __zend_lineno, size); size 1047 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", heap->real_size, __zend_filename, __zend_lineno, size); size 1056 Zend/zend_alloc.c size_t size = heap->real_size + ZEND_MM_CHUNK_SIZE; size 1057 Zend/zend_alloc.c size_t peak = MAX(heap->real_peak, size); size 1058 Zend/zend_alloc.c heap->real_size = size; size 1090 Zend/zend_alloc.c static zend_always_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1092 Zend/zend_alloc.c int pages_count = (int)ZEND_MM_SIZE_TO_NUM(size, ZEND_MM_PAGE_SIZE); size 1094 Zend/zend_alloc.c void *ptr = zend_mm_alloc_pages(heap, pages_count, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1100 Zend/zend_alloc.c size_t size = heap->size + pages_count * ZEND_MM_PAGE_SIZE; size 1101 Zend/zend_alloc.c size_t peak = MAX(heap->peak, size); size 1102 Zend/zend_alloc.c heap->size = size; size 1156 Zend/zend_alloc.c heap->size -= pages_count * ZEND_MM_PAGE_SIZE; size 1166 Zend/zend_alloc.c static zend_always_inline int zend_mm_small_size_to_bit(int size) size 1169 Zend/zend_alloc.c return (__builtin_clz(size) ^ 0x1f) + 1; size 1173 Zend/zend_alloc.c if (!BitScanReverse(&index, (unsigned long)size)) { size 1181 Zend/zend_alloc.c if (size <= 0x00ff) {n -= 8; size = size << 8;} size 1182 Zend/zend_alloc.c if (size <= 0x0fff) {n -= 4; size = size << 4;} size 1183 Zend/zend_alloc.c if (size <= 0x3fff) {n -= 2; size = size << 2;} size 1184 Zend/zend_alloc.c if (size <= 0x7fff) {n -= 1;} size 1197 Zend/zend_alloc.c static zend_always_inline int zend_mm_small_size_to_bin(size_t size) size 1205 Zend/zend_alloc.c if (UNEXPECTED(size <= 2)) return 0; size 1206 Zend/zend_alloc.c n = zend_mm_small_size_to_bit(size - 1); size 1207 Zend/zend_alloc.c return ((size-1) >> f1[n]) + f2[n]; size 1211 Zend/zend_alloc.c if (size <= 64) { size 1213 Zend/zend_alloc.c return (size - !!size) >> 3; size 1215 Zend/zend_alloc.c t1 = size - 1; size 1225 Zend/zend_alloc.c #define ZEND_MM_SMALL_SIZE_TO_BIN(size) zend_mm_small_size_to_bin(size) size 1263 Zend/zend_alloc.c dbg->size = 0; size 1274 Zend/zend_alloc.c dbg->size = 0; size 1282 Zend/zend_alloc.c static zend_always_inline void *zend_mm_alloc_small(zend_mm_heap *heap, size_t size, int bin_num ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1286 Zend/zend_alloc.c size_t size = heap->size + bin_data_size[bin_num]; size 1287 Zend/zend_alloc.c size_t peak = MAX(heap->peak, size); size 1288 Zend/zend_alloc.c heap->size = size; size 1307 Zend/zend_alloc.c heap->size -= bin_data_size[bin_num]; size 1313 Zend/zend_alloc.c dbg->size = 0; size 1350 Zend/zend_alloc.c static zend_always_inline void *zend_mm_alloc_heap(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1354 Zend/zend_alloc.c size_t real_size = size; size 1358 Zend/zend_alloc.c size = MAX(size, 1); size 1359 Zend/zend_alloc.c size = ZEND_MM_ALIGNED_SIZE(size) + ZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_debug_info)); size 1360 Zend/zend_alloc.c if (UNEXPECTED(size < real_size)) { size 1365 Zend/zend_alloc.c if (size <= ZEND_MM_MAX_SMALL_SIZE) { size 1366 Zend/zend_alloc.c ptr = zend_mm_alloc_small(heap, size, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1369 Zend/zend_alloc.c dbg->size = real_size; size 1376 Zend/zend_alloc.c } else if (size <= ZEND_MM_MAX_LARGE_SIZE) { size 1377 Zend/zend_alloc.c ptr = zend_mm_alloc_large(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1380 Zend/zend_alloc.c dbg->size = real_size; size 1389 Zend/zend_alloc.c size = real_size; size 1391 Zend/zend_alloc.c return zend_mm_alloc_huge(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1430 Zend/zend_alloc.c return dbg->size; size 1448 Zend/zend_alloc.c static void *zend_mm_realloc_heap(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1462 Zend/zend_alloc.c return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1466 Zend/zend_alloc.c real_size = size; size 1467 Zend/zend_alloc.c size = ZEND_MM_ALIGNED_SIZE(size) + ZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_debug_info)); size 1469 Zend/zend_alloc.c if (size > ZEND_MM_MAX_LARGE_SIZE) { size 1471 Zend/zend_alloc.c size = real_size; size 1478 Zend/zend_alloc.c new_size = ZEND_MM_ALIGNED_SIZE_EX(size, MAX(REAL_PAGE_SIZE, ZEND_MM_CHUNK_SIZE)); size 1480 Zend/zend_alloc.c new_size = ZEND_MM_ALIGNED_SIZE_EX(size, REAL_PAGE_SIZE); size 1496 Zend/zend_alloc.c heap->size -= old_size - new_size; size 1512 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->limit, __zend_filename, __zend_lineno, size); size 1514 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)", heap->limit, size); size 1527 Zend/zend_alloc.c heap->size += new_size - old_size; size 1528 Zend/zend_alloc.c heap->peak = MAX(heap->peak, heap->size); size 1544 Zend/zend_alloc.c size_t real_size = size; size 1546 Zend/zend_alloc.c size = ZEND_MM_ALIGNED_SIZE(size) + ZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_debug_info)); size 1555 Zend/zend_alloc.c bin_num = ZEND_MM_SMALL_SIZE_TO_BIN(size); size 1559 Zend/zend_alloc.c dbg->size = real_size; size 1570 Zend/zend_alloc.c if (size > ZEND_MM_MAX_SMALL_SIZE && size <= ZEND_MM_MAX_LARGE_SIZE) { size 1571 Zend/zend_alloc.c new_size = ZEND_MM_ALIGNED_SIZE_EX(size, ZEND_MM_PAGE_SIZE); size 1575 Zend/zend_alloc.c dbg->size = real_size; size 1588 Zend/zend_alloc.c heap->size -= rest_pages_count * ZEND_MM_PAGE_SIZE; size 1595 Zend/zend_alloc.c dbg->size = real_size; size 1611 Zend/zend_alloc.c size_t size = heap->size + (new_size - old_size); size 1612 Zend/zend_alloc.c size_t peak = MAX(heap->peak, size); size 1613 Zend/zend_alloc.c heap->size = size; size 1622 Zend/zend_alloc.c dbg->size = real_size; size 1634 Zend/zend_alloc.c size = real_size; size 1644 Zend/zend_alloc.c ret = zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1648 Zend/zend_alloc.c heap->peak = MAX(orig_peak, heap->size); size 1660 Zend/zend_alloc.c static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1662 Zend/zend_alloc.c static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1667 Zend/zend_alloc.c list->size = size; size 1670 Zend/zend_alloc.c list->dbg.size = dbg_size; size 1685 Zend/zend_alloc.c size_t size; size 1692 Zend/zend_alloc.c size = list->size; size 1694 Zend/zend_alloc.c return size; size 1708 Zend/zend_alloc.c return list->size; size 1717 Zend/zend_alloc.c static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1719 Zend/zend_alloc.c static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1725 Zend/zend_alloc.c list->size = size; size 1727 Zend/zend_alloc.c list->dbg.size = dbg_size; size 1739 Zend/zend_alloc.c static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 1746 Zend/zend_alloc.c size_t new_size = ZEND_MM_ALIGNED_SIZE_EX(size, MAX(REAL_PAGE_SIZE, ZEND_MM_CHUNK_SIZE)); size 1748 Zend/zend_alloc.c size_t new_size = ZEND_MM_ALIGNED_SIZE_EX(size, REAL_PAGE_SIZE); size 1758 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->limit, __zend_filename, __zend_lineno, size); size 1760 Zend/zend_alloc.c zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)", heap->limit, size); size 1776 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", heap->real_size, __zend_filename, __zend_lineno, size); size 1778 Zend/zend_alloc.c zend_mm_safe_error(heap, "Out of memory (allocated %zu) (tried to allocate %zu bytes)", heap->real_size, size); size 1784 Zend/zend_alloc.c zend_mm_add_huge_block(heap, ptr, new_size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1790 Zend/zend_alloc.c size_t size = heap->real_size + new_size; size 1791 Zend/zend_alloc.c size_t peak = MAX(heap->real_peak, size); size 1792 Zend/zend_alloc.c heap->real_size = size; size 1796 Zend/zend_alloc.c size_t size = heap->size + new_size; size 1797 Zend/zend_alloc.c size_t peak = MAX(heap->peak, size); size 1798 Zend/zend_alloc.c heap->size = size; size 1809 Zend/zend_alloc.c size_t size; size 1812 Zend/zend_alloc.c size = zend_mm_del_huge_block(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1813 Zend/zend_alloc.c zend_mm_chunk_free(heap, ptr, size); size 1815 Zend/zend_alloc.c heap->real_size -= size; size 1818 Zend/zend_alloc.c heap->size -= size; size 1861 Zend/zend_alloc.c heap->size = 0; size 2004 Zend/zend_alloc.c if (dbg->size != 0) { size 2007 Zend/zend_alloc.c dbg->size = 0; size 2062 Zend/zend_alloc.c zend_mm_chunk_free(heap, p->ptr, p->size); size 2089 Zend/zend_alloc.c leak.size = list->dbg.size; size 2104 Zend/zend_alloc.c zend_mm_chunk_free(heap, q->ptr, q->size); size 2120 Zend/zend_alloc.c if (dbg->size != 0) { size 2122 Zend/zend_alloc.c leak.size = dbg->size; size 2131 Zend/zend_alloc.c dbg->size = 0; size 2151 Zend/zend_alloc.c leak.size = dbg->size; size 2211 Zend/zend_alloc.c zend_mm_chunk_free(heap, q->ptr, q->size); size 2276 Zend/zend_alloc.c heap->size = heap->peak = 0; size 2285 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2287 Zend/zend_alloc.c return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2295 Zend/zend_alloc.c void* ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2297 Zend/zend_alloc.c return zend_mm_realloc_heap(heap, ptr, size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2300 Zend/zend_alloc.c void* ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2302 Zend/zend_alloc.c return zend_mm_realloc_heap(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2339 Zend/zend_alloc.c # define ZEND_MM_CUSTOM_ALLOCATOR(size) do { \ size 2342 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.debug._malloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \ size 2344 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.std._malloc(size); \ size 2359 Zend/zend_alloc.c # define ZEND_MM_CUSTOM_ALLOCATOR(size) size 2371 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _emalloc_large(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2374 Zend/zend_alloc.c ZEND_MM_CUSTOM_ALLOCATOR(size); size 2375 Zend/zend_alloc.c return zend_mm_alloc_large(AG(mm_heap), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2378 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _emalloc_huge(size_t size) size 2381 Zend/zend_alloc.c ZEND_MM_CUSTOM_ALLOCATOR(size); size 2382 Zend/zend_alloc.c return zend_mm_alloc_huge(AG(mm_heap), size); size 2413 Zend/zend_alloc.c ZEND_API void ZEND_FASTCALL _efree_large(void *ptr, size_t size) size 2421 Zend/zend_alloc.c int pages_count = ZEND_MM_ALIGNED_SIZE_EX(size, ZEND_MM_PAGE_SIZE) / ZEND_MM_PAGE_SIZE; size 2430 Zend/zend_alloc.c ZEND_API void ZEND_FASTCALL _efree_huge(void *ptr, size_t size) size 2438 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2444 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.debug._malloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2446 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.std._malloc(size); size 2450 Zend/zend_alloc.c return zend_mm_alloc_heap(AG(mm_heap), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2469 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _erealloc(void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2474 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.debug._realloc(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2476 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.std._realloc(ptr, size); size 2479 Zend/zend_alloc.c return zend_mm_realloc_heap(AG(mm_heap), ptr, size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2482 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _erealloc2(void *ptr, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2487 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.debug._realloc(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2489 Zend/zend_alloc.c return AG(mm_heap)->custom_heap.std._realloc(ptr, size); size 2492 Zend/zend_alloc.c return zend_mm_realloc_heap(AG(mm_heap), ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2503 Zend/zend_alloc.c static zend_always_inline size_t safe_address(size_t nmemb, size_t size, size_t offset) size 2506 Zend/zend_alloc.c size_t ret = zend_safe_address(nmemb, size, offset, &overflow); size 2509 Zend/zend_alloc.c zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", nmemb, size, offset); size 2516 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2518 Zend/zend_alloc.c return emalloc_rel(safe_address(nmemb, size, offset)); size 2521 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _safe_malloc(size_t nmemb, size_t size, size_t offset) size 2523 Zend/zend_alloc.c return pemalloc(safe_address(nmemb, size, offset), 1); size 2526 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2528 Zend/zend_alloc.c return erealloc_rel(ptr, safe_address(nmemb, size, offset)); size 2531 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset) size 2533 Zend/zend_alloc.c return perealloc(ptr, safe_address(nmemb, size, offset), 1); size 2537 Zend/zend_alloc.c ZEND_API void* ZEND_FASTCALL _ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) size 2541 Zend/zend_alloc.c p = _safe_emalloc(nmemb, size, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 2545 Zend/zend_alloc.c memset(p, 0, size * nmemb); size 2616 Zend/zend_alloc.c size_t usage = AG(mm_heap)->size; size 2821 Zend/zend_alloc.c heap->size = 0; size 43 Zend/zend_alloc.h #define ZEND_MM_ALIGNED_SIZE(size) (((size) + ZEND_MM_ALIGNMENT - Z_L(1)) & ZEND_MM_ALIGNMENT_MASK) size 45 Zend/zend_alloc.h #define ZEND_MM_ALIGNED_SIZE_EX(size, alignment) \ size 46 Zend/zend_alloc.h (((size) + ((alignment) - Z_L(1))) & ~((alignment) - Z_L(1))) size 50 Zend/zend_alloc.h size_t size; size 59 Zend/zend_alloc.h size_t size; size 75 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1); size 76 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; size 77 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _safe_malloc(size_t nmemb, size_t size, size_t offset) ZEND_ATTRIBUTE_MALLOC; size 79 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _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 80 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _erealloc(void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2); size 81 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _erealloc2(void *ptr, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2); size 82 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 83 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset); size 98 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _emalloc_large(size_t size) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1); size 99 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _emalloc_huge(size_t size) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1); size 101 Zend/zend_alloc.h # define _ZEND_BIN_ALLOCATOR_SELECTOR_START(_num, _size, _elements, _pages, size, y) \ size 102 Zend/zend_alloc.h ((size <= _size) ? _emalloc_ ## _size() : size 103 Zend/zend_alloc.h # define _ZEND_BIN_ALLOCATOR_SELECTOR_END(_num, _size, _elements, _pages, size, y) \ size 106 Zend/zend_alloc.h # define ZEND_ALLOCATOR(size) \ size 107 Zend/zend_alloc.h ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR_SELECTOR_START, size, y) \ size 108 Zend/zend_alloc.h ((size <= ZEND_MM_MAX_LARGE_SIZE) ? _emalloc_large(size) : _emalloc_huge(size)) \ size 109 Zend/zend_alloc.h ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR_SELECTOR_END, size, y) size 111 Zend/zend_alloc.h # define _emalloc(size) \ size 112 Zend/zend_alloc.h (__builtin_constant_p(size) ? \ size 113 Zend/zend_alloc.h ZEND_ALLOCATOR(size) \ size 115 Zend/zend_alloc.h _emalloc(size) \ size 123 Zend/zend_alloc.h ZEND_API void ZEND_FASTCALL _efree_large(void *, size_t size); size 124 Zend/zend_alloc.h ZEND_API void ZEND_FASTCALL _efree_huge(void *, size_t size); size 126 Zend/zend_alloc.h # define _ZEND_BIN_DEALLOCATOR_SELECTOR_START(_num, _size, _elements, _pages, ptr, size) \ size 127 Zend/zend_alloc.h if (size <= _size) { _efree_ ## _size(ptr); } else size 129 Zend/zend_alloc.h # define ZEND_DEALLOCATOR(ptr, size) \ size 130 Zend/zend_alloc.h ZEND_MM_BINS_INFO(_ZEND_BIN_DEALLOCATOR_SELECTOR_START, ptr, size) \ size 131 Zend/zend_alloc.h if (size <= ZEND_MM_MAX_LARGE_SIZE) { _efree_large(ptr, size); } \ size 132 Zend/zend_alloc.h else { _efree_huge(ptr, size); } size 134 Zend/zend_alloc.h # define efree_size(ptr, size) do { \ size 135 Zend/zend_alloc.h if (__builtin_constant_p(size)) { \ size 136 Zend/zend_alloc.h ZEND_DEALLOCATOR(ptr, size) \ size 141 Zend/zend_alloc.h # define efree_size_rel(ptr, size) \ size 142 Zend/zend_alloc.h efree_size(ptr, size) size 146 Zend/zend_alloc.h # define efree_size(ptr, size) \ size 148 Zend/zend_alloc.h # define efree_size_rel(ptr, size) \ size 159 Zend/zend_alloc.h #define emalloc(size) _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 160 Zend/zend_alloc.h #define emalloc_large(size) _emalloc_large((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 161 Zend/zend_alloc.h #define emalloc_huge(size) _emalloc_huge((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 162 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 166 Zend/zend_alloc.h #define ecalloc(nmemb, size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 167 Zend/zend_alloc.h #define erealloc(ptr, size) _erealloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 168 Zend/zend_alloc.h #define erealloc2(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 169 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 170 Zend/zend_alloc.h #define erealloc_recoverable(ptr, size) _erealloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 171 Zend/zend_alloc.h #define erealloc2_recoverable(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 177 Zend/zend_alloc.h #define emalloc_rel(size) _emalloc((size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 178 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 180 Zend/zend_alloc.h #define ecalloc_rel(nmemb, size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 181 Zend/zend_alloc.h #define erealloc_rel(ptr, size) _erealloc((ptr), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 182 Zend/zend_alloc.h #define erealloc2_rel(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 183 Zend/zend_alloc.h #define erealloc_recoverable_rel(ptr, size) _erealloc((ptr), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 184 Zend/zend_alloc.h #define erealloc2_recoverable_rel(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 185 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 195 Zend/zend_alloc.h #define pemalloc(size, persistent) ((persistent)?__zend_malloc(size):emalloc(size)) size 196 Zend/zend_alloc.h #define safe_pemalloc(nmemb, size, offset, persistent) ((persistent)?_safe_malloc(nmemb, size, offset):safe_emalloc(nmemb, size, offset)) size 198 Zend/zend_alloc.h #define pefree_size(ptr, size, persistent) ((persistent)?free(ptr):efree_size(ptr, size)) size 199 Zend/zend_alloc.h #define pecalloc(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc((nmemb), (size))) size 200 Zend/zend_alloc.h #define perealloc(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc((ptr), (size))) size 201 Zend/zend_alloc.h #define perealloc2(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc2((ptr), (size), (copy_size))) size 202 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 203 Zend/zend_alloc.h #define perealloc_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable((ptr), (size))) size 204 Zend/zend_alloc.h #define perealloc2_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc2_recoverable((ptr), (size), (copy_size))) size 208 Zend/zend_alloc.h #define pemalloc_rel(size, persistent) ((persistent)?__zend_malloc(size):emalloc_rel(size)) size 210 Zend/zend_alloc.h #define pecalloc_rel(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc_rel((nmemb), (size))) size 211 Zend/zend_alloc.h #define perealloc_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_rel((ptr), (size))) size 212 Zend/zend_alloc.h #define perealloc2_rel(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc2_rel((ptr), (size), (copy_size))) size 213 Zend/zend_alloc.h #define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size))) size 214 Zend/zend_alloc.h #define perealloc2_recoverable_rel(ptr, size, copy_size, persistent) ((persistent)?realloc((ptr), (size)):erealloc2_recoverable_rel((ptr), (size), (copy_size))) size 244 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; size 246 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 247 Zend/zend_alloc.h ZEND_API void* ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *p, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); size 250 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 252 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 253 Zend/zend_alloc.h #define zend_mm_realloc2(heap, p, size, copy_size) _zend_mm_realloc2((heap), (p), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC) size 256 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 258 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 259 Zend/zend_alloc.h #define zend_mm_realloc2_rel(heap, p, size, copy_size) _zend_mm_realloc2((heap), (p), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC) size 290 Zend/zend_alloc.h typedef void* (*zend_mm_chunk_alloc_t)(zend_mm_storage *storage, size_t size, size_t alignment); size 291 Zend/zend_alloc.h typedef void (*zend_mm_chunk_free_t)(zend_mm_storage *storage, void *chunk, size_t size); size 34 Zend/zend_arena.h static zend_always_inline zend_arena* zend_arena_create(size_t size) size 36 Zend/zend_arena.h zend_arena *arena = (zend_arena*)emalloc(size); size 39 Zend/zend_arena.h arena->end = (char*) arena + size; size 55 Zend/zend_arena.h static zend_always_inline void* zend_arena_alloc(zend_arena **arena_ptr, size_t size) size 60 Zend/zend_arena.h size = ZEND_MM_ALIGNED_SIZE(size); size 62 Zend/zend_arena.h if (EXPECTED(size <= (size_t)(arena->end - ptr))) { size 63 Zend/zend_arena.h arena->ptr = ptr + size; size 66 Zend/zend_arena.h UNEXPECTED((size + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena))) > (size_t)(arena->end - (char*) arena)) ? size 67 Zend/zend_arena.h (size + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena))) : size 72 Zend/zend_arena.h new_arena->ptr = (char*) new_arena + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena)) + size; size 84 Zend/zend_arena.h size_t size; size 87 Zend/zend_arena.h size = zend_safe_address(unit_size, count, 0, &overflow); size 91 Zend/zend_arena.h ret = zend_arena_alloc(arena_ptr, size); size 92 Zend/zend_arena.h memset(ret, 0, size); size 31 Zend/zend_ast.c static inline void *zend_ast_alloc(size_t size) { size 32 Zend/zend_ast.c return zend_arena_alloc(&CG(ast_arena), size); size 730 Zend/zend_exceptions.c fci.size = sizeof(fci); size 147 Zend/zend_execute.c #define ZEND_VM_STACK_PAGE_ALIGNED_SIZE(gen, size) \ size 148 Zend/zend_execute.c (((size) + (ZEND_VM_STACK_FREE_PAGE_SIZE(gen) - 1)) & ~(ZEND_VM_STACK_PAGE_SIZE(gen) - 1)) size 150 Zend/zend_execute.c static zend_always_inline zend_vm_stack zend_vm_stack_new_page(size_t size, zend_vm_stack prev) { size 151 Zend/zend_execute.c zend_vm_stack page = (zend_vm_stack)emalloc(size); size 154 Zend/zend_execute.c page->end = (zval*)((char*)page + size); size 178 Zend/zend_execute.c ZEND_API void* zend_vm_stack_extend(size_t size) size 186 Zend/zend_execute.c EXPECTED(size < ZEND_VM_STACK_FREE_PAGE_SIZE(0)) ? size 187 Zend/zend_execute.c ZEND_VM_STACK_PAGE_SIZE(0) : ZEND_VM_STACK_PAGE_ALIGNED_SIZE(0, size), size 190 Zend/zend_execute.c EG(vm_stack_top) = (void*)(((char*)ptr) + size); size 168 Zend/zend_execute.h ZEND_API void* zend_vm_stack_extend(size_t size); size 675 Zend/zend_execute_API.c fci.size = sizeof(fci); size 708 Zend/zend_execute_API.c switch (fci->size) { size 1027 Zend/zend_execute_API.c fcall_info.size = sizeof(fcall_info); size 274 Zend/zend_extensions.c size_t size; size 281 Zend/zend_extensions.c data->size += extension->op_array_persist_calc(data->op_array); size 288 Zend/zend_extensions.c size_t size = extension->op_array_persist(data->op_array, data->mem); size 289 Zend/zend_extensions.c if (size) { size 290 Zend/zend_extensions.c data->mem = (void*)((char*)data->mem + size); size 291 Zend/zend_extensions.c data->size += size; size 302 Zend/zend_extensions.c data.size = 0; size 305 Zend/zend_extensions.c return data.size; size 316 Zend/zend_extensions.c data.size = 0; size 319 Zend/zend_extensions.c return data.size; size 555 Zend/zend_hash.h static zend_always_inline void *zend_hash_add_mem(HashTable *ht, zend_string *key, void *pData, size_t size) size 561 Zend/zend_hash.h Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 562 Zend/zend_hash.h memcpy(Z_PTR_P(zv), pData, size); size 568 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_add_mem(HashTable *ht, const char *str, size_t len, void *pData, size_t size) size 574 Zend/zend_hash.h Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 575 Zend/zend_hash.h memcpy(Z_PTR_P(zv), pData, size); size 581 Zend/zend_hash.h static zend_always_inline void *zend_hash_update_mem(HashTable *ht, zend_string *key, void *pData, size_t size) size 585 Zend/zend_hash.h p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 586 Zend/zend_hash.h memcpy(p, pData, size); size 590 Zend/zend_hash.h static zend_always_inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, size_t len, void *pData, size_t size) size 594 Zend/zend_hash.h p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 595 Zend/zend_hash.h memcpy(p, pData, size); size 631 Zend/zend_hash.h static zend_always_inline void *zend_hash_index_add_mem(HashTable *ht, zend_ulong h, void *pData, size_t size) size 637 Zend/zend_hash.h Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 638 Zend/zend_hash.h memcpy(Z_PTR_P(zv), pData, size); size 658 Zend/zend_hash.h static zend_always_inline void *zend_hash_index_update_mem(HashTable *ht, zend_ulong h, void *pData, size_t size) size 662 Zend/zend_hash.h p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 663 Zend/zend_hash.h memcpy(p, pData, size); size 667 Zend/zend_hash.h static zend_always_inline void *zend_hash_next_index_insert_mem(HashTable *ht, void *pData, size_t size) size 673 Zend/zend_hash.h Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); size 674 Zend/zend_hash.h memcpy(Z_PTR_P(zv), pData, size); size 279 Zend/zend_ini_scanner.c size_t size; size 281 Zend/zend_ini_scanner.c if (zend_stream_fixup(fh, &buf, &size) == FAILURE) { size 290 Zend/zend_ini_scanner.c yy_scan_buffer(buf, (unsigned int)size); size 50 Zend/zend_interfaces.c fci.size = sizeof(fci); size 500 Zend/zend_language_scanner.c size_t size, offset = 0; size 510 Zend/zend_language_scanner.c if (zend_stream_fixup(file_handle, &buf, &size) == FAILURE) { size 526 Zend/zend_language_scanner.c if (size != -1) { size 529 Zend/zend_language_scanner.c SCNG(script_org_size) = size; size 540 Zend/zend_language_scanner.c size = SCNG(script_filtered_size); size 544 Zend/zend_language_scanner.c yy_scan_buffer(buf, (unsigned int)size); size 672 Zend/zend_language_scanner.c size_t size, old_len; size 685 Zend/zend_language_scanner.c size = old_len; size 689 Zend/zend_language_scanner.c SCNG(script_org_size) = size; size 700 Zend/zend_language_scanner.c size = SCNG(script_filtered_size); size 704 Zend/zend_language_scanner.c yy_scan_buffer(buf, (unsigned int)size); 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 38 Zend/zend_llist.c zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent); size 48 Zend/zend_llist.c memcpy(tmp->data, element, l->size); size 56 Zend/zend_llist.c zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent); size 66 Zend/zend_llist.c memcpy(tmp->data, element, l->size); size 155 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)) { size 197 Zend/zend_multibyte.c if (size == 0) { size 202 Zend/zend_multibyte.c if (FAILURE == zend_multibyte_set_script_encoding(list, size)) { size 122 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 130 Zend/zend_multiply.h "rm"(size), size 143 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 159 Zend/zend_multiply.h "rm"(size), size 173 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 181 Zend/zend_multiply.h "r"(size), size 195 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 203 Zend/zend_multiply.h "r"(size), size 216 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 227 Zend/zend_multiply.h "r"(size), size 240 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 242 Zend/zend_multiply.h uint64_t res = (uint64_t) nmemb * (uint64_t) size + (uint64_t) offset; size 254 Zend/zend_multiply.h static zend_always_inline size_t zend_safe_address(size_t nmemb, size_t size, size_t offset, int *overflow) size 256 Zend/zend_multiply.h size_t res = nmemb * size + offset; size 257 Zend/zend_multiply.h double _d = (double)nmemb * (double)size + (double)offset; size 33 Zend/zend_objects_API.c objects->size = init_size; size 122 Zend/zend_objects_API.c if (EG(objects_store).top == EG(objects_store).size) { size 123 Zend/zend_objects_API.c EG(objects_store).size <<= 1; size 124 Zend/zend_objects_API.c EG(objects_store).object_buckets = (zend_object **) erealloc(EG(objects_store).object_buckets, EG(objects_store).size * sizeof(zend_object*)); size 46 Zend/zend_objects_API.h uint32_t size; size 47 Zend/zend_opcode.c static void op_array_alloc_ops(zend_op_array *op_array, uint32_t size) size 49 Zend/zend_opcode.c op_array->opcodes = erealloc(op_array->opcodes, size * sizeof(zend_op)); size 346 Zend/zend_portability.h # define do_alloca_ex(size, limit, use_heap) \ size 347 Zend/zend_portability.h ((use_heap = (UNEXPECTED((size) > (limit)))) ? emalloc(size) : alloca(size)) size 348 Zend/zend_portability.h # define do_alloca(size, use_heap) \ size 349 Zend/zend_portability.h do_alloca_ex(size, ZEND_ALLOCA_MAX_SIZE, use_heap) size 436 Zend/zend_portability.h #define ZEND_SECURE_ZERO(var, size) RtlSecureZeroMemory((var), (size)) size 438 Zend/zend_portability.h #define ZEND_SECURE_ZERO(var, size) memset((var), 0, (size)) size 54 Zend/zend_range_check.h #define ZEND_SIZE_T_INT_OVFL(size) UNEXPECTED((size) > (size_t)INT_MAX) size 56 Zend/zend_range_check.h # define ZEND_SIZE_T_UINT_OVFL(size) UNEXPECTED((size) > (size_t)UINT_MAX) size 58 Zend/zend_range_check.h # define ZEND_SIZE_T_UINT_OVFL(size) (0) size 62 Zend/zend_range_check.h #define ZEND_SIZE_T_GT_ZEND_LONG(size, zlong) ((zlong) < 0 || (size) > (size_t)(zlong)) size 63 Zend/zend_range_check.h #define ZEND_SIZE_T_GTE_ZEND_LONG(size, zlong) ((zlong) < 0 || (size) >= (size_t)(zlong)) size 64 Zend/zend_range_check.h #define ZEND_SIZE_T_LT_ZEND_LONG(size, zlong) ((zlong) >= 0 && (size) < (size_t)(zlong)) size 65 Zend/zend_range_check.h #define ZEND_SIZE_T_LTE_ZEND_LONG(size, zlong) ((zlong) >= 0 && (size) <= (size_t)(zlong)) size 25 Zend/zend_stack.c #define ZEND_STACK_ELEMENT(stack, n) ((void *)((char *) (stack)->elements + (stack)->size * (n))) size 27 Zend/zend_stack.c ZEND_API int zend_stack_init(zend_stack *stack, int size) size 29 Zend/zend_stack.c stack->size = size; size 41 Zend/zend_stack.c stack->elements = safe_erealloc(stack->elements, stack->size, stack->max, 0); size 43 Zend/zend_stack.c memcpy(ZEND_STACK_ELEMENT(stack, stack->top), element, stack->size); size 26 Zend/zend_stack.h int size, top, max; size 34 Zend/zend_stack.h ZEND_API int zend_stack_init(zend_stack *stack, int size); size 182 Zend/zend_stream.c size_t size; size 221 Zend/zend_stream.c size = zend_stream_fsize(file_handle); size 222 Zend/zend_stream.c if (size == (size_t)-1) { size 229 Zend/zend_stream.c if (old_type == ZEND_HANDLE_FP && !file_handle->handle.stream.isatty && size) { size 234 Zend/zend_stream.c size != 0 && size 235 Zend/zend_stream.c ((size - 1) % page_size) <= page_size - ZEND_MMAP_AHEAD) { size 237 Zend/zend_stream.c *buf = mmap(0, size + ZEND_MMAP_AHEAD, PROT_READ, MAP_PRIVATE, fileno(file_handle->handle.fp), 0); size 244 Zend/zend_stream.c size -= offset; size 247 Zend/zend_stream.c file_handle->handle.stream.mmap.len = size; size 254 Zend/zend_stream.c file_handle->handle.stream.mmap.buf = *buf = safe_emalloc(1, size, ZEND_MMAP_AHEAD); size 255 Zend/zend_stream.c file_handle->handle.stream.mmap.len = zend_stream_read(file_handle, *buf, size); size 259 Zend/zend_stream.c size = 0; size 261 Zend/zend_stream.c while ((read = zend_stream_read(file_handle, *buf + size, remain)) > 0) { size 262 Zend/zend_stream.c size += read; size 266 Zend/zend_stream.c *buf = safe_erealloc(*buf, size, 2, 0); size 267 Zend/zend_stream.c remain = size; size 271 Zend/zend_stream.c file_handle->handle.stream.mmap.len = size; size 272 Zend/zend_stream.c if (size && remain < ZEND_MMAP_AHEAD) { size 273 Zend/zend_stream.c *buf = safe_erealloc(*buf, size, 1, ZEND_MMAP_AHEAD); size 570 Zend/zend_virtual_cwd.c CWD_API char *virtual_getcwd(char *buf, size_t size) /* {{{ */ size 580 Zend/zend_virtual_cwd.c if (length > size-1) { size 678 Zend/zend_virtual_cwd.c zend_long size = sizeof(realpath_cache_bucket) + path_len + 1; size 683 Zend/zend_virtual_cwd.c size += realpath_len + 1; size 687 Zend/zend_virtual_cwd.c if (CWDG(realpath_cache_size) + size <= CWDG(realpath_cache_size_limit)) { size 688 Zend/zend_virtual_cwd.c realpath_cache_bucket *bucket = malloc(size); size 717 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); size 260 Zend/zend_virtual_cwd.h #define VCWD_GETCWD(buff, size) virtual_getcwd(buff, size) size 292 Zend/zend_virtual_cwd.h #define VCWD_GETCWD(buff, size) getcwd(buff, size) size 5255 Zend/zend_vm_def.h uint32_t size; size 5260 Zend/zend_vm_def.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 5262 Zend/zend_vm_def.h size = 0; size 5265 Zend/zend_vm_def.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 6089 Zend/zend_vm_execute.h uint32_t size; size 6094 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 6096 Zend/zend_vm_execute.h size = 0; size 6099 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 7903 Zend/zend_vm_execute.h uint32_t size; size 7908 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 7910 Zend/zend_vm_execute.h size = 0; size 7913 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 9778 Zend/zend_vm_execute.h uint32_t size; size 9783 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 9785 Zend/zend_vm_execute.h size = 0; size 9788 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 11552 Zend/zend_vm_execute.h uint32_t size; size 11557 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 11559 Zend/zend_vm_execute.h size = 0; size 11562 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 13005 Zend/zend_vm_execute.h uint32_t size; size 13010 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 13012 Zend/zend_vm_execute.h size = 0; size 13015 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 13729 Zend/zend_vm_execute.h uint32_t size; size 13734 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 13736 Zend/zend_vm_execute.h size = 0; size 13739 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 14278 Zend/zend_vm_execute.h uint32_t size; size 14283 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 14285 Zend/zend_vm_execute.h size = 0; size 14288 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 14792 Zend/zend_vm_execute.h uint32_t size; size 14797 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 14799 Zend/zend_vm_execute.h size = 0; size 14802 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 17878 Zend/zend_vm_execute.h uint32_t size; size 17883 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 17885 Zend/zend_vm_execute.h size = 0; size 17888 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 19463 Zend/zend_vm_execute.h uint32_t size; size 19468 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 19470 Zend/zend_vm_execute.h size = 0; size 19473 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 21034 Zend/zend_vm_execute.h uint32_t size; size 21039 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 21041 Zend/zend_vm_execute.h size = 0; size 21044 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 22611 Zend/zend_vm_execute.h uint32_t size; size 22616 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 22618 Zend/zend_vm_execute.h size = 0; size 22621 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 23993 Zend/zend_vm_execute.h uint32_t size; size 23998 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 24000 Zend/zend_vm_execute.h size = 0; size 24003 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 25138 Zend/zend_vm_execute.h uint32_t size; size 25143 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 25145 Zend/zend_vm_execute.h size = 0; size 25148 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 26301 Zend/zend_vm_execute.h uint32_t size; size 26306 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 26308 Zend/zend_vm_execute.h size = 0; size 26311 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 27794 Zend/zend_vm_execute.h uint32_t size; size 27799 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 27801 Zend/zend_vm_execute.h size = 0; size 27804 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 32224 Zend/zend_vm_execute.h uint32_t size; size 32229 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 32231 Zend/zend_vm_execute.h size = 0; size 32234 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 34756 Zend/zend_vm_execute.h uint32_t size; size 34761 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 34763 Zend/zend_vm_execute.h size = 0; size 34766 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 37308 Zend/zend_vm_execute.h uint32_t size; size 37313 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 37315 Zend/zend_vm_execute.h size = 0; size 37318 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); size 39889 Zend/zend_vm_execute.h uint32_t size; size 39894 Zend/zend_vm_execute.h size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; size 39896 Zend/zend_vm_execute.h size = 0; size 39899 Zend/zend_vm_execute.h zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); 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 565 ext/bz2/bz2.c unsigned __int64 size = 0; size 567 ext/bz2/bz2.c unsigned long long size = 0; size 592 ext/bz2/bz2.c size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32; size 593 ext/bz2/bz2.c dest = safe_erealloc(dest, 1, bzs.avail_out+1, (size_t) size ); size 594 ext/bz2/bz2.c bzs.next_out = dest + size; size 598 ext/bz2/bz2.c size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32; size 599 ext/bz2/bz2.c dest = safe_erealloc(dest, 1, (size_t) size, 1); size 600 ext/bz2/bz2.c dest[size] = '\0'; size 601 ext/bz2/bz2.c RETVAL_STRINGL(dest, (int) size); 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 486 ext/com_dotnet/com_persist.c ULARGE_INTEGER size; size 493 ext/com_dotnet/com_persist.c res = IPersistStreamInit_GetSizeMax(helper->ipsi, &size); size 497 ext/com_dotnet/com_persist.c res = IPersistStream_GetSizeMax(helper->ips, &size); size 508 ext/com_dotnet/com_persist.c RETURN_LONG((zend_long)size.QuadPart); size 1300 ext/curl/interface.c static size_t curl_write_nothing(char *data, size_t size, size_t nmemb, void *ctx) size 1302 ext/curl/interface.c return size * nmemb; size 1308 ext/curl/interface.c static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) size 1312 ext/curl/interface.c size_t length = size * nmemb; size 1316 ext/curl/interface.c fprintf(stderr, "data = %s, size = %d, nmemb = %d, ctx = %x\n", data, size, nmemb, ctx); size 1324 ext/curl/interface.c return fwrite(data, size, nmemb, t->fp); size 1340 ext/curl/interface.c fci.size = sizeof(fci); size 1391 ext/curl/interface.c fci.size = sizeof(fci); size 1448 ext/curl/interface.c fci.size = sizeof(fci); size 1483 ext/curl/interface.c static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) size 1492 ext/curl/interface.c length = fread(data, size, nmemb, t->fp); size 1509 ext/curl/interface.c ZVAL_LONG(&argv[2], (int)size * nmemb); size 1511 ext/curl/interface.c fci.size = sizeof(fci); size 1532 ext/curl/interface.c length = MIN((int) (size * nmemb), Z_STRLEN(retval)); size 1551 ext/curl/interface.c static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx) size 1555 ext/curl/interface.c size_t length = size * nmemb; size 1568 ext/curl/interface.c return fwrite(data, size, nmemb, t->fp); size 1579 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 52 ext/dba/dba_db3.c gkey.data = (char *) key; gkey.size = keylen size 140 ext/dba/dba_db3.c if (newlen) *newlen = gval.size; size 141 ext/dba/dba_db3.c new = estrndup(gval.data, gval.size); size 154 ext/dba/dba_db3.c gval.size = vallen; size 212 ext/dba/dba_db3.c nkey = estrndup(gkey.data, gkey.size); size 213 ext/dba/dba_db3.c if (newlen) *newlen = gkey.size; size 66 ext/dba/dba_db4.c gkey.data = (char *) key; gkey.size = keylen size 172 ext/dba/dba_db4.c if (newlen) *newlen = gval.size; size 173 ext/dba/dba_db4.c new = estrndup(gval.data, gval.size); size 189 ext/dba/dba_db4.c gval.size = vallen; size 259 ext/dba/dba_db4.c nkey = estrndup(gkey.data, gkey.size); size 260 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) 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 1617 ext/dom/document.c int size, format, saveempty = 0; size 1662 ext/dom/document.c xmlDocDumpFormatMemory(docp, &mem, &size, format); size 1666 ext/dom/document.c if (!size) { size 1669 ext/dom/document.c RETVAL_STRINGL((char *) mem, size); size 2156 ext/dom/document.c int size = 0, format; size 2191 ext/dom/document.c size += one_size; size 2193 ext/dom/document.c size = -1; size 2198 ext/dom/document.c size = htmlNodeDump(buf, docp, node); size 2200 ext/dom/document.c if (size >= 0) { size 2205 ext/dom/document.c RETVAL_STRINGL((const char*) mem, size); size 2214 ext/dom/document.c htmlDocDumpMemoryFormat(docp, &mem, &size, format); size 2216 ext/dom/document.c htmlDocDumpMemory(docp, &mem, &size); size 2218 ext/dom/document.c if (!size) { size 2221 ext/dom/document.c RETVAL_STRINGL((const char*) mem, size); size 173 ext/dom/xpath.c fci.size = sizeof(fci); size 1477 ext/exif/exif.c size_t size; size 1489 ext/exif/exif.c size_t size; size 1496 ext/exif/exif.c size_t size; size 1592 ext/exif/exif.c static int exif_file_sections_add(image_info_type *ImageInfo, int type, size_t size, uchar *data) size 1601 ext/exif/exif.c ImageInfo->file.list[count].size = 0; size 1603 ext/exif/exif.c if (!size) { size 1606 ext/exif/exif.c data = safe_emalloc(size, 1, 0); size 1610 ext/exif/exif.c ImageInfo->file.list[count].size = size; size 1618 ext/exif/exif.c static int exif_file_sections_realloc(image_info_type *ImageInfo, int section_index, size_t size) size 1629 ext/exif/exif.c tmp = safe_erealloc(ImageInfo->file.list[section_index].data, 1, size, 0); size 1631 ext/exif/exif.c ImageInfo->file.list[section_index].size = size; size 2437 ext/exif/exif.c if (!ImageInfo->read_thumbnail || !ImageInfo->Thumbnail.offset || !ImageInfo->Thumbnail.size) { size 2464 ext/exif/exif.c new_data = safe_erealloc(ImageInfo->Thumbnail.data, 1, ImageInfo->Thumbnail.size, new_size); size 2466 ext/exif/exif.c memmove(ImageInfo->Thumbnail.data + new_move, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 2467 ext/exif/exif.c ImageInfo->Thumbnail.size += new_size; size 2527 ext/exif/exif.c if (ImageInfo->Thumbnail.size >= 65536 size 2528 ext/exif/exif.c || ImageInfo->Thumbnail.size <= 0 size 2535 ext/exif/exif.c if ((ImageInfo->Thumbnail.offset + ImageInfo->Thumbnail.size) > length) { size 2539 ext/exif/exif.c ImageInfo->Thumbnail.data = estrndup(offset + ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size); size 2690 ext/exif/exif.c &xp_field->size, size 2696 ext/exif/exif.c xp_field->size = exif_process_string_raw(&xp_field->value, szValuePtr, ByteCount); size 2698 ext/exif/exif.c return xp_field->size; size 2928 ext/exif/exif.c ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, format, ImageInfo->motorola_intel); size 2934 ext/exif/exif.c ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, format, ImageInfo->motorola_intel); size 3154 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail size: 0x%04X", ImageInfo->Thumbnail.size); size 3157 ext/exif/exif.c && ImageInfo->Thumbnail.size size 3263 ext/exif/exif.c size_t fpos, size, got, itemlen; size 3349 ext/exif/exif.c size = ImageInfo->FileSize - fpos; size 3350 ext/exif/exif.c sn = exif_file_sections_add(ImageInfo, M_PSEUDO, size, NULL); size 3352 ext/exif/exif.c got = php_stream_read(ImageInfo->infile, (char*)Data, size); size 3353 ext/exif/exif.c if (got != size) { size 3443 ext/exif/exif.c if (pos>=ImageInfo->Thumbnail.size) size 3446 ext/exif/exif.c if (pos>=ImageInfo->Thumbnail.size) size 3453 ext/exif/exif.c if (pos+3>=ImageInfo->Thumbnail.size) size 3461 ext/exif/exif.c if (pos+length>=ImageInfo->Thumbnail.size) { size 3614 ext/exif/exif.c if (ImageInfo->FileSize >= dir_offset + ImageInfo->file.list[sn].size) { size 3669 ext/exif/exif.c && ImageInfo->Thumbnail.size size 3674 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 3677 ext/exif/exif.c ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0); size 3679 ext/exif/exif.c fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 3680 ext/exif/exif.c if (fgot < ImageInfo->Thumbnail.size) { size 3708 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 3710 ext/exif/exif.c if (!ImageInfo->Thumbnail.data && ImageInfo->Thumbnail.offset && ImageInfo->Thumbnail.size && ImageInfo->read_thumbnail) { size 3711 ext/exif/exif.c ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0); size 3713 ext/exif/exif.c fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size); size 3714 ext/exif/exif.c if (fgot < ImageInfo->Thumbnail.size) { size 3725 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 4034 ext/exif/exif.c if (ImageInfo.Thumbnail.size) { size 4037 ext/exif/exif.c exif_iif_add_tag(&ImageInfo, SECTION_THUMBNAIL, "THUMBNAIL", TAG_NONE, TAG_FMT_UNDEFINED, ImageInfo.Thumbnail.size, ImageInfo.Thumbnail.data); size 4109 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 4111 ext/exif/exif.c if (!ImageInfo.Thumbnail.data || !ImageInfo.Thumbnail.size) { size 4117 ext/exif/exif.c exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Returning thumbnail(%d)", ImageInfo.Thumbnail.size); size 4120 ext/exif/exif.c ZVAL_STRINGL(return_value, ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size); size 475 ext/fileinfo/libmagic/cdf.c cdf_count_chain(const cdf_sat_t *sat, cdf_secid_t sid, size_t size) size 478 ext/fileinfo/libmagic/cdf.c cdf_secid_t maxsector = (cdf_secid_t)((sat->sat_len * size) size 1214 ext/fileinfo/libmagic/cdf.c cdf_dump_sat(const char *prefix, const cdf_sat_t *sat, size_t size) size 1216 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 162 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 164 ext/filter/filter.c for (i = 0; i < size; ++i) { size 340 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 342 ext/filter/filter.c for (i = 0; i < size; ++i) { size 348 ext/filter/filter.c for (i = 0; i < size; ++i) { size 864 ext/filter/filter.c int i, size = sizeof(filter_list) / sizeof(filter_list_entry); size 871 ext/filter/filter.c for (i = 0; i < size; ++i) { size 883 ext/filter/filter.c int size = sizeof(filter_list) / sizeof(filter_list_entry); size 890 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 651 ext/ftp/ftp.c ftp_alloc(ftpbuf_t *ftp, const zend_long size, zend_string **response) size 655 ext/ftp/ftp.c if (ftp == NULL || size <= 0) { size 659 ext/ftp/ftp.c snprintf(buffer, sizeof(buffer) - 1, ZEND_LONG_FMT, size); size 923 ext/ftp/ftp.c zend_long size; size 959 ext/ftp/ftp.c size = 0; size 963 ext/ftp/ftp.c if (FTP_BUFSIZE - size < 2) { size 964 ext/ftp/ftp.c if (my_send(ftp, data->fd, data->buf, size) != size) { size 968 ext/ftp/ftp.c size = 0; size 973 ext/ftp/ftp.c size++; size 977 ext/ftp/ftp.c size++; size 980 ext/ftp/ftp.c if (size && my_send(ftp, data->fd, data->buf, size) != size) { size 1133 ext/ftp/ftp.c int size; size 1148 ext/ftp/ftp.c size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s %s\r\n", cmd, args); size 1154 ext/ftp/ftp.c size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s\r\n", cmd); size 1162 ext/ftp/ftp.c if (my_send(ftp, ftp->fd, data, size) != size) { size 1174 ext/ftp/ftp.c long size, rcvd; size 1178 ext/ftp/ftp.c size = FTP_BUFSIZE; size 1188 ext/ftp/ftp.c size -= rcvd; size 1212 ext/ftp/ftp.c if ((rcvd = my_recv(ftp, ftp->fd, data, size)) < 1) { size 1215 ext/ftp/ftp.c } while (size); size 1264 ext/ftp/ftp.c zend_long size, sent; size 1274 ext/ftp/ftp.c size = len; size 1275 ext/ftp/ftp.c while (size) { size 1302 ext/ftp/ftp.c sent = SSL_write(handle, buf, size); size 1337 ext/ftp/ftp.c sent = send(s, buf, size, 0); size 1346 ext/ftp/ftp.c size -= sent; size 1517 ext/ftp/ftp.c socklen_t size; size 1547 ext/ftp/ftp.c size = php_sockaddr_size(&ftp->pasvaddr); size 1550 ext/ftp/ftp.c if (php_connect_nonb(fd, (struct sockaddr*) &ftp->pasvaddr, size, &tv) == -1) { size 1566 ext/ftp/ftp.c size = php_sockaddr_size(&addr); size 1568 ext/ftp/ftp.c if (bind(fd, (struct sockaddr*) &addr, size) != 0) { size 1573 ext/ftp/ftp.c if (getsockname(fd, (struct sockaddr*) &addr, &size) != 0) { size 1636 ext/ftp/ftp.c socklen_t size; size 1648 ext/ftp/ftp.c size = sizeof(addr); size 1649 ext/ftp/ftp.c data->fd = my_accept(ftp, data->listener, (struct sockaddr*) &addr, &size); size 1789 ext/ftp/ftp.c size_t size, rcvd; size 1828 ext/ftp/ftp.c size = 0; size 1832 ext/ftp/ftp.c if (rcvd == -1 || rcvd > ((size_t)(-1))-size) { size 1838 ext/ftp/ftp.c size += rcvd; size 1851 ext/ftp/ftp.c ret = safe_emalloc((lines + 1), sizeof(char*), size); size 2057 ext/ftp/ftp.c long size; size 2066 ext/ftp/ftp.c size = 0; size 2072 ext/ftp/ftp.c size++; size 2076 ext/ftp/ftp.c size++; size 2079 ext/ftp/ftp.c if (FTP_BUFSIZE - size < 2) { size 2080 ext/ftp/ftp.c if (my_send(ftp, ftp->data->fd, ftp->data->buf, size) != size) { size 2087 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 zend_long size, zend_string **response); size 109 ext/ftp/php_ftp.c ZEND_ARG_INFO(0, size) size 669 ext/ftp/php_ftp.c zend_long size, ret; size 672 ext/ftp/php_ftp.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|z/", &z_ftp, &size, &zresponse) == FAILURE) { size 680 ext/ftp/php_ftp.c ret = ftp_alloc(ftp, size, zresponse ? &response : NULL); size 688 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 697 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 709 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 717 ext/gd/gd.c ZEND_ARG_INFO(0, size) size 3402 ext/gd/gd.c static gdFontPtr php_find_gd_font(int size) size 3406 ext/gd/gd.c switch (size) { size 3423 ext/gd/gd.c zval *zv = zend_hash_index_find(&EG(regular_list), size - 5); size 3425 ext/gd/gd.c if (size < 1) { size 3514 ext/gd/gd.c int ch = 0, col, x, y, size, i, l = 0; size 3537 ext/gd/gd.c size = SIZE; size 3539 ext/gd/gd.c font = php_find_gd_font(size); 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 26 ext/gd/libgd/gd_webp.c gdImagePtr gdImageCreateFromWebpPtr (int size, void *data) size 29 ext/gd/libgd/gd_webp.c gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); size 42 ext/gd/libgd/gd_webp.c size_t size = 0, n; size 50 ext/gd/libgd/gd_webp.c temp = gdRealloc(filedata, size+GD_WEBP_ALLOC_STEP); size 53 ext/gd/libgd/gd_webp.c read = temp + size; size 64 ext/gd/libgd/gd_webp.c size += n; size 68 ext/gd/libgd/gd_webp.c if (WebPGetInfo(filedata,size, &width, &height) == 0) { size 79 ext/gd/libgd/gd_webp.c argb = WebPDecodeARGB(filedata, size, &width, &height); size 171 ext/gd/libgd/gd_webp.c void * gdImageWebpPtr (gdImagePtr im, int *size) size 176 ext/gd/libgd/gd_webp.c rv = gdDPExtractData(out, size); size 182 ext/gd/libgd/gd_webp.c void * gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization) size 187 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 980 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 1048 ext/gmp/gmp.c int gmp_import_export_validate(zend_long size, zend_long options, int *order, int *endian) size 1050 ext/gmp/gmp.c if (size < 1) { size 1052 ext/gmp/gmp.c "Word size must be positive, %pd given", size); size 1096 ext/gmp/gmp.c zend_long size = 1; size 1101 ext/gmp/gmp.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &data, &data_len, &size, &options) == FAILURE) { size 1105 ext/gmp/gmp.c if (gmp_import_export_validate(size, options, &order, &endian) == FAILURE) { size 1109 ext/gmp/gmp.c if ((data_len % size) != 0) { size 1117 ext/gmp/gmp.c mpz_import(gmpnumber, data_len / size, order, size, endian, 0, data); size 1126 ext/gmp/gmp.c zend_long size = 1; size 1132 ext/gmp/gmp.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|ll", &gmpnumber_arg, &size, &options) == FAILURE) { size 1136 ext/gmp/gmp.c if (gmp_import_export_validate(size, options, &order, &endian) == FAILURE) { size 1145 ext/gmp/gmp.c size_t bits_per_word = size * 8; size 1147 ext/gmp/gmp.c size_t out_len = count * size; size 1150 ext/gmp/gmp.c mpz_export(ZSTR_VAL(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 1493 ext/imap/php_imap.c limits.text.size = mailbox_size; size 2743 ext/imap/php_imap.c src.size = 0; size 2745 ext/imap/php_imap.c dest.size = 0; size 2754 ext/imap/php_imap.c RETVAL_STRINGL((char*)dest.data, dest.size); size 3375 ext/imap/php_imap.c if (body->size.lines) { size 3376 ext/imap/php_imap.c add_property_long(return_value, "lines", body->size.lines); size 3378 ext/imap/php_imap.c if (body->size.bytes) { size 3379 ext/imap/php_imap.c add_property_long(return_value, "bytes", body->size.bytes); size 3681 ext/imap/php_imap.c bod->contents.text.size = Z_STRLEN_P(pvalue); size 3685 ext/imap/php_imap.c bod->contents.text.size = 0; size 3689 ext/imap/php_imap.c bod->size.lines = Z_LVAL_P(pvalue); size 3693 ext/imap/php_imap.c bod->size.bytes = Z_LVAL_P(pvalue); size 3785 ext/imap/php_imap.c bod->contents.text.size = Z_STRLEN_P(pvalue); size 3789 ext/imap/php_imap.c bod->contents.text.size = 0; size 3793 ext/imap/php_imap.c bod->size.lines = Z_LVAL_P(pvalue); size 3797 ext/imap/php_imap.c bod->size.bytes = Z_LVAL_P(pvalue); size 4605 ext/imap/php_imap.c if (body->size.lines) { size 4606 ext/imap/php_imap.c add_property_long(arg, "lines", body->size.lines); size 4609 ext/imap/php_imap.c if (body->size.bytes) { size 4610 ext/imap/php_imap.c add_property_long(arg, "bytes", body->size.bytes); size 4828 ext/imap/php_imap.c static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md) /* {{{ */ size 4836 ext/imap/php_imap.c while (size) { size 4839 ext/imap/php_imap.c if (size > GETS_FETCH_SIZE) { size 4841 ext/imap/php_imap.c size -=GETS_FETCH_SIZE; size 4843 ext/imap/php_imap.c read = size; size 4844 ext/imap/php_imap.c size = 0; size 4857 ext/imap/php_imap.c char *buf = pemalloc(size + 1, 1); size 4859 ext/imap/php_imap.c if (f(stream, size, buf)) { size 4860 ext/imap/php_imap.c buf[size] = '\0'; size 55 ext/imap/php_imap.h #define LSIZE text.size size 62 ext/imap/php_imap.h #define LSIZE size size 539 ext/interbase/ibase_blobs.c int size; size 564 ext/interbase/ibase_blobs.c for (size = 0; (b = php_stream_read(stream, bl_data, sizeof(bl_data))); size += b) { size 746 ext/intl/grapheme/grapheme_string.c grapheme_extract_count_iter(UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len) size 751 ext/intl/grapheme/grapheme_string.c while ( size ) { size 758 ext/intl/grapheme/grapheme_string.c size--; size 789 ext/intl/grapheme/grapheme_string.c zend_long size; /* maximum number of grapheme clusters, bytes, or characters (based on extract_type) to return */ size 799 ext/intl/grapheme/grapheme_string.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|llz", &str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) { size 830 ext/intl/grapheme/grapheme_string.c if ( size > INT32_MAX || size < 0) { size 834 ext/intl/grapheme/grapheme_string.c if (size == 0) { size 864 ext/intl/grapheme/grapheme_string.c if ( -1 != grapheme_ascii_check((unsigned char *)pstr, MIN(size + 1, str_len)) ) { size 865 ext/intl/grapheme/grapheme_string.c size_t nsize = MIN(size, str_len); size 902 ext/intl/grapheme/grapheme_string.c ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, (unsigned char *)pstr, (int32_t)str_len); size 33 ext/intl/intl_common.h # define eumalloc(size) (UChar*)safe_emalloc(size, sizeof(UChar), 0) size 37 ext/intl/intl_common.h # define eurealloc(ptr, size) (UChar*)erealloc((ptr), size * sizeof(UChar)) size 70 ext/json/json_scanner.c static int php_json_ucs2_to_int_ex(php_json_scanner *s, int size, int start) size 74 ext/json/json_scanner.c for (i = 0; i < size; i++) { size 80 ext/json/json_scanner.c static int php_json_ucs2_to_int(php_json_scanner *s, int size) size 82 ext/json/json_scanner.c return php_json_ucs2_to_int_ex(s, size, 1); size 281 ext/libxml/libxml.c libxml_globals->entity_loader.fci.size = 0; size 287 ext/libxml/libxml.c if (fci->size > 0) { size 289 ext/libxml/libxml.c fci->size = 0; size 586 ext/libxml/libxml.c if (fci->size == 0) { size 1123 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 690 ext/mbstring/mbstring.c int size, bauto, ret = SUCCESS; size 723 ext/mbstring/mbstring.c size = n + MBSTRG(default_detect_order_list_size); size 725 ext/mbstring/mbstring.c list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent); size 768 ext/mbstring/mbstring.c } while (n < size && p2 != NULL); size 811 ext/mbstring/mbstring.c int i, n, size, bauto, ret = SUCCESS; size 818 ext/mbstring/mbstring.c size = i + MBSTRG(default_detect_order_list_size); size 819 ext/mbstring/mbstring.c list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent); size 1223 ext/mbstring/mbstring.c size_t size; size 1234 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(ZSTR_VAL(new_value), ZSTR_LEN(new_value), &list, &size, 1)) { size 1242 ext/mbstring/mbstring.c MBSTRG(detect_order_list_size) = size; size 1251 ext/mbstring/mbstring.c size_t size; size 1257 ext/mbstring/mbstring.c if (SUCCESS == php_mb_parse_encoding_list(get_input_encoding(), strlen(get_input_encoding())+1, &list, &size, 1)) { size 1259 ext/mbstring/mbstring.c MBSTRG(http_input_list_size) = size; size 1267 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(ZSTR_VAL(new_value), ZSTR_LEN(new_value), &list, &size, 1)) { size 1275 ext/mbstring/mbstring.c MBSTRG(http_input_list_size) = size; size 1940 ext/mbstring/mbstring.c size_t size = 0; size 1943 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_array(arg1, &list, &size, 0)) { size 1952 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), &list, &size, 0)) { size 1969 ext/mbstring/mbstring.c MBSTRG(current_detect_order_list_size) = size; size 3116 ext/mbstring/mbstring.c size_t size; size 3149 ext/mbstring/mbstring.c size = 0; size 3150 ext/mbstring/mbstring.c php_mb_parse_encoding_list(_from_encodings, strlen(_from_encodings), &list, &size, 0); size 3151 ext/mbstring/mbstring.c if (size == 1) { size 3154 ext/mbstring/mbstring.c } else if (size > 1) { size 3156 ext/mbstring/mbstring.c from_encoding = mbfl_identify_encoding2(&string, list, size, MBSTRG(strict_detection)); size 3204 ext/mbstring/mbstring.c size_t size, l, n; size 3249 ext/mbstring/mbstring.c ret = php_mb_convert_encoding(arg_str, str_len, arg_new, _from_encodings, &size); size 3252 ext/mbstring/mbstring.c RETVAL_STRINGL(ret, size); /* the string is already strdup()'ed */ size 3357 ext/mbstring/mbstring.c size_t size; size 3365 ext/mbstring/mbstring.c size = 0; size 3369 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_array(encoding_list, &list, &size, 0)) { size 3373 ext/mbstring/mbstring.c size = 0; size 3379 ext/mbstring/mbstring.c if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_P(encoding_list), Z_STRLEN_P(encoding_list), &list, &size, 0)) { size 3383 ext/mbstring/mbstring.c size = 0; size 3388 ext/mbstring/mbstring.c if (size <= 0) { size 3397 ext/mbstring/mbstring.c if (size > 0 && list != NULL) { size 3401 ext/mbstring/mbstring.c size = MBSTRG(current_detect_order_list_size); size 3408 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 353 ext/mbstring/oniguruma/regint.h #define BBUF_INIT(buf,size) onig_bbuf_init((BBuf* )(buf), (size)) size 367 ext/mbstring/oniguruma/regint.h #define BBUF_ENSURE_SIZE(buf,size) do{\ size 369 ext/mbstring/oniguruma/regint.h while (new_alloc < (unsigned int )(size)) { new_alloc *= 2; }\ size 790 ext/mbstring/oniguruma/regint.h extern int onig_bbuf_init P_((BBuf* buf, int size)); size 807 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 204 ext/mcrypt/mcrypt.c ZEND_ARG_INFO(0, size) size 1345 ext/mcrypt/mcrypt.c zend_long size; size 1348 ext/mcrypt/mcrypt.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &size, &source) == FAILURE) { size 1352 ext/mcrypt/mcrypt.c if (size <= 0 || size >= INT_MAX) { size 1357 ext/mcrypt/mcrypt.c iv = ecalloc(size + 1, 1); size 1363 ext/mcrypt/mcrypt.c if (php_win32_get_random_bytes(iv_b, (size_t) size) == FAILURE){ size 1368 ext/mcrypt/mcrypt.c n = (int)size; size 1382 ext/mcrypt/mcrypt.c while (read_bytes < size) { size 1383 ext/mcrypt/mcrypt.c n = read(*fd, iv + read_bytes, size - read_bytes); size 1391 ext/mcrypt/mcrypt.c if (n < size) { size 1398 ext/mcrypt/mcrypt.c n = (int)size; size 1399 ext/mcrypt/mcrypt.c while (size) { size 1400 ext/mcrypt/mcrypt.c iv[--size] = (char) (255.0 * php_rand() / RAND_MAX); size 1293 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) 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_emalloc(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_emalloc(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_erealloc(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) 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_emalloc(size); size 143 ext/mysqlnd/mysqlnd_block_alloc.c pool->free_size -= size; size 552 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); size 59 ext/mysqlnd/mysqlnd_structs.h enum_func_status (*resize_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size); size 61 ext/mysqlnd/mysqlnd_structs.h unsigned int size; size 279 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))) { \ 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 289 ext/mysqlnd/mysqlnd_wireprotocol.c header->size = uint3korr(buffer); size 293 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_INF_FMT("HEADER: prot_packet_no=%u size=%3u", header->packet_no, header->size); size 310 ext/mysqlnd/mysqlnd_wireprotocol.c net->packet_no, header->packet_no, header->size); size 313 ext/mysqlnd/mysqlnd_wireprotocol.c net->packet_no, header->packet_no, header->size); size 337 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size < sizeof(buf)) { size 342 ext/mysqlnd/mysqlnd_wireprotocol.c buf[packet->header.size] = '\0'; size 350 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 398 ext/mysqlnd/mysqlnd_wireprotocol.c if ((size_t) (p - buf) < packet->header.size) { size 408 ext/mysqlnd/mysqlnd_wireprotocol.c if ((size_t) (p - buf) < packet->header.size) { size 447 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("GREET packet %d bytes shorter than expected", p - begin - packet->header.size); size 449 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 700 ext/mysqlnd/mysqlnd_wireprotocol.c buf[packet->header.size] = '\0'; size 708 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 716 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf)) { size 721 ext/mysqlnd/mysqlnd_wireprotocol.c packet->new_auth_protocol_data_len = packet->header.size - (size_t) (p - buf); size 746 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (i = php_mysqlnd_net_field_length(&p))) { size 761 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 763 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 863 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 886 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (i = php_mysqlnd_net_field_length(&p))) { size 902 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 904 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 953 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 965 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > 1) { size 985 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("EOF packet %d bytes shorter than expected", p - begin - packet->header.size); size 987 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 1106 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 1127 ext/mysqlnd/mysqlnd_wireprotocol.c len = packet->header.size - 1; size 1154 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && (len = php_mysqlnd_net_field_length(&p))) { size 1178 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("RSET_HEADER packet %d bytes shorter than expected", p - begin - packet->header.size); size 1180 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 1248 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 1254 ext/mysqlnd/mysqlnd_wireprotocol.c } else if (EODATA_MARKER == *p && packet->header.size < 8) { size 1331 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size > (size_t) (p - buf) && size 1413 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("RSET field packet %d bytes shorter than expected", p - begin - packet->header.size); size 1415 ext/mysqlnd/mysqlnd_wireprotocol.c "shorter than expected", p - begin - packet->header.size); size 1463 ext/mysqlnd/mysqlnd_wireprotocol.c *data_size += header.size; size 1475 ext/mysqlnd/mysqlnd_wireprotocol.c if (!header.size) { size 1488 ext/mysqlnd/mysqlnd_wireprotocol.c p = (*buffer)->ptr + (*data_size - header.size); size 1491 ext/mysqlnd/mysqlnd_wireprotocol.c if (PASS != (ret = conn->net->data->m.receive_ex(conn->net, p, header.size, conn->stats, conn->error_info))) { size 1497 ext/mysqlnd/mysqlnd_wireprotocol.c if (header.size < MYSQLND_MAX_PACKET_SIZE) { size 1810 ext/mysqlnd/mysqlnd_wireprotocol.c MYSQLND_HEADER_SIZE + packet->header.size, size 1815 ext/mysqlnd/mysqlnd_wireprotocol.c packet->header.size = data_size; size 1918 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message = mnd_emalloc(packet->header.size + 1); size 1919 ext/mysqlnd/mysqlnd_wireprotocol.c memcpy(packet->message, buf, packet->header.size); size 1920 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message[packet->header.size] = '\0'; size 1921 ext/mysqlnd/mysqlnd_wireprotocol.c packet->message_len = packet->header.size; size 1965 ext/mysqlnd/mysqlnd_wireprotocol.c data_size = packet->header.size; size 2016 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("PREPARE packet %d bytes shorter than expected", p - begin - packet->header.size); size 2018 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 2061 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->header.size == 1 && buf[0] == EODATA_MARKER && packet->server_capabilities & CLIENT_SECURE_CONNECTION) { size 2068 ext/mysqlnd/mysqlnd_wireprotocol.c php_mysqlnd_read_error_from_line(p, packet->header.size - 1, size 2076 ext/mysqlnd/mysqlnd_wireprotocol.c if (packet->response_code == 0xFE && packet->header.size > (size_t) (p - buf)) { size 2080 ext/mysqlnd/mysqlnd_wireprotocol.c packet->new_auth_protocol_data_len = packet->header.size - (size_t) (p - buf); size 2091 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("CHANGE_USER packet %d bytes shorter than expected", p - begin - packet->header.size); size 2093 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 2173 ext/mysqlnd/mysqlnd_wireprotocol.c packet->public_key_len = packet->header.size - (p - buf); size 2181 ext/mysqlnd/mysqlnd_wireprotocol.c DBG_ERR_FMT("OK packet %d bytes shorter than expected", p - begin - packet->header.size); size 2183 ext/mysqlnd/mysqlnd_wireprotocol.c p - begin - packet->header.size); size 61 ext/mysqlnd/mysqlnd_wireprotocol.h size_t size; size 999 ext/oci8/oci8.c PHP_FALIAS(size, oci_lob_size, arginfo_oci_lob_size_method) size 1025 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) size 249 ext/oci8/oci8_collection.c PHP_OCI_CALL_RETURN(errstatus, OCICollSize, (connection->env, connection->err, collection->collection, (sb4 *)size)); size 1748 ext/oci8/oci8_interface.c zend_long size; size 1750 ext/oci8/oci8_interface.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &z_statement, &size) == FAILURE) { size 1756 ext/oci8/oci8_interface.c if (size < 0) { size 1761 ext/oci8/oci8_interface.c if (php_oci_statement_set_prefetch(statement, (ub4)size)) { size 2364 ext/oci8/oci8_interface.c sb4 size = 0; size 2379 ext/oci8/oci8_interface.c if (php_oci_collection_size(collection, &size)) { size 2382 ext/oci8/oci8_interface.c RETURN_LONG(size); size 463 ext/oci8/php_oci8_int.h int php_oci_collection_size(php_oci_collection *collection, sb4 *size); size 710 ext/opcache/ZendAccelerator.c static accel_time_t zend_get_file_handle_timestamp_win(zend_file_handle *file_handle, size_t *size) size 745 ext/opcache/ZendAccelerator.c if (size) { size 746 ext/opcache/ZendAccelerator.c *size = (size_t)((((unsigned __int64)fdata.nFileSizeHigh) << 32) + (unsigned __int64)fdata.nFileSizeLow); size 754 ext/opcache/ZendAccelerator.c accel_time_t zend_get_file_handle_timestamp(zend_file_handle *file_handle, size_t *size) size 768 ext/opcache/ZendAccelerator.c if (size) { size 769 ext/opcache/ZendAccelerator.c *size = tmpbuf->st_size; size 776 ext/opcache/ZendAccelerator.c res = zend_get_file_handle_timestamp_win(file_handle, size); size 846 ext/opcache/ZendAccelerator.c if (size) { size 847 ext/opcache/ZendAccelerator.c *size = statbuf.st_size; size 1198 ext/opcache/ZendAccelerator.c if ((char*)new_persistent_script->mem + new_persistent_script->size != (char*)ZCG(mem)) { size 1200 ext/opcache/ZendAccelerator.c ((char*)new_persistent_script->mem + new_persistent_script->size < (char*)ZCG(mem)) ? ACCEL_LOG_ERROR : ACCEL_LOG_WARNING, size 1204 ext/opcache/ZendAccelerator.c (char *)new_persistent_script->mem + new_persistent_script->size, size 1292 ext/opcache/ZendAccelerator.c if ((char*)new_persistent_script->mem + new_persistent_script->size != (char*)ZCG(mem)) { size 1294 ext/opcache/ZendAccelerator.c ((char*)new_persistent_script->mem + new_persistent_script->size < (char*)ZCG(mem)) ? ACCEL_LOG_ERROR : ACCEL_LOG_WARNING, size 1298 ext/opcache/ZendAccelerator.c (char *)new_persistent_script->mem + new_persistent_script->size, size 1324 ext/opcache/ZendAccelerator.c new_persistent_script->dynamic_members.memory_consumption = ZEND_ALIGNED_SIZE(new_persistent_script->size); size 1441 ext/opcache/ZendAccelerator.c size_t size = 0; size 1446 ext/opcache/ZendAccelerator.c timestamp = zend_get_file_handle_timestamp(file_handle, ZCG(accel_directives).max_file_size > 0 ? &size : NULL); size 1463 ext/opcache/ZendAccelerator.c if (ZCG(accel_directives).max_file_size > 0 && size > (size_t)ZCG(accel_directives).max_file_size) { size 2530 ext/opcache/ZendAccelerator.c static int accel_remap_huge_pages(void *start, size_t size, const char *name, size_t offset) size 2535 ext/opcache/ZendAccelerator.c mem = mmap(NULL, size, size 2545 ext/opcache/ZendAccelerator.c memcpy(mem, start, size); size 2548 ext/opcache/ZendAccelerator.c ret = mmap(start, size, size 2554 ext/opcache/ZendAccelerator.c ret = mmap(start, size, size 2561 ext/opcache/ZendAccelerator.c if (-1 == madvise(start, size, MADV_HUGEPAGE)) { size 2562 ext/opcache/ZendAccelerator.c memcpy(start, mem, size); size 2563 ext/opcache/ZendAccelerator.c mprotect(start, size, PROT_READ | PROT_EXEC); size 2564 ext/opcache/ZendAccelerator.c munmap(mem, size); size 2571 ext/opcache/ZendAccelerator.c memcpy(start, mem, size); size 2572 ext/opcache/ZendAccelerator.c mprotect(start, size, PROT_READ | PROT_EXEC); size 2573 ext/opcache/ZendAccelerator.c munmap(mem, size); size 2582 ext/opcache/ZendAccelerator.c memcpy(start, mem, size); size 2583 ext/opcache/ZendAccelerator.c mprotect(start, size, PROT_READ | PROT_EXEC); size 2585 ext/opcache/ZendAccelerator.c munmap(mem, size); size 170 ext/opcache/ZendAccelerator.h size_t size; /* size of used shared memory */ size 324 ext/opcache/ZendAccelerator.h accel_time_t zend_get_file_handle_timestamp(zend_file_handle *file_handle, size_t *size); size 59 ext/opcache/shared_alloc_mmap.c shared_segment->size = requested_size; size 72 ext/opcache/shared_alloc_mmap.c shared_segment->size = requested_size; size 79 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 322 ext/opcache/shared_alloc_win32.c shared_segment->size = requested_size; size 55 ext/opcache/zend_accelerator_blacklist.c blacklist->size = ZEND_BLACKLIST_BLOCK_SIZE; size 61 ext/opcache/zend_accelerator_blacklist.c blacklist->entries = (zend_blacklist_entry *) calloc(sizeof(zend_blacklist_entry), blacklist->size); size 218 ext/opcache/zend_accelerator_blacklist.c if (blacklist->pos == blacklist->size) { size 219 ext/opcache/zend_accelerator_blacklist.c blacklist->size += ZEND_BLACKLIST_BLOCK_SIZE; size 220 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 140 ext/opcache/zend_accelerator_module.c zend_long size; size 151 ext/opcache/zend_accelerator_module.c size = atoi(ZSTR_VAL(new_value)); size 154 ext/opcache/zend_accelerator_module.c if (size < MIN_ACCEL_FILES || size > MAX_ACCEL_FILES) { size 158 ext/opcache/zend_accelerator_module.c if (size < MIN_ACCEL_FILES) { size 159 ext/opcache/zend_accelerator_module.c size = MIN_ACCEL_FILES; size 164 ext/opcache/zend_accelerator_module.c if (size > MAX_ACCEL_FILES) { size 165 ext/opcache/zend_accelerator_module.c size = MAX_ACCEL_FILES; size 177 ext/opcache/zend_accelerator_module.c *p = size; size 653 ext/opcache/zend_accelerator_util_funcs.c static zend_always_inline void fast_memcpy(void *dest, const void *src, size_t size) size 657 ext/opcache/zend_accelerator_util_funcs.c const __m128i *end = (const __m128i*)((const char*)src + size); size 829 ext/opcache/zend_accelerator_util_funcs.c size_t size = persistent_script->size; size 835 ext/opcache/zend_accelerator_util_funcs.c size -= (signed char*)persistent_script - mem; size 841 ext/opcache/zend_accelerator_util_funcs.c size -= sizeof(*persistent_script); size 843 ext/opcache/zend_accelerator_util_funcs.c if (size > 0) { size 844 ext/opcache/zend_accelerator_util_funcs.c checksum = zend_adler32(checksum, mem, size); size 97 ext/opcache/zend_file_cache.c ((char*)(ptr) < (char*)script->size) size 99 ext/opcache/zend_file_cache.c (((char*)(ptr) >= (char*)script->mem && (char*)(ptr) < (char*)script->mem + script->size) || \ size 655 ext/opcache/zend_file_cache.c info->mem_size = script->size; size 660 ext/opcache/zend_file_cache.c memcpy(buf, script->mem, script->size); size 744 ext/opcache/zend_file_cache.c mem = emalloc(script->size + 64); size 747 ext/opcache/zend_file_cache.c mem = buf = emalloc(script->size); size 762 ext/opcache/zend_file_cache.c info.checksum = zend_adler32(ADLER32_INIT, buf, script->size); size 769 ext/opcache/zend_file_cache.c vec[1].iov_len = script->size; size 773 ext/opcache/zend_file_cache.c if (writev(fd, vec, 3) != (ssize_t)(sizeof(info) + script->size + info.str_size)) { size 782 ext/opcache/zend_file_cache.c if (ZEND_LONG_MAX < (zend_long)(sizeof(info) + script->size + info.str_size) || size 784 ext/opcache/zend_file_cache.c write(fd, buf, script->size) != script->size || 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)) 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) size 29 ext/opcache/zend_persist_calc.c #define ADD_DUP_SIZE(m,s) ZCG(current_persistent_script)->size += zend_shared_memdup_size((void*)m, s) size 30 ext/opcache/zend_persist_calc.c #define ADD_SIZE(m) ZCG(current_persistent_script)->size += ZEND_ALIGNED_SIZE(m) size 124 ext/opcache/zend_persist_calc.c uint size; size 137 ext/opcache/zend_persist_calc.c size = zend_shared_memdup_size(Z_ARR_P(z), sizeof(zend_array)); size 138 ext/opcache/zend_persist_calc.c if (size) { size 139 ext/opcache/zend_persist_calc.c ADD_SIZE(size); size 144 ext/opcache/zend_persist_calc.c size = zend_shared_memdup_size(Z_REF_P(z), sizeof(zend_reference)); size 145 ext/opcache/zend_persist_calc.c if (size) { size 146 ext/opcache/zend_persist_calc.c ADD_SIZE(size); size 151 ext/opcache/zend_persist_calc.c size = zend_shared_memdup_size(Z_AST_P(z), sizeof(zend_ast_ref)); size 152 ext/opcache/zend_persist_calc.c if (size) { size 153 ext/opcache/zend_persist_calc.c ADD_SIZE(size); size 387 ext/opcache/zend_persist_calc.c new_persistent_script->size = 0; size 404 ext/opcache/zend_persist_calc.c new_persistent_script->size = (new_persistent_script->size + 63) & ~63; size 416 ext/opcache/zend_persist_calc.c new_persistent_script->size += new_persistent_script->arena_size; size 421 ext/opcache/zend_persist_calc.c return new_persistent_script->size; size 106 ext/opcache/zend_shared_alloc.c static void copy_shared_segments(void *to, void *from, int count, int size) size 115 ext/opcache/zend_shared_alloc.c memcpy(shared_segments_to_p, shared_segments_from_p, size); size 116 ext/opcache/zend_shared_alloc.c shared_segments_to_p = ((char *)shared_segments_to_p + size); size 117 ext/opcache/zend_shared_alloc.c shared_segments_from_p = ((char *)shared_segments_from_p + size); size 287 ext/opcache/zend_shared_alloc.c size_t block_size = ZSMMG(shared_segments)[i]->size - ZSMMG(shared_segments)[i]->pos; size 299 ext/opcache/zend_shared_alloc.c zend_accel_error(ACCEL_LOG_WARNING, "Not enough free shared space to allocate %pd bytes (%pd bytes free)", (zend_long)size, (zend_long)ZSMMG(shared_free)); \ size 305 ext/opcache/zend_shared_alloc.c void *zend_shared_alloc(size_t size) size 308 ext/opcache/zend_shared_alloc.c unsigned int block_size = ZEND_ALIGNED_SIZE(size); size 320 ext/opcache/zend_shared_alloc.c if (ZSMMG(shared_segments)[i]->size - ZSMMG(shared_segments)[i]->pos >= block_size) { /* found a valid block */ size 334 ext/opcache/zend_shared_alloc.c int zend_shared_memdup_size(void *source, size_t size) size 343 ext/opcache/zend_shared_alloc.c return ZEND_ALIGNED_SIZE(size); size 346 ext/opcache/zend_shared_alloc.c void *_zend_shared_memdup(void *source, size_t size, zend_bool free_source) size 355 ext/opcache/zend_shared_alloc.c ZCG(mem) = (void*)(((char*)ZCG(mem)) + ZEND_ALIGNED_SIZE(size)); size 356 ext/opcache/zend_shared_alloc.c memcpy(retval, source, size); size 510 ext/opcache/zend_shared_alloc.c mprotect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->size, mode); size 525 ext/opcache/zend_shared_alloc.c (char*)ptr < (char*)ZSMMG(shared_segments)[i]->p + ZSMMG(shared_segments)[i]->size) { size 74 ext/opcache/zend_shared_alloc.h size_t size; size 125 ext/opcache/zend_shared_alloc.h void *zend_shared_alloc(size_t size); size 128 ext/opcache/zend_shared_alloc.h void *_zend_shared_memdup(void *p, size_t size, zend_bool free_source); size 129 ext/opcache/zend_shared_alloc.h int zend_shared_memdup_size(void *p, size_t size); size 145 ext/opcache/zend_shared_alloc.h #define ZEND_ALIGNED_SIZE(size) \ size 146 ext/opcache/zend_shared_alloc.h ZEND_MM_ALIGNED_SIZE_EX(size, PLATFORM_ALIGNMENT) size 9005 ext/pcre/pcrelib/pcre_compile.c size_t size; size 9337 ext/pcre/pcrelib/pcre_compile.c size = sizeof(REAL_PCRE) + size 9342 ext/pcre/pcrelib/pcre_compile.c re = (REAL_PCRE *)(PUBL(malloc))(size); size 9356 ext/pcre/pcrelib/pcre_compile.c re->size = (int)size; size 108 ext/pcre/pcrelib/pcre_fullinfo.c *((size_t *)where) = re->size; size 112 ext/pcre/pcrelib/pcre_fullinfo.c *((size_t *)where) = (study == NULL)? 0 : study->size; size 334 ext/pcre/pcrelib/pcre_get.c int stringnumber, char *buffer, int size) size 338 ext/pcre/pcrelib/pcre_get.c int stringnumber, PCRE_UCHAR16 *buffer, int size) size 342 ext/pcre/pcrelib/pcre_get.c int stringnumber, PCRE_UCHAR32 *buffer, int size) size 350 ext/pcre/pcrelib/pcre_get.c if (size < yield + 1) return PCRE_ERROR_NOMEMORY; size 390 ext/pcre/pcrelib/pcre_get.c char *buffer, int size) size 395 ext/pcre/pcrelib/pcre_get.c PCRE_UCHAR16 *buffer, int size) size 400 ext/pcre/pcrelib/pcre_get.c PCRE_UCHAR32 *buffer, int size) size 406 ext/pcre/pcrelib/pcre_get.c return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size); size 408 ext/pcre/pcrelib/pcre_get.c return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size); size 410 ext/pcre/pcrelib/pcre_get.c return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size); size 452 ext/pcre/pcrelib/pcre_get.c int size = sizeof(pcre_uchar *); size 458 ext/pcre/pcrelib/pcre_get.c size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1); size 460 ext/pcre/pcrelib/pcre_get.c stringlist = (pcre_uchar **)(PUBL(malloc))(size); size 2327 ext/pcre/pcrelib/pcre_internal.h pcre_uint32 size; /* Total that was malloced */ size 2353 ext/pcre/pcrelib/pcre_internal.h pcre_uint32 size; /* Total that was malloced */ size 2388 ext/pcre/pcrelib/pcre_internal.h #define REAL_PCRE_SIZE(re) (((REAL_PCRE*)re)->size) size 2396 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 317 ext/pcre/pcrelib/pcre_printint.c int size = re->name_entry_size; size 323 ext/pcre/pcrelib/pcre_printint.c size = ((size << 8) & 0xff00) | ((size >> 8) & 0xff); size 330 ext/pcre/pcrelib/pcre_printint.c code = codestart = (pcre_uchar *)re + offset + count * size; size 431 ext/pcre/pcrelib/pcre_printint.c pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) + size 449 ext/pcre/pcrelib/pcre_printint.c pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) + size 615 ext/pcre/pcrelib/pcre_printint.c pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) + size 1582 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 438 ext/pdo/pdo_dbh.c fci.size = sizeof(zend_fcall_info); size 735 ext/pdo/pdo_stmt.c fci->size = sizeof(zend_fcall_info); size 809 ext/pdo/pdo_stmt.c if (stmt->fetch.cls.fci.size && stmt->fetch.cls.fci.params) { size 819 ext/pdo/pdo_stmt.c stmt->fetch.cls.fci.size = 0; size 951 ext/pdo/pdo_stmt.c if (!stmt->fetch.cls.fci.size) { size 992 ext/pdo/pdo_stmt.c if (!stmt->fetch.func.fci.size) { size 327 ext/pdo_sqlite/sqlite_driver.c fc->fci.size = sizeof(fc->fci); size 478 ext/pdo_sqlite/sqlite_driver.c collation->fc.fci.size = sizeof(collation->fc.fci); size 381 ext/pgsql/pgsql.c ZEND_ARG_INFO(0, size) size 2791 ext/pgsql/pgsql.c fci.size = sizeof(fci); size 3845 ext/pgsql/pgsql.c size_t size; size 3850 ext/pgsql/pgsql.c if (zend_parse_parameters(argc, "rl", &pgsql_id, &size) == FAILURE) { size 3860 ext/pgsql/pgsql.c result = lo_truncate64((PGconn *)pgsql->conn, pgsql->lofd, size); size 3862 ext/pgsql/pgsql.c result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size); size 3865 ext/pgsql/pgsql.c result = lo_truncate((PGconn *)pgsql->conn, pgsql->lofd, size); size 233 ext/phar/func_interceptors.c int size = 0; size 318 ext/phar/func_interceptors.c size = php_stream_passthru(stream); size 320 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)) { 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 522 ext/phar/tar.c if (size > 511) { size 531 ext/phar/tar.c read = php_stream_read(fp, buf, size); size 533 ext/phar/tar.c if (read == size) { size 534 ext/phar/tar.c buf[size] = '\0'; size 535 ext/phar/tar.c if (!phar_validate_alias(buf, size)) { size 536 ext/phar/tar.c if (size > 50) { size 552 ext/phar/tar.c actual_alias = pestrndup(buf, size, myphar->is_persistent); size 554 ext/phar/tar.c myphar->alias_len = size; size 567 ext/phar/tar.c size = (size+511)&~511; size 569 ext/phar/tar.c if (((hdr->typeflag == '\0') || (hdr->typeflag == TAR_FILE)) && size > 0) { size 572 ext/phar/tar.c php_stream_seek(fp, size, SEEK_CUR); size 747 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 zend_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 822 ext/phar/zip.c PHAR_SET_16(perms.size, sizeof(perms) - 4); size 586 ext/readline/readline_cli.c size_t size = 4096, pos = 0, len; size 587 ext/readline/readline_cli.c char *code = emalloc(size); size 642 ext/readline/readline_cli.c if (pos + len + 2 > size) { size 643 ext/readline/readline_cli.c size = pos + len + 2; size 644 ext/readline/readline_cli.c code = erealloc(code, size); size 1392 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 1927 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 1987 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 3218 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 3325 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 4623 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 4727 ext/reflection/php_reflection.c fci.size = sizeof(fci); size 51 ext/shmop/php_shmop.h zend_long size; size 53 ext/shmop/shmop.c ZEND_ARG_INFO(0, size) size 149 ext/shmop/shmop.c zend_long key, mode, size; size 155 ext/shmop/shmop.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) { size 177 ext/shmop/shmop.c shmop->size = size; size 181 ext/shmop/shmop.c shmop->size = size; size 194 ext/shmop/shmop.c if (shmop->shmflg & IPC_CREAT && shmop->size < 1) { size 199 ext/shmop/shmop.c shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg); size 216 ext/shmop/shmop.c shmop->size = shm.shm_segsz; size 244 ext/shmop/shmop.c if (start < 0 || start > shmop->size) { size 249 ext/shmop/shmop.c if (count < 0 || start > (INT_MAX - count) || start + count > shmop->size) { size 255 ext/shmop/shmop.c bytes = count ? count : shmop->size - start; size 298 ext/shmop/shmop.c RETURN_LONG(shmop->size); size 325 ext/shmop/shmop.c if (offset < 0 || offset > shmop->size) { size 330 ext/shmop/shmop.c writesize = (ZSTR_LEN(data) < shmop->size - offset) ? ZSTR_LEN(data) : shmop->size - offset; size 34 ext/soap/php_xml.h xmlDocPtr soap_xmlParseMemory(const void *buf, size_t size); size 955 ext/soap/soap.c fci.size = sizeof(fci); size 1522 ext/soap/soap.c int num_params = 0, size, i, call_status = 0; size 1937 ext/soap/soap.c xmlDocDumpMemory(doc_return, &buf, &size); size 1939 ext/soap/soap.c if (size == 0) { size 1954 ext/soap/soap.c snprintf(cont_len, sizeof(cont_len), "Content-Length: %d", size); size 1957 ext/soap/soap.c php_write(buf, size); size 2071 ext/soap/soap.c int size; size 2080 ext/soap/soap.c xmlDocDumpMemory(doc_return, &buf, &size); size 2099 ext/soap/soap.c snprintf(cont_len, sizeof(cont_len), "Content-Length: %d", size); size 2108 ext/soap/soap.c php_write(buf, size); size 561 ext/sockets/conversions.c socklen_t size = INET_ADDRSTRLEN; size 562 ext/sockets/conversions.c zend_string *str = zend_string_alloc(size - 1, 0); size 563 ext/sockets/conversions.c memset(ZSTR_VAL(str), '\0', size); size 567 ext/sockets/conversions.c if (inet_ntop(AF_INET, addr, Z_STRVAL_P(zv), size) == NULL) { size 611 ext/sockets/conversions.c socklen_t size = INET6_ADDRSTRLEN; size 612 ext/sockets/conversions.c zend_string *str = zend_string_alloc(size - 1, 0); size 614 ext/sockets/conversions.c memset(ZSTR_VAL(str), '\0', size); size 618 ext/sockets/conversions.c if (inet_ntop(AF_INET6, addr, Z_STRVAL_P(zv), size) == NULL) { size 883 ext/sockets/conversions.c data_len = entry->size; size 966 ext/sockets/conversions.c if (CMSG_LEN(entry->size) > cmsg->cmsg_len) { size 969 ext/sockets/conversions.c (zend_long)CMSG_LEN(entry->size), (zend_long)cmsg->cmsg_len); size 634 ext/sockets/multicast.c ULONG size; size 645 ext/sockets/multicast.c size = 4 * (sizeof *addr_table); size 646 ext/sockets/multicast.c addr_table = emalloc(size); size 648 ext/sockets/multicast.c retval = GetIpAddrTable(addr_table, &size, 0); size 651 ext/sockets/multicast.c addr_table = emalloc(size); size 674 ext/sockets/multicast.c ULONG size; size 685 ext/sockets/multicast.c size = 4 * (sizeof *addr_table); size 686 ext/sockets/multicast.c addr_table = emalloc(size); size 688 ext/sockets/multicast.c retval = GetIpAddrTable(addr_table, &size, 0); size 691 ext/sockets/multicast.c addr_table = emalloc(size); size 760 ext/sockets/multicast.c int size = 0, size 770 ext/sockets/multicast.c size += 5 * sizeof(struct ifreq); size 771 ext/sockets/multicast.c buf = ecalloc(size, 1); size 772 ext/sockets/multicast.c if_conf.ifc_len = size; size 102 ext/sockets/sendrecvmsg.c entry.size = sizev; \ size 307 ext/sockets/sendrecvmsg.c if (entry->var_el_size > 0 && n > (ZEND_LONG_MAX - (zend_long)entry->size - size 315 ext/sockets/sendrecvmsg.c RETURN_LONG((zend_long)CMSG_SPACE(entry->size + n * entry->var_el_size)); size 374 ext/sockets/sendrecvmsg.c socklen_t size; size 383 ext/sockets/sendrecvmsg.c size = sizeof(struct in6_pktinfo); size 391 ext/sockets/sendrecvmsg.c buffer = ecalloc(1, size); size 392 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 2077 ext/spl/spl_directory.c fci.size = sizeof(fci); size 2936 ext/spl/spl_directory.c zend_long size; size 2938 ext/spl/spl_directory.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &size) == FAILURE) { size 2952 ext/spl/spl_directory.c RETURN_BOOL(0 == php_stream_truncate_set_size(intern->u.file.stream, size)); size 3042 ext/spl/spl_directory.c ZEND_ARG_INFO(0, size) size 64 ext/spl/spl_engine.h fci.size = sizeof(zend_fcall_info); size 46 ext/spl/spl_fixedarray.c zend_long size; size 83 ext/spl/spl_fixedarray.c static void spl_fixedarray_init(spl_fixedarray *array, zend_long size) /* {{{ */ size 85 ext/spl/spl_fixedarray.c if (size > 0) { size 86 ext/spl/spl_fixedarray.c array->size = 0; /* reset size in case ecalloc() fails */ size 87 ext/spl/spl_fixedarray.c array->elements = ecalloc(size, sizeof(zval)); size 88 ext/spl/spl_fixedarray.c array->size = size; size 91 ext/spl/spl_fixedarray.c array->size = 0; size 96 ext/spl/spl_fixedarray.c static void spl_fixedarray_resize(spl_fixedarray *array, zend_long size) /* {{{ */ size 98 ext/spl/spl_fixedarray.c if (size == array->size) { size 104 ext/spl/spl_fixedarray.c if (array->size == 0) { size 105 ext/spl/spl_fixedarray.c spl_fixedarray_init(array, size); size 110 ext/spl/spl_fixedarray.c if (size == 0) { size 113 ext/spl/spl_fixedarray.c for (i = 0; i < array->size; i++) { size 121 ext/spl/spl_fixedarray.c } else if (size > array->size) { size 122 ext/spl/spl_fixedarray.c array->elements = safe_erealloc(array->elements, size, sizeof(zval), 0); size 123 ext/spl/spl_fixedarray.c memset(array->elements + array->size, '\0', sizeof(zval) * (size - array->size)); size 127 ext/spl/spl_fixedarray.c for (i = size; i < array->size; i++) { size 130 ext/spl/spl_fixedarray.c array->elements = erealloc(array->elements, sizeof(zval) * size); size 133 ext/spl/spl_fixedarray.c array->size = size; size 140 ext/spl/spl_fixedarray.c for (i = 0; i < from->size; i++) { size 153 ext/spl/spl_fixedarray.c *n = (int)intern->array->size; size 172 ext/spl/spl_fixedarray.c for (i = 0; i < intern->array->size; i++) { size 182 ext/spl/spl_fixedarray.c if (j > intern->array->size) { size 183 ext/spl/spl_fixedarray.c for (i = intern->array->size; i < j; ++i) { size 199 ext/spl/spl_fixedarray.c for (i = 0; i < intern->array->size; i++) { size 203 ext/spl/spl_fixedarray.c if (intern->array->size > 0 && intern->array->elements) { size 237 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, other->array->size); size 344 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 397 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 445 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 484 ext/spl/spl_fixedarray.c if (index < 0 || intern->array == NULL || index >= intern->array->size) { size 541 ext/spl/spl_fixedarray.c *count = intern->array->size; size 556 ext/spl/spl_fixedarray.c zend_long size = 0; size 558 ext/spl/spl_fixedarray.c if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "|l", &size) == FAILURE) { size 562 ext/spl/spl_fixedarray.c if (size < 0) { size 575 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, size); size 593 ext/spl/spl_fixedarray.c int size = zend_hash_num_elements(intern_ht); size 596 ext/spl/spl_fixedarray.c spl_fixedarray_init(intern->array, size); size 626 ext/spl/spl_fixedarray.c RETURN_LONG(intern->array->size); size 647 ext/spl/spl_fixedarray.c for (; i < intern->array->size; i++) { size 744 ext/spl/spl_fixedarray.c RETURN_LONG(intern->array->size); size 756 ext/spl/spl_fixedarray.c zend_long size; size 758 ext/spl/spl_fixedarray.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &size) == FAILURE) { size 762 ext/spl/spl_fixedarray.c if (size < 0) { size 772 ext/spl/spl_fixedarray.c spl_fixedarray_resize(intern->array, size); size 876 ext/spl/spl_fixedarray.c if (object->current >= 0 && object->array && object->current < object->array->size) { size 970 ext/spl/spl_fixedarray.c RETURN_BOOL(intern->current >= 0 && intern->array && intern->current < intern->array->size); size 1047 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 697 ext/sqlite3/sqlite3.c fc->fci.size = sizeof(fc->fci); size 856 ext/sqlite3/sqlite3.c collation->fci.fci.size = (sizeof(collation->fci.fci)); size 1058 ext/sqlite3/sqlite3.c size_t size; size 1072 ext/sqlite3/sqlite3.c if (sqlite3_stream->position + count >= sqlite3_stream->size) { size 1073 ext/sqlite3/sqlite3.c count = sqlite3_stream->size - sqlite3_stream->position; size 1123 ext/sqlite3/sqlite3.c if (sqlite3_stream->position + (size_t)(offset) > sqlite3_stream->size) { size 1124 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1135 ext/sqlite3/sqlite3.c if (sqlite3_stream->size < (size_t)(offset)) { size 1136 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1147 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size; size 1150 ext/sqlite3/sqlite3.c } else if (sqlite3_stream->size < (size_t)(-offset)) { size 1155 ext/sqlite3/sqlite3.c sqlite3_stream->position = sqlite3_stream->size + offset; size 1176 ext/sqlite3/sqlite3.c ssb->sb.st_size = sqlite3_stream->size; size 1220 ext/sqlite3/sqlite3.c sqlite3_stream->size = sqlite3_blob_bytes(blob); size 2075 ext/standard/array.c size = (uint32_t)__calc_size; \ size 2076 ext/standard/array.c array_init_size(return_value, size); \ size 2086 ext/standard/array.c size = (uint32_t)(__calc_size + 1); \ size 2087 ext/standard/array.c array_init_size(return_value, size); \ size 2188 ext/standard/array.c uint32_t i, size; size 2208 ext/standard/array.c for (i = 0; i < size; ++i) { size 2222 ext/standard/array.c for (i = 0; i < size; ++i) { size 2236 ext/standard/array.c uint32_t i, size; size 2258 ext/standard/array.c for (i = 0; i < size; ++i) { size 2272 ext/standard/array.c for (i = 0; i < size; ++i) { size 2846 ext/standard/array.c zend_long size = length; size 2857 ext/standard/array.c size = num_in - offset + length; size 2859 ext/standard/array.c size = num_in - offset; size 2863 ext/standard/array.c array_init_size(return_value, size > 0 ? (uint32_t)size : 0); size 5459 ext/standard/array.c zend_long size, current = 0; size 5467 ext/standard/array.c if (zend_parse_parameters(argc, "al|b", &input, &size, &preserve_keys) == FAILURE) { size 5471 ext/standard/array.c if (size < 1) { size 5478 ext/standard/array.c if (size > num_in) { size 5479 ext/standard/array.c size = num_in > 0 ? num_in : 1; size 5482 ext/standard/array.c array_init_size(return_value, (uint32_t)(((num_in - 1) / size) + 1)); size 5489 ext/standard/array.c array_init_size(&chunk, (uint32_t)size); size 5506 ext/standard/array.c if (!(++current % size)) { size 595 ext/standard/basic_functions.c ZEND_ARG_INFO(0, size) size 1173 ext/standard/basic_functions.c ZEND_ARG_INFO(0, size) size 4034 ext/standard/basic_functions.c int size; size 4040 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, &dummybuf, 0); size 4046 ext/standard/basic_functions.c if (size == 0) { size 4051 ext/standard/basic_functions.c ptr = emalloc(size); size 4052 ext/standard/basic_functions.c size = GetEnvironmentVariableA(str, ptr, size); size 4053 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 1395 ext/standard/file.c size_t size = 0; size 1409 ext/standard/file.c size = php_stream_passthru(stream); size 1411 ext/standard/file.c RETURN_LONG(size); size 1450 ext/standard/file.c size_t size; size 1459 ext/standard/file.c size = php_stream_passthru(stream); size 1460 ext/standard/file.c RETURN_LONG(size); size 1537 ext/standard/file.c zend_long size; size 1540 ext/standard/file.c if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &fp, &size) == FAILURE) { size 1551 ext/standard/file.c RETURN_BOOL(0 == php_stream_truncate_set_size(stream, size)); size 96 ext/standard/formatted_print.c size_t size = ZSTR_LEN(*buffer); size 97 ext/standard/formatted_print.c while (req_size > size) { size 98 ext/standard/formatted_print.c if (size > ZEND_SIZE_MAX/2) { size 101 ext/standard/formatted_print.c size <<= 1; size 103 ext/standard/formatted_print.c PRINTF_DEBUG(("sprintf ereallocing buffer to %d bytes\n", size)); size 104 ext/standard/formatted_print.c *buffer = zend_string_extend(*buffer, size, 0); size 391 ext/standard/formatted_print.c size_t size = 240, inpos = 0, outpos = 0, temppos; size 440 ext/standard/formatted_print.c result = zend_string_alloc(size, 0); size 1186 ext/standard/html.c e = s - 1 + c->data.multicodepoint_table[0].leading_entry.size; size 1598 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 893 ext/standard/image.c int size; size 909 ext/standard/image.c size = php_ifd_get32s(a+4, 1); size 910 ext/standard/image.c if (size < 0) { size 913 ext/standard/image.c if ((size & 1) == 1) { size 914 ext/standard/image.c size++; size 917 ext/standard/image.c if (size < 9 || php_stream_read(stream, (char*)a, 9) != 9) { size 932 ext/standard/image.c if (php_stream_seek(stream, size, SEEK_CUR)) { size 190 ext/standard/md5.c static const void *body(PHP_MD5_CTX *ctx, const void *data, size_t size) size 287 ext/standard/md5.c } while (size -= 64); size 308 ext/standard/md5.c PHPAPI void PHP_MD5Update(PHP_MD5_CTX *ctx, const void *data, size_t size) size 314 ext/standard/md5.c if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) { size 317 ext/standard/md5.c ctx->hi += size >> 29; size 324 ext/standard/md5.c if (size < free) { size 325 ext/standard/md5.c memcpy(&ctx->buffer[used], data, size); size 331 ext/standard/md5.c size -= free; size 335 ext/standard/md5.c if (size >= 64) { size 336 ext/standard/md5.c data = body(ctx, data, size & ~(size_t)0x3f); size 337 ext/standard/md5.c size &= 0x3f; size 340 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 93 ext/standard/pack.c static void php_pack(zval *val, size_t size, int *map, char *output) size 101 ext/standard/pack.c for (i = 0; i < size; i++) { size 518 ext/standard/pack.c static zend_long php_unpack(char *data, size_t size, int issigned, int *map) size 526 ext/standard/pack.c for (i = 0; i < size; i++) { size 574 ext/standard/pack.c int size=0; size 611 ext/standard/pack.c size = -1; size 615 ext/standard/pack.c size = 0; size 621 ext/standard/pack.c size = arg; size 627 ext/standard/pack.c size = (arg > 0) ? (arg + (arg % 2)) / 2 : arg; size 635 ext/standard/pack.c size = 1; size 643 ext/standard/pack.c size = 2; size 649 ext/standard/pack.c size = sizeof(int); size 657 ext/standard/pack.c size = 4; size 666 ext/standard/pack.c size = 8; size 676 ext/standard/pack.c size = sizeof(float); size 681 ext/standard/pack.c size = sizeof(double); size 691 ext/standard/pack.c if (size != 0 && size != -1 && size < 0) { size 710 ext/standard/pack.c if (size != 0 && size != -1 && INT_MAX - size + 1 < inputpos) { size 716 ext/standard/pack.c if ((inputpos + size) <= inputlen) { size 723 ext/standard/pack.c if ((size >= 0) && (len > size)) { size 724 ext/standard/pack.c len = size; size 727 ext/standard/pack.c size = len; size 738 ext/standard/pack.c if ((size >= 0) && (len > size)) { size 739 ext/standard/pack.c len = size; size 742 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 793 ext/standard/pack.c if (size >= 0 && len > (size * 2)) { size 794 ext/standard/pack.c len = size * 2; size 957 ext/standard/pack.c if (inputpos < size) { size 958 ext/standard/pack.c inputpos = -size; size 978 ext/standard/pack.c inputpos += size; size 980 ext/standard/pack.c if (size != -1) { /* only print warning if not working with * */ size 989 ext/standard/pack.c php_error_docref(NULL, E_WARNING, "Type %c: not enough input, need %d, have " ZEND_LONG_FMT, type, size, inputlen - inputpos); size 1069 ext/standard/pack.c int size = sizeof(Z_LVAL(val)); size 1073 ext/standard/pack.c byte_map[0] = size - 1; size 1076 ext/standard/pack.c int_map[i] = size - (sizeof(int) - i); size 1079 ext/standard/pack.c machine_endian_short_map[0] = size - 2; size 1080 ext/standard/pack.c machine_endian_short_map[1] = size - 1; size 1081 ext/standard/pack.c big_endian_short_map[0] = size - 2; size 1082 ext/standard/pack.c big_endian_short_map[1] = size - 1; size 1083 ext/standard/pack.c little_endian_short_map[0] = size - 1; size 1084 ext/standard/pack.c little_endian_short_map[1] = size - 2; size 1086 ext/standard/pack.c machine_endian_long_map[0] = size - 4; size 1087 ext/standard/pack.c machine_endian_long_map[1] = size - 3; size 1088 ext/standard/pack.c machine_endian_long_map[2] = size - 2; size 1089 ext/standard/pack.c machine_endian_long_map[3] = size - 1; size 1090 ext/standard/pack.c big_endian_long_map[0] = size - 4; size 1091 ext/standard/pack.c big_endian_long_map[1] = size - 3; size 1092 ext/standard/pack.c big_endian_long_map[2] = size - 2; size 1093 ext/standard/pack.c big_endian_long_map[3] = size - 1; size 1094 ext/standard/pack.c little_endian_long_map[0] = size - 1; size 1095 ext/standard/pack.c little_endian_long_map[1] = size - 2; size 1096 ext/standard/pack.c little_endian_long_map[2] = size - 3; size 1097 ext/standard/pack.c little_endian_long_map[3] = size - 4; size 1100 ext/standard/pack.c machine_endian_longlong_map[0] = size - 8; size 1101 ext/standard/pack.c machine_endian_longlong_map[1] = size - 7; size 1102 ext/standard/pack.c machine_endian_longlong_map[2] = size - 6; size 1103 ext/standard/pack.c machine_endian_longlong_map[3] = size - 5; size 1104 ext/standard/pack.c machine_endian_longlong_map[4] = size - 4; size 1105 ext/standard/pack.c machine_endian_longlong_map[5] = size - 3; size 1106 ext/standard/pack.c machine_endian_longlong_map[6] = size - 2; size 1107 ext/standard/pack.c machine_endian_longlong_map[7] = size - 1; size 1108 ext/standard/pack.c big_endian_longlong_map[0] = size - 8; size 1109 ext/standard/pack.c big_endian_longlong_map[1] = size - 7; size 1110 ext/standard/pack.c big_endian_longlong_map[2] = size - 6; size 1111 ext/standard/pack.c big_endian_longlong_map[3] = size - 5; size 1112 ext/standard/pack.c big_endian_longlong_map[4] = size - 4; size 1113 ext/standard/pack.c big_endian_longlong_map[5] = size - 3; size 1114 ext/standard/pack.c big_endian_longlong_map[6] = size - 2; size 1115 ext/standard/pack.c big_endian_longlong_map[7] = size - 1; size 1116 ext/standard/pack.c little_endian_longlong_map[0] = size - 1; size 1117 ext/standard/pack.c little_endian_longlong_map[1] = size - 2; size 1118 ext/standard/pack.c little_endian_longlong_map[2] = size - 3; size 1119 ext/standard/pack.c little_endian_longlong_map[3] = size - 4; size 1120 ext/standard/pack.c little_endian_longlong_map[4] = size - 5; size 1121 ext/standard/pack.c little_endian_longlong_map[5] = size - 6; size 1122 ext/standard/pack.c little_endian_longlong_map[6] = size - 7; size 1123 ext/standard/pack.c little_endian_longlong_map[7] = size - 8; size 37 ext/standard/php_random.h PHPAPI int php_random_bytes(void *bytes, size_t size, zend_bool should_throw); size 85 ext/standard/random.c PHPAPI int php_random_bytes(void *bytes, size_t size, zend_bool should_throw) size 89 ext/standard/random.c if (php_win32_get_random_bytes(bytes, size) == FAILURE) { size 96 ext/standard/random.c arc4random_buf(bytes, size); size 114 ext/standard/random.c amount_to_read = size - read_bytes; size 134 ext/standard/random.c } while (read_bytes < size); size 168 ext/standard/random.c while (read_bytes < size) { size 169 ext/standard/random.c n = read(fd, bytes + read_bytes, size - read_bytes); size 176 ext/standard/random.c if (read_bytes < size) { size 192 ext/standard/random.c zend_long size; size 195 ext/standard/random.c if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "l", &size) == FAILURE) { size 199 ext/standard/random.c if (size < 1) { size 204 ext/standard/random.c bytes = zend_string_alloc(size, 0); size 206 ext/standard/random.c if (php_random_bytes_throw(ZSTR_VAL(bytes), size) == FAILURE) { size 211 ext/standard/random.c ZSTR_VAL(bytes)[size] = '\0'; size 43 ext/tidy/tidy.c #define FIX_BUFFER(bptr) do { if ((bptr)->size) { (bptr)->bp[(bptr)->size-1] = '\0'; } } while(0) size 628 ext/tidy/tidy.c RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0); size 760 ext/tidy/tidy.c ZVAL_STRINGL(out, (char *) output.bp, output.size ? output.size-1 : 0); size 794 ext/tidy/tidy.c ZVAL_STRINGL(out, (char *) buf.bp, buf.size-1); size 817 ext/tidy/tidy.c if (output.size) { size 821 ext/tidy/tidy.c ZVAL_STRINGL(&temp, (char*)output.bp, output.size-1); size 827 ext/tidy/tidy.c if (obj->ptdoc->errbuf->size) { size 831 ext/tidy/tidy.c ZVAL_STRINGL(&temp, (char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1); size 853 ext/tidy/tidy.c ADD_PROPERTY_STRINGL(obj->std.properties, value, buf.bp, buf.size ? buf.size-1 : 0); size 1181 ext/tidy/tidy.c output_context->out.used = outbuf.size ? outbuf.size-1 : 0; size 1232 ext/tidy/tidy.c RETURN_STRINGL((char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1); size 1249 ext/tidy/tidy.c RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0); 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 67 ext/xml/expat_compat.h void *(*malloc_fcn)(size_t size); size 68 ext/xml/expat_compat.h void *(*realloc_fcn)(void *ptr, size_t size); size 485 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 297 ext/xsl/xsltprocessor.c fci.size = sizeof(fci); size 283 ext/zip/lib/zip.h zip_uint64_t size; /* size of file (uncompressed) */ size 64 ext/zip/lib/zip_buffer.c return buffer->ok && buffer->offset == buffer->size; size 73 ext/zip/lib/zip_buffer.c if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) { size 140 ext/zip/lib/zip_buffer.c return buffer->ok ? buffer->size - buffer->offset : 0; size 145 ext/zip/lib/zip_buffer.c _zip_buffer_new(zip_uint8_t *data, zip_uint64_t size) size 151 ext/zip/lib/zip_buffer.c if ((data = (zip_uint8_t *)malloc(size)) == NULL) { size 165 ext/zip/lib/zip_buffer.c buffer->size = size; size 174 ext/zip/lib/zip_buffer.c _zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error) size 178 ext/zip/lib/zip_buffer.c if ((buffer = _zip_buffer_new(buf, size)) == NULL) { size 183 ext/zip/lib/zip_buffer.c if (_zip_read(src, buffer->data, size, error) < 0) { size 294 ext/zip/lib/zip_buffer.c if (offset > buffer->size) { size 320 ext/zip/lib/zip_buffer.c return buffer->size; size 255 ext/zip/lib/zip_close.c st.comp_size = st.size; size 268 ext/zip/lib/zip_close.c de->uncomp_size = st.size; size 271 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 315 ext/zip/lib/zip_close.c if (de->comp_method != ZIP_CM_STORE && ((st.valid & ZIP_STAT_SIZE) == 0 || st.size != 0)) { size 372 ext/zip/lib/zip_close.c de->uncomp_size = st.size; size 451 ext/zip/lib/zip_close.c zip_int64_t cd_start, end, size; size 457 ext/zip/lib/zip_close.c if ((size=_zip_cdir_write(za, filelist, survivors)) < 0) { size 87 ext/zip/lib/zip_dirent.c cd->size = cd->offset = 0; size 97 ext/zip/lib/zip_dirent.c zip_uint64_t offset, size; size 127 ext/zip/lib/zip_dirent.c size = (zip_uint64_t)off - offset; size 147 ext/zip/lib/zip_dirent.c _zip_buffer_put_64(buffer, size); size 151 ext/zip/lib/zip_dirent.c _zip_buffer_put_64(buffer, offset+size); size 159 ext/zip/lib/zip_dirent.c _zip_buffer_put_32(buffer, size >= ZIP_UINT32_MAX ? ZIP_UINT32_MAX : (zip_uint32_t)size); size 185 ext/zip/lib/zip_dirent.c return (zip_int64_t)size; size 302 ext/zip/lib/zip_dirent.c zip_uint32_t size, variable_size; size 307 ext/zip/lib/zip_dirent.c size = local ? LENTRYSIZE : CDENTRYSIZE; size 310 ext/zip/lib/zip_dirent.c if (_zip_buffer_left(buffer) < size) { size 316 ext/zip/lib/zip_dirent.c if ((buffer = _zip_buffer_new_from_source(src, size, buf, error)) == NULL) { size 528 ext/zip/lib/zip_dirent.c return (zip_int64_t)(size + variable_size); size 571 ext/zip/lib/zip_dirent.c zip_int32_t size; size 577 ext/zip/lib/zip_dirent.c size = local ? LENTRYSIZE : CDENTRYSIZE; size 589 ext/zip/lib/zip_dirent.c size += _zip_buffer_get_16(buffer); size 599 ext/zip/lib/zip_dirent.c return size; size 48 ext/zip/lib/zip_extra_field.c if ((def=_zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) { size 135 ext/zip/lib/zip_extra_field.c *lenp = ef->size; size 136 ext/zip/lib/zip_extra_field.c if (ef->size > 0) size 165 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 184 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 194 ext/zip/lib/zip_extra_field.c ef->size = size; size 195 ext/zip/lib/zip_extra_field.c if (size > 0) { size 196 ext/zip/lib/zip_extra_field.c if ((ef->data=(zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) { size 311 ext/zip/lib/zip_extra_field.c zip_uint16_t size; size 313 ext/zip/lib/zip_extra_field.c size = 0; size 316 ext/zip/lib/zip_extra_field.c size = (zip_uint16_t)(size+4+ef->size); size 319 ext/zip/lib/zip_extra_field.c return size; size 337 ext/zip/lib/zip_extra_field.c _zip_buffer_put_16(buffer, ef->size); size 347 ext/zip/lib/zip_extra_field.c if (ef->size > 0) { size 348 ext/zip/lib/zip_extra_field.c if (_zip_write(za, ef->data, ef->size) < 0) { size 136 ext/zip/lib/zip_extra_field_api.c *lenp = ef->size; size 137 ext/zip/lib/zip_extra_field_api.c if (ef->size > 0) size 290 ext/zip/lib/zip_extra_field_api.c new_len -= ef->size + 4; size 54 ext/zip/lib/zip_file_get_offset.c zip_int32_t size; size 64 ext/zip/lib/zip_file_get_offset.c if ((size=_zip_dirent_size(za->src, ZIP_EF_LOCAL, error)) < 0) size 67 ext/zip/lib/zip_file_get_offset.c if (offset+(zip_uint32_t)size > ZIP_INT64_MAX) { size 72 ext/zip/lib/zip_file_get_offset.c return offset + (zip_uint32_t)size; size 105 ext/zip/lib/zip_hash.c _hash_string(const zip_uint8_t *name, zip_uint16_t size) size 114 ext/zip/lib/zip_hash.c value = (zip_uint16_t)(((value * HASH_MULTIPLIER) + (zip_uint8_t)*name) % size); size 197 ext/zip/lib/zip_open.c len = st.size; size 311 ext/zip/lib/zip_open.c if (cd->offset + cd->size > buf_offset + eocd_offset) { size 343 ext/zip/lib/zip_open.c if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) { size 348 ext/zip/lib/zip_open.c if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) { size 371 ext/zip/lib/zip_open.c left = (zip_uint64_t)cd->size; size 406 ext/zip/lib/zip_open.c ok = ((zip_uint64_t)offset == cd->offset + cd->size); size 555 ext/zip/lib/zip_open.c return (st.valid & ZIP_STAT_SIZE) && st.size == 0 ? EXISTS_EMPTY : EXISTS_NONEMPTY; size 670 ext/zip/lib/zip_open.c zip_uint64_t i, nentry, size, offset, eocd_offset; size 696 ext/zip/lib/zip_open.c size = _zip_buffer_get_32(buffer); size 699 ext/zip/lib/zip_open.c if (offset+size < offset) { size 704 ext/zip/lib/zip_open.c if (offset+size > buf_offset + eocd_offset) { size 710 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) { size 718 ext/zip/lib/zip_open.c cd->size = size; size 732 ext/zip/lib/zip_open.c zip_uint64_t size, nentry, i, eocdloc_offset; size 777 ext/zip/lib/zip_open.c size = _zip_buffer_get_64(buffer); size 779 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) { size 821 ext/zip/lib/zip_open.c size = _zip_buffer_get_64(buffer); size 836 ext/zip/lib/zip_open.c if (offset > ZIP_INT64_MAX || offset+size < offset) { size 840 ext/zip/lib/zip_open.c if ((flags & ZIP_CHECKCONS) && offset+size != eocd_offset) { size 849 ext/zip/lib/zip_open.c cd->size = size; size 49 ext/zip/lib/zip_source_buffer.c zip_uint64_t size; /* size of data in bytes */ size 199 ext/zip/lib/zip_source_buffer.c st->size = ctx->in->size; size 200 ext/zip/lib/zip_source_buffer.c st->comp_size = st->size; size 274 ext/zip/lib/zip_source_buffer.c buffer->size = 0; size 289 ext/zip/lib/zip_source_buffer.c buffer->size = length; size 333 ext/zip/lib/zip_source_buffer.c length = ZIP_MIN(length, buffer->size - buffer->offset); size 363 ext/zip/lib/zip_source_buffer.c zip_int64_t new_offset = zip_source_seek_compute_offset(buffer->offset, buffer->size, data, len, error); size 430 ext/zip/lib/zip_source_buffer.c if (buffer->offset > buffer->size) { size 431 ext/zip/lib/zip_source_buffer.c buffer->size = buffer->offset; size 45 ext/zip/lib/zip_source_crc.c zip_uint64_t size; size 74 ext/zip/lib/zip_source_crc.c ctx->size = 0; size 102 ext/zip/lib/zip_source_crc.c ctx->size = ctx->position; size 116 ext/zip/lib/zip_source_crc.c if ((st.valid & ZIP_STAT_SIZE) && st.size != ctx->size) { size 148 ext/zip/lib/zip_source_crc.c st->size = ctx->size; size 150 ext/zip/lib/zip_source_crc.c st->comp_size = ctx->size; size 47 ext/zip/lib/zip_source_deflate.c zip_uint64_t size; size 123 ext/zip/lib/zip_source_deflate.c ctx->size = ctx->zstr.total_in; size 124 ext/zip/lib/zip_source_deflate.c memcpy(data, ctx->buffer, ctx->size); size 125 ext/zip/lib/zip_source_deflate.c return (zip_int64_t)ctx->size; size 162 ext/zip/lib/zip_source_deflate.c ctx->size = ctx->zstr.total_in; size 319 ext/zip/lib/zip_source_deflate.c st->comp_size = ctx->size; size 388 ext/zip/lib/zip_source_deflate.c if (st->comp_size > 0 && st->size > 0) size 389 ext/zip/lib/zip_source_deflate.c st->comp_size = st->size; size 431 ext/zip/lib/zip_source_filep.c st->size = ctx->end - ctx->start; size 435 ext/zip/lib/zip_source_filep.c st->size = (zip_uint64_t)fst.st_size; size 547 ext/zip/lib/zip_source_win32handle.c LARGE_INTEGER size; size 564 ext/zip/lib/zip_source_win32handle.c if (!GetFileSizeEx(h, &size)) { size 573 ext/zip/lib/zip_source_win32handle.c st->size = ctx->end - ctx->start; size 577 ext/zip/lib/zip_source_win32handle.c st->size = (zip_uint64_t)size.QuadPart; size 54 ext/zip/lib/zip_source_win32utf8.c int size; size 64 ext/zip/lib/zip_source_win32utf8.c size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, fname, -1, NULL, 0); size 65 ext/zip/lib/zip_source_win32utf8.c if (size == 0) { size 69 ext/zip/lib/zip_source_win32utf8.c if ((wfname = (wchar_t *)malloc(sizeof(wchar_t) * size)) == NULL) { size 73 ext/zip/lib/zip_source_win32utf8.c MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, fname, -1, wfname, size); size 77 ext/zip/lib/zip_source_zip_new.c if ((start > 0 || len > 0) && (start+len < start || start+len > st.size)) { size 114 ext/zip/lib/zip_source_zip_new.c st2.size = len ? len : st.size-start; size 115 ext/zip/lib/zip_source_zip_new.c st2.comp_size = st2.size; size 120 ext/zip/lib/zip_source_zip_new.c if ((src = _zip_source_window_new(srcza->src, offset+start, st2.size, &st2, &za->error)) == NULL) { size 164 ext/zip/lib/zip_source_zip_new.c s2 = zip_source_window(za, src, start, len ? len : st.size-start); size 63 ext/zip/lib/zip_stat_index.c st->size = de->uncomp_size; size 47 ext/zip/lib/zip_stat_init.c st->size = 0; size 62 ext/zip/lib/zip_stat_init.c dst->size = src->size; size 368 ext/zip/lib/zipint.h zip_uint64_t size; /* size of central directory */ size 377 ext/zip/lib/zipint.h zip_uint16_t size; /* data size */ size 437 ext/zip/lib/zipint.h zip_uint64_t size; size 474 ext/zip/lib/zipint.h zip_buffer_t *_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size); size 475 ext/zip/lib/zipint.h zip_buffer_t *_zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error); size 388 ext/zip/php_zip.c add_ascii_assoc_long(return_value, "size", (zend_long) (sb)->size); \ size 1325 ext/zip/php_zip.c RETURN_LONG((zend_long) (zr_rsrc->sb.size)); size 2714 ext/zip/php_zip.c if (sb.size < 1) { size 2719 ext/zip/php_zip.c len = sb.size; size 177 ext/zip/zip_stream.c ssb->sb.st_size = sb.size; size 45 ext/zlib/php_zlib.h size_t size; size 56 ext/zlib/zlib.c static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size) size 58 ext/zlib/zlib.c return (voidpf)safe_emalloc(items, size, 0); size 164 ext/zlib/zlib.c output_context->out.size = PHP_ZLIB_BUFFER_SIZE_GUESS(output_context->in.used); size 165 ext/zlib/zlib.c output_context->out.data = emalloc(output_context->out.size); size 171 ext/zlib/zlib.c ctx->Z.avail_out = output_context->out.size; size 192 ext/zlib/zlib.c output_context->out.used = output_context->out.size - ctx->Z.avail_out; size 383 ext/zlib/zlib.c buffer.size = (max && (max < Z->avail_in)) ? max : Z->avail_in; size 386 ext/zlib/zlib.c if ((max && (max <= buffer.used)) || !(buffer.aptr = erealloc_recoverable(buffer.data, buffer.size))) { size 390 ext/zlib/zlib.c Z->avail_out = buffer.free = buffer.size - buffer.used; size 393 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 400 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 402 ext/zlib/zlib.c buffer.size += (buffer.size >> 3) + 1; size 638 ext/zlib/zlib.c size_t size; size 654 ext/zlib/zlib.c size = php_stream_passthru(stream); size 656 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 675 main/main.c PHPAPI size_t php_write(void *buf, size_t size) size 677 main/main.c return PHPWRITE(buf, size); size 688 main/main.c size_t size; size 691 main/main.c size = vspprintf(&buffer, 0, format, args); size 692 main/main.c ret = PHPWRITE(buffer, size); size 965 main/main.c PHPAPI void php_html_puts(const char *str, size_t size) size 967 main/main.c zend_html_puts(str, size); size 1444 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 *)); size 70 main/mergesort.c static void insertionsort(u_char *a, size_t n, size_t size, int (*cmp)(const void *, const void *)); size 105 main/mergesort.c PHPAPI int php_mergesort(void *base, size_t nmemb, size_t size, int (*cmp)(const void *, const void *)) 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); size 134 main/mergesort.c last = list2 + nmemb * size; size 157 main/mergesort.c while ((b += size) < t && cmp(q, b) >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 *)) size 270 main/mergesort.c size2 = size*2; size 272 main/mergesort.c insertionsort(list1, n, size, cmp); 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); 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) > 0); size 293 main/mergesort.c if ((cmp(f2, f2+ size) > 0) != sense) size 301 main/mergesort.c swap (f1, f1 + size); size 306 main/mergesort.c if ((cmp(f2-size, f2) > 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) > 0) size 319 main/mergesort.c p2 = *EVAL(p2) = list2 + n*size; size 325 main/mergesort.c if (cmp (f1, f1 + size) > 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 *)) 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 801 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 809 main/output.c context->in.size = size; size 823 main/output.c context->in.size = context->out.size; size 827 main/output.c context->out.size = 0; size 837 main/output.c context->out.size = context->in.size; size 842 main/output.c context->in.size = 0; size 869 main/output.c handler->size = chunk_size; size 871 main/output.c handler->buffer.size = PHP_OUTPUT_HANDLER_INITBUF_SIZE(chunk_size); size 872 main/output.c handler->buffer.data = emalloc(handler->buffer.size); size 885 main/output.c if ((handler->buffer.size - handler->buffer.used) <= buf->used) { size 886 main/output.c size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(handler->size); size 887 main/output.c size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(buf->used - (handler->buffer.size - handler->buffer.used)); size 890 main/output.c handler->buffer.data = erealloc(handler->buffer.data, handler->buffer.size + grow_max); size 891 main/output.c handler->buffer.size += grow_max; size 897 main/output.c if (handler->size && (handler->buffer.used >= handler->size)) { size 929 main/output.c handler->buffer.size, size 982 main/output.c php_output_context_feed(context, handler->buffer.data, handler->buffer.size, handler->buffer.used, 0); size 1012 main/output.c handler->buffer.size = 0; size 1183 main/output.c add_assoc_long(entry, "chunk_size", (zend_long) handler->size); size 1184 main/output.c add_assoc_long(entry, "buffer_size", (zend_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 279 main/php.h PHPAPI size_t php_write(void *buf, size_t size); size 327 main/php.h PHPAPI int php_mergesort(void *base, size_t nmemb, register size_t size, int (*cmp)(const void *, const void *)); size 420 main/php_ini.c int size; size 427 main/php_ini.c size = GetEnvironmentVariableA("PHPRC", &dummybuf, 0); size 432 main/php_ini.c if (size == 0) { size 435 main/php_ini.c size = GetEnvironmentVariableA("PHPRC", phprc_path, size); size 436 main/php_ini.c if (size == 0) { size 95 main/php_output.h size_t size; size 128 main/php_output.h size_t size; size 313 main/php_streams.h PHPAPI void _php_stream_fill_read_buffer(php_stream *stream, size_t size); size 314 main/php_streams.h #define php_stream_fill_read_buffer(stream, size) _php_stream_fill_read_buffer((stream), (size)) size 373 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) size 431 main/php_streams.h #define php_stream_truncate_set_size(stream, size) _php_stream_truncate_set_size((stream), (size)) size 63 main/streams/cast.c static int stream_cookie_reader(void *cookie, char *buffer, int size) size 67 main/streams/cast.c ret = php_stream_read((php_stream*)cookie, buffer, size); size 71 main/streams/cast.c static int stream_cookie_writer(void *cookie, const char *buffer, int size) size 74 main/streams/cast.c return php_stream_write((php_stream *)cookie, (char *)buffer, size); size 92 main/streams/cast.c static ssize_t stream_cookie_reader(void *cookie, char *buffer, size_t size) size 96 main/streams/cast.c ret = php_stream_read(((php_stream *)cookie), buffer, size); size 100 main/streams/cast.c static ssize_t stream_cookie_writer(void *cookie, const char *buffer, size_t size) size 103 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 604 main/streams/plain_wrapper.c size_t size; size 640 main/streams/plain_wrapper.c size = *(size_t *)ptrparam; size 642 main/streams/plain_wrapper.c size = BUFSIZ; size 649 main/streams/plain_wrapper.c return setvbuf(data->file, NULL, _IOLBF, size); size 652 main/streams/plain_wrapper.c return setvbuf(data->file, NULL, _IOFBF, size); size 781 main/streams/plain_wrapper.c size = GetFileSize(hfile, NULL); size 782 main/streams/plain_wrapper.c if (range->length == 0 && range->offset > 0 && range->offset < size) { size 783 main/streams/plain_wrapper.c range->length = size - range->offset; size 785 main/streams/plain_wrapper.c if (range->length == 0 || range->length > size) { size 786 main/streams/plain_wrapper.c range->length = size; size 788 main/streams/plain_wrapper.c if (range->offset >= size) { size 789 main/streams/plain_wrapper.c range->offset = size; size 554 main/streams/streams.c PHPAPI void _php_stream_fill_read_buffer(php_stream *stream, size_t size) size 571 main/streams/streams.c while (!stream->eof && !err_flag && (stream->writepos - stream->readpos < (off_t)size)) { size 657 main/streams/streams.c if (stream->writepos - stream->readpos < (zend_off_t)size) { size 686 main/streams/streams.c PHPAPI size_t _php_stream_read(php_stream *stream, char *buf, size_t size) size 690 main/streams/streams.c while (size > 0) { size 699 main/streams/streams.c if (toread > size) { size 700 main/streams/streams.c toread = size; size 705 main/streams/streams.c size -= toread; size 711 main/streams/streams.c if (size == 0) { size 716 main/streams/streams.c toread = stream->ops->read(stream, buf, size); size 722 main/streams/streams.c php_stream_fill_read_buffer(stream, size); size 725 main/streams/streams.c if (toread > size) { size 726 main/streams/streams.c toread = size; size 737 main/streams/streams.c size -= toread; size 301 main/streams/userspace.c fci.size = sizeof(fci); size 858 main/streams/userspace.c STAT_PROP_ENTRY(size); size 236 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 1151 sapi/phpdbg/phpdbg.c socklen_t size = sizeof(address); size 1154 sapi/phpdbg/phpdbg.c memset(&address, 0, size); size 1155 sapi/phpdbg/phpdbg.c *socket = accept(server, (struct sockaddr *) &address, &size); size 1261 sapi/phpdbg/phpdbg.c void *phpdbg_malloc_wrapper(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) /* {{{ */ size 1263 sapi/phpdbg/phpdbg.c return _zend_mm_alloc(zend_mm_get_heap(), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 1279 sapi/phpdbg/phpdbg.c void *phpdbg_realloc_wrapper(void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) /* {{{ */ size 1281 sapi/phpdbg/phpdbg.c return _zend_mm_realloc(zend_mm_get_heap(), ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); size 57 sapi/phpdbg/phpdbg_help.c unsigned int size = 0; size 73 sapi/phpdbg/phpdbg_help.c size += bold_escape_len - 2; size 76 sapi/phpdbg/phpdbg_help.c size += prompt_escape_len - 2; size 82 sapi/phpdbg/phpdbg_help.c size += (p-text)+1; size 84 sapi/phpdbg/phpdbg_help.c new = emalloc(size); size 136 sapi/phpdbg/phpdbg_help.c if ((q-new)>size) { size 137 sapi/phpdbg/phpdbg_help.c phpdbg_error("help", "overrun=\"%lu\"", "Output overrun of %lu bytes", ((q - new) - size)); size 122 sapi/phpdbg/phpdbg_prompt.c fci.size = sizeof(zend_fcall_info); size 9 sapi/phpdbg/phpdbg_sigsafe.c static void* zend_mm_mem_alloc(zend_mm_storage *storage, size_t size, size_t alignment) { size 11 sapi/phpdbg/phpdbg_sigsafe.c if (EXPECTED(size <= PHPDBG_SIGSAFE_MEM_SIZE && !PHPDBG_G(sigsafe_mem).allocated)) { size 27 sapi/phpdbg/phpdbg_sigsafe.c static void zend_mm_mem_free(zend_mm_storage *storage, void *ptr, size_t size) { size 101 sapi/phpdbg/phpdbg_watch.c size_t size; size 107 sapi/phpdbg/phpdbg_watch.c #define MEMDUMP_SIZE(size) (sizeof(phpdbg_watch_memdump) - sizeof(void *) + (size)) size 121 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 131 sapi/phpdbg/phpdbg_watch.c mprotect(phpdbg_get_page_boundary(watch->addr.ptr), phpdbg_get_total_page_size(watch->addr.ptr, watch->size), access); size 150 sapi/phpdbg/phpdbg_watch.c void phpdbg_create_addr_watchpoint(void *addr, size_t size, phpdbg_watchpoint_t *watch) { size 152 sapi/phpdbg/phpdbg_watch.c watch->size = size; size 812 sapi/phpdbg/phpdbg_watch.c size_t size; size 827 sapi/phpdbg/phpdbg_watch.c size = phpdbg_get_total_page_size(watch->addr.ptr, watch->size); size 830 sapi/phpdbg/phpdbg_watch.c mprotect(page, size, PROT_READ | PROT_WRITE); size 832 sapi/phpdbg/phpdbg_watch.c dump = malloc(MEMDUMP_SIZE(size)); size 834 sapi/phpdbg/phpdbg_watch.c dump->size = size; size 837 sapi/phpdbg/phpdbg_watch.c memcpy(&dump->data, page, size); size 882 sapi/phpdbg/phpdbg_watch.c mprotect(dump->page, dump->size, PROT_READ); size 912 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 925 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 1143 sapi/phpdbg/phpdbg_watch.c if ((size_t) watch->addr.ptr + watch->size > (size_t) ptr) { size 68 sapi/phpdbg/phpdbg_watch.h size_t size; size 99 sapi/phpdbg/phpdbg_watch.h void phpdbg_create_addr_watchpoint(void *addr, size_t size, phpdbg_watchpoint_t *watch); size 118 sapi/phpdbg/phpdbg_watch.h static zend_always_inline size_t phpdbg_get_total_page_size(void *addr, size_t size) { size 119 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 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 116 win32/winutil.c ret = CryptGenRandom(hCryptProv, (DWORD)size, buf); size 23 win32/winutil.h PHPAPI int php_win32_get_random_bytes(unsigned char *buf, size_t size);