X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_FORM_ETAPE.py;h=8318bee39843ac580d89f095b871e4ffcd93a1a0;hb=217a9ce2f303b098ad28d282bb0df2dfeeeed3c2;hp=37323c9a64bcb1c2181079573eede5af71337fbf;hpb=1ef6f82e922819d11fc326c6dfdd578999f7fa5d;p=tools%2Feficas.git diff --git a/Ihm/I_FORM_ETAPE.py b/Ihm/I_FORM_ETAPE.py index 37323c9a..8318bee3 100644 --- a/Ihm/I_FORM_ETAPE.py +++ b/Ihm/I_FORM_ETAPE.py @@ -19,16 +19,17 @@ # """ """ +from __future__ import absolute_import import string,traceback,re identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE) from Extensions.i18n import tr -from I_MACRO_ETAPE import MACRO_ETAPE +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): @@ -37,24 +38,24 @@ 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 type_retourne="REEL" if len(self.mc_liste) > 0: @@ -81,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() @@ -90,17 +91,17 @@ 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] != '(': @@ -110,7 +111,7 @@ class FORM_ETAPE(MACRO_ETAPE): # 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 a in l_arguments : if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant" @@ -118,10 +119,10 @@ class FORM_ETAPE(MACRO_ETAPE): 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 : @@ -129,10 +130,10 @@ class FORM_ETAPE(MACRO_ETAPE): 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, @@ -144,10 +145,10 @@ class FORM_ETAPE(MACRO_ETAPE): 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 : @@ -165,10 +166,10 @@ class FORM_ETAPE(MACRO_ETAPE): 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: @@ -181,11 +182,11 @@ class FORM_ETAPE(MACRO_ETAPE): 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 : @@ -200,7 +201,7 @@ 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): @@ -239,17 +240,17 @@ class FORM_ETAPE(MACRO_ETAPE): 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.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() @@ -283,7 +284,7 @@ class FORM_ETAPE(MACRO_ETAPE): mocles["VALE_C"]=formule[2] for k,v in self.definition.entites.items(): - if not mocles.has_key(k):continue + if not k in mocles : continue child=self.definition.entites[k](None,nom=k,parent=self) child.valeur=mocles[k] child.state = 'modified' @@ -330,10 +331,10 @@ class FORM_ETAPE(MACRO_ETAPE): - sd=concept detruit Fonction : Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse - suite à la disparition du concept sd + 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 vérifier que le concept détruit n'est pas - utilisé dans le corps de la fonction + 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() @@ -343,8 +344,8 @@ class FORM_ETAPE(MACRO_ETAPE): - old_sd=concept remplace - sd = nouveau concept Fonction : - Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas - utilisé dans le corps de la fonction + Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas + utilise dans le corps de la fonction """ self.init_modif()