+# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# il faut pour les FORMULE décortiquer 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.
if len(self.mc_liste) == 0:
# pas de fils pour self --> la FORMULE est incomplète
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):
test = 1
arguments = arguments[1:-1] # on enlève les parenthèses 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 argument in l_arguments:
+ # argument = string.strip(argument)
+ # try:
+ # nom=argument
+ # 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'
return test,erreur
def verif_corps(self,corps=None,arguments=None):
return 0,"Pas de nom donné à la FORMULE"
if len(nom) > 8 :
return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
+ if nom[0] > "0" and nom[0] < "9" :
+ return 0,"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
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)
+ 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
Retourne :
- un booléen, qui vaut 1 si formule licite, 0 sinon
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,'<string>','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.
par les nouvelles valeurs passées dans le tuple formule.
On stocke les valeurs SANS vérifications.
"""
- self.init_modif()
self.type_retourne = formule[1]
self.arguments = '('+formule[2]+')'
self.corps = formule[3]
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 O
+ arguments=formule[3]
+ if arguments[0] == '(' :
+ arguments=[1,-1 ]
+ if arguments[-1] == '(' :
+ arguments=[0,-2 ]
+ self.arguments=tuple(arguments.split(','))
+
+ i=1
+ for k,v in self.definition.entites.items():
+ child=self.definition.entites[k](None,nom=k,parent=self)
+ new_valeur=formule[i+1]
+ if i+1 == 3 :
+ child.valeur = self.arguments
+ else :
+ child.valeur = new_valeur
+ child.state = 'modified'
+ self.mc_liste.append(child)
+ i=i+1
+
+ 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.
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - 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
- 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 à 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
"""
self.init_modif()
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplace
- sd = nouveau concept
+ - 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 vérifier que le concept remplacé n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()