1 # -*- coding: utf-8 -*-
2 #@ MODIF ops Cata DATE 06/09/2003 AUTEUR D6BHHJP J.P.LEFEBVRE
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
9 # (AT YOUR OPTION) ANY LATER VERSION.
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
18 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
23 import string,linecache,os,traceback,re
27 from Accas import ASSD
28 from Noyau.N_FONCTION import formule
32 # Si le module aster est présent, on le connecte
35 Build.B_CODE.CODE.codex=aster
39 def DEBUT(self,PAR_LOT,CODE,**args):
41 Fonction sdprod de la macro DEBUT
43 # La commande DEBUT ne peut exister qu'au niveau jdc
44 if self.jdc is not self.parent :
45 raise Accas.AsException("La commande DEBUT ne peut exister qu'au niveau jdc")
47 self.jdc.set_par_lot(PAR_LOT)
49 self.jdc.fico=CODE['NOM']
53 def build_debut(self,**args):
55 Fonction ops pour la macro DEBUT
57 self.jdc.UserError=self.codex.error
59 if self.jdc.par_lot == 'NON' :
61 # On execute la fonction debut pour initialiser les bases
62 # Cette execution est indispensable avant toute autre action sur ASTER
63 # op doit etre un entier car la fonction debut appelle GCECDU qui demande
64 # le numero de l'operateur associé (getoper)
67 lot,ier=self.codex.debut(self,1)
68 # On remet op a None juste apres pour eviter que la commande DEBUT
69 # ne soit executée dans la phase d'execution
70 self.definition.op=None
73 def POURSUITE(self,PAR_LOT,CODE,HDF,**args):
75 Fonction sdprod de la macro POURSUITE
77 # La commande POURSUITE ne peut exister qu'au niveau jdc
78 if self.jdc is not self.parent :
79 raise Accas.AsException("La commande POURSUITE ne peut exister qu'au niveau jdc")
81 self.jdc.set_par_lot(PAR_LOT)
83 self.jdc.fico=CODE['NOM']
86 if (self.codex and os.path.isfile("glob.1")) or HDF!=None:
87 # Le module d'execution est accessible et glob.1 est present
88 # Pour eviter de rappeler plusieurs fois la sequence d'initialisation
89 # on memorise avec l'attribut fichier_init que l'initialisation
91 if hasattr(self,'fichier_init'):return
92 self.fichier_init='glob.1'
94 # le sous programme fortran appelé par self.codex.poursu demande le numero
95 # de l'operateur (GCECDU->getoper), on lui donne la valeur 0
97 lot,ier,lonuti,concepts=self.codex.poursu(self,1)
98 # Par la suite pour ne pas executer la commande pendant la phase
99 # d'execution on le remet à None
100 self.definition.op=None
101 # On demande la numerotation de la commande POURSUITE avec l'incrément
102 # lonuti pour qu'elle soit numérotée à la suite des commandes existantes.
103 self.set_icmd(lonuti)
106 while pos+80 < len(concepts)+1:
107 nomres=concepts[pos:pos+8]
108 concep=concepts[pos+8:pos+24]
109 nomcmd=concepts[pos+24:pos+40]
110 statut=concepts[pos+40:pos+48]
111 print nomres,concep,nomcmd,statut
112 if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
113 exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
115 for k,v in d.items():
116 self.parent.NommerSdprod(v,k)
120 # Si le module d'execution n est pas accessible ou glob.1 absent on
121 # demande un fichier (EFICAS)
122 # Il faut éviter de réinterpréter le fichier à chaque appel de
124 if hasattr(self,'fichier_init'):
126 self.make_poursuite()
128 def POURSUITE_context(self,d):
130 Fonction op_init de la macro POURSUITE
132 # self représente la macro POURSUITE ...
133 d.update(self.g_context)
134 # Une commande POURSUITE n'est possible qu'au niveau le plus haut
135 # On ajoute directement les concepts dans le contexte du jdc
136 # XXX est ce que les concepts ne sont pas ajoutés plusieurs fois ??
137 for v in self.g_context.values():
138 if isinstance(v,ASSD) : self.jdc.sds.append(v)
140 def build_poursuite(self,**args):
142 Fonction ops pour la macro POURSUITE
144 # Pour POURSUITE on ne modifie pas la valeur initialisee dans ops.POURSUITE
145 # Il n y a pas besoin d executer self.codex.poursu (c'est deja fait dans
146 # la fonction sdprod de la commande (ops.POURSUITE))
147 self.jdc.UserError=self.codex.error
150 def INCLUDE(self,UNITE,**args):
152 Fonction sd_prod pour la macro INCLUDE
154 if not UNITE : return
155 if hasattr(self,'unite'):return
158 if self.jdc and self.jdc.par_lot == 'NON':
159 # On est en mode commande par commande, on appelle la methode speciale
162 self.make_include(unite=UNITE)
164 def INCLUDE_context(self,d):
166 Fonction op_init pour macro INCLUDE
168 for k,v in self.g_context.items():
171 def build_include(self,**args):
173 Fonction ops de la macro INCLUDE appelée lors de la phase de Build
175 # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
176 # le numero de la commande n est pas utile en phase de construction
177 # La macro INCLUDE ne sera pas numérotée (incrément=None)
181 # On n'execute pas l'ops d'include en phase BUILD car il ne sert a rien.
182 #ier=self.codex.opsexe(self,icmd,-1,1)
185 def detruire(self,d):
187 Cette fonction est la fonction op_init de la PROC DETRUIRE
189 if self["CONCEPT"]!=None:
191 for mc in self["CONCEPT"]:
193 if type(mcs) == types.ListType or type(mcs) == types.TupleType:
195 if isinstance(e,ASSD):
198 if d.has_key(e):del d[e]
199 if self.jdc.sds_dict.has_key(e):del self.jdc.sds_dict[e]
201 #CCAR: ajout de ce test pour ne pas détruire une formule. Faut-il le reintegrer
202 # dans le catalogue d'Aster ? Est-il spécial EFICAS ?
203 if isinstance(mcs,formule):
204 cr=self.parent.report()
205 cr.fatal("la destruction d'une FORMULE est impossible" )
207 if isinstance(mcs,ASSD):
210 if d.has_key(mcs):del d[mcs]
211 if self.jdc.sds_dict.has_key(mcs):del self.jdc.sds_dict[mcs]
213 # On signale au parent que le concept s n'existe plus apres l'étape self
214 self.parent.delete_concept_after_etape(self,s)
216 def subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR):
218 Cette fonction retourne un texte obtenu à partir du texte passé en argument (text)
219 en substituant le nom du materiau par NOM_MATER
220 et en réalisant les extractions spéciifées dans EXTRACTION
222 lines=string.split(text,'\n')
224 ##### traitement de UNIT : facteur multiplicatif puissance de 10
225 regmcsu=re.compile(r" *(.*) *= *([^ ,]*) *## +([^ ]*) *([^ ]*)")
230 if m.group(3) == "UNIT":
231 if UNITE_LONGUEUR=='M' : coef = '0'
232 elif UNITE_LONGUEUR=='MM' : coef = m.group(4)
233 print ' UNITE_LONGUEUR = BINGO'
234 print ' UNITE_LONGUEUR = ',m.group(4),type(m.group(4))
235 ll_u.append(' '+m.group(1)+" = "+m.group(2)+coef)
236 else : ll_u.append(l)
237 else : ll_u.append(l)
239 ##### traitement de EXTRACTION
241 regmcf=re.compile(r" *(.*) *= *_F\( *## +(.*) +(.*)")
242 regmcs=re.compile(r" *(.*) *= *([^ ,]*) *, *## +([^ ]*) *([^ ]*)")
243 regfin=re.compile(r" *\) *")
249 temps[mcf]=e['TEMP_EVAL']
253 if m: # On a trouve un mot cle facteur "commentarise"
254 if m.group(2) == "SUBST": # il est de plus substituable
255 if temps.has_key(m.group(3)): # Il est a substituer
256 ll.append(" "+m.group(3)+"=_F(")
259 FLAG=1 # Indique que l'on est en cours de substitution
260 else: # Il n est pas a substituer car il n est pas dans la liste demandee
262 else: # Mot cle facteur commentarise non substituable
264 else: # La ligne ne contient pas un mot cle facteur commentarise
265 if FLAG == 0: # On n est pas en cours de substitution
267 else: # On est en cours de substitution. On cherche les mots cles simples commentarises
269 if m: # On a trouve un mot cle simple commentarise
270 if m.group(3) == "EVAL":
271 ll.append(" "+m.group(1)+' = EVAL("'+m.group(4)+"("+str(TEMP)+')"),')
272 elif m.group(3) == "SUPPR":
276 else: # On cherche la fin du mot cle facteur en cours de substitution
278 if m: # On l a trouve. On le supprime de la liste
290 l=re.sub(" *MAT *= *",NOM_MATER+" = ",l,1)
292 text=string.join(ll,'\n')
295 def post_INCLUDE(self):
297 Cette fonction est executée apres toutes les commandes d'un INCLUDE (RETOUR)
298 Elle sert principalement pour les INCLUDE_MATERIAU : remise a blanc du prefixe Fortran
300 self.codex.opsexe(self,0,-1,2)
302 def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER,
303 EXTRACTION,UNITE_LONGUEUR,INFO,**args):
305 Fonction sd_prod pour la macro INCLUDE_MATERIAU
307 mat=string.join((NOM_AFNOR,'_',TYPE_MODELE,'_',VARIANTE,'.',TYPE_VALE),'')
308 if not hasattr(self,'mat') or self.mat != mat or self.nom_mater != NOM_MATER :
309 # On récupère le répertoire des matériaux dans les arguments
310 # supplémentaires du JDC
311 rep_mat=self.jdc.args.get("rep_mat","NOrep_mat")
312 f=os.path.join(rep_mat,mat)
314 self.nom_mater=NOM_MATER
315 if not os.path.isfile(f):
317 self.make_contexte(f,"#Texte sans effet pour reinitialiser le contexte a vide\n")
318 raise "Erreur sur le fichier materiau: "+f
319 # Les materiaux sont uniquement disponibles en syntaxe Python
320 # On lit le fichier et on supprime les éventuels \r
321 text=string.replace(open(f).read(),'\r\n','\n')
322 # On effectue les substitutions necessaires
323 self.prefix=NOM_MATER
324 self.text= subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR)
326 print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
328 # on execute le texte fourni dans le contexte forme par
329 # le contexte de l etape pere (global au sens Python)
330 # et le contexte de l etape (local au sens Python)
331 # Il faut auparavant l'enregistrer aupres du module linecache (utile pour nommage.py)
332 linecache.cache[f]=0,0,string.split(self.text,'\n'),f
334 self.postexec=post_INCLUDE
336 if self.jdc.par_lot == 'NON':
337 # On est en mode commande par commande, on appelle la methode speciale
340 self.make_contexte(f,self.text)
342 def build_formule(self,**args):
344 Fonction ops de la macro FORMULE appelée lors de la phase de Build
346 from Build import B_utils
347 for mc in self.mc_liste:
348 ### if mc.nom in ('REEL','ENTIER','COMPLEXE'):
349 if mc.nom in ('REEL','COMPLEXE'):
350 texte= self.sd.get_name()+ string.strip(mc.valeur)
351 mc.valeur=B_utils.ReorganisationDe(texte,80)
352 # ATTENTION : FORMULE est une des rares commandes qui a besoin de
353 # connaitre son numero d execution avant d etre construite
355 # La macro formule doit etre executee. Seules les macros qui ont
356 # un numero d'op sont executees lors des phases suivantes
357 self.definition.op = -5
358 ier=self.codex.opsexe(self,self.icmd,-1,-self.definition.op)
361 def build_procedure(self,**args):
363 Fonction ops de la macro PROCEDURE appelée lors de la phase de Build
366 # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
367 # le numero de la commande n est pas utile en phase de construction
368 # On ne numérote pas une macro PROCEDURE (incrément=None)
371 #ier=self.codex.opsexe(self,icmd,-1,3)
374 def build_retour(self,**args):
376 Fonction ops de la macro RETOUR appelée lors de la phase de Build
379 # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
380 # le numero de la commande n est pas utile en phase de construction
381 # On ne numérote pas une macro RETOUR (incrément=None)
384 #ier=self.codex.opsexe(self,icmd,-1,2)