Swi Prolog Interface XPCE

[maurty]

Bonjour,

je débute en prolog et j'ai un problème pour lier l'interface que j'ai réalisé en suivant ce tuto : http://jfoutelet.developpez.com/articles/xpce/

Voici mon code : ( j'ai enlevé le code de traitement )

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
fonctionTraitement(Formule) :-
Tab = tab(_, _,[Formule]), etendreTableau(Tab), ecrireTableau(Tab,0).



/* Ecrit la liste des équations testées*/
ecrireListeFormule([Formule]) :- send(Formule).
ecrireListeFormule([Formule | Queue]) :-
	 send(Formule),
	 send(,), 
	 ecrireListeFormule(Queue).

/*Affiche L'arbre*/
ecrireTableau(vide,_).
ecrireTableau(ferme,_):- 
	send(' X '). /*Fermeture du noeud d'échec par une croix*/
ecrireTableau(ouvert,_):-
	 send(' O '). /*Succès*/
ecrireTableau(tab(Gauche, Droit, Liste), K):-
	 nl, tab(K), K1 is K+3,
	ecrireListeFormule(Liste),
	ecrireTableau(Gauche,K1),
	ecrireTableau(Droit,K1).


dialog(dialog_1,
       [ object        :=
	   Dialog__,
	 parts         :=
	   [ Dialog__  := dialog('Dialog 1'),
	     Text_item := text_item(text_item),
	     Button    := button(button),
	     Name      := label(name,
				'Exemple : (a ^ ( ~ b v c) =>( d # a))'),	     
	     Editor    := editor(@default, 54, 14)
	   ],
	 modifications :=
	   [ Text_item := [ label  := 'Formule:',
			    length := 48
			  ],
	     Button    := [ label := 'Go'
			  ]
	   ],
	 layout        :=
	   [ area(Text_item,
		  area(86, 23, 405, 24)),
	     area(Button,
		  area(533, 22, 80, 24)),
	     area(Name,
		  area(150, 54, 212, 18)),
	     area(Editor,
		  area(82, 126, 545, 258))
	   ],
	 behaviour     :=
	   [ Button := [ message := message(@prolog,
					    fonctionTraitement,
					    Text_item?selection,
					    Editor)
		       ]
	   ],
	 initialise    :=
	   [
	    
	   
	   ]
       ]).
	   
	   
	   
	   
plop :-
       make_dialog(D, 'dialog_1'),
       send(D,open).

En gros, je souhaiterai écrire la formule que je veux traiter dans le champs input text, lancer la fonction "fonctionTraitement" en cliquant sur le bouton et afficher le résultat sur l'editor ( j'ai mis un editor à défaut de mieux je mettrai plutôt un label) .

Or quand je le fait ça m'affiche cette erreur :

ERROR: '$c_call_prolog'/0: Undefined procedure: fonctionTraitement/2
ERROR: However, there are definitions for:
ERROR: fonctionTraitement/1

Est-ce quelqu'un pourrait m'aider parce je ne vois pas du tout comment faire.

[Trap D]

Le prédicat fontionTraitement ne prend qu'un argument (d'où l'écriture fontionTraitement /1) alors que tu écris dans la description du dialog
message(@prolog, fonctionTraitement, Text_item?selection, Editor) qui sous entend qu'il y en a deux.
Ce que tu peux faire, (attention ce n'est pas testé) :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
fonctionTraitement(Formule, Editor) :-
Tab = tab(_, _,[Formule]), etendreTableau(Tab), ecrireTableau(Tab,0, Editor).



/* Ecrit la liste des équations testées*/
ecrireListeFormule([Formule], Editor) :- send(Editor, append, Formule).
ecrireListeFormule([Formule | Queue], Editor) :-
	 send(Editor, append, Formule),
	 send(Editor, append, (,)),
	 ecrireListeFormule(Queue, Editor).

/*Affiche L'arbre*/
ecrireTableau(vide,_, _Editor).
ecrireTableau(ferme,_, Editor):-
	send(Editor, append, ' X '). /*Fermeture du noeud d'échec par une croix*/
ecrireTableau(ouvert,_, Editor):-
	 send(Editor, append, ' O '). /*Succès*/
ecrireTableau(tab(Gauche, Droit, Liste), K, Editor):-
	 nl, tab(K), K1 is K+3,
	ecrireListeFormule(Liste, Editor),
	ecrireTableau(Gauche,K1, Editor),
	ecrireTableau(Droit,K1, Editor).

Attention, à mon avis, il y a un problème avec le prédicat etendreTableau(Tab) qui doit sans doute modifier Tab, il devrait avoir sans doute deux arguments etendreTableau(Tab, Tab1).

Dernière chose fonctionTableau n'est pas un bon nom pour Prolog, car Prolog ne connait pas les fonctions (sauf en arithmétique).

[maurty]

Merci pour votre réponse

j'ai tester cela permet de lier les composants

En revanche, la formule que je passe dans le inputText se réécrit simplement dans l'éditeur avec un 'O' pour succès et ce avec n'importe quelle formule.

Je pense que le traitement ne s'effectue pas ou alors pas complétement j'ai essayé plusieurs choses mais rien n'a faire.

Je ne comprend pas vraiment pourquoi le traitement de la formule ne s'effectue pas puisque pour moi c'est indépendant de l'affichage


Voici l'intégralité de mon code

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

dialog(dialog_1,
       [ object        :=
	   Dialog__,
	 parts         :=
	   [ Dialog__  := dialog('Dialog 1'),
	     Text_item := text_item(text_item),
	     Button    := button(button),
	     Name      := label(name,
				'Exemple : (a ^ ( ~ b v c) =>( d # a))'),	     
	     Editor    := editor(@default, 54, 14)
	   ],
	 modifications :=
	   [ Text_item := [ label  := 'Formule:',
			    length := 48
			  ],
	     Button    := [ label := 'Go'
			  ]
	   ],
	 layout        :=
	   [ area(Text_item,
		  area(86, 23, 405, 24)),
	     area(Button,
		  area(533, 22, 80, 24)),
	     area(Name,
		  area(150, 54, 212, 18)),
	     area(Editor,
		  area(82, 126, 545, 258))
	   ],
	 behaviour     :=
	   [ Button := [ message := message(@prolog,
					    tableauSemantique,
					    Text_item?selection,
					    Editor)
		       ]
	   ],
	 initialise    :=
	   [ ]
       ]).
	     
	   
plop :-
       make_dialog(D, 'dialog_1'),
       send(D,open).



/*Définition des opérateurs*/
:- op(650,xfy, #).
:- op(640,xfy, =>). 
:- op(630,yfx, ^).
:- op(620,yfx, v). 
:- op(610, fy, ~).

/*Fonction tableau sémantique*/
tableauSemantique(Formule, Editor) :-
Tab = tab(_, _,[Formule]), etendreTableau(Tab), ecrireTableau(Tab,0, Editor).

/* Vérification: si la branche est close 	       */

etendreTableau(tab(ferme, vide, L)) :- 
	verifFermee(L).

/* Si la branche est ouverte, on vérifie qu'elle ne contient que des litteraux*/

etendreTableau(tab(ouvert, vide, L)) :- 
	neContientQueLitteraux(L).

/**/

etendreTableau(tab(Gauche, vide, L)) :-
	regleAlpha(L,L1), Gauche = tab(_,_,L1), etendreTableau(Gauche).

etendreTableau(tab(Gauche, Droit, L)) :- 
	regleBeta(L,L1,L2),
	Gauche = tab(_,_,L1),
	Droit = tab(_,_,L2),
	 etendreTableau(Gauche),
	 etendreTableau(Droit).


/* Test si le terme est clos*/
verifFermee(L) :-
	 membre(Formule,L),membre( ~ Formule,L).

neContientQueLitteraux([]).
neContientQueLitteraux([Formule | Queue]) :-
	 litteral(Formule),
	 neContientQueLitteraux(Queue).

litteral(Formule) :- atom(Formule).
litteral(~ Formule) :- atom(Formule).

regleAlpha(L, [A1, A2 | Ltemp]) :-
	formuleAlpha(A,A1,A2),
	membre(A,L),
	supprime(A,L, Ltemp).

regleAlpha(L, [A1 | Ltemp]) :- 
	A = ~ ~ A1,
	membre(A,L),
	supprime(A,L, Ltemp).

regleBeta(L, [B1 | Ltemp], [B2 | Ltemp]) :-
	formuleBeta(B,B1,B2),
	 membre(B,L),
	 supprime(B,L, Ltemp).


/*Définition des règles ALPHA*/
formuleAlpha(A1 ^ A2, A1, A2).
formuleAlpha(~ (A1 => A2), A1, ~ A2).
formuleAlpha(~ (A1 v A2), ~ A1, ~ A2).


/*Définition des règles BETA*/
formuleBeta(A1 v A2, A1, A2).
formuleBeta(A1 => A2, ~ A1, A2).
formuleBeta(~ (A1 ^ A2), ~ A1, ~ A2).
formuleBeta(A1 # A2, A1 ^ A2, ~(A1 ^ A2)).
formuleBeta(~ (A1 # A2), A1 => A2, A2 => A1).


/* Ecrit la liste des équations testées*/
ecrireListeFormule([Formule], Editor) :- send(Editor, append,Formule).
ecrireListeFormule([Formule | Queue], Editor) :-
	 send(Editor, append, Formule),
	 send(Editor, append, (,)),
	 ecrireListeFormule(Queue, Editor).

/*Affiche L'arbre*/
ecrireTableau(vide,_, _Editor).
ecrireTableau(ferme,_, Editor):-
	send(Editor, append, ' X '). /*Fermeture du noeud d'échec par une croix*/
ecrireTableau(ouvert,_, Editor):-
	 send(Editor, append,' O '). /*Succès*/
ecrireTableau(tab(Gauche, Droit, Liste), K, Editor):-
	 nl, tab(K), K1 is K+3,
	ecrireListeFormule(Liste, Editor),
	ecrireTableau(Gauche,K1, Editor),
	ecrireTableau(Droit,K1, Editor).

/*Redéfinition de la fonction member()*/
membre(X,[X|_]).
membre(X,[_|Queue]):-membre(X,Queue).

/*On supprime un élément de la liste*/
supprime(X, [X | Queue], Queue).
supprime(X, [Tete | Queue], [Tete | Queue1]) :-
	 supprime(X, Queue, Queue1).

Par contre pour l'editor, je vais rajouter un bouton "reset" pour effacer le résultat obtenue à la premiere utilisation et je me demandais comment :

Réinitialiser l'editor à vide dans la méthode init ?

J'avoue que j'ai du mal avec les prédicat de Prolog.

[Trap D]

Pour reintialiser l'éditeur, il faut faire send(Edfitor, clear).
Pour le reste, demain je regarderai.

[Trap D]

En revanche, la formule que je passe dans le inputText se réécrit simplement dans l'éditeur avec un 'O' pour succès et ce avec n'importe quelle formule.

Je pense que le traitement ne s'effectue pas ou alors pas complétement j'ai essayé plusieurs choses mais rien n'a faire.

Je ne comprend pas vraiment pourquoi le traitement de la formule ne s'effectue pas puisque pour moi c'est indépendant de l'affichage

Pour comprendre ce qui se passe, je suggère d'ajouter un gtrace dans le code de tableauSemantique/2 :

Code :

1
2
3
4
5
6
/*Fonction tableau sémantique*/
tableauSemantique(Formule, Editor) :-
	gtrace,
	Tab = tab(_, _,[Formule]),
	etendreTableau(Tab),
	ecrireTableau(Tab,0, Editor).

Cela permettra de suivre ce qui se passe exactement dans ce prédicat.

[maurty]

Je viens de tester avec gtrace a priori la formule est bien traitée par les fonctions et donc le programme devrait afficher le résultat et non la formule passée en argument


En fait je viens de me rendre compte que la formule ne se décompose pas

par exemple quand je tape a ^~b =>c le programme ne la coupe pas sous forme d'atom du coup c'est normal que ça me l'affiche comme résultat.


Est ce que le problème se situerai au niveau de la déclaration de type du champs inputtext ?

Je viens de tester le programme sans l'interface mais avec le gtrace
quand je tape la formule a ^~b =>c
Je trouve Formule : a ^~b =>c
alors qu'avec l'interface j'ai Formule : 'a ^~b =>c'

[Trap D]

Essayez en faisant :

Code :

1
2
3
4
5
6
tableauSemantique(Formule, Editor) :-
	gtrace,
	term_to_atom(Term, Formule),
	Tab = tab(_, _,Term),
	etendreTableau(Tab),
	ecrireTableau(Tab,0, Editor).

[maurty]

Cela supprime effectivement les quotes et avec le gtrace je vois que ça décompose bien la formule comme pour le fonctionnement normal.

En revanche, plus rien ne s'affiche dans l'editor c'est à n'y rien comprendre

[Trap D]

Sans doute parce que le predicat etendreTableau/1 echoue.
Esssayez ce code

Code :

1
2
3
4
5
6
7
tableauSemantique(Formule, Editor) :-
	gtrace,
	term_to_atom(Term, Formule),
	Tab = tab(_, _,Term),
	(  etendreTableau(Tab)
	-> ecrireTableau(Tab,0, Editor)
	;   send(Editor, append, echec)).

[maurty]

Visiblement j'ai une exception dans

Code :

1
2
3
4
5
6
7
ecrireTableau(ouvert,_, Editor):-
	 send(Editor, append,' O '). /*Succès*/
ecrireTableau(tab(Gauche, Droit, Liste), K, Editor):-
	 nl, tab(K), K1 is K+3,
	ecrireListeFormule(Liste, Editor),
	ecrireTableau(Gauche,K1, Editor),
	ecrireTableau(Droit,K1, Editor).

quand je passe a v ~a en formule ou a^ ~a
J'ai l'exception : Exception : v: unknown class pour l'une et ^ pour l'autre


En fait ca me le fait quelque soit l'opérateur, un problème avec la fonction send.

Je devrai changer ce qu'elle envoi ?

Avec un prédicat atom_to_term ( si cela existe ) ou quelque chose genre

[Trap D]

Avec un prédicat atom_to_term ( si cela existe ) ou quelque chose genre

C'est un des attraits de Prolog, les prédicats fonctionnent souvent dans les deux sens , on peut utiliser donc utiliser term_to_atom pour transformer le Term en Atom, ou l'Atom en Term, c'est exactement la même syntaxe term_to_atom(Term, Atom).
C'est le sens de la doc Prolog : term_to_atom(?Term, ?Atom).
Cet extrait de la doc SWI explique la signification des codes :

Envoyé par SWI-Prolog

+Argument must be fully instantiated to a term that satisfies the required argument type. Think of the argument as input.

- Argument must be unbound. Think of the argument as output.

? Argument must be bound to a partial term of the indicated type. Note that a variable is a partial term for any type. Think of the argument as either input or output or both input and output. E.g., in stream_property(S, reposition(Bool)), the reposition part of the term is input and the uninstantiated Bool is output.

: Argument is a meta-argument. Implies +. See chapter 5 for more information on module handling.

@ Argument is not further instantiated. Typically used for type tests.

! Argument contains a mutable structure that may be modified using setarg/3 or nb_setarg/3.

[maurty]

Je viens d'essayer avec ce code

Code :

1
2
3
4
5
6
7
8
9
/* Ecrit la liste des équations testées*/
ecrireListeFormule([Formule], Editor) :- 
atom_to_term([Formule], Te),
send(Editor, append,Te).
ecrireListeFormule([Formule | Queue], Editor) :-
	 atom_to_term([Formule], Te),
	 send(Editor, append, Te),
	 send(Editor, append, (,)),
	 ecrireListeFormule(Queue, Editor).

Si j'ai bien compris atom_to_term est un genre de parse qui va transformer la formule qui est un atom en term.

Donc cela devrait règle le probleme de l'exception des opérateurs.

Cependant avec cela j'ai l'exception suivante :

Undefined procedure : atom_to_term/2

pourtant je n'ai pas l'impression de m'être tromper

[Trap D]

Non, c'est term_to_atom, pas atom_to_term !

[maurty]

ah ouai besoin d'un café moi ^^

Du coup ca marche beaucoup mieux

[Trap D]

Ça s'appelle avoir la tête dans le guidon !

[maurty]

En tout cas merci pour le temps que vous m'avez consacré

[Trap D]

Un petit clic sur ?