Return to lt1.c CVS log

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

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

1.1       root        1: /*
                      2: From pegasus.ATT.COM!hansen Sun Oct 14 23:38 EDT 1990
                      3: Received: by pyxis; Sun Oct 14 23:38 EDT 1990
                      4: FROM:       [email protected] (t.l.hansen)
                      5: TO:         research!andrew
                      6: DATE:       14 Oct 1990  23:35 EDT
                      7: SUBJECT:    regex bug take 2
                      8: 
                      9: Something's getting lost when writing or reading the compiled expression
                     10: to/from a file. The following program displays the problem. It is similar to
                     11: the previous one except that it writes the regex to a temp file in the
                     12: middle and then reads it back in.
                     13: 
                     14:                                        Tony
                     15: */
                     16: #include <stdio.h>
                     17: #include <ctype.h>
                     18: #define USE_STDIO
                     19: #include "re.h"
                     20: 
                     21: void prc(c)
                     22: unsigned char c;
                     23: {
                     24:     if (c >= 0200)
                     25:        {
                     26:        (void) printf("M-");
                     27:        c -= 0200;
                     28:        }
                     29:     if (isprint(c)) putchar(c);
                     30:     else
                     31:        {
                     32:        putchar('^');
                     33:        putchar(c ^ 0100);
                     34:        }
                     35: }
                     36: 
                     37: void pr(i, mb, me)
                     38: int i;
                     39: char *mb;
                     40: char *me;
                     41: {
                     42:     (void) printf("%d: %#x - %#x\n", i, mb, me);
                     43:     putchar('"');
                     44:     for (; mb < me; mb++)
                     45:        {
                     46:        if (!*mb)
                     47:            break;
                     48:        prc(*mb);
                     49:        }
                     50:     putchar('"');
                     51:     putchar('\n');
                     52: }
                     53: 
                     54: main()
                     55: {
                     56:     re_re *regex;
                     57:     int i;
                     58:     unsigned char re_map[256];
                     59:     static char lname[] = "!nosuchsystem!testing";
                     60:     static char pat[] = "!([^!]+)!(.+)";
                     61:     char *match[10][2];
                     62:     int parens;
                     63:     FILE *fp;
                     64: 
                     65:     for (i = 0; i < 256; i++)
                     66:        re_map[i] = i;
                     67:     regex = re_recomp(pat, pat+strlen(pat), re_map);
                     68:     parens = re_paren(regex);
                     69:     (void) printf("parens = %d\n", parens);
                     70:     if (parens != 2)
                     71:         {
                     72:        (void) printf("!= 2!!\n");
                     73:        return 0;
                     74:        }
                     75:     fp = fopen("/tmp/junk.re", "w");
                     76:     if (!fp)
                     77:         {
                     78:        (void) printf("error opening output file\n");
                     79:        return 0;
                     80:        }
                     81: 
                     82:     re_refile(regex, fp);
                     83:     fclose(fp);
                     84:     if (ferror(fp))
                     85:         {
                     86:        (void) printf("error writing\n");
                     87:        return 0;
                     88:        }
                     89: 
                     90:     fp = fopen("/tmp/junk.re", "r");
                     91:     if (!fp)
                     92:         {
                     93:        (void) printf("error opening input file\n");
                     94:        return 0;
                     95:        }
                     96: 
                     97:     regex = re_filere(fp);
                     98:     if (!regex)
                     99:         {
                    100:        (void) printf("error reading regex\n");
                    101:        return 0;
                    102:        }
                    103: 
                    104:     fclose(fp);
                    105: 
                    106:     parens = re_paren(regex);
                    107:     (void) printf("parens = %d\n", parens);
                    108:     if (parens != 2)
                    109:         {
                    110:        (void) printf("!= 2!!\n");
                    111:        return 0;
                    112:        }
                    113:     
                    114:     if (!re_reexec(regex, lname, lname+strlen(lname), match))
                    115:        {
                    116:        (void) printf("no match\n");
                    117:        return 0;
                    118:        }
                    119: 
                    120:     (void) printf("matched\n");
                    121:     for (i = 0; i <= parens; i++)
                    122:        pr(i, match[i][0], match[i][1]);
                    123:     return 0;
                    124: }

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