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