analyseur lexical en c

1 pièce(s) jointe(s)
salut
je suis chargée de faire un analyseur lexical développé en langage C, j'arrive pas à faire
Et on ne va pas le faire à ta place.

Où bloques-tu?
Qu'est-ce que tu ne comprend pas?
Il y a une fonction de recherche sur le forum, l'as tu testé ? :aie:

http://www.developpez.net/forums/sea...archid=8107678
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
#include <stdio.h>
#include <ctype.h>
Int NumLigne = 1;
Int  Vallex =  RIEN;
 
Int AnalLex()
{
    int T;
    While(1);
    {
        T = getchar();
        if (T == ‘ ‘ || T == ‘\t’) ;
        else  if (T == ‘\n’)
                      NumLigne ++;
                   else  if(isdigit(T))
              {
                                  Vallex = T-’0’;
                             T = getchar();
                             While (isdigit(T))
                                     {
                                             ValLex = ValLex*10+T-’0’;
                                             T = getchar();
                                     }
                                     ungetc(T, stdin); return NB;
                                          }
                                          Else
                                     ValLex = RIEN;
                                          Return T;
                                    }
                             }
Unilex AnalLex()      /* Unilex est une chaine si Anallex retourne uniquement l’unité lexicale*/
    { 	/* Unilex est un entier si AnalLex retourne l’unité lexicale et chaque unité est définie comme une constante*/
    /* Unilex est un enregistrement si Analex
    retourne l’unité lexicale et un attribut*/
       {
          Switch(etat)
          {
             case 0: Init(Chaine); car = carsuivant();
                         if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’)
                         {   etat = 0; debutlex ++; }
                         else if( car == ‘<‘) etat = 5;
                         else if (car == ‘=‘) etat  = 9;
                         else if (car == ‘>’) etat = 10;
                         else if (isletter(car)) Ajouter(car, chaine);
          etat = 1;
                         else if(isdigit(car)) Ajouter(car, chaine);
        etat = 3;
                         else if(car == EOF) etat = 13;
                         else Erreur();
 
              case 1: car = carsuiv();
                   if(isletter(car) || isdigit(car))
                                               ajouter(car, chaine);;
                                      else etat = 2;
                  break;
              case 2: Reculer(1); RangerId(); return(UniLexId()); /* cas où l’analyseur lexical retourne uniquement */l’unité lexicale sinon, il faut utiliser un  enregistrement  (symbole)*/
                  ………….
 
 
              case 3: car = carsuiv();
                                     if(isdigit(car))  ajouter(car, chaine);
                                     else  etat = 4;
                                     break;
              case 4 : Reculer(1); Return(NB); case 6: Return(Oprel);
                    ……………
              case 13: Return(EOF);
              }
          Unilex AnalLex()      /* Unilex est une chaine si AnalLex retourne uniquement l’unité lexicale*/
              { 		/* Unilex est un entier si AnalLex retourne l’unité lexicale et chaque unité est définie comme une constante*/
 
              /* Unilex est un enregistrement si AnalLex
              retourne l’unité lexicale et un attribut*/
                 {
                    Switch(etat)
                    {
                       case 0: Init(Chaine)car = carsuivant();
                                   if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’)
                                   {   etat = 0; debutlex ++; }
                                   else if( car == ‘<‘) etat = 5;
                                   else if (car == ‘=‘) etat  = 9;
                                   else if (car == ‘>’) etat = 10;
                                   else if (isletter(car)) etat = 1;
                                   else if(isdigit(car)) etat = 3;
                                   else if(car == EOF) etat = 13;
                                   else Erreur();
                        case 1: car = carsuiv();
                             if(isletter(car) || isdigit(car))
                                                         ajouter(car, chaine);;
                                                else etat = 2;
                            break;
                        case 2: Reculer(1); symbole.att = RangerId(); symbole.UL = UniLexId(); Return(Symbole);
                        ………….
 
                        case 3: car = carsuiv();
                                               if(isdigit(car))  ajouter(car, chaine);
                                               else  etat = 4;
                                               break;
                        case 4 : Reculer(1); symbole.UL=NB; symbole.Att = toupper(chaine)); Return(symbole);
                        case 6: symbole.UL = Oprel; symbole.att = PPE; Return(symbole);	  ……………
                        case 13: symbole.UL = EOF; symbole.att = 0;
                        Return(symbole);}
                       /* On peut retourner des numériques.
voila se que j'arrive a faire
Dis nous directement ce qui te bloque ça sera beaucoup plus rapide.
je souhaite savoir c'est juste se que j'ai fais ou non