Analyse LL(k) fonction suivant
Bonjour,
Merci par avance de vos réponse.
Je poste ce message car j'aimerai parler de l'implémentation de la fonction Suivant (Follow) lors de l'analyse du grammaire LL(k). A l'heure actuelle j'ai pas l'impression d'avoir trouvé mon bonheur sur internet donc si quelqu'un à une idée précise de la définition de cette fonction et des raison de son importance (son utilité quoi...).
A l'heure actuelle j'ai cette version de la fonction mais je ne suis pas sur que ce soit correct de la même facon que la grammaire que je parse je ne suis pas sur qu'elle soit légitime:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
typedef struct s_lltab t_lltab;
typedef struct s_llderi t_llderi;
typedef struct s_llterm t_llterm;
/*
** Structure pour la table d'analyse ll,
** Matrice cub de coordonnée x, y, z où
** x définit l'ensemble des terminaux,
** y définit l'ensemble des règles
** et z valeur à la coordonnées [x, y], dérivation de la règle y par x
*/
struct s_lltab
{
int max_x;
int max_y;
int **lltab;
};
/*
** nom de la dérivation
** y index de la regle dérivé
** taille du tableau de dérivation
** table des dérivation
*/
struct s_llderi
{
char *rule;
int y;
size_t d_size;
int *deri;
};
struct s_llterm
{
int i;
char *term;
char *token;
int (*def)(char *token);
};
#include <stddef.h>
#include "libft.h"
extern t_buff g_llderi;
extern t_lltab g_lltab;
extern int g_llpiv;
static void ft_lltab_follow_first(int follow, int first)
{
int x;
x = 0;
while (x < g_lltab.max_x)
{
if (g_lltab.lltab[first][x] != -1)
g_lltab.lltab[follow][x] = g_lltab.lltab[first][x];
x++;
}
}
/*
** Calcule de l'ensemble suivant pour une regle de dérivation donné:
**
** Pour toutes les règles de dérivation, j'itère sur l'ensemble des terminaux
** et non-terminaux de ces règles, si lorsque j'itère je tombe sur la règle de
** dérivation chercher alors si l'ément juste apres est un non terminal je
** l'ajoute au tableau d'analyse. Sinon si l'élément suivant est un
** non terminal j'ajoute l'esemble des premier du non terminal trouvé à la table
** d'analyse.
**
** Sinon si aucune règle de dérivation ne suis la règle trouvé alors j'ajoute
** $ à la table d'analyse
*/
extern int ft_lltab_follow(t_llderi rule, int y, int ind)
{
int i;
size_t j;
int tmp;
t_llderi *llderi;
i = 0;
llderi = (t_llderi *)g_llderi.buff;
while (i < g_llpiv)
{
j = 0;
while (j < llderi[i].d_size)
{
if (llderi[i].deri[j] == rule.y && j < llderi[i].d_size - 1)
{
tmp = llderi[i].deri[j + 1];
if (tmp >= g_llpiv)
g_lltab.lltab[y - 1][tmp - g_llpiv] = ind;
else if (tmp < g_llpiv && tmp != rule.y)
ft_lltab_follow_first(rule.y ,tmp);
tmp = llderi[i].deri[j + 1];
}
else if (llderi[i].deri[j] == rule.y)
{;} // Ajouter $ à suivant
j++;
}
i++;
}
return (1);
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
%%
s_quote d_quote b_quote
alpha space
%%
COMAND :: WORD COMAND
:: QUOTE COMAND
WORD :: ALPHA WORD
:: SPACE WORD
ALPHA :: alpha
:: ε
SPACE :: space
:: ε
QUOTE :: S_QUOTE
:: D_QUOTE
:: B_QUOTE
S_QUOTE :: s_quote WORD D_QUOTE WORD B_QUOTE WORD s_quote
:: ε
D_QUOTE :: d_quote WORD B_QUOTE WORD S_QUOTE WORD d_quote
:: ε
B_QUOTE :: b_quote WORD S_QUOTE WORD D_QUOTE WORD b_quote
%% |
Merci du temps passé. J'aurai vraiment besoin d'aide de ce coté la.
https://fr.wikipedia.org/wiki/Analyse_LL
https://github.com/CallMarl/analyser_ll
