Ihm/I_FORM_ETAPE.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22 """
  23 import string,traceback
  24
  25 from I_MACRO_ETAPE import MACRO_ETAPE
  26 from Extensions import interpreteur_formule
  27 from Editeur import analyse_catalogue
  28
  29 analyse_catalogue.l_noms_commandes.append('FORM') # déclare le nom FORM à l'analyseur de catalogue
  30
  31
  32 class FORM_ETAPE(MACRO_ETAPE):
  33
  34     interpreteur = interpreteur_formule.Interpreteur_Formule
  35
  36     def McBuild(self):
  37         self.mc_liste=self.build_mc()
  38         # on crée la liste des types autorisés (liste des noms de mots-clés
  39         # simples dans le catalogue de FORMULE)
  40         self.l_types_autorises = self.definition.entites.keys()
  41         # en plus de la construction traditionnelle des fils de self
  42         # il faut pour les FORMULE décortiquer l'expression ...
  43         self.type_retourne,self.arguments,self.corps = self.analyse_formule()
  44
  45
  46     def analyse_formule(self):
  47         """
  48         Cette méthode décortique l'expression de la FORMULE.
  49         Elle retourne 3 valeurs:
  50             - le type retourné par la FORMULE
  51             - les arguments de la FORMULE
  52             - le corps de la FORMULE, cad son expression
  53         """
  54         if len(self.mc_liste) == 0:
  55             # pas de fils pour self --> la FORMULE est incomplète
  56             return None,None,None
  57         child = self.mc_liste[0] # child est un MCSIMP
  58         type_retourne = child.definition.nom
  59         valeur = child.getval()
  60         # c'est dans valeur que se trouvent la liste des arguments et le corps de la fonction
  61         try:
  62             l_args,corps = string.split(valeur,'=',1)
  63         except:
  64             # pas de signe = --> la formule est fausse
  65             return type_retourne,None,None
  66         l_args = string.strip(l_args)
  67         corps = string.strip(corps)
  68         return type_retourne,l_args,corps
  69
  70     def get_nom(self):
  71         """
  72         Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
  73         la string vide sinon
  74         """
  75         if self.sd :
  76             return self.sd.get_name()
  77         else:
  78             return ''
  79
  80     def get_formule(self):
  81         """
  82         Retourne un tuple décrivant la formule :
  83         (nom,type_retourne,arguments,corps)
  84         """
  85         t,a,c = self.analyse_formule()
  86         n = self.get_nom()
  87         return (n,t,a,c)
  88
  89     def verif_arguments(self,arguments = None):
  90         """
  91         Vérifie si les arguments passés en argument (si aucun prend les arguments courants)
  92         sont des arguments valide pour une FORMULE.
  93         Retourne :
  94             - un booléen, qui vaut 1 si arguments licites, 0 sinon
  95             - un message d'erreurs ('' si illicites)
  96         """
  97         if not arguments :
  98             arguments = self.arguments
  99         if not arguments :
 100             return 0,"Une formule doit avoir au minimum un argument"
 101         # il faut au préalable enlever les parenthèses ouvrantes et fermantes
 102         # encadrant les arguments
 103         arguments = string.strip(arguments)
 104         if arguments[0] != '(':
 105             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse ouvrante manquante"
 106         if arguments[-1] != ')':
 107             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse fermante manquante"
 108         # on peut tester la syntaxe de chaque argument maintenant
 109         erreur=''
 110         test = 1
 111         arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante
 112         l_arguments = string.split(arguments,',')
 113         #for argument in l_arguments:
 114         #    argument = string.strip(argument)
 115         #    try:
 116         #       nom=argument
 117         #        typ,nom = string.split(argument,':')
 118         #        #pas de vérification sur le nom de l'argument
 119         #        #vérification du type de l'argument
 120         #        typ = string.strip(typ)
 121         #        if typ not in self.l_types_autorises :
 122         #            test = 0
 123         #            erreur = erreur + "Le type "+typ+" n'est pas un type permis pour "+nom+'\n'
 124         #    except:
 125         #        # l'argument ne respecte pas la syntaxe : typ_arg : nom_arg
 126         #        test = 0
 127         #        erreur = erreur+"Syntaxe argument non valide : "+argument+'\n'
 128         return test,erreur
 129
 130     def verif_corps(self,corps=None,arguments=None):
 131         """
 132         Cette méthode a pour but de vérifier si le corps de la FORMULE
 133         est syntaxiquement correct.
 134         Retourne :
 135             - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon
 136             - un message d'erreurs ('' si illicite)
 137         """
 138         if not corps :
 139             corps = self.corps
 140         if not arguments :
 141             arguments = self.arguments
 142         formule=(self.get_nom(),self.type_retourne,arguments,corps)
 143         # on récupère la liste des constantes et des autres fonctions prédéfinies
 144         # et qui peuvent être utilisées dans le corps de la formule courante
 145         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
 146         # on crée un objet vérificateur
 147         try:
 148             verificateur = self.interpreteur(formule=formule,
 149                                              constantes = l_ctes,
 150                                              fonctions = l_form)
 151         except :
 152             traceback.print_exc()
 153             return 0,"Impossible de réaliser la vérification de la formule"
 154         return verificateur.isvalid(),verificateur.report()
 155
 156     def verif_nom(self,nom=None):
 157         """
 158         Vérifie si le nom passé en argument (si aucun prend le nom courant)
 159         est un nom valide pour une FORMULE.
 160         Retourne :
 161             - un booléen, qui vaut 1 si nom licite, 0 sinon
 162             - un message d'erreurs ('' si illicite)
 163         """
 164         if not nom :
 165             nom = self.get_nom()
 166         if nom == "" :
 167             return 0,"Pas de nom donné à la FORMULE"
 168         if len(nom) > 8 :
 169             return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
 170         if nom[0] > "0" and nom[0] < "9" :
 171             return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
 172         sd = self.parent.get_sd_autour_etape(nom,self)
 173         if sd :
 174             return 0,"Un concept de nom %s existe déjà !" %nom
 175         return 1,''
 176
 177     def verif_type(self,type=None):
 178         """
 179         Vérifie si le type passé en argument (si aucun prend le type courant)
 180         est un type valide pour une FORMULE.
 181         Retourne :
 182             - un booléen, qui vaut 1 si type licite, 0 sinon
 183             - un message d'erreurs ('' si illicite)
 184         """
 185         if not type:
 186             type = self.type_retourne
 187         if not type :
 188             return 0,"Le type de la valeur retournée n'est pas spécifié"
 189         if type not in self.l_types_autorises:
 190             return 0,"Une formule ne peut retourner une valeur de type : %s" %type
 191         return 1,''
 192
 193     def verif_formule(self,formule=None):
 194         """
 195         Vérifie la validité de la formule passée en argument.
 196         Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
 197         Si aucune formule passée, prend les valeurs courantes de la formule
 198         Retourne :
 199             - un booléen, qui vaut 1 si formule licite, 0 sinon
 200             - un message d'erreurs ('' si illicite)
 201         """
 202         if not formule :
 203             formule = (None,None,None,None)
 204         test_nom,erreur_nom = self.verif_nom(formule[0])
 205         test_type,erreur_type = self.verif_type(formule[1])
 206         if formule[2]:
 207             args = '('+formule[2]+')'
 208         else:
 209             args = None
 210         test_arguments,erreur_arguments = self.verif_arguments(args)
 211         test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
 212         # test global = produit des tests partiels
 213         test = test_nom*test_type*test_arguments*test_corps
 214         # message d'erreurs global = concaténation des messages partiels
 215         erreur = ''
 216         if not test :
 217             for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
 218                 erreur = erreur+(len(mess) > 0)*'\n'+mess
 219         return test,erreur
 220
 221     def verif_formule_python(self,formule=None):
 222         """
 223         Pour l instant ne fait qu un compile python
 224         il serait possible d ajouter des tests sur les arguments
 225         ou le type retourne mais ...
 226         """
 227         if not formule :
 228             formule = (None,None,None,None)
 229         test_nom,erreur_nom = self.verif_nom(formule[0])
 230         if formule[2]:
 231             args = '('+formule[2]+')'
 232         else:
 233             args = None
 234         test_arguments,erreur_arguments = self.verif_arguments(args)
 235         corps=formule[3]
 236         erreur_formule= ''
 237         test_formule=1
 238         try :
 239             compile(corps,'<string>','eval')
 240         except :
 241             erreur_formule= "le corps de la formule n'est pas une formule python valide"
 242             test_formule=0
 243         erreur = ''
 244         test = test_nom*test_arguments*test_formule
 245         if not test :
 246             for mess in (erreur_nom,erreur_arguments,erreur_formule):
 247                 erreur = erreur+(len(mess) > 0)*'\n'+mess
 248         return test,erreur
 249
 250
 251     def update(self,formule):
 252         """
 253         Méthode externe.
 254         Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE
 255         par les nouvelles valeurs passées dans le tuple formule.
 256         On stocke les valeurs SANS vérifications.
 257         """
 258         self.type_retourne = formule[1]
 259         self.arguments = '('+formule[2]+')'
 260         self.corps = formule[3]
 261         # il faut ajouter le mot-clé simple correspondant dans mc_liste
 262         # pour cela on utilise la méthode générale build_mc
 263         # du coup on est obligé de modifier le dictionnaire valeur de self ...
 264         self.valeur = {}
 265         self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
 266         self.McBuild()
 267         sd = self.get_sd_prod()
 268         if sd:
 269             sd.nom = formule[0]
 270
 271     # bidouille PN
 272     # Il faut que formule soit constitue de
 273     # nom de la formule
 274     # type retourne
 275     # parametres
 276     # corps de la fonction
 277     def update_formule_python(self,formule):
 278         self.build_mc()
 279         self.mc_liste=[]
 280         if len(formule) < 4 :
 281            return O
 282         i=1
 283         for k,v in self.definition.entites.items():
 284             child=self.definition.entites[k](None,nom=k,parent=self)
 285             new_valeur=formule[i+1]
 286             child.valeur = new_valeur
 287             child.state = 'modified'
 288             self.mc_liste.append(child)
 289             i=i+1
 290         self.arguments = formule[3]
 291         self.corps = formule[2]
 292         self.type_retourne = formule[1]
 293         sd = self.get_sd_prod()
 294         if sd:
 295             sd.nom = formule[0]
 296         self.init_modif()
 297         return 1
 298
 299     def active(self):
 300         """
 301         Rend l'etape courante active.
 302         Il faut ajouter la formule au contexte global du JDC
 303         """
 304         self.actif = 1
 305         nom = self.get_nom()
 306         if nom == '' : return
 307         try:
 308             self.jdc.append_fonction(self.sd)
 309         except:
 310             pass
 311
 312     def inactive(self):
 313         """
 314         Rend l'etape courante inactive
 315         Il faut supprimer la formule du contexte global du JDC
 316         """
 317         self.actif = 0
 318         if not self.sd : return
 319         self.jdc.del_fonction(self.sd)
 320
 321     def delete_concept(self,sd):
 322         """
 323          Inputs :
 324            - sd=concept detruit
 325          Fonction :
 326          Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
 327          suite à la disparition du concept sd
 328          Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
 329          sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
 330          utilisé dans le corps de la fonction
 331         """
 332         self.init_modif()
 333
 334     def replace_concept(self,old_sd,sd):
 335         """
 336          Inputs :
 337            - old_sd=concept remplace
 338            - sd = nouveau concept
 339          Fonction :
 340          Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
 341          utilisé dans le corps de la fonction
 342         """
 343         self.init_modif()
 344