Return to head.c CVS log

Up to [Research Unix] / researchv10no / lbin / mailx

Annotation of researchv10no/lbin/mailx/head.c, revision 1.1.1.1

1.1       root        1: #ident "@(#)head.c     1.3 'attmail mail(1) command'"
                      2: #ident "@(#)mailx:head.c       1.3.1.1"
                      3: /*     Copyright (c) 1984 AT&T */
                      4: /*       All Rights Reserved   */
                      5: 
                      6: /*     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T     */
                      7: /*     The copyright notice above does not evidence any        */
                      8: /*     actual or intended publication of such source code.     */
                      9: 
                     10: #ident "@(#)mailx:head.c       1.3"
                     11: 
                     12: #include "rcv.h"
                     13: 
                     14: /*
                     15:  * mailx -- a modified version of a University of California at Berkeley
                     16:  *     mail program
                     17:  *
                     18:  * Routines for processing and detecting headlines.
                     19:  */
                     20: 
                     21: static char    *copyin();
                     22: static int     isname();
                     23: static char    *nextword();
                     24: 
                     25: /*
                     26:  * Split a headline into its useful components.
                     27:  * Copy the line into dynamic string space, then set
                     28:  * pointers into the copied line in the passed headline
                     29:  * structure.  Actually, it scans.
                     30:  */
                     31: void
                     32: parse(line, hl, pbuf)
                     33:        char line[], pbuf[];
                     34:        struct headline *hl;
                     35: {
                     36:        register char *cp, *dp;
                     37:        char *sp;
                     38:        char word[LINESIZE];
                     39: 
                     40:        hl->l_from = NOSTR;
                     41:        hl->l_tty = NOSTR;
                     42:        hl->l_date = NOSTR;
                     43:        cp = line;
                     44:        sp = pbuf;
                     45: 
                     46:        /*
                     47:         * Skip the first "word" of the line, which should be "From"
                     48:         * anyway.
                     49:         */
                     50: 
                     51:        cp = nextword(cp, word);
                     52:        dp = nextword(cp, word);
                     53:        if (dp == NOSTR) return;
                     54:        if (!equal(word, ""))
                     55:                hl->l_from = copyin(word, &sp);
                     56:        if (isname(dp, "tty", 3)) {
                     57:                cp = nextword(dp, word);
                     58:                hl->l_tty = copyin(word, &sp);
                     59:                if (cp != NOSTR)
                     60:                        hl->l_date = copyin(cp, &sp);
                     61:        }
                     62:        else
                     63:                if (dp != NOSTR)
                     64:                        hl->l_date = copyin(dp, &sp);
                     65: }
                     66: 
                     67: /*
                     68:  * Copy the string on the left into the string on the right
                     69:  * and bump the right (reference) string pointer by the length.
                     70:  * Thus, dynamically allocate space in the right string, copying
                     71:  * the left string into it.
                     72:  */
                     73: 
                     74: static char *
                     75: copyin(src, space)
                     76:        char src[];
                     77:        char **space;
                     78: {
                     79:        register char *cp, *top;
                     80:        register int s;
                     81: 
                     82:        s = strlen(src);
                     83:        cp = *space;
                     84:        top = cp;
                     85:        strcpy(cp, src);
                     86:        cp += s + 1;
                     87:        *space = cp;
                     88:        return(top);
                     89: }
                     90: 
                     91: static
                     92: isname(as1, as2, acount)
                     93:        char *as1, *as2;
                     94: {
                     95:        register char *s1, *s2;
                     96:        register count;
                     97: 
                     98:        s1 = as1;
                     99:        s2 = as2;
                    100:        count = acount;
                    101:        if (count > 0)
                    102:                do
                    103:                        if (*s1++ != *s2++)
                    104:                                return(0);
                    105:                while (--count);
                    106:        return(1);
                    107: }
                    108: 
                    109: /*
                    110:  * Collect a liberal (space, tab delimited) word into the word buffer
                    111:  * passed.  Also, return a pointer to the next word following that,
                    112:  * or NOSTR if none follow.
                    113:  */
                    114: 
                    115: static char *
                    116: nextword(wp, wbuf)
                    117:        char wp[], wbuf[];
                    118: {
                    119:        register char *cp, *cp2;
                    120: 
                    121:        if ((cp = wp) == NOSTR) {
                    122:                copy("", wbuf);
                    123:                return(NOSTR);
                    124:        }
                    125:        cp2 = wbuf;
                    126:        while (!any(*cp, " \t") && *cp != '\0')
                    127:                if (*cp == '"') {
                    128:                        *cp2++ = *cp++;
                    129:                        while (*cp != '\0' && *cp != '"')
                    130:                                *cp2++ = *cp++;
                    131:                        if (*cp == '"')
                    132:                                *cp2++ = *cp++;
                    133:                } else
                    134:                        *cp2++ = *cp++;
                    135:        *cp2 = '\0';
                    136:        while (any(*cp, " \t"))
                    137:                cp++;
                    138:        if (*cp == '\0')
                    139:                return(NOSTR);
                    140:        return(cp);
                    141: }
                    142: 
                    143: /*
                    144:  * Copy str1 to str2, return pointer to null in str2.
                    145:  */
                    146: 
                    147: char *
                    148: copy(str1, str2)
                    149:        char *str1, *str2;
                    150: {
                    151:        register char *s1, *s2;
                    152: 
                    153:        s1 = str1;
                    154:        s2 = str2;
                    155:        while (*s1)
                    156:                *s2++ = *s1++;
                    157:        *s2 = 0;
                    158:        return(s2);
                    159: }
                    160: 
                    161: /*
                    162:  * Is ch any of the characters in str?
                    163:  */
                    164: 
                    165: any(ch, str)
                    166:        char *str;
                    167: {
                    168:        register char *f;
                    169:        register c;
                    170: 
                    171:        f = str;
                    172:        c = ch;
                    173:        while (*f)
                    174:                if (c == *f++)
                    175:                        return(1);
                    176:        return(0);
                    177: }

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