+ def change_fichier_init(self,new_fic,text):
+ """
+ Tente de changer le fichier include. Le precedent include est conservé
+ dans old_xxx
+ """
+ if not hasattr(self,'fichier_ini'):
+ self.fichier_ini=None
+ self.fichier_text=None
+ self.fichier_err="Le fichier n'est pas defini"
+ self.contexte_fichier_init={}
+ self.recorded_units={}
+ self.jdc_aux=None
+ self.fichier_unite="PasDefini"
+ import Extensions.jdc_include
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+
+ self.old_fic = self.fichier_ini
+ self.old_text = self.fichier_text
+ self.old_err = self.fichier_err
+ self.old_context=self.contexte_fichier_init
+ self.old_units=self.recorded_units
+ self.old_etapes=self.etapes
+ self.old_jdc_aux=self.jdc_aux
+
+ self.fichier_ini = new_fic
+ self.fichier_text=text
+
+ try:
+ self.make_contexte_include(new_fic,text)
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ self.fichier_err=string.join(l)
+ raise
+
+ # L'evaluation de text dans un JDC auxiliaire s'est bien passé
+ # on peut poursuivre le traitement
+ self.init_modif()
+ self.state="undetermined"
+ self.fichier_err=None
+ # On enregistre la modification de fichier
+ self.record_unite()
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+ self.parent.reset_context()
+
+ # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
+ self.old_contexte_fichier_init=self.old_context
+ self.reevalue_sd_jdc()
+
+ self.fin_modif()
+
+ def restore_fichier_init(self):
+ """
+ Restaure le fichier init enregistre dans old_xxx
+ """
+ self.fichier_ini=self.old_fic
+ self.fichier_text=self.old_text
+ self.fichier_err=self.old_err
+ self.contexte_fichier_init=self.old_context
+ self.recorded_units=self.old_units
+ self.etapes=self.old_etapes
+ self.jdc_aux=self.old_jdc_aux
+
+ def force_fichier_init(self):
+ """
+ Force le fichier init en erreur
+ """
+ # On conserve la memoire du nouveau fichier
+ # mais on n'utilise pas les concepts crees par ce fichier
+ # on met l'etape en erreur : fichier_err=string.join(l)
+ self.init_modif()
+ # On enregistre la modification de fichier
+ self.record_unite()
+ #self.etapes=[]
+ self.g_context={}
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+ self.parent.reset_context()
+
+ self.old_contexte_fichier_init=self.old_context
+ self.contexte_fichier_init={}
+ self.reevalue_sd_jdc()
+
+ self.fin_modif()
+
+ def make_contexte_include(self,fichier,text):
+ """
+ Cette méthode sert à créer un contexte en interprétant un texte source
+ Python
+ """
+ #print "make_contexte_include"
+ # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
+ contexte = self.get_contexte_jdc(fichier,text)
+ if contexte == None :
+ raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
+ else:
+ # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
+ # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
+ # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
+ # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
+ # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
+ # g_context est utilisé pour avoir les concepts produits par la macro
+ # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
+ self.contexte_fichier_init = contexte
+
+ def reevalue_fichier_init_OBSOLETE(self):
+ """Recalcule les concepts produits par le fichier enregistre"""
+ #print "reevalue_fichier_init"
+ old_context=self.contexte_fichier_init
+ try:
+ self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ self.fichier_err = string.join(l)
+ #self.etapes=[]
+ self.g_context={}
+
+ self.old_contexte_fichier_init=old_context
+ self.contexte_fichier_init={}
+ self.reevalue_sd_jdc()
+ return
+
+ # L'evaluation s'est bien passee
+ self.fichier_err = None
+ self.old_contexte_fichier_init=old_context
+ self.reevalue_sd_jdc()
+ #print "reevalue_fichier_init",self.jdc_aux.context_ini
+
+ def update_fichier_init(self,unite):
+ """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
+ les noms des fichiers
+ Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
+ """
+ #print "update_fichier_init",unite
+ self.fichier_err=None
+ self.old_contexte_fichier_init=self.contexte_fichier_init
+ old_fichier_ini=self.fichier_ini
+
+ #print "update_fichier_init",self,self.parent,self.parent.recorded_units
+
+ #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
+ if not self.parent.recorded_units.has_key(unite):
+ # Nouvelle unite
+ f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
+ units={}
+ if f is not None:
+ self.fichier_ini = f
+ self.fichier_text=text
+ self.recorded_units=units
+ if self.fichier_ini is None and self.jdc.appli:
+ self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
+ message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
+ else:
+ # Unite existante
+ f,text,units=self.parent.recorded_units[unite]
+ self.fichier_ini = f
+ self.fichier_text=text
+ self.recorded_units=units
+
+ if self.fichier_ini is None:
+ # Le fichier n'est pas défini
+ self.fichier_err="Le fichier associé n'est pas défini"
+ self.parent.change_unit(unite,self,self.fichier_unite)
+ self.g_context={}
+ self.contexte_fichier_init={}
+ self.parent.reset_context()
+ self.reevalue_sd_jdc()
+ return
+
+ if old_fichier_ini == self.fichier_ini:
+ # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+ #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
+ return
+
+ try:
+ self.make_contexte_include(self.fichier_ini,self.fichier_text)
+ # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
+ # avant d'appeler change_unit
+ self.parent.change_unit(unite,self,self.fichier_unite)
+ except:
+ # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ # On conserve la memoire du nouveau fichier
+ # mais on n'utilise pas les concepts crees par ce fichier
+ # on met l'etape en erreur : fichier_err=string.join(l)
+ self.fichier_err=string.join(l)
+ self.parent.change_unit(unite,self,self.fichier_unite)
+ self.g_context={}
+ self.contexte_fichier_init={}
+
+ # Le contexte du parent doit etre reinitialise car les concepts
+ # produits ont changé
+ self.parent.reset_context()
+ # Si des concepts ont disparu lors du changement de fichier, on
+ # demande leur suppression
+ self.reevalue_sd_jdc()
+ #print "update_fichier_init",self.jdc_aux.context_ini
+
+ def record_unite(self):
+ if self.nom == "POURSUITE":
+ self.parent.record_unit(None,self)
+ else:
+ if hasattr(self,'fichier_unite') :
+ self.parent.record_unit(self.fichier_unite,self)
+
+ def get_file_memo(self,unite=None,fic_origine=''):
+ """Retourne le nom du fichier et le source correspondant a l'unite unite
+ Initialise en plus recorded_units
+ """
+ #print "get_file_memo",unite,fic_origine,self,self.parent
+ #print self.parent.old_recorded_units
+ #print self.parent.recorded_units
+ if unite is None:
+ units={}
+ else:
+ units=self.parent.recorded_units
+ if self.parent.old_recorded_units.has_key(unite):
+ f,text,units=self.parent.old_recorded_units[unite]
+ #print id(self.recorded_units)
+ self.recorded_units=units
+ #print id(self.recorded_units)
+ return f,text
+ elif self.jdc :
+ f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+ else:
+ f,text=None,None
+ self.recorded_units=units
+ if f is None and self.jdc.appli:
+ self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
+ message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
+ return f,text
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def get_file(self,unite=None,fic_origine=''):
+ """Retourne le nom du fichier et le source correspondant a l'unite unite
+ Initialise en plus recorded_units
+ """
+ #print "get_file",unite
+ units={}
+ if self.jdc :
+ f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
+ else:
+ f,text=None,None
+ self.recorded_units=units
+ return f,text
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def make_include(self,unite=None):
+ """
+ Inclut un fichier dont l'unite logique est unite
+ Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
+ Si l'INCLUDE est invalide, la methode doit produire une exception
+ Sinon on retourne None. Les concepts produits par l'INCLUDE sont
+ pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
+ """
+ #print "make_include",unite
+ # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
+ # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
+ del self.unite
+ # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
+ if not unite : return
+
+ if not hasattr(self,'fichier_ini') :
+ # Si le fichier n'est pas defini on le demande
+ f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+ # On memorise le fichier retourne
+ self.fichier_ini = f
+ self.fichier_text = text
+ self.contexte_fichier_init={}
+ self.fichier_unite=unite
+ self.fichier_err=None
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+
+ if f is None:
+ self.fichier_err="Le fichier INCLUDE n est pas defini"
+ self.parent.record_unit(unite,self)
+ raise Exception(self.fichier_err)
+
+ try:
+ self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+ self.parent.record_unit(unite,self)
+ #print "make_include.context_ini",self.jdc_aux.context_ini
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ if self.jdc.appli:
+ self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
+ message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
+ )
+ self.parent.record_unit(unite,self)
+ self.g_context={}
+ self.fichier_err = string.join(l)
+ self.contexte_fichier_init={}
+ raise
+
+ else:
+ # Si le fichier est deja defini on ne reevalue pas le fichier
+ # et on leve une exception si une erreur a été enregistrée
+ self.update_fichier_init(unite)
+ self.fichier_unite=unite
+ if self.fichier_err is not None: raise Exception(self.fichier_err)
+
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def make_contexte(self,fichier,text):
+ """
+ Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
+ en interprétant un texte source Python
+ Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
+ """
+ # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
+ # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
+ if hasattr(self,'mat'):del self.mat
+ self.fichier_ini =fichier
+ self.fichier_unite =fichier
+ self.fichier_text=text
+ self.fichier_err=None
+ self.contexte_fichier_init={}
+ # On specifie la classe a utiliser pour le JDC auxiliaire
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+ try:
+ self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+ self.parent.record_unit(self.fichier_unite,self)
+ except:
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ self.fichier_err = string.join(l)
+ self.parent.record_unit(self.fichier_unite,self)
+ self.g_context={}
+ self.contexte_fichier_init={}
+ raise
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def update_sdprod(self,cr='non'):
+ # Cette methode peut etre appelee dans EFICAS avec des mots cles de
+ # la commande modifies. Ceci peut conduire a la construction ou
+ # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
+ # Il faut donc positionner le current_step avant l'appel
+ CONTEXT.unset_current_step()
+ CONTEXT.set_current_step(self)
+ valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
+ CONTEXT.unset_current_step()
+ return valid
+
+#ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro