]> SALOME platform Git repositories - tools/eficas.git/blob - generator/generator_python.py
Salome HOME
Restitution de PN_DecoupePanel
[tools/eficas.git] / generator / generator_python.py
1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
2 # ======================================================================
3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
7 # (AT YOUR OPTION) ANY LATER VERSION.
8 #
9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
13 #
14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
17 #
18 #
19 # ======================================================================
20 """
21     Ce module contient le plugin generateur de fichier au format 
22     python pour EFICAS.
23
24 """
25 import traceback
26 import types,string,re
27
28 from Noyau import N_CR
29 from Noyau.N_utils import repr_float
30 from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
31 from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
32 from Accas import GEOM,ASSD,MCNUPLET
33 from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
34 from Formatage import Formatage
35
36 def entryPoint():
37    """
38        Retourne les informations nécessaires pour le chargeur de plugins
39
40        Ces informations sont retournées dans un dictionnaire
41    """
42    return {
43         # Le nom du plugin
44           'name' : 'python',
45         # La factory pour créer une instance du plugin
46           'factory' : PythonGenerator,
47           }
48
49
50 class PythonGenerator:
51    """
52        Ce generateur parcourt un objet de type JDC et produit
53        un fichier au format python 
54
55        L'acquisition et le parcours sont réalisés par la méthode
56        generator.gener(objet_jdc,format)
57
58        L'écriture du fichier au format ini par appel de la méthode
59        generator.writefile(nom_fichier)
60
61        Ses caractéristiques principales sont exposées dans des attributs 
62        de classe :
63          - extensions : qui donne une liste d'extensions de fichier préconisées
64
65    """
66    # Les extensions de fichier préconisées
67    extensions=('.comm',)
68
69    def __init__(self,cr=None):
70       # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
71       if cr :
72          self.cr=cr
73       else:
74          self.cr=N_CR.CR(debut='CR generateur format python pour python',
75                          fin='fin CR format python pour python')
76       # Le texte au format python est stocké dans l'attribut text
77       self.text=''
78
79    def writefile(self,filename):
80       fp=open(filename,'w')
81       fp.write(self.text)
82       fp.close()
83
84    def gener(self,obj,format='brut'):
85       """
86           Retourne une représentation du JDC obj sous une
87           forme qui est paramétrée par format.
88           Si format vaut 'brut', retourne une liste de listes de ...
89           Si format vaut 'standard', retourne un texte obtenu par concaténation de la liste
90           Si format vaut 'beautifie', retourne le meme texte beautifié
91       """
92       liste= self.generator(obj)
93       if format == 'brut':
94          self.text=liste
95       elif format == 'standard':
96          self.text=string.join(liste)
97       elif format == 'beautifie':
98          jdc_formate = Formatage(liste,mode='.py')
99          self.text=jdc_formate.formate_jdc()
100       else:
101          raise "Format pas implémenté : "+format
102       return self.text
103
104    def generator(self,obj):
105       """
106          Cette methode joue un role d'aiguillage en fonction du type de obj
107          On pourrait utiliser les méthodes accept et visitxxx à la 
108          place (dépend des gouts !!!)
109       """
110       # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
111       if isinstance(obj,PROC_ETAPE):
112          return self.generPROC_ETAPE(obj)
113       elif isinstance(obj,MACRO_ETAPE):
114          return self.generMACRO_ETAPE(obj)
115       elif isinstance(obj,FORM_ETAPE):
116          return self.generFORM_ETAPE(obj)
117       elif isinstance(obj,ETAPE):
118          return self.generETAPE(obj)
119       elif isinstance(obj,MCFACT):
120          return self.generMCFACT(obj)
121       elif isinstance(obj,MCList):
122          return self.generMCList(obj)
123       elif isinstance(obj,MCBLOC):
124          return self.generMCBLOC(obj)
125       elif isinstance(obj,MCSIMP):
126          return self.generMCSIMP(obj)
127       elif isinstance(obj,ASSD):
128          return self.generASSD(obj)
129       elif isinstance(obj,ETAPE_NIVEAU):
130          return self.generETAPE_NIVEAU(obj)
131       elif isinstance(obj,COMMENTAIRE):
132          return self.generCOMMENTAIRE(obj)
133       # Attention doit etre placé avant PARAMETRE (raison : héritage)
134       elif isinstance(obj,PARAMETRE_EVAL):
135          return self.generPARAMETRE_EVAL(obj)
136       elif isinstance(obj,PARAMETRE):
137          return self.generPARAMETRE(obj)
138       elif isinstance(obj,EVAL):
139          return self.generEVAL(obj)
140       elif isinstance(obj,COMMANDE_COMM):
141          return self.generCOMMANDE_COMM(obj)
142       elif isinstance(obj,JDC):
143          return self.generJDC(obj)
144       elif isinstance(obj,MCNUPLET):
145          return self.generMCNUPLET(obj)
146       else:
147          raise "Type d'objet non prévu",obj
148
149    def generJDC(self,obj):
150       """
151          Cette méthode convertit un objet JDC en une liste de chaines de
152          caractères à la syntaxe python
153       """
154       l=[]
155       if obj.definition.l_niveaux == ():
156          # Il n'y a pas de niveaux
157          for etape in obj.etapes:
158             l.append(self.generator(etape))
159       else:
160          # Il y a des niveaux
161          for etape_niveau in obj.etapes_niveaux:
162             l.extend(self.generator(etape_niveau))
163       if l != [] :
164          # Si au moins une étape, on ajoute le retour chariot sur la dernière étape
165          if type(l[-1])==types.ListType:
166             l[-1][-1] = l[-1][-1]+'\n'
167          elif type(l[-1])==types.StringType:
168             l[-1] = l[-1]+'\n'
169       return l
170
171    def generMCNUPLET(self,obj):
172       """ 
173           Méthode générant une représentation de self permettant son ecriture
174           dans le format python
175       """
176       l=[]
177       l.append('(')
178       for v in obj.mc_liste:
179         text = re.sub(".*=","",self.generator(v))
180         l.append(text)
181       l.append('),')
182       return l
183
184    def generCOMMANDE_COMM(self,obj):
185       """
186          Cette méthode convertit un COMMANDE_COMM
187          en une liste de chaines de caractères à la syntaxe python
188       """
189       l_lignes = string.split(obj.valeur,'\n')
190       txt=''
191       for ligne in l_lignes:
192           txt = txt + '##'+ligne+'\n'
193       return txt
194
195    def generEVAL(self,obj):
196       """
197          Cette méthode convertit un EVAL
198          en une liste de chaines de caractères à la syntaxe python
199       """
200       return 'EVAL("""'+ obj.valeur +'""")'
201
202    def generCOMMENTAIRE(self,obj):
203       """
204          Cette méthode convertit un COMMENTAIRE
205          en une liste de chaines de caractères à la syntaxe python
206       """
207       # modification pour répondre à la demande de C. Durand, d'éviter
208       # l'ajout systématique d'un dièse, à la suite du commentaire
209       # Dans la chaine de caracteres obj.valeur, on supprime le dernier
210       # saut de ligne
211       sans_saut = re.sub("\n$","",obj.valeur)
212       l_lignes = string.split(sans_saut,'\n')
213       txt=''
214       for ligne in l_lignes:
215         txt = txt + '#'+ligne+'\n'
216
217       # suppression du dernier saut de ligne
218       txt = re.sub("\n$","",txt)
219       return txt
220
221    def generPARAMETRE_EVAL(self,obj):
222       """
223          Cette méthode convertit un PARAMETRE_EVAL
224          en une liste de chaines de caractères à la syntaxe python
225       """
226       if obj.valeur == None:
227          return obj.nom + ' = None ;\n'
228       else:
229          return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
230
231    def generPARAMETRE(self,obj):
232       """
233          Cette méthode convertit un PARAMETRE
234          en une liste de chaines de caractères à la syntaxe python
235       """
236       if type(obj.valeur) == types.StringType:
237         return obj.nom + " = '" + obj.valeur + "';\n"
238       else:
239         return obj.nom + ' = ' + str(obj.valeur) + ';\n'
240
241    def generETAPE_NIVEAU(self,obj):
242       """
243          Cette méthode convertit une étape niveau
244          en une liste de chaines de caractères à la syntaxe python
245       """
246       l=[]
247       if obj.etapes_niveaux == []:
248         for etape in obj.etapes:
249           l.append(self.generator(etape))
250       else:
251         for etape_niveau in obj.etapes_niveaux:
252           l.extend(self.generator(etape_niveau))
253       return l
254
255    def generETAPE(self,obj):
256       """
257          Cette méthode convertit une étape
258          en une liste de chaines de caractères à la syntaxe python
259       """
260       try:
261         sdname= self.generator(obj.sd)
262       except:
263         sdname='sansnom'
264       l=[]
265       label=sdname + '='+obj.definition.nom+'('
266       l.append(label)
267       if obj.reuse != None :
268         str = 'reuse ='+ self.generator(obj.reuse) + ','
269         l.append(str)
270       for v in obj.mc_liste:
271         if isinstance(v,MCBLOC) :
272           liste=self.generator(v)
273           for mocle in liste :
274             l.append(mocle)
275         elif isinstance(v,MCSIMP) :
276           text=self.generator(v)
277           l.append(v.nom+'='+text)
278         else:
279           # MCFACT ou MCList
280           liste=self.generator(v)
281           liste[0]=v.nom+'='+liste[0]
282           l.append(liste)
283       if len(l) == 1:
284         l[0]=label+');'
285       else :
286         l.append(');')
287       return l
288
289    def generFORM_ETAPE(self,obj):
290         """
291             Méthode particulière pour les objets de type FORMULE
292         """
293         l=[]
294         nom = obj.get_nom()
295         if nom == '' : nom = 'sansnom'
296         if len(obj.mc_liste)>0:
297             l.append(nom + ' = FORMULE(')
298             s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
299             l.append(s)
300             l.append(');')
301         else:
302             l.append(nom+' = FORMULE();')
303         return l
304
305    def generMACRO_ETAPE(self,obj):
306       """
307          Cette méthode convertit une macro-étape
308          en une liste de chaines de caractères à la syntaxe python
309       """
310       if obj.definition.nom == 'FORMULE' : return self.gen_formule(obj)
311       try:
312         if obj.sd == None:
313           sdname=''
314         else:
315           sdname= self.generator(obj.sd)+'='
316       except:
317         sdname='sansnom='
318       l=[]
319       label = sdname + obj.definition.nom+'('
320       l.append(label)
321       if obj.reuse != None:
322          # XXX faut il la virgule ou pas ????
323          str = "reuse =" + self.generator(obj.reuse) + ','
324          l.append(str)
325       for v in obj.mc_liste:
326         if isinstance(v,MCBLOC) :
327           liste=self.generator(v)
328           for mocle in liste :
329             l.append(mocle)
330         elif isinstance(v,MCSIMP) :
331           text=self.generator(v)
332           l.append(v.nom+'='+text)
333         else:
334           # MCFACT ou MCList
335           liste=self.generator(v)
336           liste[0]=v.nom+'='+liste[0]
337           l.append(liste)
338
339       if len(l) == 1:
340         l[0]=label+');'
341       else :
342         l.append(');')
343       return l
344
345    def gen_formule(self,obj):
346       """
347            Méthode particuliere aux objets de type FORMULE
348       """
349       try:
350         if obj.sd == None:
351           sdname=''
352         else:
353           sdname= self.generator(obj.sd)
354       except:
355         sdname='sansnom'
356       l=[]
357       label=sdname + ' = FORMULE('
358       l.append(label)
359       for v in obj.mc_liste:
360         s=''
361         s= v.nom+':'+sdname+'('+v.valeur+')'
362         l.append(s)
363       if len(l) == 1:
364         l[0]=label+');'
365       else :
366         l.append(');')
367       return l
368
369    def generPROC_ETAPE(self,obj):
370       """
371          Cette méthode convertit une PROC étape
372          en une liste de chaines de caractères à la syntaxe python
373       """
374       l=[]
375       label=obj.definition.nom+'('
376       l.append(label)
377       for v in obj.mc_liste:
378         if isinstance(v,MCBLOC) :
379           liste=self.generator(v)
380           for mocle in liste :
381             l.append(mocle)
382         elif isinstance(v,MCSIMP) :
383           text=self.generator(v)
384           l.append(v.nom+'='+text)
385         else:
386           # MCFACT ou MCList
387           liste=self.generator(v)
388           liste[0]=v.nom+'='+liste[0]
389           l.append(liste)
390
391       if len(l) == 1:
392         l[0]=label+');'
393       else :
394         l.append(');')
395       return l
396
397    def generASSD(self,obj):
398       """
399           Convertit un objet dérivé d'ASSD en une chaine de caractères à la
400           syntaxe python
401       """
402       return obj.get_name()
403
404    def generMCFACT(self,obj):
405       """
406           Convertit un objet MCFACT en une liste de chaines de caractères à la
407           syntaxe python
408       """
409       l=[]
410       l.append('_F(')
411       for v in obj.mc_liste:
412          if not isinstance(v,MCSIMP) and not isinstance (v,MCBLOC) :
413            # on est en présence d'une entite composée : on récupère une liste
414            liste=self.generator(v)
415            liste[0]=v.nom+'='+liste[0]
416            l.append(liste)
417          elif isinstance(v,MCBLOC):
418            liste=self.generator(v)
419            for arg in liste :
420              l.append(arg)
421          else:
422            # on est en présence d'un MCSIMP : on récupère une string
423            text =self.generator(v)
424            l.append(v.nom+'='+text)
425       # il faut être plus subtil dans l'ajout de la virgule en différenciant 
426       # le cas où elle est obligatoire (si self a des frères cadets 
427       # dans self.parent) ou non
428       # (cas où self est seul ou le benjamin de self.parent)
429       l.append('),')
430       return l
431
432    def generMCList(self,obj):
433       """
434           Convertit un objet MCList en une liste de chaines de caractères à la
435           syntaxe python
436       """
437       l=[]
438       str =  '('
439       l.append(str)
440       for mcfact in obj.data:
441          l.append(self.generator(mcfact))
442       l.append('),')
443       return l
444
445    def generMCBLOC(self,obj):
446       """
447           Convertit un objet MCBLOC en une liste de chaines de caractères à la
448           syntaxe python
449       """
450       l=[]
451       for v in obj.mc_liste:
452         if isinstance(v,MCBLOC) :
453           liste=self.generator(v)
454           for mocle in liste :
455             l.append(mocle)
456         elif isinstance(v,MCList):
457           liste=self.generator(v)
458           liste[0]=v.nom+'='+liste[0]
459           for mocle in liste :
460             l.append(mocle)
461         else:
462           data=self.generator(v)
463           if type(data) == types.ListType:
464             data[0]=v.nom+'='+data[0]
465           else:
466             data=v.nom+'='+data
467           l.append(data)
468       return l
469
470    def generMCSIMP(self,obj) :
471       """
472           Convertit un objet MCSIMP en une liste de chaines de caractères à la
473           syntaxe python
474       """
475       if type(obj.valeur) in (types.TupleType,types.ListType) :
476          s = ''
477          for val in obj.valeur :
478             if type(val) == types.InstanceType :
479                if hasattr(obj.etape,'sdprods') and val in obj.etape.sdprods :
480                   s = s + "CO('"+ self.generator(val) +"')"
481                elif val.__class__.__name__ == 'CO':
482                   s = s + "CO('"+ self.generator(val) +"')"
483                elif isinstance(val,PARAMETRE):
484                   # il ne faut pas prendre la string que retourne gener
485                   # mais seulement le nom dans le cas d'un paramètre
486                   s = s + val.nom
487                else:
488                   s = s + self.generator(val)
489             elif type(val) == types.FloatType :
490                # Pour un flottant on utilise str qui a une precision de
491                # "seulement" 12 chiffres : evite les flottants du genre 0.599999999999998
492                s = s + str(val)
493             else :
494                # Pour les autres types on utilise repr
495                s = s + `val`
496             s = s + ','
497          if len(obj.valeur) > 1:
498             s = '(' + s + '),'
499       else :
500          val=obj.valeur
501          if type(val) == types.InstanceType :
502             if hasattr(obj.etape,'sdprods') and val in obj.etape.sdprods :
503                s = "CO('"+ self.generator(val) +"')"
504             elif val.__class__.__name__ == 'CO':
505                 s = "CO('"+ self.generator(val) +"')"
506             elif isinstance(val,PARAMETRE):
507                 # il ne faut pas prendre la string que retourne gener
508                 # mais seulement le nom dans le cas d'un paramètre
509                 s = val.nom
510             else:
511                 s = self.generator(val)
512          elif type(val) == types.FloatType :
513             # Pour un flottant on utilise str 
514             s = str(val)
515          else :
516             # Pour les autres types on utilise repr
517             s = `val`
518          s= s + ','
519       return s
520
521