Return to envargs.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / unzip

Annotation of coherent/b/bin/unzip/envargs.c, revision 1.1

1.1     ! root        1: /*****************************************************************
        !             2:  | envargs - add default options from environment to command line
        !             3:  |----------------------------------------------------------------
        !             4:  | Author: Bill Davidsen, original 10/13/91, revised 23 Oct 1991.
        !             5:  | This program is in the public domain.
        !             6:  |----------------------------------------------------------------
        !             7:  | Minor program notes:
        !             8:  |  1. Yes, the indirection is a tad complex
        !             9:  |  2. Parenthesis were added where not needed in some cases
        !            10:  |     to make the action of the code less obscure.
        !            11:  |  3. Set tabsize to four to make this pretty
        !            12:  |----------------------------------------------------------------
        !            13:  | UnZip notes 24 May 92 ("v1.4"):
        !            14:  |  1. #include "unzip.h" for prototypes
        !            15:  |  2. changed ch to type char
        !            16:  |  3. added an ifdef to avoid Borland warnings
        !            17:  *****************************************************************/
        !            18: 
        !            19: #include "unzip.h"
        !            20: static int count_args __((char *));
        !            21: static void mem_err __((void));
        !            22: 
        !            23: #if (defined(SCCS) && !defined(lint))  /* causes warnings:  annoying */
        !            24: static char *SCCSid = "@(#)envargs.c   1.3 23 Oct 1991";
        !            25: #endif
        !            26: 
        !            27: void
        !            28: envargs(Pargc, Pargv, envstr)
        !            29: int *Pargc;
        !            30: char ***Pargv;
        !            31: char *envstr;
        !            32: {
        !            33:        char *getenv();
        !            34:        char *envptr;                           /* value returned by getenv */
        !            35:        char *bufptr;                           /* copy of env info */
        !            36:        int argc = 0;                           /* internal arg count */
        !            37:        char ch;                                        /* spare temp value */
        !            38:        char **argv;                            /* internal arg vector */
        !            39:        char **argvect;                         /* copy of vector address */
        !            40: 
        !            41:        /* see if anything in the environment */
        !            42:        envptr = getenv(envstr);
        !            43:        if (envptr == (char *)NULL || *envptr == 0) return;
        !            44: 
        !            45:        /* count the args so we can allocate room for them */
        !            46:        argc = count_args(envptr);
        !            47:        bufptr = (char *)malloc(1+strlen(envptr));
        !            48:        if (bufptr == (char *)NULL) mem_err();
        !            49:        strcpy(bufptr, envptr);
        !            50: 
        !            51:        /* allocate a vector large enough for all args */
        !            52:        argv = (char **)malloc((argc+*Pargc+1)*sizeof(char *));
        !            53:        if (argv == (char **)NULL) mem_err();
        !            54:        argvect = argv;
        !            55: 
        !            56:        /* copy the program name first, that's always true */
        !            57:        *(argv++) = *((*Pargv)++);
        !            58: 
        !            59:        /* copy the environment args next, may be changed */
        !            60:        do {
        !            61:                *(argv++) = bufptr;
        !            62:                /* skip the arg and any trailing blanks */
        !            63:                while (((ch = *bufptr) != '\0') && ch != ' ') ++bufptr;
        !            64:                if (ch == ' ') *(bufptr++) = '\0';
        !            65:                while (((ch = *bufptr) != '\0') && ch == ' ') ++bufptr;
        !            66:        } while (ch);
        !            67: 
        !            68:        /* now save old argc and copy in the old args */
        !            69:        argc += *Pargc;
        !            70:        while (--(*Pargc)) *(argv++) = *((*Pargv)++);
        !            71: 
        !            72:        /* finally, add a NULL after the last arg, like UNIX */
        !            73:        *argv = (char *)NULL;
        !            74: 
        !            75:        /* save the values and return */
        !            76:        *Pargv = argvect;
        !            77:        *Pargc = argc;
        !            78: }
        !            79: 
        !            80: static int
        !            81: count_args(s)
        !            82: char *s;
        !            83: {
        !            84:        int count = 0;
        !            85:        char ch;
        !            86: 
        !            87:        do {
        !            88:                /* count and skip args */
        !            89:                ++count;
        !            90:                while (((ch = *s) != '\0') && ch != ' ') ++s;
        !            91:                while (((ch = *s) != '\0') && ch == ' ') ++s;
        !            92:        } while (ch);
        !            93: 
        !            94:        return count;
        !            95: }
        !            96: 
        !            97: static void
        !            98: mem_err()
        !            99: {
        !           100:        perror("Can't get memory for arguments");
        !           101:        exit(2);
        !           102: }
        !           103: 
        !           104: #ifdef TEST
        !           105: main(argc, argv)
        !           106: int argc;
        !           107: char **argv;
        !           108: {
        !           109:        int i;
        !           110: 
        !           111:        printf("Orig argv: %p\n", argv);
        !           112:        dump_args(argc, argv);
        !           113:        envargs(&argc, &argv, "ENVTEST");
        !           114:        printf(" New argv: %p\n", argv);
        !           115:        dump_args(argc, argv);
        !           116: }
        !           117: 
        !           118: dump_args(argc, argv)
        !           119: int argc;
        !           120: char *argv[];
        !           121: {
        !           122:        int i;
        !           123: 
        !           124:        printf("\nDump %d args:\n", argc);
        !           125:        for (i=0; i<argc; ++i) {
        !           126:                printf("%3d %s\n", i, argv[i]);
        !           127:        }
        !           128: }
        !           129: #endif

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