+#@ MODIF N_JDC Noyau DATE 05/09/2005 AUTEUR DURAND C.DURAND
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+
"""
Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
"""
from Accas import *
NONE = None
"""
+
from N_utils import SEP
def __init__(self,definition=None,procedure=None,cata=None,
self.cr = self.CR(debut = "CR phase d'initialisation",
fin = "fin CR phase d'initialisation")
self.g_context={}
+ # Liste pour stocker tous les concepts produits dans le JDC
self.sds=[]
+ # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par le nom)
+ self.sds_dict={}
self.etapes=[]
self.mc_globaux={}
self.current_context={}
+ self.condition_context={}
self.index_etape_courante=0
+ self.UserError="UserError"
+ self.alea = None
def compile(self):
"""
"""
try:
if self.appli != None :
- self.appli.affiche_infos('Compilation du fichier de commandes \
- en cours ...')
+ self.appli.affiche_infos('Compilation du fichier de commandes en cours ...')
self.proc_compile=compile(self.procedure,self.nom,'exec')
except SyntaxError,e:
if CONTEXT.debug : traceback.print_exc()
if type(obj_cata) == types.ModuleType :
init2 = "from "+obj_cata.__name__+" import *"
exec init2 in self.g_context
+
+ # Initialisation du contexte global pour l'évaluation des conditions de BLOC
+ # On utilise une copie de l'initialisation du contexte du jdc
+ self.condition_context=self.g_context.copy()
+
# Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
# le contexte initial (--> permet d'évaluer un JDC en récupérant un contexte
# d'un autre par exemple)
if self.context_ini :
self.g_context.update(self.context_ini)
+ # Update du dictionnaire des concepts
+ for sdnom,sd in self.context_ini.items():
+ if isinstance(sd,ASSD):self.sds_dict[sdnom]=sd
if self.appli != None :
- self.appli.affiche_infos('Interprétation du fichier de \
- commandes en cours ...')
+ self.appli.affiche_infos('Interprétation du fichier de commandes en cours ...')
# On sauve le contexte pour garder la memoire des constantes
# En mode edition (EFICAS) ou lors des verifications le contexte
# est recalculé
# de commandes avant la fin
# Fonctionnement normal, ne doit pas etre considere comme une erreur
CONTEXT.unset_current_step()
+ self.affiche_fin_exec()
+ self.traiter_fin_exec('commande')
except AsException,e:
# une erreur a ete identifiee
s= traceback.format_exception_only("Erreur de nom",e)[0][:-1]
message = "erreur de syntaxe, %s ligne %d" % (s,l[-1][1])
if CONTEXT.debug :
- #prbanner(message)
traceback.print_exc()
self.cr.exception(message)
CONTEXT.unset_current_step()
+ except self.UserError,exc_val:
+ self.traiter_user_exception(exc_val)
+ CONTEXT.unset_current_step()
+ self.traiter_fin_exec('commande')
+
except :
# erreur inattendue
# sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
# (tuple de 3 éléments)
- if CONTEXT.debug :
- traceback.print_exc()
- #prbanner("erreur non prevue et non traitee prevenir \
- # la maintenance "+self.nom)
- l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
- sys.exc_info()[2])
+ if CONTEXT.debug : traceback.print_exc()
+
+ exc_typ,exc_val,exc_fr=sys.exc_info()
+ l=traceback.format_exception(exc_typ,exc_val,exc_fr)
self.cr.exception("erreur non prevue et non traitee prevenir la maintenance "+
self.nom+'\n'+ string.join(l))
+ del exc_typ,exc_val,exc_fr
CONTEXT.unset_current_step()
+ def affiche_fin_exec(self):
+ """
+ Cette methode realise l'affichage final des statistiques de temps
+ apres l'execution de toutes
+ les commandes en mode commande par commande ou par lot
+ Elle doit etre surchargee pour en introduire un
+ """
+ return
+
+ def traiter_fin_exec(self,mode,etape=None):
+ """
+ Cette methode realise un traitement final apres l'execution de toutes
+ les commandes en mode commande par commande ou par lot
+ Par defaut il n'y a pas de traitement. Elle doit etre surchargee
+ pour en introduire un
+ """
+ print "FIN D'EXECUTION",mode,etape
+
+ def traiter_user_exception(self,exc_val):
+ """Cette methode realise un traitement sur les exceptions utilisateur
+ Par defaut il n'y a pas de traitement. La méthode doit etre
+ surchargée pour en introduire un.
+ """
+ return
+
def register(self,etape):
"""
Cette méthode ajoute etape dans la liste des etapes : self.etapes
Dans le cas du JDC, le deuxième cas ne peut pas se produire.
"""
sd= etape.get_sd_prod()
- if sd != None and etape.reuse == None:
+ if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None) :
# ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
- # d un concept
+ # d un concept. Commande non reentrante ou reuse absent.
self.NommerSdprod(sd,nomsd)
return sd
- def NommerSdprod(self,sd,sdnom):
+ def NommerSdprod(self,sd,sdnom,restrict='non'):
"""
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Met le concept créé dans le concept global g_context
"""
if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
- o=self.g_context.get(sdnom,None)
+
+ o=self.sds_dict.get(sdnom,None)
if isinstance(o,ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
# ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
# Ajoute a la creation (appel de reg_sd).
- self.g_context[sdnom]=sd
+ self.sds_dict[sdnom]=sd
sd.nom=sdnom
+ # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
+ if restrict == 'non':
+ self.g_context[sdnom]=sd
+
def reg_sd(self,sd):
"""
Methode appelee dans l __init__ d un ASSD lors de sa creation
"""
if self.appli :
# Si le JDC est relié à une application maitre, on délègue la recherche
- file= self.appli.get_file(unite,fic_origine)
+ file,text= self.appli.get_file(unite,fic_origine)
else:
file = None
if unite != None:
if os.path.exists("fort."+str(unite)):
file= "fort."+str(unite)
if file == None :
- raise AsException("Impossible de trouver le fichier correspondant \
- a l unite %s" % unite)
+ raise AsException("Impossible de trouver le fichier correspondant"
+ " a l unite %s" % unite)
if not os.path.exists(file):
raise AsException("%s n'est pas un fichier existant" % unite)
- fproc=open(file,'r')
- text=string.replace(fproc.read(),'\r\n','\n')
- fproc.close()
+ fproc=open(file,'r')
+ text=fproc.read()
+ fproc.close()
+ if file == None : return None,None
+ text=string.replace(text,'\r\n','\n')
linecache.cache[file]=0,0,string.split(text,'\n'),file
return file,text
if index_etape >= self.index_etape_courante:
# On calcule le contexte en partant du contexte existant
d=self.current_context
+ if self.index_etape_courante==0 and self.context_ini:
+ d.update(self.context_ini)
liste_etapes=self.etapes[self.index_etape_courante:index_etape]
else:
d=self.current_context={}
+ if self.context_ini:d.update(self.context_ini)
liste_etapes=self.etapes
for e in liste_etapes:
self.index_etape_courante=index_etape
return d
+ def get_global_contexte(self):
+ return self.g_context.copy()
+
+ def get_cmd(self,nomcmd):
+ """
+ Méthode pour recuperer la definition d'une commande
+ donnee par son nom dans les catalogues declares
+ au niveau du jdc
+ """
+ for cata in self.cata:
+ if hasattr(cata,nomcmd):
+ return getattr(cata,nomcmd)
+
