extern void LSQ_DeleteElement(LSQ_HandleT handle, LSQ_IntegerIndexT key) { AVLTreeT *tree = (AVLTreeT *)handle; TreeNodeT *node = NULL, *parent = NULL; IteratorT * iter = (IteratorT *)LSQ_GetElementByIndex(handle, key); int new_key; if (!LSQ_IsIteratorDereferencable(iter)) return; parent = iter->node->parent; if (iter->node->l_child == NULL && iter->node->r_child == NULL) replaceNode(tree, iter->node, NULL); else if (iter->node->l_child != NULL && iter->node->r_child != NULL) { node = successor(iter->node); new_key = node->key; iter->node->value = node->value; LSQ_DeleteElement(handle, node->key); iter->node->key = new_key; return; } else if (iter->node->l_child != NULL) replaceNode(tree, iter->node, iter->node->l_child); else if (iter->node->r_child != NULL) replaceNode(tree, iter->node, iter->node->r_child); free(iter->node); tree->size--; restoreBalance(tree, parent, BT_AFTER_DELETE); }
void ConvHandler::cleanUp(Node node) { if (is_Conv(node)) { Node child = node.getChild(0); if (/*is_Conv(child) && */ node.getMode() == child.getMode()) replaceNode(node, child); else if (is_Const(child)) replaceNode(node, new_r_Const_long(irg, node.getMode(), child.getTarval().getLong())); else if (is_Conv(child)) set_irn_n(node, 0, child.getChild(0)); } }
void AABBTree::insertNode(AABBNode *nodeToInsert, AABBNode *currentNode) { if (currentNode->isLeaf()) { AABBNode *newParent = new AABBNode(nullptr); replaceNode(currentNode, newParent); newParent->setLeftChild(nodeToInsert); newParent->setRightChild(currentNode); newParent->updateAABBox(fatMargin); }else { const AABBox<float> &leftAABBox = currentNode->getLeftChild()->getAABBox(); float volumeDiffLeft = leftAABBox.merge(nodeToInsert->getAABBox()).getVolume() - leftAABBox.getVolume(); const AABBox<float> &rightAABBox = currentNode->getRightChild()->getAABBox(); float volumeDiffRight = rightAABBox.merge(nodeToInsert->getAABBox()).getVolume() - rightAABBox.getVolume(); if(volumeDiffLeft < volumeDiffRight) { insertNode(nodeToInsert, currentNode->getLeftChild()); }else { insertNode(nodeToInsert, currentNode->getRightChild()); } currentNode->updateAABBox(fatMargin); } }
bool TreeView::addToEntry(d3DisplayItem* entry, const osg::ref_ptr<osg::Node> node, const bool& enableNode, const bool& replace, d3DisplayItem* myParent) { // add in the new node (maybe replace) if ( replace ) return replaceNode(entry, node, enableNode, myParent); return appendNode(entry, node, enableNode, myParent); };
uint32 Lz77::addString(uint32 newNode, uint32 *matchPosition) { uint32 i; uint32 testNode; uint32 matchLength; uint32 *child; int delta = 0; DEBUG_FATAL(!matchPosition, ("matchPosition is NULL")); if (newNode == endOfStream) return 0; testNode = tree[treeRoot].largeChild; matchLength = 0; for (;;) { for (i = 0 ; i < lookAheadSize ; i++) { delta = window[modWindow(newNode + i)] - window[modWindow(testNode + i)]; if (delta != 0) break; } if (i >= matchLength) { matchLength = i; *matchPosition = testNode; if (matchLength >= lookAheadSize) { replaceNode(testNode, newNode); return(matchLength); } } if (delta >= 0) child = &tree[testNode].largeChild; else child = &tree[testNode].smallChild; if (*child == unused) { *child = newNode; tree[newNode].parent = testNode; tree[newNode].largeChild = unused; tree[newNode].smallChild = unused; return(matchLength); } testNode = *child; } }
int main(int argc, char* argv[]){ char buffer[BUFFER_SIZE]; int index, pages; int requests = 0; int faults = 0; if(argc < 1){ printf("Too many arguments. Please look at documentation to compile.\n"); return 0; } sscanf(argv[1], "%d", &pages); List* list = create(pages); FILE* fp = fopen("out.txt", "w"); assert(fp != NULL); while(fgets(buffer, sizeof(buffer), stdin) != NULL) { if(!isdigit((int)buffer[0])) continue; sscanf(buffer, "%d", &index); requests++; if(findNode(list, index) != NULL){ setNodeRef(list, index, requests); } else{ if(listFull(list)){ replaceNode(list, findMinNode(list), index); setNodeRef(list, index, requests); } else{ insertNode(list, index, 0 ,0); setNodeRef(list, index, requests); } faults++; assert(fprintf(fp, "%d \n", index) >= 0); } } // while fclose(fp); free(list); printf("Number of page requests: %d \nNumber of page faults: %d \n", requests, faults); return 1; }
void AABBTree::removeNode(AABBNode *nodeToRemove) { AABBNode *parentNode = nodeToRemove->getParent(); if(parentNode==nullptr) { rootNode = nullptr; }else { AABBNode *sibling = nodeToRemove->getSibling(); replaceNode(parentNode, sibling); parentNode->setLeftChild(nullptr); //avoid child removal parentNode->setRightChild(nullptr); //avoid child removal delete parentNode; } removeOverlappingPairs(nodeToRemove->getBodyNodeData()); delete nodeToRemove; }
void Lz77::deleteString(uint32 p) { uint32 replacement; if (tree[p].parent == unused) return; if ( tree[p].largeChild == unused) { contractNode(p, tree[p].smallChild); } else if (tree[p].smallChild == unused) { contractNode(p, tree[p].largeChild); } else { replacement = findNextNode(p); deleteString(replacement); replaceNode(p, replacement); } }
void BTreeBase::pruneTree(BTreeNode *root, bool /*conditionalRoot*/) { Traverser t(root); t.descendLeftwardToTerminal(); bool done = false; while(!done) { //t.descendLeftwardToTerminal(); if( t.current()->parent() ) { if( t.oppositeNode()->hasChildren() ) pruneTree(t.oppositeNode()); } t.moveToParent(); if( !t.current()->hasChildren() ) { //if(t.current() == t.root()) done = true; if(!t.current()->parent()) done = true; continue; } BTreeNode *l = t.current()->left(); BTreeNode *r = t.current()->right(); BTreeNode *n = 0; BTreeNode *z = 0; // Deal with situations where there are two constants so we want // to evaluate at compile time if( (l->type() == number && r->type() == number) ) // && !(t.current()==root&&conditionalRoot) ) { if(t.current()->childOp() == Expression::division && r->value() == "0" ) { t.current()->setChildOp(Expression::divbyzero); return; } QString value = QString::number(Parser::doArithmetic(l->value().toInt(),r->value().toInt(),t.current()->childOp())); t.current()->deleteChildren(); t.current()->setChildOp(Expression::noop); t.current()->setType(number); t.current()->setValue(value); } // Addition and subtraction else if(t.current()->childOp() == Expression::addition || t.current()->childOp() == Expression::subtraction) { // See if one of the nodes is 0, and set n to the node that actually has data, // z to the one containing zero. bool zero = false; if( l->value() == "0" ) { zero = true; n = r; z = l; } else if( r->value() == "0" ) { zero = true; n = l; z = r; } // Now get rid of the useless nodes if(zero) { BTreeNode *p = t.current(); // save in order to delete after replaceNode(p,n); t.setCurrent(n); // Delete the old nodes delete p; delete z; } } // Multiplication and division else if(t.current()->childOp() == Expression::multiplication || t.current()->childOp() == Expression::division) { // See if one of the nodes is 0, and set n to the node that actually has data, // z to the one containing zero. bool zero = false; bool one = false; if( l->value() == "1" ) { one = true; n = r; z = l; } else if( r->value() == "1" ) { one = true; n = l; z = r; } if( l->value() == "0" ) { zero = true; n = r; z = l; } else if( r->value() == "0" ) { // since we can't call compileError from in this class, we have a special way of handling it: // Leave the children as they are, and set childOp to divbyzero if( t.current()->childOp() == Expression::division ) { t.current()->setChildOp(Expression::divbyzero); return; // no point doing any more since we are going to raise a compileError later anyway. } zero = true; n = l; z = r; } // Now get rid of the useless nodes if(one) { BTreeNode *p = t.current(); // save in order to delete after replaceNode(p,n); t.setCurrent(n); // Delete the old nodes delete p; delete z; } if(zero) { BTreeNode *p = t.current(); p->deleteChildren(); p->setChildOp(Expression::noop); p->setType(number); p->setValue("0"); } } else if( t.current()->childOp() == Expression::bwand || t.current()->childOp() == Expression::bwor || t.current()->childOp() == Expression::bwxor ) { bool zero = false; if( l->value() == "0" ) { zero = true; n = r; z = l; } else if( r->value() == "0" ) { zero = true; n = l; z = r; } // Now get rid of the useless nodes if(zero) { BTreeNode *p = t.current(); QString value; if( p->childOp() == Expression::bwand ) { value = "0"; p->deleteChildren(); p->setChildOp(Expression::noop); p->setType(number); } if( p->childOp() == Expression::bwor || p->childOp() == Expression::bwxor ) { value = n->value(); BTreeNode *p = t.current(); // save in order to delete after replaceNode(p,n); t.setCurrent(n); // Delete the old nodes delete p; delete z; } p->setValue(value); } } if(!t.current()->parent() || t.current() == root) done = true; else { } } }
void XMLWriter::putItem(QObject *item) { QDomElement node=putQObjectItem(item->metaObject()->className(),item); if (!replaceNode(node,item)) m_rootElement.appendChild(node); }
void HOptimizer::constFolding(Node *node, Place p){ if(node->isSimple()) return; if(BinaryOpNode *bNode = dynamic_cast<BinaryOpNode*>(node)){ if(TernaryOpNode *tNode = dynamic_cast<TernaryOpNode*>(node)){ if(tNode->condition->isSimple()) replaceNode(tNode->calculate(), node, p); else { Node *c = current; current = tNode; constFolding(tNode->condition, BaseofTern); current = c; if(tNode->condition->isSimple()) replaceNode(tNode->calculate(), node, p); } return; } if(bNode->left->isSimple() && bNode->right->isSimple()){ replaceNode(bNode->BinaryOpNode::calculate(), node, p); return; } else { if(!bNode->left->isSimple()){ Node *c = current; current = bNode; constFolding(bNode->left, BinLeft); current = c; } if(!bNode->right->isSimple()){ Node *c = current; current = bNode; constFolding(bNode->right, BinRight); current = c; } if(bNode->left->isSimple() && bNode->right->isSimple()) replaceNode(bNode->BinaryOpNode::calculate(), node, p); } return; } else if(UnaryOpNode *uNode = dynamic_cast<UnaryOpNode*>(node)){ if(uNode->operand->isSimple()) replaceNode(uNode->calculate(), node, p); else { Node *c = current; current = uNode; constFolding(uNode->operand, UnOperand); current = c; if(uNode->operand->isSimple()) replaceNode(uNode->calculate(), node, p); } return; } else if(FunctionalNode *fNode = dynamic_cast<FunctionalNode*>(node)){ Node *c = current; current = fNode; int base_index = argIndex; for(int i = 0; i < fNode->args.size(); i++){ argIndex = i; constFolding(fNode->args[i], FuncArg); } argIndex = base_index; current = c; return; } else if(IdentifierNode *iNode = dynamic_cast<IdentifierNode*>(node)){ if(iNode->var->type->isConstSymbol()){ if(iNode->var->init->isSimple()) replaceNode(iNode->var->init, node, p); else { Node *c = current; current = iNode; constFolding(iNode->var->init, Ident); current = c; if(iNode->var->init->isSimple()) replaceNode(iNode->var->init->calculate(), node, p); } } } }
bool SystemTree::replaceNode(JausAddress address, JausNode newNode) { return replaceNode(address->subsystem, address->node, newNode); }
void NodeStore_addNode(struct NodeStore* store, struct Address* addr, const int64_t reachDifference) { Address_getPrefix(addr); if (memcmp(addr->ip6.bytes, store->thisNodeAddress, 16) == 0) { printf("got introduced to ourselves\n"); return; } if (addr->ip6.bytes[0] != 0xfc) { uint8_t address[60]; Address_print(address, addr); Log_critical1(store->logger, "tried to insert address %s which does not begin with 0xFC.\n", address); assert(false); } // TODO: maintain a sorted list. uint32_t pfx = Address_getPrefix(addr); if (store->size < store->capacity) { for (uint32_t i = 0; i < store->size; i++) { if (store->headers[i].addressPrefix == pfx && Address_isSameIp(&store->nodes[i].address, addr)) { int red = Address_checkRedundantRoute(&store->nodes[i].address, addr); if (red == 1) { #ifdef Log_DEBUG uint8_t nodeAddr[60]; Address_print(nodeAddr, &store->nodes[i].address); uint8_t newAddr[20]; Address_printNetworkAddress(newAddr, addr); Log_debug2(store->logger, "Found a better route to %s via %s\n", nodeAddr, newAddr); struct Node* n = NodeStore_getNodeByNetworkAddr(addr->networkAddress_be, store); if (n) { Log_warn(store->logger, "This route is probably invalid, giving up.\n"); continue; } #endif store->nodes[i].address.networkAddress_be = addr->networkAddress_be; } else if (red == 0 && store->nodes[i].address.networkAddress_be != addr->networkAddress_be) { // Completely different routes, store seperately. continue; } /*#ifdef Log_DEBUG uint32_t oldReach = store->headers[i].reach; #endif*/ adjustReach(&store->headers[i], reachDifference); /*#ifdef Log_DEBUG if (oldReach != store->headers[i].reach) { uint8_t nodeAddr[60]; Address_print(nodeAddr, addr); Log_debug3(store->logger, "Altering reach for node %s, old reach %u, new reach %u.\n", nodeAddr, oldReach, store->headers[i].reach); if (oldReach > store->headers[i].reach) { Log_debug(store->logger, "Reach was decreased!\n"); } } #endif*/ return; } #ifdef Log_DEBUG else if (store->headers[i].addressPrefix == pfx) { uint8_t realAddr[16]; AddressCalc_addressForPublicKey(realAddr, addr->key); assert(!memcmp(realAddr, addr->ip6.bytes, 16)); } #endif } #ifdef Log_DEBUG uint8_t nodeAddr[60]; Address_print(nodeAddr, addr); Log_debug2(store->logger, "Discovered node: %s reach %u\n", nodeAddr, reachDifference); #endif // Free space, regular insert. replaceNode(&store->nodes[store->size], &store->headers[store->size], addr); adjustReach(&store->headers[store->size], reachDifference); store->size++; return; } // The node whose reach OR distance is the least. // This means nodes who are close and have short reach will be removed uint32_t indexOfNodeToReplace = 0; uint32_t leastReachOrDistance = UINT32_MAX; for (uint32_t i = 0; i < store->size; i++) { uint32_t distance = store->headers[i].addressPrefix ^ pfx; if (distance == 0 && Address_isSame(&store->nodes[i].address, addr)) { // Node already exists adjustReach(&store->headers[store->size], reachDifference); return; } uint32_t reachOrDistance = store->headers[i].reach | distance; if (reachOrDistance < leastReachOrDistance) { leastReachOrDistance = reachOrDistance; indexOfNodeToReplace = i; } } replaceNode(&store->nodes[indexOfNodeToReplace], &store->headers[indexOfNodeToReplace], addr); adjustReach(&store->headers[indexOfNodeToReplace], reachDifference); }