allocate
pointer allocate(size_type n) {
return ::allocate((difference_type)n, (pointer)0);
(_CharT*)alloc::allocate(__len * sizeof(_CharT));
return Allocator::allocate(s + extra * sizeof (charT));
static void* allocate(size_t __n)
static _Tp* allocate(size_t __n)
{ return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
static _Tp* allocate(void)
{ return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
static void* allocate(size_t __n)
char* __result = (char*)_Alloc::allocate(__n + _S_extra);
static void* allocate(size_t __n)
return(malloc_alloc::allocate(__n));
_S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
__result = allocate(__new_sz);
_Tp* allocate(size_type __n, const void* = 0) {
return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)))
_Tp* allocate(size_type __n, const void* = 0) {
? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
{ return _M_data_allocator.allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
{ return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
{ return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
return node_allocator.allocate(__deque_buf_size(__bufsiz,sizeof(_Tp)));
{ return map_allocator.allocate(__n); }
{ return _Node_alloc_type::allocate(__deque_buf_size(__bufsiz,
{ return _Map_alloc_type::allocate(__n); }
{ return _Node_alloc_type::allocate(__deque_buf_size(__bufsiz,
{ return _Map_alloc_type::allocate(__n); }
_Node* _M_get_node() { return _M_node_allocator.allocate(1); }
_Node* _M_get_node() { return _M_node_allocator_type::allocate(1); }
{ return _Node_allocator.allocate(1); }
_List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
_List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
{ return __name##Allocator(_M_data_allocator).allocate(__n); } \
{ return __name##Alloc::allocate(__n); } \
{ return __name##Alloc::allocate(__n); } \
_RopeLeaf* __space = _LAllocator(__a).allocate(1);
_RopeConcatenation* __space = _CAllocator(__a).allocate(1);
_RopeFunction* __space = _FAllocator(__a).allocate(1);
_RopeSubstring* __space = _SAllocator(__a).allocate(1);
_CharT* __buf = __a.allocate(_S_rounded_up_size(__size));
{ return __name##Allocator(_M_data_allocator).allocate(__n); } \
{ return __name##Alloc::allocate(__n); } \
{ return __name##Alloc::allocate(__n); } \
{ return _M_node_allocator.allocate(1); }
_Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
_Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
{ return _M_node_allocator.allocate(1); }
{ return _Alloc_type::allocate(1); }
{ return _Alloc_type::allocate(1); }
{ return _M_data_allocator::allocate(__n); }
{ return _M_data_allocator.allocate(__n); }
{ return _Alloc_type::allocate(__n); }
int allocate() { // For AT&T compatibility
m_array(pod_allocator<T>::allocate(size)),
m_array(pod_allocator<T>::allocate(v.m_size)),
m_array = pod_allocator<T>::allocate(m_size = size);
void allocate(unsigned size, unsigned extra_tail=0);
m_array = m_capacity ? pod_allocator<T>::allocate(m_capacity) : 0;
void pod_vector<T>::allocate(unsigned size, unsigned extra_tail)
T* data = pod_allocator<T>::allocate(new_size);
m_array(pod_allocator<T>::allocate(m_capacity)) {}
m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
allocate(v.m_size);
allocate(byte_size);
pod_allocator<T*>::allocate(v.m_max_blocks) :
m_blocks[i] = pod_allocator<T>::allocate(block_size);
T** new_blocks = pod_allocator<T*>::allocate(m_max_blocks + m_block_ptr_inc);
m_blocks[nb] = pod_allocator<T>::allocate(block_size);
int8u* allocate(unsigned size, unsigned alignment=1)
return allocate(size - align, alignment);
return allocate(size, alignment);
pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
pod_allocator<int8u>::allocate(size);
static T* allocate(unsigned num) { return new T [num]; }
static T* allocate() { return new T; }
m_sum1.allocate(w);
m_sum2.allocate(w);
m_buf.allocate(w);
m_buf.allocate(w, 128);
m_stack.allocate(div, 32);
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
(glyph_cache*)m_allocator.allocate(sizeof(glyph_cache),
glyph->data = m_allocator.allocate(data_size);
m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
m_fonts[idx] = obj_allocator<font_cache>::allocate();
m_fonts[m_num_fonts] = obj_allocator<font_cache>::allocate();
m_font_signature = (char*)m_allocator.allocate(strlen(font_signature) + 1);
(glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256,
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
pod_allocator<T>::allocate(block_size * 2 +
pod_allocator<cell_type*>::allocate(m_max_blocks +
pod_allocator<cell_type>::allocate(cell_block_size);
m_sorted_cells.allocate(m_num_cells, 16);
m_sorted_y.allocate(m_max_y - m_min_y + 1, 16);
m_styles.allocate(m_max_style - m_min_style + 2, 128);
m_cells.allocate(num_cells * 2, 256); // Each cell can have two styles
m_asm.allocate((num_styles + 7) >> 3, 8);
m_styles.allocate(m_max_style - m_min_style + 2, 128);
m_cover_buf.allocate(len, 256);
typename BaseRenderer::color_type* colors = alloc.allocate(len);
typename BaseRenderer::color_type* colors = alloc.allocate(len);
color_type* color_span = alloc.allocate(len * 2);
int8u* p = pod_allocator<int8u>::allocate(m_byte_width);
s.ptr = pod_allocator<T>::allocate(num_cells);
dst.ptr = pod_allocator<T>::allocate(dst.len);
AGG_INLINE color_type* allocate(unsigned span_len)
ZYCORE_EXPORT ZyanStatus ZyanAllocatorInit(ZyanAllocator* allocator, ZyanAllocatorAllocate allocate,
ZyanAllocatorAllocate allocate;
bool allocate);
goto allocate;
goto allocate;
goto allocate;
goto allocate;
goto allocate;
allocate:
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
stack.allocate(div);
ZyanStatus ZyanAllocatorInit(ZyanAllocator* allocator, ZyanAllocatorAllocate allocate,
if (!allocator || !allocate || !reallocate || !deallocate)
allocator->allocate = allocate;
ZYAN_ASSERT(list->allocator->allocate);
ZYAN_CHECK(list->allocator->allocate(list->allocator, (void**)node,
ZYAN_ASSERT(allocator->allocate);
return allocator->allocate(vector->allocator, &vector->data, vector->element_size,
bool allocate)
if (owner != NULL || !allocate)
bool allocate);
vfs_get_vnode_cache(struct vnode* vnode, VMCache** _cache, bool allocate)
if (allocate) {
m.allocate((int)sb->getNumBlocks() *
if (fFree >= allocate) {
FreeChunk* chunk = fChunksBySizeTree.FindClosest(allocate, true, true);
address = _Use(chunk, allocate);
status_t status = _Map(allocate, chunk, mostlyClear);
address = _Use(chunk, allocate);
status_t AllocatePagesAt(void* _address, size_t allocate, bool& cleared)
if (allocate <= kLargestUsefulChunk) {
if (remainingAfter < allocate) {
size_t add = allocate - remainingAfter;
_Use(chunk, allocate);
if (allocate > kLargestUsefulChunk)
status_t status = _ResizeLastArea(allocate);
fUsed += allocate;
status = resize_area(info.area, info.size + allocate);
fUsed += allocate;
status_t _Map(size_t allocate, FreeChunk*& allocated, bool& mostlyClear)
status_t status = _ResizeLastArea(allocate);
allocated = _Insert((void*)oldTop, allocate);
allocate, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
fLastAreaTop = newAreaBase + allocate;
fLastAreaSize = allocate;
allocated = _Insert((void*)newAreaBase, allocate);
status_t AllocatePages(size_t allocate, void*& address, bool& cleared)
if (allocate > kLargestUsefulChunk) {
&address, B_ANY_ADDRESS, allocate,
fUsed += allocate;
allocate(aperture, 2 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);
allocate(aperture, 4 * B_PAGE_SIZE, 0, B_APERTURE_NON_RESERVED, base[1],
allocate(aperture, 1 * B_PAGE_SIZE, 0, B_APERTURE_NEED_PHYSICAL, base[2],
allocate(aperture, 1 * B_PAGE_SIZE, 4 * B_PAGE_SIZE, 0, base[2],
allocate(aperture, 5 * B_PAGE_SIZE, 0, 0, base[1], physical[1]);
allocate(aperture, 25 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);
allocate(aperture, 4 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);
allocate(start, length);