Ihm/I_MACRO_ETAPE.py

   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.
   8 #
   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.
  13 #
  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.
  17 #
  18 #
  19 # ======================================================================
  20 """
  21 """
  22 # Modules Python
  23 import traceback,types,string
  24
  25 # Modules Eficas
  26 import I_ETAPE
  27 from Noyau.N_ASSD import ASSD
  28
  29 # import rajoutés suite à l'ajout de Build_sd --> à résorber
  30 import Noyau
  31 from Noyau import N_Exception
  32 from Noyau.N_Exception import AsException
  33 # fin import à résorber
  34
  35 class MACRO_ETAPE(I_ETAPE.ETAPE):
  36
  37   def __init__(self):
  38       # XXX CCAR : ne suis pas certain que typret doive etre
  39       # initialise à None (a verifier)
  40       self.typret=None
  41
  42   def get_sdprods(self,nom_sd):
  43     """
  44          Fonction : retourne le concept produit par l etape de nom nom_sd
  45                     s il existe sinon None
  46     """
  47     if self.sd:
  48       if self.sd.nom == nom_sd:
  49          return self.sd
  50     for co in self.sdprods:
  51       if co.nom==nom_sd:return co
  52     return None
  53
  54   def make_contexte(self,fichier,text):
  55     """
  56         Cette méthode sert à créer un contexte en interprétant un texte source
  57         Python
  58     """
  59     # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
  60     contexte = self.get_contexte_jdc(fichier,text)
  61     if contexte == None :
  62       raise Exception("Impossible de relire le fichier")
  63     else:
  64       self.g_context = contexte
  65       if hasattr(self,'contexte_fichier_init'):
  66         self.old_contexte_fichier_init = self.contexte_fichier_init
  67       self.contexte_fichier_init = contexte
  68       # XXX la validité ne doit pas etre forcée à 1. Que faut-il faire exactement ???
  69       self.init_modif()
  70       #self.valid = 1
  71       #self.state = 'unchanged'
  72
  73   def get_contexte_jdc(self,fichier,text):
  74     """
  75          Interprète text comme un texte de jdc et retourne le
  76          contexte final
  77          cad le dictionnaire des sd disponibles à la dernière étape
  78          Si text n'est pas un texte de jdc valide, retourne None
  79          --> utilisée par ops.POURSUITE et INCLUDE
  80     """
  81     try:
  82        # on essaie de créer un objet JDC...
  83        context_ini = self.parent.get_contexte_avant(self)
  84
  85        CONTEXT.unset_current_step()
  86        j=self.jdc.definition(procedure=text,cata=self.jdc.cata,
  87                              nom=fichier,
  88                              context_ini = context_ini,
  89                              appli=self.jdc.appli)
  90        j.analyse()
  91        # XXX en passant par un jdc auxiliaire, on risque de rendre les etapes inactives
  92        # on les force dans l'etat actif
  93        for etape in j.etapes:
  94           etape.active()
  95     except:
  96        traceback.print_exc()
  97        return None
  98     CONTEXT.set_current_step(self)
  99     if not j.cr.estvide():
 100         raise Exception("Impossible de relire le fichier\n"+str(j.cr))
 101
 102     #XXX la validité d'un source inclus n'est pas identique à celle d'un JDC complet
 103     #    impossible de la tester en dehors du JDC d'accueil
 104     #cr=j.report()
 105     #if not cr.estvide():
 106     #    raise Exception("Le fichier contient des erreurs\n"+str(j.cr))
 107     j_context=j.get_contexte_avant(None)
 108     # XXX j.g_context doit donner le meme résultat
 109     # On retourne le contexte apres la derniere etape
 110     # XXX j.supprime() ???
 111     self.verif_contexte(j_context)
 112     # Le contexte est acceptable. On récupère les étapes internes (pour validation)
 113     self.etapes=j.etapes
 114     return j_context
 115
 116   def verif_contexte(self,context):
 117      """
 118          On verifie que le contexte context peut etre inséré dans le jeu
 119          de commandes à la position de self
 120      """
 121      for nom_sd,sd in context.items():
 122         if not isinstance(sd,ASSD):continue
 123         if self.parent.get_sd_apres_etape(nom_sd,etape=self):
 124            # Il existe un concept apres self => impossible d'inserer
 125            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 126                            "%s existe déjà dans le jeu de commandes." % nom_sd)
 127
 128   def reevalue_sd_jdc(self):
 129      """
 130          Avec la liste des SD qui ont été supprimées, propage la
 131          disparition de ces SD dans totues les étapes et descendants
 132      """
 133      l_sd = self.diff_contextes()
 134      if len(l_sd) == 0 : return
 135      for sd in l_sd:
 136         self.jdc.delete_concept(sd)
 137
 138   def diff_contextes(self):
 139      """
 140          Réalise la différence entre les 2 contextes
 141          old_contexte_fichier_init et contexte_fichier_init
 142          cad retourne la liste des sd qui ont disparu
 143      """
 144      if not hasattr(self,'old_contexte_fichier_init'):return []
 145      l_sd_suppressed = []
 146      for old_key in self.old_contexte_fichier_init.keys():
 147        if not self.contexte_fichier_init.has_key(old_key):
 148          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
 149            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
 150      return l_sd_suppressed
 151
 152   def supprime_sdprods(self):
 153       """
 154           Fonction:
 155             Lors d'une destruction d'etape, detruit tous les concepts produits
 156             Un opérateur n a qu un concept produit
 157             Une procedure n'en a aucun
 158             Une macro en a en général plus d'un
 159       """
 160       if not self.is_reentrant() :
 161          # l'étape n'est pas réentrante
 162          # le concept retourné par l'étape est à supprimer car il était
 163          # créé par l'étape
 164          if self.sd != None :
 165             self.parent.del_sdprod(self.sd)
 166             self.parent.delete_concept(self.sd)
 167       # On détruit les concepts à droite du signe =
 168       for co in self.sdprods:
 169          self.parent.del_sdprod(co)
 170          self.parent.delete_concept(co)
 171       # Si la macro a des etapes et des concepts inclus, on les detruit
 172       for nom_sd,co in self.g_context.items():
 173          if not isinstance(co,ASSD):continue
 174          print "Delete: ",self.nom,co.nom
 175          self.parent.del_sdprod(co)
 176          self.parent.delete_concept(co)
 177       # On met g_context à blanc
 178       self.g_context={}
 179
 180   def Build_sd(self,nom):
 181      """
 182         Construit le concept produit de l'opérateur. Deux cas
 183         peuvent se présenter :
 184
 185         - le parent n'est pas défini. Dans ce cas, l'étape prend en charge
 186           la création et le nommage du concept.
 187
 188         - le parent est défini. Dans ce cas, l'étape demande au parent la
 189           création et le nommage du concept.
 190
 191      """
 192      if not self.isactif():return
 193      # CCAR : meme modification que dans I_ETAPE
 194      if not self.isvalid(sd='non') : return
 195      else:self.state='undetermined'
 196      self.sdnom=nom
 197      try:
 198         # On positionne la macro self en tant que current_step pour que les
 199         # étapes créées lors de l'appel à sd_prod et à op_init aient la macro
 200         #  comme parent
 201         self.set_current_step()
 202         if self.parent:
 203            sd= self.parent.create_sdprod(self,nom)
 204            if type(self.definition.op_init) == types.FunctionType:
 205               apply(self.definition.op_init,(self,self.parent.g_context))
 206         else:
 207            sd=self.get_sd_prod()
 208            if sd != None and self.reuse == None:
 209               # On ne nomme le concept que dans le cas de non reutilisation
 210               # d un concept
 211               sd.nom=nom
 212         self.reset_current_step()
 213         if self.jdc and self.jdc.par_lot == "NON" :
 214            self.Execute()
 215         return sd
 216      except AsException,e:
 217         self.reset_current_step()
 218         raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 219                              'fichier : ',self.appel[1],e)
 220      except EOFError:
 221         #self.reset_current_step()
 222         raise
 223      except :
 224         self.reset_current_step()
 225         l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
 226         raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 227                           'fichier : ',self.appel[1]+'\n',
 228                            string.join(l))