void addItem( int coeff, int exp, Poly L ){
Position p = findPreviousNode( exp, L );
if( !isLast(p,L) && p->next->exp == exp )
p->next->coeff += coeff;
else
insertAfter( coeff, exp, L, p);
}
NodeImpl *NodeIteratorImpl::previousNode(int &exceptioncode)
{
NodeImpl *node = referenceNode() ? referenceNode() : root();
if (pointerBeforeReferenceNode() || acceptNode(node) != NodeFilter::FILTER_ACCEPT)
node = findPreviousNode(node);
if (node)
setReferenceNode(node);
setPointerBeforeReferenceNode();
return node;
}
void delNode( int X, Poly L ){
Position b, p, n;
b = findPreviousNode( X, L );
if( !isLast( b, L ) && b->next->exp != X){
p = b->next;
n = p->next;
b->next = n;
if ( NULL != n )
n->prev = b;
free(p);
}
}
uint8_t Scheduler::removeNode(const uint8_t nodeCurr) {
const uint8_t nodePrev = findPreviousNode(nodeCurr);
const uint8_t nodeNext = nodes[nodeCurr].next;
nodes[nodeCurr].inUse = false;
if (nodePrev == 0) { // This is the first node in the list
head = nodes[nodeCurr].next;
} else { // somewhere in the middle or the end of the list.
nodes[nodePrev].next = nodeNext;
}
// Removing this node so add the delta ticks to the
// next if the next is valid.
if (nodeNext != 0) {
nodes[nodeNext].tick += nodes[nodeCurr].tick;
}
return nodeNext;
}
/*
* RemoveIconFromList - remove an icon image from the current icon file
* - after calling this routine, the 'node' variable
* should no longer be used by the calling routine
*/
img_node *RemoveIconFromList( img_node *node, int index )
{
img_node *prevnode;
img_node *nextimage;
img_node *newnodelist;
nextimage = node->next;
prevnode = findPreviousNode( node );
newnodelist = removeIcon( node, index );
if( prevnode == NULL ) {
imgHead = newnodelist;
} else {
prevnode->next = newnodelist;
}
newnodelist->next = nextimage;
if( nextimage == NULL ) {
imgTail = newnodelist;
}
return( newnodelist );
} /* RemoveIconFromList */
void NodeIteratorImpl::notifyBeforeNodeRemoval(NodeImpl *willRemove)
{
// Iterator is not affected if the removed node is the reference node and is the root.
// or if removed node is not the reference node, or the ancestor of the reference node.
if (!willRemove || willRemove == root())
return;
bool willRemoveReferenceNode = willRemove == referenceNode();
bool willRemoveReferenceNodeAncestor = referenceNode() && referenceNode()->isAncestor(willRemove);
if (!willRemoveReferenceNode && !willRemoveReferenceNodeAncestor)
return;
if (pointerBeforeReferenceNode()) {
NodeImpl *node = findNextNode(willRemove);
if (node) {
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isAncestor(willRemove))
node = findNextNode(node);
}
if (node)
setReferenceNode(node);
}
else {
node = findPreviousNode(willRemove);
if (node) {
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isAncestor(willRemove))
node = findPreviousNode(node);
}
if (node) {
// Removing last node.
// Need to move the pointer after the node preceding the
// new reference node.
setReferenceNode(node);
setPointerBeforeReferenceNode(false);
}
}
}
}
else {
NodeImpl *node = findPreviousNode(willRemove);
if (node) {
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isAncestor(willRemove))
node = findPreviousNode(node);
}
if (node)
setReferenceNode(node);
}
else {
node = findNextNode(willRemove);
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isAncestor(willRemove))
node = findPreviousNode(node);
}
if (node)
setReferenceNode(node);
}
}
}
