recherche qq'un qui s'y connait en javacc

Version imprimable

03/01/2008, 01h15
troussepoil

recherche qq'un qui s'y connait en javacc

Bonjour, comme l'intitulé de cette discussion l'indique, je voudrais savoir si quelqu'un s'y connait en javacc car j'ai quelques problème de compréhension et j'aurais voulu poser des questions?
03/01/2008, 02h16
eclesia

pose la question plutot, si quelqu'un sait il te repondra ;)

Voici ma grammaire:

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
 
options {
    LOOKAHEAD=1;
}
 
PARSER_BEGIN(Grammaire)
public class Grammaire {
 
}
PARSER_END(Grammaire)
 
SKIP :
{
    " "		//caractère ESPACE
|   "\r"	//retour chariot
|   "\t"	//tabulation
|	"\f"	//fin de fichier
}
 
TOKEN :
{
	<NON : "-">
|	<ET : "&">
|	<OU : "|">
|	<EQUIVALENT : "<>">
|	<IMPLIQUE : ">">
 
|	< PETITEVARIABLE : (["a"-"z"])+ >
|	< GRANDEVARIABLE : (["A"-"Z"])+ >
 
|	< SUITE : <MINUSCULE> | <MINUSCULE> "," <MINUSCULE> >
 
|	< #MAJUSCULE : (["A"-"Z"])+ >
|	< #MINUSCULE : (["a"-"z"])+ >
 
|   < EOL: "\n" >
}
 
void start():
{
    String a;
}
{
//	a = fonction() <EOL> { System.out.println(a); }
	a = predicat() <EOL> { System.out.println(a); }
 
  | <EOL>
  | <EOF>               { System.exit(-1); }
}
 
 
String fonction():
{
	Token a;
	Token b;
}
{
	a=<PETITEVARIABLE> "("
	(
		b=<PETITEVARIABLE>
	)
	")"
		{return a.toString() + "(" + b.toString() + ")";}
}
 
String predicat():
{
	Token a;
	Token b;
}
{
	a=<GRANDEVARIABLE> "("
	(
		b=<SUITE>
	)
	")"
		{return a.toString() + "(" + b.toString() + ")";}
}

Ce que je voudrais, c'est avoir un prédicat de la forme suivante:
A(x) ou A(x,y)
En gros, une majuscule avec, entre parenthèses, une ou deux variable/constante.

Si je test avec ce code, j'obtiens l'erreur suivante(ici, je test la méthode nommée 'prédicat()'):

Code:

1
2
3
4
5
 
A(c)
Exception in thread "main" ParseException: Encountered "c" at line 1, column 3.
Was expecting:
    <SUITE> ...

Si je test comme suit(j'ai enlevé les # et les trucs appelé PETITEVARIABLE et GRANDE VARIABLE).

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
 
options {
//    STATIC = false;
    LOOKAHEAD=1;
}
 
PARSER_BEGIN(Grammaire)
public class Grammaire {
 
}
PARSER_END(Grammaire)
 
SKIP :
{
    " "		//caractère ESPACE
|   "\r"	//retour chariot
|   "\t"	//tabulation
|	"\f"	//fin de fichier
}
 
TOKEN :
{
	<NON : "-">
|	<ET : "&">
|	<OU : "|">
|	<EQUIVALENT : "<>">
|	<IMPLIQUE : ">">
 
|	< SUITE : <MINUSCULE> | <MINUSCULE> "," <MINUSCULE> >
 
|	< MAJUSCULE : (["A"-"Z"])+ >
|	< MINUSCULE : (["a"-"z"])+ >
 
|   < EOL: "\n" >
}
 
void start():
{
    String a;
}
{
//	a = fonction() <EOL> { System.out.println(a); }
	a = predicat() <EOL> { System.out.println(a); }
 
  | <EOL>
  | <EOF>               { System.exit(-1); }
}
 
 
String fonction():
{
	Token a;
	Token b;
	StringBuilder sb = new StringBuilder();
}
{
	a=<MINUSCULE> "("
		{sb.append(a.image);}
	(
		b=<MINUSCULE>
				{sb.append("(").append(b.image).append(")");}
	)
	")"
		{return a.toString() + "(" + b.toString() + ")";}
}
 
String predicat():
{
	Token a;
	Token b;
}
{
	a=<MAJUSCULE> "("
	(
		b=<SUITE>
	)
	")"
		{return a.toString() + "(" + b.toString() + ")";}
}

Alors ça fonctionne:

Code:

1
2
3
 
A(z)
A(z)

Code:

1
2
3
 
A(r,t)
A(r,t)

mais si je teste ensuite la méthode 'fonction()':

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
...
void start():
{
    String a;
}
{
	a = fonction() <EOL> { System.out.println(a); }
//	a = predicat() <EOL> { System.out.println(a); }
 
  | <EOL>
  | <EOF>               { System.exit(-1); }
}
...

alors:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
f(x)
Exception in thread "main" ParseException: Encountered "f" at line 1, column 1.
Was expecting one of:
    <EOF> 
    <MINUSCULE> ...
    "\n" ...
 
	at Grammaire.generateParseException(Grammaire.java:218)
	at Grammaire.jj_consume_token(Grammaire.java:160)
	at Grammaire.start(Grammaire.java:22)
	at Main.main(Main.java:7)

Dans la définition de la grammaire, si je place
...
| < SUITE : <MINUSCULE> | <MINUSCULE> "," <MINUSCULE> >
...
sous
...
| < MAJUSCULE : (["A"-"Z"])+ >
| < MINUSCULE : (["a"-"z"])+ >
...

alors ça fonctionne pour la méthode fonction() mais ne fonctionne plus pour la méthode 'predicat()'

voilà.

ça inspire vraiment personne le javacc..
Bon disons que j'ai résolu mon problème, en voici un nouveau.
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 [...] TOKEN : { < EXISTENTIEL : "9" <MINUSCULE> > | < MINUSCULE : (["a"-"z"])+ > } [...] String element(): { String t; String a; } { t=predicat() { return t; } | "(" a=formuleComplete() ")" { return "(" + a + ")"; } } String element2(): { String a; Token b; } { "-" a=element() { return "-" + a; } | b=<EXISTENTIEL> a=element() { return b.image + a; } | "-" b=<EXISTENTIEL> a=element() { return b.image + a; } | b=<EXISTENTIEL> "-" a=element() { return b.image + a; } | a=element() { return a; } }
J'ai un warning:
Warning: Choice conflict involving two expansions at line...

J'aurais voulu savoir si qq'un savait ce que ça voulait dire exactement pour javacc parce que c'est une erreur qui revient souvent quand même.