void* operator new[] (size_t size) throw (bad_alloc) { if (m_poolManager.init != B_OK) throw bad_alloc(); void* ret = rtm_alloc(m_poolManager.pool, size); if (! ret) throw bad_alloc(); return ret; }
_LIBCPP_HIDDEN __i_node* __libcpp_db::__insert_iterator(void* __i) { if (__isz_ + 1 > __iend_ - __ibeg_) { size_t nc = __next_prime(2*(__iend_ - __ibeg_) + 1); __i_node** ibeg = (__i_node**)calloc(nc, sizeof(void*)); if (ibeg == nullptr) throw bad_alloc(); for (__i_node** p = __ibeg_; p != __iend_; ++p) { __i_node* q = *p; while (q != nullptr) { size_t h = hash<void*>()(q->__i_) % nc; __i_node* r = q->__next_; q->__next_ = ibeg[h]; ibeg[h] = q; q = r; } } free(__ibeg_); __ibeg_ = ibeg; __iend_ = __ibeg_ + nc; } size_t hi = hash<void*>()(__i) % (__iend_ - __ibeg_); __i_node* p = __ibeg_[hi]; __i_node* r = __ibeg_[hi] = (__i_node*)malloc(sizeof(__i_node)); if (r == nullptr) throw bad_alloc(); ::new(r) __i_node(__i, p, nullptr); ++__isz_; return r; }
// returns the data of the uninstaller icon that should replace the installer icon data // return values: // 0 - Bad icon file // Anything else - Pointer to the uninstaller icon data unsigned char* generate_uninstall_icon_data(char* filename) { int i; FILE* f = fopen(filename, "rb"); if (!f) return 0; IconGroupHeader igh; if (!fread(&igh, sizeof(IconGroupHeader), 1, f)) return 0; if (igh.wIsIcon != 1 && igh.wReserved != 0) return 0; int iNewIconSize = 0; FileIconGroupEntry ige; DWORD* offsets = (DWORD*)malloc(sizeof(DWORD)*igh.wCount); DWORD* rawSizes = (DWORD*)malloc(sizeof(DWORD)*igh.wCount); if (!offsets || !rawSizes) throw bad_alloc(); for (i = 0; i < igh.wCount; i++) { if (!fread(&ige, sizeof(FileIconGroupEntry), 1, f)) return 0; offsets[i] = ige.dwImageOffset; rawSizes[i] = ige.dwRawSize; iNewIconSize += ige.dwRawSize; } // Before each icon come two DWORDs, one for size and the other for offset (set later) // The last size is 0, no offset iNewIconSize += sizeof(DWORD)*(1 + igh.wCount*2); BYTE* pbUninstIcon = (BYTE*)malloc(iNewIconSize); if (!pbUninstIcon) throw bad_alloc(); BYTE* seeker = pbUninstIcon; for (i = 0; i < igh.wCount; i++) { *(DWORD*)seeker = rawSizes[i]; seeker += sizeof(DWORD); *(DWORD*)seeker = 0; seeker += sizeof(DWORD); fseek(f, offsets[i], SEEK_SET); fread(seeker, 1, rawSizes[i], f); seeker += rawSizes[i]; } // This is how we know there are no more icons (size = 0) *(DWORD*)seeker = 0; free(offsets); free(rawSizes); unicondata_size = iNewIconSize; return pbUninstIcon; }
void* single_alloc(size_t size) { if ( size > SINGLE_ALLOC_THRESHOLD ) { return ::operator new(size); } sx_SingleAllocMutex.Lock(); size_t pool_size = single_alloc_pool_size; char* pool; if ( size > pool_size ) { pool_size = SINGLE_ALLOC_POOL_SIZE; pool = (char*) malloc(pool_size); if ( !pool ) { sx_SingleAllocMutex.Unlock(); throw bad_alloc(); } single_alloc_pool = pool; single_alloc_pool_size = pool_size; } else { pool = single_alloc_pool; } single_alloc_pool = pool + size; single_alloc_pool_size = pool_size - size; sx_SingleAllocMutex.Unlock(); return pool; }
void __c_node::__add(__i_node* i) { if (end_ == cap_) { size_t nc = 2*static_cast<size_t>(cap_ - beg_); if (nc == 0) nc = 1; __i_node** beg = static_cast<__i_node**>(malloc(nc * sizeof(__i_node*))); if (beg == nullptr) #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else abort(); #endif if (nc > 1) memcpy(beg, beg_, nc/2*sizeof(__i_node*)); free(beg_); beg_ = beg; end_ = beg_ + nc/2; cap_ = beg_ + nc; } *end_++ = i; }
/** * Print error and and throw an exception * @throw bad_alloc * * @param [in] FMT - format of error * @param [in] HDF5MatrixName - HDF5 dataset name * @param [in] File File of error * @param [in] Line Line of error * */ void TMatrixContainer::PrintErrorAndThrowException(const char * FMT, const string HDF5MatrixName, const char * File, const int Line){ fprintf(stderr,FMT, HDF5MatrixName.c_str(), File, Line); throw bad_alloc(); }// end of PrintErrorAndAbort
/* Construct a matching table for specified hashtable, original and new files. */ JMatchTable::JMatchTable (JHashPos const * const cpHsh, JFile * const apFilOrg, JFile * const apFilNew, const bool abCmpAll) : mpHsh(cpHsh), mpFilOrg(apFilOrg), mpFilNew(apFilNew), mbCmpAll(abCmpAll) { // allocate table // TODO only allocate max number of elements msMch = (rMch *) malloc(sizeof(rMch) * MCH_MAX) ; #ifndef __MINGW32__ if ( msMch == null ) { throw bad_alloc() ; } #endif // initialize linked list of free nodes for (int liIdx=0; liIdx < MCH_MAX - 1; liIdx++) { msMch[liIdx].ipNxt = &msMch[liIdx + 1]; } msMch[MCH_MAX - 1].ipNxt = null ; mpMchFre = msMch ; memset(mpMch, 0, MCH_PME * sizeof(tMch *)); // initialize other values mpMchGld = null; mzGldDlt = 0 ; }
__c_node* __libcpp_db::__insert_c(void* __c) { #ifndef _LIBCPP_HAS_NO_THREADS WLock _(mut()); #endif if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_)) { size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1); __c_node** cbeg = static_cast<__c_node**>(calloc(nc, sizeof(void*))); if (cbeg == nullptr) #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else abort(); #endif for (__c_node** p = __cbeg_; p != __cend_; ++p) { __c_node* q = *p; while (q != nullptr) { size_t h = hash<void*>()(q->__c_) % nc; __c_node* r = q->__next_; q->__next_ = cbeg[h]; cbeg[h] = q; q = r; } } free(__cbeg_); __cbeg_ = cbeg; __cend_ = __cbeg_ + nc; } size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_); __c_node* p = __cbeg_[hc]; __c_node* r = __cbeg_[hc] = static_cast<__c_node*>(malloc(sizeof(__c_node))); if (__cbeg_[hc] == nullptr) #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else abort(); #endif r->__c_ = __c; r->__next_ = p; ++__csz_; return r; }
void EncryptionModeLRW::SetKey (const ConstBufferPtr &key) { if (key.Size() != 16) throw ParameterIncorrect (SRC_POS); if (!KeySet) GfContext.Allocate (sizeof (GfCtx)); if (!Gf64TabInit ((unsigned char *) key.Get(), (GfCtx *) (GfContext.Ptr()))) throw bad_alloc(); if (!Gf128Tab64Init ((unsigned char *) key.Get(), (GfCtx *) (GfContext.Ptr()))) throw bad_alloc(); Key.CopyFrom (key); KeySet = true; }
void __throw_bad_alloc() { #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else _VSTD::abort(); #endif }
_LIBCPP_HIDDEN __i_node* __libcpp_db::__insert_iterator(void* __i) { if (__isz_ + 1 > static_cast<size_t>(__iend_ - __ibeg_)) { size_t nc = __next_prime(2*static_cast<size_t>(__iend_ - __ibeg_) + 1); __i_node** ibeg = static_cast<__i_node**>(calloc(nc, sizeof(void*))); if (ibeg == nullptr) #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else abort(); #endif for (__i_node** p = __ibeg_; p != __iend_; ++p) { __i_node* q = *p; while (q != nullptr) { size_t h = hash<void*>()(q->__i_) % nc; __i_node* r = q->__next_; q->__next_ = ibeg[h]; ibeg[h] = q; q = r; } } free(__ibeg_); __ibeg_ = ibeg; __iend_ = __ibeg_ + nc; } size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_); __i_node* p = __ibeg_[hi]; __i_node* r = __ibeg_[hi] = static_cast<__i_node*>(malloc(sizeof(__i_node))); if (r == nullptr) #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else abort(); #endif ::new(r) __i_node(__i, p, nullptr); ++__isz_; return r; }
void GUI_MemoryHog::our_new_handler() { for(set<GUI_MemoryHog *>::iterator h = sHogs.begin(); h != sHogs.end(); ++h) { if ((*h)->ReleaseMemory()) return; } if (sOldHandler) sOldHandler(); else throw bad_alloc(); }
cn_context::cn_context() { #if !defined(__APPLE__) data = mmap(nullptr, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0); #else data = mmap(nullptr, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); #endif if (data == MAP_FAILED) { throw bad_alloc(); } mlock(data, MAP_SIZE); }
void *Memory::Allocate (std::size_t size) { if (size < 1) throw ParameterIncorrect (SRC_POS); void *bufPtr = malloc (size); if (!bufPtr) throw bad_alloc(); return bufPtr; }
/** * Memory allocation based on the total number of elements. \n * Memory is aligned by the SSE_ALIGNMENT and all elements are zeroed. */ void TBaseLongMatrix::AllocateMemory(){ /* No memory allocated before this function*/ pMatrixData = (long *) memalign(SSE_ALIGNMENT,pTotalAllocatedElementCount * sizeof (long)); if (!pMatrixData) { fprintf(stderr,Matrix_ERR_FMT_NotEnoughMemory, "TBaseLongMatrix"); throw bad_alloc(); } ZeroMatrix(); }// end of AllocateMemory
__c_node* __libcpp_db::__insert_c(void* __c) { WLock _(mut()); if (__csz_ + 1 > __cend_ - __cbeg_) { size_t nc = __next_prime(2*(__cend_ - __cbeg_) + 1); __c_node** cbeg = (__c_node**)calloc(nc, sizeof(void*)); if (cbeg == nullptr) throw bad_alloc(); for (__c_node** p = __cbeg_; p != __cend_; ++p) { __c_node* q = *p; while (q != nullptr) { size_t h = hash<void*>()(q->__c_) % nc; __c_node* r = q->__next_; q->__next_ = cbeg[h]; cbeg[h] = q; q = r; } } free(__cbeg_); __cbeg_ = cbeg; __cend_ = __cbeg_ + nc; } size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_); __c_node* p = __cbeg_[hc]; __c_node* r = __cbeg_[hc] = (__c_node*)malloc(sizeof(__c_node)); if (__cbeg_[hc] == nullptr) throw bad_alloc(); r->__c_ = __c; r->__next_ = p; ++__csz_; return r; }
void *FreeListNode::getBlock() { ChunkHeader *chunk; void *block; // если chunk в m_freeList берем его оттуда и кладем в m_usedList if (m_freeList) { //1. берем chunk из m_freeList chunk = m_freeList; m_freeList = chunk->next; if (m_freeList) m_freeList->last = NULL; // кладем в m_usedList chunk->next = m_usedList; if (m_usedList) { m_usedList->last = chunk; } m_usedList = chunk; return (void *)((char *)m_usedList + sizeof(ChunkHeader)); } // иначе создаем новой chunk и кледем его в m_usedList else { size_t chunkSize = sizeof(ChunkHeader) + m_blockSize; block = malloc(chunkSize); if (!block) throw bad_alloc(); ChunkHeader *chunk = (ChunkHeader *)block; chunk->size = m_blockSize; if (m_usedList) { m_usedList->last = chunk; chunk->next = m_usedList; chunk->last = NULL; m_usedList = chunk; } else { chunk->last = chunk->next = (ChunkHeader*) NULL; m_usedList = chunk; } } return (void *)((char*)block + sizeof(ChunkHeader)); }
/// \brief Reallocates internal block to hold at least \p newSize bytes. /// /// Additional memory may be allocated, but for efficiency it is a very /// good idea to call reserve before doing byte-by-byte edit operations. /// The block size as returned by size() is not altered. reserve will not /// reduce allocated memory. If you think you are wasting space, call /// deallocate and start over. To avoid wasting space, use the block for /// only one purpose, and try to get that purpose to use similar amounts /// of memory on each iteration. /// void memblock::reserve (size_type newSize, bool bExact) { if ((newSize += minimumFreeCapacity()) <= m_Capacity) return; pointer oldBlock (is_linked() ? NULL : data()); const size_t alignedSize (Align (newSize, 64)); if (!bExact) newSize = alignedSize; pointer newBlock = (pointer) realloc (oldBlock, newSize); if (!newBlock) USTL_THROW(bad_alloc (newSize)); if (!oldBlock & (cdata() != NULL)) copy_n (cdata(), min (size() + 1, newSize), newBlock); link (newBlock, size()); m_Capacity = newSize; }
float *getFFT(const void *matData, const Size &imSz, const fftwf_plan &plan) { float *fft = (float *)fftwf_malloc_thr(sizeof(float) * getFFTLen(imSz)); if (!fft) { throw bad_alloc(); } int inI = 0, outI = 0; for (int r = 0; r < imSz.height; r++) { for (int c = 0; c < imSz.width; c++) { fft[outI++] = ((const float *)matData)[inI++]; if (((const float *)matData)[inI - 1] != ((const float *)matData)[inI - 1]) { //printf(" UH UH %d %d\n", r, c); } } fft[outI++] = 0; // zero-pad twice fft[outI++] = 0; } fftwf_execute_dft_r2c(plan, fft, (fftwf_complex *)fft); // testing // static mutex mut; // mut.lock(); // Mat im(imSz, CV_32FC1, (void *)matData); // // double minVal, maxVal; // Point minLoc, maxLoc; // // minMaxLoc(im, &minVal, &maxVal, &minLoc, &maxLoc); // printf("min: %lf, (%d, %d)\n", minVal, minLoc.x, minLoc.y); // printf("max: %lf, (%d, %d)\n", maxVal, maxLoc.x, maxLoc.y); // imshow("hn", im); // waitKey(0); // mut.unlock(); // // Mat matDatam(imSz.height, imSz.width+2, CV_32F, (float *)fft); // minMaxLoc(matDatam, &minVal, &maxVal, &minLoc, &maxLoc); // printf("min: %lf, (%d, %d)\n", minVal, minLoc.x, minLoc.y); // printf("max: %lf, (%d, %d)\n", maxVal, maxLoc.x, maxLoc.y); // // imshow("immmmm", matDatam); // waitKey(0); // return fft; }
AutoMatrix& AutoMatrix::operator= ( const AutoMatrix& original ) { if ( this != &original ) { const size_t rows = original.countRows(), cols = original.countColumns(); const size_t used = calculateSize( rows, cols ); double* newArray; if ( used <= size ) { newArray = matrix.data; } else { newArray = static_cast<double*>( malloc( used ) ); if ( NULL == newArray ) { throw bad_alloc(); } free( matrix.data ); matrix.data = newArray; size = used; } gslInit( rows, cols, newArray, calculateSize( rows, original.matrix.tda ) <= size ? original.matrix.tda : cols // try to copy tda ); // the following copy is like in the copy constructor if ( cols == original.matrix.tda ) { // copy one big lump memcpy( matrix.data, original.matrix.data, used ); } else { // copy row by row const size_t blockSize = cols * sizeof( double ); const double *source = original.matrix.data; double *target = matrix.data; for ( size_t row = 0; row < rows; ++row ) { memcpy( target, source, blockSize ); source += original.matrix.tda; target += matrix.tda; } } } return *this; }
/// \brief Reallocates internal block to hold at least \p newSize bytes. /// /// Additional memory may be allocated, but for efficiency it is a very /// good idea to call reserve before doing byte-by-byte edit operations. /// The block size as returned by size() is not altered. reserve will not /// reduce allocated memory. If you think you are wasting space, call /// deallocate and start over. To avoid wasting space, use the block for /// only one purpose, and try to get that purpose to use similar amounts /// of memory on each iteration. /// void memblock::reserve (size_type newSize, bool bExact) { if ((newSize += minimumFreeCapacity()) <= m_Capacity) return; void* oldBlock (is_linked() ? NULL : data()); if (!bExact) newSize = Align (newSize, c_PageSize); pointer newBlock = (pointer) realloc (oldBlock, newSize); if (!newBlock) #if PLATFORM_ANDROID printf("bad_alloc\n"); #else throw bad_alloc (newSize); #endif if (!oldBlock && cdata()) copy_n (cdata(), min (size() + 1, newSize), newBlock); link (newBlock, size()); m_Capacity = newSize; }
_CONCRTIMP void* NFS_Allocate( size_t n, size_t element_size, void*) { size_t m = NFS_LineSize; _CONCRT_ASSERT( m<=NFS_MaxLineSize ); // illegal value for NFS_LineSize _CONCRT_ASSERT( (m & m-1)==0 ); // must be power of two size_t bytes = n*element_size; unsigned char* base; if( bytes<n || bytes+m<bytes || !(base=(unsigned char*)(malloc(m+bytes))) ) { // Overflow throw bad_alloc(); } // Round up to next line unsigned char* result = (unsigned char*)((size_t)(base+m)&-m); // Record where block actually starts. ((size_t*)result)[-1] = size_t(base); _CONCRT_ASSERT( ((size_t)result&(m-1)) == 0 ); // The address returned isn't aligned to cache line size return result; }
MP_Var_Array_c<TYPE>& MP_Var_Array_c<TYPE>::operator=(const MP_Var_Array_c<TYPE>& cSource){ TYPE* tmp; // check for self-assignment if (this == &cSource) return *this; // First we need to copy the elements nElem = cSource.nElem; maxNElem = cSource.maxNElem; blockSize = cSource.blockSize; // Second we need to allocate memory for our copy tmp = (TYPE*) malloc((maxNElem+blockSize)*sizeof(TYPE)); if(tmp == NULL) throw bad_alloc(); // Third we need to deallocate any value that elem is holding! free(elem); // allocate memory for our copy elem = tmp; // Copy the parameter the newly allocated memory memcpy(elem, cSource.elem, nElem*sizeof(TYPE)); return *this; }
_LIBCPP_HIDDEN void __c_node::__add(__i_node* i) { if (end_ == cap_) { size_t nc = 2*(cap_ - beg_); if (nc == 0) nc = 1; __i_node** beg = (__i_node**)malloc(nc * sizeof(__i_node*)); if (beg == nullptr) throw bad_alloc(); if (nc > 1) memcpy(beg, beg_, nc/2*sizeof(__i_node*)); free(beg_); beg_ = beg; end_ = beg_ + nc/2; cap_ = beg_ + nc; } *end_++ = i; }
void *operator new[](size_t i) { i += sizeof(MemoryRecord); BufferID id; void *p = NULL; if(pBufferSuite != NULL) { SPErr iErr = pBufferSuite->allocateProc(i, &id); if(!iErr) { p = pBufferSuite->lockProc(id, 0); } } else { p = malloc(i); } if(p == NULL) { #if defined(DEBUG) printf("Allocation failure of %i bytes, current allocation %i, peak %i\n", i, g_iTotal, g_iPeak); #endif throw bad_alloc(); } MemoryRecord *pRec = (MemoryRecord *) p; pRec->id = id; #if defined(DEBUG) pRec->iSize = i; AdjustMemory(pRec, true); #endif return pRec + 1; }
void Stack::push(int a){ if(height == 0){ tab = new int[1]; tab[0] = a; height++; } else { int* temp = new int[height +1]; if (temp == NULL) throw bad_alloc(); memcpy(temp + 1, tab, height*sizeof(int)); temp[0] = a; delete[] tab; tab = temp; height++; } }
void Stack::pop(){ if(height == 0) { return; } if(height == 1) { height--; delete[] tab; tab = NULL; } else { int* temp = new int[height - 1]; if(temp == NULL) throw bad_alloc(); memcpy(temp, tab + 1 , (height-1) * sizeof(int)); delete[] tab; tab = temp; height--; } }
void __throw_bad_alloc() { throw bad_alloc(); }
void *operator new(size_t size) { void *p = malloc(size); if (!p) throw bad_alloc(); return p; }
// Returns 0 if everything is OK // Returns -1 if can't find the file // Returns -2 if the file is an invalid bitmap // Returns -3 if the size doesn't match // Returns -4 if the bpp doesn't match int update_bitmap(CResourceEditor* re, WORD id, char* filename, int width/*=0*/, int height/*=0*/, int maxbpp/*=0*/) { FILE *f = fopen(filename, "rb"); if (!f) return -1; if (fgetc(f) != 'B' || fgetc(f) != 'M') { fclose(f); return -2; } if (width != 0) { LONG biWidth; fseek(f, 18, SEEK_SET); // Seek to the width member of the header fread(&biWidth, sizeof(LONG), 1, f); if (width != biWidth) { fclose(f); return -3; } } if (height != 0) { LONG biHeight; fseek(f, 22, SEEK_SET); // Seek to the height member of the header fread(&biHeight, sizeof(LONG), 1, f); // Bitmap height can be negative too... if (height != abs(biHeight)) { fclose(f); return -3; } } if (maxbpp != 0) { WORD biBitCount; fseek(f, 28, SEEK_SET); // Seek to the height member of the header fread(&biBitCount, sizeof(WORD), 1, f); if (biBitCount > maxbpp) { fclose(f); return -4; } } DWORD dwSize; fseek(f, 2, SEEK_SET); fread(&dwSize, sizeof(DWORD), 1, f); dwSize -= 14; unsigned char* bitmap = (unsigned char*)malloc(dwSize); if (!bitmap) throw bad_alloc(); fseek(f, 14, SEEK_SET); if (fread(bitmap, 1, dwSize, f) != dwSize) { fclose(f); return -2; } fclose(f); re->UpdateResource(RT_BITMAP, MAKEINTRESOURCE(id), MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), bitmap, dwSize); free(bitmap); return 0; }