Développement d’un analyseur lexical

Version imprimable

23/04/2016, 03h04
max_123

1 pièce(s) jointe(s)

Développement d’un analyseur lexical

Bonsoir
j'ai trouvé un probléme qui traite le développement d'un analyseur lexical mais j'ai pas trouvé la solution sur le forum
voici le mini projet :
http://www.developpez.net/forums/att...utomates.docx/
j'ai trouvé des difficultés alors s'il est possible que qq a la solution le publier
merci.
23/04/2016, 07h25
ternel

Bonjour.
A priori, nous n'avons pas la solution. Et de toute façon, notre charte est claire sur ce point: relis son article IV-N

Par contre, si tu as des questions précises, nous serons heureux d'y réfléchir avec toi.
23/04/2016, 11h36
max_123

2 pièce(s) jointe(s)

bonjour
j'ai un probléme a comprendre totallement le concept de ce analyseur, par exemple c'est quoi l'affichage a la sortie du compilation ? comment est il le syntaxe d'un mot appartient a cette gramaire ? s'il est possible m'indiquer un exemple d'input et output
mercii

voici 2 exemples d'automate que j'ai essayé , la 1(simple) est recursive
quelle est la plus logic des ces 2 ? (pieces jointe)
merci .
23/04/2016, 13h45
ternel

Je ne peux pas ouvrir ton document, mais ta question est plus fondamentale.

Un analyseur syntaxique est un (morceau d'un) programme qui lit un fichier texte, telle qu'un .c ou un .xml, et en fait deux choses.

La première est de vérifier que le contenu est une suite valide de caractères, c'est à dire que chaque mot ou signe du fichier est acceptable (par exemple, dans le cas du c, a@2 n'est pas valide)
Une fois cette étape terminée, on a une suite de "tokens", c'est à dire de mots avec une première idée de ce dont il s'agit (identifier, symbole, constante numérique, constante de texte).
Ainsi, int i = 2; n'est plus la suite de dix caractères arbitraires (i, n, t, ...) mais de mots du langage: identifier:int, identifier:i, operator:=, integer:2, symbole:;

Ce travail terminé, l'analyseur vérifie que la syntaxe de cette chaine est correcte.
c'est à dire qu'il respecte un certain nombre de règle qui définissent la syntaxe.

La suite du travail sera probablement de constituer un "arbre syntaxique abstrait" (ou abstract syntaxic tree noté AST). Mais ca n'est plus forcément l'analyse syntaxique.
Dans la phase suivante de la compilation, l'analyse sémantique, cet arbre permettra de vérifier le sens du code, en cherchant par exemple si une variable n'est pas définie à temps.

Puis par la suite, il permettra de faire un certain nombre de préoptimisation, avant de compiler effectivement.

En général, pour tester l'analyse syntaxique, on réalise un programme qui lit un code source, le vérifie, et le réécrit en faisant une belle indentation.
23/04/2016, 14h00
max_123

merci pour cette information , j'ai postulé 2 automates ci de dessus lequels est le plus logic ? j'ai compris qu'il est necessaire de modeliser le probléme par une automate ,une fois l'automate est validé j'ai pas un probléme avec l'implémentation C , juste je voulais savoir l'automate correct qui modélise ce probléme sachant que le code est contenu dans un fichier txt

Citation:

Envoyé par leternel

Je ne peux pas ouvrir ton document, mais ta question est plus fondamentale.

Un analyseur syntaxique est un (morceau d'un) programme qui lit un fichier texte, telle qu'un .c ou un .xml, et en fait deux choses.

La première est de vérifier que le contenu est une suite valide de caractères, c'est à dire que chaque mot ou signe du fichier est acceptable (par exemple, dans le cas du c, a@2 n'est pas valide)
Une fois cette étape terminée, on a une suite de "tokens", c'est à dire de mots avec une première idée de ce dont il s'agit (identifier, symbole, constante numérique, constante de texte).
Ainsi, int i = 2; n'est plus la suite de dix caractères arbitraires (i, n, t, ...) mais de mots du langage: identifier:int, identifier:i, operator:=, integer:2, symbole:;

Ce travail terminé, l'analyseur vérifie que la syntaxe de cette chaine est correcte.
c'est à dire qu'il respecte un certain nombre de règle qui définissent la syntaxe.

La suite du travail sera probablement de constituer un "arbre syntaxique abstrait" (ou abstract syntaxic tree noté AST). Mais ca n'est plus forcément l'analyse syntaxique.
Dans la phase suivante de la compilation, l'analyse sémantique, cet arbre permettra de vérifier le sens du code, en cherchant par exemple si une variable n'est pas définie à temps.

Puis par la suite, il permettra de faire un certain nombre de préoptimisation, avant de compiler effectivement.

En général, pour tester l'analyse syntaxique, on réalise un programme qui lit un code source, le vérifie, et le réécrit en faisant une belle indentation.

Bonsoir !
voila j'ai essayé de resoudre le probléme mais j'ai un probléme dans le code ci dessous
j'arrive pas a afficher le resultat ,quand je compile le program n'affiche rien , un peu d'aide svp ??

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void reculer(FILE* fich);
char* Anal_lex(FILE *fich);
int main()
{
    FILE *ficEntree;
    ficEntree=fopen("test.txt","r") ;
    Anal_lex(ficEntree) ;
 
}
 
void reculer(FILE* fich)
  {  fseek(fich,-1,1);            //reculer de la position courante de -1
   return (fich);     }
char* Anal_lex(FILE *fich)            //fonction analyseur lexicale
      {    int beta ;
           char c,*ch,*val,*T[7][20];
             ch=malloc(10*sizeof(char));
             val=malloc(10*sizeof(char));
             int etat=0;
             int w=0;
             int aux=-1;
             int j=1;
             int i=0;
             //les mots clé du language
             strcpy(T[0],"fin");
             strcpy(T[1],"ecrire");
             strcpy(T[2],"var");
             strcpy(T[3],"reel");
             strcpy(T[4],"entier");
             strcpy(T[5],"deb");
             strcpy(T[6],"lire");
             i=0;
             c=fgetc(fich);
                      while(j==1)
            {
                 switch (etat)
                     {  case 0:
                         if ((isspace(c))||(c=='/n')||(c=='/t'))    //si le caractère est un espace ou un retour à la ligne
                                                                    //ou une tabulation alors l'état est encore 0
                                 {  etat=0;
                                    c=fgetc(fich);
                                 }
                        else if (isalpha(c))   //si c'est un caractère alors l'état devient 1 et on incrémente le i
                            {
                            ch[i]=c;
                             i++;
                             ch[i]='\0';
                             c=fgetc(fich);
                             etat=1;
                            }
                         else
                            if (isdigit(c))       //si c'est un nombre alors l'état devient 3
                             {  etat=3;
                                c=fgetc(fich);
                             }
                         else
                           if (c==')')          //si c'est un ')' l'état devient 5
                               etat=5;
                         else
                            if (c=='(')
                               etat=6;
                         else
                            if (c==':')
                                { c=fgetc(fich);
                                       if (c=='=')
                                       etat=91;
                                       else
                                       etat=19;
                                }
                        else
                             if (c=='=')
                                {
                                    etat=7;
                                    c=fgetc(fich);
                                }
                        else
                              if (c=='*')
                                etat=30;
                        else
                               if (c=='+')
                                 etat=10;
                        else
                                if (c==';')
                                 etat=12;
                        else
                                 if (c==EOF)
                                 etat=13;
                        else
                                 {  val[i]=c;
                                    i++;
                                    val[i]='\0';
                                    sprintf ("ERREUR : le caractère est invalide '%s'",val);
                                    i=0;
                                    c=fgetc(fich);
                                    etat=14;
                                }
 
                                 break;
            case 1:
                                 while (isalpha(c) || isdigit(c))
                                  {   ch[i]=c;
                                      i++;
                                      ch[i]='\0';
                                      c=fgetc(fich);
                                  }
                                 reculer(fich);
                                 etat=2;
                                 break;
            case 2:
                                 for (w=0 ; w<7 ; w++)
                                  {
                                    if (strcmp(T[w],ch) == 0)          //retouner les termes clé
                                    {  aux = w;
                                        return (T[w]);
                                        j=0;
                                    }
                                   }
                                     if (aux == -1)
                                    {  j=0;
                                      return ("id");
                                    }
                                  break;
            case 3:
                                  while(isdigit(c))
                                    {   c=fgetc(fich);         //lire les caractères
                                    }
                                  if (c=='.')
                                    {  c=fgetc(fich);
                                        etat=60;
                                    }
                                  else
                                    {  etat=4;
                                    }
                                   break;
            case 4:
                                  return ("nb");
                                  break;
            case 60:                 if (isdigit(c))
                                     {  c=fgetc(fich);
                                        etat=60;
                                     }
                                      else
                                     {  reculer(fich);
                                        c=fgetc(fich);
                                      if (c=='.')
                                     {  reculer(fich);
                                        etat=4;
                                     }
                                      else
                                      etat=50;
                                      }
                                      break;
            case 50:
                                      return("nbr");
                                      j=0;
                                      break;
            case 14:
                                      return("ERROR");
                                      j=0;
                                      break;
             case 5:
                                      return("(");
                                      j=0;
                                      break;
            case 6:
                                      return(")");
                                      j=0;
                                      break;
            case 19:
                                      return(":");
                                      j=0;
                                      break;
                     }
                     }
                 for(beta=0;beta<10;beta++)
                    printf("%c",ch[beta]) ;
 
                     }

28/04/2016, 10h26
ternel
tu as bien conscience que return sort de la fonction, donc que le printf n'est pas exécuté.

Tu as aussi conscience que retourner un littéral de chaine peut être risqué.

de plus, rien qu'en regardant ton main, il y a un gros défaut:
Code:

1 2 3 4 5 6 7 int main() { FILE *ficEntree; ficEntree=fopen("test.txt","r") ; Anal_lex(ficEntree) ; }
Je vois un pointeur initialisé avec fopen dans main, mais aucun appel à fclose. C'est un bon moyen de faire des erreurs.
Il faut toujours utiliser par paire les fonctions d'acquisition et de libération de ressource. On doit les voir dans la même accolade
(sauf quand on crée de telles fonctions, qui doivent alors être symétrique un open contient un open plus basique, et un close contient un close plus basique)