Return to fns.c CVS log

Up to [Research Unix] / researchv10no / cmd / gre

Annotation of researchv10no/cmd/gre/fns.c, revision 1.1.1.1

1.1       root        1: #include       "re.h"
                      2: #include       "lre.h"
                      3: #include       "hdr.h"
                      4: 
                      5: void
                      6: pr(char *b, char *e)
                      7: {
                      8:        nmatch++;
                      9:        if(prname)
                     10:                PR "%s:", curfile);
                     11:        if(bflag){
                     12:                PR "%ld:", nbytes/offsetunit);
                     13:                nbytes += (e-b) + noverflow;
                     14:                noverflow = 0;
                     15:        }
                     16:        if(nflag)
                     17:                PR "%ld:", ++lnum);
                     18:        WR(b, e-b);
                     19: }
                     20: 
                     21: void
                     22: pr_m(char *b, char *e)
                     23: {
                     24:        register char *nl;
                     25: 
                     26:        while(nl = (char*)memchr(b, '\n', e-b)){
                     27:                nmatch++;
                     28:                nl++;
                     29:                if(prname)
                     30:                        PR "%s:", curfile);
                     31:                if(bflag){
                     32:                        PR "%ld:", nbytes/offsetunit);
                     33:                        nbytes += (nl-b) + noverflow;
                     34:                        noverflow = 0;
                     35:                }
                     36:                if(nflag)
                     37:                        PR "%ld:", ++lnum);
                     38:                WR(b, nl-b);
                     39:                if((b = nl) >= e)
                     40:                        break;
                     41:        }
                     42: }
                     43: 
                     44: /* ARGSUSED */
                     45: void
                     46: inc(char *UNUSED, char *UNUSED2)
                     47: {
                     48: #pragma ref UNUSED
                     49: #pragma ref UNUSED2
                     50:        nmatch++;
                     51: }
                     52: 
                     53: void
                     54: inc_m(register char *b, register char *e)
                     55: {
                     56:        register char *nl;
                     57: 
                     58:        while(nl = (char*)memchr(b, '\n', e-b)){
                     59:                nmatch++;
                     60:                if((b = nl+1) >= e)
                     61:                        break;
                     62:        }
                     63: }
                     64: 
                     65: void
                     66: null(char *UNUSED, char *UNUSED2)
                     67: #pragma ref UNUSED
                     68: #pragma ref UNUSED2
                     69: {
                     70: }
                     71: 
                     72: void
                     73: count(register char *b, register char *e)
                     74: {
                     75:        nbytes += (e-b) + noverflow;
                     76:        noverflow = 0;
                     77:        lnum++;
                     78: }
                     79: 
                     80: void
                     81: count_m(register char *b, register char *e)
                     82: {
                     83:        register char *nl;
                     84: 
                     85:        nbytes += (e-b) + noverflow;
                     86:        noverflow = 0;
                     87:        while(nl = (char*)memchr(b, '\n', e-b)){
                     88:                lnum++;
                     89:                if((b = nl+1) >= e)
                     90:                        break;
                     91:        }
                     92: }
                     93: 
                     94: void
                     95: oneshot(char *b, char *e)
                     96: {
                     97:        register char *nl;
                     98: 
                     99:        nmatch++;
                    100:        nl = (char*)memchr(b, '\n', e-b)+1;
                    101:        if(oneflag)
                    102:                pr(b, nl);
                    103:        longjmp(env, 1);
                    104: }

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