Ihm/I_MACRO_ETAPE.py

   1 """
   2 """
   3 # Modules Python
   4 import traceback,types,string
   5
   6 # Modules Eficas
   7 import I_ETAPE
   8 from Noyau.N_ASSD import ASSD
   9
  10 class MACRO_ETAPE(I_ETAPE.ETAPE):
  11
  12   def __init__(self):
  13       I_ETAPE.ETAPE.__init__(self)
  14
  15   def get_sdprods(self,nom_sd):
  16     """
  17          Fonction : retourne le concept produit par l etape de nom nom_sd
  18                     s il existe sinon None
  19     """
  20     if self.sd:
  21       if self.sd.nom == nom_sd:
  22          return self.sd
  23     for co in self.sdprods:
  24       if co.nom==nom_sd:return co
  25     return None
  26
  27   def make_contexte(self,fichier,text):
  28     """
  29         Cette méthode sert à créer un contexte en interprétant un texte source
  30         Python
  31     """
  32     # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
  33     contexte = self.get_contexte_jdc(fichier,text)
  34     if contexte == None :
  35       raise Exception("Impossible de relire le fichier")
  36     else:
  37       self.g_context = contexte
  38       if hasattr(self,'contexte_fichier_init'):
  39         self.old_contexte_fichier_init = self.contexte_fichier_init
  40       self.contexte_fichier_init = contexte
  41       # XXX la validité ne doit pas etre forcée à 1. Que faut-il faire exactement ???
  42       self.init_modif()
  43       #self.valid = 1
  44       #self.state = 'unchanged'
  45
  46   def get_contexte_jdc(self,fichier,text):
  47     """
  48          Interprète text comme un texte de jdc et retourne le
  49          contexte final
  50          cad le dictionnaire des sd disponibles à la dernière étape
  51          Si text n'est pas un texte de jdc valide, retourne None
  52          --> utilisée par ops.POURSUITE et INCLUDE
  53     """
  54     try:
  55        # on essaie de créer un objet JDC...
  56        context_ini = self.parent.get_contexte_avant(self)
  57
  58        CONTEXT.unset_current_step()
  59        j=self.jdc.definition(procedure=text,cata=self.jdc.cata,
  60                              nom=fichier,
  61                              context_ini = context_ini,
  62                              appli=self.jdc.appli)
  63        j.analyse()
  64     except:
  65        traceback.print_exc()
  66        return None
  67     CONTEXT.set_current_step(self)
  68     if not j.cr.estvide():
  69         raise Exception("Impossible de relire le fichier\n"+str(j.cr))
  70
  71     #XXX la validité d'un source inclus n'est pas identique à celle d'un JDC complet
  72     #    impossible de la tester en dehors du JDC d'accueil
  73     #cr=j.report()
  74     #if not cr.estvide():
  75     #    raise Exception("Le fichier contient des erreurs\n"+str(j.cr))
  76     j_context=j.get_contexte_avant(None)
  77     # XXX j.g_context doit donner le meme résultat
  78     # On retourne le contexte apres la derniere etape
  79     # XXX j.supprime() ???
  80     self.verif_contexte(j_context)
  81     # Le contexte est acceptable. On récupère les étapes internes (pour validation)
  82     self.etapes=j.etapes
  83     return j_context
  84
  85   def verif_contexte(self,context):
  86      """
  87          On verifie que le contexte context peut etre inséré dans le jeu
  88          de commandes à la position de self
  89      """
  90      for nom_sd,sd in context.items():
  91         if not isinstance(sd,ASSD):continue
  92         if self.parent.get_sd_apres_etape(nom_sd,etape=self):
  93            # Il existe un concept apres self => impossible d'inserer
  94            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
  95                            "%s existe déjà dans le jeu de commandes." % nom_sd)
  96
  97   def reevalue_sd_jdc(self):
  98      """
  99          Avec la liste des SD qui ont été supprimées, propage la
 100          disparition de ces SD dans totues les étapes et descendants
 101      """
 102      l_sd = self.diff_contextes()
 103      if len(l_sd) == 0 : return
 104      for sd in l_sd:
 105         self.jdc.delete_concept(sd)
 106
 107   def diff_contextes(self):
 108      """
 109          Réalise la différence entre les 2 contextes
 110          old_contexte_fichier_init et contexte_fichier_init
 111          cad retourne la liste des sd qui ont disparu
 112      """
 113      if not hasattr(self,'old_contexte_fichier_init'):return []
 114      l_sd_suppressed = []
 115      for old_key in self.old_contexte_fichier_init.keys():
 116        if not self.contexte_fichier_init.has_key(old_key):
 117          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
 118            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
 119      return l_sd_suppressed
 120
 121   def supprime_sdprods(self):
 122       """
 123           Fonction:
 124             Lors d'une destruction d'etape, detruit tous les concepts produits
 125             Un opérateur n a qu un concept produit
 126             Une procedure n'en a aucun
 127             Une macro en a en général plus d'un
 128       """
 129       if not self.is_reentrant() :
 130          # l'étape n'est pas réentrante
 131          # le concept retourné par l'étape est à supprimer car il était
 132          # créé par l'étape
 133          if self.sd != None :
 134             self.parent.del_sdprod(self.sd)
 135             self.parent.delete_concept(self.sd)
 136       # On détruit les concepts à droite du signe =
 137       for co in self.sdprods:
 138          self.parent.del_sdprod(co)
 139          self.parent.delete_concept(co)
 140       # Si la macro a des etapes et des concepts inclus, on les detruit
 141       for nom_sd,co in self.g_context.items():
 142          if not isinstance(co,ASSD):continue
 143          print "Delete: ",self.nom,co.nom
 144          self.parent.del_sdprod(co)
 145          self.parent.delete_concept(co)
 146       # On met g_context à blanc
 147       self.g_context={}
 148