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