void Blocks::build() { int i = 0, j = 0, k = 0; int halfSize = 0; int round = 0; bool * block; /////////////////////////////// block = newBlock(); block[0] = one; build(block, 1); if (size >= 5) { halfSize = size % 2 == 0 ? (size / 2) : (size - 1) / 2; for (i = 1; i < halfSize; i++) { for (j = 1, round = 0; j < halfSize; j++) { round = 0; block = newBlock(); for (k = 0; k < j; k++) { block[convert(i, k)] = one; round++; } for (k = 0; k < i; k++) { block[convert(k, j)] = one; round++; } block[convert(i, j)] = one; round++; build(block, round); } } } }
void initMainGameTable() { int i; int j; int x,y; /* malloc memory space for blocks */ for(i=0;i<VBLOCKS;i++) for(j=0;j<HBLOCKS;j++){ gameTable[i][j]=newBlock(); } printf("Block table malloced\n"); /* assign positions to malloced blocks */ for(i=0,y=0;i<VBLOCKS;i++) for(j=0,x=0;j<HBLOCKS;j++) setBlock(gameTable[i][j],j,i); printf("Blocks placed\n"); }
block_ptr XML::getChildren(const node_ptr spec, bool nested) { block_ptr startBlock, curBlock; node_ptr tmpSpec(spec); while (tmpSpec) { block_ptr newBlock(new blocks::Block); getOpArgs(tmpSpec, newBlock); if (curBlock == nullptr) { startBlock = newBlock; curBlock = startBlock; } else { curBlock->next(newBlock); curBlock = curBlock->next(); } tmpSpec.reset(tmpSpec->next_sibling(), null_deleter()); } if (!nested) { curBlock->next(startBlock); } return startBlock; }
void GalFile::readFile(const QString &fileName) { QFile file(fileName); if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) return; QTextStream in(&file); QString line = in.readLine().simplified(); if (line.toUpper().startsWith("ATF")) _metaData.insert("version",line.split(QRegExp("[,\\s+]")).last()); else qDebug() << "no Gal file"; QStringList headndata = in.readLine().simplified().split(QRegExp("\\s+")); int headCount = headndata.first().toInt(); _colCount = headndata.last().toInt(); QRegExp blockRx("Block[0-9]+"); QRegExpValidator blockV(blockRx, 0); int pos=0; while (!in.atEnd() && headCount > 0) { QStringList headline = in.readLine().simplified().split('='); if(blockV.validate(headline.first(),pos)) newBlock(headline.first().mid(5).toInt(),headline.last()); else _metaData.insert(headline.first(),headline.last()); headCount--; } qDebug() << _blocks.count(); setColumnHeader(in.readLine().simplified()); while (!in.atEnd()) { setSpotData(in.readLine().simplified().remove("\"")); } emit fileRead(); }
blockDescriptor* newTBlock() { blockDescriptor* block = newBlock(2, 3); //### // # block->rotations[0][0][0] = '#'; block->rotations[0][0][1] = '#'; block->rotations[0][0][2] = '#'; block->rotations[0][1][1] = '#'; // # //### block->rotations[2][0][1] = '#'; block->rotations[2][1][0] = '#'; block->rotations[2][1][1] = '#'; block->rotations[2][1][2] = '#'; //# //## //# block->rotations[1][0][0] = '#'; block->rotations[1][1][0] = '#'; block->rotations[1][1][1] = '#'; block->rotations[1][2][0] = '#'; // # //## // # block->rotations[3][0][1] = '#'; block->rotations[3][1][0] = '#'; block->rotations[3][1][1] = '#'; block->rotations[3][2][1] = '#'; return block; }
void loadObject(string pathname) { HandleList hl; static char fullPath[MAX_PATH_NAME]; hl = newBlock(HandleList); switch (pathname[0]) { case '/': strcpy(fullPath, pathname); break; case '~': strcpy(fullPath, expandPathname(pathname)); break; default: getcwd(fullPath, MAX_PATH_NAME); strcat(fullPath, "/"); strcat(fullPath, pathname); break; } hl->handle = dlopen(fullPath, RTLD_NOW); if (hl->handle == NULL) { freeBlock(hl); error("loadObject: %s", dlerror()); } hl->link = handles; handles = hl; }
Map cloneMap(Map map) { Map newmap; newmap = newBlock(Map); enableIteration(newmap, newMapIterator); newmap->bst = cloneBST(map->bst); return newmap; }
Map newMap() { Map map; map = newBlock(Map); enableIteration(map, newMapIterator); map->bst = newBST(string); return map; }
FifoFreeStoreWithoutTLS::FifoFreeStoreWithoutTLS () : m_pages (GlobalPagedFreeStore::getInstance ()) { if (m_pages->getPageBytes () < sizeof (Block) + 256) Throw (Error ().fail (__FILE__, __LINE__, TRANS ("the block size is too small"))); m_active = newBlock (); }
void* my_alloc(int size){ int leftOver = size%sizeof(void*); size +=leftOver; Block* open_block = free_head; Block* previous_block = NULL; int req_size = size+overhead; while(open_block){ if(size <= open_block->block_size){ //split and add head printf("Head Block Size:%i\n",free_head->block_size); if(req_size<=free_head->block_size){ //free_head->block_size = size; free_head = (Block*)newBlock(free_head,req_size); return &open_block->data; //split and not add head }else if(req_size<=open_block->block_size){ previous_block->next_block =(Block*) newBlock(open_block,req_size); open_block->next_block = NULL; open_block->block_size = size; return &open_block->data; //not split and add head }else if(req_size>free_head->block_size){ free_head = free_head->next_block; open_block->next_block = NULL; return &open_block->data; //not split and add head }else{ previous_block = open_block; return &previous_block->data; } }else{ previous_block = open_block; open_block = open_block->next_block; } } return 0; }
void JitWriter::startBlock(const FrameState* frame) { newBlock(frame->abc_pc, frame); MethodSignaturep signature = method_->getMethodSignature(); const Type** types = new (abc_->alloc0()) const Type*[signature->frame_size()]; FrameRange<const FrameValue> from = range(&frame->value(0), frame, signature); FrameRange<const Type*> t = range(types, frame, signature); for (; !from.empty(); from.popFront(), t.popFront()) t.front() = jit_mgr_->lattice()->makeType(from.front()); current_block_->start_types = types; }
blockDescriptor* newColumnBlock() { blockDescriptor* block = newBlock(4, 1); for(int i = 0; i < 4; i++) { block->rotations[0][i][0] = '#'; block->rotations[2][i][0] = '#'; block->rotations[1][0][i] = '#'; block->rotations[3][0][i] = '#'; } return block; }
void GLSLShader::splitBranches() { // Conversion to StatementPtr overload is ambiguous otherwise. StatementPtr main_stmt(main); StatementPtr ref; while (IfCodeNodePtr p = findBranch(main_stmt, ref)) { CodeNodePtr condition = p->getChildren()[0]; CodeNodePtr truePart = p->getChildren()[1]; CodeNodePtr falsePart = p->getChildren()[2]; string name = newRegisterName(); CodeNodePtr nameReference( new NameCodeNode( name, p->getType(), p->getFrequency(), NullValue, ValueNode::BUILTIN)); // suitable substitute for local replace(main_stmt, p, nameReference); DeclarationPtr decl(new Declaration(p->getType(), name)); AssignmentPtr assignTrue(new Assignment); assignTrue->define = false; assignTrue->lhs = name; assignTrue->rhs = truePart; AssignmentPtr assignFalse(new Assignment); assignFalse->define = false; assignFalse->lhs = name; assignFalse->rhs = falsePart; IfStatementPtr ifst(new IfStatement); ifst->condition = condition; ifst->setTrue(assignTrue); ifst->setFalse(assignFalse); BlockPtr newBlock(new Block); newBlock->statements.push_back(decl); newBlock->statements.push_back(ifst); newBlock->statements.push_back(ref); if (main_stmt == ref) { REN_DYNAMIC_CAST_PTR(main, Block, ref); assert(main); main_stmt = main; } else { replace(main_stmt, ref, newBlock); } } }
blockDescriptor* newSquareBlock() { blockDescriptor* block = newBlock(2, 2); for(int i = 0; i < 4; i++) { for(int j = 0; j < 2; j++) { for(int k = 0; k < 2; k++) { block->rotations[i][j][k] = '#'; } } } return block; }
void MultiDataDistribution2D::addBlock(int x0, int x1, int y0, int y1, int envelopeWidth, int procId) { OLB_PRECONDITION( x0>=0 && y0>=0 ); OLB_PRECONDITION( x1<nx && y1<ny ); OLB_PRECONDITION( x0 <= x1 && y0 <= y1 ); BlockParameters2D newBlock(x0, x1, y0, y1, envelopeWidth, procId, x0==0, x1==nx-1, y0==0, y1==ny-1); computeNormalOverlaps(newBlock); blocks.push_back(newBlock); computePeriodicOverlaps(); }
void GLSLShader::share() { ReferenceMap rm; countReferences(main, rm); // std::cout << "++++\n"; // output(std::cout); // Conversion to StatementPtr overload is ambiguous otherwise. StatementPtr main_stmt(main); while (CodeNodePtr p = findMultiplyReferenced(main_stmt, rm)) { ReferenceList rl = rm[p]; ReferencePath prefix(getCommonPrefix(rl)); assert(prefix[0] == main); string name = newRegisterName(); CodeNodePtr nameReference( new NameCodeNode( name, p->getType(), p->getFrequency(), NullValue, ValueNode::BUILTIN)); // suitable substitute for local replace(main_stmt, p, nameReference); AssignmentPtr ns(new Assignment); ns->define = true; ns->lhs = name; ns->rhs = p; assert(!prefix.empty()); StatementPtr lastInCommonPrefix(prefix[prefix.size() - 1]); // Make a new block. BlockPtr newBlock(new Block); newBlock->statements.push_back(ns); newBlock->statements.push_back(lastInCommonPrefix); if (main_stmt == lastInCommonPrefix) { main = newBlock; main_stmt = main; } else { replace(main_stmt, lastInCommonPrefix, newBlock); } rm.clear(); countReferences(main, rm); // std::cout << "++++\n"; // output(std::cout); } }
Iterator newListIterator(int size, CompareFn cmpFn) { Iterator iterator; iterator = newBlock(Iterator); enableIteration(iterator, 0); iterator->elementSize = size; iterator->stepFn = stepListIterator; iterator->cmpFn = cmpFn; iterator->head = iterator->tail = NULL; iterator->data = NULL; return iterator; }
Iterator newStepIterator(int size, StepIteratorFn stepFn) { Iterator iterator; iterator = newBlock(Iterator); enableIteration(iterator, 0); iterator->elementSize = size; iterator->stepFn = stepFn; iterator->cmpFn = NULL; iterator->head = iterator->tail = NULL; iterator->data = NULL; return iterator; }
/* mkGrid: * Create grid data structure. * cellHint provides rough idea of how many cells * may be needed. */ Grid *mkGrid(int cellHint) { Grid *g; g = GNEW(Grid); _grid = g; /* see comment above */ g->data = dtopen(&gridDisc, Dtoset); g->listMem = 0; g->listSize = 0; g->cellMem = newBlock(cellHint); return g; }
/** This method is called by this->relocate when object that has shrunk * and so has left a bit of free space after itself on the file; * or when an object gets moved to a new spot. * * @param pos :: position in the file of the START of the new free block * @param size :: size of the free block */ void DiskBuffer::freeBlock(uint64_t const pos, uint64_t const size) { if (size == 0) return; m_freeMutex.lock(); // Make the block FreeBlock newBlock(pos, size); // Insert it std::pair<freeSpace_t::iterator,bool> p = m_free.insert( newBlock ); // Failed insert? Should not happen since the map is NOT unique // Or, if the map has only 1 item then it cannot do any merging. This solves a hanging bug in MacOS. Refs #3652 if (!p.second || m_free.size() <= 1) { m_freeMutex.unlock(); return; } // This is where we inserted freeSpace_t::iterator it = p.first; if (it != m_free.begin()) { freeSpace_t::iterator it_before = it; --it_before; // There is a block before FreeBlock block_before = *it_before; if (FreeBlock::merge(block_before, newBlock)) { // Change the map by replacing the old "before" block with the new merged one m_free.replace(it_before, block_before); // Remove the block we just inserted m_free.erase(it); // For cases where the new block was between two blocks. newBlock = block_before; it = it_before; } } // Get an iterator to the block AFTER this one freeSpace_t::iterator it_after = it; ++it_after; // There is a block after if (it_after != m_free.end()) { FreeBlock block_after = *it_after; if (FreeBlock::merge(newBlock, block_after)) { // Change the map by replacing the old "new" block with the new merged one m_free.replace(it, newBlock); // Remove the block that was after this one m_free.erase(it_after); } } m_freeMutex.unlock(); }
void EtherIPC::handleGetBlock() { QJsonValue jv; if ( !readReply(jv) ) { return bail(); } const QJsonObject block = jv.toObject(); const quint64 num = Helpers::toQUInt64(block.value("number")); emit getBlockNumberDone(num); emit newBlock(block); done(); }
bool * Blocks::blockCopy(bool block[]) { int i = 0, j = 0; bool * blockCopy; /////////////////////// blockCopy = newBlock(); for (i = 0; i < size; i++) { for (j = 0; j + i < size; j++) { blockCopy[convert(i, j)] = block[convert(i, j)]; } } return blockCopy; }
static autoBlock_t *GetSabun(autoBlock_t *fileImage1, autoBlock_t *fileImage2) { autoBlock_t *sabun = newBlock(); uint index; for(index = 0; index < getSize(fileImage2); index++) { int chr1 = refByte(fileImage1, index); int chr2 = getByte(fileImage2, index); addByte(sabun, chr1 ^ chr2); } return sabun; }
void *lmAlloc(struct lm *lm, size_t size) /* Allocate memory from local pool. */ { struct lmBlock *mb = lm->blocks; void *ret; size_t memLeft = mb->end - mb->free; if (memLeft < size) mb = newBlock(lm, size); ret = mb->free; mb->free += ((size+lm->allignAdd)&lm->allignMask); if (mb->free > mb->end) mb->free = mb->end; return ret; }
void run(StatementPtr s) { m_state = AstWalkerStateVec(s); m_pass = 1; m_cur = 0; newBlock(); m_head = m_cur; AstWalker::walk(*this, this->m_state, ConstructRawPtr(), ConstructRawPtr()); for (LabelInfoMap::iterator it = m_labelInfoMap.begin(), end = m_labelInfoMap.end(); it != end; ++it) { LabelInfo &li = it->second; if (li.first && li.second.size()) { for (GotoStatementPtrVec::iterator ii = li.second.begin(), ee = li.second.end(); ii != ee; ++ii) { addEdge(*ii, AfterConstruct, li.first, BeforeConstruct); } } } newBlock(); m_state = AstWalkerStateVec(s); m_pass = 2; m_cur = m_head; AstWalker::walk(*this, this->m_state, ConstructRawPtr(), ConstructRawPtr()); }
/* getCell: * Create a new cell using memory blocks. */ static cell *getCell(Grid * g) { cell *cp; block_t *bp = g->cellCur; /* current block */ if (bp->cur == bp->endp) { /* current block is full */ if (bp->next == 0) { bp->next = newBlock(2 * (bp->endp - bp->mem)); } bp = g->cellCur = bp->next; bp->cur = bp->mem; } cp = bp->cur++; return cp; }
static GObject newGObject(int type) { GObject gobj; gobj = newBlock(GObject); gobj->type = type; gobj->x = 0; gobj->y = 0; gobj->width = 0; gobj->height = 0; gobj->color = "BLACK"; gobj->fillColor = NULL; gobj->filled = false; gobj->visible = true; gobj->parent = NULL; return gobj; }
/* add a thunk block to get us out of an infinite loop */ static void makeNonInfinite(BLOCK *b) { BLOCKLIST *bi = newBlock(), *bi2, **bt; QUAD *quad, *quad2; blockArray[bi->block->blocknum] = bi->block; bi->block->unuseThunk = TRUE; bi->block->succ = oAlloc(sizeof(BLOCKLIST)); bi->block->succ->block = blockArray[exitBlock]; bi->block->pred = oAlloc(sizeof(BLOCKLIST)); bi->block->pred->block = b; bt = &b->succ; while (*bt) bt = &(*bt)->next; *bt = bi; bi2 = oAlloc(sizeof(BLOCKLIST)); bi2->block = bi->block; bt = &blockArray[exitBlock]->pred; while (*bt) bt = &(*bt)->next; *bt = bi2; /* note : the following does NOT insert jmps for the * newly added block */ *criticalThunkPtr = quad = Alloc(sizeof(QUAD)); criticalThunkPtr = & quad->fwd; quad->dc.opcode = i_block; quad->block = bi->block; quad->dc.v.label = bi->block->blocknum; *criticalThunkPtr = quad2 = Alloc(sizeof(QUAD)); criticalThunkPtr = & quad2->fwd; quad2->back = quad; quad2->dc.opcode = i_blockend; quad2->block = bi->block; // quad2->dc.v.label = bi->block->blocknum; bi->block->head = quad; bi->block->tail = quad2; }
/** Sets the free space map. Should only be used when loading a file. * @param[in] free :: vector containing free space index to set */ void DiskBuffer::setFreeSpaceVector(std::vector<uint64_t> &free) { m_free.clear(); if (free.size() % 2 != 0) throw std::length_error("Free vector size is not a factor of 2."); for (auto it = free.begin(); it != free.end(); it += 2) { auto it_next = boost::next(it); if (*it == 0 && *it_next == 0) { continue; // Not really a free space block! } FreeBlock newBlock(*it, *it_next); m_free.insert(newBlock); } }
void JitWriter::writeOp1(const FrameState* frame, const uint8_t *pc, AbcOpcode abcop, uint32_t opd1, Traits*) { analyze(abcop, pc, frame); if (needSavedScopes(pc, abcop)) abc_->abc_instrs.put(pc, new (abc_->alloc_) AbcInstr(abcop, opd1)); if (isBranchOpcode(abcop)) { const uint8_t* nextpc = pc + 4; int offset = int32_t(opd1); if (abcop == OP_jump) { abc_->analyzeEnd(current_block_, nextpc + offset); finishBlock(nextpc); } else { abc_->analyzeBranch(current_block_, abcop, nextpc, offset); finishBlock(nextpc); newBlock(nextpc, frame); } } }