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.
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.
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.
19 # ======================================================================
21 Ce module contient le plugin generateur de fichier au format asterv5 pour EFICAS.
28 from Noyau import N_CR
29 from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
30 from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
31 from Accas import GEOM,ASSD
32 from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
33 from Formatage import Formatage
37 Retourne les informations nécessaires pour le chargeur de plugins
39 Ces informations sont retournées dans un dictionnaire
44 # La factory pour créer une instance du plugin
45 'factory' : AsterGenerator,
51 Ce generateur parcourt un objet de type JDC et produit
52 un fichier au format asterv5
54 L'acquisition et le parcours sont réalisés par la méthode
55 generator.gener(objet_jdc,format)
57 L'écriture du fichier au format asterv5 est réalisée par appel de la méthode
58 generator.writefile(nom_fichier)
60 Ses caractéristiques principales sont exposées dans des attributs
62 - extensions : qui donne une liste d'extensions de fichier préconisées
65 # Les extensions de fichier préconisées
68 def __init__(self,cr=None):
69 # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
73 self.cr=N_CR.CR(debut='CR generateur format asterv5',
74 fin='fin CR format asterv5')
75 # Le texte au format asterv5 est stocké dans l'attribut text
78 def writefile(self,filename):
83 def gener(self,obj,format='brut'):
85 Retourne une représentation du JDC obj sous une
86 forme qui est paramétrée par format.
87 Si format vaut 'brut', retourne une liste de listes de ...
88 Si format vaut 'standard', retourne un texte obtenu par concaténation de la liste
89 Si format vaut 'beautifie', retourne le meme texte beautifié
91 liste= self.generator(obj)
94 elif format == 'standard':
95 self.text=string.join(liste)
96 elif format == 'beautifie':
97 jdc_formate = Formatage(liste,sep=':',l_max=72)
98 self.text=jdc_formate.formate_jdc()
100 raise "Format pas implémenté : "+format
103 def generator(self,obj):
105 Cette methode joue un role d'aiguillage en fonction du type de obj
106 On pourrait utiliser les méthodes accept et visitxxx à la
107 place (dépend des gouts !!!)
109 # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
110 if isinstance(obj,PROC_ETAPE):
111 return self.generPROC_ETAPE(obj)
112 elif isinstance(obj,MACRO_ETAPE):
113 return self.generMACRO_ETAPE(obj)
114 elif isinstance(obj,FORM_ETAPE):
115 return self.generFORM_ETAPE(obj)
116 elif isinstance(obj,ETAPE):
117 return self.generETAPE(obj)
118 elif isinstance(obj,MCFACT):
119 return self.generMCFACT(obj)
120 elif isinstance(obj,MCList):
121 return self.generMCList(obj)
122 elif isinstance(obj,MCBLOC):
123 return self.generMCBLOC(obj)
124 elif isinstance(obj,MCSIMP):
125 return self.generMCSIMP(obj)
126 elif isinstance(obj,ASSD):
127 return self.generASSD(obj)
128 elif isinstance(obj,ETAPE_NIVEAU):
129 return self.generETAPE_NIVEAU(obj)
130 elif isinstance(obj,COMMENTAIRE):
131 return self.generCOMMENTAIRE(obj)
132 # Attention doit etre placé avant PARAMETRE (raison : héritage)
133 elif isinstance(obj,PARAMETRE_EVAL):
134 return self.generPARAMETRE_EVAL(obj)
135 elif isinstance(obj,PARAMETRE):
136 return self.generPARAMETRE(obj)
137 elif isinstance(obj,EVAL):
138 return self.generEVAL(obj)
139 elif isinstance(obj,COMMANDE_COMM):
140 return self.generCOMMANDE_COMM(obj)
141 elif isinstance(obj,JDC):
142 return self.generJDC(obj)
144 raise "Type d'objet non prévu",obj
146 def generJDC(self,obj):
148 Cette méthode convertit un objet JDC en une liste de chaines de
149 caractères à la syntaxe asterv5
152 if obj.definition.l_niveaux == ():
153 # Il n'y a pas de niveaux
154 for etape in obj.etapes:
155 l.append(self.generator(etape))
158 for etape_niveau in obj.etapes_niveaux:
159 l.extend(self.generator(etape_niveau))
161 # Si au moins une étape, on ajoute le retour chariot sur la dernière étape
162 if type(l[-1])==types.ListType:
163 l[-1][-1] = l[-1][-1]+'\n'
164 elif type(l[-1])==types.StringType:
168 def generCOMMANDE_COMM(self,obj):
170 Cette méthode convertit un COMMANDE_COMM
171 en une liste de chaines de caractères à la syntaxe asterv5
173 l_lignes = string.split(obj.valeur,'\n')
175 for ligne in l_lignes:
176 txt = txt + '%%'+ligne+'\n'
179 def generEVAL(self,obj):
181 Cette méthode convertit un EVAL
182 en une liste de chaines de caractères à la syntaxe asterv5
184 return 'EVAL("'+ obj.valeur +'")'
186 def generCOMMENTAIRE(self,obj):
188 Cette méthode convertit un COMMENTAIRE
189 en une liste de chaines de caractères à la syntaxe asterv5
191 l_lignes = string.split(obj.valeur,'\n')
193 for ligne in l_lignes:
194 txt = txt + '%'+ligne+'\n'
197 def generPARAMETRE_EVAL(self,obj):
199 Cette méthode convertit un PARAMETRE_EVAL
200 en une liste de chaines de caractères à la syntaxe asterv5
202 if obj.valeur == None:
203 return obj.nom + ' = None ;\n'
205 return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
207 def generPARAMETRE(self,obj):
209 Cette méthode convertit un PARAMETRE
210 en une liste de chaines de caractères à la syntaxe asterv5
212 if type(obj.valeur) == types.StringType:
213 return obj.nom + " = '" + obj.valeur + "';\n"
215 return obj.nom + ' = ' + str(obj.valeur) + ';\n'
217 def generETAPE_NIVEAU(self,obj):
219 Cette méthode convertit une étape niveau
220 en une liste de chaines de caractères à la syntaxe asterv5
223 if obj.etapes_niveaux == []:
224 for etape in obj.etapes:
225 l.append(self.generator(etape))
227 for etape_niveau in obj.etapes_niveaux:
228 l.extend(self.generator(etape_niveau))
231 def generETAPE(self,obj):
233 Cette méthode convertit une étape
234 en une liste de chaines de caractères à la syntaxe asterv5
237 if obj.reuse != None:
238 sdname= "&" + self.generator(obj.reuse)
240 sdname= self.generator(obj.sd)
244 label=sdname + '='+obj.definition.nom+'('
246 for v in obj.mc_liste:
247 if isinstance(v,MCBLOC) or isinstance(v,MCList):
248 liste=self.generator(v)
252 l.append(self.generator(v))
259 def generFORM_ETAPE(self,obj):
261 Méthode particulière pour les objets de type FORMULE
265 if nom == '' : nom = 'sansnom'
266 if len(obj.mc_liste)>0:
267 l.append(nom + ' = FORMULE(')
268 s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
272 l.append(nom+' = FORMULE();')
275 def generMACRO_ETAPE(self,obj):
277 Cette méthode convertit une macro-étape
278 en une liste de chaines de caractères à la syntaxe asterv5
280 if obj.definition.nom == 'FORMULE' : return self.gen_ast_formule(obj)
282 if obj.reuse != None:
283 sdname= "&" + self.generator(obj.reuse)+'='
287 sdname= self.generator(obj.sd)+'='
291 label = sdname + obj.definition.nom+'('
293 for v in obj.mc_liste:
294 if isinstance(v,MCBLOC) or isinstance(v,MCList):
295 liste=self.generator(v)
300 l.append(self.generator(v))
307 def gen_ast_formule(self,obj):
309 Méthode gen_ast particuliere aux objets de type FORMULE
313 sdname= self.generator(obj.sd)
318 for v in obj.mc_liste:
320 s= v.nom+':'+sdname+'('+v.valeur+')'
328 def generPROC_ETAPE(self,obj):
330 Cette méthode convertit une étape
331 en une liste de chaines de caractères à la syntaxe asterv5
334 label=obj.definition.nom+'('
336 for v in obj.mc_liste:
337 if isinstance(v,MCBLOC) or isinstance(v,MCList):
338 liste=self.generator(v)
342 l.append(self.generator(v))
349 def generMCSIMP(self,obj) :
351 Convertit un objet MCSIMP en une liste de chaines de caractères à la
354 if type(obj.valeur) == types.TupleType :
356 for val in obj.valeur :
357 if s != '(': s = s + ','
358 if type(val) == types.InstanceType :
359 if isinstance(val,PARAMETRE):
360 # il ne faut pas prendre la string que retourne gen_ast
361 # mais seulement le nom dans le cas d'un paramètre
364 s = s + self.generator(val)
365 elif self.wait_geom(obj):
367 elif type(val) == types.FloatType :
368 #s = s + self.repr_float(val)
376 if type(obj.valeur) == types.InstanceType :
377 if isinstance(obj.valeur,PARAMETRE):
378 # il ne faut pas prendre la string que retourne gen_ast
379 # mais seulement str dans le cas d'un paramètre
382 s = self.generator(obj.valeur)
383 elif self.wait_geom(obj):
385 elif type(obj.valeur) == types.FloatType :
386 #s = self.repr_float(obj.valeur)
393 def wait_geom(self,obj):
394 for typ in obj.definition.type:
395 if type(typ) == types.ClassType :
396 if issubclass(typ,GEOM) : return 1
399 def repr_float(self,valeur):
401 Cette fonction représente le réel valeur comme une chaîne de caractères
402 sous forme mantisse exposant si nécessaire cad si le nombre contient plus de 5 caractères
403 NB : valeur est un réel au format Python ou une chaîne de caractères représentant un réel
405 if type(valeur) == types.StringType : valeur = eval(valeur)
406 if valeur == 0. : return '0.0'
407 if abs(valeur) > 1. :
408 if abs(valeur) < 10000. : return repr(valeur)
410 if abs(valeur) > 0.01 : return repr(valeur)
412 if string.find(t,'e') != -1 or string.find(t,'E') != -1 :
413 # le réel est déjà sous forme mantisse exposant !
414 # --> on remplace e par E
415 t=string.replace(t,'e','E')
416 # --> on doit encore vérifier que la mantisse contient bien un '.'
417 if string.find(t,'.')!= -1:
420 # -->il faut rajouter le point avant le E
421 t=string.replace(t,'E','.E')
429 if string.atof(t[0]) == 0.:
430 # réel plus petit que 1
434 while string.atof(t[0]) == 0. :
441 # réel plus grand que 1
443 if string.atof(t[1:]) == 0.:
444 l=string.split(t[1:],'.')
452 if pt != 1 : cpt = cpt + 1
456 if r+1 == len(t) or string.atof(t[r+1:]) == 0.:break
457 s=s+'E'+neg*'-'+repr(cpt)
460 def generASSD(self,obj):
462 Convertit un objet dérivé d'ASSD en une chaine de caractères à la
465 return obj.get_name()
467 def generMCFACT(self,obj):
469 Convertit un objet MCFACT en une liste de chaines de caractères à la
475 for v in obj.mc_liste:
476 if isinstance(v,MCBLOC) or isinstance(v,MCList):
477 liste=self.generator(v)
481 l.append(self.generator(v))
485 def generMCList(self,obj):
487 Convertit un objet MCList en une liste de chaines de caractères à la
491 for mcfact in obj.data:
492 l.append(self.generator(mcfact))
495 def generMCBLOC(self,obj):
497 Convertit un objet MCBLOC en une liste de chaines de caractères à la
501 for v in obj.mc_liste:
502 if isinstance(v,MCBLOC) or isinstance(v,MCList):
503 liste=self.generator(v)
507 l.append(self.generator(v))