# Modules Eficas
import I_ETAPE
+import Noyau
from Noyau.N_ASSD import ASSD
# import rajoutés suite à l'ajout de Build_sd --> à résorber
import Noyau, Validation.V_MACRO_ETAPE
from Noyau import N_Exception
from Noyau.N_Exception import AsException
+import Accas # attention aux imports circulaires
# fin import à résorber
class MACRO_ETAPE(I_ETAPE.ETAPE):
ou leve une exception
--> utilisée par ops.POURSUITE et INCLUDE
"""
+ #print "get_contexte_jdc",self,self.nom
+ # On recupere l'etape courante
+ step=CONTEXT.get_current_step()
try:
# on essaie de créer un objet JDC auxiliaire avec un contexte initial
- context_ini = self.parent.get_contexte_avant(self)
+ # Attention get_contexte_avant retourne un dictionnaire qui contient
+ # le contexte courant. Ce dictionnaire est reactualise regulierement.
+ # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
+ context_ini = self.parent.get_contexte_avant(self).copy()
+ #print "get_contexte_jdc",context_ini.keys()
# Indispensable avant de creer un nouveau JDC
CONTEXT.unset_current_step()
# En principe si la memorisation est faite au bon moment il n'est pas necessaire
# de prendre cette precaution mais ce n'est pas vrai partout.
old_recorded_units=self.recorded_units.copy()
- self.recorded_units.clear()
- j=self.JdC_aux( procedure=text,cata=self.jdc.cata,
- nom=fichier,
- context_ini = context_ini,
+ if fichier is None:fichier="SansNom"
+ j=self.JdC_aux( procedure=text, nom=fichier,
appli=self.jdc.appli,
+ cata=self.jdc.cata,
+ cata_ord_dico=self.jdc.cata_ordonne_dico,
+ context_ini = context_ini,
jdc_pere=self.jdc,etape_include=self,
prefix_include=prefix_include,
recorded_units=self.recorded_units,
j.analyse()
# On récupère les étapes internes (pour validation)
self.etapes=j.etapes
+ self.jdc_aux=j
except:
- traceback.print_exc()
- # On force le contexte (etape courante) à self
+ # On retablit l'etape courante step
CONTEXT.unset_current_step()
- CONTEXT.set_current_step(self)
+ CONTEXT.set_current_step(step)
return None
if not j.cr.estvide():
# Erreurs dans l'INCLUDE. On garde la memoire du fichier
# mais on n'insere pas les concepts
- # On force le contexte (etape courante) à self
+ # On retablit l'etape courante step
CONTEXT.unset_current_step()
- CONTEXT.set_current_step(self)
+ CONTEXT.set_current_step(step)
raise Exception("Impossible de relire le fichier\n"+str(j.cr))
if not j.isvalid():
# L'INCLUDE n'est pas valide.
# on produit un rapport d'erreurs
- # On force le contexte (etape courante) à self
cr=j.report()
+ # On retablit l'etape courante step
CONTEXT.unset_current_step()
- CONTEXT.set_current_step(self)
+ CONTEXT.set_current_step(step)
raise Exception("Le fichier include contient des erreurs\n"+str(cr))
# Si aucune erreur rencontrée
try:
j_context=j.get_verif_contexte()
except:
+ # On retablit l'etape courante step
CONTEXT.unset_current_step()
- CONTEXT.set_current_step(self)
+ CONTEXT.set_current_step(step)
raise
# On remplit le dictionnaire des concepts produits inclus
# On recupere le contexte courant
self.current_context=j.current_context
self.index_etape_courante=j.index_etape_courante
+ self.jdc_aux=j
- # XXX j.supprime() ???
- # On rétablit le contexte (etape courante) à self
+ # On retablit l'etape courante step
CONTEXT.unset_current_step()
- CONTEXT.set_current_step(self)
+ CONTEXT.set_current_step(step)
return j_context
Avec la liste des SD qui ont été supprimées, propage la
disparition de ces SD dans toutes les étapes et descendants
"""
+ #print "reevalue_sd_jdc"
l_sd_supp,l_sd_repl = self.diff_contextes()
for sd in l_sd_supp:
self.parent.delete_concept_after_etape(self,sd)
def control_sdprods(self,d):
"""
- Cette methode doit updater le contexte fournit par
- l'appelant en argument (d) en fonction de sa definition
- tout en verifiant que ses concepts produits ne sont pas
- deja definis dans le contexte
+ Cette methode doit verifier que les concepts produits par la
+ commande ne sont pas incompatibles avec le contexte fourni (d).
+ Si c'est le cas, le concept produit doit etre supprime
+ Si la macro a elle meme des etapes, elle doit propager
+ le traitement (voir methode control_jdc_context_apres de I_JDC)
"""
- if hasattr(self,"fichier_unite"):
- self.update_fichier_init(self.fichier_unite)
- self.init_modif()
-
- if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init,(self,d))
+ #print "I_MACRO_ETAPE.control_sdprods",d.keys(),self.nom,self.sd and self.sd.nom
if self.sd:
if d.has_key(self.sd.nom):
# Le concept est deja defini
# Redefinition du concept, on l'annule
#XXX on pourrait simplement annuler son nom pour conserver les objets
# l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
- self.sd=self.reuse=self.sdnom=None
self.init_modif()
- else:
- # Le concept n'est pas defini, on peut updater d
- d[self.sd.nom]=self.sd
+ sd=self.sd
+ self.sd=self.reuse=self.sdnom=None
+ self.parent.delete_concept_after_etape(self,sd)
+ self.fin_modif()
+
# On verifie les concepts a droite du signe =
- for co in self.sdprods:
+ self.init_modif()
+ sdprods=self.sdprods[:]
+ self.sdprods=[]
+ for co in sdprods:
if d.has_key(co.nom) and co is not d[co.nom] :
+ #nettoie les mots cles de l'étape qui ont comme valeur co
self.delete_concept(co)
+ #supprime les references a co dans les etapes suivantes
+ self.parent.delete_concept_after_etape(self,co)
else:
- d[co.nom]=co
+ self.sdprods.append(co)
+ self.fin_modif()
+ for e in self.etapes:
+ e.control_sdprods(d)
+ e.update_context(d)
+
+ def supprime_sdprod(self,sd):
+ """
+ Supprime le concept produit sd s'il est produit par l'etape
+ """
+ if sd in self.sdprods:
+ self.init_modif()
+ self.parent.del_sdprod(sd)
+ self.sdprods.remove(sd)
+ self.fin_modif()
+ self.parent.delete_concept(sd)
+ return
+
+ if sd is not self.sd :return
+ if self.sd is not None :
+ self.init_modif()
+ self.parent.del_sdprod(sd)
+ self.sd=None
+ self.fin_modif()
+ self.parent.delete_concept(sd)
def supprime_sdprods(self):
"""
- Fonction:
- Lors d'une destruction d'etape, detruit tous les concepts produits
+ Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
Un opérateur n a qu un concept produit
Une procedure n'en a aucun
Une macro en a en général plus d'un
"""
- if not self.is_reentrant() :
+ #print "supprime_sdprods"
+ if self.reuse is not self.sd :
# l'étape n'est pas réentrante
# le concept retourné par l'étape est à supprimer car il était
# créé par l'étape
self.parent.delete_concept(co)
# On met g_context à blanc
self.g_context={}
+
+ def close(self):
+ #print "close",self
+ if hasattr(self,"jdc_aux") and self.jdc_aux:
+ # La macro a un jdc auxiliaire inclus. On demande sa fermeture
+ self.jdc_aux.close()
+
+ def reset_context(self):
+ if hasattr(self,"jdc_aux") and self.jdc_aux:
+ # La macro a un jdc auxiliaire inclus. On demande la reinitialisation du contexte
+ self.jdc_aux.reset_context()
+
+ def update_concept(self,sd):
+ I_ETAPE.ETAPE.update_concept(self,sd)
+ for etape in self.etapes:
+ etape.update_concept(sd)
+
+ def delete_concept(self,sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse suite à la disparition du concept sd
+ Seuls les mots cles simples MCSIMP font un traitement autre
+ que de transmettre aux fils
+ """
+ #print "delete_concept",sd
+ I_ETAPE.ETAPE.delete_concept(self,sd)
+ for etape in self.etapes:
+ etape.delete_concept(sd)
+
+ def replace_concept(self,old_sd,sd):
+ """
+ Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
+ suite au remplacement du concept old_sd par sd
+ """
+ #print "replace_concept",old_sd,sd
+ I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
+ for etape in self.etapes:
+ etape.replace_concept(old_sd,sd)
+ def change_fichier_init(self,new_fic,text):
+ """
+ Tente de changer le fichier include. Le precedent include est conservé
+ dans old_xxx
+ """
+ #print "change_fichier_init",new_fic
+ 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()
+ if self.old_jdc_aux:
+ self.old_jdc_aux.close()
+
+ def restore_fichier_init(self):
+ """
+ Restaure le fichier init enregistre dans old_xxx
+ """
+ self.fichier_ini=self.old_fic
+ self.fichier_text=self.old_text
+ self.fichier_err=self.old_err
+ self.contexte_fichier_init=self.old_context
+ self.recorded_units=self.old_units
+ self.etapes=self.old_etapes
+ self.jdc_aux=self.old_jdc_aux
+
+ def force_fichier_init(self):
+ """
+ Force le remplacement du fichier init meme si le remplacant est en erreur
+ """
+ # Reinitialisation complete du compte-rendu d'erreurs
+ self.jdc_aux.cr=self.jdc_aux.CR()
+ # On remplit le dictionnaire des concepts produits inclus
+ # en retirant les concepts présents dans le contexte initial
+ # On ajoute egalement le concept produit dans le sds_dict du parent
+ # sans verification car on est sur (verification integrée) que
+ # le nommage est possible
+ j_context=self.jdc_aux.get_contexte_avant(None)
+ self.g_context.clear()
+ context_ini=self.jdc_aux.context_ini
+ for k,v in j_context.items():
+ if not context_ini.has_key(k) or context_ini[k] != v:
+ self.g_context[k]=v
+ self.parent.sds_dict[k]=v
+ # On recupere le contexte courant
+ self.current_context=self.jdc_aux.current_context
+ self.index_etape_courante=self.jdc_aux.index_etape_courante
+ self.contexte_fichier_init = j_context
+ self.fichier_err = None
+
+ # On enregistre la modification de fichier
+ self.init_modif()
+ self.state="undetermined"
+ self.record_unite()
+ # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
+ self.parent.reset_context()
+
+ # On remplace les anciens concepts par les nouveaux (y compris ajouts
+ # et suppression) et on propage les modifications aux etapes precedentes et suivantes
+ # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
+ # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
+ # necessaires
+ self.old_contexte_fichier_init=self.old_context
+ self.reevalue_sd_jdc()
+ self.fin_modif()
+ if self.old_jdc_aux:
+ self.old_jdc_aux.close()
+
+ self.jdc_aux.force_contexte(self.g_context)
+
+ def build_include(self,fichier,text):
+ import Extensions.jdc_include
+ self.JdC_aux=Extensions.jdc_include.JdC_include
+ # un include partage la table des unites avec son parent (jdc)
+ self.recorded_units=self.parent.recorded_units
+ self.build_jdcaux(fichier,text)
+
+ def build_poursuite(self,fichier,text):
+ import Extensions.jdc_include
+ self.JdC_aux=Extensions.jdc_include.JdC_poursuite
+ # une poursuite a sa propre table d'unites
+ self.recorded_units={}
+ self.build_jdcaux(fichier,text)
+
+ def build_jdcaux(self,fichier,text):
+ """
+ Cree un jdc auxiliaire initialise avec text.
+ Initialise le nom du fichier associé avec fichier
+ N'enregistre pas d'association unite <-> fichier
+ """
+ self.fichier_ini = fichier
+ self.fichier_text= text
+ self.fichier_unite=None
+ self.fichier_err = None
+ try:
+ contexte = self.get_contexte_jdc(fichier,text)
+ if contexte is None :
+ # Impossible de construire le jdc auxiliaire (sortie par None)
+ # On simule une sortie par exception
+ raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
+ else:
+ # La construction du jdc auxiliaire est allée au bout
+ self.contexte_fichier_init = contexte
+ self.init_modif()
+ self.fin_modif()
+ except:
+ # Impossible de construire le jdc auxiliaire (sortie par exception)
+ l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
+ if self.jdc.appli:
+ 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.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
+ self.fichier_err = string.join(l)
+ self.contexte_fichier_init={}
+ self.init_modif()
+ self.fin_modif()
+ raise
+
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 :
# contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
self.contexte_fichier_init = contexte
- def reevalue_fichier_init(self):
+ 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.etapes=[]
+ self.jdc_aux=None
self.old_contexte_fichier_init=old_context
self.contexte_fichier_init={}
self.reevalue_sd_jdc()
"""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
+ L'include a été initialisé précédemment. Le jdc auxiliaire existe.
"""
-
- self.fichier_err=None
+ #print "update_fichier_init",unite,self.fichier_unite
self.old_contexte_fichier_init=self.contexte_fichier_init
+ old_fichier_ini=self.fichier_ini
+ if not hasattr(self,"jdc_aux"):self.jdc_aux=None
+ old_jdc_aux=self.jdc_aux
- if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
- # Changement d'unite ou Nouvelle unite
- f,text=self.get_file(unite=unite,fic_origine=self.parent.nom)
- units={}
- if f is not None:
+ #print "update_fichier_init",self,self.parent,self.parent.recorded_units
+
+ if self.fichier_unite is None:
+ # L'unité n'était pas définie précédemment. On ne change que l'unite
+ #print "update_fichier_init","pas de changement dans include"
+ self.fichier_unite=unite
+ return
+ elif unite == self.fichier_unite :
+ # L'unité n'a pas changé
+ #print "update_fichier_init","pas de changement dans include 3"
+ return
+ elif unite != self.fichier_unite :
+ # L'unité était définie précédemment. On remplace l'include
+ #
+ f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
+ if f is None:
+ # Le fichier associé n'a pas pu etre defini
+ # on change l'unite associée mais pas l'include
+ #print "update_fichier_init","pas de changement dans include 2"
+ self.fichier_unite=unite
+ return
+ else:
self.fichier_ini = f
self.fichier_text=text
- self.recorded_units=units
- if self.fichier_ini is None and self.jdc.appli:
- self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
- message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
- else:
- # Meme unite existante
- f,text,units=self.parent.recorded_units[unite]
- self.fichier_ini = f
- self.fichier_text=text
- self.recorded_units=units
+ self.fichier_unite=unite
+ #print "update_fichier_init",self.recorded_units
- if self.fichier_ini is None:
- # Le fichier n'est pas défini
- self.fichier_err="Le fichier associé n'est pas défini"
- self.parent.change_unit(unite,self,self.fichier_unite)
- self.g_context={}
- self.contexte_fichier_init={}
- self.parent.reset_context()
- self.reevalue_sd_jdc()
+ #print "update_fichier_init",self.fichier_ini,self.fichier_text,self.fichier_unite
+
+ if old_fichier_ini == self.fichier_ini:
+ # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
+ # mais on enregistre le changement d'association unite <-> fichier
+ #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
+ self.parent.record_unit(unite,self)
return
try:
+ self.fichier_err=None
self.make_contexte_include(self.fichier_ini,self.fichier_text)
# Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
# avant d'appeler change_unit
- self.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])
# 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.etapes=[]
+ self.jdc_aux=None
self.contexte_fichier_init={}
+ if old_jdc_aux:
+ old_jdc_aux.close()
+ self.parent.record_unit(unite,self)
# Le contexte du parent doit etre reinitialise car les concepts
# produits ont 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.keys()
def record_unite(self):
+ #print "record_unite",self.nom
if self.nom == "POURSUITE":
self.parent.record_unit(None,self)
else:
"""Retourne le nom du fichier et le source correspondant a l'unite unite
Initialise en plus recorded_units
"""
- units={}
- if self.parent.old_recorded_units.has_key(unite):
- f,text,units=self.parent.old_recorded_units[unite]
- self.recorded_units=units
- return f,text
+ #print "get_file_memo",unite,fic_origine,self,self.parent
+ #print self.parent.recorded_units
+ if unite is None:
+ # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
+ units={}
+ else:
+ # On est dans le cas d'un include. On reutilise toutes les unites de parent
+ units=self.parent.recorded_units
+
+ if self.parent.recorded_units.has_key(unite):
+ f,text,units=self.parent.recorded_units[unite]
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
+ def update_context(self,d):
+ """
+ Met à jour le contexte contenu dans le dictionnaire d
+ Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
+ Une fonction enregistree dans op_init peut egalement modifier le contexte
+ """
+ #print "update_context",self,self.nom,d.keys()
+ if hasattr(self,"jdc_aux") and self.jdc_aux:
+ #ATTENTION: update_context NE DOIT PAS appeler reset_context
+ # car il appelle directement ou indirectement update_context
+ # equivalent a reset_context. Evite les recursions
+ self.jdc_aux.context_ini=d.copy()
+ self.jdc_aux.current_context={}
+ self.jdc_aux.index_etape_courante=0
+ #ATTENTION: il ne faut pas utiliser self.jdc_aux.get_contexte_avant
+ #car cet appel conduit a des remontées multiples incohérentes dans le
+ # ou les parents.
+ #get_context_avant appelle update_context qui NE DOIT PAS appeler get_contexte_avant
+ #On n'a besoin que d'un update local connaissant
+ # le contexte amont : d qui sert a reinitialiser self.context_ini
+ for e in self.etapes:
+ e.update_context(d)
+ return
+
+ if type(self.definition.op_init) == types.FunctionType:
+ apply(self.definition.op_init,(self,d))
+ if self.sd != None:d[self.sd.nom]=self.sd
+ for co in self.sdprods:
+ d[co.nom]=co
+ #print "update_context.fin",d.keys()
+
+#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ def supprime(self):
+ #print "supprime",self
+ if hasattr(self,"jdc_aux") and self.jdc_aux:
+ self.jdc_aux.supprime_aux()
+ self.jdc_aux=None
+ Noyau.N_MACRO_ETAPE.MACRO_ETAPE.supprime(self)
+
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
def get_file(self,unite=None,fic_origine=''):
"""Retourne le nom du fichier et le source correspondant a l'unite unite
- Initialise en plus recorded_units
"""
- 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)
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
self.contexte_fichier_init={}
self.fichier_unite=unite
self.fichier_err=None
- import Extensions.jdc_include
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
self.JdC_aux=Extensions.jdc_include.JdC_include
- if f is None:
+ #print "make_include",self.fichier_ini,self.fichier_text
+ if f is None and not text:
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)
+ message="Le contenu de ce fichier ne sera pas pris en compte\n"+string.join(l)
)
self.parent.record_unit(unite,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.fichier_err = string.join(l)
self.contexte_fichier_init={}
raise
self.fichier_err=None
self.contexte_fichier_init={}
# On specifie la classe a utiliser pour le JDC auxiliaire
- import Extensions.jdc_include
+ 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)
+ #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.parent.record_unit(self.fichier_unite,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.contexte_fichier_init={}
raise
# 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
- if self.state == "undetermined":return 1
CONTEXT.unset_current_step()
CONTEXT.set_current_step(self)
valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
def make_poursuite(self):
""" Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
"""
+ #print "make_poursuite"
if not hasattr(self,'fichier_ini') :
# Si le fichier n'est pas defini on le demande
f,text=self.get_file_memo(fic_origine=self.parent.nom)
self.fichier_unite = None
self.fichier_text = text
self.fichier_err=None
- import Extensions.jdc_include
+ try:
+ import Extensions.jdc_include
+ except:
+ traceback.print_exc()
+ raise
self.JdC_aux=Extensions.jdc_include.JdC_poursuite
self.contexte_fichier_init={}
+ #print "make_poursuite",self.fichier_ini,self.fichier_text
if f is None:
self.fichier_err="Le fichier POURSUITE n'est pas defini"
+ self.jdc_aux=None
self.parent.record_unit(None,self)
raise Exception(self.fichier_err)
)
self.parent.record_unit(None,self)
self.g_context={}
+ self.etapes=[]
+ self.jdc_aux=None
self.fichier_err = string.join(l)
self.contexte_fichier_init={}
raise
# et on leve une exception si une erreur a été enregistrée
self.update_fichier_init(None)
if self.fichier_err is not None: raise Exception(self.fichier_err)
-