]> SALOME platform Git repositories - tools/eficas.git/blob - Ihm/I_FORM_ETAPE.py
Salome HOME
PN Pour les formules
[tools/eficas.git] / Ihm / I_FORM_ETAPE.py
1 # -*- coding: utf-8 -*-
2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
9 #
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
14 #
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
18 #
19 #
20 # ======================================================================
21 """
22 """
23 import string,traceback
24
25 from I_MACRO_ETAPE import MACRO_ETAPE
26 from Extensions import interpreteur_formule
27 from Editeur import analyse_catalogue
28
29 analyse_catalogue.l_noms_commandes.append('FORM') # déclare le nom FORM à l'analyseur de catalogue
30
31
32 class FORM_ETAPE(MACRO_ETAPE):
33
34     interpreteur = interpreteur_formule.Interpreteur_Formule
35
36     def McBuild(self):
37         self.mc_liste=self.build_mc()
38         # on crée la liste des types autorisés (liste des noms de mots-clés
39         # simples dans le catalogue de FORMULE)
40         self.l_types_autorises = self.definition.entites.keys()
41         # en plus de la construction traditionnelle des fils de self
42         # il faut pour les FORMULE décortiquer l'expression ...
43         self.type_retourne,self.arguments,self.corps = self.analyse_formule()
44
45
46     def analyse_formule(self):
47         """
48         Cette méthode décortique l'expression de la FORMULE.
49         Elle retourne 3 valeurs:
50             - le type retourné par la FORMULE
51             - les arguments de la FORMULE
52             - le corps de la FORMULE, cad son expression
53         """
54         if len(self.mc_liste) == 0:
55             # pas de fils pour self --> la FORMULE est incomplète
56             return None,None,None
57         child = self.mc_liste[0] # child est un MCSIMP
58         type_retourne = child.definition.nom
59         valeur = child.getval()
60         # c'est dans valeur que se trouvent la liste des arguments et le corps de la fonction
61         try:
62             l_args,corps = string.split(valeur,'=',1)
63         except:
64             # pas de signe = --> la formule est fausse
65             return type_retourne,None,None
66         l_args = string.strip(l_args)
67         corps = string.strip(corps)
68         return type_retourne,l_args,corps
69
70     def get_nom(self):
71         """
72         Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
73         la string vide sinon
74         """
75         if self.sd :
76             return self.sd.get_name()
77         else:
78             return ''
79
80     def get_formule(self):
81         """
82         Retourne un tuple décrivant la formule :
83         (nom,type_retourne,arguments,corps)
84         """
85         t,a,c = self.analyse_formule()
86         n = self.get_nom()
87         return (n,t,a,c)
88
89     def verif_arguments(self,arguments = None):
90         """
91         Vérifie si les arguments passés en argument (si aucun prend les arguments courants)
92         sont des arguments valide pour une FORMULE.
93         Retourne :
94             - un booléen, qui vaut 1 si arguments licites, 0 sinon
95             - un message d'erreurs ('' si illicites)
96         """
97         if not arguments :
98             arguments = self.arguments
99         if not arguments :
100             return 0,"Une formule doit avoir au minimum un argument"
101         # il faut au préalable enlever les parenthèses ouvrantes et fermantes
102         # encadrant les arguments
103         arguments = string.strip(arguments)
104         if arguments[0] != '(':
105             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse ouvrante manquante"
106         if arguments[-1] != ')':
107             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse fermante manquante"
108         # on peut tester la syntaxe de chaque argument maintenant
109         erreur=''
110         test = 1
111         arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante
112         l_arguments = string.split(arguments,',')
113         #for argument in l_arguments:
114         #    argument = string.strip(argument)
115         #    try:
116         #       nom=argument
117         #        typ,nom = string.split(argument,':')
118         #        #pas de vérification sur le nom de l'argument
119         #        #vérification du type de l'argument
120         #        typ = string.strip(typ)
121         #        if typ not in self.l_types_autorises :
122         #            test = 0
123         #            erreur = erreur + "Le type "+typ+" n'est pas un type permis pour "+nom+'\n'
124         #    except:
125         #        # l'argument ne respecte pas la syntaxe : typ_arg : nom_arg
126         #        test = 0
127         #        erreur = erreur+"Syntaxe argument non valide : "+argument+'\n'
128         return test,erreur
129
130     def verif_corps(self,corps=None,arguments=None):
131         """
132         Cette méthode a pour but de vérifier si le corps de la FORMULE
133         est syntaxiquement correct.
134         Retourne :
135             - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon
136             - un message d'erreurs ('' si illicite)
137         """
138         if not corps :
139             corps = self.corps
140         if not arguments :
141             arguments = self.arguments
142         formule=(self.get_nom(),self.type_retourne,arguments,corps)
143         # on récupère la liste des constantes et des autres fonctions prédéfinies
144         # et qui peuvent être utilisées dans le corps de la formule courante
145         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
146         # on crée un objet vérificateur
147         try:
148             verificateur = self.interpreteur(formule=formule,
149                                              constantes = l_ctes,
150                                              fonctions = l_form)
151         except :
152             traceback.print_exc()
153             return 0,"Impossible de réaliser la vérification de la formule"
154         return verificateur.isvalid(),verificateur.report()
155
156     def verif_nom(self,nom=None):
157         """
158         Vérifie si le nom passé en argument (si aucun prend le nom courant)
159         est un nom valide pour une FORMULE.
160         Retourne :
161             - un booléen, qui vaut 1 si nom licite, 0 sinon
162             - un message d'erreurs ('' si illicite)
163         """
164         if not nom :
165             nom = self.get_nom()
166         if nom == "" :
167             return 0,"Pas de nom donné à la FORMULE"
168         if len(nom) > 8 :
169             return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
170         if nom[0] > "0" and nom[0] < "9" :
171             return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
172         sd = self.parent.get_sd_autour_etape(nom,self)
173         if sd :
174             return 0,"Un concept de nom %s existe déjà !" %nom
175         return 1,''
176
177     def verif_type(self,type=None):
178         """
179         Vérifie si le type passé en argument (si aucun prend le type courant)
180         est un type valide pour une FORMULE.
181         Retourne :
182             - un booléen, qui vaut 1 si type licite, 0 sinon
183             - un message d'erreurs ('' si illicite)
184         """
185         if not type:
186             type = self.type_retourne
187         if not type :
188             return 0,"Le type de la valeur retournée n'est pas spécifié"
189         if type not in self.l_types_autorises:
190             return 0,"Une formule ne peut retourner une valeur de type : %s" %type
191         return 1,''
192
193     def verif_formule(self,formule=None):
194         """
195         Vérifie la validité de la formule passée en argument.
196         Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
197         Si aucune formule passée, prend les valeurs courantes de la formule
198         Retourne :
199             - un booléen, qui vaut 1 si formule licite, 0 sinon
200             - un message d'erreurs ('' si illicite)
201         """
202         if not formule :
203             formule = (None,None,None,None)
204         test_nom,erreur_nom = self.verif_nom(formule[0])
205         test_type,erreur_type = self.verif_type(formule[1])
206         if formule[2]:
207             args = '('+formule[2]+')'
208         else:
209             args = None
210         test_arguments,erreur_arguments = self.verif_arguments(args)
211         test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
212         # test global = produit des tests partiels
213         test = test_nom*test_type*test_arguments*test_corps
214         # message d'erreurs global = concaténation des messages partiels
215         erreur = ''
216         if not test :
217             for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
218                 erreur = erreur+(len(mess) > 0)*'\n'+mess
219         return test,erreur
220
221     def verif_formule_python(self,formule=None):
222         """
223         Pour l instant ne fait qu un compile python
224         il serait possible d ajouter des tests sur les arguments
225         ou le type retourne mais ...
226         """
227         if not formule :
228             formule = (None,None,None,None)
229         test_nom,erreur_nom = self.verif_nom(formule[0])
230         if formule[2]:
231             args = '('+formule[2]+')'
232         else:
233             args = None
234         test_arguments,erreur_arguments = self.verif_arguments(args)
235         corps=formule[3]
236         erreur_formule= ''
237         test_formule=1
238         try :
239             compile(corps,'<string>','eval')
240         except :
241             erreur_formule= "le corps de la formule n'est pas une formule python valide"
242             test_formule=0
243         erreur = ''
244         test = test_nom*test_arguments*test_formule
245         if not test :
246             for mess in (erreur_nom,erreur_arguments,erreur_formule):
247                 erreur = erreur+(len(mess) > 0)*'\n'+mess
248         return test,erreur
249
250
251     def update(self,formule):
252         """
253         Méthode externe.
254         Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE
255         par les nouvelles valeurs passées dans le tuple formule.
256         On stocke les valeurs SANS vérifications.
257         """
258         self.type_retourne = formule[1]
259         self.arguments = '('+formule[2]+')'
260         self.corps = formule[3]
261         # il faut ajouter le mot-clé simple correspondant dans mc_liste
262         # pour cela on utilise la méthode générale build_mc
263         # du coup on est obligé de modifier le dictionnaire valeur de self ...
264         self.valeur = {}
265         self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
266         self.McBuild()
267         sd = self.get_sd_prod()
268         if sd:
269             sd.nom = formule[0]
270
271     # bidouille PN 
272     # Il faut que formule soit constitue de 
273     # nom de la formule
274     # type retourne
275     # parametres
276     # corps de la fonction
277     def update_formule_python(self,formule):
278         self.build_mc()
279         self.mc_liste=[]
280         if len(formule) < 4 :
281            return O
282         i=1
283         for k,v in self.definition.entites.items():
284             child=self.definition.entites[k](None,nom=k,parent=self)
285             new_valeur=formule[i+1]
286             child.valeur = new_valeur
287             child.state = 'modified'
288             self.mc_liste.append(child)
289             i=i+1
290         self.arguments = formule[3]
291         self.corps = formule[2]
292         self.type_retourne = formule[1]
293         sd = self.get_sd_prod()
294         if sd:
295             sd.nom = formule[0]
296         self.init_modif()
297         return 1
298
299     def active(self):
300         """
301         Rend l'etape courante active.
302         Il faut ajouter la formule au contexte global du JDC
303         """
304         self.actif = 1
305         nom = self.get_nom()
306         if nom == '' : return
307         try:
308             self.jdc.append_fonction(self.sd)
309         except:
310             pass
311
312     def inactive(self):
313         """
314         Rend l'etape courante inactive
315         Il faut supprimer la formule du contexte global du JDC
316         """
317         self.actif = 0
318         if not self.sd : return
319         self.jdc.del_fonction(self.sd)
320
321     def delete_concept(self,sd):
322         """ 
323          Inputs :
324            - sd=concept detruit
325          Fonction :
326          Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
327          suite à la disparition du concept sd
328          Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
329          sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas 
330          utilisé dans le corps de la fonction
331         """
332         self.init_modif()
333          
334     def replace_concept(self,old_sd,sd):
335         """
336          Inputs :
337            - old_sd=concept remplace
338            - sd = nouveau concept
339          Fonction :
340          Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
341          utilisé dans le corps de la fonction
342         """
343         self.init_modif()
344