Noyau/N_MACRO.py

   1 #@ MODIF N_MACRO Noyau  DATE 16/05/2007   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 #
  20 #
  21 # ======================================================================
  22
  23
  24 """
  25     Ce module contient la classe de definition MACRO
  26     qui permet de spécifier les caractéristiques d'une macro-commande
  27 """
  28
  29 import types,string,traceback
  30
  31 import N_ENTITE
  32 import N_MACRO_ETAPE
  33 import nommage
  34
  35 class MACRO(N_ENTITE.ENTITE):
  36    """
  37     Classe pour definir une macro-commande
  38
  39     Cette classe a trois attributs de classe
  40
  41     - class_instance qui indique la classe qui devra etre utilisée
  42             pour créer l'objet qui servira à controler la conformité d'un
  43             macro-commande avec sa définition
  44
  45     - label qui indique la nature de l'objet de définition (ici, MACRO)
  46
  47     - nommage qui est un module Python qui fournit la fonctionnalité de nommage
  48
  49     et les attributs d'instance suivants :
  50
  51     - nom   : son nom
  52
  53     - op   : le numéro d'opérateur
  54
  55     - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
  56                       une classe
  57
  58     - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
  59                         réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
  60
  61     - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
  62                         non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
  63                         de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
  64
  65     - fr   : commentaire associé en francais
  66
  67     - ang : commentaire associé en anglais
  68
  69     - docu : clé de documentation associée
  70
  71     - regles : liste des règles associées
  72
  73     - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
  74                       fonction est exécutée lors des phases d'initialisation de l'étape associée.
  75
  76     - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
  77                      rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
  78                      Si niveau vaut None, l'opérateur est rangé au niveau global.
  79
  80     - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
  81                       des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
  82                       est initialisé avec args, c'est à dire les arguments d'appel restants.
  83
  84
  85    """
  86    class_instance = N_MACRO_ETAPE.MACRO_ETAPE
  87    label = 'MACRO'
  88    nommage = nommage
  89
  90    def __init__(self,nom,op,sd_prod=None,reentrant='n',repetable='o',fr="",ang="",
  91                 docu="",regles=(),op_init=None,niveau = None,fichier_ini=0,UIinfo=None,**args):
  92       """
  93          Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser
  94          les attributs de meme nom
  95       """
  96       # XXX fichier_ini n'est pas utilisé pour l'instant
  97       self.nom=nom
  98       # op est obligatoire et permet de spécifier la procédure de construction de la macro
  99       # - Si op est un entier la construction de la macro est réalisée par une subroutine fortran opsxxx ou
 100       # xxx est donné par la valeur absolue de op. L'execution est egalement effectuée via cette subroutine.
 101       # - Si op est une fonction Python, la construction de la macro est effectuée par l'appel à cette fonction
 102       # Suivant le cas on garde l info dans self.op ou dans self.proc
 103       if type(op) == types.IntType:
 104         self.proc=None
 105         self.op=op
 106       else:
 107         self.op=None
 108         self.proc=op
 109
 110       self.sd_prod=sd_prod
 111       self.reentrant=reentrant
 112       self.fr=fr
 113       self.ang=ang
 114       self.repetable = repetable
 115       self.docu=docu
 116       if type(regles)== types.TupleType:
 117           self.regles=regles
 118       else:
 119           self.regles=(regles,)
 120       self.fichier_ini = fichier_ini
 121       # Attribut op_init : Fonction a appeler a la construction de l operateur sauf si == None
 122       self.op_init=op_init
 123       self.entites=args
 124       current_cata=CONTEXT.get_current_cata()
 125       if niveau == None:
 126          self.niveau=None
 127          current_cata.enregistre(self)
 128       else:
 129          self.niveau=current_cata.get_niveau(niveau)
 130          self.niveau.enregistre(self)
 131       self.UIinfo=UIinfo
 132       self.affecter_parente()
 133
 134    def __call__(self,reuse=None,**args):
 135       """
 136           Construit l'objet MACRO_ETAPE a partir de sa definition (self),
 137           puis demande la construction de ses sous-objets et du concept produit.
 138       """
 139       # Glut MC (2007-05) / Sensibilité
 140       # Précaution nécessaire pour la sensibilité (on fait 'exec' du texte d'une commande)
 141       # car on n'a pas de "ligne" à décoder pour trouver le nom du résultat (à gauche
 142       # du signe égal). Cà tombe bien, dans ce cas, sd_prod=None : pas de résultat !
 143       if self.sd_prod != None:
 144          nomsd=self.nommage.GetNomConceptResultat(self.nom)
 145       else:
 146          nomsd = None
 147       etape= self.class_instance(oper=self,reuse=reuse,args=args)
 148       etape.McBuild()
 149       return etape.Build_sd(nomsd)
 150
 151    def make_objet(self,mc_list='oui'):
 152       """
 153            Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans
 154            créer sa sdprod.
 155            Normalement l'étape est enregistrée auprès de son parent.
 156            Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
 157            des objets MCxxx.
 158       """
 159       etape= self.class_instance(oper=self,reuse=None,args={})
 160       if mc_list == 'oui':etape.McBuild()
 161       return etape
 162
 163    def verif_cata(self):
 164       """
 165           Méthode de vérification des attributs de définition
 166       """
 167       if self.op is not None and (type(self.op) != types.IntType or self.op > 0) :
 168         self.cr.fatal("L'attribut 'op' doit etre un entier signé : %s" %`self.op`)
 169       if self.proc is not None and type(self.proc) != types.FunctionType:
 170         self.cr.fatal("L'attribut op doit etre une fonction Python : %s" % `self.proc`)
 171       if type(self.regles) != types.TupleType :
 172         self.cr.fatal("L'attribut 'regles' doit etre un tuple : %s" %`self.regles`)
 173       if type(self.fr) != types.StringType :
 174         self.cr.fatal("L'attribut 'fr' doit etre une chaine de caractères : %s" %`self.fr`)
 175       if type(self.docu) != types.StringType :
 176         self.cr.fatal("L'attribut 'docu' doit etre une chaine de caractères : %s" %`self.docu` )
 177       if type(self.nom) != types.StringType :
 178         self.cr.fatal("L'attribut 'nom' doit etre une chaine de caractères : %s" %`self.nom`)
 179       if self.reentrant not in ('o','n','f'):
 180         self.cr.fatal("L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %s" %`self.reentrant`)
 181       self.verif_cata_regles()
 182
 183    def supprime(self):
 184       """
 185           Méthode pour supprimer les références arrières susceptibles de provoquer
 186           des cycles de références
 187       """
 188       self.niveau=None
 189
 190