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     # 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.unset_current_step()
 234     CONTEXT.set_current_step(step)
 235
 236     return j_context
 237
 238   def reevalue_sd_jdc(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 "reevalue_sd_jdc"
 244      l_sd_supp,l_sd_repl = self.diff_contextes()
 245      for sd in l_sd_supp:
 246         self.parent.delete_concept_after_etape(self,sd)
 247      for old_sd,sd in l_sd_repl:
 248         self.parent.replace_concept_after_etape(self,old_sd,sd)
 249
 250   def diff_contextes(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 control_sdprods(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 control_jdc_context_apres de I_JDC)
 282       """
 283       #print ("I_MACRO_ETAPE.control_sdprods",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.init_modif()
 295               sd=self.sd
 296               self.sd=self.reuse=self.sdnom=None
 297               self.parent.delete_concept_after_etape(self,sd)
 298               self.fin_modif()
 299
 300       # On verifie les concepts a droite du signe =
 301       self.init_modif()
 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.delete_concept(co)
 308            #supprime les references a co dans les etapes suivantes
 309            self.parent.delete_concept_after_etape(self,co)
 310         else:
 311            self.sdprods.append(co)
 312       self.fin_modif()
 313
 314       for e in self.etapes:
 315           e.control_sdprods(d)
 316           e.update_context(d)
 317
 318   def supprime_sdprod(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.init_modif()
 324          self.parent.del_sdprod(sd)
 325          self.sdprods.remove(sd)
 326          self.fin_modif()
 327          self.parent.delete_concept(sd)
 328          return
 329
 330       if sd is not self.sd :return
 331       if self.sd is not None :
 332          self.init_modif()
 333          self.parent.del_sdprod(sd)
 334          self.sd=None
 335          self.fin_modif()
 336          self.parent.delete_concept(sd)
 337
 338   def supprime_sdprods(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 "supprime_sdprods"
 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.del_sdprod(self.sd)
 352             self.parent.delete_concept(self.sd)
 353       # On detruit les concepts a droite du signe =
 354       for co in self.sdprods:
 355          self.parent.del_sdprod(co)
 356          self.parent.delete_concept(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.del_sdprod(co)
 361          self.parent.delete_concept(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 reset_context(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.reset_context()
 375
 376   def update_concept(self,sd):
 377       I_ETAPE.ETAPE.update_concept(self,sd)
 378       for etape in self.etapes:
 379           etape.update_concept(sd)
 380
 381   def delete_concept(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 "delete_concept",sd
 389       I_ETAPE.ETAPE.delete_concept(self,sd)
 390       for etape in self.etapes:
 391          etape.delete_concept(sd)
 392
 393   def replace_concept(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 "replace_concept",old_sd,sd
 399       I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
 400       for etape in self.etapes:
 401          etape.replace_concept(old_sd,sd)
 402
 403   def change_fichier_init(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.make_contexte_include(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.init_modif()
 440     self.state="undetermined"
 441     self.fichier_err=None
 442     # On enregistre la modification de fichier
 443     self.record_unite()
 444     # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 445     self.parent.reset_context()
 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.reevalue_sd_jdc()
 450
 451     self.fin_modif()
 452     if self.old_jdc_aux:
 453        self.old_jdc_aux.close()
 454
 455   def restore_fichier_init(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 force_fichier_init(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.get_contexte_avant(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.init_modif()
 493     self.state="undetermined"
 494     self.record_unite()
 495     # Le contexte du parent doit etre reinitialise car les concepts produits ont change
 496     self.parent.reset_context()
 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     # reevalue_sd_jdc 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.reevalue_sd_jdc()
 505     self.fin_modif()
 506     if self.old_jdc_aux:
 507        self.old_jdc_aux.close()
 508
 509     self.jdc_aux.force_contexte(self.g_context)
 510
 511   def build_include(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.build_jdcaux(fichier,text)
 517
 518   def build_poursuite(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.build_jdcaux(fichier,text)
 524
 525
 526   def build_includeInclude(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     self.build_jdcauxInclude(text)
 531
 532
 533
 534   def build_includeEtape(self,text):
 535     import Extensions.jdc_include
 536     self.JdC_aux=Extensions.jdc_include.JdC_include
 537     # un include partage la table des unites avec son parent (jdc)
 538     #self.build_jdcauxInclude(text)
 539     # Attention fonctionne pour import_Zone de MT
 540     # a adapter eventuellement
 541     try :
 542        contexte = self.get_contexte_jdc(None,text)
 543     except EficasException:
 544        return 0
 545
 546     for e in self.etapes:
 547         e.niveau=self.niveau
 548         e.parent=self.parent
 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.reset_context()
 556     self.jdc_aux=None
 557     CONTEXT.unset_current_step()
 558     return 1
 559
 560
 561   def build_jdcauxInclude(self,text):
 562
 563        try :
 564          contexte = self.get_contexte_jdc(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.unset_current_step()
 575
 576   def build_jdcaux(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.get_contexte_jdc(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.init_modif()
 596        self.fin_modif()
 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.affiche_alerte(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.init_modif()
 610        self.fin_modif()
 611        raise EficasException(" ")
 612
 613   def make_contexte_include(self,fichier,text):
 614     """
 615         Cette methode sert a craer un contexte en interpratant un texte source Python.
 616     """
 617     print ("make_contexte_include",fichier)
 618     # on recupere le contexte d'un nouveau jdc dans lequel on interprete text
 619     contexte = self.get_contexte_jdc(fichier,text)
 620     print ("make_contexte_include",fichier)
 621     if contexte == None :
 622       raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
 623     else:
 624       # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
 625       # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
 626       # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
 627       # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
 628       # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
 629       # g_context est utilise pour avoir les concepts produits par la macro
 630       # contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
 631       self.contexte_fichier_init = contexte
 632     print ("fin make_contexte_include",fichier)
 633
 634   def reevalue_fichier_init_OBSOLETE(self):
 635       """Recalcule les concepts produits par le fichier enregistre"""
 636       #print "reevalue_fichier_init"
 637       old_context=self.contexte_fichier_init
 638       try:
 639          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 640       except:
 641          l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 642          self.fichier_err = ''.join(l)
 643          self.g_context={}
 644          self.etapes=[]
 645          self.jdc_aux=None
 646          self.old_contexte_fichier_init=old_context
 647          self.contexte_fichier_init={}
 648          self.reevalue_sd_jdc()
 649          return
 650
 651       # L'evaluation s'est bien passee
 652       self.fichier_err = None
 653       self.old_contexte_fichier_init=old_context
 654       self.reevalue_sd_jdc()
 655
 656   def update_fichier_init(self,unite):
 657       """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
 658          les noms des fichiers
 659          Ceci suppose que les relations entre unites et noms ont ete memorisees prealablement
 660          L'include a ete initialise precedemment. Le jdc auxiliaire existe.
 661       """
 662       #print "update_fichier_init",unite,self.fichier_unite
 663       self.old_contexte_fichier_init=self.contexte_fichier_init
 664       old_fichier_ini=self.fichier_ini
 665       if not hasattr(self,"jdc_aux"):self.jdc_aux=None
 666       old_jdc_aux=self.jdc_aux
 667
 668       #print "update_fichier_init",self,self.parent,self.parent.recorded_units
 669
 670       if self.fichier_unite is None:
 671          # L'unite n'etait pas definie precedemment. On ne change que l'unite
 672          #print "update_fichier_init","pas de changement dans include"
 673          self.fichier_unite=unite
 674          return
 675       elif unite == self.fichier_unite :
 676          # L'unite n'a pas change
 677          #print "update_fichier_init","pas de changement dans include 3"
 678          return
 679       elif unite != self.fichier_unite :
 680          # L'unite etait definie precedemment. On remplace l'include
 681          #
 682          f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
 683          if f is None:
 684             # Le fichier associe n'a pas pu etre defini
 685             # on change l'unite associee mais pas l'include
 686             #print "update_fichier_init","pas de changement dans include 2"
 687             self.fichier_unite=unite
 688             return
 689          else:
 690             self.fichier_ini = f
 691             self.fichier_text=text
 692             self.fichier_unite=unite
 693          #print "update_fichier_init",self.recorded_units
 694
 695       #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
 696
 697       if old_fichier_ini == self.fichier_ini:
 698          # Le fichier inclus n'a pas change. On ne recree pas le contexte
 699          # mais on enregistre le changement d'association unite <-> fichier
 700          #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
 701          self.parent.record_unit(unite,self)
 702          return
 703
 704       try:
 705         self.fichier_err=None
 706         self.make_contexte_include(self.fichier_ini,self.fichier_text)
 707         # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
 708         # avant d'appeler change_unit
 709       except:
 710         # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
 711         l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
 712         # On conserve la memoire du nouveau fichier
 713         # mais on n'utilise pas les concepts crees par ce fichier
 714         # on met l'etape en erreur : fichier_err=''.join(l)
 715         self.fichier_err=''.join(l)
 716         self.g_context={}
 717         self.etapes=[]
 718         self.jdc_aux=None
 719         self.contexte_fichier_init={}
 720
 721       if old_jdc_aux:
 722          old_jdc_aux.close()
 723       self.parent.record_unit(unite,self)
 724       # Le contexte du parent doit etre reinitialise car les concepts
 725       # produits ont change
 726       self.parent.reset_context()
 727       # Si des concepts ont disparu lors du changement de fichier, on
 728       # demande leur suppression
 729       self.reevalue_sd_jdc()
 730       #print "update_fichier_init",self.jdc_aux.context_ini.keys()
 731
 732   def record_unite(self):
 733       #print "record_unite",self.nom
 734       if self.nom == "POURSUITE":
 735          self.parent.record_unit(None,self)
 736       else:
 737          if hasattr(self,'fichier_unite') :
 738             self.parent.record_unit(self.fichier_unite,self)
 739
 740   def get_file_memo(self, unite=None, fname=None, fic_origine=''):
 741       """Retourne le nom du fichier et le source correspondant a l'unite unite
 742          Initialise en plus recorded_units
 743       """
 744       #print "get_file_memo",unite,fic_origine,self,self.parent
 745       #print self.parent.recorded_units
 746       if unite is None:
 747          # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
 748          units={}
 749       else:
 750          # On est dans le cas d'un include. On reutilise toutes les unites de parent
 751          units=self.parent.recorded_units
 752
 753       if unite in self.parent.recorded_units:
 754          f,text,units=self.parent.recorded_units[unite]
 755       elif self.jdc :
 756          if fname:
 757              if not osp.exists(fname):
 758                 raise AsException(fname + tr(" n'est pas un fichier existant"))
 759              f = fname
 760              text = open(fname, 'r').read()
 761          else:
 762              f,text=self.jdc.get_file(unite=unite, fic_origine=fic_origine)
 763       else:
 764          f,text=None,None
 765
 766       self.recorded_units=units
 767       if f is None and self.jdc.appli:
 768          self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
 769                message= tr("Ce fichier ne sera pas pris en compte\nLe fichier associe n'est pas defini"))
 770       return f,text
 771
 772   def update_context(self,d):
 773       """
 774          Met a jour le contexte contenu dans le dictionnaire d
 775          Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
 776          Une fonction enregistree dans op_init peut egalement modifier le contexte
 777       """
 778       #print ("update_context",self,self.nom,d.keys())
 779       if hasattr(self,"jdc_aux") and self.jdc_aux:
 780             #ATTENTION: update_context NE DOIT PAS appeler reset_context
 781             # car il appelle directement ou indirectement update_context
 782             # equivalent a reset_context. Evite les recursions
 783             self.jdc_aux.context_ini=d.copy()
 784             self.jdc_aux.current_context={}
 785             self.jdc_aux.index_etape_courante=0
 786             #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
 787             #car cet appel conduit a des remontees multiples incoherentes dans le
 788             # ou les parents.
 789             #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
 790             #On n'a besoin que d'un update local connaissant
 791             # le contexte amont : d qui sert a reinitialiser self.context_ini
 792             for e in self.etapes:
 793                 e.update_context(d)
 794             return
 795
 796       if type(self.definition.op_init) == types.FunctionType:
 797         self.definition.op_init(*(self,d))
 798       if self.sd != None :d[self.sd.nom]=self.sd
 799       for co in self.sdprods:
 800         d[co.nom]=co
 801       #print "update_context.fin",d.keys()
 802
 803 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 804   def copy(self):
 805       etape=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.copy(self)
 806       if hasattr(etape,"etapes") :etape.etapes=[]
 807       if hasattr(etape,"jdc_aux") :
 808          etape.jdc_aux=None
 809          del etape.fichier_ini
 810       return etape
 811
 812   def supprime(self):
 813       #print "supprime",self
 814       if hasattr(self,"jdc_aux") and self.jdc_aux:
 815          self.jdc_aux.supprime_aux()
 816          self.jdc_aux=None
 817       Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
 818
 819 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
 820   def get_file(self,unite=None,fic_origine=''):
 821       """Retourne le nom du fichier et le source correspondant a l'unite unite
 822       """
 823       if self.jdc :
 824          f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
 825       else:
 826          f,text=None,None
 827       return f,text
 828
 829
 830   def make_include3(self,fichier=None):
 831       self.make_includeCarmel(fichier)
 832
 833
 834   def make_includeCND(self,fichier=None):
 835       unite=999
 836       if fichier==None : return
 837       if hasattr(self,'fichier_ini') : print((self.fichier_ini))
 838       if hasattr(self,'fichier_ini') : return
 839       self.fichier_ini=fichier
 840       from acquiertGroupes import getGroupes
 841       erreur,listeGroupes=getGroupes(fichier)
 842       if erreur != "" : print ("a traiter")
 843       texteSources=""
 844       texteCond=""
 845       texteNoCond=""
 846       texteVcut=""
 847       for groupe in listeGroupes :
 848           if groupe[0:8]=='CURRENT_': texteSources +=groupe[8:]+"=SOURCE();\n"
 849           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
 850           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
 851           #if groupe[0:5]=='VCUT_':    texteVcut    +=groupe[5:]+"=VCUT();\n"
 852           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
 853       texte=texteSources+texteCond+texteNoCond+texteVcut
 854       #print (texte)
 855       self.build_includeInclude(texte)
 856       if CONTEXT.get_current_step()==None : CONTEXT.set_current_step(self)
 857       reevalue=0
 858
 859   def make_includeCarmel(self,fichier=None):
 860   # Pour Carmel
 861       #print "je suis dans make_includeCarmel"
 862       unite=999
 863       if hasattr(self,'fichier_ini') : return
 864       reevalue=0
 865       if hasattr(self,'old_context_fichier_init' ):
 866          reevalue=1
 867          for concept in self.old_context_fichier_init.values():
 868              self.jdc.delete_concept(concept)
 869       if fichier == None :
 870          fichier=str(self.jdc.appli.get_file_dictDonnees())
 871          if fichier  == str("") :
 872            self.fichier_ini="badfile"
 873            self.fichier_text=""
 874            self.fichier_err=tr("Le fichier n est pas defini")
 875            self.parent.record_unit(999,self)
 876            try :
 877               MCFils=self.get_child('FileName')
 878               MCFils.set_valeur(None)
 879            except :
 880               pass
 881            raise EficasException(self.fichier_err)
 882       self.fichier_ini  = fichier
 883       f=open(self.fichier_ini,'r')
 884       self.fichier_text=f.read()
 885       f.close()
 886
 887       self.contexte_fichier_init={}
 888       self.fichier_unite=999
 889       self.fichier_err=None
 890
 891       try:
 892       #if 1 :
 893          import Extensions.jdc_include
 894          self.JdC_aux=Extensions.jdc_include.JdC_include
 895       except:
 896       #else:
 897          traceback.print_exc()
 898          self.make_incl2_except()
 899          raise EficasException(" ")
 900
 901       try:
 902       #if 1 :
 903          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 904          self.old_context_fichier_init=self.contexte_fichier_init
 905          self.parent.record_unit(unite,self)
 906          try :
 907             MCFils=self.get_child('FileName')
 908             #MCFils.set_valeur(fichier)
 909             #on appelle pas set_valeur qui modifie le contexte ce qui fout le bazar
 910             #pas de modification de bloc
 911             MCFils.valeur=fichier
 912             MCFils.val=fichier
 913          except :
 914             pass
 915       except:
 916       #else:
 917          self.make_incl2_except()
 918       # Cette P*** de ligne suivante ne fonctionne que pour Aster
 919       # si quelqu un a une idee merci de m en parler
 920       #CONTEXT.set_current_step(self)
 921
 922   def make_include2(self,fichier=None):
 923   # Pour OT
 924       # gestion de l unicite SVP
 925       unite=999
 926
 927       if hasattr(self,'fichier_ini') : return
 928       reevalue=0
 929       if hasattr(self,'old_context_fichier_init' ):
 930          reevalue=1
 931          for concept in self.old_context_fichier_init.values():
 932              self.jdc.delete_concept(concept)
 933
 934       if fichier == None :
 935          fichier=str(self.jdc.appli.get_file_variable())
 936          if fichier  == str("") :
 937            self.fichier_ini="badfile"
 938            self.fichier_text=""
 939            self.fichier_err=tr("Le fichier n est pas defini")
 940            self.parent.record_unit(999,self)
 941            try :
 942               MCFils=self.get_child('FileName')
 943               MCFils.set_valeur(None)
 944            except :
 945               pass
 946            raise EficasException(self.fichier_err)
 947
 948       self.fichier_ini  = fichier
 949       self.fichier_text = ""
 950       self.contexte_fichier_init={}
 951       self.fichier_unite=999
 952       self.fichier_err=None
 953       nbVariableOut=0
 954       try :
 955          from openturns import WrapperFile
 956          monWrapper=WrapperFile(fichier)
 957          data=monWrapper.getWrapperData()
 958          maVariableListe=data.getVariableList()
 959          nbVariables=maVariableListe.getSize()
 960          for i in range(nbVariables) :
 961              nom=maVariableListe[i].id_
 962              type=maVariableListe[i].type_
 963              if type :
 964                #ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
 965                ligneTexte=""
 966                nbVariableOut=nbVariableOut+1
 967              else :
 968                ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
 969              self.fichier_text = self.fichier_text + ligneTexte
 970       except:
 971          self.make_incl2_except()
 972          raise EficasException(" ")
 973
 974       if nbVariableOut != 1 :
 975          print((nbVariableOut ,"nbVariableOut"))
 976          self.make_incl2_except(mess=tr("le fichier doit contenir une unique variable de sortie"))
 977          raise EficasException(" ")
 978
 979       try:
 980          import Extensions.jdc_include
 981          self.JdC_aux=Extensions.jdc_include.JdC_include
 982       except:
 983          traceback.print_exc()
 984          self.make_incl2_except()
 985          raise EficasException(" ")
 986
 987       try:
 988          print((self.fichier_ini ,self.fichier_text))
 989          self.make_contexte_include(self.fichier_ini ,self.fichier_text)
 990          self.old_context_fichier_init=self.contexte_fichier_init
 991          self.parent.record_unit(unite,self)
 992          try :
 993             MCFils=self.get_child('FileName')
 994             MCFils.set_valeur(fichier)
 995          except :
 996             pass
 997       except:
 998          self.make_incl2_except()
 999
1000       # recalcul validite pour la matrice eventuelle
1001       if reevalue :
1002          for e in self.jdc.etapes:
1003            if e.nom == "VARIABLE" :
1004               e.state="modified"
1005               try :
1006                  mc=e.get_child('ModelVariable')
1007                  mc.state="modified"
1008               except :
1009                  pass
1010            if e.nom == "CORRELATION" :
1011               e.state="modified"
1012               try :
1013                  mc=e.get_child('Matrix')
1014                  mc.state="modified"
1015                  mcFeuille=mc.get_child('CorrelationMatrix')
1016                  mcFeuille.state="modified"
1017               except :
1018                  pass
1019               e.isvalid()
1020
1021   def make_incl2_except(self,mess=None):
1022          l=traceback.format_exception_only(tr("Fichier invalide"),sys.exc_info()[1])
1023          if self.jdc.appli is not None:
1024              if mess == None :
1025                      self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1026                      message= tr("Le contenu de ce fichier ne sera pas pris en compte\n %s",\
1027                                                                    ''.join(l)))
1028
1029              else :
1030                      self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1031                                             message=tr(mess))
1032          #self.parent.record_unit(unite,self)
1033          self.g_context={}
1034          self.etapes=[]
1035          self.jdc_aux=None
1036          self.fichier_err = ''.join(l)
1037          self.contexte_fichier_init={}
1038          try :
1039             MCFils=self.get_child('FileName')
1040             MCFils.set_valeur(None)
1041          except :
1042             pass
1043
1044
1045 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1046   def make_include(self, unite=None, fname=None):
1047       """
1048           Inclut un fichier dont l'unite logique est unite
1049           Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
1050           Si l'INCLUDE est invalide, la methode doit produire une exception
1051           Sinon on retourne None. Les concepts produits par l'INCLUDE sont
1052           pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
1053       """
1054       #print "make_include",unite
1055       # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
1056       # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1057       # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
1058       if not unite and not fname:
1059           return
1060
1061       if not hasattr(self,'fichier_ini') :
1062          # Si le fichier n'est pas defini on le demande
1063          f,text=self.get_file_memo(unite=unite, fname=fname, fic_origine=self.parent.nom)
1064          # On memorise le fichier retourne
1065          self.fichier_ini  = f
1066          self.fichier_text = text
1067          self.contexte_fichier_init={}
1068          self.fichier_unite=unite
1069          self.fichier_err=None
1070          try:
1071            import Extensions.jdc_include
1072          except:
1073            traceback.print_exc()
1074            raise EficasException("pb import Extensions")
1075          self.JdC_aux=Extensions.jdc_include.JdC_include
1076
1077          #print "make_include",self.fichier_ini,self.fichier_text
1078          if f is None and not text:
1079              self.fichier_err=tr("Le fichier INCLUDE n est pas defini")
1080              self.parent.record_unit(unite,self)
1081              raise EficasException(self.fichier_err)
1082
1083          try:
1084            self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1085            self.parent.record_unit(unite,self)
1086          except:
1087            l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1088            if self.jdc.appli:
1089               self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier inclus"),
1090                                             message=tr("Le contenu de ce fichier ne sera pas pris en compte\n"+''.join(l)))
1091            self.parent.record_unit(unite,self)
1092            self.g_context={}
1093            self.etapes=[]
1094            self.jdc_aux=None
1095            self.fichier_err = ''.join(l)
1096            self.contexte_fichier_init={}
1097            raise EficasException(" ")
1098
1099       else:
1100          # Si le fichier est deja defini on ne reevalue pas le fichier
1101          # et on leve une exception si une erreur a ete enregistree
1102          self.update_fichier_init(unite)
1103          self.fichier_unite=unite
1104          if self.fichier_err is not None: raise EficasException(self.fichier_err)
1105
1106
1107 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1108   def make_contexte(self,fichier,text):
1109     """
1110         Cette methode sert a creer un contexte pour INCLUDE_MATERIAU
1111         en interpretant un texte source Python
1112         Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
1113     """
1114     #print "make_contexte",fichier
1115     # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
1116     # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
1117     if hasattr(self,'mat'):del self.mat
1118     if not hasattr(self,'fichier_ini') or self.fichier_ini != fichier or self.fichier_mater != self.nom_mater:
1119        # le fichier est nouveau ou change
1120        self.fichier_ini =fichier
1121        self.fichier_unite =fichier
1122        self.fichier_mater=self.nom_mater
1123        self.fichier_text=text
1124        self.fichier_err=None
1125        self.contexte_fichier_init={}
1126        # On specifie la classe a utiliser pour le JDC auxiliaire
1127        try:
1128          import Extensions.jdc_include
1129          self.JdC_aux=Extensions.jdc_include.JdC_include
1130        except:
1131          raise EficasException(" ")
1132        try:
1133           self.make_contexte_include(self.fichier_ini ,self.fichier_text)
1134           if not self.nom_mater in self.g_context :
1135              #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1136              self.g_context[self.nom_mater]=None
1137              if self.parent: self.parent.g_context[self.nom_mater]=None
1138        except:
1139           l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
1140           self.fichier_err = ''.join(l)
1141           self.g_context={}
1142           #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
1143           if self.parent:
1144               self.parent.g_context[self.nom_mater]=None
1145           self.g_context[self.nom_mater]=None
1146           #-------------
1147           self.etapes=[]
1148           self.jdc_aux=None
1149           self.contexte_fichier_init={}
1150           raise EficasException(" ")
1151     else:
1152        # le fichier est le meme on ne le reevalue pas
1153        # et on leve une exception si une erreur a ete enregistree
1154        if self.fichier_err is not None: raise EficasException(self.fichier_err)
1155
1156 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
1157   def update_sdprod(self,cr='non'):
1158      # Cette methode peut etre appelee dans EFICAS avec des mots cles de
1159      # la commande modifies. Ceci peut conduire a la construction ou
1160      # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
1161      # Il faut donc positionner le current_step avant l'appel
1162      CONTEXT.unset_current_step()
1163      CONTEXT.set_current_step(self)
1164      valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
1165      CONTEXT.unset_current_step()
1166      return valid
1167
1168 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1169   def Build_sd(self,nom):
1170       """
1171            Methode de Noyau surchargee pour poursuivre malgre tout
1172            si une erreur se produit pendant la creation du concept produit
1173       """
1174       try:
1175          sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
1176       except :
1177       #   return None
1178       #except AsException,e:
1179          # Une erreur s'est produite lors de la construction du concept
1180          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
1181          # Si on poursuit, on a le choix entre deux possibilites :
1182          # 1. on annule la sd associee a self
1183          # 2. on la conserve mais il faut la retourner
1184          # On choisit de l'annuler
1185          # En plus il faut rendre coherents sdnom et sd.nom
1186          self.sd=None
1187          self.sdnom=None
1188          self.state="unchanged"
1189          self.valid=0
1190
1191       return self.sd
1192
1193 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
1194   def make_poursuite(self):
1195       """ Cette methode est appelee par la fonction sd_prod de la macro POURSUITE
1196       """
1197       #print "make_poursuite"
1198       if not hasattr(self,'fichier_ini') :
1199          # Si le fichier n'est pas defini on le demande
1200          f,text=self.get_file_memo(fic_origine=self.parent.nom)
1201          # On memorise le fichier retourne
1202          self.fichier_ini = f
1203          self.fichier_unite = None
1204          self.fichier_text = text
1205          self.fichier_err=None
1206          try:
1207            import Extensions.jdc_include
1208          except:
1209            traceback.print_exc()
1210            raise EficasException(" ")
1211          self.JdC_aux=Extensions.jdc_include.JdC_poursuite
1212          self.contexte_fichier_init={}
1213          #print "make_poursuite",self.fichier_ini,self.fichier_text
1214
1215          if f is None:
1216              self.fichier_err="Le fichier POURSUITE n'est pas defini"
1217              self.jdc_aux=None
1218              self.parent.record_unit(None,self)
1219              raise EficasException(self.fichier_err)
1220
1221          try:
1222            self.make_contexte_include(self.fichier_ini,self.fichier_text)
1223            self.parent.record_unit(None,self)
1224          except:
1225            l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
1226            if self.jdc.appli:
1227               self.jdc.appli.affiche_alerte(tr("Erreur lors de l'evaluation du fichier poursuite"),
1228                                             message=tr("Ce fichier ne sera pas pris en compte\n %s",''.join(l)))
1229            self.parent.record_unit(None,self)
1230            self.g_context={}
1231            self.etapes=[]
1232            self.jdc_aux=None
1233            self.fichier_err = ''.join(l)
1234            self.contexte_fichier_init={}
1235            raise EficasException(" ")
1236
1237       else:
1238          # Si le fichier est deja defini on ne reevalue pas le fichier
1239          # et on leve une exception si une erreur a ete enregistree
1240          self.update_fichier_init(None)
1241          if self.fichier_err is not None: raise EficasException(self.fichier_err)