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.
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.
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.
20 # ======================================================================
22 Ce module contient le plugin generateur de fichier au format asterv5 pour EFICAS.
29 from Noyau import N_CR
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
33 from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
34 from Formatage import Formatage
38 Retourne les informations nécessaires pour le chargeur de plugins
40 Ces informations sont retournées dans un dictionnaire
45 # La factory pour créer une instance du plugin
46 'factory' : AsterGenerator,
52 Ce generateur parcourt un objet de type JDC et produit
53 un fichier au format asterv5
55 L'acquisition et le parcours sont réalisés par la méthode
56 generator.gener(objet_jdc,format)
58 L'écriture du fichier au format asterv5 est réalisée par appel de la méthode
59 generator.writefile(nom_fichier)
61 Ses caractéristiques principales sont exposées dans des attributs
63 - extensions : qui donne une liste d'extensions de fichier préconisées
66 # Les extensions de fichier préconisées
69 def __init__(self,cr=None):
70 # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
74 self.cr=N_CR.CR(debut='CR generateur format asterv5',
75 fin='fin CR format asterv5')
76 # Le texte au format asterv5 est stocké dans l'attribut text
79 def writefile(self,filename):
84 def gener(self,obj,format='brut'):
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é
92 liste= self.generator(obj)
95 elif format == 'standard':
96 self.text=string.join(liste)
97 elif format == 'beautifie':
98 jdc_formate = Formatage(liste,sep=':',l_max=72)
99 self.text=jdc_formate.formate_jdc()
101 raise "Format pas implémenté : "+format
104 def generator(self,obj):
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 !!!)
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)
145 raise "Type d'objet non prévu",obj
147 def generJDC(self,obj):
149 Cette méthode convertit un objet JDC en une liste de chaines de
150 caractères à la syntaxe asterv5
153 if obj.definition.l_niveaux == ():
154 # Il n'y a pas de niveaux
155 for etape in obj.etapes:
156 l.append(self.generator(etape))
159 for etape_niveau in obj.etapes_niveaux:
160 l.extend(self.generator(etape_niveau))
162 # Si au moins une étape, on ajoute le retour chariot sur la dernière étape
163 if type(l[-1])==types.ListType:
164 l[-1][-1] = l[-1][-1]+'\n'
165 elif type(l[-1])==types.StringType:
169 def generCOMMANDE_COMM(self,obj):
171 Cette méthode convertit un COMMANDE_COMM
172 en une liste de chaines de caractères à la syntaxe asterv5
174 l_lignes = string.split(obj.valeur,'\n')
176 for ligne in l_lignes:
177 txt = txt + '%%'+ligne+'\n'
180 def generEVAL(self,obj):
182 Cette méthode convertit un EVAL
183 en une liste de chaines de caractères à la syntaxe asterv5
185 return 'EVAL("'+ obj.valeur +'")'
187 def generCOMMENTAIRE(self,obj):
189 Cette méthode convertit un COMMENTAIRE
190 en une liste de chaines de caractères à la syntaxe asterv5
192 l_lignes = string.split(obj.valeur,'\n')
194 for ligne in l_lignes:
195 txt = txt + '%'+ligne+'\n'
198 def generPARAMETRE_EVAL(self,obj):
200 Cette méthode convertit un PARAMETRE_EVAL
201 en une liste de chaines de caractères à la syntaxe asterv5
203 if obj.valeur == None:
204 return obj.nom + ' = None ;\n'
206 return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
208 def generPARAMETRE(self,obj):
210 Cette méthode convertit un PARAMETRE
211 en une liste de chaines de caractères à la syntaxe asterv5
213 if type(obj.valeur) == types.StringType:
214 return obj.nom + " = '" + obj.valeur + "';\n"
216 return obj.nom + ' = ' + str(obj.valeur) + ';\n'
218 def generETAPE_NIVEAU(self,obj):
220 Cette méthode convertit une étape niveau
221 en une liste de chaines de caractères à la syntaxe asterv5
224 if obj.etapes_niveaux == []:
225 for etape in obj.etapes:
226 l.append(self.generator(etape))
228 for etape_niveau in obj.etapes_niveaux:
229 l.extend(self.generator(etape_niveau))
232 def generETAPE(self,obj):
234 Cette méthode convertit une étape
235 en une liste de chaines de caractères à la syntaxe asterv5
238 if obj.reuse != None:
239 sdname= "&" + self.generator(obj.reuse)
241 sdname= self.generator(obj.sd)
245 label=sdname + '='+obj.definition.nom+'('
247 for v in obj.mc_liste:
248 if isinstance(v,MCBLOC) or isinstance(v,MCList):
249 liste=self.generator(v)
253 l.append(self.generator(v))
260 def generFORM_ETAPE(self,obj):
262 Méthode particulière pour les objets de type FORMULE
266 if nom == '' : nom = 'sansnom'
267 if len(obj.mc_liste)>0:
268 l.append(nom + ' = FORMULE(')
269 s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
273 l.append(nom+' = FORMULE();')
276 def generMACRO_ETAPE(self,obj):
278 Cette méthode convertit une macro-étape
279 en une liste de chaines de caractères à la syntaxe asterv5
281 if obj.definition.nom == 'FORMULE' : return self.gen_ast_formule(obj)
283 if obj.reuse != None:
284 sdname= "&" + self.generator(obj.reuse)+'='
288 sdname= self.generator(obj.sd)+'='
292 label = sdname + obj.definition.nom+'('
294 for v in obj.mc_liste:
295 if isinstance(v,MCBLOC) or isinstance(v,MCList):
296 liste=self.generator(v)
301 l.append(self.generator(v))
308 def gen_ast_formule(self,obj):
310 Méthode gen_ast particuliere aux objets de type FORMULE
314 sdname= self.generator(obj.sd)
319 for v in obj.mc_liste:
321 s= v.nom+':'+sdname+'('+v.valeur+')'
329 def generPROC_ETAPE(self,obj):
331 Cette méthode convertit une étape
332 en une liste de chaines de caractères à la syntaxe asterv5
335 label=obj.definition.nom+'('
337 for v in obj.mc_liste:
338 if isinstance(v,MCBLOC) or isinstance(v,MCList):
339 liste=self.generator(v)
343 l.append(self.generator(v))
350 def generMCSIMP(self,obj) :
352 Convertit un objet MCSIMP en une liste de chaines de caractères à la
355 if type(obj.valeur) == types.TupleType :
357 for val in obj.valeur :
358 if s != '(': s = s + ','
359 if type(val) == types.InstanceType :
360 if isinstance(val,PARAMETRE):
361 # il ne faut pas prendre la string que retourne gen_ast
362 # mais seulement le nom dans le cas d'un paramètre
365 s = s + self.generator(val)
366 elif self.wait_geom(obj):
368 elif type(val) == types.FloatType :
369 #s = s + self.repr_float(val)
377 if type(obj.valeur) == types.InstanceType :
378 if isinstance(obj.valeur,PARAMETRE):
379 # il ne faut pas prendre la string que retourne gen_ast
380 # mais seulement str dans le cas d'un paramètre
383 s = self.generator(obj.valeur)
384 elif self.wait_geom(obj):
386 elif type(obj.valeur) == types.FloatType :
387 #s = self.repr_float(obj.valeur)
394 def wait_geom(self,obj):
395 for typ in obj.definition.type:
396 if type(typ) == types.ClassType :
397 if issubclass(typ,GEOM) : return 1
400 def repr_float(self,valeur):
402 Cette fonction représente le réel valeur comme une chaîne de caractères
403 sous forme mantisse exposant si nécessaire cad si le nombre contient plus de 5 caractères
404 NB : valeur est un réel au format Python ou une chaîne de caractères représentant un réel
406 if type(valeur) == types.StringType : valeur = eval(valeur)
407 if valeur == 0. : return '0.0'
408 if abs(valeur) > 1. :
409 if abs(valeur) < 10000. : return repr(valeur)
411 if abs(valeur) > 0.01 : return repr(valeur)
413 if string.find(t,'e') != -1 or string.find(t,'E') != -1 :
414 # le réel est déjà sous forme mantisse exposant !
415 # --> on remplace e par E
416 t=string.replace(t,'e','E')
417 # --> on doit encore vérifier que la mantisse contient bien un '.'
418 if string.find(t,'.')!= -1:
421 # -->il faut rajouter le point avant le E
422 t=string.replace(t,'E','.E')
430 if string.atof(t[0]) == 0.:
431 # réel plus petit que 1
435 while string.atof(t[0]) == 0. :
442 # réel plus grand que 1
444 if string.atof(t[1:]) == 0.:
445 l=string.split(t[1:],'.')
453 if pt != 1 : cpt = cpt + 1
457 if r+1 == len(t) or string.atof(t[r+1:]) == 0.:break
458 s=s+'E'+neg*'-'+repr(cpt)
461 def generASSD(self,obj):
463 Convertit un objet dérivé d'ASSD en une chaine de caractères à la
466 return obj.get_name()
468 def generMCFACT(self,obj):
470 Convertit un objet MCFACT en une liste de chaines de caractères à la
476 for v in obj.mc_liste:
477 if isinstance(v,MCBLOC) or isinstance(v,MCList):
478 liste=self.generator(v)
482 l.append(self.generator(v))
486 def generMCList(self,obj):
488 Convertit un objet MCList en une liste de chaines de caractères à la
492 for mcfact in obj.data:
493 l.append(self.generator(mcfact))
496 def generMCBLOC(self,obj):
498 Convertit un objet MCBLOC en une liste de chaines de caractères à la
502 for v in obj.mc_liste:
503 if isinstance(v,MCBLOC) or isinstance(v,MCList):
504 liste=self.generator(v)
508 l.append(self.generator(v))