Some changes to the dfa module.
# 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
* 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
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;
}
int agrep (dfas, fd)
-DFA_states *dfas;
+struct DFA_state **dfas;
int fd;
{
inf_buf = imalloc (sizeof(char)*INF_BUF_SIZE);
inf_flush (fd);
line_no = 1;
- go (fd, dfas->sortarray);
+ go (fd, dfas);
ifree (inf_buf);
return 0;
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
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
{
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;
return 2;
}
fflush(stdout);
+ dfa_delete (&dfa);
return 0;
}
* 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.
*
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;
{
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;
}
}
{
int wsize;
- assert( sh );
+ assert (sh);
*used = 0;
*allocated = 0;
wsize = sh->wsize;
{
*used += sh->offset;
*allocated += sh->chunk;
- } while( (sh = sh->setchain) );
+ } while ((sh = sh->setchain));
return wsize;
}
{
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;
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++;
}
{
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;
}
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;
}
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<<b) )
+ else if (*sw & (1<<b))
return member;
else
{
++member;
--i;
- if( ++b == sizeof(BSetWord)*8 )
+ if (++b == sizeof(BSetWord)*8)
{
b = 0;
++sw;
BSetWord *sw = src+member/(sizeof(BSetWord)*8);
unsigned b = member & (sizeof(BSetWord)*8-1);
while(i >= 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<<b)) == 0 )
+ else if ((*sw & (1<<b)) == 0)
return member;
else
{
++member;
--i;
- if( ++b == sizeof(BSetWord)*8 )
+ if (++b == sizeof(BSetWord)*8)
{
b = 0;
++sw;
void pr_BSet (BSetHandle *sh, BSet src)
{
int i;
- assert( sh );
- assert( src );
- for( i=0; (i=trav_BSet(sh,src,i)) != -1; i++ )
- printf( " %d", i );
- putchar( '\n' );
+ assert (sh);
+ assert (src);
+ for (i=0; (i=trav_BSet(sh,src,i)) != -1; i++)
+ printf (" %d", i);
+ putchar ('\n');
}
void pr_charBSet (BSetHandle *sh, BSet src, void (*f) (int))
{
int i0, i1, i;
- assert( sh );
- assert( src );
- i = trav_BSet( sh, src, 0 );
- while( i != -1 )
+ assert (sh);
+ assert (src);
+ i = trav_BSet (sh, src, 0);
+ while (i != -1)
{
i0 = i;
- if( i == '-' )
- f( '\\' );
+ if (i == '-')
+ f ('\\');
f(i);
- i1 = trav_BSet( sh, src, ++i );
- if( i1 == i )
+ i1 = trav_BSet (sh, src, ++i);
+ if (i1 == i)
{
- while( (i1=trav_BSet( sh, src, ++i )) == i )
+ while ((i1=trav_BSet (sh, src, ++i)) == i)
;
- if( i != i0+2 )
- f( '-' );
- if( i-1 == '-' )
- f( '\\' );
+ if (i != i0+2)
+ f ('-');
+ if (i-1 == '-')
+ f ('\\');
f(i-1);
}
i = i1;
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: grepper.c,v $
- * Revision 1.3 1994-10-04 17:46:43 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/10/04 17:46:43 adam
* Function options now returns arg with error option.
*
* Revision 1.2 1994/10/03 17:22:18 adam
return m[mc->n * ch + wno] & (1<<off);
}
-static MatchContext *mk_MatchContext (DFA_states *dfas, int range)
+static MatchContext *mk_MatchContext (struct DFA *dfa, int range)
{
MatchContext *mc = imalloc (sizeof(*mc));
int i;
- mc->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; i<dfas->no; i++)
+ for (i=0; i<dfa->no_states; i++)
{
int j;
- DFA_state *state = dfas->sortarray[i];
+ struct DFA_state *state = dfa->states[i];
for (j=0; j<state->tran_no; j++)
{
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;
{
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] &&
}
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] &&
}
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] &&
}
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] &&
}
}
s += 4;
- if (s >= dfas->no)
+ if (s >= dfa->no_states)
return;
mask >>= 4;
}
}
static void shift (MatchContext *mc, MatchWord *Rdst, MatchWord *Rsrc,
- DFA_states *dfas)
+ struct DFA *dfa)
{
int j, s = 0;
MatchWord *Rsrc_p = Rsrc, mask;
{
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;
}
}
-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;
{
int s;
memcpy (Rj + mc->n * d, Rj + mc->n * (d-1), mc->n * sizeof(*Rj));
- for (s = 0; s<dfas->no; s++)
+ for (s = 0; s<dfa->no_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);
}
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; s<dfas->no; s++)
+ for (s = 0; s<dfa->no_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;
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;
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);
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)
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')
}
else if (no_files == 0)
{
- grep_file (dfas, NULL, range);
+ grep_file (dfa, NULL, range);
}
+ dfa_delete (&dfa);
return 0;
}
* 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
int main (int argc, char **argv)
{
int i, no = 0;
- DFA *dfa;
- DFA_states *dfas;
+ struct DFA *dfa;
prog = *argv;
#ifdef YACC
#else
alexdebug = 0;
#endif
+ dfa = dfa_init ();
i = lexer_options (argc, argv);
if (i)
return i;
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
* 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;
* 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
static void
prep (char **s),
read_defs (void),
- read_rules (DFA **dfap),
+ read_rules (struct DFA *dfap),
read_tail (void);
static char
const char *src = *s;
int c;
- while( (c = *src++) )
+ while ((c = *src++))
*dst++ = c;
*dst = '\0';
{
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;
}
* 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.
*
{
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;
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;
}
{
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;
}
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--;
Set s1 = s;
int i = 1;
- if( s )
+ if (s)
{
- while( s->next )
+ while (s->next)
{
s = s->next;
++i;
s->next = st->freelist;
st->freelist = s1;
st->used -= i;
- assert( st->used >= 0 );
+ assert (st->used >= 0);
}
return NULL;
}
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;
}
{
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
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;
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;
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;
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;
}
* 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.
*
#include <string.h>
#include <util.h>
-#include <dfa.h>
+#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;
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; i<dfas->hash; i++ )
+ for (i=0; i<dfas->hash; 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; i<DFA_CHUNK-1; i++, si++ )
+ (struct DFA_state *) imalloc (sizeof(struct DFA_state)*DFA_CHUNK);
+ for (i = 0; i<DFA_CHUNK-1; i++, si++)
si->next = si+1;
si->next = NULL;
}
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;
}
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;
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;
}
projects / idzebra-moved-to-github.git / commitdiff