Return to parsit.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / nntp / server

Annotation of 43BSD/contrib/nntp/server/parsit.c, revision 1.1.1.1

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

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