-/*
- * Copyright (C) 1994, Index Data I/S
- * All rights reserved.
- * Sebastian Hammer, Adam Dickmeiss
- *
- * $Log: grepper.c,v $
- * 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
- * Optimization of grepper.
- *
- * Revision 1.1 1994/09/27 16:31:18 adam
- * First version of grepper: grep with error correction.
- *
- */
+/* This file is part of the Zebra server.
+ Copyright (C) Index Data
+
+Zebra is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+*/
+
+
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
-#include <util.h>
+#include <idzebra/util.h>
+#include <yaz/yaz-util.h>
#include <dfa.h>
#include "imalloc.h"
#define INFBUF_SIZE 16384
-#define INLINE
+#define INLINE
static INLINE void set_bit (MatchContext *mc, MatchWord *m, int ch, int state)
{
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++)
{
int ch0 = state->trans[j].ch[0];
int ch1 = state->trans[j].ch[1];
assert (ch0 >= 0 && ch1 >= 0);
-
+
for (ch = ch0; ch <= ch1; ch++)
set_bit (mc, mc->Sc, ch, i);
}
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);
while ((ch = getc (inf)) != EOF)
{
MatchWord *Rj_t;
-
+
infbuf[inf_ptr] = ch;
if (ch == '\n')
{
}
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;
inf = fopen (fname, "r");
if (!inf)
{
- log (LOG_FATAL|LOG_ERRNO, "cannot open `%s'", fname);
+ yaz_log (YLOG_FATAL|YLOG_ERRNO, "cannot open `%s'", fname);
exit (1);
}
}
else
inf = stdin;
-
- mc = mk_MatchContext (dfas, range);
- go (mc, dfas, inf);
+ mc = mk_MatchContext (dfa, range);
+
+ go (mc, dfa, inf);
if (fname)
fclose (inf);
int ret;
int range = 0;
char *arg;
- char *pattern = NULL;
- DFA_states *dfas = NULL;
+ const char *pattern = 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')
{
- log_init (log_mask_str(arg), prog, NULL);
+ yaz_log_init (yaz_log_mask_str(arg), prog, NULL);
}
else if (ret == 's')
{
}
else
{
- log (LOG_FATAL, "Unknown option '-%s'", arg);
+ yaz_log (YLOG_FATAL, "Unknown option '-%s'", arg);
exit (1);
}
}
}
else if (no_files == 0)
{
- grep_file (dfas, NULL, range);
+ grep_file (dfa, NULL, range);
}
+ dfa_delete (&dfa);
return 0;
}
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+
projects / idzebra-moved-to-github.git / blobdiff