Return to parsit.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / nntp / server

Annotation of 43BSDTahoe/new/nntp/server/parsit.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *osccsid = "@(#)parsit.c   1.1     (Berkeley) 12/5/84";
        !             3: static char *sccsid = "@(#)parsit.c    1.2     (Berkeley) 10/15/87";
        !             4: #endif
        !             5: 
        !             6: /*
        !             7:  * Parse a string of words separated by spaces into an
        !             8:  * array of pointers to characters, just like good ol' argv[]
        !             9:  * and argc.
        !            10:  *
        !            11:  * Usage:
        !            12:  *
        !            13:  * char line[132];
        !            14:  * char **argv;
        !            15:  * int argc;
        !            16:  *
        !            17:  *     argv = (char **) NULL;
        !            18:  *     argc = parsit(line, &argv);
        !            19:  *
        !            20:  * returns the number of words parsed in argc.  argv[argc] will
        !            21:  * be (char *) NULL to indicate end of list, if you're not
        !            22:  * happy with just knowing how many words you have.
        !            23:  *
        !            24:  * Note that setting argv = (char **) NULL is only done the first
        !            25:  * time the routine is called with a new "argv" -- it tells
        !            26:  * parsit that "argv" is a new array, and parsit shouldn't free
        !            27:  * up the elements (as it would do if it were an old array).
        !            28:  *
        !            29:  *     Phil Lapsley
        !            30:  *     College of Engineering
        !            31:  *     University of California, Berkeley
        !            32:  *     (ARPA: [email protected]; UUCP: ...!ucbvax!phil)
        !            33:  */
        !            34: 
        !            35: #include <stdio.h>
        !            36: 
        !            37: extern char    *malloc(), *strcpy();
        !            38: 
        !            39: parsit(line, array)
        !            40: char *line;
        !            41: char ***array;
        !            42: {
        !            43:        char    **argv;
        !            44:        char    word[132];
        !            45:        char    *linecp;
        !            46:        int     i, j, num_words;
        !            47: 
        !            48:        argv = *array;
        !            49:        if (argv != (char **) NULL) {  /* Check to see if we should */
        !            50:                for (i = 0; argv[i] != (char *) NULL; i++)      /* free */
        !            51:                        free(argv[i]);  /* the old array */
        !            52:                free((char *) argv);    /* and then free the ptr itself */
        !            53:        }
        !            54: 
        !            55:        linecp = line;
        !            56:        num_words = 0;
        !            57:        while (1) {     /* count words in input */
        !            58:                for (; *linecp == ' ' || *linecp == '\t'; ++linecp)
        !            59:                        ;
        !            60:                if (*linecp == '\0')
        !            61:                        break;
        !            62: 
        !            63:                for (; *linecp != ' ' && *linecp != '\t' && *linecp != '\0'; ++linecp)
        !            64:                        ;
        !            65:                ++num_words;
        !            66:                if (*linecp == '\0')
        !            67:                        break;
        !            68:        }
        !            69: 
        !            70:        /* Then malloc enough for that many words plus 1 (for null) */
        !            71: 
        !            72:        if ((argv = (char **) malloc((num_words + 1) * sizeof(char *))) ==
        !            73:                (char **) NULL) {
        !            74:                fprintf(stderr, "parsit: malloc out of space!\n");
        !            75:                return(0);
        !            76:        }
        !            77: 
        !            78:        j = i = 0;
        !            79:        while (1) {     /* Now build the list of words */
        !            80:                for (; *line == ' ' || *line == '\t'; ++line)
        !            81:                        ;
        !            82:                if (*line == '\0')
        !            83:                        break;
        !            84: 
        !            85:                i = 0;
        !            86:                for (; *line != ' ' && *line != '\t' && *line != '\0'; ++line)
        !            87:                        word[i++] =  *line;
        !            88:                word[i] = '\0';
        !            89:                argv[j] = malloc(strlen(word) + 1);
        !            90:                if (argv[j] == (char *) NULL) {
        !            91:                        fprintf(stderr, "parsit: malloc out of space!\n");
        !            92:                        return(0);
        !            93:                }
        !            94: 
        !            95:                (void) strcpy(argv[j], word);
        !            96:                ++j;
        !            97:                if (*line == '\0')
        !            98:                        break;
        !            99:        }
        !           100:        argv[j] = (char *) NULL;  /* remember null at end of list */
        !           101:        *array = argv;
        !           102:        return(j);
        !           103: }

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