Return to lnklist.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / tran

Annotation of 43BSD/contrib/icon/tran/lnklist.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Routines for handling file linking.
        !             3:  */
        !             4: 
        !             5: #include "itran.h"
        !             6: #include "lfile.h"
        !             7: 
        !             8: struct lfile *lfiles;
        !             9: 
        !            10: /*
        !            11:  * alclfile allocates an lfile structure for the named file, fills
        !            12:  *  in the name and returns a pointer to it.
        !            13:  */
        !            14: struct lfile *alclfile(name)
        !            15: char *name;
        !            16:    {
        !            17:    struct lfile *p;
        !            18:    char *np;
        !            19:    int l;
        !            20:    extern char *allocate();
        !            21:    
        !            22:    p = (struct lfile *)allocate(1,sizeof(struct lfile));
        !            23:    if (!p)
        !            24:       syserr("not enough memory for file list");
        !            25:    p->lf_link = NULL;
        !            26:    l = strlen(name);
        !            27:    np = allocate(1,(l+1+sizeof(int *)) & ~(sizeof(int *)-1));
        !            28:    if (!np)
        !            29:       syserr("not enough memory for file list");
        !            30:    strncpy(np,name,l);
        !            31:    p->lf_name = np;
        !            32:    return p;
        !            33:    }
        !            34: /*
        !            35:  * dumplfiles - print the list of files to link.  Debugging only.
        !            36:  */
        !            37: dumplfiles()
        !            38: {
        !            39:    struct lfile *p,*lfls;
        !            40: 
        !            41:    printf("lfiles:\n");
        !            42:    lfls = lfiles;
        !            43:    while (p = getlfile(&lfls))
        !            44:        printf("'%s'\n",p->lf_name);
        !            45: }
        !            46: /*
        !            47:  * addlfile creates an lfile structure for the named file and add it to the
        !            48:  *  end of the list of files (lfiles) to generate link instructions for.
        !            49:  */
        !            50: addlfile(name)
        !            51: char *name;
        !            52: {
        !            53:    struct lfile *nlf, *p;
        !            54:    
        !            55:    nlf = alclfile(name);
        !            56:    if (lfiles == NULL) {
        !            57:       lfiles = nlf;
        !            58:       }
        !            59:    else {
        !            60:       p = lfiles;
        !            61:       while (p->lf_link != NULL) {
        !            62:          p = p->lf_link;
        !            63:          }
        !            64:       p->lf_link = nlf;
        !            65:       }
        !            66: }
        !            67: /*
        !            68:  * getlfile returns a pointer (p) to the lfile structure pointed at by lptr
        !            69:  *  and moves lptr to the lfile structure that p points at.  In other words,
        !            70:  *  getlfile returns a pointer to the current (wrt. lptr) lfile and advances
        !            71:  *  lptr.
        !            72:  */
        !            73: struct lfile *
        !            74: getlfile(lptr)
        !            75: struct lfile **lptr;
        !            76: {
        !            77:    struct lfile *p;
        !            78:    
        !            79:    if (*lptr == NULL)
        !            80:       return NULL;
        !            81:    else {
        !            82:       p = *lptr;
        !            83:       *lptr = p->lf_link;
        !            84:       return p;
        !            85:       }
        !            86: }

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