Return to dogre.c CVS log

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

Annotation of researchv10dc/cmd/gre/dogre.c, revision 1.1

1.1     ! root        1: #include       <ctype.h>
        !             2: #include       "re.h"
        !             3: #include       "lre.h"
        !             4: #include       "hdr.h"
        !             5: 
        !             6: static void gresucc(char*, char*);     /* does reg exp match after bm */
        !             7: static int reader(void*, RDFN, MATCHFN);/* plain analog of bmfind, cwfind */
        !             8: static void readin(char*, char*, unsigned char**, unsigned char**);
        !             9: 
        !            10: void
        !            11: dogre(Parsetype parser, char *input, char *finput, unsigned char *map, PROCFN *pprocfn, void **pat, RDFN *prdfn, MATCHFN *pmatchfn)
        !            12: {
        !            13:        unsigned char *lb, *le;
        !            14: 
        !            15:        readin(input, finput, &lb, &le);
        !            16:        *pat = 0;
        !            17:        globre = egprep(parser, lb, le, map, 1);
        !            18:        *prdfn = greprd;
        !            19:        *pmatchfn = grepmatch;
        !            20:        if(sflag || lflag || Lflag || oneflag){
        !            21:                if(vflag == 0)
        !            22:                        succ2fn = oneshot, failfn = count_m;
        !            23:                else
        !            24:                        succ2fn = count, failfn = oneshot;
        !            25:        } else if(cflag){
        !            26:                if(vflag == 0)
        !            27:                        succ2fn = inc, failfn = null;
        !            28:                else
        !            29:                        succ2fn = null, failfn = inc_m;
        !            30:        } else if(vflag){
        !            31:                if(bflag||nflag)
        !            32:                        succ2fn = count;
        !            33:                else
        !            34:                        succ2fn = null;
        !            35:                failfn = pr_m;
        !            36:        } else {
        !            37:                succ2fn = pr;
        !            38:                if(bflag||nflag)
        !            39:                        failfn = count_m;
        !            40:                else
        !            41:                        failfn = null;
        !            42:        }
        !            43:        if(re_lit(globre, &lb, &le)){
        !            44:                *pat = (void *)re_bmcomp((char *)lb, (char *)le, map);
        !            45:                *pprocfn = re_bmexec;
        !            46:                succfn = gresucc;
        !            47:        } else {
        !            48:                if(*pat = (void *)re_recw(globre, map))
        !            49:                        *pprocfn = re_cwexec;
        !            50:                else
        !            51:                        *pprocfn = reader;
        !            52:                succfn = succ2fn;
        !            53:        }
        !            54: }
        !            55: 
        !            56: static
        !            57: reader(void *UNUSED, RDFN rdfn, MATCHFN matchfn)
        !            58: {
        !            59:        unsigned char *b, *e;
        !            60:        unsigned char *nl;
        !            61:        int k;
        !            62: #pragma ref UNUSED
        !            63: 
        !            64:        b = 0;
        !            65:        while((k = (*rdfn)((char**)&b, (char**)&e)) > 0){
        !            66:                while(nl = (unsigned char *)memchr((char *)b, '\n', e-b)){
        !            67:                        if(eg_match(globre, b, nl, (unsigned char **)0, (unsigned char **)0)){
        !            68:                                e = nl;
        !            69:                                if((k = (*matchfn)((char**)&b, (char**)&e)) <= 0)
        !            70:                                        return(k);
        !            71:                        } else
        !            72:                                b = nl+1;
        !            73:                }
        !            74:        }
        !            75:        return(k);
        !            76: }
        !            77: 
        !            78: static void
        !            79: readin(char *in, char *fin, unsigned char **beg, unsigned char **end)
        !            80: {
        !            81:        int size, n, fd, left;
        !            82:        char *base, *p;
        !            83: 
        !            84:        if(in){
        !            85:                if(xflag){
        !            86:                        size = 4+strlen(in)+1;
        !            87:                        *beg = (unsigned char *)malloc(size);
        !            88:                        if (!*beg){
        !            89:                                EPR "%s: can't malloc %d bytes for -x\n", progname, size);
        !            90:                                exit(2);
        !            91:                        }
        !            92:                        p = (char *)*beg;
        !            93:                        *p++ = '^';
        !            94:                        *p++ = '(';
        !            95:                        memmove(p, in, n = strlen(in));
        !            96:                        p += n;
        !            97:                        *p++ = ')';
        !            98:                        *p++ = '$';
        !            99:                        *end = (unsigned char *)p;
        !           100:                } else {
        !           101:                        *beg = (unsigned char *)in;
        !           102:                        *end = *beg + strlen(in);
        !           103:                }
        !           104:                return;
        !           105:        }
        !           106:        /* we know fin is nonzero */
        !           107:        if((fd = open(fin, 0)) < 0){
        !           108:                perror(fin);
        !           109:                exit(2);
        !           110:        }
        !           111:        /*
        !           112:                i object to calling stat; the following crap is not painful
        !           113:                and at worst involves copying twice the number of bytes.
        !           114:        */
        !           115:        size = 128;
        !           116:        if((base = malloc(size)) == 0){
        !           117:                EPR "%s: can't malloc %d bytes for -f %s\n", progname, size, fin);
        !           118:                exit(2);
        !           119:        }
        !           120:        left = size;
        !           121:        p = base;
        !           122:        if(xflag){
        !           123:                *p++ = '^';
        !           124:                left--;
        !           125:        }
        !           126:        for(; (n = read(fd, p, left)) > 0;){
        !           127:                p += n;
        !           128:                left -= n;
        !           129:                if(left == 0){
        !           130:                        size *= 2;
        !           131:                        if((base = realloc(base, size+2)) == 0){
        !           132:                                EPR "%s: can't malloc %d bytes for -f %s\n", progname, size, fin);
        !           133:                                exit(2);
        !           134:                        }
        !           135:                        p = base+size/2;
        !           136:                        left = size/2;
        !           137:                }
        !           138:        }
        !           139:        if(n < 0){
        !           140:                perror(fin);
        !           141:                exit(2);
        !           142:        }
        !           143:        close(fd);
        !           144:        if(xflag){
        !           145:                *p++ = '$';
        !           146:        }
        !           147:        *beg = (unsigned char *)base;
        !           148:        *end = (unsigned char *)p;
        !           149: }
        !           150: 
        !           151: static void
        !           152: gresucc(char *b, char *e)
        !           153: {
        !           154:        if(eg_match(globre, (unsigned char*)b, (unsigned char*)(e-1), (unsigned char **)0, (unsigned char **)0))
        !           155:                (*succ2fn)(b, e);
        !           156:        else
        !           157:                (*failfn)(b, e);
        !           158: }

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