Return to eglit.c CVS log

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

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

1.1       root        1: #include       "re.h"
                      2: #include       "lre.h"
                      3: #include       "hdr.h"
                      4: 
                      5: static void traverse(Expr *);
                      6: 
                      7: #define        MAXLIT  256     /* is plenty big enough */
                      8: static unsigned char tmp[MAXLIT], best[MAXLIT];
                      9: static unsigned char *p;
                     10: static int bestlen;
                     11: #define        START   { p = tmp ; }
                     12: #define        ADD(c)  { if(p >= &tmp[MAXLIT]) p--; *p++ = c; }
                     13: #define        FINISH  { ADD(0) if((p-tmp) > bestlen) memmove((char *)best, (char *)tmp, bestlen = p-tmp); }
                     14: 
                     15: re_lit(re_re *r, unsigned char **b, unsigned char **e)
                     16: {
                     17:        bestlen = 0;
                     18:        START
                     19:        traverse(r->root);
                     20:        FINISH
                     21:        if(bestlen < 3)
                     22:                return(0);
                     23:        *b = best;
                     24:        *e = best+bestlen-1;
                     25:        return(1);
                     26: }
                     27: 
                     28: static void
                     29: traverse(register Expr *e)
                     30: {
                     31:        switch(e->type)
                     32:        {
                     33:        case Literal:
                     34:                ADD(e->lit)
                     35:                break;
                     36:        case Charclass:
                     37:                if((int)e->l == 1)
                     38:                        ADD(*(char *)e->r)
                     39:                else {
                     40:                        FINISH
                     41:                        START
                     42:                }
                     43:                break;
                     44:        case Cat:
                     45:                traverse(e->l);
                     46:                traverse(e->r);
                     47:                break;
                     48:        case Plus:
                     49:                traverse(e->l);
                     50:                FINISH  /* can't go on past a + */
                     51:                START   /* but we can start with one! */
                     52:                traverse(e->l);
                     53:                break;
                     54:        case EOP:
                     55:                FINISH
                     56:                START
                     57:                traverse(e->l);
                     58:                break;
                     59:        default:
                     60:                FINISH
                     61:                START
                     62:                break;
                     63:        }
                     64: }

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