Ihm/I_MACRO_ETAPE.py

   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.
   9 #
  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.
  14 #
  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.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22 """
  23 # Modules Python
  24 import sys
  25 import traceback,types,string
  26
  27 # Modules Eficas
  28 import I_ETAPE
  29 from Noyau.N_ASSD import ASSD
  30
  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
  37
  38 class MACRO_ETAPE(I_ETAPE.ETAPE):
  39
  40   def __init__(self):
  41       self.typret=None
  42       self.recorded_units={}
  43
  44   def get_sdprods(self,nom_sd):
  45     """
  46          Fonction : retourne le concept produit par l etape de nom nom_sd
  47          s il existe sinon None
  48     """
  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:
  53       d={}
  54       apply(self.definition.op_init,(self,d))
  55       return d.get(nom_sd,None)
  56     return None
  57
  58   def get_contexte_jdc(self,fichier,text):
  59     """
  60          Interprète text comme un texte de jdc et retourne le
  61          contexte final
  62          cad le dictionnaire des sd disponibles à la dernière étape
  63          Si text n'est pas un texte de jdc valide, retourne None
  64          ou leve une exception
  65          --> utilisée par ops.POURSUITE et INCLUDE
  66     """
  67     #print "get_contexte_jdc"
  68     try:
  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()
  74
  75        # Indispensable avant de creer un nouveau JDC
  76        CONTEXT.unset_current_step()
  77        args=self.jdc.args
  78        prefix_include=None
  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()
  90
  91        j=self.JdC_aux( procedure=text, nom=fichier,
  92                                 appli=self.jdc.appli,
  93                                 cata=self.jdc.cata,
  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)
 100
 101        j.analyse()
 102        # On récupère les étapes internes (pour validation)
 103        self.etapes=j.etapes
 104        self.jdc_aux=j
 105        #print "get_contexte_jdc",id(self.etapes)
 106     except:
 107        traceback.print_exc()
 108        # On force le contexte (etape courante) à self
 109        CONTEXT.unset_current_step()
 110        CONTEXT.set_current_step(self)
 111        return None
 112
 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))
 120
 121     if not j.isvalid():
 122        # L'INCLUDE n'est pas valide.
 123        # on produit un rapport d'erreurs
 124        # On force le contexte (etape courante) à self
 125        cr=j.report()
 126        CONTEXT.unset_current_step()
 127        CONTEXT.set_current_step(self)
 128        raise Exception("Le fichier include contient des erreurs\n"+str(cr))
 129
 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
 134     try:
 135        j_context=j.get_verif_contexte()
 136     except:
 137        CONTEXT.unset_current_step()
 138        CONTEXT.set_current_step(self)
 139        raise
 140
 141     #print "context_ini",j.context_ini
 142
 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:
 151            self.g_context[k]=v
 152            self.parent.sds_dict[k]=v
 153
 154
 155     # On recupere le contexte courant
 156     self.current_context=j.current_context
 157     self.index_etape_courante=j.index_etape_courante
 158     self.jdc_aux=j
 159
 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
 165
 166     return j_context
 167
 168   def reevalue_sd_jdc(self):
 169      """
 170          Avec la liste des SD qui ont été supprimées, propage la
 171          disparition de ces SD dans toutes les étapes et descendants
 172      """
 173      #print "reevalue_sd_jdc"
 174      l_sd_supp,l_sd_repl = self.diff_contextes()
 175      for sd in l_sd_supp:
 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)
 179
 180   def diff_contextes(self):
 181      """
 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
 186      """
 187      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
 188      l_sd_suppressed = []
 189      l_sd_replaced = []
 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])
 194        else:
 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])
 201             else:
 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
 204
 205   def control_sdprods(self,d):
 206       """
 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
 211       """
 212       if hasattr(self,"fichier_unite"):
 213          self.update_fichier_init(self.fichier_unite)
 214          self.init_modif()
 215
 216       if type(self.definition.op_init) == types.FunctionType:
 217         apply(self.definition.op_init,(self,d))
 218       if self.sd:
 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
 223               pass
 224            else:
 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
 229               self.init_modif()
 230         else:
 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)
 237         else:
 238            d[co.nom]=co
 239
 240   def supprime_sdprod(self,sd):
 241       """
 242          Supprime le concept produit sd s'il est produit par l'etape
 243       """
 244       if sd in self.sdprods:
 245          self.init_modif()
 246          self.parent.del_sdprod(sd)
 247          self.sdprods.remove(sd)
 248          self.fin_modif()
 249          self.parent.delete_concept(sd)
 250          return
 251
 252       if sd is not self.sd :return
 253       if self.sd is not None :
 254          self.init_modif()
 255          self.parent.del_sdprod(sd)
 256          self.sd=None
 257          self.fin_modif()
 258          self.parent.delete_concept(sd)
 259
 260   def supprime_sdprods(self):
 261       """
 262           Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
 263           Un opérateur n a qu un concept produit
 264           Une procedure n'en a aucun
 265           Une macro en a en général plus d'un
 266       """
 267       #print "supprime_sdprods"
 268       if self.reuse is not self.sd :
 269          # l'étape n'est pas réentrante
 270          # le concept retourné par l'étape est à supprimer car il était
 271          # créé par l'étape
 272          if self.sd != None :
 273             self.parent.del_sdprod(self.sd)
 274             self.parent.delete_concept(self.sd)
 275       # On détruit les concepts à droite du signe =
 276       for co in self.sdprods:
 277          self.parent.del_sdprod(co)
 278          self.parent.delete_concept(co)
 279       # Si la macro a des etapes et des concepts inclus, on les detruit
 280       for nom_sd,co in self.g_context.items():
 281          if not isinstance(co,ASSD):continue
 282          self.parent.del_sdprod(co)
 283          self.parent.delete_concept(co)
 284       # On met g_context à blanc
 285       self.g_context={}
 286
 287   def close(self):
 288       if hasattr(self,"jdc_aux") and self.jdc_aux:
 289          # La macro a un jdc auxiliaire inclus. On demande sa fermeture
 290          self.jdc_aux.close()
 291
 292   def reset_context(self):
 293       if hasattr(self,"jdc_aux") and self.jdc_aux:
 294          # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
 295          self.jdc_aux.reset_context()
 296
 297   def delete_concept(self,sd):
 298       """
 299           Fonction : Mettre a jour les mots cles de l etape et eventuellement
 300           le concept produit si reuse suite à la disparition du concept sd
 301           Seuls les mots cles simples MCSIMP font un traitement autre
 302           que de transmettre aux fils
 303       """
 304       #print "delete_concept",sd
 305       I_ETAPE.ETAPE.delete_concept(self,sd)
 306       for etape in self.etapes:
 307          etape.delete_concept(sd)
 308
 309   def replace_concept(self,old_sd,sd):
 310       """
 311           Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
 312           suite au remplacement  du concept old_sd par sd
 313       """
 314       #print "replace_concept",old_sd,sd
 315       I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
 316       for etape in self.etapes:
 317          etape.replace_concept(old_sd,sd)
 318
 319   def change_fichier_init(self,new_fic,text):
 320     """
 321        Tente de changer le fichier include. Le precedent include est conservé
 322        dans old_xxx
 323     """
 324     if not hasattr(self,'fichier_ini'):
 325        self.fichier_ini=None
 326        self.fichier_text=None
 327        self.fichier_err="Le fichier n'est pas defini"
 328        self.contexte_fichier_init={}
 329        self.recorded_units={}
 330        self.jdc_aux=None
 331        self.fichier_unite="PasDefini"
 332        import Extensions.jdc_include
 333        self.JdC_aux=Extensions.jdc_include.JdC_include
 334
 335     self.old_fic = self.fichier_ini
 336     self.old_text = self.fichier_text
 337     self.old_err = self.fichier_err
 338     self.old_context=self.contexte_fichier_init
 339     self.old_units=self.recorded_units
 340     self.old_etapes=self.etapes
 341     self.old_jdc_aux=self.jdc_aux
 342
 343     self.fichier_ini = new_fic
 344     self.fichier_text=text
 345
 346     try:
 347        self.make_contexte_include(new_fic,text)
 348     except:
 349        l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 350        self.fichier_err=string.join(l)
 351        raise
 352
 353     # L'evaluation de text dans un JDC auxiliaire s'est bien passé
 354     # on peut poursuivre le traitement
 355     self.init_modif()
 356     self.state="undetermined"
 357     self.fichier_err=None
 358     # On enregistre la modification de fichier
 359     self.record_unite()
 360     # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
 361     self.parent.reset_context()
 362
 363     # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
 364     self.old_contexte_fichier_init=self.old_context
 365     self.reevalue_sd_jdc()
 366
 367     self.fin_modif()
 368
 369   def restore_fichier_init(self):
 370     """
 371        Restaure le fichier init enregistre dans old_xxx
 372     """
 373     self.fichier_ini=self.old_fic
 374     self.fichier_text=self.old_text
 375     self.fichier_err=self.old_err
 376     self.contexte_fichier_init=self.old_context
 377     self.recorded_units=self.old_units
 378     self.etapes=self.old_etapes
 379     self.jdc_aux=self.old_jdc_aux
 380
 381   def force_fichier_init(self):
 382     """
 383        Force le remplacement du fichier init meme si le remplacant est en erreur
 384     """
 385     # Reinitialisation complete du compte-rendu d'erreurs
 386     self.jdc_aux.cr=self.jdc_aux.CR()
 387     # On remplit le dictionnaire des concepts produits inclus
 388     # en retirant les concepts présents dans le  contexte initial
 389     # On ajoute egalement le concept produit dans le sds_dict du parent
 390     # sans verification car on est sur (verification integrée) que
 391     # le nommage est possible
 392     j_context=self.jdc_aux.get_contexte_avant(None)
 393     self.g_context.clear()
 394     context_ini=self.jdc_aux.context_ini
 395     for k,v in j_context.items():
 396        if not context_ini.has_key(k) or context_ini[k] != v:
 397            self.g_context[k]=v
 398            self.parent.sds_dict[k]=v
 399     # On recupere le contexte courant
 400     self.current_context=self.jdc_aux.current_context
 401     self.index_etape_courante=self.jdc_aux.index_etape_courante
 402     self.contexte_fichier_init = j_context
 403
 404     # On enregistre la modification de fichier
 405     self.init_modif()
 406     self.state="undetermined"
 407     self.record_unite()
 408     # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
 409     self.parent.reset_context()
 410
 411     # On remplace les anciens concepts par les nouveaux (y compris ajouts
 412     # et suppression) et on propage les modifications aux etapes precedentes et suivantes
 413     # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
 414     # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
 415     # necessaires
 416     self.old_contexte_fichier_init=self.old_context
 417     self.reevalue_sd_jdc()
 418     self.fin_modif()
 419
 420     self.jdc_aux.force_contexte(self.g_context)
 421
 422
 423   def make_contexte_include(self,fichier,text):
 424     """
 425         Cette méthode sert à créer un contexte en interprétant un texte source
 426         Python
 427     """
 428     #print "make_contexte_include"
 429     # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
 430     contexte = self.get_contexte_jdc(fichier,text)
 431     if contexte == None :
 432       raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
 433     else:
 434       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
 435       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
 436       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
 437       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
 438       # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
 439       # g_context est utilisé pour avoir les concepts produits par la macro
 440       # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
 441       self.contexte_fichier_init = contexte
 442
 443   def reevalue_fichier_init_OBSOLETE(self):
 444       """Recalcule les concepts produits par le fichier enregistre"""
 445       #print "reevalue_fichier_init"
 446       old_context=self.contexte_fichier_init
 447       try:
 448          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 449       except:
 450          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 451          self.fichier_err = string.join(l)
 452          self.g_context={}
 453          self.etapes=[]
 454          self.jdc_aux=None
 455          self.old_contexte_fichier_init=old_context
 456          self.contexte_fichier_init={}
 457          self.reevalue_sd_jdc()
 458          return
 459
 460       # L'evaluation s'est bien passee
 461       self.fichier_err = None
 462       self.old_contexte_fichier_init=old_context
 463       self.reevalue_sd_jdc()
 464       #print "reevalue_fichier_init",self.jdc_aux.context_ini
 465
 466   def update_fichier_init(self,unite):
 467       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
 468          les noms des fichiers
 469          Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
 470       """
 471       #print "update_fichier_init",unite
 472       self.fichier_err=None
 473       self.old_contexte_fichier_init=self.contexte_fichier_init
 474       old_fichier_ini=self.fichier_ini
 475
 476       #print "update_fichier_init",self,self.parent,self.parent.recorded_units
 477
 478       #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
 479       if not self.parent.recorded_units.has_key(unite):
 480          # Le numero d'unite a ete change. Le nouveau numero ne fait pas partie des numeros
 481          # enregistres.
 482          f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
 483          if f is not None:
 484             self.fichier_ini = f
 485             self.fichier_text=text
 486          #print "update_fichier_init",self.recorded_units
 487       else:
 488          # Unite existante
 489          f,text,units=self.parent.recorded_units[unite]
 490          self.fichier_ini = f
 491          self.fichier_text=text
 492          self.recorded_units=units
 493
 494       if self.fichier_ini is None:
 495          # Le fichier n'est pas défini
 496          self.fichier_err="Le fichier associé n'est pas défini"
 497          self.parent.change_unit(unite,self,self.fichier_unite)
 498          self.g_context={}
 499          self.etapes=[]
 500          self.jdc_aux=None
 501          self.contexte_fichier_init={}
 502          self.parent.reset_context()
 503          self.reevalue_sd_jdc()
 504          return
 505
 506       if old_fichier_ini == self.fichier_ini:
 507          # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
 508          #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
 509          return
 510
 511       try:
 512         self.make_contexte_include(self.fichier_ini,self.fichier_text)
 513         # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
 514         # avant d'appeler change_unit
 515         self.parent.change_unit(unite,self,self.fichier_unite)
 516       except:
 517         # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
 518         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 519         # On conserve la memoire du nouveau fichier
 520         # mais on n'utilise pas les concepts crees par ce fichier
 521         # on met l'etape en erreur : fichier_err=string.join(l)
 522         self.fichier_err=string.join(l)
 523         self.parent.change_unit(unite,self,self.fichier_unite)
 524         self.g_context={}
 525         self.etapes=[]
 526         self.jdc_aux=None
 527         self.contexte_fichier_init={}
 528
 529       # Le contexte du parent doit etre reinitialise car les concepts
 530       # produits ont changé
 531       self.parent.reset_context()
 532       # Si des concepts ont disparu lors du changement de fichier, on
 533       # demande leur suppression
 534       self.reevalue_sd_jdc()
 535       #print "update_fichier_init",self.jdc_aux.context_ini
 536
 537   def record_unite(self):
 538       if self.nom == "POURSUITE":
 539          self.parent.record_unit(None,self)
 540       else:
 541          if hasattr(self,'fichier_unite') :
 542             self.parent.record_unit(self.fichier_unite,self)
 543
 544   def get_file_memo(self,unite=None,fic_origine=''):
 545       """Retourne le nom du fichier et le source correspondant a l'unite unite
 546          Initialise en plus recorded_units
 547       """
 548       #print "get_file_memo",unite,fic_origine,self,self.parent
 549       #print self.parent.old_recorded_units
 550       #print self.parent.recorded_units
 551       if unite is None:
 552          # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
 553          units={}
 554       else:
 555          # On est dans le cas d'un include. On reutilise toutes les unites de parent
 556          units=self.parent.recorded_units
 557
 558       #if self.parent.old_recorded_units.has_key(unite):
 559       if self.parent.recorded_units.has_key(unite):
 560          f,text,units=self.parent.recorded_units[unite]
 561          #f,text,units=self.parent.old_recorded_units[unite]
 562          #print id(self.recorded_units)
 563          self.recorded_units=units
 564          #print id(self.recorded_units)
 565          return f,text
 566       elif self.jdc :
 567          f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
 568       else:
 569          f,text=None,None
 570
 571       self.recorded_units=units
 572       if f is None and self.jdc.appli:
 573          self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
 574                           message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
 575       return f,text
 576
 577 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 578   def get_file(self,unite=None,fic_origine=''):
 579       """Retourne le nom du fichier et le source correspondant a l'unite unite
 580       """
 581       if self.jdc :
 582          f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
 583       else:
 584          f,text=None,None
 585       return f,text
 586
 587 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 588   def make_include(self,unite=None):
 589       """
 590           Inclut un fichier dont l'unite logique est unite
 591           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
 592           Si l'INCLUDE est invalide, la methode doit produire une exception
 593           Sinon on retourne None. Les concepts produits par l'INCLUDE sont
 594           pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
 595       """
 596       #print "make_include",unite
 597       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
 598       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
 599       del self.unite
 600       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
 601       if not unite : return
 602
 603       if not hasattr(self,'fichier_ini') :
 604          # Si le fichier n'est pas defini on le demande
 605          f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
 606          # On memorise le fichier retourne
 607          self.fichier_ini  = f
 608          self.fichier_text = text
 609          self.contexte_fichier_init={}
 610          self.fichier_unite=unite
 611          self.fichier_err=None
 612          try:
 613            import Extensions.jdc_include
 614          except:
 615            traceback.print_exc()
 616            raise
 617          self.JdC_aux=Extensions.jdc_include.JdC_include
 618
 619          if f is None:
 620              self.fichier_err="Le fichier INCLUDE n est pas defini"
 621              self.parent.record_unit(unite,self)
 622              raise Exception(self.fichier_err)
 623
 624          try:
 625            self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 626            self.parent.record_unit(unite,self)
 627            #print "make_include.context_ini",self.jdc_aux.context_ini
 628          except:
 629            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 630            if self.jdc.appli:
 631               self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
 632                                             message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
 633                                            )
 634            self.parent.record_unit(unite,self)
 635            self.g_context={}
 636            self.etapes=[]
 637            self.jdc_aux=None
 638            self.fichier_err = string.join(l)
 639            self.contexte_fichier_init={}
 640            raise
 641
 642       else:
 643          # Si le fichier est deja defini on ne reevalue pas le fichier
 644          # et on leve une exception si une erreur a été enregistrée
 645          self.update_fichier_init(unite)
 646          self.fichier_unite=unite
 647          if self.fichier_err is not None: raise Exception(self.fichier_err)
 648
 649
 650 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 651   def make_contexte(self,fichier,text):
 652     """
 653         Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
 654         en interprétant un texte source Python
 655         Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
 656     """
 657     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
 658     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
 659     if hasattr(self,'mat'):del self.mat
 660     self.fichier_ini =fichier
 661     self.fichier_unite =fichier
 662     self.fichier_text=text
 663     self.fichier_err=None
 664     self.contexte_fichier_init={}
 665     # On specifie la classe a utiliser pour le JDC auxiliaire
 666     try:
 667       import Extensions.jdc_include
 668     except:
 669       traceback.print_exc()
 670       raise
 671     self.JdC_aux=Extensions.jdc_include.JdC_include
 672     try:
 673        self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 674        self.parent.record_unit(self.fichier_unite,self)
 675     except:
 676        l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 677        self.fichier_err = string.join(l)
 678        self.parent.record_unit(self.fichier_unite,self)
 679        self.g_context={}
 680        self.etapes=[]
 681        self.jdc_aux=None
 682        self.contexte_fichier_init={}
 683        raise
 684
 685 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 686   def update_sdprod(self,cr='non'):
 687      # Cette methode peut etre appelee dans EFICAS avec des mots cles de
 688      # la commande modifies. Ceci peut conduire a la construction ou
 689      # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
 690      # Il faut donc positionner le current_step avant l'appel
 691      CONTEXT.unset_current_step()
 692      CONTEXT.set_current_step(self)
 693      valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
 694      CONTEXT.unset_current_step()
 695      return valid
 696
 697 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
 698   def Build_sd(self,nom):
 699       """
 700            Methode de Noyau surchargee pour poursuivre malgre tout
 701            si une erreur se produit pendant la creation du concept produit
 702       """
 703       try:
 704          sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
 705       except AsException,e:
 706          # Une erreur s'est produite lors de la construction du concept
 707          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
 708          # Si on poursuit, on a le choix entre deux possibilités :
 709          # 1. on annule la sd associée à self
 710          # 2. on la conserve mais il faut la retourner
 711          # On choisit de l'annuler
 712          # En plus il faut rendre coherents sdnom et sd.nom
 713          self.sd=None
 714          self.sdnom=None
 715          self.state="unchanged"
 716          self.valid=0
 717
 718       return self.sd
 719
 720 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
 721   def make_poursuite(self):
 722       """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
 723       """
 724       #print "make_poursuite"
 725       if not hasattr(self,'fichier_ini') :
 726          # Si le fichier n'est pas defini on le demande
 727          f,text=self.get_file_memo(fic_origine=self.parent.nom)
 728          # On memorise le fichier retourne
 729          self.fichier_ini = f
 730          self.fichier_unite = None
 731          self.fichier_text = text
 732          self.fichier_err=None
 733          try:
 734            import Extensions.jdc_include
 735          except:
 736            traceback.print_exc()
 737            raise
 738          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
 739          self.contexte_fichier_init={}
 740
 741          if f is None:
 742              self.fichier_err="Le fichier POURSUITE n'est pas defini"
 743              self.parent.record_unit(None,self)
 744              raise Exception(self.fichier_err)
 745
 746          try:
 747            self.make_contexte_include(self.fichier_ini,self.fichier_text)
 748            self.parent.record_unit(None,self)
 749          except:
 750            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 751            if self.jdc.appli:
 752               self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
 753                                             message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
 754                                            )
 755            self.parent.record_unit(None,self)
 756            self.g_context={}
 757            self.etapes=[]
 758            self.jdc_aux=None
 759            self.fichier_err = string.join(l)
 760            self.contexte_fichier_init={}
 761            raise
 762
 763       else:
 764          # Si le fichier est deja defini on ne reevalue pas le fichier
 765          # et on leve une exception si une erreur a été enregistrée
 766          self.update_fichier_init(None)
 767          if self.fichier_err is not None: raise Exception(self.fichier_err)