Return to mkproject.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / spms / src / bin / mkproject

Annotation of 43BSD/contrib/spms/src/bin/mkproject/mkproject.c, revision 1.1

1.1     ! root        1: static char *rcsid = "$Header";
        !             2: /*
        !             3:  * mkproject - make a project root directory
        !             4:  *
        !             5:  * Author: Peter J. Nicklin
        !             6:  */
        !             7: #include <signal.h>
        !             8: #include <stdio.h>
        !             9: #include <sys/types.h>
        !            10: #include <sys/stat.h>
        !            11: #include "getarg.h"
        !            12: #include "macro.h"
        !            13: #include "null.h"
        !            14: #include "path.h"
        !            15: #include "pdb.h"
        !            16: #include "pld.h"
        !            17: #include "slist.h"
        !            18: #include "spms.h"
        !            19: #include "system.h"
        !            20: #include "yesno.h"
        !            21: 
        !            22: char CWD[PATHSIZE];                    /* current working directory */
        !            23: char *CWP;                             /* current working project */
        !            24: char *PGN = "mkproject";               /* program name */
        !            25: int WANT_TO_EXIT = 0;                  /* advisory exit flag */
        !            26: 
        !            27: main(argc, argv)
        !            28:        int argc;
        !            29:        char **argv;
        !            30: {
        !            31:        extern int PPDEBUG;             /* project pathname debug flag */
        !            32:        char *alias = NULL;             /* alternative project directory name */
        !            33:        char *getcwp();                 /* get current working project */
        !            34:        char *getwd();                  /* get current working directory */
        !            35:        int addtyp();                   /* make project directory type labels */
        !            36:        int chalias();                  /* change project directory alias */
        !            37:        int chdesc();                   /* change project directory descrip */
        !            38:        int isfg();                     /* is process in foreground? */
        !            39:        int minusdflag = YES;           /* project directory description flag */
        !            40:        int mkproject();                /* make a project root directory */
        !            41:        int mustexist = 0;              /* existing directories flag */
        !            42:        int plusdflag = NO;             /* project directory description flag */
        !            43:        int typargtolist();             /* type labels -> pdirtyp list */
        !            44:        int xppath();                   /* expand project pathname */
        !            45:        PATH pathbuf;                   /* pathname struct buffer */
        !            46:        SLIST *pdirtyp;                 /* project directory type labels list */
        !            47:        SLIST *slinit();                /* initialize singly-linked list */
        !            48:        int onintr();                   /* process signals */
        !            49:        int status = 0;                 /* exit status */
        !            50: 
        !            51:        pdirtyp = slinit();
        !            52:        {
        !            53:        register char *s;               /* option pointer */
        !            54:        while (--argc > 0 && (**++argv == '-' || **argv == '+'))
        !            55:                {
        !            56:                if (**argv == '-')
        !            57:                        {
        !            58:                        for (s = argv[0]+1; *s != '\0'; s++)
        !            59:                                switch (*s)
        !            60:                                        {
        !            61:                                        case 'D':
        !            62:                                                PPDEBUG = YES;
        !            63:                                                break;
        !            64:                                        case 'N':
        !            65:                                                alias = GETARG(s);
        !            66:                                                if (*alias == '\0')
        !            67:                                                        status = 1;
        !            68:                                                goto endif;
        !            69:                                        case 'T':
        !            70:                                                if (typargtolist(GETARG(s),pdirtyp)==NO)
        !            71:                                                        status = 1;
        !            72:                                                else if (*s == '\0')
        !            73:                                                        status = 1;
        !            74:                                                goto endif;
        !            75:                                        case 'd':
        !            76:                                                minusdflag = NO;
        !            77:                                                break;
        !            78:                                        default:
        !            79:                                                warn("bad option -%c", *s);
        !            80:                                                status = 1;
        !            81:                                                goto endif;
        !            82:                                        }
        !            83:                        }
        !            84:                else    {
        !            85:                        mustexist = 1;
        !            86:                        for (s = argv[0]+1; *s != '\0'; s++)
        !            87:                                switch (*s)
        !            88:                                        {
        !            89:                                        case 'N':
        !            90:                                                alias = GETARG(s);
        !            91:                                                if (*alias == '\0')
        !            92:                                                        status = 1;
        !            93:                                                goto endif;
        !            94:                                        case 'T':
        !            95:                                                if (typargtolist(GETARG(s),pdirtyp)==NO)
        !            96:                                                        status = 1;
        !            97:                                                else if (*s == '\0')
        !            98:                                                        status = 1;
        !            99:                                                goto endif;
        !           100:                                        case 'd':
        !           101:                                                plusdflag = YES;
        !           102:                                                break;
        !           103:                                        default:
        !           104:                                                warn("bad option +%c", *s);
        !           105:                                                status = 1;
        !           106:                                                goto endif;
        !           107:                                        }
        !           108:                        }
        !           109:                endif: continue;
        !           110:                }
        !           111:        if (status == 1 || argc < 1)
        !           112:                fatal("usage: mkproject [{+-}d] [{+-}N alias] %s",
        !           113:                      "[{+-}T type[,type...]]\n           projectname ...");
        !           114:        }
        !           115: 
        !           116:        if (getwd(CWD) == NULL)
        !           117:                fatal("can't find current working directory");
        !           118:        CWP = getcwp();
        !           119:        if (isfg() == YES)
        !           120:                {
        !           121:                signal(SIGINT, onintr);
        !           122:                signal(SIGQUIT, onintr);
        !           123:                signal(SIGHUP, onintr);
        !           124:                }
        !           125: 
        !           126:        for (; argc > 0; argv++, argc--)
        !           127:                {
        !           128:                if (xppath(*argv, &pathbuf) == -1)
        !           129:                        {
        !           130:                        patherr(*argv);
        !           131:                        status = 1;
        !           132:                        continue;
        !           133:                        }
        !           134:                if (CWP == NULL && (pathbuf.p_mode&P_IFMT) != P_IFHOME)
        !           135:                        fatal("no project environment");
        !           136:                if (mustexist)
        !           137:                        switch (pathbuf.p_mode & P_IFMT)
        !           138:                                {
        !           139:                                case P_IFHOME:
        !           140:                                case P_IFPROOT:
        !           141:                                        if (SLNUM(pdirtyp) > 0)
        !           142:                                                status |= addtyp(*argv, pdirtyp,
        !           143:                                                          &pathbuf);
        !           144:                                        if (plusdflag == YES)
        !           145:                                                status |= chdesc(*argv, &pathbuf);
        !           146:                                        if (alias != NULL)
        !           147:                                                status |= chalias(*argv, alias,
        !           148:                                                           &pathbuf);
        !           149:                                        break;
        !           150:                                case P_IFPDIR:
        !           151:                                        warn("%s is a project directory", *argv);
        !           152:                                        status = 1;
        !           153:                                        break;
        !           154:                                case P_IFNEW:
        !           155:                                case P_IFREG:
        !           156:                                        warn("%s: no such project", *argv);
        !           157:                                        status = 1;
        !           158:                                        break;
        !           159:                                }
        !           160:                else    {
        !           161:                        status |= mkproject(*argv, alias, pdirtyp, minusdflag, &pathbuf);
        !           162:                        }
        !           163:                if (WANT_TO_EXIT)
        !           164:                        exit(1);
        !           165:                }
        !           166:        exit(status);
        !           167: }
        !           168: 
        !           169: 
        !           170: 
        !           171: /*
        !           172:  * addtyp() adds type labels to an existing project directory.
        !           173:  */
        !           174: addtyp(ppathname, pdirtyp, pb)
        !           175:        char *ppathname;                /* project directory pathname */
        !           176:        SLIST *pdirtyp;                 /* project directory type labels list */
        !           177:        PATH *pb;                       /* pathname struct buffer */
        !           178: {
        !           179:        char *pbfndkey();               /* find key */
        !           180:        int closepdb();                 /* close database */
        !           181:        int errpdb();                   /* print database error */
        !           182:        int pgetent();                  /* load next entry into buffer */
        !           183:        int pputent();                  /* write buffer to database */
        !           184:        PDB *openpdb();                 /* open database */
        !           185:        PDB *pldp;                      /* project link directory stream */
        !           186:        void pbaddtyp();                /* add type labels to buffer */
        !           187: 
        !           188:        if ((pldp = openpdb(PLDNAME, pb->p_project, "rw")) == NULL)
        !           189:                return(errpdb((PDB *) NULL));
        !           190:        while (pgetent(pldp) != EOF)
        !           191:                {
        !           192:                if (pbfndkey(CURPROJECT) != NULL)
        !           193:                        pbaddtyp(ppathname, pdirtyp);
        !           194:                pputent(pldp);
        !           195:                }
        !           196:        return(closepdb(pldp));
        !           197: }
        !           198: 
        !           199: 
        !           200: 
        !           201: /*
        !           202:  * badtyp() prints a bad format type label message.
        !           203:  */
        !           204: void
        !           205: badtyp(type)
        !           206:        char *type;                     /* type label */
        !           207: {
        !           208:        warn("\"%s\" type label is badly formatted", type);
        !           209: }
        !           210: 
        !           211: 
        !           212: 
        !           213: /*
        !           214:  * chalias() changes an existing project directory alias.
        !           215:  */
        !           216: chalias(ppathname, newalias, pb)
        !           217:        char *ppathname;                /* project directory pathname */
        !           218:        char *newalias;                 /* new project directory alias */
        !           219:        PATH *pb;                       /* pathname struct buffer */
        !           220: {
        !           221:        char *pbfndkey();               /* find key */
        !           222:        char *ppathcat();               /* project pathname concatenation */
        !           223:        char pppathname[PPATHSIZE];     /* parent project pathname */
        !           224:        int _closepdb();                /* close database without updating */
        !           225:        int closepdb();                 /* close database */
        !           226:        int errpdb();                   /* print database error */
        !           227:        int pbchgkey();                 /* change existing key */
        !           228:        int pgetent();                  /* load next entry into buffer */
        !           229:        int pputent();                  /* write buffer to database */
        !           230:        int xppath();                   /* expand project pathname */
        !           231:        PATH ppathbuf;                  /* parent pathname struct buffer */
        !           232:        PDB *openpdb();                 /* open database */
        !           233:        PDB *pldp;                      /* project link directory stream */
        !           234: 
        !           235:        ppathcat(pppathname, ppathname, PARENTPROJECT);
        !           236:        xppath(pppathname, &ppathbuf);
        !           237:        if ((pldp = openpdb(PLDNAME, ppathbuf.p_path, "rw")) == NULL)
        !           238:                return(errpdb((PDB *) NULL));
        !           239:        while (pgetent(pldp) != EOF)
        !           240:                {
        !           241:                if (pbfndkey(newalias) != NULL)
        !           242:                        {
        !           243:                        warn("%s: %s exists", ppathname, newalias);
        !           244:                        _closepdb(pldp);
        !           245:                        return(1);
        !           246:                        }
        !           247:                pbchgkey(pb->p_alias, newalias);
        !           248:                pputent(pldp);
        !           249:                }
        !           250:        return(closepdb(pldp));
        !           251: }
        !           252: 
        !           253: 
        !           254: 
        !           255: /*
        !           256:  * chdesc() changes an existing project directory description.
        !           257:  */
        !           258: chdesc(ppathname, pb)
        !           259:        char *ppathname;                /* project directory pathname */
        !           260:        PATH *pb;                       /* pathname struct buffer */
        !           261: {
        !           262:        char *pbfndkey();               /* find key */
        !           263:        int closepdb();                 /* close database */
        !           264:        int errpdb();                   /* print database error */
        !           265:        int pgetent();                  /* load next entry into buffer */
        !           266:        int pputent();                  /* write buffer to database */
        !           267:        PDB *openpdb();                 /* open database */
        !           268:        PDB *pldp;                      /* project link directory stream */
        !           269:        void pbadddesc();               /* add project directory description */
        !           270: 
        !           271:        if ((pldp = openpdb(PLDNAME, pb->p_project, "rw")) == NULL)
        !           272:                return(errpdb((PDB *) NULL));
        !           273:        while (pgetent(pldp) != EOF)
        !           274:                {
        !           275:                if (pbfndkey(CURPROJECT) != NULL)
        !           276:                        pbadddesc(ppathname);
        !           277:                pputent(pldp);
        !           278:                }
        !           279:        return(closepdb(pldp));
        !           280: }
        !           281: 
        !           282: 
        !           283: 
        !           284: /*
        !           285:  * mkpld() creates a project link directory. If PLDNAME already exists,
        !           286:  * the database is altered accordingly.
        !           287:  */
        !           288: mkpld(pathname, ppathname, ptp, pdirtyp, dflag)
        !           289:        char *pathname;                 /* project root directory pathname */
        !           290:        char *ppathname;                /* project directory pathname */
        !           291:        char *ptp;                      /* path to parent project */
        !           292:        SLIST *pdirtyp;                 /* project directory type labels list */
        !           293:        int dflag;                      /* project directory description flag */
        !           294: {
        !           295:        char *pathcat();                /* pathname concatenation */
        !           296:        char *pbfndkey();               /* find key */
        !           297:        char pldpath[PATHSIZE];         /* project link directory pathname */
        !           298:        int closepdb();                 /* close database */
        !           299:        int errpdb();                   /* print database error message */
        !           300:        int pbaddflag();                /* add flag field */
        !           301:        int pbaddkey();                 /* add key */
        !           302:        int pbaddstring();              /* add string field */
        !           303:        int pgetent();                  /* load database entry into buffer */
        !           304:        int pputent();                  /* write buffer to database */
        !           305:        PDB *openpdb();                 /* open database */
        !           306:        PDB *pldp;                      /* project link directory stream */
        !           307:        void pbclear();                 /* clear buffer */
        !           308:        void resetpdb();                /* reset current database pointer */
        !           309:        void pbadddesc();               /* add project directory description */
        !           310:        void pbaddtyp();                /* add type labels to buffer */
        !           311: 
        !           312:        if (FILEXIST(pathcat(pldpath, pathname, PLDNAME)))
        !           313:                {
        !           314:                if ((pldp = openpdb(PLDNAME, pathname, "rw")) == NULL)
        !           315:                        return(errpdb((PDB *) NULL));
        !           316:                while (pgetent(pldp) != EOF)
        !           317:                        {
        !           318:                        if (pbfndkey(CURPROJECT) != NULL)
        !           319:                                {
        !           320:                                pbaddtyp(ppathname, pdirtyp);
        !           321:                                if (dflag == YES)
        !           322:                                        pbadddesc(ppathname);
        !           323:                                }
        !           324:                        else if (pbfndkey(PARENTPROJECT) != NULL)
        !           325:                                pbaddstring(PDIRPATH, ptp);
        !           326:                        pputent(pldp);
        !           327:                        }
        !           328:                }
        !           329:        else    {
        !           330:                if ((pldp = openpdb(PLDNAME, pathname, "w")) == NULL)
        !           331:                        return(errpdb((PDB *) NULL));
        !           332: 
        !           333:                /* create current project entry */
        !           334:                resetpdb(pldp);
        !           335:                pbclear();
        !           336:                pbaddkey(CURPROJECT);
        !           337:                pbaddflag(PROOTDIR);
        !           338:                pbaddstring(PDIRPATH, CURDIR);
        !           339:                pbaddtyp(ppathname, pdirtyp);
        !           340:                if (dflag == YES)
        !           341:                        pbadddesc(ppathname);
        !           342:                else
        !           343:                        pbaddstring(PDIRDESC, "");
        !           344:                pputent(pldp);
        !           345: 
        !           346:                /* create parent project entry */
        !           347:                pbclear();
        !           348:                pbaddkey(PARENTPROJECT);
        !           349:                pbaddflag(PROOTDIR);
        !           350:                pbaddstring(PDIRPATH, ptp);
        !           351:                pputent(pldp);
        !           352:                }
        !           353:        return(closepdb(pldp));
        !           354: }
        !           355: 
        !           356: 
        !           357: 
        !           358: /*
        !           359:  * mkproject() makes a project root directory.
        !           360:  */
        !           361: mkproject(ppathname, alias, pdirtyp, dflag, pb)
        !           362:        char *ppathname;                /* project root directory pathname */
        !           363:        char *alias;                    /* alternative project directory name */
        !           364:        int dflag;                      /* project directory description flag */
        !           365:        SLIST *pdirtyp;                 /* project directory type labels list */
        !           366:        PATH *pb;                       /* pathname struct buffer */
        !           367: {
        !           368:        char apathname[PATHSIZE];       /* absolute regular pathname */
        !           369:        char *mkalias();                /* construct alias from pathname */
        !           370:        char *mkptp();                  /* make path to parent project */
        !           371:        char *optpath();                /* optimize pathname */
        !           372:        char *pathcat();                /* pathname concatenation */
        !           373:        char *pbfndkey();               /* find database key */
        !           374:        char *rdp;                      /* relative project directory path */
        !           375:        char rpathname[PATHSIZE];       /* project root directory pathname */
        !           376:        char *strcpy();                 /* string copy */
        !           377:        char *xorpath();                /* remove subpathname */
        !           378:        int _closepdb();                /* close database without updating */
        !           379:        int closepdb();                 /* close database */
        !           380:        int errpdb();                   /* print database error message */
        !           381:        int mkpld();                    /* make project link directory */
        !           382:        int mkrootproject();            /* make root project root directory */
        !           383:        int pbaddflag();                /* add flag field */
        !           384:        int pbaddkey();                 /* add key */
        !           385:        int pbaddstring();              /* add string field */
        !           386:        int pgetent();                  /* load next entry into buffer */
        !           387:        int pputent();                  /* write buffer to database */
        !           388:        PDB *openpdb();                 /* open database */
        !           389:        PDB *pldp;                      /* project link directory stream */
        !           390:        void pbadddesc();               /* add project directory description */
        !           391:        void pbclear();                 /* clear buffer */
        !           392: 
        !           393:        switch (pb->p_mode & P_IFMT)
        !           394:                {
        !           395:                case P_IFNEW:
        !           396:                case P_IFREG:
        !           397:                        break;
        !           398:                case P_IFHOME:
        !           399:                        return(mkrootproject(ppathname, pdirtyp, dflag, pb));
        !           400:                case P_IFPDIR:
        !           401:                case P_IFPROOT:
        !           402:                        warn("%s exists", ppathname);
        !           403:                        return(1);
        !           404:                }
        !           405: 
        !           406:        /* create pathname relative to project root directory */
        !           407:        strcpy(rpathname, pb->p_project);
        !           408:        if (*pb->p_path == _RDIRC)
        !           409:                {
        !           410:                rdp = xorpath(rpathname, pb->p_path);
        !           411:                }
        !           412:        else    {
        !           413:                optpath(pathcat(apathname, CWD, pb->p_path));
        !           414:                rdp = xorpath(rpathname, apathname);
        !           415:                }
        !           416: 
        !           417:        /* open project link directory */
        !           418:        if ((pldp = openpdb(PLDNAME, rpathname, "rw")) == NULL)
        !           419:                return(errpdb((PDB *) NULL));
        !           420: 
        !           421:        /*
        !           422:         * check for existing aliases while preparing project link
        !           423:         * directory for new entry
        !           424:         */
        !           425:        if (alias == NULL)
        !           426:                if (EQUAL(pb->p_alias, CURDIR) || EQUAL(pb->p_alias, PARENTDIR))
        !           427:                        alias = mkalias(rdp);
        !           428:                else
        !           429:                        alias = pb->p_alias;
        !           430:        while (pgetent(pldp) != EOF)
        !           431:                {
        !           432:                if (pbfndkey(alias) != NULL)
        !           433:                        {
        !           434:                        warn("%s: %s exists", ppathname, alias);
        !           435:                        _closepdb(pldp);
        !           436:                        return(1);
        !           437:                        }
        !           438:                pputent(pldp);
        !           439:                }
        !           440: 
        !           441:        /* make the directory if non-existent */
        !           442:        if ((pb->p_mode & P_IFMT) == P_IFREG)
        !           443:                {
        !           444:                if ((pb->p_mode & S_IFMT) != S_IFDIR)
        !           445:                        {
        !           446:                        warn("%s: not a directory", ppathname);
        !           447:                        _closepdb(pldp);
        !           448:                        return(1);
        !           449:                        }
        !           450:                }
        !           451:        else if (MK_DIR(pb->p_path) != 0)
        !           452:                {
        !           453:                _closepdb(pldp);
        !           454:                return(1);
        !           455:                }
        !           456: 
        !           457:        /* update database */
        !           458:        pbclear();
        !           459:        pbaddkey(alias);
        !           460:        pbaddflag(PROOTDIR);
        !           461:        pbaddstring(PDIRPATH, rdp);
        !           462:        pputent(pldp);
        !           463:        if (mkpld(pb->p_path, ppathname, mkptp(rpathname, rdp), pdirtyp, dflag) != 0)
        !           464:                {
        !           465:                _closepdb(pldp);
        !           466:                return(1);
        !           467:                }
        !           468:        return(closepdb(pldp));
        !           469: }
        !           470: 
        !           471: 
        !           472: 
        !           473: /*
        !           474:  * mkptp() returns a pathname to the parent project root directory.
        !           475:  * It attempts to create a relative pathname if possible, otherwise
        !           476:  * the parent root directory pathname is used.
        !           477:  */
        !           478: char *
        !           479: mkptp(rpathname, rdp)
        !           480:        char *rpathname;                /* parent project root directory */
        !           481:        register char *rdp;             /* pathname to project being created */
        !           482: {
        !           483:        register char *rp;              /* parent project root directory ptr */
        !           484:        char *strpcpy();                /* string copy and update pointer */
        !           485: 
        !           486:        if (*rdp == _RDIRC)
        !           487:                return(rpathname);
        !           488:        for(rp = rpathname; *rdp != '\0'; rdp++)
        !           489:                if (*rdp == _PSC)
        !           490:                        rp = strpcpy(strpcpy(rp, PARENTDIR), PATHSEP);
        !           491:        rp = strpcpy(rp, PARENTDIR);
        !           492:        return(rpathname);
        !           493: }
        !           494: 
        !           495: 
        !           496: 
        !           497: /*
        !           498:  * mkrootproject creates a project link directory in the user's home
        !           499:  * directory. Returns zero if successful, otherwise 1.
        !           500:  */
        !           501: mkrootproject(ppathname, pdirtyp, dflag, pb)
        !           502:        char *ppathname;                /* project pathname */
        !           503:        SLIST *pdirtyp;                 /* project directory type labels list */
        !           504:        int dflag;                      /* project directory description flag */
        !           505:        PATH *pb;                       /* pathname struct buffer */
        !           506: {
        !           507:        char *pathcat();                /* pathname concatenation */
        !           508:        char pldpath[PATHSIZE];         /* project link directory pathname */
        !           509:        int mkpld();                    /* make a project link directory */
        !           510:        
        !           511:        if (FILEXIST(pathcat(pldpath, pb->p_path, PLDNAME)))
        !           512:                {
        !           513:                warn("%s exists", ppathname);
        !           514:                return(1);
        !           515:                }
        !           516:        return(mkpld(pb->p_path, ROOTPROJECT, CURDIR, pdirtyp, dflag));
        !           517: }
        !           518: 
        !           519: 
        !           520: 
        !           521: /*
        !           522:  * onintr() resets interrupt, quit, and hangup signals, and sets a flag
        !           523:  * which advises the process to exit at the first opportunity.
        !           524:  */
        !           525: onintr()
        !           526: {
        !           527:        signal(SIGINT, onintr);
        !           528:        signal(SIGQUIT, onintr);
        !           529:        signal(SIGHUP, onintr);
        !           530: 
        !           531:        WANT_TO_EXIT = 1;
        !           532: }
        !           533: 
        !           534: 
        !           535: 
        !           536: /*
        !           537:  * pbadddesc() fetchs a project directory description from stdin and
        !           538:  * adds to database buffer.
        !           539:  */
        !           540: void
        !           541: pbadddesc(ppathname)
        !           542:        char *ppathname;                /* project directory pathname */
        !           543: {
        !           544:        char dirdesc[DIRDESCSIZE];      /* project directory description */
        !           545:        char *gets();                   /* get a line from stdin */
        !           546:        int pbaddstring();              /* add string field */
        !           547: 
        !           548:        printf("%s: description? (1 line): ", ppathname);
        !           549:        gets(dirdesc);
        !           550:        pbaddstring(PDIRDESC, dirdesc);
        !           551: }
        !           552: 
        !           553: 
        !           554: 
        !           555: 
        !           556: /*
        !           557:  * pbaddtyp() adds type labels to database buffer.
        !           558:  */
        !           559: void
        !           560: pbaddtyp(ppathname, typlist)
        !           561:        char *ppathname;                /* project pathname */
        !           562:        SLIST *typlist;                 /* type labels list */
        !           563: {
        !           564:        char *pbgetstring();            /* get specified string field */
        !           565:        char *pdtfind();                /* find type label in buffer */
        !           566:        char *pfxcpy();                 /* copy string prefix */
        !           567:        char *slget();                  /* get next key from list */
        !           568:        char *tp;                       /* pointer to type label */
        !           569:        char type[TYPESIZE];            /* type label buffer */
        !           570:        char typbuf[TYPBUFSIZE];        /* project directory types buffer */
        !           571:        int pbaddstring();              /* add string field */
        !           572:        void pdtinsert();               /* insert type label */
        !           573:        void slrewind();                /* rewind list */
        !           574: 
        !           575:        pbgetstring(PDIRTYPE, typbuf);
        !           576:        slrewind(typlist);
        !           577:        while ((tp = slget(typlist)) != NULL)
        !           578:                {
        !           579:                if (pdtfind(pfxcpy(type, tp), typbuf) == NULL)
        !           580:                        pdtinsert(tp, typbuf);
        !           581:                else
        !           582:                        warn("%s: \"%s\" type label exists", ppathname, type);
        !           583:                }
        !           584:        pbaddstring(PDIRTYPE, typbuf);
        !           585: }
        !           586: 
        !           587: 
        !           588: 
        !           589: /*
        !           590:  * typargtolist() prepends comma-separated type labels specified in typarg
        !           591:  * to typlist. Returns NO if type labels are badly formatted, otherwise
        !           592:  * YES.
        !           593:  */
        !           594: typargtolist(typarg, typlist)
        !           595:        register char *typarg;          /* type labels argument */
        !           596:        SLIST *typlist;                 /* type labels list */
        !           597: {
        !           598:        register char *t;               /* type label argument pointer */
        !           599:        char *slprepend();              /* prepend singly-linked list key */
        !           600:        int ispdt();                    /* is project dir type label legal? */
        !           601:        int status = YES;               /* return status */
        !           602:        void badtyp();                  /* print bad type label message */
        !           603: 
        !           604:        for (t = typarg; *t != '\0'; t++)
        !           605:                continue;
        !           606:        for (; t >= typarg; t--)
        !           607:                if (t[0] == ',')
        !           608:                        {
        !           609:                        if (t[1] != '\0')
        !           610:                                if (ispdt(t+1))
        !           611:                                        slprepend(t+1, typlist);
        !           612:                                else    {
        !           613:                                        badtyp(t+1);
        !           614:                                        status = NO;
        !           615:                                        }
        !           616:                        t[0] = '\0';
        !           617:                        }
        !           618:        if (ispdt(typarg))
        !           619:                slprepend(typarg, typlist);
        !           620:        else    {
        !           621:                badtyp(typarg);
        !           622:                status = NO;
        !           623:                }
        !           624:        return(status);
        !           625: }

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