]> SALOME platform Git repositories - tools/eficas.git/blob - Noyau/N_JDC.py
Salome HOME
5088de7d2bffa034f64807e0b92be5633b39f578
[tools/eficas.git] / Noyau / N_JDC.py
1 # coding=utf-8
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    Ce module contient la classe JDC qui sert à interpréter un jeu de commandes
23 """
24
25 # Modules Python
26 import os
27 import string
28 import traceback
29 import types
30 import sys
31 import linecache
32
33 # Modules EFICAS
34 import N_OBJECT
35 import N_CR
36 from N_Exception import AsException, InterruptParsingError
37 from N_ASSD import ASSD
38 from N_info import message, SUPERV
39 from strfunc import get_encoding
40
41
42 MemoryErrorMsg = """MemoryError :
43
44 En général, cette erreur se produit car la mémoire utilisée hors du fortran
45 (jeveux) est importante.
46
47 Causes possibles :
48    - le calcul produit de gros objets Python dans une macro-commande ou
49      dans le jeu de commande lui-même,
50    - le calcul appelle un solveur (MUMPS par exemple) ou un outil externe
51      qui a besoin de mémoire hors jeveux,
52    - utilisation de jeveux dynamique,
53    - ...
54
55 Solution :
56    - distinguer la mémoire limite du calcul (case "Mémoire totale" de astk)
57      de la mémoire réservée à jeveux (case "dont Aster"), le reste étant
58      disponible pour les allocations dynamiques.
59 """
60
61
62 class JDC(N_OBJECT.OBJECT):
63
64     """
65        Cette classe interprete un jeu de commandes fourni sous
66        la forme d'une chaine de caractères
67
68        Attributs de classe :
69
70        Attributs d'instance :
71
72     """
73     nature = "JDC"
74     CR = N_CR.CR
75     exec_init = """
76 import Accas
77 from Accas import _F
78 from Accas import *
79 NONE = None
80 """
81
82     from N_utils import SEP
83
84     def __init__(self, definition=None, procedure=None, cata=None,
85                  cata_ord_dico=None, parent=None,
86                  nom='SansNom', appli=None, context_ini=None, **args):
87         self.procedure = procedure
88         self.definition = definition
89         self.cata = cata
90         if type(self.cata) != types.TupleType and cata != None:
91             self.cata = (self.cata,)
92         self._build_reserved_kw_list()
93         self.cata_ordonne_dico = cata_ord_dico
94         self.nom = nom
95         self.appli = appli
96         self.parent = parent
97         self.context_ini = context_ini
98         # On conserve les arguments supplémentaires. Il est possible de passer
99         # des informations globales au JDC par ce moyen. Il pourrait etre plus
100         # sur de mettre en place le mecanisme des mots-cles pour verifier la
101         # validité des valeurs passées.
102         # Ceci reste à faire
103         # On initialise avec les parametres de la definition puis on
104         # update avec ceux du JDC
105         self.args = self.definition.args
106         self.args.update(args)
107         self.nstep = 0
108         self.nsd = 0
109         self.par_lot = 'OUI'
110         self.par_lot_user = None
111         if definition:
112             self.regles = definition.regles
113             self.code = definition.code
114         else:
115             self.regles = ()
116             self.code = "CODE"
117         #
118         #  Creation de l objet compte rendu pour collecte des erreurs
119         #
120         self.cr = self.CR(debut="CR phase d'initialisation",
121                           fin="fin CR phase d'initialisation")
122         # on met le jdc lui-meme dans le context global pour l'avoir sous
123         # l'etiquette "jdc" dans le fichier de commandes
124         self.g_context = {'jdc': self}
125         # message.debug(SUPERV, "g_context : %s - %s", self.g_context, id(self.g_context))
126         # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
127         # le nom)
128         self.sds_dict = {}
129         self.etapes = []
130         self.index_etapes = {}
131         self.mc_globaux = {}
132         self.current_context = {}
133         self.condition_context = {}
134         self.index_etape_courante = 0
135         self.UserError = "UserError"
136         self.alea = None
137         # permet transitoirement de conserver la liste des étapes
138         self.hist_etape = False
139
140     def compile(self):
141         """
142            Cette methode compile la chaine procedure
143            Si des erreurs se produisent, elles sont consignées dans le
144            compte-rendu self.cr
145         """
146         try:
147             if self.appli != None:
148                 self.appli.affiche_infos(
149                     'Compilation du fichier de commandes en cours ...')
150             # Python 2.7 compile function does not accept unicode filename, so we encode it
151             # with the current locale encoding in order to have a correct
152             # traceback
153             encoded_filename = self.nom.encode(get_encoding())
154             self.proc_compile = compile(
155                 self.procedure, encoded_filename, 'exec')
156         except SyntaxError, e:
157             if CONTEXT.debug:
158                 traceback.print_exc()
159             l = traceback.format_exception_only(SyntaxError, e)
160             self.cr.exception("Compilation impossible : " + string.join(l))
161         except MemoryError, e:
162             self.cr.exception(MemoryErrorMsg)
163         except SystemError, e:
164             erreurs_connues = """
165 Causes possibles :
166  - offset too large : liste trop longue derrière un mot-clé.
167    Solution : liste = (valeurs, ..., )
168               MOT_CLE = *liste,
169 """
170             l = traceback.format_exception_only(SystemError, e)
171             l.append(erreurs_connues)
172             self.cr.exception("Compilation impossible : " + ''.join(l))
173         return
174
175     def exec_compile(self):
176         """
177            Cette méthode execute le jeu de commandes compilé dans le contexte
178            self.g_context de l'objet JDC
179         """
180         CONTEXT.set_current_step(self)
181         # Le module nommage utilise le module linecache pour accéder
182         # au source des commandes du jeu de commandes.
183         # Dans le cas d'un fichier, on accède au contenu de ce fichier
184         # Dans le cas d'une chaine de caractères il faut accéder
185         # aux commandes qui sont dans la chaine
186         import linecache
187         linecache.cache[self.nom] = 0, 0, string.split(
188             self.procedure, '\n'), self.nom
189         try:
190             exec self.exec_init in self.g_context
191             # message.debug(SUPERV, "JDC.exec_compile_1 - len(g_context) = %d",
192             # len(self.g_context.keys()))
193             for obj_cata in self.cata:
194                 if type(obj_cata) == types.ModuleType:
195                     init2 = "from " + obj_cata.__name__ + " import *"
196                     exec init2 in self.g_context
197             # message.debug(SUPERV, "JDC.exec_compile_2 - len(g_context) = %d",
198             # len(self.g_context.keys()))
199
200             # Initialisation du contexte global pour l'évaluation des conditions de BLOC
201             # On utilise une copie de l'initialisation du contexte du jdc
202             self.condition_context = self.g_context.copy()
203
204             # Si l'attribut context_ini n'est pas vide, on ajoute au contexte global
205             # le contexte initial (--> permet d'évaluer un JDC en récupérant un contexte
206             # d'un autre par exemple)
207             if self.context_ini:
208                 self.g_context.update(self.context_ini)
209                 # Update du dictionnaire des concepts
210                 for sdnom, sd in self.context_ini.items():
211                     if isinstance(sd, ASSD):
212                         self.sds_dict[sdnom] = sd
213
214             if self.appli != None:
215                 self.appli.affiche_infos(
216                     'Interprétation du fichier de commandes en cours ...')
217             # On sauve le contexte pour garder la memoire des constantes
218             # En mode edition (EFICAS) ou lors des verifications le contexte
219             # est recalculé
220             # mais les constantes sont perdues
221             self.const_context = self.g_context
222             # message.debug(SUPERV, "pass")
223             exec self.proc_compile in self.g_context
224             # message.debug(SUPERV, "JDC.exec_compile_3 - len(g_context) = %d",
225             # len(self.g_context.keys()))
226
227             CONTEXT.unset_current_step()
228             if self.appli != None:
229                 self.appli.affiche_infos('')
230
231         except InterruptParsingError:
232             # interrupt the command file parsing used by FIN to ignore the end
233             # of the file
234             pass
235
236         except EOFError:
237             # Exception utilise pour interrompre un jeu
238             # de commandes avant la fin
239             # Fonctionnement normal, ne doit pas etre considere comme une
240             # erreur
241             CONTEXT.unset_current_step()
242             self.affiche_fin_exec()
243             self.traiter_fin_exec('commande')
244
245         except AsException, e:
246             # une erreur a ete identifiee
247             if CONTEXT.debug:
248                 traceback.print_exc()
249             # l'exception a été récupérée avant (où, comment ?),
250             # donc on cherche dans le texte
251             txt = str(e)
252             if txt.find('MemoryError') >= 0:
253                 txt = MemoryErrorMsg
254             self.cr.exception(txt)
255             CONTEXT.unset_current_step()
256
257         except NameError, e:
258             etype, value, tb = sys.exc_info()
259             l = traceback.extract_tb(tb)
260             s = traceback.format_exception_only("Erreur de nom", e)[0][:-1]
261             msg = "erreur de syntaxe,  %s ligne %d" % (s, l[-1][1])
262             if CONTEXT.debug:
263                 traceback.print_exc()
264             self.cr.exception(msg)
265             CONTEXT.unset_current_step()
266
267         except self.UserError, exc_val:
268             self.traiter_user_exception(exc_val)
269             CONTEXT.unset_current_step()
270             self.affiche_fin_exec()
271             self.traiter_fin_exec('commande')
272
273         except:
274             # erreur inattendue
275             # sys_exc_typ,sys_exc_value,sys_exc_frame = sys_exc.info()
276             # (tuple de 3 éléments)
277             if CONTEXT.debug:
278                 traceback.print_exc()
279
280             traceback.print_exc()
281
282             exc_typ, exc_val, exc_fr = sys.exc_info()
283             l = traceback.format_exception(exc_typ, exc_val, exc_fr)
284             self.cr.exception(
285                 "erreur non prevue et non traitee prevenir la maintenance " + '\n' + string.join(l))
286             del exc_typ, exc_val, exc_fr
287             CONTEXT.unset_current_step()
288
289     def affiche_fin_exec(self):
290         """
291            Cette methode realise l'affichage final des statistiques de temps
292            apres l'execution de toutes
293            les commandes en mode commande par commande ou par lot
294            Elle doit etre surchargee pour en introduire un
295         """
296         return
297
298     def traiter_fin_exec(self, mode, etape=None):
299         """
300            Cette methode realise un traitement final apres l'execution de toutes
301            les commandes en mode commande par commande ou par lot
302            Par defaut il n'y a pas de traitement. Elle doit etre surchargee
303            pour en introduire un
304         """
305         message.info(SUPERV, "FIN D'EXECUTION %s %s", mode, etape)
306
307     def traiter_user_exception(self, exc_val):
308         """Cette methode realise un traitement sur les exceptions utilisateur
309            Par defaut il n'y a pas de traitement. La méthode doit etre
310            surchargée pour en introduire un.
311         """
312         return
313
314     def register(self, etape):
315         """
316            Cette méthode ajoute etape dans la liste des etapes : self.etapes
317            et retourne un numéro d'enregistrement
318         """
319         self.etapes.append(etape)
320         self.index_etapes[etape] = len(self.etapes) - 1
321         # message.debug(SUPERV, "#%d %s", self.index_etapes[etape], etape.nom)
322         return self.g_register(etape)
323
324     def o_register(self, sd):
325         """
326            Retourne un identificateur pour concept
327         """
328         self.nsd = self.nsd + 1
329         nom = sd.idracine + self.SEP + `self.nsd`
330         return nom
331
332     def g_register(self, etape):
333         """
334             Retourne un identificateur pour etape
335         """
336         self.nstep = self.nstep + 1
337         idetape = etape.idracine + self.SEP + `self.nstep`
338         return idetape
339
340     def create_sdprod(self, etape, nomsd):
341         """
342             Cette methode doit fabriquer le concept produit retourne
343             par l'etape etape et le nommer.
344
345             Elle est appelée à l'initiative de l'etape
346             pendant le processus de construction de cette etape :
347             methode __call__ de la classe CMD (OPER ou MACRO)
348
349             Ce travail est réalisé par le contexte supérieur
350             (etape.parent) car dans certains cas, le concept ne doit
351             pas etre fabriqué mais l'etape doit simplement utiliser
352             un concept préexistant.
353
354             Deux cas possibles :
355                     - Cas 1 : etape.reuse != None : le concept est réutilisé
356                     - Cas 2 : l'étape appartient à une macro qui a déclaré un
357                             concept de sortie qui doit etre produit par cette
358                             etape.
359             Dans le cas du JDC, le deuxième cas ne peut pas se produire.
360         """
361         sd = etape.get_sd_prod()
362         if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None):
363             # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
364             # d un concept. Commande non reentrante ou reuse absent.
365             self.NommerSdprod(sd, nomsd)
366         return sd
367
368     def NommerSdprod(self, sd, sdnom, restrict='non'):
369         """
370             Nomme la SD apres avoir verifie que le nommage est possible : nom
371             non utilise
372             Si le nom est deja utilise, leve une exception
373             Met le concept créé dans le concept global g_context
374         """
375         o = self.sds_dict.get(sdnom, None)
376         if isinstance(o, ASSD):
377             raise AsException("Nom de concept deja defini : %s" % sdnom)
378         if sdnom in self._reserved_kw:
379             raise AsException(
380                 "Nom de concept invalide. '%s' est un mot-clé réservé." % sdnom)
381
382         # Ajoute a la creation (appel de reg_sd).
383         self.sds_dict[sdnom] = sd
384         sd.set_name(sdnom)
385
386         # En plus si restrict vaut 'non', on insere le concept dans le contexte
387         # du JDC
388         if restrict == 'non':
389             self.g_context[sdnom] = sd
390             # message.debug(SUPERV, "g_context[%r] = %s", sdnom, sd)
391
392     def reg_sd(self, sd):
393         """
394             Methode appelee dans l __init__ d un ASSD lors de sa creation
395             pour s enregistrer
396         """
397         return self.o_register(sd)
398
399     def delete_concept_after_etape(self, etape, sd):
400         """
401             Met à jour les étapes du JDC qui sont après etape suite à
402             la disparition du concept sd
403         """
404         # Cette methode est définie dans le noyau mais ne sert que pendant
405         # la phase de creation des etapes et des concepts. Il n'y a aucun
406         # traitement particulier à réaliser.
407         # Dans d'autres conditions, il faut surcharger cette méthode
408         return
409
410     def supprime(self):
411         N_OBJECT.OBJECT.supprime(self)
412         for etape in self.etapes:
413             etape.supprime()
414
415     def clean(self, netapes):
416         """Nettoie les `netapes` dernières étapes de la liste des étapes."""
417         if self.hist_etape:
418             return
419         for i in xrange(netapes):
420             e = self.etapes.pop()
421             jdc = e.jdc
422             parent = e.parent
423             e.supprime()
424             e.parent = parent
425             e.jdc = jdc
426             # message.debug(SUPERV, "JDC.clean - etape = %r - refcount(e) = %d",
427                           # e.nom, sys.getrefcount(e))
428             del self.index_etapes[e]
429
430     def get_file(self, unite=None, fic_origine='', fname=None):
431         """
432             Retourne le nom du fichier correspondant à un numero d'unité
433             logique (entier) ainsi que le source contenu dans le fichier
434         """
435         if self.appli:
436             # Si le JDC est relié à une application maitre, on délègue la
437             # recherche
438             return self.appli.get_file(unite, fic_origine)
439         else:
440             if unite != None:
441                 if os.path.exists("fort." + str(unite)):
442                     fname = "fort." + str(unite)
443             if fname == None:
444                 raise AsException("Impossible de trouver le fichier correspondant"
445                                   " a l unite %s" % unite)
446             if not os.path.exists(fname):
447                 raise AsException("%s n'est pas un fichier existant" % fname)
448             fproc = open(fname, 'r')
449             text = fproc.read()
450             fproc.close()
451             text = text.replace('\r\n', '\n')
452             linecache.cache[fname] = 0, 0, text.split('\n'), fname
453             return fname, text
454
455     def set_par_lot(self, par_lot, user_value=False):
456         """
457         Met le mode de traitement a PAR LOT
458         ou a COMMANDE par COMMANDE
459         en fonction de la valeur du mot cle PAR_LOT et
460         du contexte : application maitre ou pas
461
462         En PAR_LOT='NON', il n'y a pas d'ambiguité.
463         En PAR_LOT='OUI', E_SUPERV positionne l'attribut à 'NON' après la phase
464         d'analyse et juste avant la phase d'exécution.
465         `user_value` : permet de stocker la valeur choisie par l'utilisateur
466         pour l'interroger plus tard (par exemple dans `get_contexte_avant`).
467         """
468         # message.debug(SUPERV, "set par_lot = %r", par_lot)
469         if user_value:
470             self.par_lot_user = par_lot
471         if self.appli == None:
472             # Pas d application maitre
473             self.par_lot = par_lot
474         else:
475             # Avec application maitre
476             self.par_lot = 'OUI'
477
478     def accept(self, visitor):
479         """
480            Cette methode permet de parcourir l'arborescence des objets
481            en utilisant le pattern VISITEUR
482         """
483         visitor.visitJDC(self)
484
485     def interact(self):
486         """
487             Cette methode a pour fonction d'ouvrir un interpreteur
488             pour que l'utilisateur entre des commandes interactivement
489         """
490         CONTEXT.set_current_step(self)
491         try:
492             # Le module nommage utilise le module linecache pour accéder
493             # au source des commandes du jeu de commandes.
494             # Dans le cas d'un fichier, on accède au contenu de ce fichier
495             # Dans le cas de la console interactive, il faut pouvoir accéder
496             # aux commandes qui sont dans le buffer de la console
497             import linecache
498             import code
499             console = code.InteractiveConsole(
500                 self.g_context, filename="<console>")
501             linecache.cache["<console>"] = 0, 0, console.buffer, "<console>"
502             banner = """***********************************************
503 *          Interpreteur interactif %s
504 ***********************************************""" % self.code
505             console.interact(banner)
506         finally:
507             console = None
508             CONTEXT.unset_current_step()
509
510     def get_contexte_avant(self, etape):
511         """
512            Retourne le dictionnaire des concepts connus avant etape
513            On tient compte des commandes qui modifient le contexte
514            comme DETRUIRE ou les macros
515            Si etape == None, on retourne le contexte en fin de JDC
516         """
517         # L'étape courante pour laquelle le contexte a été calculé est
518         # mémorisée dans self.index_etape_courante
519         # XXX on pourrait faire mieux dans le cas PAR_LOT="NON" : en
520         # mémorisant l'étape
521         # courante pendant le processus de construction des étapes.
522         # Si on insère des commandes (par ex, dans EFICAS), il faut préalablement
523         # remettre ce pointeur à 0
524         # message.debug(SUPERV, "g_context : %s", [k for k, v in self.g_context.items() if isinstance(v, ASSD)])
525         # message.debug(SUPERV, "current_context : %s", [k for k, v in
526         # self.current_context.items() if isinstance(v, ASSD)])
527         if self.par_lot_user == 'NON':
528             d = self.current_context = self.g_context.copy()
529             if etape is None:
530                 return d
531             # retirer les sd produites par 'etape'
532             sd_names = [sd.nom for sd in etape.get_created_sd()]
533             # message.debug(SUPERV, "reuse : %s, sdprods : %s", etape.reuse,
534             # sd_names)
535             for nom in sd_names:
536                 try:
537                     del d[nom]
538                 except KeyError:
539                     from warnings import warn
540                     warn(
541                         "concept '%s' absent du contexte de %s" % (
542                             nom, self.nom),
543                         RuntimeWarning, stacklevel=2)
544             return d
545         if etape:
546             index_etape = self.index_etapes[etape]
547         else:
548             index_etape = len(self.etapes)
549         if index_etape >= self.index_etape_courante:
550             # On calcule le contexte en partant du contexte existant
551             d = self.current_context
552             if self.index_etape_courante == 0 and self.context_ini:
553                 d.update(self.context_ini)
554             liste_etapes = self.etapes[self.index_etape_courante:index_etape]
555         else:
556             d = self.current_context = {}
557             if self.context_ini:
558                 d.update(self.context_ini)
559             liste_etapes = self.etapes
560
561         for e in liste_etapes:
562             if e is etape:
563                 break
564             if e.isactif():
565                 e.update_context(d)
566         self.index_etape_courante = index_etape
567         # message.debug(SUPERV, "returns : %s", [k for k, v in d.items() if
568         # isinstance(v, ASSD)])
569         return d
570
571     def get_global_contexte(self):
572         """Retourne "un" contexte global ;-)"""
573         # N'est utilisé que par INCLUDE (sauf erreur).
574         # g_context est remis à {} en PAR_LOT='OUI'. const_context permet
575         # de retrouver ce qui y a été mis par exec_compile.
576         # Les concepts n'y sont pas en PAR_LOT='OUI'. Ils sont ajoutés
577         # par get_global_contexte de la MACRO.
578         d = self.const_context.copy()
579         d.update(self.g_context)
580         return d
581
582     def get_contexte_courant(self, etape_courante=None):
583         """
584            Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
585            de construction) au moment de l'exécution de l'étape courante.
586         """
587         if etape_courante is None:
588             etape_courante = CONTEXT.get_current_step()
589         return self.get_contexte_avant(etape_courante)
590
591     def get_concept(self, nomsd):
592         """
593             Méthode pour récuperer un concept à partir de son nom
594         """
595         co = self.get_contexte_courant().get(nomsd.strip(), None)
596         if not isinstance(co, ASSD):
597             co = None
598         return co
599
600     def get_concept_by_type(self, nomsd, typesd, etape):
601         """
602             Méthode pour récuperer un concept à partir de son nom et de son type.
603             Il aura comme père 'etape'.
604         """
605         assert issubclass(typesd, ASSD), typesd
606         co = typesd(etape=etape)
607         co.set_name(nomsd)
608         co.executed = 1
609         return co
610
611     def del_concept(self, nomsd):
612         """
613            Méthode pour supprimer la référence d'un concept dans le sds_dict.
614            Ne détruire pas le concept (différent de supprime).
615         """
616         try:
617             del self.sds_dict[nomsd.strip()]
618         except:
619             pass
620
621     def get_cmd(self, nomcmd):
622         """
623             Méthode pour recuperer la definition d'une commande
624             donnee par son nom dans les catalogues declares
625             au niveau du jdc
626         """
627         for cata in self.cata:
628             if hasattr(cata, nomcmd):
629                 return getattr(cata, nomcmd)
630
631     def append_reset(self, etape):
632         """
633            Ajoute une etape provenant d'un autre jdc a la liste des etapes
634            et remet à jour la parenté de l'étape et des concepts
635         """
636         self.etapes.append(etape)
637         self.index_etapes[etape] = len(self.etapes) - 1
638         etape.reparent(self)
639         etape.reset_jdc(self)
640
641     def sd_accessible(self):
642         """On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON".
643         """
644         if CONTEXT.debug:
645             print ' `- JDC sd_accessible : PAR_LOT =', self.par_lot
646         return self.par_lot == 'NON'
647
648     def _build_reserved_kw_list(self):
649         """Construit la liste des mots-clés réservés (interdits pour le
650         nommage des concepts)."""
651         self._reserved_kw = set()
652         for cat in self.cata:
653             self._reserved_kw.update(
654                 [kw for kw in dir(cat) if len(kw) <= 8 and kw == kw.upper()])
655         self._reserved_kw.difference_update(
656             ['OPER', 'MACRO', 'BLOC', 'SIMP', 'FACT', 'FORM',
657              'GEOM', 'MCSIMP', 'MCFACT'])