Return to re.c CVS log

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

Annotation of researchv10dc/cmd/gre/re.c, revision 1.1.1.1

1.1       root        1: #include       "re.h"
                      2: #include       "lre.h"
                      3: #include       "hdr.h"
                      4: 
                      5: re_re *
                      6: re_recomp(char *b, char *e, unsigned char *map)
                      7: {
                      8:        return(egprep(greparse, (unsigned char *)b, (unsigned char *)e, map, 1));
                      9: }
                     10: 
                     11: re_reexec(re_re *pat, char *b, char *e, char *match[10][2])
                     12: {
                     13:        unsigned char *mb[10], *me[10], **rb, **re;
                     14:        int n, i;
                     15: 
                     16:        if(match)
                     17:                rb = mb, re = me;
                     18:        else
                     19:                rb = re = 0;
                     20:        n = eg_match(pat, (unsigned char *)b, (unsigned char *)e, rb, re);
                     21:        if(match)
                     22:                for(i = 0; i < 10; i++){
                     23:                        match[i][0] = (char *)mb[i];
                     24:                        match[i][1] = (char *)me[i];
                     25:                }
                     26:        return(n);
                     27: }
                     28: 
                     29: static void
                     30: freeexpr(register Expr *e)
                     31: {
                     32:        switch(e->type)
                     33:        {
                     34:        case Literal:
                     35:        case Dot:
                     36:        case Carat:
                     37:        case Dollar:
                     38:                if(e->follow)
                     39:                        free((char *)e->follow);
                     40:                break;
                     41:        case Compcharclass:
                     42:        case Charclass:
                     43:                free((char *)e->r);
                     44:                break;
                     45:        case Cat:
                     46:        case Alternate:
                     47:                freeexpr(e->l);
                     48:                freeexpr(e->r);
                     49:                break;
                     50:        case Star:
                     51:        case Plus:
                     52:        case Quest:
                     53:        case Group:
                     54:        case EOP:
                     55:                freeexpr(e->l);
                     56:                break;
                     57:        case Backref:
                     58:        default:
                     59:                break;
                     60:        }
                     61: }
                     62: 
                     63: void
                     64: re_refree(re_re *re)
                     65: {
                     66:        if(re == 0)
                     67:                return;
                     68:        if(re->posbase)
                     69:                free((char *)re->posbase);
                     70:        if(re->root)
                     71:                freeexpr(re->root);
                     72:        if(re->ptr)
                     73:                free((char *)re->ptr);
                     74:        if(re->states)
                     75:                free((char *)re->states);
                     76:        /* leave br alone for now; it is hard to get right */
                     77:        free((char *)re);
                     78: }

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