Salome HOME
pb de check box
[tools/eficas.git] / Ihm / I_MACRO_ETAPE.py
index fa7ed33e6c6524cb73958e3f4fe039c2bd03a6d7..b3c03efb4153659ef73f53d381712c2c2fe86a55 100644 (file)
@@ -1,55 +1,62 @@
-#            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
 """
 """
 # Modules Python
+from __future__ import absolute_import
+from __future__ import print_function
 import sys
 import sys
-import traceback,types,string
+import os.path as osp
+import traceback,types
 
 # Modules Eficas
 
 # Modules Eficas
-import I_ETAPE
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from . import I_ETAPE
+from . import I_ENTITE
+from . import I_OBJECT
+import Noyau
 from Noyau.N_ASSD import ASSD
 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
 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
+import six
+from six.moves import range
+# fin import a resorber
 
 class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def __init__(self):
       self.typret=None
 
 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={}
 
       self.recorded_units={}
 
-  def copy(self):
-      """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
-          et sans sd
-          On surcharge la methode de ETAPE pour exprimer que les concepts crees
-          par la MACRO d'origine ne sont pas crees par la copie mais eventuellement 
-          seulement utilises
-      """
-      etape=I_ETAPE.ETAPE.copy(self)
-      etape.sdprods=[]
-      return etape
-
   def get_sdprods(self,nom_sd):
     """ 
          Fonction : retourne le concept produit par l etape de nom nom_sd
   def get_sdprods(self,nom_sd):
     """ 
          Fonction : retourne le concept produit par l etape de nom nom_sd
@@ -60,22 +67,30 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       if co.nom == nom_sd:return co
     if type(self.definition.op_init) == types.FunctionType:
       d={}
       if co.nom == nom_sd:return co
     if type(self.definition.op_init) == types.FunctionType:
       d={}
-      apply(self.definition.op_init,(self,d))
+      self.definition.op_init(*(self,d))
       return d.get(nom_sd,None)
     return None
 
   def get_contexte_jdc(self,fichier,text):
     """ 
       return d.get(nom_sd,None)
     return None
 
   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
          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",self,self.nom)
+    # On recupere l'etape courante
+    step=CONTEXT.get_current_step()
     try:
     try:
-       # on essaie de créer un objet JDC auxiliaire avec un contexte initial
-       context_ini = self.parent.get_contexte_avant(self)
+    #if 1 :
+       # 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()
 
        # Indispensable avant de creer un nouveau JDC
        CONTEXT.unset_current_step()
@@ -83,97 +98,151 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
        prefix_include=None
        if hasattr(self,'prefix'):
           prefix_include=self.prefix
        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
        # 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.
+       # 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()
        # 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()
-       self.recorded_units.clear()
 
 
-       j=self.JdC_aux( procedure=text,cata=self.jdc.cata,
-                                nom=fichier,
-                                context_ini = context_ini,
+       # 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 format in convert.plugins :
+              # 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,
                                 appli=self.jdc.appli,
+                                cata=self.jdc.cata,
+                                cata_ord_dico=self.jdc.cata_ordonne_dico,
+                                context_ini = context_ini,
                                 jdc_pere=self.jdc,etape_include=self,
                                 prefix_include=prefix_include,
                                 recorded_units=self.recorded_units,
                                 old_recorded_units=old_recorded_units,**args)
 
        j.analyse()
                                 jdc_pere=self.jdc,etape_include=self,
                                 prefix_include=prefix_include,
                                 recorded_units=self.recorded_units,
                                 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.etapes=j.etapes
+       self.jdc_aux=j
+       self.jdc.jdcDict=self.jdc_aux
+
     except:
     except:
+    #else :
        traceback.print_exc()
        traceback.print_exc()
-       # On force le contexte (etape courante) à self
+       # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
+       CONTEXT.set_current_step(step)
        return None
 
     if not j.cr.estvide():
        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
+       # Erreurs dans l'INCLUDE. On garde la memoire du fichier 
+       # mais on n'insere pas les concepts
+       # On retablit l'etape courante step
+       #print j.cr
+       #print j.isvalid()
        CONTEXT.unset_current_step()
        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 EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
 
 
-    cr=j.report()
-    if not cr.estvide():
-       # On force le contexte (etape courante) à self
+
+    if not j.isvalid():
+       # L'INCLUDE n'est pas valide.
+       # on produit un rapport d'erreurs
+       cr=j.report()
+       # On retablit l'etape courante step
        CONTEXT.unset_current_step()
        CONTEXT.unset_current_step()
-       CONTEXT.set_current_step(self)
-       raise Exception("Le fichier include contient des erreurs\n"+str(j.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 "))
 
 
-    # On recupere le contexte apres la derniere etape
-    j_context=j.get_contexte_avant(None)
 
 
-    # Cette verification n'est plus necessaire elle est integree dans le JDC_INCLUDE
-    self.verif_contexte(j_context)
+    # 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(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
 
     # 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
     # On ajoute egalement le concept produit dans le sds_dict du parent
-    # sans verification car on est sur (verification integrée) que le nommage est possible
+    # sans verification car on est sur (verification integree) que 
+    # le nommage est possible
     self.g_context.clear()
     for k,v in j_context.items():
     self.g_context.clear()
     for k,v in j_context.items():
-       if not context_ini.has_key(k) or context_ini[k] != v:
+       if (not k in context_ini) or (context_ini[k] != v):
            self.g_context[k]=v
            self.parent.sds_dict[k]=v
 
            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)
 
 
+    print ('kljkljkljlkjklj')
     # On recupere le contexte courant
     self.current_context=j.current_context
     self.index_etape_courante=j.index_etape_courante
     # 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.unset_current_step()
-    CONTEXT.set_current_step(self)
+    CONTEXT.set_current_step(step)
 
 
+    print ('kljkljkljlkjklj')
     return j_context
 
     return j_context
 
-  def verif_contexte(self,context):
-     """
-         On verifie que le contexte context peut etre inséré dans le jeu
-         de commandes à la position de self
-     """
-     for nom_sd,sd in context.items():
-        if not isinstance(sd,ASSD):continue
-        #if self.parent.get_sd_apres_etape(nom_sd,etape=self):
-        if self.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,etape=self):
-           # Il existe un concept produit par une etape apres self => impossible d'inserer
-           # On force le contexte (etape courante) à self
-           CONTEXT.unset_current_step()
-           CONTEXT.set_current_step(self)
-           raise Exception("Impossible d'inclure le fichier. Un concept de nom " + 
-                           "%s existe déjà dans le jeu de commandes." % nom_sd)
-
   def reevalue_sd_jdc(self):
      """
   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)
      l_sd_supp,l_sd_repl = self.diff_contextes()
      for sd in l_sd_supp:
         self.parent.delete_concept_after_etape(self,sd)
@@ -182,16 +251,16 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
 
   def diff_contextes(self):
      """ 
 
   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
          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
+         cad retourne la liste des sd qui ont disparu ou ne derivent pas 
+         de la meme classe et des sd qui ont ete remplacees
      """
      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
      l_sd_suppressed = []
      l_sd_replaced = []
      """
      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
      l_sd_suppressed = []
      l_sd_replaced = []
-     for old_key in self.old_contexte_fichier_init.keys():
-       if not self.contexte_fichier_init.has_key(old_key):
+     for old_key in self.old_contexte_fichier_init:
+       if not old_key in self.contexte_fichier_init:
          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
        else:
          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
        else:
@@ -207,19 +276,15 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       
   def control_sdprods(self,d):
       """
       
   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 self.sd:
-        if d.has_key(self.sd.nom):
+        if self.sd.nom in d:
            # Le concept est deja defini
            if self.reuse and self.reuse is d[self.sd.nom]:
               # Le concept est reutilise : situation normale
            # Le concept est deja defini
            if self.reuse and self.reuse is d[self.sd.nom]:
               # Le concept est reutilise : situation normale
@@ -228,35 +293,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??)
               # 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()
               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 =
       # On verifie les concepts a droite du signe =
-      for co in self.sdprods:
-        if d.has_key(co.nom) and co is not d[co.nom] :
+      self.init_modif()
+      sdprods=self.sdprods[:]
+      self.sdprods=[]
+      for co in sdprods:
+        if co.nom in d and co is not d[co.nom] :
+           #nettoie les mots cles de l'etape qui ont comme valeur co
            self.delete_concept(co)
            self.delete_concept(co)
+           #supprime les references a co dans les etapes suivantes
+           self.parent.delete_concept_after_etape(self,co)
         else:
         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):
       """
 
   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 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)
          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)
       for co in self.sdprods:
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
@@ -265,128 +361,263 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
          if not isinstance(co,ASSD):continue
          self.parent.del_sdprod(co)
          self.parent.delete_concept(co)
          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={}
       self.g_context={}
-         
-#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
-  def Build_sd(self,nom):
+
+  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):
       """
       """
-           Methode de Noyau surchargee pour poursuivre malgre tout
-           si une erreur se produit pendant la creation du concept produit
+          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
       """
       """
-      try:
-         sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
-         self.state="unchanged"
-         self.valid=1
-      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
-         # 2. on la conserve mais il faut la retourner
-         # On choisit de l'annuler
-         # En plus il faut rendre coherents sdnom et sd.nom
-         self.sd=None
-         self.sdnom=None
-         self.state="unchanged"
-         self.valid=0
+      #print "delete_concept",sd
+      I_ETAPE.ETAPE.delete_concept(self,sd)
+      for etape in self.etapes:
+         etape.delete_concept(sd)
 
 
-      return self.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
 
 
-#ATTENTION : cette methode surcharge celle de Noyau (a garder en synchro ou a reintegrer)
-  def Build_sd_old(self,nom):
-     """
-        Construit le concept produit de l'opérateur. Deux cas 
-        peuvent se présenter :
+    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
 
 
-           - le parent n'est pas défini. Dans ce cas, l'étape prend en charge 
-             la création et le nommage du concept.
+    self.fichier_ini = new_fic
+    self.fichier_text=text
 
 
-           - le parent est défini. Dans ce cas, l'étape demande au parent la 
-             création et le nommage du concept.
+    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=''.join(l)
+       raise EficasException(self.fichier_err)
 
 
-     """
-     if not self.isactif():return
-     # CCAR : meme modification que dans I_ETAPE
-     if not self.isvalid(sd='non') : return
-     self.sdnom=nom
-     try:
-        # On positionne la macro self en tant que current_step pour que les 
-        # étapes créées lors de l'appel à sd_prod et à op_init aient la macro
-        #  comme parent 
-        self.set_current_step()
-        if self.parent:
-           sd= self.parent.create_sdprod(self,nom)
-           if type(self.definition.op_init) == types.FunctionType: 
-              apply(self.definition.op_init,(self,self.parent.g_context))
-        else:
-           sd=self.get_sd_prod()
-           if sd != None and self.reuse == None:
-              # On ne nomme le concept que dans le cas de non reutilisation 
-              # d un concept
-              sd.nom=nom
-        self.reset_current_step()
-        # Si on est arrive ici, l'etape est valide
-        self.state="unchanged"
-        self.valid=1
-        if self.jdc and self.jdc.par_lot == "NON" :
-           self.Execute()
-        return sd
-     except AsException,e:
-        self.reset_current_step()
-        # 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
-        # 2. on la conserve mais il faut qu'elle soit correcte et la retourner
-        # En plus il faut rendre coherents sdnom et sd.nom
-        # On choisit de retourner None et de mettre l'etape invalide 
-        self.sd=None
-        self.sdnom=None
-        self.state="unchanged"
-        self.valid=0
-        return self.sd
-        #raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
-        #                     'fichier : ',self.appel[1],e)
-     except EOFError:
-        raise
-     except :
-        self.reset_current_step()
-        l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
-        raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
-                          'fichier : ',self.appel[1]+'\n',
-                           string.join(l))
+    # 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 k in context_ini 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",''.join(l)))
+
+       self.g_context={}
+       self.etapes=[]
+       self.jdc_aux=None
+       self.fichier_err = ''.join(l)
+       self.contexte_fichier_init={}
+       self.init_modif()
+       self.fin_modif()
+       raise EficasException(" ")
 
   def make_contexte_include(self,fichier,text):
     """
 
   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.
     """
     """
-    # 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)
     contexte = self.get_contexte_jdc(fichier,text)
+    print ("make_contexte_include",fichier)
     if contexte == None :
     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)
     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
       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"""
       """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])
       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.fichier_err = ''.join(l)
          self.g_context={}
          self.g_context={}
-
+         self.etapes=[]
+         self.jdc_aux=None
          self.old_contexte_fichier_init=old_context
          self.contexte_fichier_init={}
          self.reevalue_sd_jdc()
          self.old_contexte_fichier_init=old_context
          self.contexte_fichier_init={}
          self.reevalue_sd_jdc()
@@ -400,142 +631,394 @@ 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
   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.
       """
       """
-      
-      self.fichier_err=None
+      #print "update_fichier_init",unite,self.fichier_unite 
       self.old_contexte_fichier_init=self.contexte_fichier_init
       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
 
 
-      if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
-         # Changement d'unite ou Nouvelle unite
-         f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
-         units={}
-         if f is not None:
+      #print "update_fichier_init",self,self.parent,self.parent.recorded_units
+
+      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.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:
-         # Meme 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()
+      #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 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:
          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.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])
         # On conserve la memoire du nouveau fichier
         # mais on n'utilise pas les concepts crees par ce fichier
       except:
         # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
         # On conserve la memoire du nouveau fichier
         # 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)
+        # on met l'etape en erreur : fichier_err=''.join(l)
+        self.fichier_err=''.join(l)
         self.g_context={}
         self.g_context={}
+        self.etapes=[]
+        self.jdc_aux=None
         self.contexte_fichier_init={}
 
         self.contexte_fichier_init={}
 
-      # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+      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 change
       self.parent.reset_context()
       self.parent.reset_context()
-      # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
+      # Si des concepts ont disparu lors du changement de fichier, on 
+      # demande leur suppression
       self.reevalue_sd_jdc()
       self.reevalue_sd_jdc()
+      #print "update_fichier_init",self.jdc_aux.context_ini.keys()
 
   def record_unite(self):
 
   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)
 
       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 make_poursuite(self):
-      """ Cette methode est appelée par la fonction sd_prod de la macro 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)
-         # On memorise le fichier retourne
-         self.fichier_ini = f
-         self.fichier_unite = None
-         self.fichier_text = text
-         self.fichier_err=None
-         import Extensions.jdc_include
-         self.JdC_aux=Extensions.jdc_include.JdC_poursuite
-         self.contexte_fichier_init={}
-
-         if f is None:
-             self.fichier_err="Le fichier POURSUITE n'est pas defini"
-             self.parent.record_unit(None,self)
-             raise Exception(self.fichier_err)
-
-         try:
-           self.make_contexte_include(self.fichier_ini,self.fichier_text)
-           self.parent.record_unit(None,self)
-         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.parent.record_unit(None,self)
-           self.g_context={}
-           self.fichier_err = string.join(l)
-           self.contexte_fichier_init={}
-           raise
-
-      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
-         self.update_fichier_init(None)
-         if self.fichier_err is not None: raise Exception(self.fichier_err)
-
-  def get_file(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
       """
       """Retourne le nom du fichier et le source correspondant a l'unite unite
          Initialise en plus recorded_units
       """
-      units={}
-      if self.jdc :
-         f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+      #print "get_file_memo",unite,fic_origine,self,self.parent
+      #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 unite in self.parent.recorded_units:
+         f,text,units=self.parent.recorded_units[unite]
+      elif self.jdc :
+         if fname:
+             if not osp.exists(fname):
+                raise AsException(fname + tr(" n'est pas un fichier existant"))
+             f = fname
+             text = open(fname, 'r').read()
+         else:
+             f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
       else:
          f,text=None,None
       else:
          f,text=None,None
+
       self.recorded_units=units
       self.recorded_units=units
+      if f is None and self.jdc.appli:
+         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
 
       return f,text
 
-  def get_file_memo(self,unite=None,fic_origine=''):
+  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:
+        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
       """Retourne le nom du fichier et le source correspondant a l'unite unite
-         Initialise en plus recorded_units
       """
       """
-      units={}
-      if self.parent.old_recorded_units.has_key(unite):
-         f,text,units=self.parent.old_recorded_units[unite]
-         self.recorded_units=units
-         return f,text
-      elif self.jdc :
+      if self.jdc :
          f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
       else:
          f,text=None,None
          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")
       return f,text
 
       return f,text
 
-#ATTENTION : cette methode surcharge celle de Noyau (a garder en synchro)
-  def make_include(self,unite=None):
+
+  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
+      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",\
+                                                                   ''.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 = ''.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, fname=None):
       """
           Inclut un fichier dont l'unite logique est unite
           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
       """
           Inclut un fichier dont l'unite logique est unite
           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
@@ -543,83 +1026,109 @@ 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 ???)
       """
           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
       # 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
       # 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
       # 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
 
       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
          self.contexte_fichier_init={}
          self.fichier_unite=unite
          self.fichier_err=None
          # On memorise le fichier retourne
          self.fichier_ini  = f
          self.fichier_text = text
          self.contexte_fichier_init={}
          self.fichier_unite=unite
          self.fichier_err=None
-         import Extensions.jdc_include
+         try:
+           import Extensions.jdc_include
+         except:
+           traceback.print_exc()
+           raise EficasException("pb import Extensions")
          self.JdC_aux=Extensions.jdc_include.JdC_include
 
          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)
              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:
 
          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:
            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"+''.join(l)))
            self.parent.record_unit(unite,self)
            self.g_context={}
            self.parent.record_unit(unite,self)
            self.g_context={}
-           self.fichier_err = string.join(l)
+           self.etapes=[]
+           self.jdc_aux=None
+           self.fichier_err = ''.join(l)
            self.contexte_fichier_init={}
            self.contexte_fichier_init={}
-           raise
+           raise EficasException(" ")
 
       else:
          # Si le fichier est deja defini on ne reevalue pas le fichier
 
       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
          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 : cette methode surcharge celle de Noyau (a garder en synchro)
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def make_contexte(self,fichier,text):
     """
   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
     # 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
-    import Extensions.jdc_include
-    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={}
        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.nom_mater in self.g_context :
+             #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 = ''.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 : cette methode surcharge celle de Noyau (a garder en synchro)
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
   def update_sdprod(self,cr='non'):
      # Cette methode peut etre appelee dans EFICAS avec des mots cles de 
      # la commande modifies. Ceci peut conduire a la construction ou
   def update_sdprod(self,cr='non'):
      # Cette methode peut etre appelee dans EFICAS avec des mots cles de 
      # la commande modifies. Ceci peut conduire a la construction ou
@@ -631,3 +1140,77 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
      CONTEXT.unset_current_step()
      return valid
 
      CONTEXT.unset_current_step()
      return valid
 
+#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro 
+  def Build_sd(self,nom):
+      """
+           Methode de Noyau surchargee pour poursuivre malgre tout
+           si une erreur se produit pendant la creation du concept produit
+      """
+      try:
+         sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
+      except :
+      #   return None
+      #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 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
+         self.sd=None
+         self.sdnom=None
+         self.state="unchanged"
+         self.valid=0
+
+      return self.sd
+
+#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro 
+  def make_poursuite(self):
+      """ 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)
+         # On memorise le fichier retourne
+         self.fichier_ini = f
+         self.fichier_unite = None
+         self.fichier_text = text
+         self.fichier_err=None
+         try:
+           import Extensions.jdc_include
+         except:
+           traceback.print_exc()
+           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 EficasException(self.fichier_err)
+
+         try:
+           self.make_contexte_include(self.fichier_ini,self.fichier_text)
+           self.parent.record_unit(None,self)
+         except:
+           l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+           if self.jdc.appli:
+              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",''.join(l)))
+           self.parent.record_unit(None,self)
+           self.g_context={}
+           self.etapes=[]
+           self.jdc_aux=None
+           self.fichier_err = ''.join(l)
+           self.contexte_fichier_init={}
+           raise EficasException(" ")
+
+      else:
+         # Si le fichier est deja defini on ne reevalue pas le fichier
+         # et on leve une exception si une erreur a ete enregistree
+         self.update_fichier_init(None)
+         if self.fichier_err is not None: raise EficasException(self.fichier_err)