Return to efile.c CVS log

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

Annotation of researchv10no/cmd/gre/efile.c, revision 1.1

1.1     ! root        1: #include       "re.h"
        !             2: #include       <string.h>
        !             3: #include       <stdio.h>
        !             4: 
        !             5: etofile(e, fp)
        !             6:        Expr *e;
        !             7:        FILE *fp;
        !             8: {
        !             9:        Expr ee;
        !            10:        char res[256];
        !            11: 
        !            12:        if(e == 0){
        !            13:                e = &ee;
        !            14:                e->type = Null;
        !            15:        }
        !            16:        putw(e->type, fp);
        !            17:        putw(e->lit, fp);
        !            18:        switch(e->type)
        !            19:        {
        !            20:        case Null:
        !            21:        case Literal:
        !            22:        case Dot:
        !            23:        case Carat:
        !            24:        case Dollar:
        !            25:        case Backref:
        !            26:                break;
        !            27:        case Compcharclass:
        !            28:        case Charclass:
        !            29:                putw((int)e->l, fp);
        !            30:                fwrite((char *)e->r, (int)e->l, 1, fp);
        !            31:                break;
        !            32:        case Cat:
        !            33:        case Alternate:
        !            34:                etofile(e->l, fp);
        !            35:                etofile(e->r, fp);
        !            36:                break;
        !            37:        case Star:
        !            38:        case Plus:
        !            39:        case Quest:
        !            40:        case Group:
        !            41:        case EOP:
        !            42:                etofile(e->l, fp);
        !            43:                break;
        !            44:        }
        !            45: }
        !            46: 
        !            47: Expr *
        !            48: filetoe(fp)
        !            49:        FILE *fp;
        !            50: {
        !            51:        Expr *ee, *er, *el;
        !            52:        int t, l;
        !            53:        char res[256];
        !            54: 
        !            55:        t = getw(fp);
        !            56:        if((t == EOF) && feof(fp))
        !            57:                return(0);
        !            58:        l = getw(fp);
        !            59:        switch(t)
        !            60:        {
        !            61:        case Null:
        !            62:                return(0);
        !            63:        case Literal:
        !            64:        case Dot:
        !            65:        case Carat:
        !            66:        case Dollar:
        !            67:        case Backref:
        !            68:                return(eg_newexpr(t, l, (Expr *)0, (Expr *)0));
        !            69:        case Compcharclass:
        !            70:        case Charclass:
        !            71:                ee = eg_newexpr(t, l, (Expr *)0, (Expr *)0);
        !            72:                l = getw(fp);
        !            73:                ee->r = (Expr *)egmalloc(l, "filetoe copy");
        !            74:                ee->l = (Expr *)l;
        !            75:                fread((char *)ee->r, l, 1, fp);
        !            76:                return(ee);
        !            77:        case Cat:
        !            78:        case Alternate:
        !            79:                el = filetoe(fp);
        !            80:                er = filetoe(fp);
        !            81:                return(eg_newexpr(t, l, el, er));
        !            82:        case Star:
        !            83:        case Plus:
        !            84:        case Quest:
        !            85:        case Group:
        !            86:        case EOP:
        !            87:                el = filetoe(fp);
        !            88:                return(eg_newexpr(t, l, el, (Expr *)0));
        !            89:        default:
        !            90:                SPR res, "<reading expr undef type %d lit=%d>", t, l);
        !            91:                re_error(res);
        !            92:                return((Expr *)0);
        !            93:        }
        !            94: }
        !            95: 
        !            96: #ifdef MAIN
        !            97: #include       <tmpnam.h>
        !            98: 
        !            99: main(argc, argv)
        !           100:        char **argv;
        !           101: {
        !           102:        Expr *re;
        !           103:        re_re *r;
        !           104:        char *pat;
        !           105:        FILE *tmp;
        !           106:        char *tmpn;
        !           107:        extern char *tmpnam();
        !           108:        char e1[4096], e2[4096];
        !           109:        unsigned char map[256];
        !           110:        int n;
        !           111: 
        !           112:        if(argc != 2){
        !           113:                fprintf(stderr, "Usage: efile pattern\n");
        !           114:                exit(1);
        !           115:        }
        !           116:        pat = argv[1];
        !           117:        for(n = 0; n < 256; n++)
        !           118:                map[n] = n;
        !           119:        r = re_recomp(pat, pat+strlen(pat), map);
        !           120:        if(r == 0)
        !           121:                exit(1);
        !           122:        re = r->root;
        !           123:        tmpn = tmpnam((char *)0);
        !           124:        if((tmp = fopen(tmpn, "w+r")) == NULL){
        !           125:                perror(tmpn);
        !           126:                exit(1);
        !           127:        }
        !           128:        eg_epr(re, e1, 0);
        !           129:        etofile(re, tmp);
        !           130:        rewind(tmp);
        !           131:        re = filetoe(tmp);
        !           132:        eg_epr(re, e2, 0);
        !           133:        if(strcmp(e1, e2))
        !           134:                printf("MISMATCH!!\nbefore:\n%s\nafter:\n%s\n", e1, e2);
        !           135:        else
        !           136:                printf("ok\n");
        !           137:        re_refree(r);
        !           138:        exit(0);
        !           139: }
        !           140: #endif

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