Salome HOME
premiere version
[tools/eficas.git] / Ihm / I_MACRO_ETAPE.py
index 9be1ca6fd32e7dbe673165824e3cdf22f42bb09f..a991663cb0452246a7beb108a9562e882e369cf0 100644 (file)
@@ -1,43 +1,57 @@
-# -*- coding: utf-8 -*-
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2013   EDF R&D
 #
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
 #
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
 #
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
-# ======================================================================
 """
 """
 # Modules Python
 import sys
+import os.path as osp
 import traceback,types,string
 
 # Modules Eficas
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+import exceptions
 import I_ETAPE
+import I_ENTITE
+import I_OBJECT
+import Noyau
 from Noyau.N_ASSD import ASSD
+from Noyau import N__F
+import convert
+from Extensions import param2
 
-# import rajoutés suite à l'ajout de Build_sd --> à résorber
+# import rajoutes suite a l'ajout de Build_sd --> a resorber
 import Noyau, Validation.V_MACRO_ETAPE
 from Noyau import N_Exception
 from Noyau.N_Exception import AsException
-# fin import à résorber
+import Accas # attention aux imports circulaires
+# fin import a resorber
 
 class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def __init__(self):
       self.typret=None
+      #indique si le jeu de commande inclus a pu etre analyse par convert
+      #pour etre editable (0=NON, 1=OUI)
+      self.text_converted=1
+      self.text_error=""
       self.recorded_units={}
 
   def get_sdprods(self,nom_sd):
@@ -56,17 +70,23 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def get_contexte_jdc(self,fichier,text):
     """ 
-         Interprète text comme un texte de jdc et retourne le 
-         contexte final
-         cad le dictionnaire des sd disponibles à la dernière étape
+         Interprete text comme un texte de jdc et retourne le contexte final.
+
+         Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
          Si text n'est pas un texte de jdc valide, retourne None
          ou leve une exception
-         --> utilisée par ops.POURSUITE et INCLUDE
+         --> utilisee par ops.POURSUITE et INCLUDE
     """
-    print "get_contexte_jdc"
+    print "get_contexte_jdc",self,self.nom
+    # On recupere l'etape courante
+    step=CONTEXT.get_current_step()
     try:
-       # on essaie de créer un objet JDC auxiliaire avec un contexte initial
-       context_ini = self.parent.get_contexte_avant(self)
+       # on essaie de creer un objet JDC auxiliaire avec un contexte initial
+       # Attention get_contexte_avant retourne un dictionnaire qui contient
+       # le contexte courant. Ce dictionnaire est reactualise regulierement.
+       # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
+       context_ini = self.parent.get_contexte_avant(self).copy()
+       #print "get_contexte_jdc",context_ini.keys()
 
        # Indispensable avant de creer un nouveau JDC
        CONTEXT.unset_current_step()
@@ -74,15 +94,44 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        prefix_include=None
        if hasattr(self,'prefix'):
           prefix_include=self.prefix
-       # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des 
+       # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des 
        # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
        # tout le traitement et de ne pas le reinitialiser brutalement (utiliser 
        # clear plutot) si on ne veut pas perdre la memoire des unites.
        # En principe si la memorisation est faite au bon moment il n'est pas necessaire
        # de prendre cette precaution mais ce n'est pas vrai partout.
        old_recorded_units=self.recorded_units.copy()
-       #print "get_contexte_jdc",id(self.recorded_units)
-       #self.recorded_units.clear()
+
+       # on supprime l'ancien jdc_aux s'il existe
+       if hasattr(self,'jdc_aux') and self.jdc_aux:
+          self.jdc_aux.supprime_aux()
+
+       if fichier is None:fichier="SansNom"
+
+       # Il faut convertir le texte inclus en fonction du format
+       # sauf les INCLUDE_MATERIAU
+       self.text_converted=0
+       self.text_error=""
+       if self.nom != "INCLUDE_MATERIAU":
+          if self.parent.appli.ihm == "QT" :
+              format=self.parent.appli.appliEficas.format_fichier
+          else :
+              format=self.jdc.appli.format_fichier.get()
+          #on force a python pour Carmel
+          if format=="CARMEL3D" : format="python"
+          if convert.plugins.has_key(format):
+              # Le convertisseur existe on l'utilise
+              p=convert.plugins[format]()
+              p.text=text
+              text=p.convert('exec',self.jdc.appli)
+              #Si le fichier ne peut pas etre converti, le cr n'est pas vide
+              #et le texte est retourne tel que
+              if not p.cr.estvide(): 
+                  self.text_converted=0
+                  self.text_error=str(p.cr)
+              else:
+                  self.text_converted=1
+
 
        j=self.JdC_aux( procedure=text, nom=fichier,
                                 appli=self.jdc.appli,
@@ -95,47 +144,59 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
                                 old_recorded_units=old_recorded_units,**args)
 
        j.analyse()
-       # On récupère les étapes internes (pour validation)
+       # On recupere les etapes internes (pour validation)
        self.etapes=j.etapes
        self.jdc_aux=j
-       print "get_contexte_jdc",id(self.etapes)
+       self.jdc.jdcDict=self.jdc_aux
+
     except:
        traceback.print_exc()
-       # On force le contexte (etape courante) à self
+       # On retablit l'etape courante step
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
+       CONTEXT.set_current_step(step)
        return None
 
     if not j.cr.estvide():
        # Erreurs dans l'INCLUDE. On garde la memoire du fichier 
        # mais on n'insere pas les concepts
-       # On force le contexte (etape courante) à self
+       # On retablit l'etape courante step
+       print j.cr
+       #print j.isvalid()
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
-       raise Exception("Impossible de relire le fichier\n"+str(j.cr))
+       CONTEXT.set_current_step(step)
+       raise exceptions.Exception(tr("Impossible de relire le fichier %s \n ")+ unicode(j.cr))
+
 
     if not j.isvalid():
        # L'INCLUDE n'est pas valide.
        # on produit un rapport d'erreurs
-       # On force le contexte (etape courante) à self
        cr=j.report()
+       # On retablit l'etape courante step
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
-       raise Exception("Le fichier include contient des erreurs\n"+str(cr))
+       CONTEXT.set_current_step(step)
+       self.jdc.cr.fatal("Le fichier include contient des erreurs ")
+       raise EficasException(tr("Le fichier include contient des erreurs "))
+
 
-    # Si aucune erreur rencontrée
+    # Si aucune erreur rencontree
     # On recupere le contexte de l'include verifie
     try:
        j_context=j.get_verif_contexte()
+       #print j_context.keys()
+       #print j.g_context.keys()
     except:
+       # On retablit l'etape courante step
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
-       raise
+       CONTEXT.set_current_step(step)
+       raise EficasException(" ")
+
+    # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
+    # est valide et inserable dans le JDC
 
     # On remplit le dictionnaire des concepts produits inclus
-    # en retirant les concepts présents dans le  contexte initial
+    # en retirant les concepts presents dans le  contexte initial
     # On ajoute egalement le concept produit dans le sds_dict du parent
-    # sans verification car on est sur (verification integrée) que 
+    # sans verification car on est sur (verification integree) que 
     # le nommage est possible
     self.g_context.clear()
     for k,v in j_context.items():
@@ -143,24 +204,38 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
 
+    #Ce traitement n'est realise que dans les cas suivants:
+    #     - si convert n'a pas pu convertir le jeu de commandes
+    #     - et ce n'est pas un INCLUDE_MATERIAU
+    #On collecte les variables Python qui ne sont pas dans le contexte initial
+    #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
+    if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
+        for k,v in j.g_context.items():
+            if k in context_ini:continue
+            if k in j_context:continue
+            if isinstance(v,ASSD):continue
+            if isinstance(v,I_ENTITE.ENTITE):continue
+            if isinstance(v,I_OBJECT.OBJECT):continue
+            if callable(v):continue
+            self.g_context[k]=param2.Variable(k,v)
 
     # On recupere le contexte courant
     self.current_context=j.current_context
     self.index_etape_courante=j.index_etape_courante
     self.jdc_aux=j
 
-    # XXX j.supprime() ???
-    # On rétablit le contexte (etape courante) à self
+    # On retablit l'etape courante step
     CONTEXT.unset_current_step()
-    CONTEXT.set_current_step(self)
+    CONTEXT.set_current_step(step)
 
     return j_context
 
   def reevalue_sd_jdc(self):
      """
-         Avec la liste des SD qui ont été supprimées, propage la 
-         disparition de ces SD dans toutes les étapes et descendants
+         Avec la liste des SD qui ont ete supprimees, propage la 
+         disparition de ces SD dans toutes les etapes et descendants
      """
+     #print "reevalue_sd_jdc"
      l_sd_supp,l_sd_repl = self.diff_contextes()
      for sd in l_sd_supp:
         self.parent.delete_concept_after_etape(self,sd)
@@ -169,7 +244,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def diff_contextes(self):
      """ 
-         Réalise la différence entre les 2 contextes 
+         Realise la difference entre les 2 contextes 
          old_contexte_fichier_init et contexte_fichier_init
          cad retourne la liste des sd qui ont disparu ou ne derivent pas 
          de la meme classe et des sd qui ont ete remplacees
@@ -194,17 +269,13 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       
   def control_sdprods(self,d):
       """
-          Cette methode doit updater le contexte fournit par
-          l'appelant en argument (d) en fonction de sa definition
-          tout en verifiant que ses concepts produits ne sont pas
-          deja definis dans le contexte
+          Cette methode doit verifier que les concepts produits par la 
+          commande ne sont pas incompatibles avec le contexte fourni (d).
+          Si c'est le cas, le concept produit doit etre supprime
+          Si la macro a elle meme des etapes, elle doit propager
+          le traitement (voir methode control_jdc_context_apres de I_JDC)
       """
-      if hasattr(self,"fichier_unite"):
-         self.update_fichier_init(self.fichier_unite)
-         self.init_modif()
-
-      if type(self.definition.op_init) == types.FunctionType:
-        apply(self.definition.op_init,(self,d))
+      #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
       if self.sd:
         if d.has_key(self.sd.nom):
            # Le concept est deja defini
@@ -215,35 +286,66 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
               # Redefinition du concept, on l'annule
               #XXX on pourrait simplement annuler son nom pour conserver les objets
               # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
-              self.sd=self.reuse=self.sdnom=None
               self.init_modif()
-        else:
-           # Le concept n'est pas defini, on peut updater d
-           d[self.sd.nom]=self.sd
+              sd=self.sd
+              self.sd=self.reuse=self.sdnom=None
+              self.parent.delete_concept_after_etape(self,sd)
+              self.fin_modif()
+
       # On verifie les concepts a droite du signe =
-      for co in self.sdprods:
+      self.init_modif()
+      sdprods=self.sdprods[:]
+      self.sdprods=[]
+      for co in sdprods:
         if d.has_key(co.nom) and co is not d[co.nom] :
+           #nettoie les mots cles de l'etape qui ont comme valeur co
            self.delete_concept(co)
+           #supprime les references a co dans les etapes suivantes
+           self.parent.delete_concept_after_etape(self,co)
         else:
-           d[co.nom]=co
+           self.sdprods.append(co)
+      self.fin_modif()
        
+      for e in self.etapes:
+          e.control_sdprods(d)
+          e.update_context(d)
+
+  def supprime_sdprod(self,sd):
+      """
+         Supprime le concept produit sd s'il est produit par l'etape
+      """
+      if sd in self.sdprods:
+         self.init_modif()
+         self.parent.del_sdprod(sd)
+         self.sdprods.remove(sd)
+         self.fin_modif()
+         self.parent.delete_concept(sd)
+         return
+
+      if sd is not self.sd :return
+      if self.sd is not None :
+         self.init_modif()
+         self.parent.del_sdprod(sd)
+         self.sd=None
+         self.fin_modif()
+         self.parent.delete_concept(sd)
 
   def supprime_sdprods(self):
       """
-          Fonction:
-          Lors d'une destruction d'etape, detruit tous les concepts produits
-          Un opérateur n a qu un concept produit
+          Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
+          Un operateur n a qu un concept produit
           Une procedure n'en a aucun
-          Une macro en a en général plus d'un
+          Une macro en a en general plus d'un
       """
-      if not self.is_reentrant() :
-         # l'étape n'est pas réentrante
-         # le concept retourné par l'étape est à supprimer car il était
-         # créé par l'étape
+      #print "supprime_sdprods"
+      if self.reuse is not self.sd :
+         # l'etape n'est pas reentrante
+         # le concept retourne par l'etape est a supprimer car il etait
+         # cree par l'etape
          if self.sd != None :
             self.parent.del_sdprod(self.sd)
             self.parent.delete_concept(self.sd)
-      # On détruit les concepts à droite du signe =
+      # On detruit les concepts a droite du signe =
       for co in self.sdprods:
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
@@ -252,40 +354,262 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          if not isinstance(co,ASSD):continue
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
-      # On met g_context à blanc
+      # On met g_context a blanc
       self.g_context={}
+
+  def close(self):
+      #print "close",self
+      if hasattr(self,"jdc_aux") and self.jdc_aux:
+         # La macro a un jdc auxiliaire inclus. On demande sa fermeture
+         self.jdc_aux.close()
+
+  def reset_context(self):
+      if hasattr(self,"jdc_aux") and self.jdc_aux:
+         # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
+         self.jdc_aux.reset_context()
+
+  def update_concept(self,sd):
+      I_ETAPE.ETAPE.update_concept(self,sd)
+      for etape in self.etapes:
+          etape.update_concept(sd)
+
+  def delete_concept(self,sd):
+      """
+          Fonction : Mettre a jour les mots cles de l etape et eventuellement
+          le concept produit si reuse suite a la disparition du concept sd
+          Seuls les mots cles simples MCSIMP font un traitement autre
+          que de transmettre aux fils
+      """
+      #print "delete_concept",sd
+      I_ETAPE.ETAPE.delete_concept(self,sd)
+      for etape in self.etapes:
+         etape.delete_concept(sd)
+
+  def replace_concept(self,old_sd,sd):
+      """
+          Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse 
+          suite au remplacement  du concept old_sd par sd
+      """
+      #print "replace_concept",old_sd,sd
+      I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
+      for etape in self.etapes:
+         etape.replace_concept(old_sd,sd)
          
+  def change_fichier_init(self,new_fic,text):
+    """
+       Tente de changer le fichier include. Le precedent include est conserve
+       dans old_xxx
+    """
+    if not hasattr(self,'fichier_ini'):
+       self.fichier_ini=None
+       self.fichier_text=None
+       self.fichier_err="Le fichier n'est pas defini"
+       self.contexte_fichier_init={}
+       self.recorded_units={}
+       self.jdc_aux=None
+       self.fichier_unite="PasDefini"
+       import Extensions.jdc_include
+       self.JdC_aux=Extensions.jdc_include.JdC_include
+
+    self.old_fic = self.fichier_ini
+    self.old_text = self.fichier_text
+    self.old_err = self.fichier_err
+    self.old_context=self.contexte_fichier_init
+    self.old_units=self.recorded_units
+    self.old_etapes=self.etapes
+    self.old_jdc_aux=self.jdc_aux
+
+    self.fichier_ini = new_fic
+    self.fichier_text=text
+
+    try:
+       self.make_contexte_include(new_fic,text)
+    except:
+       l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
+       self.fichier_err=string.join(l)
+       raise EficasException(self.fichier_err)
+
+    # L'evaluation de text dans un JDC auxiliaire s'est bien passe
+    # on peut poursuivre le traitement
+    self.init_modif()
+    self.state="undetermined"
+    self.fichier_err=None
+    # On enregistre la modification de fichier
+    self.record_unite()
+    # Le contexte du parent doit etre reinitialise car les concepts produits ont change
+    self.parent.reset_context()
+
+    # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
+    self.old_contexte_fichier_init=self.old_context
+    self.reevalue_sd_jdc()
+
+    self.fin_modif()
+    if self.old_jdc_aux:
+       self.old_jdc_aux.close()
+
+  def restore_fichier_init(self):
+    """
+       Restaure le fichier init enregistre dans old_xxx
+    """
+    self.fichier_ini=self.old_fic
+    self.fichier_text=self.old_text
+    self.fichier_err=self.old_err
+    self.contexte_fichier_init=self.old_context
+    self.recorded_units=self.old_units
+    self.etapes=self.old_etapes
+    self.jdc_aux=self.old_jdc_aux
+
+  def force_fichier_init(self):
+    """
+       Force le remplacement du fichier init meme si le remplacant est en erreur
+    """
+    # Reinitialisation complete du compte-rendu d'erreurs
+    self.jdc_aux.cr=self.jdc_aux.CR()
+    # On remplit le dictionnaire des concepts produits inclus
+    # en retirant les concepts presents dans le  contexte initial
+    # On ajoute egalement le concept produit dans le sds_dict du parent
+    # sans verification car on est sur (verification integree) que
+    # le nommage est possible
+    j_context=self.jdc_aux.get_contexte_avant(None)
+    self.g_context.clear()
+    context_ini=self.jdc_aux.context_ini
+    for k,v in j_context.items():
+       if not context_ini.has_key(k) or context_ini[k] != v:
+           self.g_context[k]=v
+           self.parent.sds_dict[k]=v
+    # On recupere le contexte courant
+    self.current_context=self.jdc_aux.current_context
+    self.index_etape_courante=self.jdc_aux.index_etape_courante
+    self.contexte_fichier_init = j_context
+    self.fichier_err = None
+
+    # On enregistre la modification de fichier
+    self.init_modif()
+    self.state="undetermined"
+    self.record_unite()
+    # Le contexte du parent doit etre reinitialise car les concepts produits ont change
+    self.parent.reset_context()
+
+    # On remplace les anciens concepts par les nouveaux (y compris ajouts 
+    # et suppression) et on propage les modifications aux etapes precedentes et suivantes
+    # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
+    # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
+    # necessaires
+    self.old_contexte_fichier_init=self.old_context
+    self.reevalue_sd_jdc()
+    self.fin_modif()
+    if self.old_jdc_aux:
+       self.old_jdc_aux.close()
+
+    self.jdc_aux.force_contexte(self.g_context)
+
+  def build_include(self,fichier,text):
+    import Extensions.jdc_include
+    self.JdC_aux=Extensions.jdc_include.JdC_include
+    # un include partage la table des unites avec son parent (jdc)
+    self.recorded_units=self.parent.recorded_units
+    self.build_jdcaux(fichier,text)
+
+  def build_poursuite(self,fichier,text):
+    import Extensions.jdc_include
+    self.JdC_aux=Extensions.jdc_include.JdC_poursuite
+    # une poursuite a sa propre table d'unites
+    self.recorded_units={}
+    self.build_jdcaux(fichier,text)
+
+       
+
+  def build_includeInclude(self,text):
+    import Extensions.jdc_include
+    self.JdC_aux=Extensions.jdc_include.JdC_include
+    # un include partage la table des unites avec son parent (jdc)
+    self.build_jdcauxInclude(text)
+
+
+  def build_jdcauxInclude(self,text):
+       
+       try :
+         contexte = self.get_contexte_jdc(None,text)
+       except EficasException:
+         pass
+       index=self.jdc.etapes.index(self)
+       for e in self.etapes:
+           e.niveau=self.niveau
+       self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
+       self.g_context={}
+       self.etapes=[]
+       self.jdc_aux=None
+       CONTEXT.unset_current_step()
+
+  def build_jdcaux(self,fichier,text):
+    """
+         Cree un jdc auxiliaire initialise avec text. 
+         Initialise le nom du fichier associe avec fichier
+         N'enregistre pas d'association unite <-> fichier
+    """
+    self.fichier_ini = fichier
+    self.fichier_text= text
+    self.fichier_unite=None
+    self.fichier_err = None
+    try:
+       contexte = self.get_contexte_jdc(fichier,text)
+       if contexte is None :
+          # Impossible de construire le jdc auxiliaire (sortie par None)
+          # On simule une sortie par exception
+          raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
+       else:
+          # La construction du jdc auxiliaire est allee au bout
+          self.contexte_fichier_init = contexte
+       self.init_modif()
+       self.fin_modif()
+    except:
+       # Impossible de construire le jdc auxiliaire (sortie par exception)
+       l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+       if self.jdc.appli is not None:
+          self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                       message= tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
+
+       self.g_context={}
+       self.etapes=[]
+       self.jdc_aux=None
+       self.fichier_err = string.join(l)
+       self.contexte_fichier_init={}
+       self.init_modif()
+       self.fin_modif()
+       raise EficasException(" ")
+
   def make_contexte_include(self,fichier,text):
     """
-        Cette méthode sert à créer un contexte en interprétant un texte source
-        Python
+        Cette methode sert a craer un contexte en interpratant un texte source Python.
     """
-    print "make_contexte_include"
-    # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
+    #print "make_contexte_include",fichier
+    # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
     contexte = self.get_contexte_jdc(fichier,text)
     if contexte == None :
-      raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
+      raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
     else:
       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
       # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
-      # g_context est utilisé pour avoir les concepts produits par la macro
-      # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
+      # g_context est utilise pour avoir les concepts produits par la macro
+      # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
       self.contexte_fichier_init = contexte
+    #print "fin make_contexte_include",fichier
 
-  def reevalue_fichier_init(self):
+  def reevalue_fichier_init_OBSOLETE(self):
       """Recalcule les concepts produits par le fichier enregistre"""
+      #print "reevalue_fichier_init"
       old_context=self.contexte_fichier_init
       try:
          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
       except:
          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
          self.fichier_err = string.join(l)
-         #self.etapes=[]
          self.g_context={}
-
+         self.etapes=[]
+         self.jdc_aux=None
          self.old_contexte_fichier_init=old_context
          self.contexte_fichier_init={}
          self.reevalue_sd_jdc()
@@ -299,53 +623,56 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
   def update_fichier_init(self,unite):
       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur 
          les noms des fichiers
-         Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
+         Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
+         L'include a ete initialise precedemment. Le jdc auxiliaire existe.
       """
-      print "update_fichier_init",unite
-      self.fichier_err=None
+      #print "update_fichier_init",unite,self.fichier_unite 
       self.old_contexte_fichier_init=self.contexte_fichier_init
       old_fichier_ini=self.fichier_ini
+      if not hasattr(self,"jdc_aux"):self.jdc_aux=None
+      old_jdc_aux=self.jdc_aux
 
-      print "update_fichier_init",self,self.parent,self.parent.recorded_units
+      #print "update_fichier_init",self,self.parent,self.parent.recorded_units
 
-      #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
-      if not self.parent.recorded_units.has_key(unite):
-         # Nouvelle unite
-         f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
-         units={}
-         if f is not None:
+      if self.fichier_unite is None:
+         # L'unite n'etait pas definie precedemment. On ne change que l'unite
+         #print "update_fichier_init","pas de changement dans include"
+         self.fichier_unite=unite
+         return
+      elif unite == self.fichier_unite :
+         # L'unite n'a pas change
+         #print "update_fichier_init","pas de changement dans include 3"
+         return
+      elif unite != self.fichier_unite :
+         # L'unite etait definie precedemment. On remplace l'include 
+         #
+         f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+         if f is None:
+            # Le fichier associe n'a pas pu etre defini
+            # on change l'unite associee mais pas l'include
+            #print "update_fichier_init","pas de changement dans include 2"
+            self.fichier_unite=unite
+            return
+         else:
             self.fichier_ini = f
             self.fichier_text=text
-         self.recorded_units=units
-         if self.fichier_ini is None and self.jdc.appli:
-            self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                     message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
-      else:
-         # Unite existante
-         f,text,units=self.parent.recorded_units[unite]
-         self.fichier_ini = f
-         self.fichier_text=text
-         self.recorded_units=units
+            self.fichier_unite=unite
+         #print "update_fichier_init",self.recorded_units
 
-      if self.fichier_ini is None:
-         # Le fichier n'est pas défini
-         self.fichier_err="Le fichier associé n'est pas défini"
-         self.parent.change_unit(unite,self,self.fichier_unite)
-         self.g_context={}
-         self.contexte_fichier_init={}
-         self.parent.reset_context()
-         self.reevalue_sd_jdc()
-         return
+      #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
 
       if old_fichier_ini == self.fichier_ini:
-         # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+         # Le fichier inclus n'a pas change. On ne recree pas le contexte
+         # mais on enregistre le changement d'association unite <-> fichier
+         #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
+         self.parent.record_unit(unite,self)
          return
 
       try:
+        self.fichier_err=None
         self.make_contexte_include(self.fichier_ini,self.fichier_text)
         # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
         # avant d'appeler change_unit
-        self.parent.change_unit(unite,self,self.fichier_unite)
       except:
         # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
@@ -353,67 +680,338 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
         # mais on n'utilise pas les concepts crees par ce fichier
         # on met l'etape en erreur : fichier_err=string.join(l)
         self.fichier_err=string.join(l)
-        self.parent.change_unit(unite,self,self.fichier_unite)
         self.g_context={}
+        self.etapes=[]
+        self.jdc_aux=None
         self.contexte_fichier_init={}
 
+      if old_jdc_aux:
+         old_jdc_aux.close()
+      self.parent.record_unit(unite,self)
       # Le contexte du parent doit etre reinitialise car les concepts 
-      # produits ont changé
+      # produits ont change
       self.parent.reset_context()
       # Si des concepts ont disparu lors du changement de fichier, on 
       # demande leur suppression
       self.reevalue_sd_jdc()
+      #print "update_fichier_init",self.jdc_aux.context_ini.keys()
 
   def record_unite(self):
+      #print "record_unite",self.nom
       if self.nom == "POURSUITE":
          self.parent.record_unit(None,self)
       else:
          if hasattr(self,'fichier_unite') : 
             self.parent.record_unit(self.fichier_unite,self)
 
-  def get_file_memo(self,unite=None,fic_origine=''):
+  def get_file_memo(self, unite=None, fname=None, fic_origine=''):
       """Retourne le nom du fichier et le source correspondant a l'unite unite
          Initialise en plus recorded_units
       """
       #print "get_file_memo",unite,fic_origine,self,self.parent
-      #print self.parent.old_recorded_units
       #print self.parent.recorded_units
       if unite is None:
+         # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
          units={}
       else:
+         # On est dans le cas d'un include. On reutilise toutes les unites de parent
          units=self.parent.recorded_units
-      if self.parent.old_recorded_units.has_key(unite):
-         f,text,units=self.parent.old_recorded_units[unite]
-         #print id(self.recorded_units)
-         self.recorded_units=units
-         #print id(self.recorded_units)
-         return f,text
+
+      if self.parent.recorded_units.has_key(unite):
+         f,text,units=self.parent.recorded_units[unite]
       elif self.jdc :
-         f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+         if fname:
+             if not osp.exists(fname):
+                raise AsException(fname + tr(" n'est pas un fichier existant"))
+             f = fname
+             text = open(fname, 'rb').read()
+         else:
+             f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
       else:
          f,text=None,None
+
       self.recorded_units=units
       if f is None and self.jdc.appli:
-         self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                          message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
+         self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+               message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
       return f,text
 
+  def update_context(self,d):
+      """
+         Met a jour le contexte contenu dans le dictionnaire d
+         Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
+         Une fonction enregistree dans op_init peut egalement modifier le contexte
+      """
+      #print "update_context",self,self.nom,d.keys()
+      if hasattr(self,"jdc_aux") and self.jdc_aux:
+            #ATTENTION: update_context NE DOIT PAS appeler reset_context
+            # car il appelle directement ou indirectement update_context
+            # equivalent a reset_context. Evite les recursions
+            self.jdc_aux.context_ini=d.copy()
+            self.jdc_aux.current_context={}
+            self.jdc_aux.index_etape_courante=0
+            #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
+            #car cet appel conduit a des remontees multiples incoherentes dans le
+            # ou les parents. 
+            #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
+            #On n'a besoin que d'un update local connaissant
+            # le contexte amont : d qui sert a reinitialiser self.context_ini
+            for e in self.etapes:
+                e.update_context(d)
+            return
+
+      if type(self.definition.op_init) == types.FunctionType:
+        apply(self.definition.op_init,(self,d))
+      if self.sd != None:d[self.sd.nom]=self.sd
+      for co in self.sdprods:
+        d[co.nom]=co
+      #print "update_context.fin",d.keys()
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+  def copy(self):
+      etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
+      if hasattr(etape,"etapes") :etape.etapes=[]
+      if hasattr(etape,"jdc_aux") : 
+         etape.jdc_aux=None
+         del etape.fichier_ini
+      return etape
+
+  def supprime(self):
+      #print "supprime",self
+      if hasattr(self,"jdc_aux") and self.jdc_aux:
+         self.jdc_aux.supprime_aux()
+         self.jdc_aux=None
+      Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
+
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def get_file(self,unite=None,fic_origine=''):
       """Retourne le nom du fichier et le source correspondant a l'unite unite
-         Initialise en plus recorded_units
       """
-      #print "get_file",unite
-      units={}
       if self.jdc :
          f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
       else:
          f,text=None,None
-      self.recorded_units=units
       return f,text
 
+
+  def make_include3(self,fichier=None):
+      self.make_includeCarmel(fichier)
+
+
+  def make_includeCND(self,fichier=None):
+      unite=999
+      if fichier==None : return
+      if hasattr(self,'fichier_ini'):print self.fichier_ini
+      if hasattr(self,'fichier_ini') : return
+      self.fichier_ini=fichier
+      print "je suis dans make_includeCND"
+      from acquiertGroupes import getGroupes
+      erreur,listeGroupes=getGroupes(fichier)
+      if erreur != "" : print "a traiter"
+      texteSources=""
+      texteCond=""
+      texteNoCond=""
+      texteVcut=""
+      for groupe in listeGroupes :
+          if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
+          if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
+          if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
+          #if groupe[0:5]=='VCUT_':    texteVcut    +=groupe[5:]+"=VCUT();\n"
+          if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
+      texte=texteSources+texteCond+texteNoCond+texteVcut
+      print texte
+      self.build_includeInclude(texte)
+      if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
+      reevalue=0
+
+  def make_includeCarmel(self,fichier=None):
+  # Pour Carmel
+      #print "je suis dans make_includeCarmel"
+      unite=999
+      if hasattr(self,'fichier_ini') : return
+      reevalue=0
+      if hasattr(self,'old_context_fichier_init' ):
+         reevalue=1
+         for concept in self.old_context_fichier_init.values():
+             self.jdc.delete_concept(concept)
+      if fichier == None :
+         fichier=str(self.jdc.appli.get_file_dictDonnees())
+         if fichier  == str("") : 
+           self.fichier_ini="badfile"
+           self.fichier_text=""
+           self.fichier_err=tr("Le fichier n est pas defini")
+           self.parent.record_unit(999,self)
+           try :
+              MCFils=self.get_child('FileName')
+              MCFils.set_valeur(None)
+           except :
+              pass
+           raise EficasException(self.fichier_err)
+      self.fichier_ini  = fichier
+      f=open(self.fichier_ini,'r')
+      self.fichier_text=f.read()
+      f.close()
+
+      self.contexte_fichier_init={}
+      self.fichier_unite=999
+      self.fichier_err=None
+
+      try:
+      #if 1 :
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+      except:
+      #else:
+         traceback.print_exc()
+         self.make_incl2_except()
+         raise EficasException(" ")
+
+      try:
+      #if 1 :
+         self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+         self.old_context_fichier_init=self.contexte_fichier_init
+         self.parent.record_unit(unite,self)
+         try :
+            MCFils=self.get_child('FileName')
+            #MCFils.set_valeur(fichier)
+            #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
+            #pas de modification de bloc
+            MCFils.valeur=fichier
+            MCFils.val=fichier
+         except :
+            pass
+      except:
+      #else:
+         self.make_incl2_except()
+      # Cette P*** de ligne suivante ne fonctionne que pour Aster
+      # si quelqu un a une idee merci de m en parler
+      #CONTEXT.set_current_step(self)
+
+  def make_include2(self,fichier=None):
+  # Pour OT
+      # gestion de l unicite SVP
+      unite=999
+
+      if hasattr(self,'fichier_ini') : return
+      reevalue=0
+      if hasattr(self,'old_context_fichier_init' ):
+         reevalue=1
+         for concept in self.old_context_fichier_init.values():
+             self.jdc.delete_concept(concept)
+
+      if fichier == None :
+         fichier=str(self.jdc.appli.get_file_variable())
+         if fichier  == str("") : 
+           self.fichier_ini="badfile"
+           self.fichier_text=""
+           self.fichier_err=tr("Le fichier n est pas defini")
+           self.parent.record_unit(999,self)
+           try :
+              MCFils=self.get_child('FileName')
+              MCFils.set_valeur(None)
+           except :
+              pass
+           raise EficasException(self.fichier_err)
+
+      self.fichier_ini  = fichier
+      self.fichier_text = ""
+      self.contexte_fichier_init={}
+      self.fichier_unite=999
+      self.fichier_err=None
+      nbVariableOut=0
+      try :
+         from openturns import WrapperFile
+         monWrapper=WrapperFile(fichier)
+         data=monWrapper.getWrapperData()
+         maVariableListe=data.getVariableList()
+         nbVariables=maVariableListe.getSize()
+         for i in range(nbVariables) :
+             nom=maVariableListe[i].id_
+             type=maVariableListe[i].type_
+             if type :
+               #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
+               ligneTexte=""
+               nbVariableOut=nbVariableOut+1
+             else :
+               ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
+             self.fichier_text = self.fichier_text + ligneTexte
+      except:
+         self.make_incl2_except()
+         raise EficasException(" ")
+
+      if nbVariableOut != 1 :
+         print nbVariableOut ,"nbVariableOut"
+         self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
+         raise EficasException(" ")
+
+      try:
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+      except:
+         traceback.print_exc()
+         self.make_incl2_except()
+         raise EficasException(" ")
+      
+      try:
+         print self.fichier_ini ,self.fichier_text
+         self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+         self.old_context_fichier_init=self.contexte_fichier_init
+         self.parent.record_unit(unite,self)
+         try :
+            MCFils=self.get_child('FileName')
+            MCFils.set_valeur(fichier)
+         except :
+            pass
+      except:
+         self.make_incl2_except()
+
+      # recalcul validite pour la matrice eventuelle
+      if reevalue :
+         for e in self.jdc.etapes:
+           if e.nom == "VARIABLE" :
+              e.state="modified"
+              try :
+                 mc=e.get_child('ModelVariable') 
+                 mc.state="modified"
+              except :
+                 pass
+           if e.nom == "CORRELATION" :
+              e.state="modified"
+              try :
+                 mc=e.get_child('Matrix') 
+                 mc.state="modified"
+                 mcFeuille=mc.get_child('CorrelationMatrix')
+                 mcFeuille.state="modified"
+              except :
+                 pass
+              e.isvalid()
+
+  def make_incl2_except(self,mess=None):
+         l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
+         if self.jdc.appli is not None:
+             if mess == None :
+                     self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                     message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
+                                                                   string.join(l)))
+
+             else :
+                     self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                            message=tr(mess))
+         #self.parent.record_unit(unite,self)
+         self.g_context={}
+         self.etapes=[]
+         self.jdc_aux=None
+         self.fichier_err = string.join(l)
+         self.contexte_fichier_init={}
+         try :
+            MCFils=self.get_child('FileName')
+            MCFils.set_valeur(None)
+         except :
+            pass
+
+
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
-  def make_include(self,unite=None):
+  def make_include(self, unite=None, fname=None):
       """
           Inclut un fichier dont l'unite logique est unite
           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
@@ -421,16 +1019,16 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
           Sinon on retourne None. Les concepts produits par l'INCLUDE sont
           pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
       """
-      print "make_include",unite
+      #print "make_include",unite
       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
-      del self.unite
       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
-      if not unite : return
+      if not unite and not fname:
+          return
 
       if not hasattr(self,'fichier_ini') : 
          # Si le fichier n'est pas defini on le demande
-         f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+         f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
          # On memorise le fichier retourne
          self.fichier_ini  = f
          self.fichier_text = text
@@ -441,69 +1039,87 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
            import Extensions.jdc_include
          except:
            traceback.print_exc()
-           raise
+           raise EficasException("pb import Extensions")
          self.JdC_aux=Extensions.jdc_include.JdC_include
 
-         if f is None:
-             self.fichier_err="Le fichier INCLUDE n est pas defini"
+         #print "make_include",self.fichier_ini,self.fichier_text 
+         if f is None and not text:
+             self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
              self.parent.record_unit(unite,self)
-             raise Exception(self.fichier_err)
+             raise EficasException(self.fichier_err)
 
          try:
            self.make_contexte_include(self.fichier_ini ,self.fichier_text)
            self.parent.record_unit(unite,self)
          except:
-           l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+           l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
            if self.jdc.appli:
-              self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
-                                            message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
-                                           )
+              self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
+                                            message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)))
            self.parent.record_unit(unite,self)
            self.g_context={}
+           self.etapes=[]
+           self.jdc_aux=None
            self.fichier_err = string.join(l)
            self.contexte_fichier_init={}
-           raise
+           raise EficasException(" ")
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
-         # et on leve une exception si une erreur a été enregistrée
+         # et on leve une exception si une erreur a ete enregistree
          self.update_fichier_init(unite)
          self.fichier_unite=unite
-         if self.fichier_err is not None: raise Exception(self.fichier_err)
+         if self.fichier_err is not None: raise EficasException(self.fichier_err)
         
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def make_contexte(self,fichier,text):
     """
-        Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
-        en interprétant un texte source Python
-        Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
+        Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
+        en interpretant un texte source Python
+        Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
     """
+    #print "make_contexte",fichier
     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
     if hasattr(self,'mat'):del self.mat
-    self.fichier_ini =fichier
-    self.fichier_unite =fichier
-    self.fichier_text=text
-    self.fichier_err=None 
-    self.contexte_fichier_init={}
-    # On specifie la classe a utiliser pour le JDC auxiliaire
-    try:
-      import Extensions.jdc_include
-    except:
-      traceback.print_exc()
-      raise
-    self.JdC_aux=Extensions.jdc_include.JdC_include
-    try:
-       self.make_contexte_include(self.fichier_ini ,self.fichier_text)
-       self.parent.record_unit(self.fichier_unite,self)
-    except:
-       l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
-       self.fichier_err = string.join(l)
-       self.parent.record_unit(self.fichier_unite,self)
-       self.g_context={}
+    if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater: 
+       # le fichier est nouveau ou change
+       self.fichier_ini =fichier
+       self.fichier_unite =fichier
+       self.fichier_mater=self.nom_mater
+       self.fichier_text=text
+       self.fichier_err=None 
        self.contexte_fichier_init={}
-       raise
+       # On specifie la classe a utiliser pour le JDC auxiliaire
+       try:
+         import Extensions.jdc_include
+         self.JdC_aux=Extensions.jdc_include.JdC_include
+       except:
+         raise EficasException(" ")
+       try:
+          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+          if not self.g_context.has_key(self.nom_mater):
+             #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+             self.g_context[self.nom_mater]=None
+             if self.parent: self.parent.g_context[self.nom_mater]=None
+       except:
+          l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
+          self.fichier_err = string.join(l)
+          self.g_context={}
+          #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+          if self.parent:
+              self.parent.g_context[self.nom_mater]=None
+          self.g_context[self.nom_mater]=None
+          #-------------
+          self.etapes=[]
+          self.jdc_aux=None
+          self.contexte_fichier_init={}
+          raise EficasException(" ")
+    else:
+       # le fichier est le meme on ne le reevalue pas
+       # et on leve une exception si une erreur a ete enregistree
+       if self.fichier_err is not None: raise EficasException(self.fichier_err)
 
 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def update_sdprod(self,cr='non'):
@@ -511,7 +1127,6 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
      # la commande modifies. Ceci peut conduire a la construction ou
      # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
      # Il faut donc positionner le current_step avant l'appel
-     if self.state == "undetermined":return 1
      CONTEXT.unset_current_step()
      CONTEXT.set_current_step(self)
      valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
@@ -529,8 +1144,8 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       except AsException,e:
          # Une erreur s'est produite lors de la construction du concept
          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
-         # Si on poursuit, on a le choix entre deux possibilités :
-         # 1. on annule la sd associée à self
+         # Si on poursuit, on a le choix entre deux possibilites :
+         # 1. on annule la sd associee a self
          # 2. on la conserve mais il faut la retourner
          # On choisit de l'annuler
          # En plus il faut rendre coherents sdnom et sd.nom
@@ -543,8 +1158,9 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro 
   def make_poursuite(self):
-      """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
+      """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
       """
+      #print "make_poursuite"
       if not hasattr(self,'fichier_ini') :
          # Si le fichier n'est pas defini on le demande
          f,text=self.get_file_memo(fic_origine=self.parent.nom)
@@ -557,14 +1173,16 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
            import Extensions.jdc_include
          except:
            traceback.print_exc()
-           raise
+           raise EficasException(" ")
          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
          self.contexte_fichier_init={}
+         #print "make_poursuite",self.fichier_ini,self.fichier_text
 
          if f is None:
              self.fichier_err="Le fichier POURSUITE n'est pas defini"
+             self.jdc_aux=None
              self.parent.record_unit(None,self)
-             raise Exception(self.fichier_err)
+             raise EficasException(self.fichier_err)
 
          try:
            self.make_contexte_include(self.fichier_ini,self.fichier_text)
@@ -572,18 +1190,18 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          except:
            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
            if self.jdc.appli:
-              self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
-                                            message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
-                                           )
+              self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
+                                            message=tr("Ce fichier ne sera pas pris en compte\n %s",string.join(l)))
            self.parent.record_unit(None,self)
            self.g_context={}
+           self.etapes=[]
+           self.jdc_aux=None
            self.fichier_err = string.join(l)
            self.contexte_fichier_init={}
-           raise
+           raise EficasException(" ")
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
-         # et on leve une exception si une erreur a été enregistrée
+         # et on leve une exception si une erreur a ete enregistree
          self.update_fichier_init(None)
-         if self.fichier_err is not None: raise Exception(self.fichier_err)
-
+         if self.fichier_err is not None: raise EficasException(self.fichier_err)