def get_file(self, unite=None, fic_origine='', fname=None):
"""
Retourne le nom du fichier correspondant à un numero d'unité
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.appli:
# Si le JDC est relié à une application maitre, on délègue la
# recherche
return self.appli.get_file(unite, fic_origine)
else:
if unite != None:
if os.path.exists("fort." + str(unite)):
fname = "fort." + str(unite)
if fname == None:
raise AsException(
"Impossible de trouver le fichier correspondant"
" a l unite %s" % unite)
if not os.path.exists(fname):
raise AsException("%s n'est pas un fichier existant" % fname)
fproc = open(fname, 'r')
text = fproc.read()
fproc.close()
text = text.replace('\r\n', '\n')
linecache.cache[fname] = 0, 0, text.split('\n'), fname
return fname, text
def verif_presence(self, dict, globs):
"""
Cette méthode vérifie si le dictionnaire passé en argument (dict)
est susceptible de contenir un bloc de mots-clés conforme à la
définition qu'il porte.
Si la réponse est oui, la méthode retourne 1
Si la réponse est non, la méthode retourne 0
Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
les valeurs des mots-clés
"""
# On recopie le dictionnaire pour protéger l'original
dico = {}
dico.update(block_utils(dico))
dico.update(dict)
if self.condition != None:
try:
test = eval(self.condition, globs, dico)
return test
except NameError:
# erreur 'normale' : un mot-clé n'est pas présent et on veut
# l'évaluer dans la condition
if CONTEXT.debug:
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
print "WARNING : Erreur a l'evaluation de la condition " + string.join(
l)
return 0
except SyntaxError:
# le texte de la condition n'est pas du Python correct -->
# faute de catalogue
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
raise AsException("Catalogue entite : ", self.nom,
", de pere : ", self.pere.nom, '\n',
"Erreur dans la condition : ",
self.condition, string.join(l))
except:
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
raise AsException("Catalogue entite : ", self.nom,
", de pere : ", self.pere.nom, '\n',
"Erreur dans la condition : ",
self.condition, string.join(l))
else:
return 0
def Build_sd(self, nom):
"""
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- le parent n'est pas défini. Dans ce cas, l'étape prend en charge
la création et le nommage du concept.
- le parent est défini. Dans ce cas, l'étape demande au parent la
création et le nommage du concept.
"""
# message.debug(SUPERV, "%s", self.nom)
self.sdnom = nom
try:
# On positionne la macro self en tant que current_step pour que les
# étapes créées lors de l'appel à sd_prod et à op_init aient la macro
# comme parent
self.set_current_step()
if self.parent:
sd = self.parent.create_sdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
apply(self.definition.op_init,
(self, self.parent.g_context))
else:
sd = self.get_sd_prod()
if sd != None and self.reuse == None:
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
sd.set_name(nom)
self.reset_current_step()
except AsException, e:
self.reset_current_step()
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], str(e))
def Build_sd(self, nom):
"""
Construit le concept produit de l'opérateur. Deux cas
peuvent se présenter :
- le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
et le nommage du concept.
- le parent est défini. Dans ce cas, l'étape demande au parent la création et
le nommage du concept.
"""
# message.debug(SUPERV, "Build_sd %s", self.nom)
self.sdnom = nom
try:
if self.parent:
sd = self.parent.create_sdprod(self, nom)
if type(self.definition.op_init) == types.FunctionType:
apply(self.definition.op_init,
(self, self.parent.g_context))
else:
sd = self.get_sd_prod()
# On n'utilise pas self.definition.op_init car self.parent
# n'existe pas
if sd != None and self.reuse == None:
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
sd.set_name(nom)
except AsException, e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], str(e))
def NommerSdprod(self, sd, sdnom, restrict='non'):
"""
Cette méthode est appelée par les etapes internes de la macro.
La macro appelle le JDC pour valider le nommage.
On considère que l'espace de nom est unique et géré par le JDC.
Si le nom est déjà utilisé, l'appel lève une exception.
Si restrict=='non', on insère le concept dans le contexte du parent de la macro.
Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro.
"""
# Normalement, lorsqu'on appelle cette methode, on ne veut nommer que des concepts nouvellement crees.
# Le filtrage sur les concepts a creer ou a ne pas creer est fait dans la methode
# create_sdprod. La seule chose a verifier apres conversion eventuelle du nom
# est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant
# au JDC par l'intermediaire du parent.
# message.debug(SUPERV, "macro results = %s, (sdnom: %r, restrict: %r)",
# self.Outputs.keys(), sdnom, restrict)
if self.Outputs.has_key(sdnom):
# Il s'agit d'un concept de sortie de la macro produit par une
# sous commande
sdnom = self.Outputs[sdnom].nom
elif len(sdnom) > 0:
if sdnom[0] in ('_', '.') and sdnom[1:].isdigit():
# il est déjà de la forme _9000012 ou .9000017
pass
elif sdnom[0] == '_':
# Si le nom du concept commence par le caractère '_', on lui attribue
# un identificateur JEVEUX construit par gcncon.
# nom commençant par __ : il s'agit de concepts qui seront détruits
# nom commençant par _ : il s'agit de concepts intermediaires
# qui seront gardés
if len(sdnom) > 1 and sdnom[1] == '_':
sdnom = self.gcncon('.')
else:
sdnom = self.gcncon('_')
elif self.nom in ('INCLUDE', 'MACR_RECAL'):
# dans le cas d'INCLUDE, on passe
# MACR_RECAL fonctionne comme INCLUDE
pass
else:
# On est dans le cas d'un nom de concept global
# XXX à voir, création de CO() dans CALC_ESSAI (sdls139a)
if not sd.is_typco():
raise AsException(
"Résultat non déclaré par la macro %s : %s" %
(self.nom, sdnom))
self.last = sdnom
if restrict == 'non':
# On demande le nommage au parent mais sans ajout du concept dans le contexte du parent
# car on va l'ajouter dans le contexte de la macro
self.parent.NommerSdprod(sd, sdnom, restrict='oui')
# On ajoute dans le contexte de la macro les concepts nommes
# Ceci est indispensable pour les CO (macro) dans un INCLUDE
self.g_context[sdnom] = sd
# message.debug(SUPERV, "g_context[%s] = %s", sdnom, sd)
else:
# La demande de nommage vient probablement d'une macro qui a mis
# le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
# message.debug(SUPERV, "restrict=oui co[%s] = %s", sdnom, sd)
self.parent.NommerSdprod(sd, sdnom, restrict='oui')
def reset_current_step(self):
"""
Methode utilisee par l'etape self qui remet son etape parent comme
etape courante
"""
cs = CONTEXT.get_current_step()
if self != cs:
raise AsException("L'étape courante", cs.nom, cs, "devrait etre",
self.nom, self)
else:
CONTEXT.unset_current_step()
CONTEXT.set_current_step(self.parent)
def __init__(self, nom):
ASSD.__init__(self, etape=None, sd=None, reg='oui')
self._as_co = 1
#
# On demande le nommage du concept
#
if self.parent:
try:
self.parent.NommerSdprod(self, nom)
except AsException, e:
appel = N_utils.callee_where(niveau=2)
raise AsException(
"Concept CO, fichier: ", appel[1], " ligne : ", appel[0], '\n', e)
def set_current_step(self):
"""
Methode utilisee pour que l etape self se declare etape
courante. Utilise par les macros
"""
# message.debug(SUPERV, "call etape.set_current_step", stack_id=-1)
cs = CONTEXT.get_current_step()
if self.parent != cs:
raise AsException("L'étape courante", cs.nom, cs,
"devrait etre le parent de", self.nom, self)
else:
CONTEXT.unset_current_step()
CONTEXT.set_current_step(self)
def NommerSdprod(self, sd, sdnom, restrict='non'):
"""
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Si le nom est deja utilise, leve une exception
Met le concept créé dans le concept global g_context
"""
o = self.sds_dict.get(sdnom, None)
if isinstance(o, ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
if sdnom in self._reserved_kw:
raise AsException(
"Nom de concept invalide. '%s' est un mot-clé réservé." %
sdnom)
# Ajoute a la creation (appel de reg_sd).
self.sds_dict[sdnom] = sd
sd.set_name(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 AsType(a):
"""
Retourne le type d'un concept (a) à partir
des caractéristiques de l'objet Python
"""
if is_sequence(a):
return AsType(a[0])
if is_assd(a):
return type(a)
if is_float(a):
return "R"
if is_int(a):
return "I"
if is_str(a):
return "TXM"
if a == None:
return None
raise AsException("type inconnu: %r %s" % (a, type(a)))
def Build_sd(self):
"""
Cette methode applique la fonction op_init au contexte du parent
et lance l'exécution en cas de traitement commande par commande
Elle doit retourner le concept produit qui pour une PROC est toujours None
En cas d'erreur, elle leve une exception : AsException ou EOFError
"""
if not self.isactif():
return
try:
if self.parent:
if type(self.definition.op_init) == types.FunctionType:
apply(self.definition.op_init,
(self, self.parent.g_context))
else:
pass
except AsException, e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
if type(self.definition.op_init) == types.FunctionType:
apply(self.definition.op_init,
(self, self.parent.g_context))
else:
pass
except AsException, e:
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], e)
except EOFError:
raise
except:
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1] + '\n',
string.join(l))
self.Execute()
return None
def supprime(self):
"""
Méthode qui supprime toutes les références arrières afin que l'objet puisse
etre correctement détruit par le garbage collector
"""
N_MCCOMPO.MCCOMPO.supprime(self)
self.jdc = None
self.appel = None
def accept(self, visitor):
def create_sdprod(self, etape, nomsd):
"""
Cette methode doit fabriquer le concept produit retourne
par l'etape etape et le nommer.
Elle est appelée à l'initiative de l'etape
pendant le processus de construction de cette etape : methode __call__
de la classe CMD (OPER ou MACRO)
Ce travail est réalisé par le contexte supérieur (etape.parent)
car dans certains cas, le concept ne doit pas etre fabriqué mais
l'etape doit simplement utiliser un concept préexistant.
- Cas 1 : etape.reuse != None : le concept est réutilisé
- Cas 2 : l'étape appartient à une macro qui a déclaré un concept
de sortie qui doit etre produit par cette etape.
"""
if self.Outputs.has_key(nomsd):
# Il s'agit d'un concept de sortie de la macro. Il ne faut pas le créer
# Il faut quand meme appeler la fonction sd_prod si elle existe.
# get_type_produit le fait et donne le type attendu par la commande
# pour verification ultérieure.
sdprod = etape.get_type_produit_brut()
sd = self.Outputs[nomsd]
# On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
# Cette règle est normalement cohérente avec les règles de
# vérification des mots-clés
if not issubclass(sdprod, sd.__class__):
raise AsException(
"Le type du concept produit %s devrait etre une sur classe de %s"
% (sd.__class__, sdprod))
# La propriete du concept est transferee a l'etape avec le type
# attendu par l'étape
etape.sd = sd
sd.etape = etape
if self.reuse == sd and etape.reuse != sd \
and getattr(sd, "executed", 0) == 1: # n'a pas été pas détruit
raise AsException(
"Le concept '%s' est réentrant dans la macro-commande %s. "
"Il devrait donc l'être dans %s (produit sous le nom '%s')."
% (sd.nom, self.nom, etape.nom, nomsd))
# On donne au concept le type produit par la sous commande.
# Le principe est le suivant : apres avoir verifie que le type deduit par la sous commande
# est bien coherent avec celui initialement affecte par la macro (voir ci dessus)
# on affecte au concept ce type car il peut etre plus precis
# (derive, en general)
sd.__class__ = sdprod
# On force également le nom stocké dans l'attribut sdnom : on lui donne le nom
# du concept associé à nomsd
etape.sdnom = sd.nom
# pour l'ajouter au contexte de la macro
self.g_context[sd.nom] = sd
elif etape.definition.reentrant != 'n' and etape.reuse != None:
# On est dans le cas d'une commande avec reutilisation d'un concept existant
# get_sd_prod fait le necessaire : verifications, associations, etc. mais ne cree
# pas un nouveau concept. Il retourne le concept reutilise
sd = etape.get_sd_prod()
# Dans le cas d'un concept nomme automatiquement : _xxx, __xxx,
# On force le nom stocke dans l'attribut sdnom de l'objet etape : on lui donne le nom
# du concept reutilise (sd ou etape.reuse c'est pareil)
# Ceci est indispensable pour eviter des erreurs lors des verifications des macros
# En effet une commande avec reutilisation d'un concept verifie que le nom de
# la variable a gauche du signe = est le meme que celui du concept reutilise.
# Lorsqu'une telle commande apparait dans une macro, on supprime
# cette verification.
if (etape.sdnom == '' or etape.sdnom[0] == '_'):
etape.sdnom = sd.nom
else:
# On est dans le cas de la creation d'un nouveau concept
sd = etape.get_sd_prod()
if sd != None:
self.NommerSdprod(sd, nomsd)
return sd
def type_sdprod(self, co, t):
"""
Cette methode a pour fonction de typer le concept co avec le type t
dans les conditions suivantes :
1. co est un concept produit de self
2. co est un concept libre : on le type et on l attribue à self
Elle enregistre egalement les concepts produits (on fait l hypothese
que la liste sdprods a été correctement initialisee, vide probablement)
"""
if not hasattr(co, 'etape'):
# Le concept vaut None probablement. On ignore l'appel
return
#
# On cherche a discriminer les differents cas de typage d'un concept
# produit par une macro qui est specifie dans un mot cle simple.
# On peut passer plusieurs fois par type_sdprod ce qui explique
# le nombre important de cas.
#
# Cas 1 : Le concept est libre. Il vient d'etre cree par CO(nom)
# Cas 2 : Le concept est produit par la macro. On est deja passe par type_sdprod.
# Cas semblable a Cas 1.
# Cas 3 : Le concept est produit par la macro englobante (parent). On transfere
# la propriete du concept de la macro parent a la macro courante (self)
# en verifiant que le type est valide
# Cas 4 : La concept est la propriete d'une etape fille. Ceci veut dire qu'on est
# deja passe par type_sdprod et que la propriete a ete transfere a une
# etape fille. Cas semblable a Cas 3.
# Cas 5 : Le concept est produit par une etape externe a la macro.
#
if co.etape == None:
# Cas 1 : le concept est libre
# On l'attache a la macro et on change son type dans le type demande
# Recherche du mot cle simple associe au concept
mcs = self.get_mcs_with_co(co)
if len(mcs) != 1:
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
mcs = mcs[0]
if not self.typeCO in mcs.definition.type:
raise AsException("""Erreur interne.
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
% (co, mcs.definition.type))
co.etape = self
# affectation du bon type du concept
# message.debug(SUPERV, "MACRO.type_sdprod : changement de type de
# %s --> %s", co, t)
co.change_type(t)
self.sdprods.append(co)
elif co.etape == self:
# Cas 2 : le concept est produit par la macro (self)
# On est deja passe par type_sdprod (Cas 1 ou 3).
# XXX Peut-il être créer par une autre macro ?
# On vérifie juste que c'est un vrai CO non déjà typé
# if co.etape == co._etape:
if co.is_typco() == 1:
# Le concept a été créé par la macro (self)
# On peut changer son type
co.change_type(t)
else:
# Le concept a été créé par une macro parente
# Le type du concept doit etre coherent avec le type demande
# (seulement derive)
if not isinstance(co, t):
raise AsException("""Erreur interne.
Le type demande (%s) et le type du concept (%s) devraient etre derives""" %
(t, co.__class__))
self.sdprods.append(co)
elif co.etape == self.parent:
# Cas 3 : le concept est produit par la macro parente (self.parent)
# on transfere la propriete du concept a la macro fille
# et on change le type du concept comme demande
# Au prealable, on verifie que le concept existant (co) est une instance
# possible du type demande (t)
# Cette règle est normalement cohérente avec les règles de
# vérification des mots-clés
if not isinstance(co, t):
raise AsException("""
Impossible de changer le type du concept produit (%s) en (%s).
Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" %
(co, t, co.__class__, t))
mcs = self.get_mcs_with_co(co)
if len(mcs) != 1:
raise AsException("""Erreur interne.
Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co)
mcs = mcs[0]
if not self.typeCO in mcs.definition.type:
raise AsException("""Erreur interne.
Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)"""
% (co, mcs.definition.type))
co.etape = self
# On ne change pas le type car il respecte la condition isinstance(co,t)
# co.__class__ = t
self.sdprods.append(co)
elif self.issubstep(co.etape):
# Cas 4 : Le concept est propriété d'une sous etape de la macro (self).
# On est deja passe par type_sdprod (Cas 3 ou 1).
# Il suffit de le mettre dans la liste des concepts produits (self.sdprods)
# Le type du concept et t doivent etre derives.
# Il n'y a aucune raison pour que la condition ne soit pas
# verifiee.
if not isinstance(co, t):
raise AsException("""Erreur interne.
Le type demande (%s) et le type du concept (%s) devraient etre derives""" %
(t, co.__class__))
self.sdprods.append(co)
else:
# Cas 5 : le concept est produit par une autre étape
# On ne fait rien
return
except AsException, e:
self.reset_current_step()
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1], str(e))
except (EOFError, self.UserError):
# Le retablissement du step courant n'est pas strictement
# necessaire. On le fait pour des raisons de coherence
self.reset_current_step()
raise
except:
self.reset_current_step()
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0],
'fichier : ', self.appel[1] + '\n',
string.join(l))
self.Execute()
return sd
def get_sd_prod(self):
"""
Retourne le concept résultat d'une macro étape
La difference avec une etape ou une proc-etape tient a ce que
le concept produit peut exister ou pas
Si sd_prod == None le concept produit n existe pas on retourne None
Deux cas :
- cas 1 : sd_prod n'est pas une fonction