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 # ======================================================================
25 import traceback,types,string
29 from Noyau.N_ASSD import ASSD
31 # import rajoutés suite à l'ajout de Build_sd --> à résorber
32 import Noyau, Validation.V_MACRO_ETAPE
33 from Noyau import N_Exception
34 from Noyau.N_Exception import AsException
35 import Accas # attention aux imports circulaires
36 # fin import à résorber
38 class MACRO_ETAPE(I_ETAPE.ETAPE):
42 self.recorded_units={}
44 def get_sdprods(self,nom_sd):
46 Fonction : retourne le concept produit par l etape de nom nom_sd
47 s il existe sinon None
49 if self.sd and self.sd.nom == nom_sd :return self.sd
50 for co in self.sdprods:
51 if co.nom == nom_sd:return co
52 if type(self.definition.op_init) == types.FunctionType:
54 apply(self.definition.op_init,(self,d))
55 return d.get(nom_sd,None)
58 def get_contexte_jdc(self,fichier,text):
60 Interprète text comme un texte de jdc et retourne le
62 cad le dictionnaire des sd disponibles à la dernière étape
63 Si text n'est pas un texte de jdc valide, retourne None
65 --> utilisée par ops.POURSUITE et INCLUDE
67 #print "get_contexte_jdc"
69 # on essaie de créer un objet JDC auxiliaire avec un contexte initial
70 # Attention get_contexte_avant retourne un dictionnaire qui contient
71 # le contexte courant. Ce dictionnaire est reactualise regulierement.
72 # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
73 context_ini = self.parent.get_contexte_avant(self).copy()
75 # Indispensable avant de creer un nouveau JDC
76 CONTEXT.unset_current_step()
79 if hasattr(self,'prefix'):
80 prefix_include=self.prefix
81 # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des
82 # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
83 # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
84 # clear plutot) si on ne veut pas perdre la memoire des unites.
85 # En principe si la memorisation est faite au bon moment il n'est pas necessaire
86 # de prendre cette precaution mais ce n'est pas vrai partout.
87 old_recorded_units=self.recorded_units.copy()
88 #print "get_contexte_jdc",id(self.recorded_units)
89 #self.recorded_units.clear()
91 j=self.JdC_aux( procedure=text, nom=fichier,
94 cata_ord_dico=self.jdc.cata_ordonne_dico,
95 context_ini = context_ini,
96 jdc_pere=self.jdc,etape_include=self,
97 prefix_include=prefix_include,
98 recorded_units=self.recorded_units,
99 old_recorded_units=old_recorded_units,**args)
102 # On récupère les étapes internes (pour validation)
105 #print "get_contexte_jdc",id(self.etapes)
107 traceback.print_exc()
108 # On force le contexte (etape courante) à self
109 CONTEXT.unset_current_step()
110 CONTEXT.set_current_step(self)
113 if not j.cr.estvide():
114 # Erreurs dans l'INCLUDE. On garde la memoire du fichier
115 # mais on n'insere pas les concepts
116 # On force le contexte (etape courante) à self
117 CONTEXT.unset_current_step()
118 CONTEXT.set_current_step(self)
119 raise Exception("Impossible de relire le fichier\n"+str(j.cr))
122 # L'INCLUDE n'est pas valide.
123 # on produit un rapport d'erreurs
124 # On force le contexte (etape courante) à self
126 CONTEXT.unset_current_step()
127 CONTEXT.set_current_step(self)
128 raise Exception("Le fichier include contient des erreurs\n"+str(cr))
130 # Si aucune erreur rencontrée
131 # On recupere le contexte de l'include verifie
132 #print "context_ini",j.context_ini
133 #print "g_context",j.g_context
135 j_context=j.get_verif_contexte()
137 CONTEXT.unset_current_step()
138 CONTEXT.set_current_step(self)
141 #print "context_ini",j.context_ini
143 # On remplit le dictionnaire des concepts produits inclus
144 # en retirant les concepts présents dans le contexte initial
145 # On ajoute egalement le concept produit dans le sds_dict du parent
146 # sans verification car on est sur (verification integrée) que
147 # le nommage est possible
148 self.g_context.clear()
149 for k,v in j_context.items():
150 if not context_ini.has_key(k) or context_ini[k] != v:
152 self.parent.sds_dict[k]=v
155 # On recupere le contexte courant
156 self.current_context=j.current_context
157 self.index_etape_courante=j.index_etape_courante
160 # XXX j.supprime() ???
161 # On rétablit le contexte (etape courante) à self
162 CONTEXT.unset_current_step()
163 CONTEXT.set_current_step(self)
164 #print "context_ini",self.jdc_aux.context_ini
168 def reevalue_sd_jdc(self):
170 Avec la liste des SD qui ont été supprimées, propage la
171 disparition de ces SD dans toutes les étapes et descendants
173 #print "reevalue_sd_jdc"
174 l_sd_supp,l_sd_repl = self.diff_contextes()
176 self.parent.delete_concept_after_etape(self,sd)
177 for old_sd,sd in l_sd_repl:
178 self.parent.replace_concept_after_etape(self,old_sd,sd)
180 def diff_contextes(self):
182 Réalise la différence entre les 2 contextes
183 old_contexte_fichier_init et contexte_fichier_init
184 cad retourne la liste des sd qui ont disparu ou ne derivent pas
185 de la meme classe et des sd qui ont ete remplacees
187 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
190 for old_key in self.old_contexte_fichier_init.keys():
191 if not self.contexte_fichier_init.has_key(old_key):
192 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
193 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
195 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
196 # Un concept de meme nom existe
197 old_class=self.old_contexte_fichier_init[old_key].__class__
198 if not isinstance(self.contexte_fichier_init[old_key],old_class):
199 # S'il n'est pas d'une classe derivee, on le supprime
200 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
202 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
203 return l_sd_suppressed,l_sd_replaced
205 def control_sdprods(self,d):
207 Cette methode doit updater le contexte fournit par
208 l'appelant en argument (d) en fonction de sa definition
209 tout en verifiant que ses concepts produits ne sont pas
210 deja definis dans le contexte
212 if hasattr(self,"fichier_unite"):
213 self.update_fichier_init(self.fichier_unite)
216 if type(self.definition.op_init) == types.FunctionType:
217 apply(self.definition.op_init,(self,d))
219 if d.has_key(self.sd.nom):
220 # Le concept est deja defini
221 if self.reuse and self.reuse is d[self.sd.nom]:
222 # Le concept est reutilise : situation normale
225 # Redefinition du concept, on l'annule
226 #XXX on pourrait simplement annuler son nom pour conserver les objets
227 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
228 self.sd=self.reuse=self.sdnom=None
231 # Le concept n'est pas defini, on peut updater d
232 d[self.sd.nom]=self.sd
233 # On verifie les concepts a droite du signe =
234 for co in self.sdprods:
235 if d.has_key(co.nom) and co is not d[co.nom] :
236 self.delete_concept(co)
241 def supprime_sdprods(self):
243 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
244 Un opérateur n a qu un concept produit
245 Une procedure n'en a aucun
246 Une macro en a en général plus d'un
248 #print "supprime_sdprods"
249 if not self.is_reentrant() :
250 # l'étape n'est pas réentrante
251 # le concept retourné par l'étape est à supprimer car il était
254 self.parent.del_sdprod(self.sd)
255 self.parent.delete_concept(self.sd)
256 # On détruit les concepts à droite du signe =
257 for co in self.sdprods:
258 self.parent.del_sdprod(co)
259 self.parent.delete_concept(co)
260 # Si la macro a des etapes et des concepts inclus, on les detruit
261 for nom_sd,co in self.g_context.items():
262 if not isinstance(co,ASSD):continue
263 self.parent.del_sdprod(co)
264 self.parent.delete_concept(co)
265 # On met g_context à blanc
268 def delete_concept(self,sd):
270 Fonction : Mettre a jour les mots cles de l etape et eventuellement
271 le concept produit si reuse suite à la disparition du concept sd
272 Seuls les mots cles simples MCSIMP font un traitement autre
273 que de transmettre aux fils
275 #print "delete_concept",sd
276 I_ETAPE.ETAPE.delete_concept(self,sd)
277 for etape in self.etapes:
278 etape.delete_concept(sd)
280 def replace_concept(self,old_sd,sd):
282 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
283 suite au remplacement du concept old_sd par sd
285 #print "replace_concept",old_sd,sd
286 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
287 for etape in self.etapes:
288 etape.replace_concept(sd)
290 def change_fichier_init(self,new_fic,text):
292 Tente de changer le fichier include. Le precedent include est conservé
295 if not hasattr(self,'fichier_ini'):
296 self.fichier_ini=None
297 self.fichier_text=None
298 self.fichier_err="Le fichier n'est pas defini"
299 self.contexte_fichier_init={}
300 self.recorded_units={}
302 self.fichier_unite="PasDefini"
303 import Extensions.jdc_include
304 self.JdC_aux=Extensions.jdc_include.JdC_include
306 self.old_fic = self.fichier_ini
307 self.old_text = self.fichier_text
308 self.old_err = self.fichier_err
309 self.old_context=self.contexte_fichier_init
310 self.old_units=self.recorded_units
311 self.old_etapes=self.etapes
312 self.old_jdc_aux=self.jdc_aux
314 self.fichier_ini = new_fic
315 self.fichier_text=text
318 self.make_contexte_include(new_fic,text)
320 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
321 self.fichier_err=string.join(l)
324 # L'evaluation de text dans un JDC auxiliaire s'est bien passé
325 # on peut poursuivre le traitement
327 self.state="undetermined"
328 self.fichier_err=None
329 # On enregistre la modification de fichier
331 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
332 self.parent.reset_context()
334 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
335 self.old_contexte_fichier_init=self.old_context
336 self.reevalue_sd_jdc()
340 def restore_fichier_init(self):
342 Restaure le fichier init enregistre dans old_xxx
344 self.fichier_ini=self.old_fic
345 self.fichier_text=self.old_text
346 self.fichier_err=self.old_err
347 self.contexte_fichier_init=self.old_context
348 self.recorded_units=self.old_units
349 self.etapes=self.old_etapes
350 self.jdc_aux=self.old_jdc_aux
352 def force_fichier_init(self):
354 Force le fichier init en erreur
356 # On conserve la memoire du nouveau fichier
357 # mais on n'utilise pas les concepts crees par ce fichier
358 # on met l'etape en erreur : fichier_err=string.join(l)
360 # On enregistre la modification de fichier
364 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
365 self.parent.reset_context()
367 self.old_contexte_fichier_init=self.old_context
368 self.contexte_fichier_init={}
369 self.reevalue_sd_jdc()
373 def make_contexte_include(self,fichier,text):
375 Cette méthode sert à créer un contexte en interprétant un texte source
378 #print "make_contexte_include"
379 # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
380 contexte = self.get_contexte_jdc(fichier,text)
381 if contexte == None :
382 raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
384 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
385 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
386 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
387 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
388 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
389 # g_context est utilisé pour avoir les concepts produits par la macro
390 # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
391 self.contexte_fichier_init = contexte
393 def reevalue_fichier_init_OBSOLETE(self):
394 """Recalcule les concepts produits par le fichier enregistre"""
395 #print "reevalue_fichier_init"
396 old_context=self.contexte_fichier_init
398 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
400 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
401 self.fichier_err = string.join(l)
405 self.old_contexte_fichier_init=old_context
406 self.contexte_fichier_init={}
407 self.reevalue_sd_jdc()
410 # L'evaluation s'est bien passee
411 self.fichier_err = None
412 self.old_contexte_fichier_init=old_context
413 self.reevalue_sd_jdc()
414 #print "reevalue_fichier_init",self.jdc_aux.context_ini
416 def update_fichier_init(self,unite):
417 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
418 les noms des fichiers
419 Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
421 #print "update_fichier_init",unite
422 self.fichier_err=None
423 self.old_contexte_fichier_init=self.contexte_fichier_init
424 old_fichier_ini=self.fichier_ini
426 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
428 #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
429 if not self.parent.recorded_units.has_key(unite):
431 f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
435 self.fichier_text=text
436 self.recorded_units=units
437 if self.fichier_ini is None and self.jdc.appli:
438 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
439 message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
442 f,text,units=self.parent.recorded_units[unite]
444 self.fichier_text=text
445 self.recorded_units=units
447 if self.fichier_ini is None:
448 # Le fichier n'est pas défini
449 self.fichier_err="Le fichier associé n'est pas défini"
450 self.parent.change_unit(unite,self,self.fichier_unite)
452 self.contexte_fichier_init={}
453 self.parent.reset_context()
454 self.reevalue_sd_jdc()
457 if old_fichier_ini == self.fichier_ini:
458 # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
459 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
463 self.make_contexte_include(self.fichier_ini,self.fichier_text)
464 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
465 # avant d'appeler change_unit
466 self.parent.change_unit(unite,self,self.fichier_unite)
468 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
469 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
470 # On conserve la memoire du nouveau fichier
471 # mais on n'utilise pas les concepts crees par ce fichier
472 # on met l'etape en erreur : fichier_err=string.join(l)
473 self.fichier_err=string.join(l)
474 self.parent.change_unit(unite,self,self.fichier_unite)
476 self.contexte_fichier_init={}
478 # Le contexte du parent doit etre reinitialise car les concepts
479 # produits ont changé
480 self.parent.reset_context()
481 # Si des concepts ont disparu lors du changement de fichier, on
482 # demande leur suppression
483 self.reevalue_sd_jdc()
484 #print "update_fichier_init",self.jdc_aux.context_ini
486 def record_unite(self):
487 if self.nom == "POURSUITE":
488 self.parent.record_unit(None,self)
490 if hasattr(self,'fichier_unite') :
491 self.parent.record_unit(self.fichier_unite,self)
493 def get_file_memo(self,unite=None,fic_origine=''):
494 """Retourne le nom du fichier et le source correspondant a l'unite unite
495 Initialise en plus recorded_units
497 #print "get_file_memo",unite,fic_origine,self,self.parent
498 #print self.parent.old_recorded_units
499 #print self.parent.recorded_units
503 units=self.parent.recorded_units
504 if self.parent.old_recorded_units.has_key(unite):
505 f,text,units=self.parent.old_recorded_units[unite]
506 #print id(self.recorded_units)
507 self.recorded_units=units
508 #print id(self.recorded_units)
511 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
514 self.recorded_units=units
515 if f is None and self.jdc.appli:
516 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
517 message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
520 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
521 def get_file(self,unite=None,fic_origine=''):
522 """Retourne le nom du fichier et le source correspondant a l'unite unite
523 Initialise en plus recorded_units
525 #print "get_file",unite
528 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
531 self.recorded_units=units
534 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
535 def make_include(self,unite=None):
537 Inclut un fichier dont l'unite logique est unite
538 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
539 Si l'INCLUDE est invalide, la methode doit produire une exception
540 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
541 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
543 #print "make_include",unite
544 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
545 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
547 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
548 if not unite : return
550 if not hasattr(self,'fichier_ini') :
551 # Si le fichier n'est pas defini on le demande
552 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
553 # On memorise le fichier retourne
555 self.fichier_text = text
556 self.contexte_fichier_init={}
557 self.fichier_unite=unite
558 self.fichier_err=None
560 import Extensions.jdc_include
562 traceback.print_exc()
564 self.JdC_aux=Extensions.jdc_include.JdC_include
567 self.fichier_err="Le fichier INCLUDE n est pas defini"
568 self.parent.record_unit(unite,self)
569 raise Exception(self.fichier_err)
572 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
573 self.parent.record_unit(unite,self)
574 #print "make_include.context_ini",self.jdc_aux.context_ini
576 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
578 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
579 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
581 self.parent.record_unit(unite,self)
583 self.fichier_err = string.join(l)
584 self.contexte_fichier_init={}
588 # Si le fichier est deja defini on ne reevalue pas le fichier
589 # et on leve une exception si une erreur a été enregistrée
590 self.update_fichier_init(unite)
591 self.fichier_unite=unite
592 if self.fichier_err is not None: raise Exception(self.fichier_err)
595 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
596 def make_contexte(self,fichier,text):
598 Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
599 en interprétant un texte source Python
600 Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
602 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
603 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
604 if hasattr(self,'mat'):del self.mat
605 self.fichier_ini =fichier
606 self.fichier_unite =fichier
607 self.fichier_text=text
608 self.fichier_err=None
609 self.contexte_fichier_init={}
610 # On specifie la classe a utiliser pour le JDC auxiliaire
612 import Extensions.jdc_include
614 traceback.print_exc()
616 self.JdC_aux=Extensions.jdc_include.JdC_include
618 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
619 self.parent.record_unit(self.fichier_unite,self)
621 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
622 self.fichier_err = string.join(l)
623 self.parent.record_unit(self.fichier_unite,self)
625 self.contexte_fichier_init={}
628 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
629 def update_sdprod(self,cr='non'):
630 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
631 # la commande modifies. Ceci peut conduire a la construction ou
632 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
633 # Il faut donc positionner le current_step avant l'appel
634 CONTEXT.unset_current_step()
635 CONTEXT.set_current_step(self)
636 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
637 CONTEXT.unset_current_step()
640 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
641 def Build_sd(self,nom):
643 Methode de Noyau surchargee pour poursuivre malgre tout
644 si une erreur se produit pendant la creation du concept produit
647 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
648 except AsException,e:
649 # Une erreur s'est produite lors de la construction du concept
650 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
651 # Si on poursuit, on a le choix entre deux possibilités :
652 # 1. on annule la sd associée à self
653 # 2. on la conserve mais il faut la retourner
654 # On choisit de l'annuler
655 # En plus il faut rendre coherents sdnom et sd.nom
658 self.state="unchanged"
663 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
664 def make_poursuite(self):
665 """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
667 #print "make_poursuite"
668 if not hasattr(self,'fichier_ini') :
669 # Si le fichier n'est pas defini on le demande
670 f,text=self.get_file_memo(fic_origine=self.parent.nom)
671 # On memorise le fichier retourne
673 self.fichier_unite = None
674 self.fichier_text = text
675 self.fichier_err=None
677 import Extensions.jdc_include
679 traceback.print_exc()
681 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
682 self.contexte_fichier_init={}
685 self.fichier_err="Le fichier POURSUITE n'est pas defini"
686 self.parent.record_unit(None,self)
687 raise Exception(self.fichier_err)
690 self.make_contexte_include(self.fichier_ini,self.fichier_text)
691 self.parent.record_unit(None,self)
693 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
695 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
696 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
698 self.parent.record_unit(None,self)
700 self.fichier_err = string.join(l)
701 self.contexte_fichier_init={}
705 # Si le fichier est deja defini on ne reevalue pas le fichier
706 # et on leve une exception si une erreur a été enregistrée
707 self.update_fichier_init(None)
708 if self.fichier_err is not None: raise Exception(self.fichier_err)
710 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
711 def type_sdprod(self,co,t):
713 Cette methode a pour fonction de typer le concept co avec le type t
714 dans les conditions suivantes
715 1- co est un concept produit de self
716 2- co est un concept libre : on le type et on l attribue à self
717 Elle enregistre egalement les concepts produits (on fait l hypothese
718 que la liste sdprods a été correctement initialisee, vide probablement)
720 #print "type_sdprod",co,t
721 if not hasattr(co,'etape'):
722 # Le concept vaut None probablement. On ignore l'appel
725 # On cherche a discriminer les differents cas de typage d'un concept
726 # produit par une macro qui est specifie dans un mot cle simple.
727 # On peut passer plusieurs fois par type_sdprod ce qui explique
728 # le nombre important de cas.
730 # Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
731 # Cas 2 : Le concept est produit par la macro. On est deja passe par type_sdprod.
732 # Cas semblable a Cas 1.
733 # Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
734 # la propriete du concept de la macro parent a la macro courante (self)
735 # en verifiant que le type est valide
736 # Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
737 # deja passe par type_sdprod et que la propriete a ete transfere a une
738 # etape fille. Cas semblable a Cas 3.
739 # Cas 5 : Le concept est produit par une etape externe a la macro.
742 # Cas 1 : le concept est libre
743 # On l'attache a la macro et on change son type dans le type demande
744 # Recherche du mot cle simple associe au concept
745 mcs=self.get_mcs_with_co(co)
747 raise AsException("""Erreur interne.
748 Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
751 # Attention : la seule modif est ici : Accas.CO au lieu de CO
753 if not Accas.CO in mcs.definition.type:
754 raise AsException("""Erreur interne.
755 Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
758 self.sdprods.append(co)
760 elif co.etape== self:
761 # Cas 2 : le concept est produit par la macro (self)
762 # On est deja passe par type_sdprod (Cas 1 ou 3).
763 # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
764 # Le type du concept doit etre coherent avec le type demande (seulement derive)
765 if not isinstance(co,t):
766 raise AsException("""Erreur interne.
767 Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
768 self.sdprods.append(co)
770 elif co.etape== self.parent:
771 # Cas 3 : le concept est produit par la macro parente (self.parent)
772 # on transfere la propriete du concept a la macro fille
773 # et on change le type du concept comme demande
774 # Au prealable, on verifie que le concept existant (co) est une instance
775 # possible du type demande (t)
776 # Cette règle est normalement cohérente avec les règles de vérification des mots-clés
777 if not isinstance(co,t):
778 raise AsException("""
779 Impossible de changer le type du concept produit (%s) en (%s).
780 Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" % (co,t,co.__class__,t))
781 mcs=self.get_mcs_with_co(co)
783 raise AsException("""Erreur interne.
784 Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
786 if not Accas.CO in mcs.definition.type:
787 raise AsException("""Erreur interne.
788 Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" %(co,mcs.definition.type))
790 # On ne change pas le type car il respecte la condition isinstance(co,t)
792 self.sdprods.append(co)
794 elif self.issubstep(co.etape):
795 # Cas 4 : Le concept est propriété d'une sous etape de la macro (self).
796 # On est deja passe par type_sdprod (Cas 3 ou 1).
797 # Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
798 # Le type du concept et t doivent etre derives.
799 # Il n'y a aucune raison pour que la condition ne soit pas verifiee.
800 if not isinstance(co,t):
801 raise AsException("""Erreur interne.
802 Le type demande (%s) et le type du concept (%s) devraient etre derives""" %(t,co.__class__))
803 self.sdprods.append(co)
806 # Cas 5 : le concept est produit par une autre étape