Return to refile.c CVS log

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

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

1.1     ! root        1: #include       <string.h>
        !             2: #include       <stdio.h>
        !             3: #if defined(__STDC__) || defined(c_plusplus) || defined(__cplusplus)
        !             4: #include       <stdlib.h>
        !             5: #endif
        !             6: #include       "re.h"
        !             7: 
        !             8: #ifdef MAIN
        !             9: 
        !            10: main(argc, argv)
        !            11:        char **argv;
        !            12: {
        !            13:        Expr *re;
        !            14:        re_re *r;
        !            15:        char *pat;
        !            16:        FILE *tmp;
        !            17:        char *tmpn;
        !            18:        extern char *tmpnam();
        !            19:        char e1[4096], e2[4096];
        !            20:        unsigned char map[256];
        !            21:        int n;
        !            22: 
        !            23:        if(argc != 2){
        !            24:                fprintf(stderr, "Usage: efile pattern\n");
        !            25:                exit(1);
        !            26:        }
        !            27:        pat = argv[1];
        !            28:        for(n = 0; n < 256; n++)
        !            29:                map[n] = n;
        !            30:        r = re_recomp(pat, pat+strlen(pat), map);
        !            31:        if(r == 0)
        !            32:                exit(1);
        !            33:        re = r->root;
        !            34:        tmpn = tmpnam((char *)0);
        !            35:        if((tmp = fopen(tmpn, "w+r")) == NULL){
        !            36:                perror(tmpn);
        !            37:                exit(1);
        !            38:        }
        !            39:        eg_epr(re, e1, 0);
        !            40:        re_refile(r, tmp);
        !            41:        rewind(tmp);
        !            42:        r = re_filere(tmp);
        !            43:        eg_epr(r->root, e2, 0);
        !            44:        if(strcmp(e1, e2))
        !            45:                printf("MISMATCH!!\nbefore:\n%s\nafter:\n%s\n", e1, e2);
        !            46:        else
        !            47:                printf("ok\n");
        !            48:        re_refree(r);
        !            49:        exit(0);
        !            50: }
        !            51: #else
        !            52: 
        !            53: #include       "lre.h"
        !            54: 
        !            55: #if defined(__STDC__) || defined(c_plusplus) || defined(__cplusplus)
        !            56: static void etofile(Expr *, FILE *);
        !            57: static Expr *filetoe(FILE *);
        !            58: #else
        !            59: static void etofile();
        !            60: static Expr *filetoe();
        !            61: #endif
        !            62: 
        !            63: #define                REVERSION               2
        !            64: 
        !            65: void
        !            66: re_refile(re_re *re, FILE *fp)
        !            67: {
        !            68:        if(re == 0)
        !            69:                return;
        !            70:        if(putc(REVERSION, fp) != REVERSION){
        !            71:                re_error("couldn't write version");
        !            72:                return;
        !            73:        }
        !            74:        if(fwrite(re->mymap, 256, 1, fp) != 1){
        !            75:                re_error("couldn't write char map");
        !            76:                return;
        !            77:        }
        !            78:        putw(re->carat, fp);
        !            79:        etofile(re->root, fp);
        !            80: }
        !            81: 
        !            82: static void
        !            83: etofile(Expr *e, FILE *fp)
        !            84: {
        !            85:        Expr ee;
        !            86: 
        !            87:        if(e == 0){
        !            88:                e = &ee;
        !            89:                e->type = Null;
        !            90:        }
        !            91:        putw(e->type, fp);
        !            92:        putw(e->lit, fp);
        !            93:        putc(e->backref, fp);
        !            94:        putc(e->parens, fp);
        !            95:        switch(e->type)
        !            96:        {
        !            97:        case Null:
        !            98:        case Literal:
        !            99:        case Dot:
        !           100:        case Carat:
        !           101:        case Dollar:
        !           102:        case Backref:
        !           103:                break;
        !           104:        case Compcharclass:
        !           105:        case Charclass:
        !           106:                putw((int)e->l, fp);
        !           107:                fwrite((char *)e->r, (int)e->l, 1, fp);
        !           108:                break;
        !           109:        case Cat:
        !           110:        case Alternate:
        !           111:                etofile(e->l, fp);
        !           112:                etofile(e->r, fp);
        !           113:                break;
        !           114:        case Star:
        !           115:        case Plus:
        !           116:        case Quest:
        !           117:        case Group:
        !           118:        case EOP:
        !           119:                etofile(e->l, fp);
        !           120:                break;
        !           121:        }
        !           122: }
        !           123: 
        !           124: re_re *
        !           125: re_filere(FILE *fp)
        !           126: {
        !           127:        register re_re *r;
        !           128: 
        !           129:        r = (re_re *)egmalloc(sizeof (re_re), "allocating re_re");
        !           130:        if(r == 0)
        !           131:                return(0);
        !           132:        memset((char *)r, 0, sizeof (re_re));
        !           133:        if(getc(fp) != REVERSION){
        !           134:                re_error("read bad version number");
        !           135:                goto err;
        !           136:        }
        !           137:        if(fread(r->mymap, 256, 1, fp) != 1){
        !           138:                re_error("couldn't read char map");
        !           139:                goto err;
        !           140:        }
        !           141:        r->carat = getw(fp);
        !           142:        eg_lexinit((char *)0, (char *)0);
        !           143:        if((r->root = filetoe(fp)) == 0){
        !           144: err:
        !           145:                free((char *)r);
        !           146:                return(0);
        !           147:        }
        !           148:        egpost(r);
        !           149:        if(r->backref || r->parens)
        !           150:                egbr(r);
        !           151:        else
        !           152:                eginit(r, r->carat);
        !           153:        return(r);
        !           154: }
        !           155: 
        !           156: static Expr *
        !           157: filetoe(FILE *fp)
        !           158: {
        !           159:        Expr *ee, *er, *el, *ret;
        !           160:        int t, l;
        !           161:        Exprtype et;
        !           162:        char res[256];
        !           163:        int br, parens;
        !           164: 
        !           165:        t = getw(fp);
        !           166:        if((t == EOF) && feof(fp))
        !           167:                return(0);
        !           168:        et = (Exprtype)t;
        !           169:        l = getw(fp);
        !           170:        br = getc(fp);
        !           171:        parens = getc(fp);
        !           172:        switch(et)
        !           173:        {
        !           174:        case Null:
        !           175:                return(0);
        !           176:        case Literal:
        !           177:        case Dot:
        !           178:        case Carat:
        !           179:        case Dollar:
        !           180:        case Backref:
        !           181:                ret = eg_newexpr(et, l, (Expr *)0, (Expr *)0);
        !           182:                break;
        !           183:        case Compcharclass:
        !           184:        case Charclass:
        !           185:                ee = eg_newexpr(et, l, (Expr *)0, (Expr *)0);
        !           186:                l = getw(fp);
        !           187:                ee->r = (Expr *)egmalloc(l, "filetoe copy");
        !           188:                if (!ee->r)
        !           189:                        return 0;
        !           190:                ee->l = (Expr *)l;
        !           191:                fread((char *)ee->r, l, 1, fp);
        !           192:                ret = ee;
        !           193:                break;
        !           194:        case Cat:
        !           195:        case Alternate:
        !           196:                el = filetoe(fp);
        !           197:                er = filetoe(fp);
        !           198:                ret = eg_newexpr(et, l, el, er);
        !           199:                break;
        !           200:        case Star:
        !           201:        case Plus:
        !           202:        case Quest:
        !           203:        case Group:
        !           204:        case EOP:
        !           205:                el = filetoe(fp);
        !           206:                ret = eg_newexpr(et, l, el, (Expr *)0);
        !           207:                break;
        !           208:        default:
        !           209:                SPR res, "<reading expr undef type %d lit=%d>", t, l);
        !           210:                re_error(res);
        !           211:                return((Expr *)0);
        !           212:        }
        !           213:        ret->backref = br;
        !           214:        ret->parens = parens;
        !           215:        return(ret);
        !           216: }
        !           217: #endif

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