Ihm/I_FORM_ETAPE.py

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