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         type_retourne="REEL"
  58         child = self.mc_liste[0] # child est un MCSIMP
  59         corps = child.getval()
  60         child = self.mc_liste[1]
  61         l_args= child.getval()
  62         return type_retourne,l_args,corps
  63
  64     def get_nom(self):
  65         """
  66         Retourne le nom de la FORMULE, cad le nom de la SD si elle existe,
  67         la string vide sinon
  68         """
  69         if self.sd :
  70             return self.sd.get_name()
  71         else:
  72             return ''
  73
  74     def get_formule(self):
  75         """
  76         Retourne un tuple décrivant la formule :
  77         (nom,type_retourne,arguments,corps)
  78         """
  79         t,a,c = self.analyse_formule()
  80         n = self.get_nom()
  81         return (n,t,a,c)
  82
  83     def verif_arguments(self,arguments = None):
  84         """
  85         Vérifie si les arguments passés en argument (si aucun prend les arguments courants)
  86         sont des arguments valide pour une FORMULE.
  87         Retourne :
  88             - un booléen, qui vaut 1 si arguments licites, 0 sinon
  89             - un message d'erreurs ('' si illicites)
  90         """
  91         if not arguments :
  92             arguments = self.arguments
  93         if not arguments :
  94             return 0,"Une formule doit avoir au minimum un argument"
  95         # il faut au préalable enlever les parenthèses ouvrantes et fermantes
  96         # encadrant les arguments
  97         arguments = string.strip(arguments)
  98         if arguments[0] != '(':
  99             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse ouvrante manquante"
 100         if arguments[-1] != ')':
 101             return 0,"La liste des arguments d'une formule doit être entre parenthèses : parenthèse fermante manquante"
 102         # on peut tester la syntaxe de chaque argument maintenant
 103         erreur=''
 104         test = 1
 105         arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante
 106         l_arguments = string.split(arguments,',')
 107         #for argument in l_arguments:
 108         #    argument = string.strip(argument)
 109         #    try:
 110         #       nom=argument
 111         #        typ,nom = string.split(argument,':')
 112         #        #pas de vérification sur le nom de l'argument
 113         #        #vérification du type de l'argument
 114         #        typ = string.strip(typ)
 115         #        if typ not in self.l_types_autorises :
 116         #            test = 0
 117         #            erreur = erreur + "Le type "+typ+" n'est pas un type permis pour "+nom+'\n'
 118         #    except:
 119         #        # l'argument ne respecte pas la syntaxe : typ_arg : nom_arg
 120         #        test = 0
 121         #        erreur = erreur+"Syntaxe argument non valide : "+argument+'\n'
 122         return test,erreur
 123
 124     def verif_corps(self,corps=None,arguments=None):
 125         """
 126         Cette méthode a pour but de vérifier si le corps de la FORMULE
 127         est syntaxiquement correct.
 128         Retourne :
 129             - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon
 130             - un message d'erreurs ('' si illicite)
 131         """
 132         if not corps :
 133             corps = self.corps
 134         if not arguments :
 135             arguments = self.arguments
 136         formule=(self.get_nom(),self.type_retourne,arguments,corps)
 137         # on récupère la liste des constantes et des autres fonctions prédéfinies
 138         # et qui peuvent être utilisées dans le corps de la formule courante
 139         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
 140         # on crée un objet vérificateur
 141         try:
 142             verificateur = self.interpreteur(formule=formule,
 143                                              constantes = l_ctes,
 144                                              fonctions = l_form)
 145         except :
 146             traceback.print_exc()
 147             return 0,"Impossible de réaliser la vérification de la formule"
 148         return verificateur.isvalid(),verificateur.report()
 149
 150     def verif_nom(self,nom=None):
 151         """
 152         Vérifie si le nom passé en argument (si aucun prend le nom courant)
 153         est un nom valide pour une FORMULE.
 154         Retourne :
 155             - un booléen, qui vaut 1 si nom licite, 0 sinon
 156             - un message d'erreurs ('' si illicite)
 157         """
 158         if not nom :
 159             nom = self.get_nom()
 160         if nom == "" :
 161             return 0,"Pas de nom donné à la FORMULE"
 162         if len(nom) > 8 :
 163             return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
 164         if nom[0] > "0" and nom[0] < "9" :
 165             return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
 166         sd = self.parent.get_sd_autour_etape(nom,self)
 167         if sd :
 168             return 0,"Un concept de nom %s existe déjà !" %nom
 169         return 1,''
 170
 171     def verif_type(self,type=None):
 172         """
 173         Vérifie si le type passé en argument (si aucun prend le type courant)
 174         est un type valide pour une FORMULE.
 175         Retourne :
 176             - un booléen, qui vaut 1 si type licite, 0 sinon
 177             - un message d'erreurs ('' si illicite)
 178         """
 179         if not type:
 180             type = self.type_retourne
 181         if not type :
 182             return 0,"Le type de la valeur retournée n'est pas spécifié"
 183         if type not in self.l_types_autorises:
 184             return 0,"Une formule ne peut retourner une valeur de type : %s" %type
 185         return 1,''
 186
 187     def verif_formule(self,formule=None):
 188         """
 189         Vérifie la validité de la formule passée en argument.
 190         Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
 191         Si aucune formule passée, prend les valeurs courantes de la formule
 192         Retourne :
 193             - un booléen, qui vaut 1 si formule licite, 0 sinon
 194             - un message d'erreurs ('' si illicite)
 195         """
 196         if not formule :
 197             formule = (None,None,None,None)
 198         test_nom,erreur_nom = self.verif_nom(formule[0])
 199         test_type,erreur_type = self.verif_type(formule[1])
 200         if formule[2]:
 201             args = '('+formule[2]+')'
 202         else:
 203             args = None
 204         test_arguments,erreur_arguments = self.verif_arguments(args)
 205         test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
 206         # test global = produit des tests partiels
 207         test = test_nom*test_type*test_arguments*test_corps
 208         # message d'erreurs global = concaténation des messages partiels
 209         erreur = ''
 210         if not test :
 211             for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
 212                 erreur = erreur+(len(mess) > 0)*'\n'+mess
 213         return test,erreur
 214
 215     def verif_formule_python(self,formule=None):
 216         """
 217         Pour l instant ne fait qu un compile python
 218         il serait possible d ajouter des tests sur les arguments
 219         ou le type retourne mais ...
 220         """
 221         if not formule :
 222             formule = (None,None,None,None)
 223         test_nom,erreur_nom = self.verif_nom(formule[0])
 224         if formule[2]:
 225             args = '('+formule[2]+')'
 226         else:
 227             args = None
 228         test_arguments,erreur_arguments = self.verif_arguments(args)
 229         corps=formule[3]
 230         erreur_formule= ''
 231         test_formule=1
 232         try :
 233             compile(corps,'<string>','eval')
 234         except :
 235             erreur_formule= "le corps de la formule n'est pas une formule python valide"
 236             test_formule=0
 237         erreur = ''
 238         test = test_nom*test_arguments*test_formule
 239         if not test :
 240             for mess in (erreur_nom,erreur_arguments,erreur_formule):
 241                 erreur = erreur+(len(mess) > 0)*'\n'+mess
 242         return test,erreur
 243
 244
 245     def update(self,formule):
 246         """
 247         Méthode externe.
 248         Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE
 249         par les nouvelles valeurs passées dans le tuple formule.
 250         On stocke les valeurs SANS vérifications.
 251         """
 252         self.type_retourne = formule[1]
 253         self.arguments = '('+formule[2]+')'
 254         self.corps = formule[3]
 255         # il faut ajouter le mot-clé simple correspondant dans mc_liste
 256         # pour cela on utilise la méthode générale build_mc
 257         # du coup on est obligé de modifier le dictionnaire valeur de self ...
 258         self.valeur = {}
 259         self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
 260         self.McBuild()
 261         sd = self.get_sd_prod()
 262         if sd:
 263             sd.nom = formule[0]
 264
 265     # bidouille PN
 266     # Il faut que formule soit constituee de
 267     # nom de la formule
 268     # type retourne
 269     # parametres
 270     # corps de la fonction
 271     # il faut aussi que les arguments soient sous forme de tuple
 272     def update_formule_python(self,formule):
 273         self.build_mc()
 274         self.mc_liste=[]
 275         if len(formule) < 4 :
 276            return O
 277         arguments=formule[3]
 278         if arguments[0] == '(' :
 279            arguments=[1,-1 ]
 280         if arguments[-1] == '(' :
 281            arguments=[0,-2 ]
 282         self.arguments=tuple(arguments.split(','))
 283
 284         i=1
 285         for k,v in self.definition.entites.items():
 286             child=self.definition.entites[k](None,nom=k,parent=self)
 287             new_valeur=formule[i+1]
 288             if i+1 == 3 :
 289                child.valeur = self.arguments
 290             else :
 291                child.valeur = new_valeur
 292             child.state = 'modified'
 293             self.mc_liste.append(child)
 294             i=i+1
 295
 296         self.corps = formule[2]
 297         self.type_retourne = formule[1]
 298         sd = self.get_sd_prod()
 299         if sd:
 300             sd.nom = formule[0]
 301         self.init_modif()
 302         return 1
 303
 304     def active(self):
 305         """
 306         Rend l'etape courante active.
 307         Il faut ajouter la formule au contexte global du JDC
 308         """
 309         self.actif = 1
 310         nom = self.get_nom()
 311         if nom == '' : return
 312         try:
 313             self.jdc.append_fonction(self.sd)
 314         except:
 315             pass
 316
 317     def inactive(self):
 318         """
 319         Rend l'etape courante inactive
 320         Il faut supprimer la formule du contexte global du JDC
 321         """
 322         self.actif = 0
 323         if not self.sd : return
 324         self.jdc.del_fonction(self.sd)
 325
 326     def delete_concept(self,sd):
 327         """
 328          Inputs :
 329            - sd=concept detruit
 330          Fonction :
 331          Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
 332          suite à la disparition du concept sd
 333          Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
 334          sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
 335          utilisé dans le corps de la fonction
 336         """
 337         self.init_modif()
 338
 339     def replace_concept(self,old_sd,sd):
 340         """
 341          Inputs :
 342            - old_sd=concept remplace
 343            - sd = nouveau concept
 344          Fonction :
 345          Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
 346          utilisé dans le corps de la fonction
 347         """
 348         self.init_modif()
 349