Return to pdlist.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / spms / src / bin / pexec

Annotation of 43BSDTahoe/new/spms/src/bin/pexec/pdlist.c, revision 1.1.1.1

1.1       root        1: /* $Header$ */
                      2: 
                      3: /*
                      4:  * Author: Peter J. Nicklin
                      5:  */
                      6: #include "null.h"
                      7: #include "pdlist.h"
                      8: #include "yesno.h"
                      9: 
                     10: /*
                     11:  * pdinit() returns a pointer to the head block of a new project directory
                     12:  * list, or dies if out of memory.
                     13:  */
                     14: PDLIST *
                     15: pdinit()
                     16: {
                     17:        char *malloc();                 /* memory allocator */
                     18:        PDLIST *pdlist;                 /* pointer to list head block */
                     19: 
                     20:        if ((pdlist = (PDLIST *) malloc(sizeof(PDLIST))) == NULL)
                     21:                nomorecore();
                     22:        pdlist->nd = 0;
                     23:        pdlist->head = NULL;
                     24:        return(pdlist);
                     25: }
                     26: 
                     27: 
                     28: 
                     29: /*
                     30:  * pdprepend() saves null-terminated project directory pathnames
                     31:  * somewhere and inserts a pointer to the directory at the head of list
                     32:  * pdlist. Returns a pointer to the pathname, or dies if out of
                     33:  * memory.
                     34:  */
                     35: char *
                     36: pdprepend(ppathname, pathname, project, pdlist)
                     37:        char *ppathname;                /* project directory project pathname */
                     38:        char *pathname;                 /* project directory regular pathname */
                     39:        char *project;                  /* project directory's project */
                     40:        PDLIST *pdlist;                 /* pointer to list head block */
                     41: {
                     42:        char *malloc();                 /* memory allocator */
                     43:        char *strcpy();                 /* string copy */
                     44:        int strlen();                   /* string length */
                     45:        PDBLK *pdbptr;                  /* pointer to list block */
                     46: 
                     47:        if (pdlist == NULL)
                     48:                return(NULL);
                     49:        if ((pdbptr = (PDBLK *) malloc(sizeof(PDBLK))) == NULL ||
                     50:            (pdbptr->ppath = malloc((unsigned)(strlen(ppathname)+1))) == NULL ||
                     51:            (pdbptr->rpath = malloc((unsigned)(strlen(pathname)+1))) == NULL)
                     52:                nomorecore();
                     53:        strcpy(pdbptr->rpath, pathname);
                     54:        strcpy(pdbptr->ppath, ppathname);
                     55:        pdbptr->project = project;
                     56:        pdbptr->next = pdlist->head;
                     57:        pdlist->head = pdbptr;
                     58:        pdlist->nd++;
                     59:        return(pdbptr->ppath);
                     60: }
                     61: 
                     62: 
                     63: 
                     64: /*
                     65:  * pdrm() removes a project directory list.
                     66:  */
                     67: void
                     68: pdrm(pdlist)
                     69:        PDLIST *pdlist;                 /* pointer to list head block */
                     70: {
                     71:        PDBLK *nxtblk;                  /* next list block */
                     72: 
                     73:        while (pdlist->head != NULL)
                     74:                {
                     75:                nxtblk = pdlist->head->next;
                     76:                free(pdlist->head->ppath);
                     77:                free(pdlist->head->rpath);
                     78:                free((char *) pdlist->head);
                     79:                pdlist->head = nxtblk;
                     80:                }
                     81:        free((char *) pdlist);
                     82: }
                     83: 
                     84: 
                     85: 
                     86: /*
                     87:  * pdsort() sorts list pdlist according to comparison function compar().
                     88:  * compar() is to be called with two arguments and must return an integer
                     89:  * greater than, equal to, or less than 0, depending on the lexicographic
                     90:  * relationship between the two arguments.
                     91:  */
                     92: 
                     93: static int (*sscmp)();                 /* string compare function */
                     94: 
                     95: void
                     96: pdsort(compar, pdlist)
                     97:        int (*compar)();                /* compare two strings */
                     98:        PDLIST *pdlist;                 /* pointer to list head block */
                     99: {
                    100:        char *malloc();                 /* memory allocator */
                    101:        int bpi;                        /* block pointer array index */
                    102:        int comparb();                  /* compare 2 list blocks */
                    103:        PDBLK **bp;                     /* pointer to block pointer array */
                    104:        PDBLK *curblk;                  /* current list block */
                    105: 
                    106:        if (pdlist->nd <= 0)
                    107:                return;
                    108:        else if ((bp = (PDBLK **) malloc((unsigned)pdlist->nd*sizeof(PDBLK *)))==NULL)
                    109:                nomorecore();
                    110:        for (bpi=0, curblk=pdlist->head; curblk != NULL; bpi++, curblk=curblk->next)
                    111:                bp[bpi] = curblk;
                    112: 
                    113:        sscmp = compar;
                    114:        qsort((char *) bp, pdlist->nd, sizeof(PDBLK *), comparb);
                    115: 
                    116:        for (bpi=0, curblk=pdlist->head=bp[bpi++]; bpi < pdlist->nd; bpi++)
                    117:                curblk = curblk->next = bp[bpi];
                    118:        curblk->next = NULL;
                    119:        
                    120:        free((char *) bp);
                    121: }
                    122: 
                    123: 
                    124: 
                    125: /*
                    126:  * comparb() compares project directory pathnames in 2 list blocks.
                    127:  * Returns whatever sscmp() returns. sscmp() is a string compare function.
                    128:  */
                    129: static int
                    130: comparb(b1, b2)
                    131:        PDBLK **b1;                     /* block pointer */
                    132:        PDBLK **b2;                     /* block pointer */
                    133: {
                    134:        return(sscmp((*b1)->ppath, (*b2)->ppath));
                    135: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.