Extensions/parametre_eval.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2017   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 Ce module contient la classe PARAMETRE_EVAL qui sert a definir
  22 des objets parametres qui sont comprehensibles et donc affichables
  23 par EFICAS.
  24 Ces objets sont crees a partir de la modification du fichier de commandes
  25 de l'utilisateur par le parseur de fichiers Python
  26 """
  27 # import de modules Python
  28 from __future__ import absolute_import
  29 from __future__ import print_function
  30 import types,re
  31 import traceback
  32
  33 # import modules Eficas
  34 from . import interpreteur_formule
  35 from Noyau.N_CR import CR
  36 from Extensions.i18n import tr
  37 from . import parametre
  38
  39 pattern_eval       = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
  40
  41 class PARAMETRE_EVAL(parametre.PARAMETRE) :
  42   """
  43   Cette classe permet de creer des objets de type PARAMETRE_EVAL
  44   cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)'''))
  45   qui sont interpretees par le parseur de fichiers Python.
  46   Les objets ainsi crees constituent des parametres evalues pour le jdc
  47   """
  48   nature = 'PARAMETRE_EVAL'
  49   idracine='param_eval'
  50
  51   def __init__(self,nom,valeur=None):
  52     # parent ne peut etre qu'un objet de type JDC
  53     import Accas
  54     self.Accas_EVAL=Accas.EVAL
  55     self.valeur = self.interpreteValeur(valeur)
  56     self.val    = valeur
  57     self.nom = nom
  58     self.jdc = self.parent = CONTEXT.getCurrentStep()
  59     self.definition=self
  60     self.niveau = self.parent.niveau
  61     self.actif=1
  62     self.state='undetermined'
  63     # Ceci est-il indispensable ???
  64     #self.appel = N_utils.calleeWhere(niveau=2)
  65     self.register()
  66
  67   def __repr__(self):
  68     """
  69         Donne un echo de self sous la forme nom = valeur
  70     """
  71     return self.nom+' = '+ repr(self.valeur)
  72
  73   def __str__(self):
  74     """
  75         Retourne le nom du parametre evalue comme representation de self
  76     """
  77     return self.nom
  78
  79   def interpreteValeur(self,val):
  80     """
  81     Essaie d'interpreter val (chaine de caracteres ou None) comme :
  82     une instance de Accas.EVAL
  83     Retourne la valeur interpretee
  84     """
  85     if not val : return None
  86     d={}
  87     val = val.strip()
  88     if val[-1] == ';' : val = val[0:-1]
  89     d['EVAL'] = self.Accas_EVAL
  90     try:
  91         valeur = eval(val,{},d)
  92         return valeur
  93     except:
  94         traceback.print_exc()
  95         print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
  96         return None
  97
  98   def setValeur(self,new_valeur):
  99     """
 100     Remplace la valeur de self par new_valeur interpretee.
 101     """
 102     self.valeur = self.interpreteValeur(new_valeur)
 103     self.val = new_valeur
 104     self.initModif()
 105
 106   def getNom(self) :
 107     """
 108     Retourne le nom du parametre
 109     """
 110     return self.nom
 111
 112   def getValeur(self):
 113     """
 114     Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
 115     """
 116     if self.valeur :
 117         return self.valeur.valeur
 118     else:
 119         return ''
 120
 121   def verifEval(self,exp_eval=None,cr='non'):
 122     """
 123     Cette methode a pour but de verifier si l'expression EVAL
 124     est syntaxiquement correcte.
 125     Retourne :
 126         - un booleen, qui vaut 1 si licite, 0 sinon
 127         - un message d'erreurs ('' si illicite)
 128     """
 129     if not exp_eval:
 130         if self.valeur :
 131             exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets
 132         else:
 133             exp_eval = None
 134     if exp_eval :
 135         # on construit un interpreteur de formule
 136         formule=(self.nom,'',None,exp_eval)
 137         # on recupere la liste des constantes et des autres fonctions predefinies
 138         # et qui peuvent etre utilisees dans le corps de la formule courante
 139         l_ctes,l_form = self.jdc.getParametresFonctionsAvantEtape(self)
 140         # on cree un objet verificateur
 141         verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule,
 142                                                                  constantes = l_ctes,
 143                                                                  fonctions = l_form)
 144         if cr == 'oui' :
 145           if not verificateur.cr.estvide():
 146             self.cr.fatal(verificateur.cr.getMessFatal())
 147         return verificateur.isValid(),''.join(verificateur.cr.crfatal)
 148     else:
 149         # pas d'expression EVAL --> self non valide
 150         if cr == 'oui' :
 151            self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom)
 152         return 0,tr("Le parametre EVAL ne peut valoir None")
 153
 154   def verifNom(self,nom=None,cr='non'):
 155     """
 156     Verifie si le nom passe en argument (si aucun prend le nom courant)
 157     est un nom valide pour un parametre EVAL
 158     Retourne :
 159         - un booleen, qui vaut 1 si nom licite, 0 sinon
 160         - un message d'erreurs ('' si illicite)
 161     """
 162     if not nom :
 163         nom = self.nom
 164     if nom == "" :
 165         if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL"))
 166         return 0,"Pas de nom donne au parametre EVAL"
 167     if len(nom) > 8 :
 168         if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres"))
 169         return 0,"Un nom de parametre ne peut depasser 8 caracteres"
 170     sd = self.parent.getSdAutourEtape(nom,self)
 171     if sd :
 172         if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom)
 173         return 0,"Un concept de nom %s existe deja !" %nom
 174     return 1,''
 175
 176   def verifParametreEval(self,param=None,cr='non'):
 177     """
 178     Verifie la validite du parametre EVAL passe en argument.
 179     Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur)
 180     Si aucun tuple passe, prend les valeurs courantes de l'objet
 181     Retourne :
 182             - un booleen, qui vaut 1 si EVAL licite, 0 sinon
 183             - un message d'erreurs ('' si illicite)
 184     """
 185     if not param :
 186         if self.valeur :
 187             param = (self.nom,self.valeur.valeur)
 188         else:
 189             param = (self.nom,None)
 190     test_nom,erreur_nom   = self.verifNom(param[0],cr=cr)
 191     test_eval,erreur_eval = self.verifEval(param[1],cr=cr)
 192     # test global = produit des tests partiels
 193     test = test_nom*test_eval
 194     # message d'erreurs global = concatenation des messages partiels
 195     erreur = ''
 196     if not test :
 197         for mess in (erreur_nom,erreur_eval):
 198             erreur = erreur+(len(mess) > 0)*'\n'+mess
 199     return test,erreur
 200
 201   def update(self,param):
 202     """
 203     Methode externe.
 204     Met a jour les champs nom, valeur de self
 205     par les nouvelles valeurs passees dans le tuple formule.
 206     On stocke les valeurs SANS verifications.
 207     """
 208     self.initModif()
 209     self.setNom(param[0])
 210     self.setValeur('EVAL("""'+param[1]+'""")')
 211
 212   def isValid(self,cr='non'):
 213     """
 214     Retourne 1 si self est valide, 0 sinon
 215     Un parametre evalue est considere comme valide si :
 216       - il a un nom
 217       - il a une valeur qui est interpretable par l'interpreteur de FORMULEs
 218     """
 219     resu,erreur= self.verifParametreEval(cr=cr)
 220     return resu
 221
 222   def report(self):
 223     """
 224         Genere l'objet rapport (classe CR)
 225     """
 226     self.cr = CR()
 227     self.isValid(cr='oui')
 228     return self.cr
 229
 230   def setNom(self,new_nom):
 231     """
 232     Remplace le nom de self par new_nom
 233     """
 234     self.nom = new_nom
 235
 236