From 4f1420ed31e56d5ee7447467d6dbedffb75bc927 Mon Sep 17 00:00:00 2001 From: Antoine Fraboulet <antoine.fraboulet@free.fr> Date: Sat, 9 Apr 2005 19:16:09 +0000 Subject: [PATCH] - minor dictionary .h changes - starting integrating regexp into eliot --- dic/Makefile.am | 26 +++++++++-- dic/automaton.c | 30 +++++++------ dic/automaton.h | 12 ++--- dic/dic.h | 4 +- dic/dic_search.c | 113 +++++++++++++++++++++++++++++------------------ dic/dic_search.h | 10 +++-- dic/er.l | 24 ++++++++++ dic/er.y | 81 +++++++++++++++++++++++++++++++++ dic/regexp.c | 83 +++++++++------------------------- dic/regexp.h | 15 ++++++- dic/regexpmain.c | 73 ++++++++++++++++++++++++++++++ 11 files changed, 337 insertions(+), 134 deletions(-) create mode 100644 dic/er.l create mode 100644 dic/er.y create mode 100644 dic/regexpmain.c diff --git a/dic/Makefile.am b/dic/Makefile.am index 0bd0d10..e12632a 100644 --- a/dic/Makefile.am +++ b/dic/Makefile.am @@ -16,12 +16,12 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# $Id: Makefile.am,v 1.4 2005/04/03 21:12:03 ipkiss Exp $ - -bin_PROGRAMS = compdic listdic +# $Id: Makefile.am,v 1.5 2005/04/09 19:16:09 afrab Exp $ noinst_LIBRARIES = libdic.a +INCLUDES = -I$(top_srcdir) + libdic_a_SOURCES = \ dic_internals.h \ dic_search.c dic_search.h \ @@ -29,6 +29,15 @@ libdic_a_SOURCES = \ automaton.c automaton.h \ regexp.c regexp.h +##################################### +# if BUILD_DICTOOLS +# automake does not support regexp_YFLAGS being defined conditionally + +bin_PROGRAMS = \ + compdic \ + listdic \ + regexp + compdic_SOURCES= \ dic_internals.h \ hashtable.c hashtble.h \ @@ -39,3 +48,14 @@ listdic_SOURCES= \ dic.c dic.h \ listdic.c +regexp_YFLAGS=-d +regexp_CFLAGS=${REGEXP_FLAGS} + +regexp_SOURCES= \ + regexpmain.c \ + regexp.c regexp.h \ + automaton.h automaton.c \ + er.y \ + er.l + +# endif diff --git a/dic/automaton.c b/dic/automaton.c index eb44dfa..0583502 100644 --- a/dic/automaton.c +++ b/dic/automaton.c @@ -16,8 +16,9 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* - * $Id: automaton.c,v 1.3 2005/02/05 11:14:56 ipkiss Exp $ + * $Id: automaton.c,v 1.4 2005/04/09 19:16:09 afrab Exp $ */ +#include "config.h" #include <string.h> #include <stdlib.h> #include <stdio.h> @@ -30,15 +31,19 @@ #ifndef PDBG #ifdef DEBUG -# define PDBG(x) { x ; } +# define PDBG(s...) { printf(s); } #else -# define PDBG(x) { } +# define PDBG(s...) { } #endif #endif -int -automaton_build(automaton* aa, int init_state, int *ptl, int *PS) +automaton +automaton_build(int init_state, int *ptl, int *PS) { + /* int init_state; */ + /* int *ptl; // mapping postition -> lettre */ + /* int *PS; // Position Suivante [ 1 << (position-1)] = \cup { 1 << (p-1) | p \in position accept�e } */ + int i,l,pos,letter,ens; int state,plist; int *state_list; @@ -46,7 +51,6 @@ automaton_build(automaton* aa, int init_state, int *ptl, int *PS) automaton a; a = (automaton)malloc(sizeof(struct _automaton)); - *aa = a; a->nterm = PS[0]; a->nstate = 1; @@ -68,7 +72,7 @@ automaton_build(automaton* aa, int init_state, int *ptl, int *PS) while (plist) { state = state_list[--plist]; - PDBG(printf("** traitement �tat 0x%08x\n",state)); + PDBG("** traitement �tat 0x%08x\n",state); memset(used_letter,0,sizeof(used_letter)); /* 3: \foreach l in \sigma | l \neq # */ for(l=1; l < PS[0]; l++) @@ -88,7 +92,7 @@ automaton_build(automaton* aa, int init_state, int *ptl, int *PS) { state_list[plist++] = ens; a->Dtrans[state][letter] = ens; - PDBG(printf(" adding %x -%c> %x (queue %x)\n",state,letter,ens,ens)); + PDBG(" adding %x -%c> %x (queue %x)\n",state,letter,ens,ens); if (ens != state) { a->nstate = a->nstate + 1; @@ -98,7 +102,7 @@ automaton_build(automaton* aa, int init_state, int *ptl, int *PS) if (ens && a->marque[ens] == 1) { a->Dtrans[state][letter] = ens; - PDBG(printf(" adding %x -%c> %x\n",state,letter,ens)); + PDBG(" adding %x -%c> %x\n",state,letter,ens); } a->marque[state] = 1; used_letter[letter] = 1; @@ -106,19 +110,19 @@ automaton_build(automaton* aa, int init_state, int *ptl, int *PS) } } - PDBG(printf("** accept : ")); + PDBG("** accept : "); for(i=0; i < (1 << PS[0]); i++) { if (a->marque[i] && (i & (1 << (PS[0] - 1)))) { a->accept[i] = 1; - PDBG(printf("%x ",i)); + PDBG("%x ",i); } } - PDBG(printf("\n")); + PDBG("\n"); free(state_list); - return 0; + return a; } ////////////////////////////////////////////////// diff --git a/dic/automaton.h b/dic/automaton.h index a5b037e..af0d44c 100644 --- a/dic/automaton.h +++ b/dic/automaton.h @@ -16,7 +16,7 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* - * $Id: automaton.h,v 1.2 2005/03/29 08:22:55 afrab Exp $ + * $Id: automaton.h,v 1.3 2005/04/09 19:16:09 afrab Exp $ */ #ifndef _DIC_AUTOMATON_H_ @@ -26,15 +26,15 @@ struct _automaton { int nterm; int nstate; int init; - int **Dtrans; - int *accept; + int **Dtrans; + int *accept; int *marque; }; typedef struct _automaton* automaton; -int automaton_build (automaton *a, int init_state, int *ptl, int *PS); -void automaton_delete(automaton a); -void automaton_dump (automaton a, char* filename); +automaton automaton_build (int init_state, int *ptl, int *PS); +void automaton_delete(automaton a); +void automaton_dump (automaton a, char* filename); #endif diff --git a/dic/dic.h b/dic/dic.h index 265c76b..fd32a98 100644 --- a/dic/dic.h +++ b/dic/dic.h @@ -16,7 +16,7 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* $Id: dic.h,v 1.2 2004/08/07 18:10:42 ipkiss Exp $ */ +/* $Id: dic.h,v 1.3 2005/04/09 19:16:09 afrab Exp $ */ /*! * \file dic.h @@ -35,8 +35,6 @@ extern "C" { #endif -#define LETTERS 27 - typedef struct _Dictionary* Dictionary; typedef unsigned int uint_t; diff --git a/dic/dic_search.c b/dic/dic_search.c index ec438b7..c64d486 100644 --- a/dic/dic_search.c +++ b/dic/dic_search.c @@ -16,7 +16,7 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* - * $Id: dic_search.c,v 1.4 2005/02/05 11:14:56 ipkiss Exp $ + * $Id: dic_search.c,v 1.5 2005/04/09 19:16:09 afrab Exp $ */ #include <ctype.h> @@ -26,6 +26,8 @@ #include "dic_internals.h" #include "dic.h" #include "dic_search.h" + +#include "regexp.h" #include "automaton.h" /****************************************/ @@ -77,7 +79,7 @@ struct params_7plus1_t { int search_wordlistlen; int search_wordlistlenmax; char search_wordtst[DIC_WORD_MAX]; - char search_letters[LETTERS]; + char search_letters[DIC_LETTERS]; char (*search_wordlist)[RES_7PL1_MAX][DIC_WORD_MAX]; }; @@ -138,7 +140,7 @@ Dic_search_word_by_len(struct params_7plus1_t *params, int i, Dawg_edge *edgeptr void Dic_search_7pl1(const Dictionary dic, const char* rack, - char buff[LETTERS][RES_7PL1_MAX][DIC_WORD_MAX], + char buff[DIC_LETTERS][RES_7PL1_MAX][DIC_WORD_MAX], int joker) { int i,j,wordlen; @@ -146,11 +148,11 @@ Dic_search_7pl1(const Dictionary dic, const char* rack, struct params_7plus1_t params; Dawg_edge *root_edge; - for(i=0; i < LETTERS; i++) + for(i=0; i < DIC_LETTERS; i++) for(j=0; j < RES_7PL1_MAX; j++) buff[i][j][0] = '\0'; - for(i=0; i<LETTERS; i++) + for(i=0; i<DIC_LETTERS; i++) params.search_letters[i] = 0; if (dic == NULL || rack == NULL) @@ -397,51 +399,59 @@ struct params_regexp_t { }; void -Dic_search_regexp_rec(struct params_regexp_t *params, char wordlist[RES_CROS_MAX][DIC_WORD_MAX], Dawg_edge *edgeptr, int state) +Dic_search_regexp_rec(struct params_regexp_t *params, + char wordlist[RES_CROS_MAX][DIC_WORD_MAX], + Dawg_edge *edgeptr, int state) { + /* // Dawg_edge *current = params->dic->dawg + edgeptr->ptr; -/* // fin du motif et fin de mot */ -/* if (params->mask[params->wordlen] == '\0' && edgeptr->term) */ -/* { */ -/* if (params->wordlistlen < params->wordlistlenmax) */ -/* strcpy(wordlist[params->wordlistlen++],params->mask); */ -/* } */ -/* // n'importe quel char */ -/* else if (params->mask[params->wordlen] == '.') */ -/* { */ -/* do */ -/* { */ -/* params->mask[params->wordlen] = current->chr + 'a' - 1; */ -/* params->wordlen ++; */ -/* Dic_search_regexp_rec(params,wordlist,current, ??); */ -/* params->wordlen --; */ -/* params->mask[params->wordlen] = '.'; */ -/* } */ -/* while (!(*current++).last); */ -/* } */ -/* // une lettre dans le motif */ -/* else */ -/* { */ -/* do */ -/* { */ -/* if (current->chr == (params->mask[params->wordlen] & CHAR)) */ -/* { */ -/* params->wordlen ++; */ -/* Dic_search_cross_rec(params,wordlist,current); */ -/* params->wordlen --; */ -/* break; */ -/* } */ -/* } */ -/* while (!(*current++).last); */ -/* } */ + // fin du motif et fin de mot + if (params->mask[params->wordlen] == '\0' && edgeptr->term) + { + if (params->wordlistlen < params->wordlistlenmax) + strcpy(wordlist[params->wordlistlen++],params->mask); + } + // n'importe quel char + else if (params->mask[params->wordlen] == '.') + { + do + { + params->mask[params->wordlen] = current->chr + 'a' - 1; + params->wordlen ++; + Dic_search_regexp_rec(params,wordlist,current, ??); + params->wordlen --; + params->mask[params->wordlen] = '.'; + } + while (!(*current++).last); + } + // une lettre dans le motif + else + { + do + { + if (current->chr == (params->mask[params->wordlen] & CHAR)) + { + params->wordlen ++; + Dic_search_cross_rec(params,wordlist,current); + params->wordlen --; + break; + } + } + while (!(*current++).last); + } + */ } void Dic_search_RegE(const Dictionary dic, const char* mask, char wordlist[RES_REGE_MAX][DIC_WORD_MAX]) { - int i; + int i,p,n; struct params_regexp_t params; + + int ptl[REGEXP_MAX+1]; // mapping postition -> lettre + int PS [REGEXP_MAX+1]; // Position Suivante [ 1 << (position-1)] = \cup { 1 << (p-1) | p \in position accept�e } + automaton a = NULL; for(i=0; i < RES_REGE_MAX; i++) @@ -450,8 +460,22 @@ Dic_search_RegE(const Dictionary dic, const char* mask, if (dic == NULL || mask == NULL) return; -/* if (automaton_build(&a,"")) */ -/* return; */ + /* + * we stop here right now + + if ((root = regexp_parse(mask)) == NULL) + return; + + n = 1; + p = 1; + regexp_parcours(root,&p,&n,ptl); + PS [0] = p - 1; + ptl[0] = p - 1; + + regexp_possuivante(root,PS); + + if ((a = automaton_build()) == NULL) + return; params.dic = dic; params.wordlen = 0; @@ -459,6 +483,9 @@ Dic_search_RegE(const Dictionary dic, const char* mask, params.wordlistlenmax = RES_REGE_MAX; params.er_automaton = a; Dic_search_regexp_rec(¶ms, wordlist, dic->dawg + dic->root, 0); + + automaton_delete(a); + */ } /****************************************/ diff --git a/dic/dic_search.h b/dic/dic_search.h index f025697..a3bca39 100644 --- a/dic/dic_search.h +++ b/dic/dic_search.h @@ -16,7 +16,7 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* $Id: dic_search.h,v 1.3 2005/02/05 11:14:56 ipkiss Exp $ */ +/* $Id: dic_search.h,v 1.4 2005/04/09 19:16:09 afrab Exp $ */ #ifndef _DIC_SEARCH_H_ #define _DIC_SEARCH_H_ @@ -26,7 +26,9 @@ extern "C" { #endif -#define DIC_WORD_MAX 16 +#define DIC_LETTERS 27 // different letters in the dictionary +#define DIC_WORD_MAX 16 // max length of words (including last \0) + #define RES_7PL1_MAX 200 #define RES_RACC_MAX 100 #define RES_BENJ_MAX 100 @@ -34,11 +36,11 @@ extern "C" #define RES_REGE_MAX 200 int Dic_search_word(Dictionary, const char*); -void Dic_search_7pl1(Dictionary, const char* rack, char wordlist[LETTERS][RES_7PL1_MAX][DIC_WORD_MAX], int joker); +void Dic_search_7pl1(Dictionary, const char* rack, char wordlist[DIC_LETTERS][RES_7PL1_MAX][DIC_WORD_MAX], int joker); void Dic_search_Racc(Dictionary, const char* word, char wordlist[RES_RACC_MAX][DIC_WORD_MAX]); void Dic_search_Benj(Dictionary, const char* word, char wordlist[RES_BENJ_MAX][DIC_WORD_MAX]); void Dic_search_Cros(Dictionary, const char* mask, char wordlist[RES_CROS_MAX][DIC_WORD_MAX]); -void Dic_search_RegE(Dictionary, const char* mask, char wordlist[RES_CROS_MAX][DIC_WORD_MAX]); +void Dic_search_RegE(Dictionary, const char* mask, char wordlist[RES_REGE_MAX][DIC_WORD_MAX]); #if defined(__cplusplus) } diff --git a/dic/er.l b/dic/er.l new file mode 100644 index 0000000..8879948 --- /dev/null +++ b/dic/er.l @@ -0,0 +1,24 @@ +%{ + +#include "regexp.h" +#include "regexp-er.h" + +#define YY_NO_UNPUT + +%} +%option noyywrap + +alphabet [a-zA-Z] +%% + +{alphabet} {yylval.variable = yytext[0]; return VARIABLE;} +"(" {return PAR_G;} +")" {return PAR_D;} +"#" {return DIESE;} +"*" {return STAR;} +"+" {return OR;} +"." {return AND;} + +"\n" {return FIN;} +%% + diff --git a/dic/er.y b/dic/er.y new file mode 100644 index 0000000..ecf9e99 --- /dev/null +++ b/dic/er.y @@ -0,0 +1,81 @@ +%{ +#include <stdio.h> +#include <malloc.h> +#include <stdlib.h> +#include "regexp.h" + +int yylex(); +void yyerror(char*); + +NODE *createNODE(int type, char v, NODE *fg, NODE *fd); + +%} +%union { + char variable; + NODE *NODE_TYPE; +}; + +%token DIESE PAR_G PAR_D FIN +%token <variable> VARIABLE +%left OR +%left AND +%left STAR +%type <NODE_TYPE> var +%type <NODE_TYPE> expr +%start start +%% + +/* start : ex ex */ +/* { root=createNODE(NODE_TOP,'\0',$1,$2); YYACCEPT; } */ +/* ; */ + +start: expr FIN + { root = createNODE(NODE_AND,'\0',$1,createNODE(NODE_VAR,'#',NULL,NULL)); YYACCEPT; } + ; + +expr : var {$$=$1;} + | expr expr {$$=createNODE(NODE_AND,'\0',$1,$2);} + | expr AND expr {$$=createNODE(NODE_AND,'\0',$1,$3);} + | PAR_G expr PAR_D {$$=$2;} + | expr OR expr {$$=createNODE(NODE_OR,'\0',$1,$3);} + | var STAR {$$=createNODE(NODE_STAR,'\0',$1,NULL);} + | PAR_G expr PAR_D STAR {$$=createNODE(NODE_STAR,'\0',$2,NULL);} + ; + +var : VARIABLE + {$$=createNODE(NODE_VAR,$1,NULL,NULL);} + ; + +%% +/*-------------------------------------------------------- + * FONCTIONS LEX/YACC + *--------------------------------------------------------*/ + +void yyerror(char *s) +{ + printf("\n erreur ! (%s)\n",s); + exit(1); +} + +/*-------------------------------------------------------- + * + *--------------------------------------------------------*/ +NODE *createNODE(int type,char v,NODE *fg,NODE *fd) +{ + NODE *x; + x=(NODE *)malloc(sizeof(NODE)); + + x->type = type; + x->var = v; + x->fd = fd; + x->fg = fg; + + x->numero = 0; + x->position = 0; + x->annulable = 0; + x->PP = 0; + x->DP = 0; + return (x); +} + + diff --git a/dic/regexp.c b/dic/regexp.c index 2f77443..4283768 100644 --- a/dic/regexp.c +++ b/dic/regexp.c @@ -16,15 +16,20 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* - * $Id: regexp.c,v 1.1 2004/06/21 16:06:54 afrab Exp $ + * $Id: regexp.c,v 1.2 2005/04/09 19:16:09 afrab Exp $ */ +#include "config.h" #include <stdio.h> #include <stdlib.h> #include <string.h> +#ifdef HAVE_SYS_WAIT_H +# include <sys/wait.h> +#endif +#include <unistd.h> + #include "regexp.h" #include "automaton.h" -#define MAX 32 #ifndef PDBG #ifdef DEBUG @@ -34,6 +39,8 @@ #endif #endif +static void print_node(NODE *n); + ////////////////////////////////////////////////// // position, annulable, PP, DP // r = root @@ -42,13 +49,13 @@ // ptl = position to letter ////////////////////////////////////////////////// -void parcours(NODE* r, int *p, int *n, int ptl[]) +void regexp_parcours(NODE* r, int *p, int *n, int ptl[]) { if (r == NULL) return; - parcours(r->fg,p,n,ptl); - parcours(r->fd,p,n,ptl); + regexp_parcours(r->fg,p,n,ptl); + regexp_parcours(r->fd,p,n,ptl); switch (r->type) { @@ -91,14 +98,14 @@ void parcours(NODE* r, int *p, int *n, int ptl[]) // PosSuivante ////////////////////////////////////////////////// -void possuivante(NODE* r, int PS[]) +void regexp_possuivante(NODE* r, int PS[]) { int pos; if (r == NULL) return; - possuivante(r->fg,PS); - possuivante(r->fd,PS); + regexp_possuivante(r->fg,PS); + regexp_possuivante(r->fd,PS); switch (r->type) { @@ -122,8 +129,7 @@ void possuivante(NODE* r, int PS[]) ////////////////////////////////////////////////// ////////////////////////////////////////////////// -#if 0 -void print_node(NODE *n) +static void print_node(NODE *n) { if (n == NULL) return; @@ -151,7 +157,7 @@ void print_node(NODE *n) ////////////////////////////////////////////////// ////////////////////////////////////////////////// -void print_PS(int PS[]) +void regexp_print_PS(int PS[]) { int i; printf("** positions suivantes **\n"); @@ -164,7 +170,7 @@ void print_PS(int PS[]) ////////////////////////////////////////////////// ////////////////////////////////////////////////// -void print_ptl(int ptl[]) +void regexp_print_ptl(int ptl[]) { int i; printf("** pos -> lettre: "); @@ -178,7 +184,7 @@ void print_ptl(int ptl[]) ////////////////////////////////////////////////// ////////////////////////////////////////////////// -void print_tree_nodes(FILE* f, NODE* n) +static void print_tree_nodes(FILE* f, NODE* n) { if (n == NULL) return; @@ -205,7 +211,7 @@ void print_tree_nodes(FILE* f, NODE* n) fprintf(f,"\\n annulable=%d\\n PP=0x%08x\\n DP=0x%08x\"];\n",n->annulable,n->PP,n->DP); } -void print_tree_edges(FILE* f, NODE* n) +static void print_tree_edges(FILE* f, NODE* n) { if (n == NULL) return; @@ -229,7 +235,7 @@ void print_tree_edges(FILE* f, NODE* n) } } -void print_tree(NODE* n) +void regexp_print_tree(NODE* n) { FILE* f; pid_t pid; @@ -243,6 +249,7 @@ void print_tree(NODE* n) fprintf(f,"}\n"); fclose(f); +#ifdef HAVE_SYS_WAIT_H pid = fork (); if (pid > 0) { wait(NULL); @@ -251,52 +258,6 @@ void print_tree(NODE* n) printf("exec dotty failed\n"); exit(1); } -} #endif -////////////////////////////////////////////////// -////////////////////////////////////////////////// -#if 0 -int main(int argc, char* argv[]) -{ - int i,p,n; - int ptl[MAX+1]; // mapping postition -> lettre - int PS [MAX+1]; // Position Suivante [ 1 << (position-1)] = \cup { 1 << (p-1) | p \in position accept�e } - automaton a,b; - - for(i=0; i < MAX; i++) - { - PS[i] = 0; - ptl[i] = 0; - } - - yyparse(); - - n = 1; - p = 1; - parcours(root,&p,&n,ptl); - PS [0] = p - 1; - ptl[0] = p - 1; - PDBG(printf("** regexp: nombre de terminaux: %d\n",PS[0])); - PDBG(printf("** regexp: nombre de noeuds dans l'arbre: %d\n",n)); - PDBG(print_ptl(ptl)); - - possuivante(root,PS); - PDBG(print_tree(root)); - PDBG(print_PS(PS)); - - automaton_build(&a,root->PP,ptl,PS); - PDBG(printf("** auto: nombre d'�tats: %d\n",a.nstate)); - print_automaton(&a); - - automaton_minimize(&a,&b); - PDBG(printf("** auto: nombre d'�tats: %d\n",b.nstate)); - PDBG(print_automaton(&b)); - - automaton_destroy(&a); - automaton_destroy(&b); - return 0; } -#endif -////////////////////////////////////////////////// -////////////////////////////////////////////////// diff --git a/dic/regexp.h b/dic/regexp.h index 769738a..1246f9c 100644 --- a/dic/regexp.h +++ b/dic/regexp.h @@ -16,7 +16,7 @@ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* - * $Id: regexp.h,v 1.1 2004/06/20 20:13:59 afrab Exp $ + * $Id: regexp.h,v 1.2 2005/04/09 19:16:09 afrab Exp $ */ #ifndef _TREE_H_ #define _TREE_H_ @@ -40,6 +40,19 @@ typedef struct node { int DP; } NODE; +extern NODE* root; + +/* max regexp length */ +#define REGEXP_MAX 32 + +void regexp_parcours(NODE* r, int *p, int *n, int ptl[]); +void regexp_possuivante(NODE* r, int PS[]); + +void regexp_print_PS(int PS[]); +void regexp_print_ptl(int ptl[]); +void regexp_print_tree(NODE* n); + + #endif diff --git a/dic/regexpmain.c b/dic/regexpmain.c new file mode 100644 index 0000000..052984c --- /dev/null +++ b/dic/regexpmain.c @@ -0,0 +1,73 @@ +/* Eliot */ +/* Copyright (C) 1999 antoine.fraboulet */ +/* antoine.fraboulet@free.fr */ +/* */ +/* This program 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 of the License, or */ +/* (at your option) any later version. */ +/* */ +/* This program 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +/* + * $Id: regexpmain.c,v 1.1 2005/04/09 19:16:09 afrab Exp $ + */ +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "regexp.h" +#include "automaton.h" + +#ifndef PDBG +#ifdef DEBUG +#define PDBG(x) { x ; } +#else +#define PDBG(x) { } +#endif +#endif + +NODE* root; + +int main(int argc, char* argv[]) +{ + int i,p,n; + int ptl[REGEXP_MAX+1]; // mapping postition -> lettre + int PS [REGEXP_MAX+1]; // Position Suivante [ 1 << (position-1)] = \cup { 1 << (p-1) | p \in position accept�e } + automaton a; + + for(i=0; i < REGEXP_MAX; i++) + { + PS[i] = 0; + ptl[i] = 0; + } + + yyparse(argv[1]); + + n = 1; + p = 1; + regexp_parcours(root,&p,&n,ptl); + PS [0] = p - 1; + ptl[0] = p - 1; + PDBG(printf("** regexp: nombre de terminaux: %d\n",PS[0])); + PDBG(printf("** regexp: nombre de noeuds dans l'arbre: %d\n",n)); + PDBG(regexp_print_ptl(ptl)); + + regexp_possuivante(root,PS); + PDBG(regexp_print_tree(root)); + PDBG(regexp_print_PS(PS)); + + a = automaton_build(root->PP,ptl,PS); + PDBG(printf("** auto: nombre d'�tats: %d\n",a->nstate)); + automaton_dump(a,"regexp.auto"); + + automaton_delete(a); + return 0; +}