Ihm/I_MACRO_ETAPE.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2017   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """
  21 """
  22 # Modules Python
  23 from __future__ import absolute_import
  24 from __future__ import print_function
  25 import sys
  26 import os.path as osp
  27 import traceback,types
  28
  29 # Modules Eficas
  30 from Extensions.i18n import tr
  31 from Extensions.eficas_exception import EficasException
  32 from Ihm  import I_ETAPE
  33 from Ihm import I_ENTITE
  34 from Ihm import I_OBJECT
  35 import Noyau
  36 from Noyau.N_ASSD import ASSD
  37 from Noyau import N__F
  38 from Extensions import param2
  39
  40 # import rajoutes suite a l'ajout de buildSd --> a resorber
  41 import Noyau, Validation.V_MACRO_ETAPE
  42 from Noyau import N_Exception
  43 from Noyau.N_Exception import AsException
  44 import Accas # attention aux imports circulaires
  45 import six
  46 from six.moves import range
  47 # fin import a resorber
  48
  49 class MACRO_ETAPE(I_ETAPE.ETAPE):
  50
  51   def __init__(self):
  52       self.typret=None
  53       #indique si le jeu de commande inclus a pu etre analyse par convert
  54       #pour etre editable (0=NON, 1=OUI)
  55       self.text_converted=1
  56       self.text_error=""
  57       self.recorded_units={}
  58
  59   def getSdprods(self,nom_sd):
  60     """
  61          Fonction : retourne le concept produit par l etape de nom nom_sd
  62          s il existe sinon None
  63     """
  64     if self.sd and self.sd.nom == nom_sd :return self.sd
  65     for co in self.sdprods:
  66       if co.nom == nom_sd:return co
  67     if type(self.definition.op_init) == types.FunctionType:
  68       d={}
  69       self.definition.op_init(*(self,d))
  70       return d.get(nom_sd,None)
  71     return None
  72
  73   def getContexteJdc(self,fichier,text,doitEtreValide=1):
  74     """
  75          Interprete text comme un texte de jdc et retourne le contexte final.
  76
  77          Le contexte final est le dictionnaire des sd disponibles a la derniere etape.
  78          Si text n'est pas un texte de jdc valide, retourne None
  79          ou leve une exception
  80          --> utilisee par ops.POURSUITE et INCLUDE
  81     """
  82     #print ("getContexteJdc",self,self.nom, text)
  83     # On recupere l'etape courante
  84     step=CONTEXT.getCurrentStep()
  85     #try:
  86     if 1 :
  87        # on essaie de creer un objet JDC auxiliaire avec un contexte initial
  88        # Attention getContexteAvant retourne un dictionnaire qui contient
  89        # le contexte courant. Ce dictionnaire est reactualise regulierement.
  90        # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
  91        context_ini = self.parent.getContexteAvant(self).copy()
  92
  93        # Indispensable avant de creer un nouveau JDC
  94        CONTEXT.unsetCurrentStep()
  95        args=self.jdc.args
  96        prefix_include=None
  97        if hasattr(self,'prefix'):
  98           prefix_include=self.prefix
  99        # ATTENTION : le dictionnaire recorded_units sert a memoriser les unites des
 100        # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
 101        # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
 102        # clear plutot) si on ne veut pas perdre la memoire des unites.
 103        # En principe si la memorisation est faite au bon moment il n'est pas necessaire
 104        # de prendre cette precaution mais ce n'est pas vrai partout.
 105        old_recorded_units=self.recorded_units.copy()
 106
 107        # on supprime l'ancien jdc_aux s'il existe
 108        if hasattr(self,'jdc_aux') and self.jdc_aux:
 109           self.jdc_aux.supprime_aux()
 110
 111        if fichier is None:fichier="SansNom"
 112
 113        # Il faut convertir le texte inclus en fonction du format
 114        # sauf les INCLUDE_MATERIAU
 115        self.text_converted=0
 116        self.text_error=""
 117        if self.nom != "INCLUDE_MATERIAU":
 118           format=self.parent.appli.appliEficas.format_fichier
 119           #on force a python pour Carmel
 120           if format=="CARMEL3D" : format="python"
 121           import convert
 122           if format in convert.plugins :
 123               # Le convertisseur existe on l'utilise
 124               p=convert.plugins[format]()
 125               p.text=text
 126               text=p.convert('exec',self.jdc.appli)
 127               #Si le fichier ne peut pas etre converti, le cr n'est pas vide
 128               #et le texte est retourne tel que
 129               if not p.cr.estvide():
 130                   self.text_converted=0
 131                   self.text_error=str(p.cr)
 132               else:
 133                   self.text_converted=1
 134
 135
 136        if hasattr(self,'sd') and self.sd != None : context_ini[self.sd.nom]=self.sd
 137        j=self.JdC_aux( procedure=text, nom=fichier,
 138                                 appli=self.jdc.appli,
 139                                 cata=self.jdc.cata,
 140                                 cata_ord_dico=self.jdc.cata_ordonne_dico,
 141                                 context_ini = context_ini,
 142                                 jdc_pere=self.jdc,etape_include=self,
 143                                 prefix_include=prefix_include,
 144                                 recorded_units=self.recorded_units,
 145                                 old_recorded_units=old_recorded_units,**args)
 146
 147        j.analyse()
 148        # On recupere les etapes internes (pour validation)
 149        self.etapes=j.etapes
 150        self.jdc_aux=j
 151        self.jdc.jdcDict=self.jdc_aux
 152
 153     #except:
 154     else :
 155        traceback.print_exc()
 156        # On retablit l'etape courante step
 157        CONTEXT.unsetCurrentStep()
 158        CONTEXT.setCurrentStep(step)
 159        return None
 160
 161
 162     if not j.cr.estvide() and doitEtreValide:
 163        # Erreurs dans l'INCLUDE. On garde la memoire du fichier
 164        # mais on n'insere pas les concepts
 165        # On retablit l'etape courante step
 166        #print (j.cr)
 167        #print ("valid ",j.isValid())
 168        CONTEXT.unsetCurrentStep()
 169        CONTEXT.setCurrentStep(step)
 170        raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
 171
 172
 173     if not j.isValid() and doitEtreValide:
 174        # L'INCLUDE n'est pas valide.
 175        # on produit un rapport d'erreurs
 176        cr=j.report()
 177        #print ('cr', cr)
 178        # On retablit l'etape courante step
 179        CONTEXT.unsetCurrentStep()
 180        CONTEXT.setCurrentStep(step)
 181        self.jdc.cr.fatal("Le fichier include contient des erreurs ")
 182        raise EficasException(tr("Le fichier include contient des erreurs "))
 183
 184
 185     # Si aucune erreur rencontree
 186     # ou qu on accepte un jdc incomplet
 187     # On recupere le contexte de l'include verifie
 188     try:
 189        j_context=j.getVerifContexte()
 190        #print j_context.keys()
 191        #print j.g_context.keys()
 192     except:
 193        # On retablit l'etape courante step
 194        CONTEXT.unsetCurrentStep()
 195        CONTEXT.setCurrentStep(step)
 196        raise EficasException(" ")
 197
 198     # Si on est arrive ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
 199     # est valide et inserable dans le JDC
 200
 201     # On remplit le dictionnaire des concepts produits inclus
 202     # en retirant les concepts presents dans le  contexte initial
 203     # On ajoute egalement le concept produit dans le sds_dict du parent
 204     # sans verification car on est sur (verification integree) que
 205     # le nommage est possible
 206     self.g_context.clear()
 207     for k,v in j_context.items():
 208        if (not k in context_ini) or (context_ini[k] != v):
 209            self.g_context[k]=v
 210            self.parent.sds_dict[k]=v
 211
 212     #Ce traitement n'est realise que dans les cas suivants:
 213     #     - si convert n'a pas pu convertir le jeu de commandes
 214     #     - et ce n'est pas un INCLUDE_MATERIAU
 215     #On collecte les variables Python qui ne sont pas dans le contexte initial
 216     #et dans le contexte valide et on en fait un pseudo-parametre (Variable)
 217     if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
 218         for k,v in j.g_context.items():
 219             if k in context_ini:continue
 220             if k in j_context:continue
 221             if isinstance(v,ASSD):continue
 222             if isinstance(v,I_ENTITE.ENTITE):continue
 223             if isinstance(v,I_OBJECT.OBJECT):continue
 224             if callable(v):continue
 225             self.g_context[k]=param2.Variable(k,v)
 226
 227     # On recupere le contexte courant
 228     self.current_context=j.current_context
 229     self.index_etape_courante=j.index_etape_courante
 230     self.jdc_aux=j
 231
 232     # On retablit l'etape courante step
 233     CONTEXT.unsetCurrentStep()
 234     CONTEXT.setCurrentStep(step)
 235
 236     return j_context
 237
 238   def reevalueSdJdc(self):
 239      """
 240          Avec la liste des SD qui ont ete supprimees, propage la
 241          disparition de ces SD dans toutes les etapes et descendants
 242      """
 243      #print "reevalueSdJdc"
 244      l_sd_supp,l_sd_repl = self.diffContextes()
 245      for sd in l_sd_supp:
 246         self.parent.deleteConceptAfterEtape(self,sd)
 247      for old_sd,sd in l_sd_repl:
 248         self.parent.replaceConceptAfterEtape(self,old_sd,sd)
 249
 250   def diffContextes(self):
 251      """
 252          Realise la difference entre les 2 contextes
 253          old_contexte_fichier_init et contexte_fichier_init
 254          cad retourne la liste des sd qui ont disparu ou ne derivent pas
 255          de la meme classe et des sd qui ont ete remplacees
 256      """
 257      if not hasattr(self,'old_contexte_fichier_init'):return [],[]
 258      l_sd_suppressed = []
 259      l_sd_replaced = []
 260      for old_key in self.old_contexte_fichier_init:
 261        if not old_key in self.contexte_fichier_init:
 262          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
 263            l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
 264        else:
 265          if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
 266             # Un concept de meme nom existe
 267             old_class=self.old_contexte_fichier_init[old_key].__class__
 268             if not isinstance(self.contexte_fichier_init[old_key],old_class):
 269                # S'il n'est pas d'une classe derivee, on le supprime
 270                l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
 271             else:
 272                l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
 273      return l_sd_suppressed,l_sd_replaced
 274
 275   def controlSdprods(self,d):
 276       """
 277           Cette methode doit verifier que les concepts produits par la
 278           commande ne sont pas incompatibles avec le contexte fourni (d).
 279           Si c'est le cas, le concept produit doit etre supprime
 280           Si la macro a elle meme des etapes, elle doit propager
 281           le traitement (voir methode controlJdcContextApres de I_JDC)
 282       """
 283       #print ("I_MACRO_ETAPE.controlSdprods",d.keys(),self,self.nom,self.sd and self.sd.nom)
 284       if self.sd:
 285         if self.sd.nom in d:
 286            # Le concept est deja defini
 287            if self.reuse and self.reuse is d[self.sd.nom]:
 288               # Le concept est reutilise : situation normale
 289               pass
 290            else:
 291               # Redefinition du concept, on l'annule
 292               #XXX on pourrait simplement annuler son nom pour conserver les objets
 293               # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
 294               self.initModif()
 295               sd=self.sd
 296               self.sd=self.reuse=self.sdnom=None
 297               self.parent.deleteConceptAfterEtape(self,sd)
 298               self.finModif()
 299
 300       # On verifie les concepts a droite du signe =
 301       self.initModif()
 302       sdprods=self.sdprods[:]
 303       self.sdprods=[]
 304       for co in sdprods:
 305         if co.nom in d and co is not d[co.nom] :
 306            #nettoie les mots cles de l'etape qui ont comme valeur co
 307            self.deleteConcept(co)
 308            #supprime les references a co dans les etapes suivantes
 309            self.parent.deleteConceptAfterEtape(self,co)
 310         else:
 311            self.sdprods.append(co)
 312       self.finModif()
 313
 314       for e in self.etapes:
 315           e.controlSdprods(d)
 316           e.updateContext(d)
 317
 318   def supprimeSdprod(self,sd):
 319       """
 320          Supprime le concept produit sd s'il est produit par l'etape
 321       """
 322       if sd in self.sdprods:
 323          self.initModif()
 324          self.parent.delSdprod(sd)
 325          self.sdprods.remove(sd)
 326          self.finModif()
 327          self.parent.deleteConcept(sd)
 328          return
 329
 330       if sd is not self.sd :return
 331       if self.sd is not None :
 332          self.initModif()
 333          self.parent.delSdprod(sd)
 334          self.sd=None
 335          self.finModif()
 336          self.parent.deleteConcept(sd)
 337
 338   def supprimeSdProds(self):
 339       """
 340           Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
 341           Un operateur n a qu un concept produit
 342           Une procedure n'en a aucun
 343           Une macro en a en general plus d'un
 344       """
 345       #print "supprimeSdProds"
 346       if self.reuse is not self.sd :
 347          # l'etape n'est pas reentrante
 348          # le concept retourne par l'etape est a supprimer car il etait
 349          # cree par l'etape
 350          if self.sd != None :
 351             self.parent.delSdprod(self.sd)
 352             self.parent.deleteConcept(self.sd)
 353       # On detruit les concepts a droite du signe =
 354       for co in self.sdprods:
 355          self.parent.delSdprod(co)
 356          self.parent.deleteConcept(co)
 357       # Si la macro a des etapes et des concepts inclus, on les detruit
 358       for nom_sd,co in self.g_context.items():
 359          if not isinstance(co,ASSD):continue
 360          self.parent.delSdprod(co)
 361          self.parent.deleteConcept(co)
 362       # On met g_context a blanc
 363       self.g_context={}
 364
 365   def close(self):
 366       #print "close",self
 367       if hasattr(self,"jdc_aux") and self.jdc_aux:
 368          # La macro a un jdc auxiliaire inclus. On demande sa fermeture
 369          self.jdc_aux.close()
 370
 371   def resetContext(self):
 372       if hasattr(self,"jdc_aux") and self.jdc_aux:
 373          # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
 374          self.jdc_aux.resetContext()
 375
 376   def updateConcept(self,sd):
 377       I_ETAPE.ETAPE.updateConcept(self,sd)
 378       for etape in self.etapes:
 379           etape.updateConcept(sd)
 380
 381   def deleteConcept(self,sd):
 382       """
 383           Fonction : Mettre a jour les mots cles de l etape et eventuellement
 384           le concept produit si reuse suite a la disparition du concept sd
 385           Seuls les mots cles simples MCSIMP font un traitement autre
 386           que de transmettre aux fils
 387       """
 388       #print "deleteConcept",sd
 389       I_ETAPE.ETAPE.deleteConcept(self,sd)
 390       for etape in self.etapes:
 391          etape.deleteConcept(sd)
 392
 393   def replaceConcept(self,old_sd,sd):
 394       """
 395           Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
 396           suite au remplacement  du concept old_sd par sd
 397       """
 398       #print "replaceConcept",old_sd,sd
 399       I_ETAPE.ETAPE.replaceConcept(self,old_sd,sd)
 400       for etape in self.etapes:
 401          etape.replaceConcept(old_sd,sd)
 402
 403   def changeFichierInit(self,new_fic,text):
 404     """
 405        Tente de changer le fichier include. Le precedent include est conserve
 406        dans old_xxx
 407     """
 408     if not hasattr(self,'fichier_ini'):
 409        self.fichier_ini=None
 410        self.fichier_text=None
 411        self.fichier_err="Le fichier n'est pas defini"
 412        self.contexte_fichier_init={}
 413        self.recorded_units={}
 414        self.jdc_aux=None
 415        self.fichier_unite="PasDefini"
 416        import Extensions.jdc_include
 417        self.JdC_aux=Extensions.jdc_include.JdC_include
 418
 419     self.old_fic = self.fichier_ini
 420     self.old_text = self.fichier_text
 421     self.old_err = self.fichier_err
 422     self.old_context=self.contexte_fichier_init
 423     self.old_units=self.recorded_units
 424     self.old_etapes=self.etapes
 425     self.old_jdc_aux=self.jdc_aux
 426
 427     self.fichier_ini = new_fic
 428     self.fichier_text=text
 429
 430     try:
 431        self.makeContexteInclude(new_fic,text)
 432     except:
 433        l=traceback.format_exception_only(tr("Fichier invalide %s", sys.exc_info()[1]))
 434        self.fichier_err=''.join(l)
 435        raise EficasException(self.fichier_err)
 436
 437     # L'evaluation de text dans un JDC auxiliaire s'est bien passe
 438     # on peut poursuivre le traitement
 439     self.initModif()
 440     self.state="undetermined"
 441     self.fichier_err=None
 442     # On enregistre la modification de fichier
 443     self.recordUnite()
 444     # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 445     self.parent.resetContext()
 446
 447     # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
 448     self.old_contexte_fichier_init=self.old_context
 449     self.reevalueSdJdc()
 450
 451     self.finModif()
 452     if self.old_jdc_aux:
 453        self.old_jdc_aux.close()
 454
 455   def restoreFichierInit(self):
 456     """
 457        Restaure le fichier init enregistre dans old_xxx
 458     """
 459     self.fichier_ini=self.old_fic
 460     self.fichier_text=self.old_text
 461     self.fichier_err=self.old_err
 462     self.contexte_fichier_init=self.old_context
 463     self.recorded_units=self.old_units
 464     self.etapes=self.old_etapes
 465     self.jdc_aux=self.old_jdc_aux
 466
 467   def forceFichierInit(self):
 468     """
 469        Force le remplacement du fichier init meme si le remplacant est en erreur
 470     """
 471     # Reinitialisation complete du compte-rendu d'erreurs
 472     self.jdc_aux.cr=self.jdc_aux.CR()
 473     # On remplit le dictionnaire des concepts produits inclus
 474     # en retirant les concepts presents dans le  contexte initial
 475     # On ajoute egalement le concept produit dans le sds_dict du parent
 476     # sans verification car on est sur (verification integree) que
 477     # le nommage est possible
 478     j_context=self.jdc_aux.getContexteAvant(None)
 479     self.g_context.clear()
 480     context_ini=self.jdc_aux.context_ini
 481     for k,v in j_context.items():
 482        if not k in context_ini or context_ini[k] != v:
 483            self.g_context[k]=v
 484            self.parent.sds_dict[k]=v
 485     # On recupere le contexte courant
 486     self.current_context=self.jdc_aux.current_context
 487     self.index_etape_courante=self.jdc_aux.index_etape_courante
 488     self.contexte_fichier_init = j_context
 489     self.fichier_err = None
 490
 491     # On enregistre la modification de fichier
 492     self.initModif()
 493     self.state="undetermined"
 494     self.recordUnite()
 495     # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 496     self.parent.resetContext()
 497
 498     # On remplace les anciens concepts par les nouveaux (y compris ajouts
 499     # et suppression) et on propage les modifications aux etapes precedentes et suivantes
 500     # reevalueSdJdc construit la liste des differences entre les contextes contexte_fichier_init
 501     # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
 502     # necessaires
 503     self.old_contexte_fichier_init=self.old_context
 504     self.reevalueSdJdc()
 505     self.finModif()
 506     if self.old_jdc_aux:
 507        self.old_jdc_aux.close()
 508
 509     self.jdc_aux.forceContexte(self.g_context)
 510
 511   def buildInclude(self,fichier,text):
 512     import Extensions.jdc_include
 513     self.JdC_aux=Extensions.jdc_include.JdC_include
 514     # un include partage la table des unites avec son parent (jdc)
 515     self.recorded_units=self.parent.recorded_units
 516     self.buildJdcaux(fichier,text)
 517
 518   def buildPoursuite(self,fichier,text):
 519     import Extensions.jdc_include
 520     self.JdC_aux=Extensions.jdc_include.JdC_poursuite
 521     # une poursuite a sa propre table d'unites
 522     self.recorded_units={}
 523     self.buildJdcaux(fichier,text)
 524
 525
 526   def buildIncludeInclude(self,text):
 527     import Extensions.jdc_include
 528     self.JdC_aux=Extensions.jdc_include.JdC_include
 529     # un include partage la table des unites avec son parent (jdc)
 530
 531
 532   def buildIncludeEtape(self,text,doitEtreValide = 0):
 533     import Extensions.jdc_include
 534     self.JdC_aux=Extensions.jdc_include.JdC_include
 535     # un include partage la table des unites avec son parent (jdc)
 536     #self.buildJdcauxInclude(text)
 537     # Attention fonctionne pour import_Zone de MT
 538     # a adapter eventuellement
 539     try :
 540     #if 1 :
 541        contexte = self.getContexteJdc(None,text,doitEtreValide)
 542     except EficasException:
 543        return 0
 544
 545     for e in self.etapes:
 546         e.niveau=self.niveau
 547         e.parent=self.parent
 548         e.state='change'
 549
 550     index=self.jdc.etapes.index(self)
 551     self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
 552
 553     self.g_context={}
 554     self.etapes=[]
 555     self.jdc.resetContext()
 556     self.jdc_aux=None
 557     CONTEXT.unsetCurrentStep()
 558     return 1
 559
 560
 561   def buildJdcauxInclude(self,text):
 562
 563        try :
 564          contexte = self.getContexteJdc(None,text)
 565        except EficasException:
 566          pass
 567        index=self.jdc.etapes.index(self)
 568        for e in self.etapes:
 569            e.niveau=self.niveau
 570        self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
 571        self.g_context={}
 572        self.etapes=[]
 573        self.jdc_aux=None
 574        CONTEXT.unsetCurrentStep()
 575
 576   def buildJdcaux(self,fichier,text):
 577     """
 578          Cree un jdc auxiliaire initialise avec text.
 579          Initialise le nom du fichier associe avec fichier
 580          N'enregistre pas d'association unite <-> fichier
 581     """
 582     self.fichier_ini = fichier
 583     self.fichier_text= text
 584     self.fichier_unite=None
 585     self.fichier_err = None
 586     try:
 587        contexte = self.getContexteJdc(fichier,text)
 588        if contexte is None :
 589           # Impossible de construire le jdc auxiliaire (sortie par None)
 590           # On simule une sortie par exception
 591           raise EficasException(tr("Impossible de construire le jeu de commandes correspondant au fichier"))
 592        else:
 593           # La construction du jdc auxiliaire est allee au bout
 594           self.contexte_fichier_init = contexte
 595        self.initModif()
 596        self.finModif()
 597     except:
 598        # Impossible de construire le jdc auxiliaire (sortie par exception)
 599        l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 600        if self.jdc.appli is not None:
 601           self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
 602                                        message= tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
 603
 604        self.g_context={}
 605        self.etapes=[]
 606        self.jdc_aux=None
 607        self.fichier_err = ''.join(l)
 608        self.contexte_fichier_init={}
 609        self.initModif()
 610        self.finModif()
 611        raise EficasException(" ")
 612
 613   def makeContexteInclude(self,fichier,text):
 614     """
 615         Cette methode sert a craer un contexte en interpratant un texte source Python.
 616     """
 617     #print ("makeContexteInclude",fichier)
 618     # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
 619     contexte = self.getContexteJdc(fichier,text)
 620     if contexte == None :
 621       raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
 622     else:
 623       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
 624       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
 625       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
 626       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
 627       # existants en debut de macro contenus dans context_ini (dans getContexteJdc)
 628       # g_context est utilise pour avoir les concepts produits par la macro
 629       # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
 630       self.contexte_fichier_init = contexte
 631     #print ("fin makeContexteInclude",fichier)
 632
 633   def reevalueFichierInitObsolete(self):
 634       """Recalcule les concepts produits par le fichier enregistre"""
 635       #print "reevalue_fichier_init"
 636       old_context=self.contexte_fichier_init
 637       try:
 638          self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 639       except:
 640          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 641          self.fichier_err = ''.join(l)
 642          self.g_context={}
 643          self.etapes=[]
 644          self.jdc_aux=None
 645          self.old_contexte_fichier_init=old_context
 646          self.contexte_fichier_init={}
 647          self.reevalueSdJdc()
 648          return
 649
 650       # L'evaluation s'est bien passee
 651       self.fichier_err = None
 652       self.old_contexte_fichier_init=old_context
 653       self.reevalueSdJdc()
 654
 655   def updateFichierInit(self,unite):
 656       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
 657          les noms des fichiers
 658          Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
 659          L'include a ete initialise precedemment. Le jdc auxiliaire existe.
 660       """
 661       #print "updateFichierInit",unite,self.fichier_unite
 662       self.old_contexte_fichier_init=self.contexte_fichier_init
 663       old_fichier_ini=self.fichier_ini
 664       if not hasattr(self,"jdc_aux"):self.jdc_aux=None
 665       old_jdc_aux=self.jdc_aux
 666
 667       #print "updateFichierInit",self,self.parent,self.parent.recorded_units
 668
 669       if self.fichier_unite is None:
 670          # L'unite n'etait pas definie precedemment. On ne change que l'unite
 671          #print "updateFichierInit","pas de changement dans include"
 672          self.fichier_unite=unite
 673          return
 674       elif unite == self.fichier_unite :
 675          # L'unite n'a pas change
 676          #print "updateFichierInit","pas de changement dans include 3"
 677          return
 678       elif unite != self.fichier_unite :
 679          # L'unite etait definie precedemment. On remplace l'include
 680          #
 681          f,text=self.getFileMemo(unite=unite,fic_origine=self.parent.nom)
 682          if f is None:
 683             # Le fichier associe n'a pas pu etre defini
 684             # on change l'unite associee mais pas l'include
 685             #print "updateFichierInit","pas de changement dans include 2"
 686             self.fichier_unite=unite
 687             return
 688          else:
 689             self.fichier_ini = f
 690             self.fichier_text=text
 691             self.fichier_unite=unite
 692          #print "updateFichierInit",self.recorded_units
 693
 694       #print "updateFichierInit",self.fichier_ini,self.fichier_text,self.fichier_unite
 695
 696       if old_fichier_ini == self.fichier_ini:
 697          # Le fichier inclus n'a pas change. On ne recree pas le contexte
 698          # mais on enregistre le changement d'association unite <-> fichier
 699          #print "updateFichierInit.fichier inchange",self.jdc_aux.context_ini
 700          self.parent.recordUnit(unite,self)
 701          return
 702
 703       try:
 704         self.fichier_err=None
 705         self.makeContexteInclude(self.fichier_ini,self.fichier_text)
 706         # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
 707         # avant d'appeler changeUnit
 708       except:
 709         # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
 710         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 711         # On conserve la memoire du nouveau fichier
 712         # mais on n'utilise pas les concepts crees par ce fichier
 713         # on met l'etape en erreur : fichier_err=''.join(l)
 714         self.fichier_err=''.join(l)
 715         self.g_context={}
 716         self.etapes=[]
 717         self.jdc_aux=None
 718         self.contexte_fichier_init={}
 719
 720       if old_jdc_aux:
 721          old_jdc_aux.close()
 722       self.parent.recordUnit(unite,self)
 723       # Le contexte du parent doit etre reinitialise car les concepts
 724       # produits ont change
 725       self.parent.resetContext()
 726       # Si des concepts ont disparu lors du changement de fichier, on
 727       # demande leur suppression
 728       self.reevalueSdJdc()
 729       #print "updateFichierInit",self.jdc_aux.context_ini.keys()
 730
 731   def recordUnite(self):
 732       #print "recordUnite",self.nom
 733       if self.nom == "POURSUITE":
 734          self.parent.recordUnit(None,self)
 735       else:
 736          if hasattr(self,'fichier_unite') :
 737             self.parent.recordUnit(self.fichier_unite,self)
 738
 739   def getFileMemo(self, unite=None, fname=None, fic_origine=''):
 740       """Retourne le nom du fichier et le source correspondant a l'unite unite
 741          Initialise en plus recorded_units
 742       """
 743       #print "getFileMemo",unite,fic_origine,self,self.parent
 744       #print self.parent.recorded_units
 745       if unite is None:
 746          # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
 747          units={}
 748       else:
 749          # On est dans le cas d'un include. On reutilise toutes les unites de parent
 750          units=self.parent.recorded_units
 751
 752       if unite in self.parent.recorded_units:
 753          f,text,units=self.parent.recorded_units[unite]
 754       elif self.jdc :
 755          if fname:
 756              if not osp.exists(fname):
 757                 raise AsException(fname + tr(" n'est pas un fichier existant"))
 758              f = fname
 759              text = open(fname, 'r').read()
 760          else:
 761              f,text=self.jdc.getFile(unite=unite, fic_origine=fic_origine)
 762       else:
 763          f,text=None,None
 764
 765       self.recorded_units=units
 766       if f is None and self.jdc.appli:
 767          self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
 768                message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
 769       return f,text
 770
 771   def updateContext(self,d):
 772       """
 773          Met a jour le contexte contenu dans le dictionnaire d
 774          Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
 775          Une fonction enregistree dans op_init peut egalement modifier le contexte
 776       """
 777       #print ("updateContext",self,self.nom,d.keys())
 778       if hasattr(self,"jdc_aux") and self.jdc_aux:
 779             #ATTENTION: updateContext NE DOIT PAS appeler resetContext
 780             # car il appelle directement ou indirectement updateContext
 781             # equivalent a resetContext. Evite les recursions
 782             self.jdc_aux.context_ini=d.copy()
 783             self.jdc_aux.current_context={}
 784             self.jdc_aux.index_etape_courante=0
 785             #ATTENTION: il ne faut pas utiliser self.jdc_aux.getContexteAvant
 786             #car cet appel conduit a des remontees multiples incoherentes dans le
 787             # ou les parents.
 788             #get_context_avant appelle updateContext qui NE DOIT PAS appeler getContexteAvant
 789             #On n'a besoin que d'un update local connaissant
 790             # le contexte amont : d qui sert a reinitialiser self.context_ini
 791             for e in self.etapes:
 792                 e.updateContext(d)
 793             return
 794
 795       if type(self.definition.op_init) == types.FunctionType:
 796         self.definition.op_init(*(self,d))
 797       if self.sd != None :d[self.sd.nom]=self.sd
 798       for co in self.sdprods:
 799         d[co.nom]=co
 800       #print "updateContext.fin",d.keys()
 801
 802 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 803   def copy(self):
 804       etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
 805       if hasattr(etape,"etapes") :etape.etapes=[]
 806       if hasattr(etape,"jdc_aux") :
 807          etape.jdc_aux=None
 808          del etape.fichier_ini
 809       return etape
 810
 811   def supprime(self):
 812       #print "supprime",self
 813       if hasattr(self,"jdc_aux") and self.jdc_aux:
 814          self.jdc_aux.supprime_aux()
 815          self.jdc_aux=None
 816       Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
 817
 818 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 819   def getFile(self,unite=None,fic_origine=''):
 820       """Retourne le nom du fichier et le source correspondant a l'unite unite
 821       """
 822       if self.jdc :
 823          f,text=self.jdc.getFile(unite=unite,fic_origine=fic_origine)
 824       else:
 825          f,text=None,None
 826       return f,text
 827
 828
 829   def makeInclude3(self,fichier=None):
 830       self.makeIncludeCarmel(fichier)
 831
 832
 833   def makeIncludeCND(self,fichier=None):
 834       unite=999
 835       if fichier==None : return
 836       if hasattr(self,'fichier_ini') : print((self.fichier_ini))
 837       if hasattr(self,'fichier_ini') : return
 838       self.fichier_ini=fichier
 839       from acquiertGroupes import getGroupes
 840       erreur,listeGroupes=getGroupes(fichier)
 841       if erreur != "" : print ("a traiter")
 842       texteSources=""
 843       texteCond=""
 844       texteNoCond=""
 845       texteVcut=""
 846       for groupe in listeGroupes :
 847           if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
 848           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
 849           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
 850           #if groupe[0:5]=='VCUT_':    texteVcut    +=groupe[5:]+"=VCUT();\n"
 851           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
 852       texte=texteSources+texteCond+texteNoCond+texteVcut
 853       #print (texte)
 854       self.buildIncludeInclude(texte)
 855       if CONTEXT.getCurrentStep()==None : CONTEXT.setCurrentStep(self)
 856       reevalue=0
 857
 858   def makeIncludeCarmel(self,fichier=None):
 859   # Pour Carmel
 860       #print "je suis dans makeIncludeCarmel"
 861       unite=999
 862       if hasattr(self,'fichier_ini') : return
 863       reevalue=0
 864       if hasattr(self,'old_context_fichier_init' ):
 865          reevalue=1
 866          for concept in self.old_context_fichier_init.values():
 867              self.jdc.deleteConcept(concept)
 868       if fichier == None :
 869          fichier=str(self.jdc.appli.getFile_dictDonnees())
 870          if fichier  == str("") :
 871            self.fichier_ini="badfile"
 872            self.fichier_text=""
 873            self.fichier_err=tr("Le fichier n est pas defini")
 874            self.parent.recordUnit(999,self)
 875            try :
 876               MCFils=self.getChild('FileName')
 877               MCFils.setValeur(None)
 878            except :
 879               pass
 880            raise EficasException(self.fichier_err)
 881       self.fichier_ini  = fichier
 882       f=open(self.fichier_ini,'r')
 883       self.fichier_text=f.read()
 884       f.close()
 885
 886       self.contexte_fichier_init={}
 887       self.fichier_unite=999
 888       self.fichier_err=None
 889
 890       try:
 891       #if 1 :
 892          import Extensions.jdc_include
 893          self.JdC_aux=Extensions.jdc_include.JdC_include
 894       except:
 895       #else:
 896          traceback.print_exc()
 897          self.makeIncl2Except()
 898          raise EficasException(" ")
 899
 900       try:
 901       #if 1 :
 902          self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 903          self.old_context_fichier_init=self.contexte_fichier_init
 904          self.parent.recordUnit(unite,self)
 905          try :
 906             MCFils=self.getChild('FileName')
 907             #MCFils.setValeur(fichier)
 908             #on appelle pas setValeur qui modifie le contexte ce qui fout le bazar
 909             #pas de modification de bloc
 910             MCFils.valeur=fichier
 911             MCFils.val=fichier
 912          except :
 913             pass
 914       except:
 915       #else:
 916          self.makeIncl2Except()
 917       # Cette P*** de ligne suivante ne fonctionne que pour Aster
 918       # si quelqu un a une idee merci de m en parler
 919       #CONTEXT.setCurrentStep(self)
 920
 921   def makeInclude2(self,fichier=None):
 922   # Pour OT
 923       # gestion de l unicite SVP
 924       unite=999
 925
 926       if hasattr(self,'fichier_ini') : return
 927       reevalue=0
 928       if hasattr(self,'old_context_fichier_init' ):
 929          reevalue=1
 930          for concept in self.old_context_fichier_init.values():
 931              self.jdc.deleteConcept(concept)
 932
 933       if fichier == None :
 934          fichier=str(self.jdc.appli.getFileVariable())
 935          if fichier  == str("") :
 936            self.fichier_ini="badfile"
 937            self.fichier_text=""
 938            self.fichier_err=tr("Le fichier n est pas defini")
 939            self.parent.recordUnit(999,self)
 940            try :
 941               MCFils=self.getChild('FileName')
 942               MCFils.setValeur(None)
 943            except :
 944               pass
 945            raise EficasException(self.fichier_err)
 946
 947       self.fichier_ini  = fichier
 948       self.fichier_text = ""
 949       self.contexte_fichier_init={}
 950       self.fichier_unite=999
 951       self.fichier_err=None
 952       nbVariableOut=0
 953       try :
 954          from openturns import WrapperFile
 955          monWrapper=WrapperFile(fichier)
 956          data=monWrapper.getWrapperData()
 957          maVariableListe=data.getVariableList()
 958          nbVariables=maVariableListe.getSize()
 959          for i in range(nbVariables) :
 960              nom=maVariableListe[i].id_
 961              type=maVariableListe[i].type_
 962              if type :
 963                #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
 964                ligneTexte=""
 965                nbVariableOut=nbVariableOut+1
 966              else :
 967                ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
 968              self.fichier_text = self.fichier_text + ligneTexte
 969       except:
 970          self.makeIncl2Except()
 971          raise EficasException(" ")
 972
 973       if nbVariableOut != 1 :
 974          print((nbVariableOut ,"nbVariableOut"))
 975          self.makeIncl2Except(mess=tr("le fichier doit contenir une unique variable de sortie"))
 976          raise EficasException(" ")
 977
 978       try:
 979          import Extensions.jdc_include
 980          self.JdC_aux=Extensions.jdc_include.JdC_include
 981       except:
 982          traceback.print_exc()
 983          self.makeIncl2Except()
 984          raise EficasException(" ")
 985
 986       try:
 987          print((self.fichier_ini ,self.fichier_text))
 988          self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
 989          self.old_context_fichier_init=self.contexte_fichier_init
 990          self.parent.recordUnit(unite,self)
 991          try :
 992             MCFils=self.getChild('FileName')
 993             MCFils.setValeur(fichier)
 994          except :
 995             pass
 996       except:
 997          self.makeIncl2Except()
 998
 999       # recalcul validite pour la matrice eventuelle
1000       if reevalue :
1001          for e in self.jdc.etapes:
1002            if e.nom == "VARIABLE" :
1003               e.state="modified"
1004               try :
1005                  mc=e.getChild('ModelVariable')
1006                  mc.state="modified"
1007               except :
1008                  pass
1009            if e.nom == "CORRELATION" :
1010               e.state="modified"
1011               try :
1012                  mc=e.getChild('Matrix')
1013                  mc.state="modified"
1014                  mcFeuille=mc.getChild('CorrelationMatrix')
1015                  mcFeuille.state="modified"
1016               except :
1017                  pass
1018               e.isValid()
1019
1020   def makeIncl2Except(self,mess=None):
1021          l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
1022          if self.jdc.appli is not None:
1023              if mess == None :
1024                      self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1025                      message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
1026                                                                    ''.join(l)))
1027
1028              else :
1029                      self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1030                                             message=tr(mess))
1031          #self.parent.recordUnit(unite,self)
1032          self.g_context={}
1033          self.etapes=[]
1034          self.jdc_aux=None
1035          self.fichier_err = ''.join(l)
1036          self.contexte_fichier_init={}
1037          try :
1038             MCFils=self.getChild('FileName')
1039             MCFils.setValeur(None)
1040          except :
1041             pass
1042
1043
1044 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1045   def makeInclude(self, unite=None, fname=None):
1046       """
1047           Inclut un fichier dont l'unite logique est unite
1048           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1049           Si l'INCLUDE est invalide, la methode doit produire une exception
1050           Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1051           pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1052       """
1053       #print "makeInclude",unite
1054       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1055       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1056       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1057       if not unite and not fname:
1058           return
1059
1060       if not hasattr(self,'fichier_ini') :
1061          # Si le fichier n'est pas defini on le demande
1062          f,text=self.getFileMemo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1063          # On memorise le fichier retourne
1064          self.fichier_ini  = f
1065          self.fichier_text = text
1066          self.contexte_fichier_init={}
1067          self.fichier_unite=unite
1068          self.fichier_err=None
1069          try:
1070            import Extensions.jdc_include
1071          except:
1072            traceback.print_exc()
1073            raise EficasException("pb import Extensions")
1074          self.JdC_aux=Extensions.jdc_include.JdC_include
1075
1076          #print "makeInclude",self.fichier_ini,self.fichier_text
1077          if f is None and not text:
1078              self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1079              self.parent.recordUnit(unite,self)
1080              raise EficasException(self.fichier_err)
1081
1082          try:
1083            self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
1084            self.parent.recordUnit(unite,self)
1085          except:
1086            l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1087            if self.jdc.appli:
1088               self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1089                                             message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
1090            self.parent.recordUnit(unite,self)
1091            self.g_context={}
1092            self.etapes=[]
1093            self.jdc_aux=None
1094            self.fichier_err = ''.join(l)
1095            self.contexte_fichier_init={}
1096            raise EficasException(" ")
1097
1098       else:
1099          # Si le fichier est deja defini on ne reevalue pas le fichier
1100          # et on leve une exception si une erreur a ete enregistree
1101          self.updateFichierInit(unite)
1102          self.fichier_unite=unite
1103          if self.fichier_err is not None: raise EficasException(self.fichier_err)
1104
1105
1106 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1107   def makeContexte(self,fichier,text):
1108     """
1109         Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1110         en interpretant un texte source Python
1111         Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1112     """
1113     #print "makeContexte",fichier
1114     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1115     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1116     if hasattr(self,'mat'):del self.mat
1117     if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1118        # le fichier est nouveau ou change
1119        self.fichier_ini =fichier
1120        self.fichier_unite =fichier
1121        self.fichier_mater=self.nom_mater
1122        self.fichier_text=text
1123        self.fichier_err=None
1124        self.contexte_fichier_init={}
1125        # On specifie la classe a utiliser pour le JDC auxiliaire
1126        try:
1127          import Extensions.jdc_include
1128          self.JdC_aux=Extensions.jdc_include.JdC_include
1129        except:
1130          raise EficasException(" ")
1131        try:
1132           self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
1133           if not self.nom_mater in self.g_context :
1134              #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1135              self.g_context[self.nom_mater]=None
1136              if self.parent: self.parent.g_context[self.nom_mater]=None
1137        except:
1138           l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1139           self.fichier_err = ''.join(l)
1140           self.g_context={}
1141           #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1142           if self.parent:
1143               self.parent.g_context[self.nom_mater]=None
1144           self.g_context[self.nom_mater]=None
1145           #-------------
1146           self.etapes=[]
1147           self.jdc_aux=None
1148           self.contexte_fichier_init={}
1149           raise EficasException(" ")
1150     else:
1151        # le fichier est le meme on ne le reevalue pas
1152        # et on leve une exception si une erreur a ete enregistree
1153        if self.fichier_err is not None: raise EficasException(self.fichier_err)
1154
1155 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1156   def updateSdprod(self,cr='non'):
1157      # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1158      # la commande modifies. Ceci peut conduire a la construction ou
1159      # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1160      # Il faut donc positionner le current_step avant l'appel
1161      CONTEXT.unsetCurrentStep()
1162      CONTEXT.setCurrentStep(self)
1163      valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.updateSdprod(self,cr=cr)
1164      CONTEXT.unsetCurrentStep()
1165      return valid
1166
1167 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1168   def buildSd(self,nom):
1169       """
1170            Methode de Noyau surchargee pour poursuivre malgre tout
1171            si une erreur se produit pendant la creation du concept produit
1172       """
1173       try:
1174          sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.buildSd(self,nom)
1175       except :
1176       #   return None
1177       #except AsException,e:
1178          # Une erreur s'est produite lors de la construction du concept
1179          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1180          # Si on poursuit, on a le choix entre deux possibilites :
1181          # 1. on annule la sd associee a self
1182          # 2. on la conserve mais il faut la retourner
1183          # On choisit de l'annuler
1184          # En plus il faut rendre coherents sdnom et sd.nom
1185          self.sd=None
1186          self.sdnom=None
1187          self.state="unchanged"
1188          self.valid=0
1189
1190       return self.sd
1191
1192 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1193   def makePoursuite(self):
1194       """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1195       """
1196       #print "makePoursuite"
1197       if not hasattr(self,'fichier_ini') :
1198          # Si le fichier n'est pas defini on le demande
1199          f,text=self.getFileMemo(fic_origine=self.parent.nom)
1200          # On memorise le fichier retourne
1201          self.fichier_ini = f
1202          self.fichier_unite = None
1203          self.fichier_text = text
1204          self.fichier_err=None
1205          try:
1206            import Extensions.jdc_include
1207          except:
1208            traceback.print_exc()
1209            raise EficasException(" ")
1210          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1211          self.contexte_fichier_init={}
1212          #print "makePoursuite",self.fichier_ini,self.fichier_text
1213
1214          if f is None:
1215              self.fichier_err="Le fichier POURSUITE n'est pas defini"
1216              self.jdc_aux=None
1217              self.parent.recordUnit(None,self)
1218              raise EficasException(self.fichier_err)
1219
1220          try:
1221            self.makeContexteInclude(self.fichier_ini,self.fichier_text)
1222            self.parent.recordUnit(None,self)
1223          except:
1224            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1225            if self.jdc.appli:
1226               self.jdc.appli.afficheAlerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1227                                             message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
1228            self.parent.recordUnit(None,self)
1229            self.g_context={}
1230            self.etapes=[]
1231            self.jdc_aux=None
1232            self.fichier_err = ''.join(l)
1233            self.contexte_fichier_init={}
1234            raise EficasException(" ")
1235
1236       else:
1237          # Si le fichier est deja defini on ne reevalue pas le fichier
1238          # et on leve une exception si une erreur a ete enregistree
1239          self.updateFichierInit(None)
1240          if self.fichier_err is not None: raise EficasException(self.fichier_err)