Ihm/I_MACRO_ETAPE.py

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