]> SALOME platform Git repositories - tools/eficas.git/blob - generator/generator_python.py
Salome HOME
premiere version
[tools/eficas.git] / generator / generator_python.py
1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013   EDF R&D
3 #
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 # Lesser General Public License for more details.
13 #
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 #
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
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 import Accas
31 import Extensions
32 from Extensions.parametre import ITEM_PARAMETRE
33 from Formatage import Formatage
34 from Extensions.param2 import Formula
35
36 def entryPoint():
37    """
38        Retourne les informations necessaires pour le chargeur de plugins
39
40        Ces informations sont retournees dans un dictionnaire
41    """
42    return {
43         # Le nom du plugin
44           'name' : 'python',
45         # La factory pour creer 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 realises par la methode
56        generator.gener(objet_jdc,format)
57
58        L'ecriture du fichier au format ini par appel de la methode
59        generator.writefile(nom_fichier)
60
61        Ses caracteristiques principales sont exposees dans des attributs 
62        de classe :
63          - extensions : qui donne une liste d'extensions de fichier preconisees
64
65    """
66    # Les extensions de fichier preconisees
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 stocke dans l'attribut text
77       self.text=''
78       self.appli=None
79
80    def writefile(self,filename):
81       fp=open(filename,'w')
82       fp.write(self.text)
83       fp.close()
84
85    def gener(self,obj,format='brut',config=None):
86       """
87           Retourne une representation du JDC obj sous une
88           forme qui est parametree par format.
89           Si format vaut 'brut', retourne une liste de listes de ...
90           Si format vaut 'standard', retourne un texte obtenu par concatenation de la liste
91           Si format vaut 'beautifie', retourne le meme texte beautifie
92       """
93       self.appli=obj.get_jdc_root().appli
94       #self.appli=obj.appli
95       liste= self.generator(obj)
96       if format == 'brut':
97          self.text=liste
98       elif format == 'standard':
99          self.text=string.join(liste)
100       elif format == 'beautifie':
101          jdc_formate = Formatage(liste,mode='.py')
102          self.text=jdc_formate.formate_jdc()
103       else:
104          raise "Format pas implemente : "+format
105       return self.text
106
107    def generator(self,obj):
108       """
109          Cette methode joue un role d'aiguillage en fonction du type de obj
110          On pourrait utiliser les methodes accept et visitxxx a la 
111          place (depend des gouts !!!)
112       """
113       # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
114       if isinstance(obj,Accas.PROC_ETAPE):
115          return self.generPROC_ETAPE(obj)
116       # Attention doit etre place avant MACRO (raison : heritage)
117       elif isinstance(obj,Accas.FORM_ETAPE):
118          return self.generFORM_ETAPE(obj)
119       elif isinstance(obj,Accas.MACRO_ETAPE):
120          return self.generMACRO_ETAPE(obj)
121       elif isinstance(obj,Accas.ETAPE):
122          return self.generETAPE(obj)
123       elif isinstance(obj,Accas.MCFACT):
124          return self.generMCFACT(obj)
125       elif isinstance(obj,Accas.MCList):
126          return self.generMCList(obj)
127       elif isinstance(obj,Accas.MCBLOC):
128          return self.generMCBLOC(obj)
129       elif isinstance(obj,Accas.MCSIMP):
130          return self.generMCSIMP(obj)
131       elif isinstance(obj,Accas.ASSD):
132          return self.generASSD(obj)
133       elif isinstance(obj,Accas.ETAPE_NIVEAU):
134          return self.generETAPE_NIVEAU(obj)
135       elif isinstance(obj,Accas.COMMENTAIRE):
136          return self.generCOMMENTAIRE(obj)
137       # Attention doit etre place avant PARAMETRE (raison : heritage)
138       elif isinstance(obj,Accas.PARAMETRE_EVAL):
139          return self.generPARAMETRE_EVAL(obj)
140       elif isinstance(obj,Accas.PARAMETRE):
141          return self.generPARAMETRE(obj)
142       elif isinstance(obj,Accas.EVAL):
143          return self.generEVAL(obj)
144       elif isinstance(obj,Accas.COMMANDE_COMM):
145          return self.generCOMMANDE_COMM(obj)
146       elif isinstance(obj,Accas.JDC):
147          return self.generJDC(obj)
148       elif isinstance(obj,Accas.MCNUPLET):
149          return self.generMCNUPLET(obj)
150       elif isinstance(obj,ITEM_PARAMETRE):
151          return self.generITEM_PARAMETRE(obj)
152       elif isinstance(obj,Formula):
153          return self.generFormula(obj)
154       else:
155          raise "Type d'objet non prevu",obj
156
157    def generJDC(self,obj):
158       """
159          Cette methode convertit un objet JDC en une liste de chaines de
160          caracteres a la syntaxe python
161       """
162       l=[]
163       if obj.definition.l_niveaux == ():
164          # Il n'y a pas de niveaux
165          for etape in obj.etapes:
166             l.append(self.generator(etape))
167       else:
168          # Il y a des niveaux
169          for etape_niveau in obj.etapes_niveaux:
170             l.extend(self.generator(etape_niveau))
171       if l != [] :
172          # Si au moins une etape, on ajoute le retour chariot sur la derniere etape
173          if type(l[-1])==types.ListType:
174             l[-1][-1] = l[-1][-1]+'\n'
175          elif type(l[-1])==types.StringType:
176             l[-1] = l[-1]+'\n'
177       return l
178
179    def generMCNUPLET(self,obj):
180       """ 
181           Methode generant une representation de self permettant son ecriture
182           dans le format python
183       """
184       l=[]
185       l.append('(')
186       for v in obj.mc_liste:
187         text = re.sub(".*=","",self.generator(v))
188         l.append(text)
189       l.append('),')
190       return l
191
192    def generCOMMANDE_COMM(self,obj):
193       """
194          Cette methode convertit un COMMANDE_COMM
195          en une liste de chaines de caracteres a la syntaxe python
196       """
197       l_lignes = string.split(obj.valeur,'\n')
198       txt=''
199       for ligne in l_lignes:
200           txt = txt + '##'+ligne+'\n'
201       return txt
202
203    def generEVAL(self,obj):
204       """
205          Cette methode convertit un EVAL
206          en une liste de chaines de caracteres a la syntaxe python
207       """
208       return 'EVAL("""'+ obj.valeur +'""")'
209
210    def generCOMMENTAIRE(self,obj):
211       """
212          Cette methode convertit un COMMENTAIRE
213          en une liste de chaines de caracteres a la syntaxe python
214       """
215       # modification pour repondre a la demande de C. Durand, d'eviter
216       # l'ajout systematique d'un diese, a la suite du commentaire
217       # Dans la chaine de caracteres obj.valeur, on supprime le dernier
218       # saut de ligne
219       sans_saut = re.sub("\n$","",obj.valeur)
220       l_lignes = string.split(sans_saut,'\n')
221       txt=''
222       i=1
223       for ligne in l_lignes:
224         txt = txt + '#'+ligne+'\n'
225
226       # suppression du dernier saut de ligne
227       #txt = re.sub("\n$","",txt)
228       # on ajoute un saut de ligne avant
229       pattern=re.compile(" ?\#")
230       m=pattern.match(txt)
231       if m:
232          txt="\n"+txt
233       return txt
234
235    def generPARAMETRE_EVAL(self,obj):
236       """
237          Cette methode convertit un PARAMETRE_EVAL
238          en une liste de chaines de caracteres a la syntaxe python
239       """
240       if obj.valeur == None:
241          return obj.nom + ' = None ;\n'
242       else:
243          return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
244
245    def generITEM_PARAMETRE(self,obj):
246        return repr(obj) 
247
248    def generFormula(self,obj):
249        #return repr(obj) 
250        return str(obj) 
251
252    def generPARAMETRE(self,obj):
253       """
254          Cette methode convertit un PARAMETRE
255          en une liste de chaines de caracteres a la syntaxe python
256       """
257       return repr(obj) + ";\n"
258
259    def generETAPE_NIVEAU(self,obj):
260       """
261          Cette methode convertit une etape niveau
262          en une liste de chaines de caracteres a la syntaxe python
263       """
264       l=[]
265       if obj.etapes_niveaux == []:
266         for etape in obj.etapes:
267           l.append(self.generator(etape))
268       else:
269         for etape_niveau in obj.etapes_niveaux:
270           l.extend(self.generator(etape_niveau))
271       return l
272
273    def generETAPE(self,obj):
274       """
275          Cette methode convertit une etape
276          en une liste de chaines de caracteres a la syntaxe python
277       """
278       try:
279         sdname= self.generator(obj.sd)
280         if  string.find(sdname,'SD_') != -1: sdname='sansnom'
281       except:
282         sdname='sansnom'
283       l=[]
284       label=sdname + '='+obj.definition.nom+'('
285       l.append(label)
286       if obj.reuse != None :
287         str = 'reuse ='+ self.generator(obj.reuse) + ','
288         l.append(str)
289       for v in obj.mc_liste:
290         if isinstance(v,Accas.MCBLOC) :
291           liste=self.generator(v)
292           for mocle in liste :
293             l.append(mocle)
294         elif isinstance(v,Accas.MCSIMP) :
295           text=self.generator(v)
296           l.append(v.nom+'='+text)
297         else:
298           # MCFACT ou MCList
299           liste=self.generator(v)
300           liste[0]=v.nom+'='+liste[0]
301           l.append(liste)
302       if len(l) == 1:
303         l[0]=label+');'
304       else :
305         l.append(');')
306       return l
307
308    def generFORM_ETAPE(self,obj):
309         """
310             Methode particuliere pour les objets de type FORMULE
311         """
312         l=[]
313         nom = obj.get_nom()
314         if nom == '' : nom = 'sansnom'
315         l.append(nom + ' = FORMULE(')
316         for v in obj.mc_liste:
317             text=self.generator(v)
318             l.append(v.nom+'='+text)
319         l.append(');')
320         return l
321
322    def generMACRO_ETAPE(self,obj):
323       """
324          Cette methode convertit une macro-etape
325          en une liste de chaines de caracteres a la syntaxe python
326       """
327       try:
328         if obj.sd == None:
329           sdname=''
330         else:
331           sdname= self.generator(obj.sd)+'='
332       except:
333         sdname='sansnom='
334       l=[]
335       label = sdname + obj.definition.nom+'('
336       l.append(label)
337       if obj.reuse != None:
338          # XXX faut il la virgule ou pas ????
339          str = "reuse =" + self.generator(obj.reuse) + ','
340          l.append(str)
341       for v in obj.mc_liste:
342         if isinstance(v,Accas.MCBLOC) :
343           liste=self.generator(v)
344           for mocle in liste :
345             l.append(mocle)
346         elif isinstance(v,Accas.MCSIMP) :
347           text=self.generator(v)
348           l.append(v.nom+'='+text)
349         else:
350           # MCFACT ou MCList
351           liste=self.generator(v)
352           liste[0]=v.nom+'='+liste[0]
353           l.append(liste)
354
355       if len(l) == 1:
356         l[0]=label+');'
357       else :
358         l.append(');')
359       return l
360
361    def generPROC_ETAPE(self,obj):
362       """
363          Cette methode convertit une PROC etape
364          en une liste de chaines de caracteres a la syntaxe python
365       """
366       l=[]
367       label=obj.definition.nom+'('
368       l.append(label)
369       for v in obj.mc_liste:
370         if isinstance(v,Accas.MCBLOC) :
371           liste=self.generator(v)
372           for mocle in liste :
373             l.append(mocle)
374         elif isinstance(v,Accas.MCSIMP) :
375           text=self.generator(v)
376           l.append(v.nom+'='+text)
377         else:
378           # MCFACT ou MCList
379           liste=self.generator(v)
380           liste[0]=v.nom+'='+liste[0]
381           l.append(liste)
382
383       if len(l) == 1:
384         l[0]=label+');'
385       else :
386         l.append(');')
387       return l
388
389    def generASSD(self,obj):
390       """
391           Convertit un objet derive d'ASSD en une chaine de caracteres a la
392           syntaxe python
393       """
394       return obj.get_name()
395
396    def generMCFACT(self,obj):
397       """
398           Convertit un objet MCFACT en une liste de chaines de caracteres a la
399           syntaxe python
400       """
401       l=[]
402       l.append('_F(')
403       for v in obj.mc_liste:
404          if not isinstance(v,Accas.MCSIMP) and not isinstance (v,Accas.MCBLOC) :
405            # on est en presence d'une entite composee : on recupere une liste
406            liste=self.generator(v)
407            liste[0]=v.nom+'='+liste[0]
408            l.append(liste)
409          elif isinstance(v,Accas.MCBLOC):
410            liste=self.generator(v)
411            for arg in liste :
412              l.append(arg)
413          else:
414            # on est en presence d'un MCSIMP : on recupere une string
415            text =self.generator(v)
416            l.append(v.nom+'='+text)
417            if obj.nom=="Observers": print l
418       # il faut etre plus subtil dans l'ajout de la virgule en differenciant 
419       # le cas ou elle est obligatoire (si self a des freres cadets 
420       # dans self.parent) ou non
421       # (cas ou self est seul ou le benjamin de self.parent)
422       l.append('),')
423       return l
424
425    def generMCList(self,obj):
426       """
427           Convertit un objet MCList en une liste de chaines de caracteres a la
428           syntaxe python
429       """
430       if len(obj.data) > 1:
431          l=['(']
432          for mcfact in obj.data: 
433              l.append(self.generator(mcfact))
434          l.append('),')
435       else:
436          l= self.generator(obj.data[0])
437       return l
438
439    def generMCBLOC(self,obj):
440       """
441           Convertit un objet MCBLOC en une liste de chaines de caracteres a la
442           syntaxe python
443       """
444       l=[]
445       for v in obj.mc_liste:
446         if isinstance(v,Accas.MCBLOC) :
447           liste=self.generator(v)
448           for mocle in liste :
449             l.append(mocle)
450         elif isinstance(v,Accas.MCFACT):
451           liste=self.generator(v)
452         elif isinstance(v,Accas.MCList):
453           liste=self.generator(v)
454           liste[0]=v.nom+'='+liste[0]
455           # PN  essai de correction bug identation
456           if (hasattr(v,'data')) :
457             if (isinstance(v.data[0],Accas.MCFACT) and (len(v.data) == 1)):
458                l.append(liste)
459             else:
460                for mocle in liste :
461                  l.append(mocle)
462           else :
463              for mocle in liste :
464                l.append(mocle)
465         else:
466           data=self.generator(v)
467           if type(data) == types.ListType:
468             data[0]=v.nom+'='+data[0]
469           else:
470             data=v.nom+'='+data
471           l.append(data)
472       return l
473
474
475    def format_item(self,valeur,etape,obj):
476       if (type(valeur) == types.FloatType or 'R' in obj.definition.type) and not(isinstance(valeur,Accas.PARAMETRE)) :
477          # Pour un flottant on utilise str
478          # ou la notation scientifique
479          # On ajoute un . si il n y en a pas dans la valeur
480          s = str(valeur)
481          if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.0'
482          clefobj=etape.get_sdname()
483          if self.appli.appliEficas and self.appli.appliEficas.dict_reels.has_key(clefobj):
484            if self.appli.appliEficas.dict_reels[clefobj].has_key(valeur):
485              s=self.appli.appliEficas.dict_reels[clefobj][valeur]
486          
487       elif type(valeur) == types.StringType :
488          if valeur.find('\n') == -1:
489             # pas de retour chariot, on utilise repr
490             s = repr(valeur)
491          elif valeur.find('"""') == -1:
492             # retour chariot mais pas de triple ", on formatte
493             s='"""'+valeur+'"""'
494          else:
495             s = repr(valeur)
496       elif isinstance(valeur,Accas.CO) or hasattr(etape,'sdprods') and valeur in etape.sdprods:
497          s = "CO('"+ self.generator(valeur) +"')"
498       elif isinstance(valeur,Accas.ASSD):
499          s = self.generator(valeur)
500       elif isinstance(valeur,Accas.PARAMETRE):
501          # il ne faut pas prendre la string que retourne gener
502          # mais seulement le nom dans le cas d'un parametre
503          s = valeur.nom
504
505       #elif type(valeur) == types.InstanceType or isinstance(valeur,object):
506       #   if valeur.__class__.__name__ == 'CO' or hasattr(etape,'sdprods') and valeur in etape.sdprods :
507       #      s = "CO('"+ self.generator(valeur) +"')"
508       #   elif isinstance(valeur,Accas.PARAMETRE):
509             # il ne faut pas prendre la string que retourne gener
510             # mais seulement le nom dans le cas d'un parametre
511       #      s = valeur.nom
512       #   else:
513       #      print valeur
514       #      s = self.generator(valeur)
515
516       else :
517          # Pour les autres types on utilise repr
518          s = repr(valeur)
519       return s
520
521    def generMCSIMP(self,obj) :
522       """
523           Convertit un objet MCSIMP en une liste de chaines de caracteres a la
524           syntaxe python
525       """
526       waitTuple=0
527       if type(obj.valeur) in (types.TupleType,types.ListType) :
528          s = ''
529          for ss_type in obj.definition.type:
530           if repr(ss_type).find('Tuple') != -1 :
531              waitTuple=1
532              break
533
534          if waitTuple :
535             s = str(obj.valeur) +','
536             obj.valeurFormatee=obj.valeur
537          else :
538             obj.valeurFormatee=[]
539             for val in obj.valeur :
540                s =s +self.format_item(val,obj.etape,obj) + ','
541                obj.valeurFormatee.append(self.format_item(val,obj.etape,obj))
542             if len(obj.valeur) > 1:
543                s = '(' + s + '),'
544             if obj.valeur==[] : s="(),"
545          if obj.nbrColonnes() :
546             s=self.formatColonnes(obj.nbrColonnes(),obj.valeur,obj)
547       else :
548          obj.valeurFormatee=obj.valeur
549          s=self.format_item(obj.valeur,obj.etape,obj) + ','
550       return s
551
552
553    def formatColonnes(self,nbrColonnes,listeValeurs,obj):
554       #try :
555       print listeValeurs
556       if 1 == 1 :
557         indice=0
558         textformat="("
559         while ( indice < len(listeValeurs) ) :
560           try :
561           #if 1 :
562             for l in range(nbrColonnes) :
563                 texteVariable=self.format_item(listeValeurs[indice],obj.etape,obj)
564                 textformat=textformat+texteVariable+" ,"
565                 indice=indice+1
566             textformat=textformat+"\n"
567           except :
568           #else :
569             while ( indice < len(listeValeurs) ) :
570                 texteVariable=self.format_item(listeValeurs[indice],obj.etape,obj)
571                 textformat=textformat+texteVariable+", "
572                 indice=indice+1
573             textformat=textformat+"\n"
574         textformat=textformat[0:-1]+"),\n"
575       #except :
576       else :
577          textformat=str(obj.valeur)
578       print textformat
579       return textformat