X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Extensions%2Fparametre_eval.py;h=abe71d5cd1dd2bf68fcb97f654fd537e5c7481ae;hb=db67610817b210277c799d3650f895c433d9a798;hp=b45546d90f8db2455eff47e23d96bf5e2399ce5a;hpb=8032f97d8fa3b30348497c1dc96c987aaffce80f;p=tools%2Feficas.git diff --git a/Extensions/parametre_eval.py b/Extensions/parametre_eval.py index b45546d9..abe71d5c 100644 --- a/Extensions/parametre_eval.py +++ b/Extensions/parametre_eval.py @@ -1,54 +1,57 @@ -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2013 EDF R&D # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. # +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# ====================================================================== """ -Ce module contient la classe PARAMETRE_EVAL qui sert à définir -des objets paramètres qui sont compréhensibles et donc affichables +Ce module contient la classe PARAMETRE_EVAL qui sert a definir +des objets parametres qui sont comprehensibles et donc affichables par EFICAS. -Ces objets sont créés à partir de la modification du fichier de commandes +Ces objets sont crees a partir de la modification du fichier de commandes de l'utilisateur par le parseur de fichiers Python """ # import de modules Python -import string,types,re +from __future__ import absolute_import +from __future__ import print_function +import types,re import traceback # import modules Eficas -import Accas -import interpreteur_formule +from . import interpreteur_formule from Noyau.N_CR import CR -import parametre +from Extensions.i18n import tr +from . import parametre pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)') class PARAMETRE_EVAL(parametre.PARAMETRE) : """ - Cette classe permet de créer des objets de type PARAMETRE_EVAL - cad des affectations directes évaluées dans le jeu de commandes - (ex: a=EVAL('''10.*SQRT(25)''')) - qui sont interprétées par le parseur de fichiers Python. - Les objets ainsi créés constituent des paramètres évalués pour le jdc + Cette classe permet de creer des objets de type PARAMETRE_EVAL + cad des affectations directes evaluees dans le jeu de commandes (ex: a=EVAL('''10.*SQRT(25)''')) + qui sont interpretees par le parseur de fichiers Python. + Les objets ainsi crees constituent des parametres evalues pour le jdc """ nature = 'PARAMETRE_EVAL' idracine='param_eval' def __init__(self,nom,valeur=None): - # parent ne peut être qu'un objet de type JDC + # parent ne peut etre qu'un objet de type JDC + import Accas + self.Accas_EVAL=Accas.EVAL self.valeur = self.interprete_valeur(valeur) self.val = valeur self.nom = nom @@ -56,6 +59,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : self.definition=self self.niveau = self.parent.niveau self.actif=1 + self.state='undetermined' # Ceci est-il indispensable ??? #self.appel = N_utils.callee_where(niveau=2) self.register() @@ -64,36 +68,36 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : """ Donne un echo de self sous la forme nom = valeur """ - return self.nom+' = '+ repr(self.valeur) + '\n' + return self.nom+' = '+ repr(self.valeur) def __str__(self): """ - Retourne le nom du paramètre évalué comme représentation de self + Retourne le nom du parametre evalue comme representation de self """ return self.nom def interprete_valeur(self,val): """ - Essaie d'interpréter val (chaîne de caractères ou None) comme : + Essaie d'interpreter val (chaine de caracteres ou None) comme : une instance de Accas.EVAL - Retourne la valeur interprétée + Retourne la valeur interpretee """ if not val : return None d={} - val = string.strip(val) + val = val.strip() if val[-1] == ';' : val = val[0:-1] - d['EVAL'] = Accas.EVAL + d['EVAL'] = self.Accas_EVAL try: valeur = eval(val,{},d) return valeur except: traceback.print_exc() - print "Le texte %s n'est pas celui d'un paramètre évalué" %val + print(("Le texte %s n'est pas celui d'un parametre evalue" %val)) return None def set_valeur(self,new_valeur): """ - Remplace la valeur de self par new_valeur interprétée. + Remplace la valeur de self par new_valeur interpretee. """ self.valeur = self.interprete_valeur(new_valeur) self.val = new_valeur @@ -101,7 +105,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def get_nom(self) : """ - Retourne le nom du paramètre + Retourne le nom du parametre """ return self.nom @@ -116,67 +120,66 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def verif_eval(self,exp_eval=None,cr='non'): """ - Cette méthode a pour but de vérifier si l'expression EVAL + Cette methode a pour but de verifier si l'expression EVAL est syntaxiquement correcte. Retourne : - - un booléen, qui vaut 1 si licite, 0 sinon + - un booleen, qui vaut 1 si licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not exp_eval: if self.valeur : - exp_eval = self.valeur.valeur[3:-3] # on enlève les triples guillemets + exp_eval = self.valeur.valeur[3:-3] # on enleve les triples guillemets else: exp_eval = None if exp_eval : - # on construit un interpréteur de formule + # on construit un interpreteur de formule formule=(self.nom,'',None,exp_eval) - # on récupère la liste des constantes et des autres fonctions prédéfinies - # et qui peuvent être utilisées dans le corps de la formule courante + # on recupere la liste des constantes et des autres fonctions predefinies + # et qui peuvent etre utilisees dans le corps de la formule courante l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self) - # on crée un objet vérificateur + # on cree un objet verificateur verificateur = interpreteur_formule.Interpreteur_Formule(formule=formule, constantes = l_ctes, fonctions = l_form) if cr == 'oui' : if not verificateur.cr.estvide(): self.cr.fatal(verificateur.cr.get_mess_fatal()) - return verificateur.isvalid(),string.join(verificateur.cr.crfatal) + return verificateur.isvalid(),''.join(verificateur.cr.crfatal) else: # pas d'expression EVAL --> self non valide if cr == 'oui' : - self.cr.fatal("Le paramètre EVAL %s ne peut valoir None" % self.nom) - return 0,"Le paramètre EVAL ne peut valoir None" + self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom) + return 0,tr("Le parametre EVAL ne peut valoir None") def verif_nom(self,nom=None,cr='non'): """ - Vérifie si le nom passé en argument (si aucun prend le nom courant) - est un nom valide pour un paramètre EVAL + Verifie si le nom passe en argument (si aucun prend le nom courant) + est un nom valide pour un parametre EVAL Retourne : - - un booléen, qui vaut 1 si nom licite, 0 sinon + - un booleen, qui vaut 1 si nom licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not nom : nom = self.nom if nom == "" : - if cr == 'oui' : self.cr.fatal("Pas de nom donné au paramètre EVAL") - return 0,"Pas de nom donné au paramètre EVAL" + if cr == 'oui' : self.cr.fatal(tr("Pas de nom donne au parametre EVAL")) + return 0,"Pas de nom donne au parametre EVAL" if len(nom) > 8 : - if cr == 'oui' : self.cr.fatal("Un nom de paramètre ne peut dépasser 8 caractères") - return 0,"Un nom de paramètre ne peut dépasser 8 caractères" + if cr == 'oui' : self.cr.fatal(tr("Un nom de parametre ne peut depasser 8 caracteres")) + return 0,"Un nom de parametre ne peut depasser 8 caracteres" sd = self.parent.get_sd_autour_etape(nom,self) if sd : - if cr == 'oui' : self.cr.fatal("Un concept de nom %s existe déjà !" %nom) - return 0,"Un concept de nom %s existe déjà !" %nom + if cr == 'oui' : self.cr.fatal(tr("Un concept de nom %s existe deja !"), nom) + return 0,"Un concept de nom %s existe deja !" %nom return 1,'' def verif_parametre_eval(self,param=None,cr='non'): """ - Vérifie la validité du paramètre EVAL passé en argument. - Ce nouveau paramètre est passé sous la forme d'un tuple : - (nom,valeur) - Si aucun tuple passé, prend les valeurs courantes de l'objet + Verifie la validite du parametre EVAL passe en argument. + Ce nouveau parametre est passe sous la forme d'un tuple : (nom,valeur) + Si aucun tuple passe, prend les valeurs courantes de l'objet Retourne : - - un booléen, qui vaut 1 si EVAL licite, 0 sinon + - un booleen, qui vaut 1 si EVAL licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not param : @@ -188,7 +191,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : test_eval,erreur_eval = self.verif_eval(param[1],cr=cr) # test global = produit des tests partiels test = test_nom*test_eval - # message d'erreurs global = concaténation des messages partiels + # message d'erreurs global = concatenation des messages partiels erreur = '' if not test : for mess in (erreur_nom,erreur_eval): @@ -197,10 +200,10 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def update(self,param): """ - Méthode externe. - Met à jour les champs nom, valeur de self - par les nouvelles valeurs passées dans le tuple formule. - On stocke les valeurs SANS vérifications. + Methode externe. + Met a jour les champs nom, valeur de self + par les nouvelles valeurs passees dans le tuple formule. + On stocke les valeurs SANS verifications. """ self.init_modif() self.set_nom(param[0]) @@ -209,16 +212,16 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) : def isvalid(self,cr='non'): """ Retourne 1 si self est valide, 0 sinon - Un paramètre évalué est considéré comme valide si : - - il a un nom - - il a une valeur qui est interprétable par l'interpréteur de FORMULEs + Un parametre evalue est considere comme valide si : + - il a un nom + - il a une valeur qui est interpretable par l'interpreteur de FORMULEs """ resu,erreur= self.verif_parametre_eval(cr=cr) return resu def report(self): """ - Génère l'objet rapport (classe CR) + Genere l'objet rapport (classe CR) """ self.cr = CR() self.isvalid(cr='oui')