Return to flagger.c CVS log

Up to [CSRG BSD Unix] / 42BSD / usr.bin / refer

Annotation of 42BSD/usr.bin/refer/flagger.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char *sccsid = "@(#)flagger.c   4.1 (Berkeley) 5/6/83";
                      3: #endif
                      4: 
                      5: #include <stdio.h>
                      6: 
                      7: char wds[100][40];
                      8: int synwd[100];
                      9: int mark[100];
                     10: int justw = 0;
                     11: extern int comcount;
                     12: int blank[100];
                     13: int wdp, wdf;
                     14: int bl;
                     15: int sargc; 
                     16: char **sargv;
                     17: FILE *inf;
                     18: 
                     19: main(argc,argv)
                     20: char *argv[];
                     21: {
                     22:        int i;
                     23:        while (--argc && **++argv== '-')
                     24:                switch(argv[0][1])
                     25:                {
                     26:                case 'w': 
                     27:                        justw=1; 
                     28:                        break;
                     29:                case 'c': 
                     30:                        comcount=atoi(argv[0]+2); 
                     31:                        break;
                     32:                }
                     33:        wdp=wdf=0;
                     34:        if (argc>0)
                     35:        {
                     36:                argc--;
                     37:                inf = fopen(argv[0], "r");
                     38:                if (inf==NULL) exit(0);
                     39:                argv++;
                     40:        }
                     41:        else
                     42:                inf=stdin;
                     43:        sargc=argc;  
                     44:        sargv= argv;
                     45:        while ( gw (wds[wdp = next(wdp)], &bl))
                     46:        {
                     47:                blank[wdp] = bl;
                     48:                mark[wdp]=0;
                     49:                synwd[wdp] = common(upcase(wds[wdp]));
                     50:                if (common(sstrip(upcase(wds[wdp]))))
                     51:                        synwd[wdp]=1;
                     52:                if (allpunct(wds[wdp]))
                     53:                        synwd[wdp]=1;
                     54:                if (strlen(wds[wdp])<3)
                     55:                        synwd[wdp]=1;
                     56:                if (synwd[wdp]==1)
                     57:                {
                     58:                        for(i=wdp; i!=wdf; i=prev(i))
                     59:                        {
                     60:                                if (synwd[i]>0)
                     61:                                        continue;
                     62:                                mark[i]=1;
                     63:                                break;
                     64:                        }
                     65:                }
                     66:        }
                     67:        if (wdp<0) return(0);
                     68:        i=wdf -1;
                     69:        i = next(i);
                     70:        while (i != wdp)
                     71:                i= next(i);
                     72: }
                     73: 
                     74: next(i)
                     75: {
                     76:        int j;
                     77:        j = (i+1) % 100;
                     78:        if (j==wdf)
                     79:        {
                     80:                if (justw==0)
                     81:                {
                     82:                        if (mark[j] ) putchar('*');
                     83:                        printf("%s",wds[j]);
                     84:                        if (blank[j]) putchar(' ');
                     85:                }
                     86:                else
                     87:                        if (mark[j]) printf("%s\n", wds[j]);
                     88:                wdf = (wdf+1)%100;
                     89:        }
                     90:        return(j);
                     91: }
                     92: 
                     93: prev(i)
                     94: {
                     95:        i = (i-1)%100;
                     96:        return(i);
                     97: }
                     98: 
                     99: allpunct(s)
                    100: char *s;
                    101: {
                    102:        int c;
                    103:        while (c = *s++)
                    104:                if (isalpha(c))
                    105:                        return(0);
                    106:        return(1);
                    107: }
                    108: 
                    109: gw(s, b)
                    110: char *s;
                    111: int *b;
                    112: {
                    113:        int c, type, nt;
                    114:        c = getc(inf);
                    115:        while (c==EOF)
                    116:        {
                    117:                fclose(inf);
                    118:                inf=NULL;
                    119:                if (sargc-->0)
                    120:                {
                    121:                        inf = fopen ( *sargv++, "r");
                    122:                }
                    123:                if (inf==NULL) return(0);
                    124:                c = getc(inf);
                    125:        }
                    126:        *s++ = c;
                    127:        type = isalpha(c) || isdigit(c);
                    128:        while ( (c = getc(inf)) != EOF )
                    129:        {
                    130:                nt = isalpha(c) || isdigit(c);
                    131:                if (nt==type)
                    132:                        *s++= c;
                    133:                else
                    134:                        break;
                    135:        }
                    136:        *s=0;
                    137:        if (c== ' ')
                    138:        {
                    139:                *b = 1;
                    140:                return(1);
                    141:        }
                    142:        while (c==EOF)
                    143:        {
                    144:                fclose(inf); 
                    145:                inf=NULL;
                    146:                if (sargc-- > 0)
                    147:                {
                    148:                        inf= fopen( *sargv++, "r");
                    149:                }
                    150:                if (inf==NULL) return(0);
                    151:                c = getc(inf);
                    152:        }
                    153:        ungetc(c, inf);
                    154:        *b=0;
                    155:        return(1);
                    156: }
                    157: 
                    158: trimnl(s)
                    159: char *s;
                    160: {
                    161:        while (*s) s++;
                    162:        if (*--s=='\n') *s=0;
                    163: }
                    164: 
                    165: upcase(s)
                    166: char *s;
                    167: {
                    168:        static char buf[100];
                    169:        strcpy (buf, s);
                    170:        for(s=buf; *s; s++)
                    171:                if (isupper(*s))
                    172:                        *s = *s-'A'+'a';
                    173:        return(buf);
                    174: }
                    175: 
                    176: sstrip(s)
                    177: char *s;
                    178: {
                    179:        char *p ; 
                    180:        p=s;
                    181:        while (*s) s++;
                    182:        if (*--s=='s') *s=0;
                    183:        return(p);
                    184: }

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