Return to egcanon.c CVS log

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

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

1.1       root        1: #include       "re.h"
                      2: #include       "lre.h"
                      3: #include       "hdr.h"
                      4: 
                      5: #define        DEBUG
                      6: 
                      7: static Expr **proot;
                      8: 
                      9: #define        PURE(e)         (!(e)->backref && !(e)->parens)
                     10: #define        PROC(kid)       if(ee = proc(kid)){ ee->parent = (kid)->parent; free((char *)kid); kid = ee; }
                     11: 
                     12: static Expr *
                     13: proc(Expr *e)
                     14: {
                     15:        Expr *ee;
                     16: 
                     17:        if(e->type == Cat){
                     18:                if(PURE(e->l)){
                     19:                        if(proot){
                     20:                                *proot = eg_newexpr(Cat, 0, *proot, e->l);
                     21:                                return((ee = proc(e->r))? ee:e->r);
                     22:                        } else
                     23:                                proot = &e->l;
                     24:                } else {
                     25:                        PROC(e->l)
                     26:                }
                     27:                if(PURE(e->r)){
                     28:                        if(proot){
                     29:                                *proot = eg_newexpr(Cat, 0, *proot, e->r);
                     30:                                return(e->l);
                     31:                        } else
                     32:                                proot = &e->r;
                     33:                } else {
                     34:                        PROC(e->r)
                     35:                }
                     36:                return(0);
                     37:        }
                     38:        proot = 0;
                     39:        switch(e->type)
                     40:        {
                     41:        case Alternate:
                     42:                PROC(e->l)
                     43:                proot = 0;
                     44:                PROC(e->r)
                     45:                break;
                     46:        case Star:
                     47:        case Plus:
                     48:        case Quest:
                     49:        case EOP:
                     50:        case Group:
                     51:                PROC(e->l)
                     52:                break;
                     53:        }
                     54:        proot = 0;
                     55:        return(0);
                     56: }
                     57: 
                     58: void
                     59: egcanon(Expr *e)
                     60: {
                     61: #ifdef DEBUG
                     62:        char before[EPRINTSIZE], after[EPRINTSIZE];
                     63: #endif
                     64: 
                     65: #ifdef DEBUG
                     66:        eg_epr(e, before, 0);
                     67:        if(TRACE(3)){
                     68:                PR "egcanon(%s):\n", before);
                     69:        }
                     70: #endif
                     71:        proot = 0;
                     72:        if(!PURE(e))
                     73:                proc(e);
                     74: #ifdef DEBUG
                     75:        eg_epr(e, after, 0);
                     76:        if(TRACE(3)){
                     77:                PR "egcanon returns %s\n", after);
                     78:        }
                     79:        if(strcmp(before, after)){
                     80:                EPR "URK! egcanon did not preserve!\nbefore=%s\n after=%s\n", before, after);
                     81:                exit(1);
                     82:        }
                     83: #endif
                     84: }

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