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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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