From 6f5101be21e854a5125b489a03814cc7509236cc Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Tue, 24 Jan 1995 16:00:20 +0000 Subject: [PATCH] Added -ansi to CFLAGS. Some changes to the dfa module. --- dfa/Makefile | 6 +-- dfa/agrep.c | 28 ++++++------ dfa/bset.c | 138 +++++++++++++++++++++++++++++--------------------------- dfa/grepper.c | 76 ++++++++++++++++--------------- dfa/lexer.c | 18 +++++--- dfa/lexer.h | 8 +++- dfa/readfile.c | 107 ++++++++++++++++++++----------------------- dfa/set.c | 108 +++++++++++++++++++++++--------------------- dfa/states.c | 129 ++++++++++++++++++++++++++++------------------------ 9 files changed, 320 insertions(+), 298 deletions(-) diff --git a/dfa/Makefile b/dfa/Makefile index 681f02f..66a92b4 100644 --- a/dfa/Makefile +++ b/dfa/Makefile @@ -1,17 +1,17 @@ # Copyright (C) 1994, Index Data I/S # All rights reserved. # Sebastian Hammer, Adam Dickmeiss -# $Id: Makefile,v 1.5 1994-10-05 10:46:41 adam Exp $ +# $Id: Makefile,v 1.6 1995-01-24 16:00:20 adam Exp $ SHELL=/bin/sh INCLUDE=-I../include TPROG1=agrep TPROG2=lexer TPROG3=grepper -CFLAGS=-g -Wall +CFLAGS=-g -Wall -pedantic -ansi DEFS=$(INCLUDE) -DYACC -DYYDEBUG=1 -DMEMDEBUG=1 LIB=../lib/dfa.a -PO = regexp.o imalloc.o states.o set.o bset.o +PO = dfa.o imalloc.o states.o set.o bset.o CPP=cc -E YACC=yacc diff --git a/dfa/agrep.c b/dfa/agrep.c index c8cdf7e..81f608c 100644 --- a/dfa/agrep.c +++ b/dfa/agrep.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: agrep.c,v $ - * Revision 1.3 1994-09-27 16:31:18 adam + * Revision 1.4 1995-01-24 16:00:21 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.3 1994/09/27 16:31:18 adam * First version of grepper: grep with error correction. * * Revision 1.2 1994/09/26 16:30:56 adam @@ -171,10 +175,10 @@ char *p; static int go (fd, dfaar) int fd; -DFA_state **dfaar; +struct DFA_state **dfaar; { - DFA_state *s = dfaar[0]; - DFA_tran *t; + struct DFA_state *s = dfaar[0]; + struct DFA_tran *t; char *p; int i; unsigned char c; @@ -222,7 +226,7 @@ DFA_state **dfaar; } int agrep (dfas, fd) -DFA_states *dfas; +struct DFA_state **dfas; int fd; { inf_buf = imalloc (sizeof(char)*INF_BUF_SIZE); @@ -231,7 +235,7 @@ int fd; inf_flush (fd); line_no = 1; - go (fd, dfas->sortarray); + go (fd, dfas); ifree (inf_buf); return 0; @@ -245,8 +249,7 @@ char **argv; char *pattern = NULL; char outbuf[BUFSIZ]; int fd, i, no = 0; - DFA *dfa = init_dfa(); - DFA_states *dfas; + struct DFA *dfa = dfa_init(); prog = *argv; #ifdef YYDEBUG @@ -265,15 +268,13 @@ char **argv; if (!pattern) { pattern = *argv; - i = parse_dfa (dfa, &pattern, dfa_thompson_chars); + i = dfa_parse (dfa, &pattern); if (i || *pattern) { fprintf (stderr, "%s: illegal pattern\n", prog); return 1; } - dfa->root = dfa->top; - dfas = mk_dfas (dfa, 200); - rm_dfa (&dfa); + dfa_mkstate (dfa); } else { @@ -284,7 +285,7 @@ char **argv; fprintf (stderr, "%s: couldn't open `%s'\n", prog, *argv); return 1; } - i = agrep (dfas, fd); + i = agrep (dfa->states, fd); close (fd); if (i) return i; @@ -295,5 +296,6 @@ char **argv; return 2; } fflush(stdout); + dfa_delete (&dfa); return 0; } diff --git a/dfa/bset.c b/dfa/bset.c index db02832..1bd65e8 100644 --- a/dfa/bset.c +++ b/dfa/bset.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: bset.c,v $ - * Revision 1.1 1994-09-26 10:16:53 adam + * Revision 1.2 1995-01-24 16:00:21 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.1 1994/09/26 10:16:53 adam * First version of dfa module in alex. This version uses yacc to parse * regular expressions. This should be hand-made instead. * @@ -27,10 +31,10 @@ BSetHandle *mk_BSetHandle (int size, int chunk) int wsize = 1+size/(sizeof(BSetWord)*8); BSetHandle *sh; - if( chunk <= 1 ) + if (chunk <= 1) chunk = 32; - sh = (BSetHandle *) imalloc( sizeof(BSetHandle) + - chunk*sizeof(BSetWord)*wsize ); + sh = (BSetHandle *) imalloc (sizeof(BSetHandle) + + chunk*sizeof(BSetWord)*wsize); sh->size = size; sh->wsize = wsize; @@ -44,13 +48,13 @@ void rm_BSetHandle (BSetHandle **shp) { BSetHandle *sh, *sh1; - assert( shp ); + assert (shp); sh = *shp; - assert( sh ); - while( sh ) + assert (sh); + while (sh) { sh1 = sh->setchain; - ifree( sh ); + ifree (sh); sh = sh1; } } @@ -59,7 +63,7 @@ int inf_BSetHandle (BSetHandle *sh, long *used, long *allocated) { int wsize; - assert( sh ); + assert (sh); *used = 0; *allocated = 0; wsize = sh->wsize; @@ -67,7 +71,7 @@ int inf_BSetHandle (BSetHandle *sh, long *used, long *allocated) { *used += sh->offset; *allocated += sh->chunk; - } while( (sh = sh->setchain) ); + } while ((sh = sh->setchain)); return wsize; } @@ -75,15 +79,15 @@ BSet mk_BSet (BSetHandle **shp) { BSetHandle *sh, *sh1; unsigned off; - assert( shp ); + assert (shp); sh = *shp; - assert( sh ); + assert (sh); off = sh->offset; - if( (off + sh->wsize) > sh->chunk ) + if ((off + sh->wsize) > sh->chunk) { - sh1 = (BSetHandle *) imalloc( sizeof(BSetHandle ) + - sh->chunk*sizeof(BSetWord) ); + sh1 = (BSetHandle *) imalloc (sizeof(BSetHandle) + + sh->chunk*sizeof(BSetWord)); sh1->size = sh->size; sh1->wsize = sh->wsize; sh1->chunk = sh->chunk; @@ -97,42 +101,42 @@ BSet mk_BSet (BSetHandle **shp) void add_BSet (BSetHandle *sh, BSet dst, unsigned member) { - assert( dst ); - assert( sh ); - assert( member <= sh->size ); + assert (dst); + assert (sh); + assert (member <= sh->size); SET_BIT(dst, member); } unsigned test_BSet (BSetHandle *sh, BSet src, unsigned member) { - assert( src ); - assert( sh ); - assert( member <= sh->size ); - return GET_BIT( src , member) != 0; + assert (src); + assert (sh); + assert (member <= sh->size); + return GET_BIT (src , member) != 0; } BSet cp_BSet (BSetHandle *sh, BSet dst, BSet src) { - assert( sh ); - assert( dst ); - assert( src ); - memcpy( dst, src, sh->wsize * sizeof(BSetWord)); + assert (sh); + assert (dst); + assert (src); + memcpy (dst, src, sh->wsize * sizeof(BSetWord)); return dst; } void res_BSet (BSetHandle *sh, BSet dst) { - assert( dst ); - memset( dst, 0, sh->wsize * sizeof(BSetWord)); + assert (dst); + memset (dst, 0, sh->wsize * sizeof(BSetWord)); } void union_BSet (BSetHandle *sh, BSet dst, BSet src) { int i; - assert( sh ); - assert( dst ); - assert( src ); - for( i=sh->wsize; --i >= 0; ) + assert (sh); + assert (dst); + assert (src); + for (i=sh->wsize; --i >= 0;) *dst++ |= *src++; } @@ -140,9 +144,9 @@ unsigned hash_BSet (BSetHandle *sh, BSet src) { int i; unsigned s = 0; - assert( sh ); - assert( src ); - for( i=sh->wsize; --i >= 0; ) + assert (sh); + assert (src); + for (i=sh->wsize; --i >= 0;) s += *src++; return s; } @@ -150,20 +154,20 @@ unsigned hash_BSet (BSetHandle *sh, BSet src) void com_BSet (BSetHandle *sh, BSet dst) { int i; - assert( sh ); - assert( dst ); - for( i=sh->wsize; --i >= 0; dst++ ) + assert (sh); + assert (dst); + for (i=sh->wsize; --i >= 0; dst++) *dst = ~*dst; } int eq_BSet (BSetHandle *sh, BSet dst, BSet src) { int i; - assert( sh ); - assert( dst ); - assert( src ); - for( i=sh->wsize; --i >= 0; ) - if( *dst++ != *src++ ) + assert (sh); + assert (dst); + assert (src); + for (i=sh->wsize; --i >= 0;) + if (*dst++ != *src++) return 0; return 1; } @@ -174,19 +178,19 @@ int trav_BSet (BSetHandle *sh, BSet src, unsigned member) BSetWord *sw = src+member/(sizeof(BSetWord)*8); unsigned b = member & (sizeof(BSetWord)*8-1); while(i >= 0) - if( b == 0 && *sw == 0 ) + if (b == 0 && *sw == 0) { member += sizeof(BSetWord)*8; ++sw; i -= sizeof(BSetWord)*8; } - else if( *sw & (1<= 0) - if( b == 0 && *sw == (BSetWord) ~ 0 ) + if (b == 0 && *sw == (BSetWord) ~ 0) { member += sizeof(BSetWord)*8; ++sw; i -= sizeof(BSetWord)*8; } - else if( (*sw & (1<n * ch + wno] & (1<n = (dfas->no+WORD_BITS) / WORD_BITS; + mc->n = (dfa->no_states+WORD_BITS) / WORD_BITS; mc->range = range; mc->Sc = icalloc (sizeof(*mc->Sc) * 256 * mc->n); - for (i=0; ino; i++) + for (i=0; ino_states; i++) { int j; - DFA_state *state = dfas->sortarray[i]; + struct DFA_state *state = dfa->states[i]; for (j=0; jtran_no; j++) { @@ -96,7 +100,7 @@ static MatchContext *mk_MatchContext (DFA_states *dfas, int range) static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, - DFA_states *dfas, int ch) + struct DFA *dfa, int ch) { int j, s = 0; MatchWord *Rsrc_p = Rsrc, mask; @@ -113,7 +117,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, { if (mask & 1) { - DFA_state *state = dfas->sortarray[s]; + struct DFA_state *state = dfa->states[s]; int i = state->tran_no; while (--i >= 0) if (ch >= state->trans[i].ch[0] && @@ -122,7 +126,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, } if (mask & 2) { - DFA_state *state = dfas->sortarray[s+1]; + struct DFA_state *state = dfa->states[s+1]; int i = state->tran_no; while (--i >= 0) if (ch >= state->trans[i].ch[0] && @@ -131,7 +135,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, } if (mask & 4) { - DFA_state *state = dfas->sortarray[s+2]; + struct DFA_state *state = dfa->states[s+2]; int i = state->tran_no; while (--i >= 0) if (ch >= state->trans[i].ch[0] && @@ -140,7 +144,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, } if (mask & 8) { - DFA_state *state = dfas->sortarray[s+3]; + struct DFA_state *state = dfa->states[s+3]; int i = state->tran_no; while (--i >= 0) if (ch >= state->trans[i].ch[0] && @@ -149,7 +153,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, } } s += 4; - if (s >= dfas->no) + if (s >= dfa->no_states) return; mask >>= 4; } @@ -157,7 +161,7 @@ static void mask_shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, } static void shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, - DFA_states *dfas) + struct DFA *dfa) { int j, s = 0; MatchWord *Rsrc_p = Rsrc, mask; @@ -172,35 +176,35 @@ static void shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc, { if (mask & 1) { - DFA_state *state = dfas->sortarray[s]; + struct DFA_state *state = dfa->states[s]; int i = state->tran_no; while (--i >= 0) set_bit (mc, Rdst, 0, state->trans[i].to); } if (mask & 2) { - DFA_state *state = dfas->sortarray[s+1]; + struct DFA_state *state = dfa->states[s+1]; int i = state->tran_no; while (--i >= 0) set_bit (mc, Rdst, 0, state->trans[i].to); } if (mask & 4) { - DFA_state *state = dfas->sortarray[s+2]; + struct DFA_state *state = dfa->states[s+2]; int i = state->tran_no; while (--i >= 0) set_bit (mc, Rdst, 0, state->trans[i].to); } if (mask & 8) { - DFA_state *state = dfas->sortarray[s+3]; + struct DFA_state *state = dfa->states[s+3]; int i = state->tran_no; while (--i >= 0) set_bit (mc, Rdst, 0, state->trans[i].to); } } s += 4; - if (s >= dfas->no) + if (s >= dfa->no_states) return; mask >>= 4; } @@ -216,7 +220,7 @@ static void or (MatchContext *mc, MatchWord *Rdst, } -static int go (MatchContext *mc, DFA_states *dfas, FILE *inf) +static int go (MatchContext *mc, struct DFA *dfa, FILE *inf) { MatchWord *Rj, *Rj1, *Rj_a, *Rj_b, *Rj_c; int s, d, ch; @@ -238,11 +242,11 @@ static int go (MatchContext *mc, DFA_states *dfas, FILE *inf) { int s; memcpy (Rj + mc->n * d, Rj + mc->n * (d-1), mc->n * sizeof(*Rj)); - for (s = 0; sno; s++) + for (s = 0; sno_states; s++) { if (get_bit (mc, Rj, d-1, s)) { - DFA_state *state = dfas->sortarray[s]; + struct DFA_state *state = dfa->states[s]; int i = state->tran_no; while (--i >= 0) set_bit (mc, Rj, d, state->trans[i].to); @@ -278,27 +282,27 @@ static int go (MatchContext *mc, DFA_states *dfas, FILE *inf) } if (++inf_ptr == INFBUF_SIZE) inf_ptr = 0; - mask_shift (mc, Rj1, Rj, dfas, ch); + mask_shift (mc, Rj1, Rj, dfa, ch); for (d = 1; d <= mc->range; d++) { - mask_shift (mc, Rj_b, Rj+d*mc->n, dfas, ch); /* 1 */ + mask_shift (mc, Rj_b, Rj+d*mc->n, dfa, ch); /* 1 */ or (mc, Rj_a, Rj+(d-1)*mc->n, Rj1+(d-1)*mc->n); /* 2,3 */ - shift (mc, Rj_c, Rj_a, dfas); + shift (mc, Rj_c, Rj_a, dfa); or (mc, Rj_a, Rj_b, Rj_c); /* 1,2,3*/ or (mc, Rj1+d*mc->n, Rj_a, Rj+(d-1)*mc->n); /* 1,2,3,4 */ } - for (s = 0; sno; s++) + for (s = 0; sno_states; s++) { - if (dfas->sortarray[s]->rule_no) + if (dfa->states[s]->rule_no) if (get_bit (mc, Rj1+mc->range*mc->n, 0, s)) no_match++; } for (d = 0; d <= mc->range; d++) - reset_bit (mc, Rj1+d*mc->n, 0, dfas->no); + reset_bit (mc, Rj1+d*mc->n, 0, dfa->no_states); Rj_t = Rj1; Rj1 = Rj; Rj = Rj_t; @@ -312,7 +316,7 @@ static int go (MatchContext *mc, DFA_states *dfas, FILE *inf) return 0; } -static int grep_file (DFA_states *dfas, const char *fname, int range) +static int grep_file (struct DFA *dfa, const char *fname, int range) { FILE *inf; MatchContext *mc; @@ -329,9 +333,9 @@ static int grep_file (DFA_states *dfas, const char *fname, int range) else inf = stdin; - mc = mk_MatchContext (dfas, range); + mc = mk_MatchContext (dfa, range); - go (mc, dfas, inf); + go (mc, dfa, inf); if (fname) fclose (inf); @@ -344,8 +348,8 @@ int main (int argc, char **argv) int range = 0; char *arg; char *pattern = NULL; - DFA_states *dfas = NULL; int no_files = 0; + struct DFA *dfa = dfa_init(); prog = argv[0]; while ((ret = options ("nr:dsv:", argv, argc, &arg)) != -2) @@ -355,22 +359,19 @@ int main (int argc, char **argv) if (!pattern) { int i; - DFA *dfa = init_dfa(); pattern = arg; - i = parse_dfa (dfa, &pattern, dfa_thompson_chars); + i = dfa_parse (dfa, &pattern); if (i || *pattern) { fprintf (stderr, "%s: illegal pattern\n", prog); return 1; } - dfa->root = dfa->top; - dfas = mk_dfas (dfa, 200); - rm_dfa (&dfa); + dfa_mkstate (dfa); } else { no_files++; - grep_file (dfas, arg, range); + grep_file (dfa, arg, range); } } else if (ret == 'v') @@ -409,7 +410,8 @@ int main (int argc, char **argv) } else if (no_files == 0) { - grep_file (dfas, NULL, range); + grep_file (dfa, NULL, range); } + dfa_delete (&dfa); return 0; } diff --git a/dfa/lexer.c b/dfa/lexer.c index b4c592d..2424444 100644 --- a/dfa/lexer.c +++ b/dfa/lexer.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: lexer.c,v $ - * Revision 1.4 1994-10-04 17:46:44 adam + * Revision 1.5 1995-01-24 16:00:22 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.4 1994/10/04 17:46:44 adam * Function options now returns arg with error option. * * Revision 1.3 1994/10/03 17:22:19 adam @@ -109,8 +113,7 @@ static int lexer_options (int argc, char **argv) int main (int argc, char **argv) { int i, no = 0; - DFA *dfa; - DFA_states *dfas; + struct DFA *dfa; prog = *argv; #ifdef YACC @@ -118,6 +121,7 @@ int main (int argc, char **argv) #else alexdebug = 0; #endif + dfa = dfa_init (); i = lexer_options (argc, argv); if (i) return i; @@ -132,13 +136,13 @@ int main (int argc, char **argv) if (**++argv != '-' && **argv) { ++no; - i = read_file (*argv, &dfa); + + i = read_file (*argv, dfa); if (i) return i; - dfas = mk_dfas (dfa, 2000); - rm_dfa (&dfa); - rm_dfas (&dfas); + dfa_mkstate (dfa); } + dfa_delete (&dfa); #ifdef MEMDEBUG imemstat(); #endif diff --git a/dfa/lexer.h b/dfa/lexer.h index 1178063..3c446e4 100644 --- a/dfa/lexer.h +++ b/dfa/lexer.h @@ -4,14 +4,18 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: lexer.h,v $ - * Revision 1.1 1994-09-26 10:16:55 adam + * Revision 1.2 1995-01-24 16:00:22 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.1 1994/09/26 10:16:55 adam * First version of dfa module in alex. This version uses yacc to parse * regular expressions. This should be hand-made instead. * */ -int read_file ( const char *, DFA ** ); +int read_file ( const char *, struct DFA * ); void error ( const char *, ... ); extern int ccluse; diff --git a/dfa/readfile.c b/dfa/readfile.c index f0e4aed..4fd9cc9 100644 --- a/dfa/readfile.c +++ b/dfa/readfile.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: readfile.c,v $ - * Revision 1.2 1994-09-26 16:30:57 adam + * Revision 1.3 1995-01-24 16:00:22 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.2 1994/09/26 16:30:57 adam * Minor changes. imalloc uses xmalloc now. * * Revision 1.1 1994/09/26 10:16:56 adam @@ -34,7 +38,7 @@ static int err_no; static void prep (char **s), read_defs (void), - read_rules (DFA **dfap), + read_rules (struct DFA *dfap), read_tail (void); static char @@ -47,7 +51,7 @@ static void prep (char **s) const char *src = *s; int c; - while( (c = *src++) ) + while ((c = *src++)) *dst++ = c; *dst = '\0'; @@ -58,110 +62,97 @@ static char *read_line (void) { static char linebuf[MAXLINE+1]; ++line_no; - return fgets( linebuf, MAXLINE, inf ); + return fgets (linebuf, MAXLINE, inf); } static void read_defs (void) { const char *s; - while( (s=read_line()) ) + while ((s=read_line())) { - if( *s == '%' && s[1] == '%' ) + if (*s == '%' && s[1] == '%') return; - else if( *s == '\0' || isspace( *s ) ) - fputs( s, outf ); + else if (*s == '\0' || isspace (*s)) + fputs (s, outf); } - error( "missing rule section" ); + error ("missing rule section"); } -static void read_rules (DFA **dfap) +static void read_rules (struct DFA *dfa) { char *s; - Tnode *n; int i; - DFA *dfa; - - *dfap = dfa = init_dfa(); - fputs( "\n#ifndef YY_BREAK\n#define YY_BREAK break;\n#endif\n", outf ); - fputs( "void lexact( int no )\n{\n", outf ); - fputs( "\tswitch( no )\n\t{\n", outf ); - dfa->root = NULL; - while( (s=read_line()) ) + int no = 0; + + fputs ("\n#ifndef YY_BREAK\n#define YY_BREAK break;\n#endif\n", outf); + fputs ("void lexact (int no)\n{\n", outf); + fputs ( "\tswitch (no)\n\t{\n", outf); + while ((s=read_line())) { - if( *s == '%' && s[1] == '%' ) + if (*s == '%' && s[1] == '%') break; - else if( *s == '\0' || isspace( *s ) ) + else if (*s == '\0' || isspace (*s)) /* copy rest of line to output */ - fputs( s, outf ); + fputs (s, outf); else { /* preprocess regular expression */ - prep( &s ); + prep (&s); /* now parse regular expression */ - if (ccluse) - i = parse_dfa( dfa, &s, dfa_ccl_chars ); - else - i = parse_dfa( dfa, &s, dfa_thompson_chars ); - - if( dfa->rule > 1 ) - fputs( "\t\tYY_BREAK\n", outf ); - fprintf( outf, "\tcase %d:\n#line %d\n\t\t", dfa->rule, line_no ); - if( i ) + i = dfa_parse (dfa, &s); + if (i) { - fprintf( stderr, "%s #%d: regular expression syntax error\n", - inf_name, line_no ); + fprintf (stderr, "%s #%d: regular expression syntax error\n", + inf_name, line_no); err_no++; } - else if( !dfa->root ) - dfa->root = dfa->top; else { - n = mk_Tnode(); - n->pos = OR; - n->u.p[0] = dfa->root; - n->u.p[1] = dfa->top; - dfa->root = n; + if (no) + fputs ("\t\tYY_BREAK\n", outf); + no++; + fprintf (outf, "\tcase %d:\n#line %d\n\t\t", no, line_no); } - while( *s == '\t' || *s == ' ' ) + while (*s == '\t' || *s == ' ') s++; - fputs( s, outf ); + fputs (s, outf); } } - fputs( "\tYY_BREAK\n\t}\n}\n", outf ); - if( !dfa->root ) - error( "no regular expressions in rule section" ); + fputs ("\tYY_BREAK\n\t}\n}\n", outf); + if (!no) + error ("no regular expressions in rule section"); } static void read_tail (void) { const char *s; - while( (s=read_line()) ) - fputs( s, outf ); + while ((s=read_line())) + fputs (s, outf); } -int read_file (const char *s, DFA **dfap) +int read_file (const char *s, struct DFA *dfa) { inf_name = s; - if( !(inf=fopen( s,"r" )) ) + if (!(inf=fopen (s,"r"))) { - error( "cannot open `%s'", s ); + error ("cannot open `%s'", s); return -1; } - if( !(outf=fopen( "lex.yy.c", "w" )) ) + if (!(outf=fopen ("lex.yy.c", "w"))) { - error( "cannot open `%s'", "lex.yy.c" ); + error ("cannot open `%s'", "lex.yy.c"); return -2; } line_no = 0; err_no = 0; - read_defs(); - read_rules( dfap ); - read_tail(); + read_defs (); + read_rules (dfa); + read_tail (); - fclose( outf ); - fclose( inf ); + fclose (outf); + fclose (inf); return err_no; } diff --git a/dfa/set.c b/dfa/set.c index f567f29..274b57c 100644 --- a/dfa/set.c +++ b/dfa/set.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: set.c,v $ - * Revision 1.1 1994-09-26 10:16:57 adam + * Revision 1.2 1995-01-24 16:00:22 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.1 1994/09/26 10:16:57 adam * First version of dfa module in alex. This version uses yacc to parse * regular expressions. This should be hand-made instead. * @@ -27,10 +31,10 @@ SetType mk_SetType (int chunk) { SetType st; - assert( chunk > 8 && chunk < 8000 ); + assert (chunk > 8 && chunk < 8000); - st = (SetType) imalloc( sizeof(*st) ); - assert( st ); + st = (SetType) imalloc (sizeof(*st)); + assert (st); st->alloclist = st->freelist = NULL; st->used = 0; @@ -41,29 +45,29 @@ SetType mk_SetType (int chunk) int inf_SetType (SetType st, long *used, long *allocated) { Set s; - assert( st ); + assert (st); *used = st->used; *allocated = 0; - for( s = st->alloclist; s; s = s->next ) + for (s = st->alloclist; s; s = s->next) *allocated += st->chunk; - return sizeof( SetElement ); + return sizeof (SetElement); } SetType rm_SetType (SetType st) { Set s, s1; - for( s = st->alloclist; (s1 = s); ) + for (s = st->alloclist; (s1 = s);) { s = s->next; - ifree( s1 ); + ifree (s1); } - ifree( st ); + ifree (st); return NULL; } Set mk_Set (SetType st) { - assert( st ); + assert (st); return NULL; } @@ -71,17 +75,17 @@ static Set mk_SetElement (SetType st, int n) { Set s; int i; - assert( st ); + assert (st); - assert( st->chunk > 8 ); - if( ! st->freelist ) + assert (st->chunk > 8); + if (! st->freelist) { - s = (Set) imalloc( sizeof(*s) * (1+st->chunk) ); - assert( s ); + s = (Set) imalloc (sizeof(*s) * (1+st->chunk)); + assert (s); s->next = st->alloclist; st->alloclist = s; st->freelist = ++s; - for( i=st->chunk; --i > 0; s++ ) + for (i=st->chunk; --i > 0; s++) s->next = s+1; s->next = NULL; } @@ -94,8 +98,8 @@ static Set mk_SetElement (SetType st, int n) static void rm_SetElement (SetType st, SetElement *p) { - assert( st ); - assert( st->used > 0 ); + assert (st); + assert (st->used > 0); p->next = st->freelist; st->freelist = p; st->used--; @@ -106,9 +110,9 @@ Set rm_Set (SetType st, Set s) Set s1 = s; int i = 1; - if( s ) + if (s) { - while( s->next ) + while (s->next) { s = s->next; ++i; @@ -116,7 +120,7 @@ Set rm_Set (SetType st, Set s) s->next = st->freelist; st->freelist = s1; st->used -= i; - assert( st->used >= 0 ); + assert (st->used >= 0); } return NULL; } @@ -126,12 +130,12 @@ Set add_Set (SetType st, Set s, int n) SetElement dummy; Set p = &dummy, new; p->next = s; - while( p->next && p->next->value < n ) + while (p->next && p->next->value < n) p = p->next; - assert( p ); - if( !(p->next && p->next->value == n ) ) + assert (p); + if (!(p->next && p->next->value == n)) { - new = mk_SetElement( st, n ); + new = mk_SetElement (st, n); new->next = p->next; p->next = new; } @@ -142,17 +146,17 @@ Set union_Set (SetType st, Set s1, Set s2) { SetElement dummy; Set p; - assert( st ); + assert (st); - for( p = &dummy; s1 && s2; ) - if( s1->value < s2->value ) + for (p = &dummy; s1 && s2;) + if (s1->value < s2->value) { p = p->next = s1; s1 = s1->next; } - else if( s1->value > s2->value ) + else if (s1->value > s2->value) { - p = p->next = mk_SetElement( st, s2->value ); + p = p->next = mk_SetElement (st, s2->value); s2 = s2->next; } else @@ -161,13 +165,13 @@ Set union_Set (SetType st, Set s1, Set s2) s1 = s1->next; s2 = s2->next; } - if( s1 ) + if (s1) p->next = s1; else { - while( s2 ) + while (s2) { - p = p->next = mk_SetElement( st, s2->value ); + p = p->next = mk_SetElement (st, s2->value); s2 = s2->next; } p->next = NULL; @@ -177,36 +181,36 @@ Set union_Set (SetType st, Set s1, Set s2) Set cp_Set (SetType st, Set s) { - return merge_Set( st, s, NULL ); + return merge_Set (st, s, NULL); } Set merge_Set (SetType st, Set s1, Set s2) { SetElement dummy; Set p; - assert( st ); - for( p = &dummy; s1 && s2; p = p->next ) - if( s1->value < s2->value ) + assert (st); + for (p = &dummy; s1 && s2; p = p->next) + if (s1->value < s2->value) { - p->next = mk_SetElement( st, s1->value ); + p->next = mk_SetElement (st, s1->value); s1 = s1->next; } - else if( s1->value > s2->value ) + else if (s1->value > s2->value) { - p->next = mk_SetElement( st, s2->value ); + p->next = mk_SetElement (st, s2->value); s2 = s2->next; } else { - p->next = mk_SetElement( st, s1->value ); + p->next = mk_SetElement (st, s1->value); s1 = s1->next; s2 = s2->next; } - if( !s1 ) + if (!s1) s1 = s2; - while( s1 ) + while (s1) { - p = p->next = mk_SetElement( st, s1->value ); + p = p->next = mk_SetElement (st, s1->value); s1 = s1->next; } p->next = NULL; @@ -215,19 +219,19 @@ Set merge_Set (SetType st, Set s1, Set s2) void pr_Set (SetType st, Set s) { - assert( st ); - while( s ) + assert (st); + while (s) { - printf( " %d", s->value ); + printf (" %d", s->value); s = s->next; } - putchar( '\n' ); + putchar ('\n'); } unsigned hash_Set (SetType st, Set s) { unsigned n = 0; - while( s ) + while (s) { n += 11*s->value; s = s->next; @@ -237,8 +241,8 @@ unsigned hash_Set (SetType st, Set s) int eq_Set (SetType st, Set s1, Set s2) { - for( ; s1 && s2; s1=s1->next, s2=s2->next ) - if( s1->value != s2->value ) + for (; s1 && s2; s1=s1->next, s2=s2->next) + if (s1->value != s2->value) return 0; return s1 == s2; } diff --git a/dfa/states.c b/dfa/states.c index 8c450c2..289d824 100644 --- a/dfa/states.c +++ b/dfa/states.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: states.c,v $ - * Revision 1.1 1994-09-26 10:16:58 adam + * Revision 1.2 1995-01-24 16:00:23 adam + * Added -ansi to CFLAGS. + * Some changes to the dfa module. + * + * Revision 1.1 1994/09/26 10:16:58 adam * First version of dfa module in alex. This version uses yacc to parse * regular expressions. This should be hand-made instead. * @@ -16,22 +20,23 @@ #include #include -#include +#include "dfap.h" #include "imalloc.h" #define DFA_CHUNK 200 #define TRAN_CHUNK 800 -int init_DFA_states (DFA_states **dfasp, SetType st, int hash) +int init_DFA_states (struct DFA_states **dfasp, SetType st, int hash) { - DFA_states *dfas; - DFA_trans *tm; + struct DFA_states *dfas; + struct DFA_trans *tm; int i; - - dfas = (DFA_states *) imalloc( sizeof(DFA_states) ); - assert( dfas ); - dfas->hasharray = (DFA_state **) imalloc( sizeof(DFA_state*) * hash ); - assert( dfas->hasharray ); + + dfas = (struct DFA_states *) imalloc (sizeof(struct DFA_states)); + assert (dfas); + dfas->hasharray = (struct DFA_state **) + imalloc (sizeof(struct DFA_state*) * hash); + assert (dfas->hasharray); *dfasp = dfas; dfas->freelist = dfas->unmarked = dfas->marked = NULL; dfas->statemem = NULL; @@ -39,71 +44,73 @@ int init_DFA_states (DFA_states **dfasp, SetType st, int hash) dfas->st = st; dfas->no = 0; - dfas->transmem = tm = (DFA_trans *) imalloc( sizeof(DFA_trans) ); - assert( tm ); + dfas->transmem = tm = (struct DFA_trans *) + imalloc (sizeof(struct DFA_trans)); + assert (tm); tm->next = NULL; tm->size = TRAN_CHUNK; tm->ptr = 0; - tm->tran_block = (DFA_tran *) imalloc( sizeof(DFA_tran) * tm->size ); - assert( tm->tran_block ); + tm->tran_block = (struct DFA_tran *) + imalloc (sizeof(struct DFA_tran) * tm->size); + assert (tm->tran_block); dfas->sortarray = NULL; - for( i=0; ihash; i++ ) + for (i=0; ihash; i++) dfas->hasharray[i] = NULL; return 0; } -int rm_DFA_states (DFA_states **dfasp) +int rm_DFA_states (struct DFA_states **dfasp) { - DFA_states *dfas = *dfasp; + struct DFA_states *dfas = *dfasp; DFA_stateb *sm, *sm1; - DFA_trans *tm, *tm1; + struct DFA_trans *tm, *tm1; - assert( dfas ); - ifree( dfas->hasharray ); - ifree( dfas->sortarray ); + assert (dfas); + ifree (dfas->hasharray); + ifree (dfas->sortarray); - for( tm=dfas->transmem; tm; tm=tm1 ) + for (tm=dfas->transmem; tm; tm=tm1) { - ifree( tm->tran_block ); + ifree (tm->tran_block); tm1 = tm->next; - ifree( tm ); + ifree (tm); } - for( sm=dfas->statemem; sm; sm=sm1 ) + for (sm=dfas->statemem; sm; sm=sm1) { - ifree( sm->state_block ); + ifree (sm->state_block); sm1 = sm->next; - ifree( sm ); + ifree (sm); } - ifree( dfas ); + ifree (dfas); *dfasp = NULL; return 0; } -int add_DFA_state (DFA_states *dfas, Set *s, DFA_state **sp) +int add_DFA_state (struct DFA_states *dfas, Set *s, struct DFA_state **sp) { int i; - DFA_state *si, **sip; + struct DFA_state *si, **sip; DFA_stateb *sb; - assert( dfas ); - assert( *s ); - sip = dfas->hasharray + (hash_Set( dfas->st, *s ) % dfas->hash); - for( si = *sip; si; si=si->link ) - if( eq_Set( dfas->st, si->set, *s ) ) + assert (dfas); + assert (*s); + sip = dfas->hasharray + (hash_Set (dfas->st, *s) % dfas->hash); + for (si = *sip; si; si=si->link) + if (eq_Set (dfas->st, si->set, *s)) { *sp = si; - *s = rm_Set( dfas->st, *s ); + *s = rm_Set (dfas->st, *s); return 0; } - if( !dfas->freelist ) + if (!dfas->freelist) { - sb = (DFA_stateb *) imalloc( sizeof(*sb) ); + sb = (DFA_stateb *) imalloc (sizeof(*sb)); sb->next = dfas->statemem; dfas->statemem = sb; sb->state_block = si = dfas->freelist = - (DFA_state *) imalloc( sizeof(DFA_state)*DFA_CHUNK); - for( i = 0; inext = si+1; si->next = NULL; } @@ -125,23 +132,26 @@ int add_DFA_state (DFA_states *dfas, Set *s, DFA_state **sp) return 1; } -void add_DFA_tran (DFA_states *dfas, DFA_state *s, int ch0, int ch1, int to) +void add_DFA_tran (struct DFA_states *dfas, struct DFA_state *s, + int ch0, int ch1, int to) { - DFA_trans *tm; - DFA_tran *t; + struct DFA_trans *tm; + struct DFA_tran *t; tm = dfas->transmem; - if( tm->ptr == tm->size ) + if (tm->ptr == tm->size) { - tm = (DFA_trans *) imalloc( sizeof(DFA_trans) ); - assert( tm ); + tm = (struct DFA_trans *) imalloc (sizeof(struct DFA_trans)); + assert (tm); tm->next = dfas->transmem; dfas->transmem = tm; tm->size = s->tran_no >= TRAN_CHUNK ? s->tran_no+8 : TRAN_CHUNK; - tm->tran_block = (DFA_tran *) imalloc( sizeof(DFA_tran) * tm->size ); - assert( tm->tran_block ); - if( s->tran_no ) - memcpy( tm->tran_block, s->trans, s->tran_no*sizeof( DFA_tran ) ); + tm->tran_block = (struct DFA_tran *) + imalloc (sizeof(struct DFA_tran) * tm->size); + assert (tm->tran_block); + if (s->tran_no) + memcpy (tm->tran_block, s->trans, + s->tran_no*sizeof (struct DFA_tran)); tm->ptr = s->tran_no; s->trans = tm->tran_block; } @@ -152,11 +162,11 @@ void add_DFA_tran (DFA_states *dfas, DFA_state *s, int ch0, int ch1, int to) t->to = to; } -DFA_state *get_DFA_state (DFA_states *dfas) +struct DFA_state *get_DFA_state (struct DFA_states *dfas) { - DFA_state *si; - assert( dfas ); - if( !(si = dfas->unmarked) ) + struct DFA_state *si; + assert (dfas); + if (!(si = dfas->unmarked)) return NULL; dfas->unmarked = si->next; si->next = dfas->marked; @@ -166,11 +176,12 @@ DFA_state *get_DFA_state (DFA_states *dfas) return si; } -void sort_DFA_states (DFA_states *dfas) +void sort_DFA_states (struct DFA_states *dfas) { - DFA_state *s; - assert( dfas ); - dfas->sortarray = (DFA_state **) imalloc( sizeof(DFA_state *)*dfas->no ); - for( s = dfas->marked; s; s=s->next ) + struct DFA_state *s; + assert (dfas); + dfas->sortarray = (struct DFA_state **) + imalloc (sizeof(struct DFA_state *)*dfas->no); + for (s = dfas->marked; s; s=s->next) dfas->sortarray[s->no] = s; } -- 1.7.10.4