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);
}
