int main()
{
int i;
void *s = filter_seq(power_seq(2), power_seq(3));
for (i = 0; i < 20; i++) seq_next(s);
for (i = 0; i < 10; i++)
printf("%d\n", seq_next(s));
return 0;
}
int filter_next(void *s)
{
gen_t *in = ((filter_gen_t*)s)->in, *wo = ((filter_gen_t*)s)->without;
do{
seq_next(in);
while (wo->output < in->output)
seq_next(wo);
} while(wo->output == in->output);
return in->output;
}
static void dn_nsp_data(struct sock *sk, struct sk_buff *skb)
{
int queued = 0;
unsigned short segnum;
struct dn_skb_cb *cb = DN_SKB_CB(skb);
struct dn_scp *scp = DN_SK(sk);
if (skb->len < 2)
goto out;
cb->segnum = segnum = le16_to_cpu(*(__le16 *)skb->data);
skb_pull(skb, 2);
if (seq_next(scp->numdat_rcv, segnum)) {
if (dn_queue_skb(sk, skb, SIGIO, &sk->sk_receive_queue) == 0) {
seq_add(&scp->numdat_rcv, 1);
queued = 1;
}
if ((scp->flowloc_sw == DN_SEND) && dn_congested(sk)) {
scp->flowloc_sw = DN_DONTSEND;
dn_nsp_send_link(sk, DN_DONTSEND, 0);
}
}
dn_nsp_send_data_ack(sk);
out:
if (!queued)
kfree_skb(skb);
}
static void dn_nsp_otherdata(struct sock *sk, struct sk_buff *skb)
{
struct dn_scp *scp = DN_SK(sk);
unsigned short segnum;
struct dn_skb_cb *cb = DN_SKB_CB(skb);
int queued = 0;
if (skb->len < 2)
goto out;
cb->segnum = segnum = le16_to_cpu(*(__le16 *)skb->data);
skb_pull(skb, 2);
if (seq_next(scp->numoth_rcv, segnum)) {
if (dn_queue_skb(sk, skb, SIGURG, &scp->other_receive_queue) == 0) {
seq_add(&scp->numoth_rcv, 1);
scp->other_report = 0;
queued = 1;
}
}
dn_nsp_send_oth_ack(sk);
out:
if (!queued)
kfree_skb(skb);
}
// try applying sequence
int try_sequence(SEQLIST *test_sequence, int mem_size) {
SEQLIST *sptr;
unsigned char *mblock;
// reset the memory allocator being tested
MEMORY_SIZE = mem_size;
init_myalloc();
for (sptr = test_sequence; !seq_null(sptr); sptr = seq_next(sptr)) {
if (seq_alloc(sptr)) { // allocate a block
mblock = myalloc(seq_size(sptr));
if (mblock == 0) {
return 0; // failed -- return indication
}
else {
// keep track of address allocated (for later frees)
seq_set_myalloc_block(sptr, mblock);
// put data in the block
// (so we can test that it holds data w/out corruption)
fill_data(seq_ref_block(sptr), mblock, seq_size(sptr));
}
}
else { // dealloc
myfree(seq_myalloc_block(seq_tofree(sptr)));
}
}
return 1; // succeeded in allocating entire sequence
}
LVAL xlc_seq_next(void)
{
seq_type arg1 = getseq(xlgaseq());
boolean result;
xllastarg();
result = seq_next(arg1);
return cvboolean(result);
}
/*----------------------------------------------------------------------------
* rumavl_node_next - find next node
*--------------------------------------------------------------------------*/
RUMAVL_NODE *rumavl_node_next (RUMAVL *tree, RUMAVL_NODE *node, int dir,
void **record)
{
/* make sure `dir' is either RUMAVL_ASC or RUMAVL_DESC */
if (dir == 0)
goto fail;
else if (dir > 0)
dir = RUMAVL_ASC;
else
dir = RUMAVL_DESC;
/* if node is uninitialised, start with first possible node in `dir'
* direction */
if (node == NULL){
/* unless the tree is empty of course */
if (tree->root == NULL)
goto fail;
dir = OTHER_LINK(LINK_NO(dir));
node = tree->root;
while (node->thread[dir] == 0){
node = node->link[dir];
}
goto found;
}
if ((node = seq_next(node, dir)) == NULL)
goto fail;
/* fall through */
found:
if (record != NULL)
*record = NODE_REC(node);
return node;
fail:
if (record != NULL)
*record = NULL;
return NULL;
}
// check all still allocated blocks in a test sequence
// contain the data originally placed into them
// i.e. have not been corrupted
int check_data(SEQLIST *test_sequence) {
int result;
SEQLIST *current;
result = 0; // stays zero if no errors
for (current = test_sequence; !seq_null(current); current = seq_next(current)) {
// only check if an allocate which has not been freed
if (seq_alloc(current) && !seq_freed(current)) {
if (!same_data(seq_ref_block(current), seq_myalloc_block(current),
seq_size(current))) {
if (VERBOSE) {
printf("Mismatch in sequence starting at:\n");
seq_print(current);
}
// returning a 1 means it failed
result = 1;
}
}
}
return result;
}
int countfile(FILE *file, int ***counts, int file_i) {
FastaSeq *seq = newFastaSeq();
(*counts)[file_i+1] = calloc(3, sizeof(int));
if (!(*counts)[file_i+1])
return 1;
while (!seq_next(file, seq, 0)) {
int seqlen = strlen(seq->seq);
if ((*counts)[file_i+1][0] < seqlen)
(*counts)[file_i+1][0] = seqlen;
(*counts)[file_i+1][1] += seqlen;
(*counts)[file_i+1][2]++;
}
(*counts)[0][0] += (*counts)[file_i+1][0];
(*counts)[0][1] += (*counts)[file_i+1][1];
(*counts)[0][2] += (*counts)[file_i+1][2];
deleteFastaSeq(seq);
return 0;
}
/*----------------------------------------------------------------------------
* rumavl_destroy - cleanly frees all memory used by the RUMAVL, as well as
* all nodes. All nodes are passed to the delete callback function in case the
* user has a special way of destroying nodes. The return value of the delete
* callback function is ignored, because once we start destroying we cant
* simply undestroy half the nodes.
*--------------------------------------------------------------------------*/
void rumavl_destroy (RUMAVL *tree)
{
RUMAVL_NODE *node, *tmp;
if (tree->root != NULL){
/* walk through tree deleting all */
node = tree->root;
while (node->thread[LEFT] == 0) /* move to bottom left most node */
node = node->link[LEFT];
while (node != NULL){
tmp = seq_next(node, RUMAVL_ASC);
if (tree->delcb != NULL){
tree->delcb(tree, node, NODE_REC(node), tree->udata);
}
node_destroy(tree, node);
node = tmp;
}
}
if (tree->alloc == NULL)
free(tree);
else
tree->alloc(tree, 0, tree->udata);
}
static void dn_nsp_linkservice(struct sock *sk, struct sk_buff *skb)
{
struct dn_scp *scp = DN_SK(sk);
unsigned short segnum;
unsigned char lsflags;
signed char fcval;
int wake_up = 0;
char *ptr = skb->data;
unsigned char fctype = scp->services_rem & NSP_FC_MASK;
if (skb->len != 4)
goto out;
segnum = le16_to_cpu(*(__le16 *)ptr);
ptr += 2;
lsflags = *(unsigned char *)ptr++;
fcval = *ptr;
/*
* Here we ignore erronous packets which should really
* should cause a connection abort. It is not critical
* for now though.
*/
if (lsflags & 0xf8)
goto out;
if (seq_next(scp->numoth_rcv, segnum)) {
seq_add(&scp->numoth_rcv, 1);
switch(lsflags & 0x04) { /* FCVAL INT */
case 0x00: /* Normal Request */
switch(lsflags & 0x03) { /* FCVAL MOD */
case 0x00: /* Request count */
if (fcval < 0) {
unsigned char p_fcval = -fcval;
if ((scp->flowrem_dat > p_fcval) &&
(fctype == NSP_FC_SCMC)) {
scp->flowrem_dat -= p_fcval;
}
} else if (fcval > 0) {
scp->flowrem_dat += fcval;
wake_up = 1;
}
break;
case 0x01: /* Stop outgoing data */
scp->flowrem_sw = DN_DONTSEND;
break;
case 0x02: /* Ok to start again */
scp->flowrem_sw = DN_SEND;
dn_nsp_output(sk);
wake_up = 1;
}
break;
case 0x04: /* Interrupt Request */
if (fcval > 0) {
scp->flowrem_oth += fcval;
wake_up = 1;
}
break;
}
if (wake_up && !sock_flag(sk, SOCK_DEAD))
sk->sk_state_change(sk);
}
dn_nsp_send_oth_ack(sk);
out:
kfree_skb(skb);
}
static void dn_nsp_linkservice(struct sock *sk, struct sk_buff *skb)
{
struct dn_scp *scp = DN_SK(sk);
unsigned short segnum;
unsigned char lsflags;
signed char fcval;
int wake_up = 0;
char *ptr = skb->data;
unsigned char fctype = scp->services_rem & NSP_FC_MASK;
if (skb->len != 4)
goto out;
segnum = le16_to_cpu(*(__le16 *)ptr);
ptr += 2;
lsflags = *(unsigned char *)ptr++;
fcval = *ptr;
if (lsflags & 0xf8)
goto out;
if (seq_next(scp->numoth_rcv, segnum)) {
seq_add(&scp->numoth_rcv, 1);
switch(lsflags & 0x04) {
case 0x00:
switch(lsflags & 0x03) {
case 0x00:
if (fcval < 0) {
unsigned char p_fcval = -fcval;
if ((scp->flowrem_dat > p_fcval) &&
(fctype == NSP_FC_SCMC)) {
scp->flowrem_dat -= p_fcval;
}
} else if (fcval > 0) {
scp->flowrem_dat += fcval;
wake_up = 1;
}
break;
case 0x01:
scp->flowrem_sw = DN_DONTSEND;
break;
case 0x02:
scp->flowrem_sw = DN_SEND;
dn_nsp_output(sk);
wake_up = 1;
}
break;
case 0x04:
if (fcval > 0) {
scp->flowrem_oth += fcval;
wake_up = 1;
}
break;
}
if (wake_up && !sock_flag(sk, SOCK_DEAD))
sk->sk_state_change(sk);
}
dn_nsp_send_oth_ack(sk);
out:
kfree_skb(skb);
}
/*----------------------------------------------------------------------------
* rumavl_delete - deletes a node. Beware! this function is the worst part of
* the library. Think (and draw pictures) when you edit this function.
*--------------------------------------------------------------------------*/
int rumavl_delete (RUMAVL *tree, const void *record)
{
RUMAVL_NODE **node, *tmpnode;
RUMAVL_STACK *stack;
int dir, ln;
if (tree->root == NULL) /* tree is empty */
return RUMAVL_ERR_NOENT;
stack = NULL;
node = &tree->root;
/* Find desired node */
while ((dir = rec_cmp(tree, record, NODE_REC(*node))) != 0){
if (stack_push(tree, &stack, node, dir) != 0)
goto nomemout;
if ((*node)->thread[LINK_NO(dir)] > 0){
/* desired node does not exist */
stack_destroy(tree, stack);
return RUMAVL_ERR_NOENT;
}
node = &(*node)->link[LINK_NO(dir)];
}
/* OK, we got the node to be deleted, now get confirmation from user */
if (tree->delcb != NULL &&
(ln = tree->delcb(tree, *node, NODE_REC(*node), tree->udata))
!= 0){
stack_destroy(tree, stack);
return ln;
}
if ((*node)->thread[LEFT] > 0){
if ((*node)->thread[RIGHT] > 0){
/* ooh look, we're a leaf */
tmpnode = *node;
if (stack != NULL){
/* This node has a parent, which will need to take over a
* thread from the node being deleted. First we work out
* which (left/right) child we are of parent, then give
* parent the respective thread. If the thread destination
* points back to us (edge of tree thread), update it to
* point to our parent. */
ln = LINK_NO(stack->dir);
(*stack->node)->link[ln] = tmpnode->link[ln];
(*stack->node)->thread[ln] = tmpnode->thread[ln];
if ((*stack->node)->thread[ln] == 2)
(*stack->node)->link[ln]->link[OTHER_LINK(ln)] =
*stack->node;
}else{
/*
* the only time stack will == NULL is when we are
* deleting the root of the tree. We already know that
* this is a leaf, so we will be leaving the tree empty.
*/
tree->root = NULL;
}
node_destroy(tree, tmpnode);
}else{
/* *node has only one child, and can be pruned by replacing
* *node with its only child. This block of code and the next
* should be identical, except that all directions and link
* numbers are opposite.
*
* Let node being deleted = DELNODE for this comment.
* DELNODE only has one child (the right child). The left
* most descendant of DELNODE will have a thread (left thread)
* pointing to DELNODE. This thread must be updated to point
* to the node currently pointed to by DELNODE's left thread.
*
* DELNODE's left thread may point to the opposite edge of the
* BST. In this case, the destination of the thread will have
* a thread back to DELNODE. This will need to be updated to
* point back to the leftmost descendant of DELNODE.
*/
tmpnode = *node; /* node being deleted */
*node = (*node)->link[RIGHT]; /* right child */
/* find left most descendant */
while ((*node)->thread[LEFT] == 0)
node = &(*node)->link[LEFT];
/* inherit thread from node being deleted */
(*node)->link[LEFT] = tmpnode->link[LEFT];
(*node)->thread[LEFT] = tmpnode->thread[LEFT];
/* update reverse thread if necessary */
if ((*node)->thread[LEFT] == 2)
(*node)->link[LEFT]->link[RIGHT] = *node;
node_destroy(tree, tmpnode);
}
}else if ((*node)->thread[RIGHT] > 0){
/* see above */
tmpnode = *node;
*node = (*node)->link[LEFT];
while ((*node)->thread[RIGHT] == 0)
node = &(*node)->link[RIGHT];
(*node)->link[RIGHT] = tmpnode->link[RIGHT];
(*node)->thread[RIGHT] = tmpnode->thread[RIGHT];
if ((*node)->thread[RIGHT] == 2)
(*node)->link[RIGHT]->link[LEFT] = *node;
node_destroy(tree, tmpnode);
}else{
/* Delete a node with children on both sides. We do this by replacing
* the node to be deleted (delnode) with its inner most child
* on the heavier side (repnode). This in place replacement is quicker
* than the previously used method of rotating delnode until it is a
* (semi) leaf.
*
* At this point node points to delnode's parent's link to delnode. */
RUMAVL_NODE *repnode, *parent;
int outdir, outln;
/* find heaviest subtree */
if ((*node)->balance > 0){
outdir = +1; /* outter direction */
dir = -1; /* inner direction */
outln = 1; /* outer link number */
ln = 0; /* inner link number */
}else{
outdir = -1; /* same as above, but opposite subtree */
dir = +1;
outln = 0;
ln = 1;
}
/* Add node to be deleted to the list of nodes to be rebalanced.
* Rememer that the replacement node will actually be acted apon,
* and that the replacement node should feel the effect of its own
* move */
if (stack_push(tree, &stack, node, outdir) != 0)
goto nomemout;
parent = *node;
repnode = parent->link[outln];
if (repnode->thread[ln] != 0){
/* repnode inherits delnode's lighter tree, and balance, and gets
* balance readjusted below */
repnode->link[ln] = (*node)->link[ln];
repnode->thread[ln] = (*node)->thread[ln];
repnode->balance = (*node)->balance;
}else{
/* Now we add delnodes direct child to the list of "to update".
* We pass a pointer to delnode's link to its direct child to
* stack_push(), but that pointer is invalid, because when
* stack_update() tries to access the link, delnode would have
* been destroyed. So, we remember the stack position at which
* we passed the faulty pointer to stack_push, and update its
* node pointer when we find repnode to point to repnodes
* link on the same side */
RUMAVL_STACK *tmpstack;
if (stack_push(tree, &stack, &parent->link[outln], dir) != 0)
goto nomemout;
tmpstack = stack;
parent = repnode;
repnode = repnode->link[ln];
/* move towards the innermost child of delnode */
while (repnode->thread[ln] == 0){
if (stack_push(tree, &stack, &parent->link[ln], dir) != 0)
goto nomemout;
parent = repnode;
repnode = repnode->link[ln];
}
if (repnode->thread[outln] == 0){
/* repnode's parent inherits repnodes only child */
parent->link[ln] = repnode->link[outln];
}else{
/* parent already has a link to repnode, but it must now be
* marked as a thread */
parent->thread[ln] = 1;
}
repnode->link[0] = (*node)->link[0];
repnode->thread[0] = (*node)->thread[0];
repnode->link[1] = (*node)->link[1];
repnode->thread[1] = (*node)->thread[1];
repnode->balance = (*node)->balance;
/* see comment above */
tmpstack->node = &repnode->link[outln];
}
node_destroy(tree, *node);
*node = repnode;
/* innermost child in lighter tree has an invalid thread to delnode,
* update it to point to repnode */
repnode = seq_next(repnode, dir);
repnode->link[outln] = *node;
}
/* update parents' balances */
stack_update(tree, stack, -1);
return 0;
nomemout:
stack_destroy(tree, stack);
return RUMAVL_ERR_NOMEM;
}
