Discussion :

[sperca]

Bonjour,

J'essaye de réaliser une calculatrice avec gestion de variables. Pour cela j'utilise l'outil Menhir. Je l'utilise simplement pour mettre au point un AST que je traiterai plus tard.

Voici les fichiers que j'utilise pour le parseur et le lexeur :

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
%token <int> INT
%token <string> SYMBOL
%token PLUS MINUS TIMES DIVIDES
%token LPAREN RPAREN
%token LET BINDS IN
 
%right IN
%left PLUS MINUS
%left TIMES DIVIDES
 
%nonassoc UMINUS
 
%token EOF
 
%start <Types.expression> main
 
%%
 
main:
| e = expression EOF
    { e }
 
expression:
| i = INT
    { Types.Number i }
| s = SYMBOL
    { Types.Variable s }
| LET s = SYMBOL BINDS i = INT IN e = expression
    { Types.Binding (s, i, e) }
| LPAREN e = expression RPAREN
    { e }
| e1 = expression PLUS e2 = expression
    { Types.Plus (e1, e2) }
| e1 = expression MINUS e2 = expression
    { Types.Minus (e1, e2) }
| e1 = expression TIMES e2 = expression
    { Types.Times (e1, e2) }
| e1 = expression DIVIDES e2 = expression
    { Types.Divides (e1, e2) }
| MINUS e = expression %prec UMINUS
    { Types.Uminus e }

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
{
 
  open Parser
 
  exception Unknown_token
 
}
 
rule token = parse
  | [' ' '\n' '\t']
      { token lexbuf }
  | ['0'-'9']+ as i
      { INT (int_of_string i) }
  | ['a'-'z']+ as v
      { SYMBOL v }
  | '+'
      { PLUS }
  | '-'
      { MINUS }
  | '*'
      { TIMES }
  | '/'
      { DIVIDES }
  | '('
      { LPAREN }
  | ')'
      { RPAREN }
  | ":="
      { BINDS }
  | "let"
      { LET }
  | "in" 
      { IN }
  | eof
      { EOF }
  | _
      { raise Unknown_token }

Là où j'ai un doute c'est la priorité que je donne au token IN car sans cette priorité j'ai un conflit shift reduce...

Pour les expressions ne faisant pas intervenir de variables, cela fonctionne bien. En revanche dès qu'un let id := int in id j'obtiens une erreur de parsing.

Voici le fichier des types que j'utilise pour l'AST :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
type expression =
  | Number of int
  | Variable of string
  | Binding of string * int * expression
  | Uminus of expression
  | Plus of expression * expression
  | Minus of expression * expression
  | Times of expression * expression
  | Divides of expression * expression

Si quelqu'un a une idée, je l'en remercie ;-)

--
sperca

[ManusDei]

Dans ton parser SYMBOL est mal placé.

Quand dans ton exemple il analyse "let", au lieu de descendre jusqu'à LET, il s'arrête à SYMBOL ("let" est un symbole valide après tout).

Donc quand tu lis "let truc = x", ça plante car il cherche une règle commençant par SYMBOL.

[sperca]

Merci à toi.

Décidément je suis trop bête...

Bref c'est bon tout est fonctionnel.

Merci encore.

--
sperca

[ManusDei]

J'ai eu le même problème il y a 3 mois