void findedge(node* start,char A,char B,listnode** edgeloc) { if(start==NULL) { printf("\nNo nodes in the graph"); return; } node* locA=NULL; findnode(start,A,&locA); node* locB=NULL; findnode(start,B,&locB); if(locA==NULL || locB==NULL) { printf("\nEdge not found!!!"); *edgeloc=NULL; return; } listnode* ptr=locA->adj; while(ptr!=NULL) { if(ptr->link==locB) { *edgeloc=ptr; return; } else { ptr=ptr->next; } } printf("\nEdge not found!!!"); }
int findtree(int order,PCB *pcb,node *node,int memsize){ int f; if(node->order==order){//find the right order if(!((node->left==NULL)&&(node->right==NULL))){ //not leaf but chunk could only be allocated at leaf return(-1); } else{ //the leaf node if(node->free_status==0){ //not free return(-1); } else{ //find one heap chunk! node->free_status=0; printf("Allocated the block: order = %d, addr= %d , requested mem size = %d, block size = %d\n",node->order,node->address,memsize,node->size); return(node->address); } } } else{ //fail to locate correct order,keep searching if((node->left==NULL)&&(node->right==NULL)){ //leaf with higher order, should create new node if(node->free_status==0){ //not free return(-1); } else{ //insert children node->left=&pcb->heapnode[findnode(pcb)]; node->left->order=node->order-1; node->left->address=node->address; node->left->size=node->size/2; node->left->left=NULL; node->left->right=NULL; node->left->free_status=1; //initiate as free printf("Created a left child node(order= %d, addr= %d, size= %d) of parent (order= %d, addr= %d, size= %d)\n",node->left->order,node->left->address,node->left->size,node->order,node->address,node->size); node->right=&pcb->heapnode[findnode(pcb)]; node->right->order=node->order-1; node->right->address=node->address+(32*(1<<node->right->order)); node->right->size=node->size/2; node->right->left=NULL; node->right->right=NULL; node->right->free_status=1; //initiate as free printf("Created a right child node(order= %d, addr= %d, size= %d) of parent (order= %d, addr= %d, size= %d)\n",node->right->order,node->right->address,node->right->size,node->order,node->address,node->size); if(((f=findtree(order,currentPCB,node->left,memsize))==-1)){ // printf("f= %d\n",f); return(findtree(order,currentPCB,node->right,memsize)); } else{ // printf("f= %d\n",f); return (f); } } } else{ //not a leaf, search in left child first, then right child if(((f=findtree(order,currentPCB,node->left,memsize))==-1)){ return(findtree(order,currentPCB,node->right,memsize)); } else{ return (f); } } } }
avlnode * Tree::insertion(avlnode * temp, int value, int value1) { avlnode * temp1 = findnode(value); if (temp1!=NULL) { ((temp1->head2)->head)=(temp1->head2)->add(value1); return temp; } if (temp==NULL) { temp = new avlnode; temp->data=value; temp->left=NULL; temp->right=NULL; temp->head2=new Connection; ((temp->head2)->head)=(temp->head2)->add(value1); } else if (value>temp->data) { temp->left=insertion(temp->left, value, value1); temp=balance (temp); } else if (value<temp->data) { temp->right=insertion(temp->right, value, value1); temp=balance (temp); } return temp; }
datum mydbm_fetch (DBM *db, datum key) { Node *p; char *s; datum val; /* make sure it's null-terminated */ s = xmalloc (key.dsize + 1); (void) strncpy (s, key.dptr, key.dsize); s[key.dsize] = '\0'; p = findnode (db->dbm_list, s); if (p) { val.dptr = p->data; val.dsize = strlen (p->data); } else { val.dptr = NULL; val.dsize = 0; } free (s); return val; }
char* list::getstrdata(char *str) { node *temp; temp = (node *)findnode(str); if (temp==NULL) return NULL; return temp->strdata; }
listitemtype list::getdata(char *str) { node *temp; temp = (node *)findnode(str); if (temp==NULL) return -1; return temp->data; }
void delete_node(node **start, char A) { if(*start==NULL) { printf("\nNo nodes in the graph!!\n"); return ; } node *ptr1=*start; //checking if the node is in the graoh or not node* locA=NULL; findnode(*start,A,&locA); if(locA==NULL) { printf("\nThe entered node is not in the graph\n"); return ; } listnode *ptr2=ptr1->adj; listnode* save2=ptr2; //deleting all the incoming edges while(ptr1!=NULL) { if(ptr1->data!=A) { while(ptr2!=NULL) { if(ptr2->link->data==A) { if(ptr2==ptr1->adj) ptr1->adj=ptr2->next; else save2->next=ptr2->next; } save2=ptr2; ptr2=ptr2->next; } } ptr1=ptr1->next; } //deleting all outgoing edges listnode* ptr=locA->adj; listnode* save=ptr; while(ptr!=NULL) { save=ptr; ptr=ptr->next; free(save); } //if starting node is to be deleted if((*start)->data==A) { *start=(*start)->next; } //delete the node free(locA); }
int main(void) { int i; node **L; if (sizeof(int) < 4) { puts("This code must be compiled with 32-bit ints!"); return EXIT_FAILURE; } L=newlist(); puts(" DOWN"); for(i = 100; i >= 0; i -=2) insertnode(L, i, i); puts(" UP"); for(i = 1; i < 100; i += 2) insertnode(L, i, i); deletenode(L, 40); puts(" FIND"); for(i = -2; i <= 100; ++i) findnode(L, i); puts(" FAST"); findall(L); puts("SAMPLES"); printf(" %d", findnode(L, -10)); printf(" %d,", findnode(L, 0)); printf(" %d", findnode(L, 1)); printf(" %d", findnode(L, 2)); printf(" %d", findnode(L, 39)); printf(" %d", findnode(L, 40)); printf(" %d", findnode(L, 41)); printf(" %d", findnode(L, 42)); puts(" DONE"); return EXIT_SUCCESS; }
int list::setdata(char *str, char *strdata,listitemtype data) { node *temp; temp = (node *)findnode(str); if (temp==NULL) return -1; temp->data = data; //temp->strdata = strdup(strdata); temp->strdata = new char[strlen(strdata)]; strcpy(temp->strdata, strdata); return 0; }
void insertedge(node* start,char A,char B) { if(start==NULL) { printf("\nNo nodes in the graph"); return; } node* locA=NULL; findnode(start,A,&locA); node* locB=NULL; findnode(start,B,&locB); if(locA==NULL || locB==NULL) { printf("\nNodes not present in graph!!!"); return; } listnode* temp=NULL; getlistnode(locB,&temp); temp->next=locA->adj; locA->adj=temp; }
void delete_edge(node* start,char A, char B) { if(start==NULL) { printf("\nNo nodes in the graph!!\n"); return ; } if(start==NULL) { printf("\nNo nodes in the graph"); return; } node* locA=NULL; findnode(start,A,&locA); node* locB=NULL; findnode(start,B,&locB); if(locA==NULL || locB==NULL) { printf("\nNodes not present in graph!!!"); return; } listnode* ptr=locA->adj; listnode* save=ptr; while(ptr!=NULL) { if(ptr->link==locB) { if(ptr==locA->adj) locA->adj=ptr->next; else save->next=ptr->next; free(ptr); return; } save=ptr; ptr=ptr->next; } }
void Tree::removelink(int x, int y) { avlnode * temp1=findnode(x); conn * temp2=(temp1->head2)->head; while ((temp2)!=NULL) { if (temp2->data==y) { (temp1->head2)->removal(y); return; } temp2=temp2->next; } }
int addnodeID(int n, char *id) /* **------------------------------------------------------------- ** Input: n = node index ** id = ID label ** Output: returns 0 if ID already in use, 1 if not ** Purpose: adds a node ID to the Node Hash Table **-------------------------------------------------------------- */ { if (findnode(id)) return(0); /* see EPANET.C */ strncpy(Node[n].ID, id, MAXID); HTinsert(Nht, Node[n].ID, n); /* see HASH.C */ return(1); }
Tnode* findnode(Tnode *t, Point p) { int i; Tnode *tt; if(ptinrect(p, rectaddpt(Rect(0,0,Nubwidth, Nubheight), t->offset))) return t; if(!t->expanded) return nil; for(i=0; i<t->nkid; i++) if(tt = findnode(t->kid[i], p)) return tt; return nil; }
int list::remove(char *str) { node *temp,*prev; temp = (node *)findnode(str); if (temp == NULL) return -1; prev = (node *)findprev(temp); if (prev == NULL) return -1; prev->next = temp->next; // delete[] temp->str; // delete[] temp->strdata; delete temp; return 0; }
struct filenode *findnode(struct filenode *node, dev_t dev, ino_t ino) { struct filenode *found, *p; /* scan the whole tree */ if (node->ondev == dev && node->onino == ino) return node; p = node->dirlist.head; while (p->next) { found = findnode(p, dev, ino); if (found) return found; p = p->next; } return NULL; }
void variable_set (char *nameval) { char *p; char *name; Node *node; p = nameval; while (isalnum ((unsigned char) *p) || *p == '_') ++p; if (*p != '=') error (1, 0, "invalid character in user variable name in %s", nameval); if (p == nameval) error (1, 0, "empty user variable name in %s", nameval); name = xmalloc (p - nameval + 1); strncpy (name, nameval, p - nameval); name[p - nameval] = '\0'; /* Make p point to the value. */ ++p; if (strchr (p, '\012')) error (1, 0, "linefeed in user variable value in %s", nameval); if (!variable_list) variable_list = getlist (); node = findnode (variable_list, name); if (!node) { node = getnode (); node->type = VARIABLE; node->delproc = variable_delproc; node->key = name; node->data = xstrdup (p); (void) addnode (variable_list, node); } else { /* Replace the old value. For example, this means that -s options on the command line override ones from .cvsrc. */ free (node->data); node->data = xstrdup (p); free (name); } }
/* lookup with optional insertion * See: The practice of programming, page 56 */ void * lookup(Symtab *table, int insert, char *key, void *value){ unsigned long h = hash(key, table->size); Node *np = findnode(table->buckets[h], key); if(np) return np->value; if(insert){ np = xmalloc(sizeof(*np)); np->key = clonekey(key); np->value = value; np->next = table->buckets[h]; table->buckets[h] = np; table->entries++; if(mustexpand(table)) expandtable(table); } return np; }
void split(int x) { int index; node *d; findnode(x, &index); d = list[index]; if (d->start < x && x < d->start + d->length) { node *right; right = makenode(); right->start = x; right->length = d->length - (x - d->start); right->count = d->count; insert(index + 1, right); d->length = x - d->start; } }
int list::insert(char *str,char *strdata,listitemtype data) { node *next, *prev; if (findnode(str) != NULL) return -1; prev = (node *)findprev(tail); next = new node; if (next == NULL) return -1; prev->next = next; next->next = tail; next->str = new char[strlen(str)+1]; if (next->str == NULL) return -1; //clearstr(next->str,strlen(str)+1); strcpy(next->str,str); next->data = data; next->strdata = new char[strlen(strdata)+1];//strdup(strdata); strcpy(next->strdata, strdata); return 0; }
void increment(int a, int b) { int index; node *d; split(a); split(b + 1); if (!findnode(a, &index)) assert(0); while (index < count) { d = list[index]; if (d->start > b) break; d->count++; index++; } }
/* Routine to slid one branch of a node along the a branch * The moving node is assumed to be simple!*/ void greasebranch(struct treenode *node_p,FILE *file_p,unsigned int e){ #include "variables.h" int steps,a,b,c; int slippe,to,from,to_root,to_false_root; int sp_case; double f_min,f_max,f,l; extern int root; struct treenode *movingnode,*node_c; struct treenode *tree; /* Make two copies of the tree*/ tree2=treecopy(node_p,0); tree=treecopy(node_p,0); filltree(node_p,tree,0); /* Print out the tree branches and respective numbers*/ printf("\n"); for(a=0;a<branches;a++) printf("Branch %d goes from %s to %s\n",a ,(branch[a]->node[0])->name,branch[a]->name); /* Get the necessary parameters from the user*/ do{ printf("\nWhich branch would you like to move?"); scanf("%d",&slippe); }while(slippe<0 || slippe>branches); do{ printf("\nWhich branch would you like to move branch %d along(towards)?" ,slippe); scanf("%d",&to); printf("\nWhich branch would you like to move branch %d along(away)?" ,slippe); scanf("%d",&from); }while(to<0 || to>branches || from<0 || from>branches); /* Out of the three parameters given, two of them must point * the common node.*/ movingnode=(branch[to]->node[0]==branch[from]->node[0]) ?branch[to]->node[0]:branch[slippe]->node[0]; /* Find which branch in the common node points to each of the * parameter branches.*/ from=findnode(movingnode,branch[from]); to=findnode(movingnode,branch[to]); slippe=findnode(movingnode,branch[slippe]); /* Get the amount of variation from the user*/ printf("Sliding branch leading to %s\n\n",branch[slippe]->name); printf("Please enter min. & max. distance to move and number of points:\n"); do{ printf("\tmin. distance:"); scanf("%lf",&f_min); }while(f_min<=-movingnode->length[from] || f_min>=movingnode->length[to]); do{ printf("\tmax. distance:"); scanf("%lf",&f_max); }while(f_min>=f_max || f_max>=movingnode->length[to]); do{ printf("\tnumber of points:"); scanf("%d",&steps); }while(steps<=0); /* Are we moving the branch towards the (code) root?*/ to_false_root=(to==0)?0:1; /* Work out where root node is relative to movingnode. * Needed to work out whether to increase or decrease branch * lengths when moving node*/ to_root=to_false_root; /* Correct unless we are between the * two roots in the tree */ /* If we have a genetic root...*/ if(ISMODE(ROOTED)){ /* Decide depending on whether the root is floating or not, * which node it refers to*/ node_c=(ISMODE(NODEASROOT))?branch[root]->node[0]:branch[root]; /* Iterate from the genetic root to the code root and set * "to_root" as appropriate. to_root only differs from to_false_root * if we are moving a branch between the two roots*/ while(node_c!=tree){ /* If we reach movingnode without passing either the to or from * node first, then we must have come down on of the other branches * or our root is the movingnode itself. In either case, we can't * keep evolutionary times fixed - problem*/ if(node_c==movingnode){ printf("Moving branch containing root - can't keep evolutionary times fixed\n"); exit(0); } /* We encounter the "to" node first and so must be moving * towards the genetic root*/ if(node_c==movingnode->node[to]){ to_root=0; break; } /* We encounter the from root first and so must be moving * away from the genetic node*/ if(node_c==movingnode->node[from]){ to_root=1; break; } /* Iterate up one step*/ node_c=node_c->node[0]; } /* If the root is on the branch we are moving, bad things * happen (TM) Moving the branch can't be done if evolutionary * times are fixed. * We have deal with the case when root is on the moving bit of * tree but not the false root.*/ if(slippe==0){ /* Decide where the root is depending on whether it is fixed * or floating*/ node_c=(ISMODE(NODEASROOT))?branch[root]->node[0]:branch[root]; a=0; /* We may assume that the code root is on the moving branch of * the tree. If we have to pass through movingnode to get from * the genetic root to the code root then we are fine*/ while(node_c!=tree){ if(node_c==movingnode){ a=1; break; } node_c=node_c->node[0]; } /* One special case if the movingnode is the fixed root*/ if(ISMODE(NODEASROOT) && branch[root]->node[0]==movingnode) a=0; /* If both the code and genetic roots are on the moving section * of tree, complain*/ if(a==0){ printf("Moving branch containing root - can't keep evolutionary" " times fixed\n"); exit(0); } } /* If the root of the tree is on the same branch as we are moving across * then we'll have trouble when we cross it - give warning*/ if(NOTMODE(NODEASROOT)) /* genetic root is floating*/ if(to_root==0) /* we are heading towards it*/ /* Depending on whether we are going away or towards the * code root, see if the genetic root is on the branch we are * moving along*/ if((to_false_root==0 && branch[root]==movingnode) ||(to_false_root==1 && branch[root]->node[0]==movingnode)) fprintf(file_p,"# *** Root in branch moving across. Beware, here be dragons ***\n"); } /* Dump some information to file informing user what we are about * to do*/ fprintf(file_p,"#Results from sliding branch from %s to" " %s along branch from %s to %s\n" ,movingnode->name,(movingnode->node[slippe])->name ,(movingnode->node[from])->name,(movingnode->node[to])->name); fprintf(file_p,"#Distance moved towards %s\t%s\n",(movingnode->node[to])->name,outstring); if(ISMODE(MATRICES)) fprintf(matrix_file_p,"#Matrices from sliding branch from %s to" " %s along branch from %s to %s\n" ,movingnode->name,(movingnode->node[slippe])->name ,(movingnode->node[from])->name,(movingnode->node[to])->name); if(sample_file_p!=NULL){ fprintf(sample_file_p,"#Points %d\n",steps); fprintf(sample_file_p,"#Samples from sliding branch from %s to" " %s along branch from %s to %s\n" ,movingnode->name,(movingnode->node[slippe])->name ,(movingnode->node[from])->name,(movingnode->node[to])->name); } if(ISMODE(PROBS)) fprintf(prob_file_p,"#Probabilities from sliding branch from %s to" " %s along branch from %s to %s\n" ,movingnode->name,(movingnode->node[slippe])->name ,(movingnode->node[from])->name,(movingnode->node[to])->name); /* l is the total length of the "branch" we are moving across*/ l=movingnode->length[to]+movingnode->length[from]; if(steps==1) f=f_min; else f=(f_max-f_min)/(steps-1); /* We aren't changing any rates, so we don't need to apply the * factor to any information (so factor=1)*/ factor=1.0; factor_flag=0; /* Initialise the tree...*/ movingnode->length[to]-=f_min; if(to==0){ b=findnode(movingnode->node[0],movingnode); (movingnode->node[to])->length[b]=movingnode->length[to]; } else (movingnode->node[to])->length[0]=movingnode->length[to]; movingnode->length[from]+=f_min; if(from==0){ b=findnode(movingnode->node[0],movingnode); (movingnode->node[from])->length[b]=movingnode->length[from]; } else (movingnode->node[from])->length[0]=movingnode->length[from]; /* If the tree is rooted, then we must preserve evolutionary * times. This requires adding bits onto any other branches * connected to the moving node, bar the to and from branches.*/ if(ISMODE(ROOTED)){ /* Case moving towards the evolutionary root - all branches * connected to the moving node, bar from and to need to have * the distance added onto them*/ sp_case=(movingnode==tree)?1:0; if(to_root==0){ if(sp_case==1 && to!=0 && from!=0){ b=findnode(movingnode->node[0],movingnode); movingnode->length[0]+=f_min; (movingnode->node[0])->length[b]=movingnode->length[0]; } for(a=sp_case;a<DOODAH && movingnode->node[a]!=NULL;a++) if(a!=to && a!=from){ (movingnode->node[a])->length[0]+=f_min; movingnode->length[a]=(movingnode->node[a])->length[0]; } } /* Else we are moving away from it and all branches connected to * the moving node need the distance subtracted from them. Same * special case as above*/ else{ if(sp_case==1 && to!=0 && from!=0){ b=findnode(movingnode->node[0],movingnode); movingnode->length[0]-=f_min; (movingnode->node[0])->length[b]=movingnode->length[0]; } for(a=sp_case;a<DOODAH && movingnode->node[a]!=NULL;a++) if(a!=to && a!=from){ (movingnode->node[a])->length[0]-=f_min; movingnode->length[a]=(movingnode->node[a])->length[0]; } } } for(c=0;c<steps;c++){ /* Adding new lengths - if any of the markers are zero then * we have to search for the correct pointer in the parent node*/ movingnode->length[to]-=(c!=0)*f; /* Also need to update length of branch that leads to this * one. If to=0 then we must look up the tree*/ if(to==0){ b=findnode(movingnode->node[0],movingnode); (movingnode->node[to])->length[b]=movingnode->length[to]; } else (movingnode->node[to])->length[0]=movingnode->length[to]; movingnode->length[from]+=(c!=0)*f; /* Also need to update length of branch that leads to this * one. If from=0 then we must look up the tree*/ if(from==0){ b=findnode(movingnode->node[0],movingnode); (movingnode->node[from])->length[b]=movingnode->length[from]; } else (movingnode->node[from])->length[0]=movingnode->length[from]; /* If the tree is rooted, then we must preserve evolutionary * times. This requires adding bits onto any other branches * connected to the moving node, bar the to and from branches.*/ if(ISMODE(ROOTED)){ /* Case moving towards the evolutionary root - all branches * connected to the moving node, bar from and to need to have * the distance added onto them*/ sp_case=(movingnode==tree)?1:0; /* Is the movingnode the code root?*/ if(to_root==0){ if(sp_case==1 && to!=0 && from!=0){ b=findnode(movingnode->node[0],movingnode); movingnode->length[0]+=(c!=0)*f; (movingnode->node[0])->length[b]=movingnode->length[0]; } for(a=sp_case;a<DOODAH && movingnode->node[a]!=NULL;a++) if(a!=to && a!=from){ (movingnode->node[a])->length[0]+=(c!=0)*f; movingnode->length[a]=(movingnode->node[a])->length[0]; } } /* Else we are moving away from it and all branches connected to * the moving node need the distance subtracted from them. Same * special case as above*/ else{ if(sp_case==1 && to!=0 && from!=0){ b=findnode(movingnode->node[0],movingnode); movingnode->length[0]-=(c!=0)*f; (movingnode->node[0])->length[b]=movingnode->length[0]; } for(a=sp_case;a<DOODAH && movingnode->node[a]!=NULL;a++) if(a!=to && a!=from){ (movingnode->node[a])->length[0]-=(c!=0)*f; movingnode->length[a]=(movingnode->node[a])->length[0]; } } } /* Fill in second copy of tree from first and update the leaf * array to point to tree*/ filltree(tree,tree2,0); leaves=0; doleaf(tree,0); /* Print a bit of information to all open files*/ printf("Doing distance %E\n",c*f+f_min); if(ISMODE(TREES)) print_tree(tree,file_p,0); fprintf(file_p,"%E\n",c*f+f_min); if(ISMODE(MATRICES)){ fprintf(matrix_file_p,"\n#Distance %E\n",c*f+f_min); if(ISMODE(TREES)) print_tree(tree,matrix_file_p,0); } if(ISMODE(VARIANCE)){ fprintf(variance_file_p,"\n#Distance %E\n",c*f+f_min); if(ISMODE(TREES)) print_tree(tree,variance_file_p,0); } if(sample_file_p!=NULL){ fprintf(sample_file_p,"\n#Distance %E\n",c*f+f_min); if(ISMODE(TREES)) print_tree(tree,sample_file_p,0); } if(ISMODE(PROBS)){ fprintf(prob_file_p,"\n#Distance %E\n",c*f+f_min); if(ISMODE(TREES)) print_tree(tree,prob_file_p,0); } det=find_information(tree,tree2,e,factor_flag,factor); /* Possible may want to print out more than one result*/ b=1; if(ISMODE(INDIVIDUAL)) b=individual; if(ISMODE(INDIVIDUAL)){ if(ISMODE(DETINDIV)){ fprintf(file_p,"\t\t\t%E\tD(",det[0]); for(a=0;a<b-1;a++) fprintf(file_p,"%d,",interesting_branches[a]); fprintf(file_p,"%d)\n",interesting_branches[a]); }else for(a=0;a<b;a++) fprintf(file_p,"\t\t\t%E\t%d\n",det[a],interesting_branches[a]); }else fprintf(file_p,"\t\t\t%E\tD\n",det[0]); if(ISMODE(HKY) && NOTMODE(NOKAPPA) && NOTMODE(PERCENTILE)) fprintf(file_p,"\t\t\t%E\tKappa\n",det[b]); free(det); } }
/* Routine to vary the length of one branch though several * multipliers. This has little meaning when considering a clock-like * (rooted) tree*/ void growbranch(struct treenode *node_p,FILE *file_p,unsigned int e){ #include "variables.h" int steps,a,b,c; int elastic; double f_min,f_max,f; struct treenode *tree; /* Test to see whether tree is rooted - changing branch * length in unrooted trees doesn't have much experimental * meaning */ if(((mode&4)|(mode&32))!=0) printf("\a\n**Changing branch length in a rooted tree doesn't" " have meaning\n**in an experimental design problem!\n\n\a"); /* Make two copies of the tree*/ tree2=treecopy(node_p,0); tree=treecopy(node_p,0); /* Fill in the first*/ filltree(node_p,tree,0); /* Choose branch to stretch - better be elastic*/ printf("\n"); for(a=0;a<branches;a++) printf("Branch %d goes from %s to %s\n",a ,(branch[a]->node[0])->name,branch[a]->name); do{ printf("\nWhich branch would you like to alter?"); scanf("%d",&elastic); }while(elastic<0 || elastic>branches); /* Get length scaling factors from user*/ printf("Altering length of a branch leading to" " %s by a varying factor\n\n",branch[elastic]->name); printf("Please enter min. factor, max factor and number of points:\n"); do{ printf("\tmin. factor:"); scanf("%lf",&f_min); }while(f_min<=0); do{ printf("\tmax. factor:"); scanf("%lf",&f_max); }while(f_min>=f_max); do{ printf("\tnumber of points:"); scanf("%d",&steps); }while(steps<=0); /* Dump the necessary information to file*/ fprintf(file_p,"#Results from varying length of branch" " between %s and %s by factor\n" ,(branch[elastic]->node[0])->name,branch[elastic]->name); fprintf(file_p,"#Factor\t\t\t%s\n",outstring); if(ISMODE(MATRICES)) fprintf(matrix_file_p,"#Matrices from varying length of branch" " between %s and %s by factor\n" ,(branch[elastic]->node[0])->name,branch[elastic]->name); if(sample_file_p!=NULL){ fprintf(sample_file_p,"#Points %d\n",steps); fprintf(sample_file_p,"#Samples from varying length of branch" " between %s and %s by factor\n" ,(branch[elastic]->node[0])->name,branch[elastic]->name); } if(ISMODE(PROBS)) fprintf(prob_file_p,"#Probabilities from varying length of branch" " between %s and %s by factor\n" ,(branch[elastic]->node[0])->name,branch[elastic]->name); /* Main loop to stretch the branch*/ for(c=0;c<steps;c++){ /* Calculate the factor wanted and set the flag - we only * want to apply the factor to one of the informations this * time*/ if(steps==1) f=f_min; else f=f_min+c*(f_max-f_min)/(steps-1); factor=f; factor_flag=elastic; /* Fill in first copy from the original*/ filltree(node_p,tree,0); /* Branch[] points to those of 'tree' * Change length of the branch by factor - need to find the node * that points from the other side of the branch.*/ branch[elastic]->length[0]=branch[elastic]->length[0]*f; a=findnode(branch[elastic]->node[0],branch[elastic]); (branch[elastic]->node[0])->length[a]=branch[elastic]->length[0]; /* Fill in the second copy from the first (with the new branch * length and set all the leaves to point to "tree"*/ filltree(tree,tree2,0); leaves=0; doleaf(tree,0); printf("Doing Factor %E\n",f); /* If we are printing out the intermediate trees, then dump them * to every file*/ if(ISMODE(TREES)) print_tree(tree,file_p,0); fprintf(file_p,"%E\n",f); if(ISMODE(MATRICES)){ fprintf(matrix_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,matrix_file_p,0); } if(ISMODE(VARIANCE)){ fprintf(variance_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,variance_file_p,0); } if(sample_file_p!=NULL){ fprintf(sample_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,sample_file_p,0); } if(ISMODE(PROBS)){ fprintf(prob_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,prob_file_p,0); } det=find_information(tree,tree2,e,factor_flag,factor); /* Possible may want to print out more than one result*/ b=1; if(ISMODE(INDIVIDUAL)) b=individual; if(ISMODE(INDIVIDUAL)){ if(ISMODE(DETINDIV)){ fprintf(file_p,"\t\t\t%E\tD(",det[0]); for(a=0;a<b-1;a++) fprintf(file_p,"%d,",interesting_branches[a]); fprintf(file_p,"%d)\n",interesting_branches[a]); }else for(a=0;a<b;a++) fprintf(file_p,"\t\t\t%E\t%d\n",det[a],interesting_branches[a]); }else fprintf(file_p,"\t\t\t%E\tD\n",det[0]); if(ISMODE(HKY) && NOTMODE(NOKAPPA) && NOTMODE(PERCENTILE)) fprintf(file_p,"\t\t\t%E\tKappa\n",det[b]); free(det); } }
int No_Difference (struct file_info *finfo, Vers_TS *vers) { Node *p; int ret; char *ts, *options; int retcode = 0; char *tocvsPath; /* If ts_user is "Is-modified", we can only conclude the files are different (since we don't have the file's contents). */ if (vers->ts_user != NULL && strcmp (vers->ts_user, "Is-modified") == 0) return -1; if (!vers->srcfile || !vers->srcfile->path) return (-1); /* different since we couldn't tell */ #ifdef PRESERVE_PERMISSIONS_SUPPORT /* If special files are in use, then any mismatch of file metadata information also means that the files should be considered different. */ if (preserve_perms && special_file_mismatch (finfo, vers->vn_user, NULL)) return 1; #endif if (vers->entdata && vers->entdata->options) options = xstrdup (vers->entdata->options); else options = xstrdup (""); tocvsPath = wrap_tocvs_process_file (finfo->file); retcode = RCS_cmp_file (vers->srcfile, vers->vn_user, NULL, NULL, options, tocvsPath == NULL ? finfo->file : tocvsPath); if (retcode == 0) { /* no difference was found, so fix the entries file */ ts = time_stamp (finfo->file); Register (finfo->entries, finfo->file, vers->vn_user ? vers->vn_user : vers->vn_rcs, ts, options, vers->tag, vers->date, NULL); #ifdef SERVER_SUPPORT if (server_active) { /* We need to update the entries line on the client side. */ server_update_entries (finfo->file, finfo->update_dir, finfo->repository, SERVER_UPDATED); } #endif free (ts); /* update the entdata pointer in the vers_ts structure */ p = findnode (finfo->entries, finfo->file); assert (p); vers->entdata = p->data; ret = 0; } else ret = 1; /* files were really different */ if (tocvsPath) { /* Need to call unlink myself because the noexec variable * has been set to 1. */ TRACE (TRACE_FUNCTION, "unlink (%s)", tocvsPath); if ( CVS_UNLINK (tocvsPath) < 0) error (0, errno, "could not remove %s", tocvsPath); } free (options); return ret; }
/* Routine to vary the length of all branches by the same factor * and dump the expected information to disk. Since we are altering * the rate of change, we need to include a factor in all the information * calculations*/ void growtree(struct treenode *node_p,FILE *file_p,unsigned int e){ #include "variables.h" int steps,a,b,c; double f_min,f_max,f; struct treenode *tree; /* Code to get the factors from the users*/ printf("Altering length of all branches by same factor\n\n"); printf("Please enter min. factor, max factor and number of points:\n"); do{ printf("\tmin. factor:"); scanf("%lf",&f_min); }while(f_min<=0); do{ printf("\tmax. factor:"); scanf("%lf",&f_max); }while(f_min>=f_max); do{ printf("\tnumber of points:"); scanf("%d",&steps); }while(steps<=0); /* Dump text to file explaining what we are about to do*/ fprintf(file_p,"#Results from Varying length of all branches by factor\n"); fprintf(file_p,"#Factor\t\t\t%s\n",outstring); if(ISMODE(MATRICES)) fprintf(matrix_file_p,"#Matrices from Varying length of all branches by factor\n"); if(sample_file_p!=NULL){ fprintf(sample_file_p,"#Points %d\n",steps); fprintf(sample_file_p,"#Samples from varying length of all branches by factor\n"); } if(ISMODE(PROBS)) fprintf(prob_file_p,"#Probabilities from varying length of all branches by factor\n"); /* Start main loop*/ /* Make two copies of the tree*/ tree2=treecopy(node_p,0); tree=treecopy(node_p,0); /* Calculate what factor we need to include in the calculations*/ for(c=0;c<(steps);c++){ if(steps==1) /* Prevent divide by zero if only one step*/ f=f_min; else f=f_min+c*(f_max-f_min)/(steps-1); factor=f; factor_flag=-1; /* Flag = -1 means that we want to include the * factor on all branches*/ /* Add all the information to one copy from the original tree*/ filltree(node_p,tree,0); /* Change all the length in the tree to the scaled version * The array branch[] currently points to those of 'tree'*/ for(b=0;b<branches;b++){ branch[b]->length[0]=branch[b]->length[0]*f; a=findnode(branch[b]->node[0],branch[b]); (branch[b]->node[0])->length[a]=branch[b]->length[0]; } /* Make copy of the tree with scaled branches*/ filltree(tree,tree2,0); /* Branch[] now points to those in tree2 * Make leaves point to those on tree*/ leaves=0; doleaf(tree,0); printf("Doing factor %E\n",f); /* If we've been asked to print out the intermediate trees, then * dump them to all the open files*/ if(ISMODE(TREES)) print_tree(tree,file_p,0); fprintf(file_p,"%E\n",f); if(ISMODE(MATRICES)){ fprintf(matrix_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,matrix_file_p,0); } if(ISMODE(VARIANCE)){ fprintf(variance_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,variance_file_p,0); } if(sample_file_p!=NULL){ fprintf(sample_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,sample_file_p,0); } if(ISMODE(PROBS)){ fprintf(prob_file_p,"\n#Factor %E\n",f); if(ISMODE(TREES)) print_tree(tree,prob_file_p,0); } det=find_information(tree,tree2,e,factor_flag,factor); /* Possible may want to print out more than one result*/ b=1; if(ISMODE(INDIVIDUAL)) b=individual; if(ISMODE(INDIVIDUAL)){ if(ISMODE(DETINDIV)){ fprintf(file_p,"\t\t\t%E\tD(",det[0]); for(a=0;a<b-1;a++) fprintf(file_p,"%d,",interesting_branches[a]); fprintf(file_p,"%d)\n",interesting_branches[a]); }else for(a=0;a<b;a++) fprintf(file_p,"\t\t\t%E\t%d\n",det[a],interesting_branches[a]); }else fprintf(file_p,"\t\t\t%E\tD\n",det[0]); if(ISMODE(HKY) && NOTMODE(NOKAPPA) && NOTMODE(PERCENTILE)) fprintf(file_p,"\t\t\t%E\tKappa\n",det[b]); free(det); } }
int processdir(int level, const char *base, const char *dirname, struct stat *sb, struct filenode *dir, struct filenode *root, int curroffset) { DIR *dirfd; struct dirent *dp; struct filenode *n, *link; struct excludes *pe; if(level <= 1) { /* Ok, to make sure . and .. are handled correctly * we add them first. Note also that we alloc them * first to get to know the real name */ link = newnode(base, ".", curroffset); if(!lstat(link->realname, sb)) { setnode(link, sb->st_dev, sb->st_ino, sb->st_mode); append(&dir->dirlist, link); /* special case for root node - '..'s in subdirs should link to * '.' of root node, not root node itself. */ dir->dirlist.owner = link; curroffset = alignnode(link, curroffset, 0) + spaceneeded(link); n = newnode(base, "..", curroffset); if(!lstat(n->realname, sb)) { setnode(n, sb->st_dev, sb->st_ino, sb->st_mode); append(&dir->dirlist, n); n->orig_link = link; curroffset = alignnode(n, curroffset, 0) + spaceneeded(n); } } } dirfd = opendir(dir->realname); while((dp = readdir(dirfd))) { /* don't process main . and .. twice */ if(level <= 1 && (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)) continue; n = newnode(base, dp->d_name, curroffset); /* Process exclude list. */ for(pe = excludelist; pe; pe = pe->next) { if(!nodematch(pe->pattern, n)) { freenode(n); break; } } if(pe) continue; if(lstat(n->realname, sb)) { fprintf(stderr, "ignoring '%s' (lstat failed)\n", n->realname); freenode(n); continue; } /* Handle special names */ if(n->name[0] == '@') { if(S_ISLNK(sb->st_mode)) { /* this is a link to follow at build time */ n->name = n->name + 1; /* strip off the leading @ */ memset(bigbuf, 0, sizeof(bigbuf)); if(readlink(n->realname, bigbuf, sizeof(bigbuf))) { return -1; } n->realname = strdup(bigbuf); if(lstat(n->realname, sb)) { fprintf(stderr, "ignoring '%s' (lstat failed)\n", n->realname); freenode(n); continue; } } else if(S_ISREG(sb->st_mode) && sb->st_size == 0) { /* * special file @name,[bcp..],major,minor */ char devname[32]; char type; int major; int minor; if(sscanf(n->name, "@%[a-zA-Z0-9],%c,%d,%d", devname, &type, &major, &minor) == 4) { strcpy(n->name, devname); sb->st_rdev = makedev(major, minor); sb->st_mode &= ~S_IFMT; switch(type) { case 'c': case 'u': sb->st_mode |= S_IFCHR; break; case 'b': sb->st_mode |= S_IFBLK; break; case 'p': sb->st_mode |= S_IFIFO; break; default: fprintf(stderr, "Invalid special device type '%c' " "for file %s\n", type, n->realname); freenode(n); continue; } } } } setnode(n, sb->st_dev, sb->st_ino, sb->st_mode); /* Skip unreadable files/dirs */ if(!S_ISLNK(n->modes) && access(n->realname, R_OK)) { fprintf(stderr, "ignoring '%s' (access failed)\n", n->realname); freenode(n); continue; } /* Look up old links */ if(strcmp(n->name, ".") == 0) { append(&dir->dirlist, n); link = n->parent; } else if(strcmp(n->name, "..") == 0) { append(&dir->dirlist, n); link = n->parent->parent; } else { link = findnode(root, n->ondev, n->onino); append(&dir->dirlist, n); } if(link) { n->orig_link = link; curroffset = alignnode(n, curroffset, 0) + spaceneeded(n); continue; } if(S_ISREG(sb->st_mode)) { curroffset = alignnode(n, curroffset, spaceneeded(n)); n->size = sb->st_size; } else curroffset = alignnode(n, curroffset, 0); if(S_ISLNK(sb->st_mode)) { n->size = sb->st_size; } curroffset += spaceneeded(n); if(S_ISCHR(sb->st_mode) || S_ISBLK(sb->st_mode)) { n->devnode = sb->st_rdev; } if(S_ISDIR(sb->st_mode)) { if(!strcmp(n->name, "..")) { curroffset = processdir(level + 1, dir->realname, dp->d_name, sb, dir, root, curroffset); } else { curroffset = processdir(level + 1, n->realname, dp->d_name, sb, n, root, curroffset); } if(curroffset < 0) return -1; } } closedir(dirfd); return curroffset; }
int newpremise(int logop) /* **-------------------------------------------------------------------- ** Adds new premise to current rule. ** Formats are: ** IF/AND/OR <object> <id> <variable> <operator> <value> ** IF/AND/OR SYSTEM <variable> <operator> <value> (units) ** ** Calls findmatch() and hour() in INPUT2.C. ** Calls findnode() and findlink() in EPANET.C. **--------------------------------------------------------------------- */ { int i,j,k,m,r,s,v; double x; struct Premise *p; /* Check for correct number of tokens */ if (Ntokens != 5 && Ntokens != 6) return(201); /* Find network object & id if present */ i = findmatch(Tok[1],Object); if (i == r_SYSTEM) { j = 0; v = findmatch(Tok[2],Varword); if (v != r_DEMAND && v != r_TIME && v != r_CLOCKTIME) return(201); } else { v = findmatch(Tok[3],Varword); if (v < 0) return(201); switch (i) { case r_NODE: case r_JUNC: case r_RESERV: case r_TANK: k = r_NODE; break; case r_LINK: case r_PIPE: case r_PUMP: case r_VALVE: k = r_LINK; break; default: return(201); } i = k; if (i == r_NODE) { j = findnode(Tok[2]); if (j == 0) return(203); switch (v) { case r_DEMAND: case r_HEAD: case r_GRADE: case r_LEVEL: case r_PRESSURE: break; /*** Updated 9/7/00 ***/ case r_FILLTIME: case r_DRAINTIME: if (j <= Njuncs) return(201); break; default: return(201); } } else { j = findlink(Tok[2]); if (j == 0) return(204); switch (v) { case r_FLOW: case r_STATUS: case r_SETTING: break; default: return(201); } } } /* Parse relational operator (r) and check for synonyms */ if (i == r_SYSTEM) m = 3; else m = 4; k = findmatch(Tok[m],Operator); if (k < 0) return(201); switch(k) { case IS: r = EQ; break; case NOT: r = NE; break; case BELOW: r = LT; break; case ABOVE: r = GT; break; default: r = k; } /* Parse for status (s) or numerical value (x) */ s = 0; x = MISSING; if (v == r_TIME || v == r_CLOCKTIME) { if (Ntokens == 6) x = hour(Tok[4],Tok[5])*3600.; else x = hour(Tok[4],"")*3600.; if (x < 0.0) return(202); } else if ((k = findmatch(Tok[Ntokens-1],Value)) > IS_NUMBER) s = k; else { if (!getfloat(Tok[Ntokens-1],&x)) return(202); if (v == r_FILLTIME || v == r_DRAINTIME) x = x*3600.0; //(2.00.11 - LR) } /* Create new premise structure */ p = (struct Premise *) malloc(sizeof(struct Premise)); if (p == NULL) return(101); p->object = i; p->index = j; p->variable = v; p->relop = r; p->logop = logop; p->status = s; p->value = x; /* Add premise to current rule's premise list */ p->next = NULL; if (Plast == NULL) Rule[Nrules].Pchain = p; else Plast->next = p; Plast = p; return(0); }
/* ARGSUSED */ static int ls_fileproc (void *callerdat, struct file_info *finfo) { Vers_TS *vers; char *regex_err; Node *p, *n; bool isdead; const char *filename; if (regexp_match) { #ifdef FILENAMES_CASE_INSENSITIVE re_set_syntax (REG_ICASE|RE_SYNTAX_EGREP); #else re_set_syntax (RE_SYNTAX_EGREP); #endif if ((regex_err = re_comp (regexp_match)) != NULL) { error (1, 0, "bad regular expression passed to 'ls': %s", regex_err); } if (re_exec (finfo->file) == 0) return 0; /* no match */ } vers = Version_TS (finfo, NULL, show_tag, show_date, 1, 0); /* Skip dead revisions unless specifically requested to do otherwise. * We also bother to check for long_format so we can print the state. */ if (vers->vn_rcs && (!show_dead_revs || long_format)) isdead = RCS_isdead (finfo->rcs, vers->vn_rcs); else isdead = false; if (!vers->vn_rcs || (!show_dead_revs && isdead)) { freevers_ts (&vers); return 0; } p = findnode (callerdat, finfo->update_dir); if (!p) { /* This only occurs when a complete path to a file is specified on the * command line. Put the file in the root list. */ filename = finfo->fullname; /* Add update_dir node. */ p = findnode (callerdat, "."); if (!p) { p = getnode (); p->key = xstrdup ("."); p->data = getlist (); p->delproc = ls_delproc; addnode (callerdat, p); } } else filename = finfo->file; n = getnode(); if (entries_format) { char *outdate = entries_time (RCS_getrevtime (finfo->rcs, vers->vn_rcs, 0, 0)); n->data = Xasprintf ("/%s/%s/%s/%s/%s%s\n", filename, vers->vn_rcs, outdate, vers->options, show_tag ? "T" : "", show_tag ? show_tag : ""); free (outdate); } else if (long_format) { struct long_format_data *out = xmalloc (sizeof (struct long_format_data)); out->header = Xasprintf ("%-5.5s", vers->options[0] != '\0' ? vers->options : "----"); /* FIXME: Do we want to mimc the real `ls' command's date format? */ out->time = gmformat_time_t (RCS_getrevtime (finfo->rcs, vers->vn_rcs, 0, 0)); out->footer = Xasprintf (" %-9.9s%s %s%s", vers->vn_rcs, strlen (vers->vn_rcs) > 9 ? "+" : " ", show_dead_revs ? (isdead ? "dead " : " ") : "", filename); n->data = out; n->delproc = long_format_data_delproc; } else n->data = Xasprintf ("%s\n", filename); addnode (p->data, n); freevers_ts (&vers); return 0; }
/* Function: * * Purpose: calculates the path from root to leaf * * Args: p,q: * wtree: * * Returns: void */ float leaf2leaf(node *q,tree wtree, node *p,int k , int l){ int i=0; int m; node **nodearray; float *branchorder; float lengthtoleaf =0; int odd=1; struct node *n; n = (struct node *)malloc(sizeof(struct node)); n->tip=1; nodearray = (struct node **)malloc(sizeof(struct node *)); *(nodearray+i) = (struct node *)malloc(sizeof(struct node)); nodearray[i] = q; branchorder = (float *)calloc(1,sizeof(float)); branchorder[i]=0; while(q!=p){ if (q->back == NULL) q->back=n; if (odd && !(q->back->tip)) { int j; nodearray = (struct node **)realloc(nodearray,(i+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(i+2)*(sizeof (float))); *(nodearray+(i+1)) = (struct node *)malloc(sizeof(struct node)); nodearray[i+1] = q->back; branchorder[i+1]=q->v; ++i; /* printf("nodearray[%d]->next: %p\n",i, nodearray[i]); printf("i: %d\n",i); fflush(stdout);*/ odd = !odd; q = q->back; j = findnode(nodearray, q, i); /* printf("j: %d\n",j);*/ fflush(stdout); if (j < i){ nodearray = (struct node **)realloc(nodearray,(j+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(j+2)*(sizeof (float))); nodearray[j+1]=q->next; branchorder[j+1]=0; j++; /* printf("nodearray[%d]: %p\n",j, nodearray[j]); */ i=j; /* printf("i: %d, j: %d\n",i,j);*/ fflush(stdout); } } else if (odd && (q->back->tip) && (q->back!=p)){ int j; nodearray = (struct node **)realloc(nodearray,(i+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(i+2)*(sizeof(float))); *(nodearray+(i+1)) = (struct node *)malloc(sizeof(struct node)); nodearray[i+1] = nodearray[i]->next; branchorder[i+1] = 0; ++i; q = q->next; j = findnode(nodearray, q, i); /* printf("nodearray[%d]->next: %p\n",i, nodearray[i]); printf("odd,tip: i: %d, j: %d\n",i,j); fflush(stdout);*/ if (j < i){ nodearray = (struct node **)realloc(nodearray,(j)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(j)*(sizeof (float))); i = j; /* printf("i: %d, j: %d\n",i,j); fflush(stdout);*/ } } else if (odd && (q->back->tip) && (q->back==p)){ /* int j = 0; printf("odd,q=p: i: %d, j: %d\n",i,j);*/ nodearray = (struct node **)realloc(nodearray,(i+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(i+2)*(sizeof(float))); *(nodearray+(i+1)) = (struct node *)malloc(sizeof(struct node)); nodearray[i+1] = nodearray[i]->back; branchorder[i+1] = q->v; ++i; /* printf("nodearray[%d]->next: %p\n",i, nodearray[i]); printf("odd,q=p: i: %d, j: %d\n",i,j); fflush(stdout);*/ q = q->back; } else if (!odd){ int j; nodearray = (struct node **)realloc(nodearray,(i+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(i+2)*(sizeof(float))); *(nodearray+(i+1)) = (struct node *)malloc(sizeof(struct node)); nodearray[i+1] = nodearray[i]->next; branchorder[i+1] = 0; ++i; /* printf("nodearray[%d]->next: %p\n",i, nodearray[i]); fflush(stdout);*/ odd = !odd; q = q->next; j = findnode(nodearray, q, i); /* printf("!odd: i: %d, j: %d\n",i,j); fflush(stdout);*/ if (j < i){ nodearray = (struct node **)realloc(nodearray,(j+2)*sizeof(struct node *)); branchorder = (float *)realloc(branchorder,(j+2)*(sizeof (float))); nodearray[j] = q; i = j; /* printf("i: %d, j: %d\n",i,j); fflush(stdout);*/ } } } /* printf("i: %d\n",i);*/ brancharray[k][l] = (struct node **)malloc((i+1)*sizeof(struct node *)); blgth[k][l] = (float *)calloc((i+1),sizeof(float)); for (m=0; m <= i; ++m){ lengthtoleaf = lengthtoleaf + branchorder[m]; arraysize[k][l]=i+1; brancharray[k][l][m]=nodearray[m]; blgth[k][l][m]=branchorder[m]; /*printf("nodearray[%d]->v: %f; p: %p\n",k,branchorder[m], nodearray[m]);*/ } free(nodearray); free(branchorder); return lengthtoleaf; }
/* * Add this directory to the list of data to be printed for a directory and * decide whether to tell the recursion processor whether to continue * recursing or not. */ static Dtype ls_direntproc (void *callerdat, const char *dir, const char *repos, const char *update_dir, List *entries) { Dtype retval; Node *p; /* Due to the way we called start_recursion() from ls_proc() with a single * argument at a time, we can assume that if we don't yet have a parent * directory in DIRS then this directory should be processed. */ if (strcmp (dir, ".")) { /* Search for our parent directory. */ char *parent; parent = xmalloc (strlen (update_dir) - strlen (dir) + 1); strncpy (parent, update_dir, strlen (update_dir) - strlen (dir)); parent[strlen (update_dir) - strlen (dir)] = '\0'; strip_trailing_slashes (parent); p = findnode (callerdat, parent); } else p = NULL; if (p) { /* Push this dir onto our parent directory's listing. */ Node *n = getnode(); if (entries_format) n->data = Xasprintf ("D/%s////\n", dir); else if (long_format) { struct long_format_data *out = xmalloc (sizeof (struct long_format_data)); out->header = xstrdup ("d--- "); out->time = gmformat_time_t (unix_time_stamp (repos)); out->footer = Xasprintf ("%12s%s%s", "", show_dead_revs ? " " : "", dir); n->data = out; n->delproc = long_format_data_delproc; } else n->data = Xasprintf ("%s\n", dir); addnode (p->data, n); } if (!p || recurse) { /* Create a new list for this directory. */ p = getnode (); p->key = xstrdup (strcmp (update_dir, ".") ? update_dir : ""); p->data = getlist (); p->delproc = ls_delproc; addnode (callerdat, p); /* Create a local directory and mark it as needing deletion. This is * the behavior the recursion processor relies upon, a la update & * checkout. */ if (!isdir (dir)) { int nonbranch; if (show_tag == NULL && show_date == NULL) { ParseTag (&show_tag, &show_date, &nonbranch); set_tag = true; } if (!created_dir) created_dir = xstrdup (update_dir); make_directory (dir); Create_Admin (dir, update_dir, repos, show_tag, show_date, nonbranch, 0, 0); Subdir_Register (entries, NULL, dir); } /* Tell do_recursion to keep going. */ retval = R_PROCESS; } else retval = R_SKIP_ALL; return retval; }