DEBUT();
P1 = 9.8;
-P2 = eeee;
+P2 = 8.8;
P3 = 7;
+_param_5 = P3*P1;
+
+_param_4 = 3.0;
+
#Pas trouve shellpanel
-MAIL=LIRE_MAILLAGE();
+MAIL=LIRE_MAILLAGE(UNITE=P3,);
MAILLA2=LIRE_MAILLAGE(UNITE=20,);
# 'LIRE_MAILLAGE', 'UNITE' --> uniquebasepanel
PHENOMENE='ACOUSTIQUE',
MODELISATION='PLAN',),),);
-MOD=AFFE_MODELE(MAILLAGE=MAILLA2,
+MOD=AFFE_MODELE(MAILLAGE=MAIL,
AFFE=(_F(GROUP_MA='RESSORT',
PHENOMENE='MECANIQUE',
MODELISATION='DIS_T',),
_F(GROUP_MA='MASSES',
PHENOMENE='MECANIQUE',
- MODELISATION='DIS_T',),),);
+ MODELISATION='DIS_T',),
+ _F(TOUT='OUI',
+ PHENOMENE='THERMIQUE',
+ MODELISATION='COQUE',),),);
+
+CARA=AFFE_CARA_ELEM(MODELE=MOD,
+ POUTRE=(_F(GROUP_MA='MA',
+ SECTION='CERCLE',
+ CARA='R',
+ VALE=1.0,),),);
# 'AFFE_MODELE', 'MAILLAGE' --> uniqueassdpanel
# AFFE_MODELE', 'AFFE', 'GROUP_MA' --> plusieursbasepanel
# 'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
VALE_C=(5.0,7.0,9.0,9.0,8.0,7.0,),);
# 'DEFI_FONCTION', 'VALE' --> fonctionpanel
-MATER2=DEFI_MATERIAU(ELAS=_F(E=100000000000.0,
- NU=0.0,),
- ECRO_ASYM_LINE=_F(DC_SIGM_EPSI=0.0,
- SY_C=200000000.0,
- DT_SIGM_EPSI=0.0,
- SY_T=50000000.0,),);
+MATER2=DEFI_MATERIAU(ELAS=(_F(E=100000000000.0,
+ NU=0.0,),),
+ ECRO_ASYM_LINE=(_F(DC_SIGM_EPSI=0.0,
+ SY_C=200000000.0,
+ DT_SIGM_EPSI=0.0,
+ SY_T=50000000.0,),),);
PS1=DEFI_PARA_SENSI(VALE=1.0,);
PS3=DEFI_PARA_SENSI(VALE=1.0,);
CHMAT2=AFFE_MATERIAU(MAILLAGE=MAIL,
- AFFE=_F(TOUT='OUI',
- MATER=MATER2,),);
+ AFFE=(_F(TOUT='OUI',
+ MATER=MATER2,),),);
AAAZ=AFFE_CHAR_THER(MODELE=AFFE1,
- TEMP_IMPO=_F(TOUT='OUI',
- TEMP=0.0,),);
+ TEMP_IMPO=(_F(TOUT='OUI',
+ TEMP=0.0,),),);
TH1=THER_LINEAIRE(MODELE=AFFE1,
CHAM_MATER=CHMAT2,
- EXCIT=_F(CHARGE=AAAZ,),
+ EXCIT=(_F(CHARGE=AAAZ,),),
SENSIBILITE=(PS1,PS2,),);
# 'THER_LINEAIRE', 'SENSIBILITE' --> plusieursassdpanel
ACA1=AFFE_CHAR_ACOU(MODELE=AFFE1,
- PRES_IMPO=_F(TOUT='OUI',
- PRES=('RI',3.0,3.0,),),);
+ PRES_IMPO=(_F(TOUT='OUI',
+ PRES=('RI',3.0,3.0,),),),);
# 'AFFE_CHAR_ACOU', 'PRES_IMPO', 'PRES' --> uniquecomppanel
MACRO_MATR_ASSE(MODELE=AFFE1,
NUME_DDL=CO('DDL1'),
- MATR_ASSE=_F(MATRICE=CO('MAT1'),
- OPTION='RIGI_THER',),);
+ MATR_ASSE=(_F(MATRICE=CO('MAT1'),
+ OPTION='RIGI_THER',),),);
# 'MACRO_MATR_ASSE', 'MATR_ASSE', 'MATRICE' --> uniquesdcopanel
FIN();
VERSION="EFICAS v1.6"
class APPLI:
- def __init__ (self,master,code='ASTER',fichier=None) :
+ def __init__ (self,master,code='ASTER',fichier=None,test=0) :
self.top=master
self.code=code
self.top.protocol("WM_DELETE_WINDOW",self.exitEFICAS)
self.top.title(VERSION + ' pour '+self.code)
self.top.withdraw()
self.initializeTk(master)
+ self.test=test
Pmw.initialise(master)
self.lecture_parametres()
self.format_fichier = Tkinter.StringVar()
self.message=''
self.cree_composants_graphiques()
self.load_appli_composants() # Creation du BUREAU
- splash.fini_splash()
- self.affiche_FAQ()
+ if (self.test == 0):
+ splash.fini_splash()
+ self.affiche_FAQ()
# AY : cas ou le nom du fichier a été passé en argument
if fichier :
fich=str(MakeNomComplet.FILENAME(fichier))
"""
Active la lecture des paramètres standards et utilisateur
"""
- splash._splash.configure(text = "Chargement des paramètres utilisateur")
+ if (self.test == 0):
+ splash._splash.configure(text = "Chargement des paramètres utilisateur")
import configuration
self.CONFIGURATION = configuration.make_config(self,prefs.REPINI)
- bureau
- statusbar
"""
- splash._splash.configure(text = "Chargement de l'IHM")
- splash._splash.configure(text = "Chargement de la menubar")
+ if (self.test == 0):
+ splash._splash.configure(text = "Chargement de l'IHM")
+ splash._splash.configure(text = "Chargement de la menubar")
import menubar
self.menubar=menubar.MENUBAR(self,self.top)
- splash._splash.configure(text = "Chargement de la toolbar")
+ if (self.test == 0):
+ splash._splash.configure(text = "Chargement de la toolbar")
import toolbar
self.toolbar=toolbar.TOOLBAR(self,self.top)
- splash._splash.configure(text = "Chargement de la statusbar")
+ if (self.test == 0):
+ splash._splash.configure(text = "Chargement de la statusbar")
import statusbar
self.statusbar=statusbar.STATUSBAR(self.top)
def load_appli_composants(self):
- splash._splash.configure(text = "Chargement des appli_composants")
+ if (self.test == 0):
+ splash._splash.configure(text = "Chargement des appli_composants")
for mname in self.appli_composants:
self.load_appli_composant(mname)
def affiche_FAQ(self):
import faq
- faq.affiche(self.top)
+ #faq.affiche(self.top)
def affiche_infos(self,message):
self.statusbar.affiche_infos(message)
def __init__(self,appli,parent):
self.parent=parent
self.appli=appli
- splash._splash.configure(text = "Création du bureau")
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Création du bureau")
self.nb = Pmw.NoteBook(self.parent,raisecommand=self.selectJDC)
self.nb.pack(fill='both',expand=1)
self.JDCDisplay_courant=None
# affichage du titre du panneau
self.titre = StringVar()
self.titre.set("FORMULE "+self.node.item.get_nom())
+
+ self.entry_nom = Entry(self.frame_valeur)
Label(self.frame_valeur,textvariable=self.titre,font=Fonte_TITRE).place(relx=0.5,rely=0.,anchor='n')
# création des labels et entries associés aux nom, type retourné, arguments et corps de la FORMULE
+
Label(self.frame_valeur,text= 'Nom de la formule : ').place(relx=0.,rely=0.1)
- self.entry_nom = Entry(self.frame_valeur)
- Label(self.frame_valeur,text= 'Type retourné : ').place(relx=0.,rely=0.25)
- self.option_menu_typ = Pmw.OptionMenu(self.frame_valeur,labelpos='w',
- label_text='',
- items = self.node.item.get_liste_types_autorises())
- self.option_menu_typ.place(relx=0.33,rely=0.23)
Label(self.frame_valeur,text= 'Arguments : ').place(relx=0.,rely=0.40)
self.entry_arg = Entry(self.frame_valeur)
Label(self.frame_valeur,text= 'Expression : ').place(relx=0.,rely=0.65)
self.entry_exp = Entry(self.frame_valeur)
+
# binding sur les entries
self.entry_nom.bind("<Return>",self.verif_nom)
self.entry_arg.bind("<Return>",self.verif_arguments)
# affichage d'une phrase d'aide pour les arguments
aide = """Entrer les arguments sous la forme
-TYPE : VARIABLE séparés par des virgules (,)
-Exemple REEL:INST,ENTIER:COEF """
+de VARIABLES séparées par des virgules (,)
+Exemple X,Y,Z """
Label(self.frame_valeur,text=aide, justify="l").place(relx=0.5,rely=0.47,anchor='n')
self.entry_exp.place(relx=0.35,rely=0.65,relwidth=0.60)
if self.parent.modified == 'n' : self.parent.init_modif()
# on récupère les nouveaux nom, type retourné, arguments et corps de la FORMULE
new_nom = self.entry_nom.get()
- new_typ = self.option_menu_typ.getcurselection()
+ new_typ="REEL"
new_arg = self.entry_arg.get()
new_exp = self.entry_exp.get()
+ self.verif_arguments
+ self.verif_corps
# on essaie de les stocker
test,erreur = self.node.item.save_formule(new_nom,new_typ,new_arg,new_exp)
if test :
nom = self.node.item.get_nom()
if nom != '':
self.entry_nom.insert(END,nom)
- type = self.node.item.get_type()
- if type :
- self.option_menu_typ.invoke(type)
args = self.node.item.get_args()
if args:
self.entry_arg.insert(END,args)
Lance la vérification du corps de formule présent dans entry_exp
"""
new_nom = self.entry_nom.get()
- new_typ = self.option_menu_typ.getcurselection()
+ new_typ="REEL"
new_arg = self.entry_arg.get()
new_exp = self.entry_exp.get()
if new_exp == '':
test,erreur = 0,"Aucune expression fournie !"
else:
- test,erreur = self.node.item.verif_formule((new_nom,new_typ,new_arg,new_exp))
+ test,erreur = self.node.item.verif_formule_python((new_nom,new_typ,new_arg,new_exp))
if not test:
widgets.showerror("Corps de FORMULE invalide",erreur)
Ce nom dépend de la validité de l'objet
"""
if self.object.isactif():
+ self.object.state="modified"
if self.object.isvalid():
return "ast-green-square"
else:
"""
Retourne les arguments de la FORMULE
"""
- args = self.object.arguments
+ args=""
+ for mot in self.object.mc_liste:
+ if mot.nom == 'NOM_PARA':
+ args=mot.valeur
+ break
if args :
- return self.object.arguments[1:-1] #on enlève les parenthèses ouvrante et fermante
- else:
- return None
+ if args[0] == "(" and args[-1] ==")":
+ args=args[1:-1]
+ return args
def get_corps(self):
"""
Retourne le corps de la FORMULE
"""
- return self.object.corps
+ corps=""
+ for mot in self.object.mc_liste:
+ if mot.nom == 'VALE':
+ corps=mot.valeur
+ break
+ return corps
+
def get_liste_types_autorises(self):
"""
- si non, laisse les paramètres anciens de la FORMULE inchangés et
retourne 0
"""
- test,erreur = self.object.verif_formule(formule=(new_nom,new_typ,new_arg,
+ test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
new_exp))
if test :
# la formule est bien correcte : on sauve les nouveaux paramètres
- self.object.update(formule=(new_nom,new_typ,new_arg,new_exp))
+ test=self.object.update_formule_python(formule=(new_nom,new_typ,new_exp,new_arg))
return test,erreur
# ---------------------------------------------------------------------------
"""
return self.object.verif_formule(formule=formule)
+
+ def verif_formule_python(self,formule):
+ """
+ Lance la vérification de FORMULE passée en argument
+ """
+ return self.object.verif_formule_python(formule=formule)
+
import Accas
treeitem =FORMULETreeItem
objet = Accas.FORM_ETAPE
essai_valeur="'" + valeur + "'"
valeurretour,validite= self.object.eval_valeur(essai_valeur)
if hasattr(valeurretour,'__class__'):
- if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ if valeurretour.__class__.__name__ in ('PARAMETRE',):
validite=1
if self.wait_co():
try:
def exitEFICAS(self):
self.bureau.exitEFICAS()
+ def getBureau(self):
+ return self.bureau
+
def browse(self,result):
if result == 'Browse':
self.ulfile = askopenfilename(title="Choix fichier :")
self.bouton_doc=None
self.bouton_com=None
self.bouton_sup=None
- self.frame_eval=None
+ #self.frame_eval=None
self.label=None
self.frame_boutons=None
self.frame_comment=None
if self.parent.modified == 'n' : self.parent.init_modif()
return self.node.append_child("PARAMETRE",'first')
- def ajout_parametre_eval(self,ind='after'):
- """
- Ajoute un paramètre EVAL à l'intérieur du JDC :
- - si ind='after' : l'ajoute après l'objet courant
- - si ind='before' : l'ajoute avant.
- """
- if self.parent.modified == 'n' : self.parent.init_modif()
- return self.node.append_brother("PARAMETRE_EVAL",ind)
+# def ajout_parametre_eval(self,ind='after'):
+# """
+# Ajoute un paramètre EVAL à l'intérieur du JDC :
+# - si ind='after' : l'ajoute après l'objet courant
+# - si ind='before' : l'ajoute avant.
+# """
+# if self.parent.modified == 'n' : self.parent.init_modif()
+# return self.node.append_brother("PARAMETRE_EVAL",ind)
- def ajout_parametre_eval_first(self):
- """
- Ajoute un paramètre EVAL en début de JDC
- """
- if self.parent.modified == 'n' : self.parent.init_modif()
- return self.node.append_child("PARAMETRE_EVAL",'first')
+# def ajout_parametre_eval_first(self):
+# """
+# Ajoute un paramètre EVAL en début de JDC
+# """
+# if self.parent.modified == 'n' : self.parent.init_modif()
+# return self.node.append_child("PARAMETRE_EVAL",'first')
# ------------------------------------------------------------------------
# les frame ...
self.frame_comment = Frame(page,bd=1,relief='raised')
self.frame_param = Frame(page,bd=1,relief='raised')
- self.frame_eval = Frame(page,bd=1,relief='raised')
+ #self.frame_eval = Frame(page,bd=1,relief='raised')
self.frame_boutons = Frame(page,bd=1,relief='raised')
- self.frame_comment.place(relx=0,rely=0,relwidth=1,relheight=0.28)
- self.frame_param.place(relx=0,rely=0.28,relwidth=1,relheight=0.28)
- self.frame_eval.place(relx=0,rely=0.56,relwidth=1,relheight=0.28)
+ self.frame_comment.place(relx=0,rely=0,relwidth=1,relheight=0.40)
+ self.frame_param.place(relx=0,rely=0.40,relwidth=1,relheight=0.40)
+ #self.frame_eval.place(relx=0,rely=0.56,relwidth=1,relheight=0.28)
self.frame_boutons.place(relx=0,rely=0.84,relwidth=1,relheight=0.16)
# remplissage de la frame commentaire
Label(self.frame_comment,text = "Insérer un commentaire :").place(relx=0.1,rely=0.5,anchor='w')
but_param_avant.place(relx=0.6,rely=0.3,anchor='w',relwidth=0.3)
but_param_apres.place(relx=0.6,rely=0.7,anchor='w',relwidth=0.3)
# remplissage de la frame eval
- Label(self.frame_eval,text="Insérer un paramètre EVAL :").place(relx=0.1,rely=0.5,anchor='w')
+ #Label(self.frame_eval,text="Insérer un paramètre EVAL :").place(relx=0.1,rely=0.5,anchor='w')
#Label(self.frame_eval,text='Non encore disponible').place(relx=0.6,rely=0.5,anchor='w')
- but_eval_avant = Button(self.frame_eval,
- text = "AVANT "+self.node.item.get_nom(),
- command = lambda s=self :s.ajout_parametre_eval(ind = 'before'))
- but_eval_apres = Button(self.frame_eval,
- text = "APRES "+self.node.item.get_nom(),
- command = self.ajout_parametre_eval)
- but_eval_avant.place(relx=0.6,rely=0.3,anchor='w',relwidth=0.3)
- but_eval_apres.place(relx=0.6,rely=0.7,anchor='w',relwidth=0.3)
+ #but_eval_avant = Button(self.frame_eval,
+ # text = "AVANT "+self.node.item.get_nom(),
+ # command = lambda s=self :s.ajout_parametre_eval(ind = 'before'))
+ #but_eval_apres = Button(self.frame_eval,
+ # text = "APRES "+self.node.item.get_nom(),
+ # command = self.ajout_parametre_eval)
+ #but_eval_avant.place(relx=0.6,rely=0.3,anchor='w',relwidth=0.3)
+ #but_eval_apres.place(relx=0.6,rely=0.7,anchor='w',relwidth=0.3)
# remplissage de la frame boutons
Button(self.frame_boutons,
text="Commentariser toute la commande",
dans le répertoire Cata
"""
message1 = "Compilation des fichiers Eficas \n\n Veuillez patienter ..."
- splash._splash.configure(text = message1)
+ if self.appli.test == 0 :
+ splash._splash.configure(text = message1)
self.configure_barre(4)
liste_cata_possibles=[]
for catalogue in self.appli.CONFIGURATION.catalogues:
self.fic_cata_c = self.fic_cata + 'c'
self.fic_cata_p = os.path.splitext(self.fic_cata)[0]+'_pickled.py'
- splash._splash.configure(text = "Debut compil cata: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Debut compil cata: %d s" % time.clock())
# compilation éventuelle du catalogue
test = self.compile_cata(self.fic_cata,self.fic_cata_c)
self.update_barre()
- splash._splash.configure(text = "Fin compil cata: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Fin compil cata: %d s" % time.clock())
if not test : showerror("Compilation catalogue","Impossible de compiler le catalogue %s" %self.fic_cata)
# import du catalogue
- splash._splash.configure(text = "Debut import_cata: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Debut import_cata: %d s" % time.clock())
self.cata = self.import_cata(self.fic_cata)
self.update_barre()
- splash._splash.configure(text = "Fin import_cata: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Fin import_cata: %d s" % time.clock())
if not self.cata : showerror("Import du catalogue","Impossible d'importer le catalogue %s" %self.fic_cata)
#
# analyse du catalogue (ordre des mots-clés)
#
- splash._splash.configure(text = "Debut Retrouve_Ordre: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Debut Retrouve_Ordre: %d s" % time.clock())
# Retrouve_Ordre_Cata_Standard fait une analyse textuelle du catalogue
# remplacé par Retrouve_Ordre_Cata_Standard_autre qui utilise une numerotation
# des mots clés à la création
#self.Retrouve_Ordre_Cata_Standard()
self.Retrouve_Ordre_Cata_Standard_autre()
self.update_barre()
- splash._splash.configure(text = "Fin Retrouve_Ordre: %d s" % time.clock())
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Fin Retrouve_Ordre: %d s" % time.clock())
#
# analyse des données liées à l'IHM : UIinfo
#
Réalise l'import du catalogue dont le chemin d'accès est donné par cata
"""
import imp
- splash._splash.configure(text = "Chargement du catalogue")
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Chargement du catalogue")
nom_cata = os.path.splitext(os.path.basename(cata))[0]
rep_cata = os.path.dirname(cata)
sys.path[:0] = [rep_cata]
if self.code != 'ASTER' : return
fic_cata = os.path.join(self.appli.CONFIGURATION.path_cata_dev,'cata_developpeur.py')
message="Chargement catalogue développeur présent dans :\n %s..." % self.appli.CONFIGURATION.path_cata_dev
- splash._splash.configure(text = message,barre='oui')
+ if self.appli.test == 0 :
+ splash._splash.configure(text = message,barre='oui')
cata_dev_ordonne = analyse_cata.analyse_catalogue(self,self.fic_cata)
self.cata_dev_ordonne_cr = cata_dev_ordonne.cr
cata_dev_ordonne_dico = cata_dev_ordonne.entites
"""
if self.code != 'ASTER' : return
message="Chargement catalogue développeur présent dans :\n %s..." % self.appli.CONFIGURATION.path_cata_dev
- splash._splash.configure(text = message,barre='oui')
+ if self.appli.test == 0 :
+ splash._splash.configure(text = message,barre='oui')
cata_dev_ordonne_dico = autre_analyse_cata.analyse_catalogue(self.cata_dev)
self.cata_ordonne_dico.update(cata_dev_ordonne_dico)
self.appli.affiche_infos(" catalogue(s) développeur(s) chargé(s)" )
try:
f = open(self.fic_cata_p)
u = cPickle.Unpickler(f)
- splash._splash.configure(text = "Analyse du catalogue")
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Analyse du catalogue")
self.cata_ordonne_dico = u.load()
f.close()
except :
# ou (le plus probable) s'il a été créé sous un autre OS
self.Get_Ordre_Cata(mode='cata')
elif mode == 'cata':
- splash._splash.configure(text = "Analyse du catalogue",barre='oui')
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Analyse du catalogue",barre='oui')
cata_ordonne = analyse_catalogue.analyse_catalogue(self,self.fic_cata)
self.cata_ordonne_cr = cata_ordonne.cr
self.cata_ordonne_dico = cata_ordonne.entites
if time1 > time2:
try:
# le catalogue doit être recompilé avant d'être importé
- splash._splash.configure(text="Compilation du catalogue\nCela peut prendre plusieurs secondes ...")
+ if self.appli.test == 0 :
+ splash._splash.configure(text="Compilation du catalogue\nCela peut prendre plusieurs secondes ...")
py_compile.compile(cata)
except:
return 0
""" Configure la barre de progression en lui passant comme paramètre le
nombre de commandes du catalogue qui lui sert à déterminer la longueur de son incrément """
try:
- splash._splash.configure(barre='oui',ratio = nbcommandes)
+ if self.appli.test == 0 :
+ splash._splash.configure(barre='oui',ratio = nbcommandes)
except:
pass
def update_barre(self):
""" Update la position de la barre de progression : la fait progresser de son incrément """
try:
- splash._splash.update_barre()
+ if self.appli.test == 0 :
+ splash._splash.update_barre()
except:
pass
return val
l_new_val.append(v)
return tuple(l_new_val)
- else:
+ # PN : commente le print
+ #else:
# on a réussi à évaluer val en autre chose qu'un tuple ...
- print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
- print 'on trouve : ',str(valeur),' de type : ',type(valeur)
+ #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
+ #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
# on retourne val comme une string car on n'a pas su l'interpréter
return val
# 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.
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
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 constitue de
+ # nom de la formule
+ # type retourne
+ # parametres
+ # corps de la fonction
+ def update_formule_python(self,formule):
+ self.build_mc()
+ self.mc_liste=[]
+ if len(formule) < 4 :
+ return O
+ 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]
+ child.valeur = new_valeur
+ child.state = 'modified'
+ self.mc_liste.append(child)
+ i=i+1
+ self.arguments = formule[3]
+ 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.
break
self.set_valid(valid)
-
return self.valid
def update_sdprod(self,cr='non'):
l=[]
nom = obj.get_nom()
if nom == '' : nom = 'sansnom'
- if len(obj.mc_liste)>0:
- l.append(nom + ' = FORMULE(')
- s=obj.type_retourne + ' = ' + "'''" + obj.arguments + ' = ' + obj.corps+"'''"
- l.append(s)
- l.append(');')
- else:
- l.append(nom+' = FORMULE();')
+ l.append(nom + ' = FORMULE(')
+ for v in obj.mc_liste:
+ text=self.generator(v)
+ l.append(v.nom+'='+text)
+ l.append(');')
return l
def generMACRO_ETAPE(self,obj):
