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