X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_FORM_ETAPE.py;h=8318bee39843ac580d89f095b871e4ffcd93a1a0;hb=217a9ce2f303b098ad28d282bb0df2dfeeeed3c2;hp=80689be47b094e2a2a9f7cb867c448fded02386b;hpb=8032f97d8fa3b30348497c1dc96c987aaffce80f;p=tools%2Feficas.git diff --git a/Ihm/I_FORM_ETAPE.py b/Ihm/I_FORM_ETAPE.py index 80689be4..8318bee3 100644 --- a/Ihm/I_FORM_ETAPE.py +++ b/Ihm/I_FORM_ETAPE.py @@ -1,31 +1,35 @@ -# 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 # -# ====================================================================== """ """ -import string,traceback +from __future__ import absolute_import +import string,traceback,re +identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE) + -from I_MACRO_ETAPE import MACRO_ETAPE +from Extensions.i18n import tr +from .I_MACRO_ETAPE import MACRO_ETAPE from Extensions import interpreteur_formule from Editeur import analyse_catalogue -analyse_catalogue.l_noms_commandes.append('FORM') # déclare le nom FORM à l'analyseur de catalogue +analyse_catalogue.l_noms_commandes.append('FORM') # declare le nom FORM a l'analyseur de catalogue class FORM_ETAPE(MACRO_ETAPE): @@ -34,35 +38,36 @@ class FORM_ETAPE(MACRO_ETAPE): def McBuild(self): self.mc_liste=self.build_mc() - # on crée la liste des types autorisés (liste des noms de mots-clés + # on cree la liste des types autorises (liste des noms de mots-cles # simples dans le catalogue de FORMULE) - self.l_types_autorises = self.definition.entites.keys() + self.l_types_autorises = list(self.definition.entites.keys()) # en plus de la construction traditionnelle des fils de self - # il faut pour les FORMULE décortiquer l'expression ... + # il faut pour les FORMULE decortiquer l'expression ... self.type_retourne,self.arguments,self.corps = self.analyse_formule() + def analyse_formule(self): """ - Cette méthode décortique l'expression de la FORMULE. + Cette methode decortique l'expression de la FORMULE. Elle retourne 3 valeurs: - - le type retourné par la FORMULE + - le type retourne par la FORMULE - les arguments de la FORMULE - le corps de la FORMULE, cad son expression """ if len(self.mc_liste) == 0: - # pas de fils pour self --> la FORMULE est incomplète + # pas de fils pour self --> la FORMULE est incomplete return None,None,None - child = self.mc_liste[0] # child est un MCSIMP - type_retourne = child.definition.nom - valeur = child.getval() - # c'est dans valeur que se trouvent la liste des arguments et le corps de la fonction - try: - l_args,corps = string.split(valeur,'=',1) - except: - # pas de signe = --> la formule est fausse - return type_retourne,None,None - l_args = string.strip(l_args) - corps = string.strip(corps) + type_retourne="REEL" + if len(self.mc_liste) > 0: + child = self.mc_liste[0] # child est un MCSIMP + corps = child.getval() + else: + corps = None + if len(self.mc_liste) > 1: + child = self.mc_liste[1] + l_args= child.getval() + else : + l_args=None return type_retourne,l_args,corps def get_nom(self): @@ -77,7 +82,7 @@ class FORM_ETAPE(MACRO_ETAPE): def get_formule(self): """ - Retourne un tuple décrivant la formule : + Retourne un tuple decrivant la formule : (nom,type_retourne,arguments,corps) """ t,a,c = self.analyse_formule() @@ -86,113 +91,102 @@ class FORM_ETAPE(MACRO_ETAPE): def verif_arguments(self,arguments = None): """ - Vérifie si les arguments passés en argument (si aucun prend les arguments courants) + Verifie si les arguments passes en argument (si aucun prend les arguments courants) sont des arguments valide pour une FORMULE. Retourne : - - un booléen, qui vaut 1 si arguments licites, 0 sinon + - un booleen, qui vaut 1 si arguments licites, 0 sinon - un message d'erreurs ('' si illicites) """ if not arguments : arguments = self.arguments if not arguments : return 0,"Une formule doit avoir au minimum un argument" - # il faut au préalable enlever les parenthèses ouvrantes et fermantes + # il faut au prealable enlever les parentheses ouvrantes et fermantes # encadrant les arguments arguments = string.strip(arguments) if arguments[0] != '(': - return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse ouvrante manquante" + return 0,tr("La liste des arguments d'une formule doit etre entre parentheses : parenthese ouvrante manquante") if arguments[-1] != ')': - return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse fermante manquante" + return 0,tr("La liste des arguments d'une formule doit etre entre parentheses : parenthese fermante manquante") # on peut tester la syntaxe de chaque argument maintenant erreur='' test = 1 - arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante + arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante l_arguments = string.split(arguments,',') - for argument in l_arguments: - argument = string.strip(argument) - try: - typ,nom = string.split(argument,':') - # pas de vérification sur le nom de l'argument - # vérification du type de l'argument - typ = string.strip(typ) - if typ not in self.l_types_autorises : - test = 0 - erreur = erreur + "Le type "+typ+" n'est pas un type permis pour "+nom+'\n' - except: - # l'argument ne respecte pas la syntaxe : typ_arg : nom_arg - test = 0 - erreur = erreur+"Syntaxe argument non valide : "+argument+'\n' + for a in l_arguments : + if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant" return test,erreur def verif_corps(self,corps=None,arguments=None): """ - Cette méthode a pour but de vérifier si le corps de la FORMULE + Cette methode a pour but de verifier si le corps de la FORMULE est syntaxiquement correct. Retourne : - - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon + - un booleen, qui vaut 1 si corps de FORMULE licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not corps : corps = self.corps - if not arguments : - arguments = self.arguments + if not arguments : + arguments = self.arguments formule=(self.get_nom(),self.type_retourne,arguments,corps) - # 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 try: verificateur = self.interpreteur(formule=formule, constantes = l_ctes, fonctions = l_form) except : traceback.print_exc() - return 0,"Impossible de réaliser la vérification de la formule" + return 0,tr("Impossible de realiser la verification de la formule") return verificateur.isvalid(),verificateur.report() def verif_nom(self,nom=None): """ - Vérifie si le nom passé en argument (si aucun prend le nom courant) + Verifie si le nom passe en argument (si aucun prend le nom courant) est un nom valide pour une FORMULE. 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.get_nom() if nom == "" : - return 0,"Pas de nom donné à la FORMULE" + return 0,tr("Pas de nom donne a la FORMULE") if len(nom) > 8 : - return 0,"Un nom de FORMULE ne peut dépasser 8 caractères" + return 0,tr("Un nom de FORMULE ne peut depasser 8 caracteres") + if nom[0] > "0" and nom[0] < "9" : + return 0,tr("Un nom de FORMULE ne peut pas commencer par un chiffre") sd = self.parent.get_sd_autour_etape(nom,self) if sd : - return 0,"Un concept de nom %s existe déjà !" %nom + return 0,tr("Un concept de nom %s existe deja !" %nom) return 1,'' def verif_type(self,type=None): """ - Vérifie si le type passé en argument (si aucun prend le type courant) + Verifie si le type passe en argument (si aucun prend le type courant) est un type valide pour une FORMULE. Retourne : - - un booléen, qui vaut 1 si type licite, 0 sinon + - un booleen, qui vaut 1 si type licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not type: type = self.type_retourne if not type : - return 0,"Le type de la valeur retournée n'est pas spécifié" + return 0,tr("Le type de la valeur retournee n'est pas specifie") if type not in self.l_types_autorises: - return 0,"Une formule ne peut retourner une valeur de type : %s" %type + return 0,tr("Une formule ne peut retourner une valeur de type : %s" %type) return 1,'' def verif_formule(self,formule=None): """ - Vérifie la validité de la formule passée en argument. - Cette nouvelle formule est passée sous la forme d'un tuple : - (nom,type_retourne,arguments,corps) - Si aucune formule passée, prend les valeurs courantes de la formule + Verifie la validite de la formule passee en argument. + Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps) + Si aucune formule passee, prend les valeurs courantes de la formule Retourne : - - un booléen, qui vaut 1 si formule licite, 0 sinon + - un booleen, qui vaut 1 si formule licite, 0 sinon - un message d'erreurs ('' si illicite) """ if not formule : @@ -207,27 +201,56 @@ class FORM_ETAPE(MACRO_ETAPE): test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args) # test global = produit des tests partiels test = test_nom*test_type*test_arguments*test_corps - # 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_type,erreur_arguments,erreur_corps): erreur = erreur+(len(mess) > 0)*'\n'+mess return test,erreur + def verif_formule_python(self,formule=None): + """ + Pour l instant ne fait qu un compile python + il serait possible d ajouter des tests sur les arguments + ou le type retourne mais ... + """ + if not formule : + formule = (None,None,None,None) + test_nom,erreur_nom = self.verif_nom(formule[0]) + if formule[2]: + args = '('+formule[2]+')' + else: + args = None + test_arguments,erreur_arguments = self.verif_arguments(args) + corps=formule[3] + erreur_formule= '' + test_formule=1 + try : + compile(corps,'','eval') + except : + erreur_formule= "le corps de la formule n'est pas une formule python valide" + test_formule=0 + erreur = '' + test = test_nom*test_arguments*test_formule + if not test : + for mess in (erreur_nom,erreur_arguments,erreur_formule): + erreur = erreur+(len(mess) > 0)*'\n'+mess + return test,erreur + + def update(self,formule): """ - Méthode externe. - Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE - 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, type_retourne,arguments et corps de la FORMULE + par les nouvelles valeurs passees dans le tuple formule. + On stocke les valeurs SANS verifications. """ - self.init_modif() self.type_retourne = formule[1] self.arguments = '('+formule[2]+')' self.corps = formule[3] - # il faut ajouter le mot-clé simple correspondant dans mc_liste - # pour cela on utilise la méthode générale build_mc - # du coup on est obligé de modifier le dictionnaire valeur de self ... + # il faut ajouter le mot-cle simple correspondant dans mc_liste + # pour cela on utilise la methode generale build_mc + # du coup on est oblige de modifier le dictionnaire valeur de self ... self.valeur = {} self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps self.McBuild() @@ -235,12 +258,53 @@ class FORM_ETAPE(MACRO_ETAPE): if sd: sd.nom = formule[0] + # bidouille PN + # Il faut que formule soit constituee de + # nom de la formule + # type retourne + # parametres + # corps de la fonction + # il faut aussi que les arguments soient sous forme de tuple + def update_formule_python(self,formule): + self.build_mc() + self.mc_liste=[] + if len(formule) < 4 : + return 0 + arguments=formule[3] + if arguments[0] == '(' : + arguments=arguments[1:] + if arguments[-1] == ')' : + arguments=arguments[:-1] + self.arguments=tuple(arguments.split(',')) + + mocles={"NOM_PARA":self.arguments} + if formule[1] == "REEL": + mocles["VALE"]=formule[2] + if formule[1] == "COMPLEXE": + mocles["VALE_C"]=formule[2] + + for k,v in self.definition.entites.items(): + if not k in mocles : continue + child=self.definition.entites[k](None,nom=k,parent=self) + child.valeur=mocles[k] + child.state = 'modified' + self.mc_liste.append(child) + + self.corps = formule[2] + self.type_retourne = formule[1] + sd = self.get_sd_prod() + if sd: + sd.nom = formule[0] + self.init_modif() + return 1 + def active(self): """ Rend l'etape courante active. Il faut ajouter la formule au contexte global du JDC """ self.actif = 1 + self.init_modif() nom = self.get_nom() if nom == '' : return try: @@ -254,19 +318,34 @@ class FORM_ETAPE(MACRO_ETAPE): Il faut supprimer la formule du contexte global du JDC """ self.actif = 0 + self.init_modif() if not self.sd : return self.jdc.del_fonction(self.sd) + def update_concept(self,sd): + return + def delete_concept(self,sd): """ Inputs : - sd=concept detruit + - sd=concept detruit Fonction : - Mettre a jour les mos cles de l etape et eventuellement le concept produit si reuse - suite à la disparition du concept sd - Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils, - sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas - utilisé dans le corps de la fonction + Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse + suite a la disparition du concept sd + Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils, + sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas + utilise dans le corps de la fonction """ self.init_modif() + def replace_concept(self,old_sd,sd): + """ + Inputs : + - old_sd=concept remplace + - sd = nouveau concept + Fonction : + Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas + utilise dans le corps de la fonction + """ + self.init_modif() +