Extensions/parametre_eval.py

   1 """
   2 Ce module contient la classe PARAMETRE_EVAL qui sert à définir
   3 des objets paramètres qui sont compréhensibles et donc affichables
   4 par EFICAS.
   5 Ces objets sont créés à partir de la modification du fichier de commandes
   6 de l'utilisateur par le parseur de fichiers Python
   7 """
   8 # import de modules Python
   9 import string,types,re
  10 import traceback
  11
  12 # import modules Eficas
  13 import Accas
  14 import interpreteur_formule
  15 from Noyau.N_CR import CR
  16 import parametre
  17
  18 pattern_eval       = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
  19
  20 class PARAMETRE_EVAL(parametre.PARAMETRE) :
  21   """
  22   Cette classe permet de créer des objets de type PARAMETRE_EVAL
  23   cad des affectations directes évaluées dans le jeu de commandes
  24               (ex: a=EVAL('''10.*SQRT(25)'''))
  25   qui sont interprétées par le parseur de fichiers Python.
  26   Les objets ainsi créés constituent des paramètres évalués pour le jdc
  27   """
  28   nature = 'PARAMETRE_EVAL'
  29   idracine='param_eval'
  30
  31   def __init__(self,nom,valeur=None):
  32     # parent ne peut être qu'un objet de type JDC
  33     self.valeur = self.interprete_valeur(valeur)
  34     self.val    = valeur
  35     self.nom = nom
  36     self.jdc = self.parent = CONTEXT.get_current_step()
  37     self.definition=self
  38     self.niveau = self.parent.niveau
  39     # Ceci est-il indispensable ???
  40     #self.appel = N_utils.callee_where(niveau=2)
  41     self.register()
  42
  43   def __repr__(self):
  44     """
  45         Donne un echo de self sous la forme nom = valeur
  46     """
  47     return self.nom+' = '+ repr(self.valeur) + '\n'
  48
  49   def __str__(self):
  50     """
  51         Retourne le nom du paramètre évalué comme représentation de self
  52     """
  53     return self.nom
  54
  55   def interprete_valeur(self,val):
  56     """
  57     Essaie d'interpréter val (chaîne de caractères ou None) comme :
  58     une instance de Accas.EVAL
  59     Retourne la valeur interprétée
  60     """
  61     if not val : return None
  62     d={}
  63     d['EVAL'] = Accas.EVAL
  64     try:
  65         valeur = eval(val,{},d)
  66         return valeur
  67     except:
  68         traceback.print_exc()
  69         print "Le texte %s n'est pas celui d'un paramètre évalué" %val
  70         return None
  71
  72   def set_valeur(self,new_valeur):
  73     """
  74     Remplace la valeur de self par new_valeur interprétée.
  75     """
  76     self.valeur = self.interprete_valeur(new_valeur)
  77     self.val = new_valeur
  78     self.init_modif()
  79
  80   def get_nom(self) :
  81     """
  82     Retourne le nom du paramètre
  83     """
  84     return self.nom
  85
  86   def get_valeur(self):
  87     """
  88     Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
  89     """
  90     if self.valeur :
  91         return self.valeur.valeur
  92     else:
  93         return ''
  94
  95   def verif_eval(self,exp_eval=None,cr='non'):
  96     """
  97     Cette méthode a pour but de vérifier si l'expression EVAL
  98     est syntaxiquement correcte.
  99     Retourne :
 100         - un booléen, qui vaut 1 si licite, 0 sinon
 101         - un message d'erreurs ('' si illicite)
 102     """
 103     if not exp_eval:
 104         if self.valeur :
 105             exp_eval = self.valeur.valeur[3:-3] # on enlève les triples guillemets
 106         else:
 107             exp_eval = None
 108     if exp_eval :
 109         # on construit un interpréteur de formule
 110         formule=(self.nom,'',None,exp_eval)
 111         # on récupère la liste des constantes et des autres fonctions prédéfinies
 112         # et qui peuvent être utilisées dans le corps de la formule courante
 113         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
 114         # on crée un objet vérificateur
 115         verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule,
 116                                                                  constantes = l_ctes,
 117                                                                  fonctions = l_form)
 118         if cr == 'oui' :
 119           if not verificateur.cr.estvide():
 120             self.cr.fatal(verificateur.cr.get_mess_fatal())
 121         return verificateur.isvalid(),string.join(verificateur.cr.crfatal)
 122     else:
 123         # pas d'expression EVAL --> self non valide
 124         if cr == 'oui' :
 125            self.cr.fatal("Le paramètre EVAL %s ne peut valoir None" % self.nom)
 126         return 0,"Le paramètre EVAL ne peut valoir None"
 127
 128   def verif_nom(self,nom=None,cr='non'):
 129     """
 130     Vérifie si le nom passé en argument (si aucun prend le nom courant)
 131     est un nom valide pour un paramètre EVAL
 132     Retourne :
 133         - un booléen, qui vaut 1 si nom licite, 0 sinon
 134         - un message d'erreurs ('' si illicite)
 135     """
 136     if not nom :
 137         nom = self.nom
 138     if nom == "" :
 139         if cr == 'oui' : self.cr.fatal("Pas de nom donné au paramètre EVAL")
 140         return 0,"Pas de nom donné au paramètre EVAL"
 141     if len(nom) > 8 :
 142         if cr == 'oui' : self.cr.fatal("Un nom de paramètre ne peut dépasser 8 caractères")
 143         return 0,"Un nom de paramètre ne peut dépasser 8 caractères"
 144     sd = self.parent.get_sd_autour_etape(nom,self)
 145     if sd :
 146         if cr == 'oui' : self.cr.fatal("Un concept de nom %s existe déjà !" %nom)
 147         return 0,"Un concept de nom %s existe déjà !" %nom
 148     return 1,''
 149
 150   def verif_parametre_eval(self,param=None,cr='non'):
 151     """
 152     Vérifie la validité du paramètre EVAL passé en argument.
 153     Ce nouveau paramètre est passé sous la forme d'un tuple :
 154                 (nom,valeur)
 155     Si aucun tuple passé, prend les valeurs courantes de l'objet
 156     Retourne :
 157             - un booléen, qui vaut 1 si EVAL licite, 0 sinon
 158             - un message d'erreurs ('' si illicite)
 159     """
 160     if not param :
 161         if self.valeur :
 162             param = (self.nom,self.valeur.valeur)
 163         else:
 164             param = (self.nom,None)
 165     test_nom,erreur_nom   = self.verif_nom(param[0],cr=cr)
 166     test_eval,erreur_eval = self.verif_eval(param[1],cr=cr)
 167     # test global = produit des tests partiels
 168     test = test_nom*test_eval
 169     # message d'erreurs global = concaténation des messages partiels
 170     erreur = ''
 171     if not test :
 172         for mess in (erreur_nom,erreur_eval):
 173             erreur = erreur+(len(mess) > 0)*'\n'+mess
 174     return test,erreur
 175
 176   def update(self,param):
 177     """
 178     Méthode externe.
 179     Met à jour les champs nom, valeur de self
 180     par les nouvelles valeurs passées dans le tuple formule.
 181     On stocke les valeurs SANS vérifications.
 182     """
 183     self.init_modif()
 184     self.set_nom(param[0])
 185     self.set_valeur('EVAL("""'+param[1]+'""")')
 186
 187   def isvalid(self,cr='non'):
 188     """
 189     Retourne 1 si self est valide, 0 sinon
 190     Un paramètre évalué est considéré comme valide si :
 191     - il a un nom
 192     - il a une valeur qui est interprétable par l'interpréteur de FORMULEs
 193     """
 194     resu,erreur= self.verif_parametre_eval(cr=cr)
 195     return resu
 196
 197   def report(self):
 198     """
 199         Génère l'objet rapport (classe CR)
 200     """
 201     self.cr = CR()
 202     self.isvalid(cr='oui')
 203     return self.cr
 204
 205   def set_nom(self,new_nom):
 206     """
 207     Remplace le nom de self par new_nom
 208     """
 209     self.nom = new_nom
 210
 211