# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# Copyright (C) 2007-2021 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
linecontinueRE = re.compile(r"\\\s*(#.*)?$")
emptyHangingBraces = [0,0,0,0,0]
-class ParserException(Exception): pass
+class parserException(Exception): pass
class FatalError(Exception): pass
#commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
)
""",re.VERBOSE|re.MULTILINE)
-def construit_genea(texte,liste_mc):
+def construitGenea(texte,listeMc):
"""
Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
Realise un filtrage sur les reels :
- Ne garde que les reels pour lesquels str ne donne pas une bonne representation.
- - Ne garde que les reels derriere un argument keyword dont le nom est dans liste_mc
+ - Ne garde que les reels derriere un argument keyword dont le nom est dans listeMc
>>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
... h=_F(x=34.6,y=-1)'''
- >>> construit_genea(s,['a','x'])
+ >>> construitGenea(s,['a','x'])
{0.000213: '21.3e-5'}
"""
d={}
#argument keyword
mot=m[:-1]
else:
- if mot not in liste_mc:continue
+ if mot not in listeMc:continue
#valeur
key=eval(m)
if str(key) != m: d[key]=m
self.texte = ''
pere.l_objets.append(self)
- def set_text(self,texte):
+ def setText(self,texte):
self.texte = texte
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
"""
#s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
#return s
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant le # initial
"""
"""
return self.texte+'\n'
- def get_nb_par(self):
+ def getNbPar(self):
"""
Retourne la difference entre le nombre de parentheses ouvrantes
et le nombre de parentheses fermantes presentes dans self.texte
class AFFECTATION(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
PN et tout commentaire
class COMMANDE_COMMENTARISEE(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant les doubles commentaires
"""
class AFFECTATION_EVAL(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant tout retour chariot
"""
self.l_objets=None
self.appli=None
- def is_affectation(self,texte):
+ def isAffectation(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
Aster, 0 sinon
if m.end() != len(s):return 0
return 1
- def is_eval(self,texte):
+ def isEval(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
dans un jeu de commandes Aster, 0 sinon
else:
return 0
- def is_commande(self,texte):
+ def isCommande(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
Aster, 0 sinon
else:
return 0
- def is_modification_catalogue(self,texte) :
+ def isModificationCatalogue(self,texte) :
if self.pattern_commande.match(texte):
return 1
hangingComments ^= line.count(u"'''") % 2
#print (hangingComments,hangingBraces)
if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
- raise ParserException()
+ raise parserException()
if ligne.strip() == '':
# il s'agit d'un saut de ligne
# on a un objet commentarise a l'interieur d'une commande
# --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
# un commentaire ordinaire
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
elif commande_commentarisee_courante :
# commande_commentarisee en cours : on ajoute la ligne
- commande_commentarisee_courante.append_text(ligne)
+ commande_commentarisee_courante.appendText(ligne)
# on a 2 commandes commentarisees de suite
if pattern_finComments.match(ligne) :
commande_commentarisee_courante = None
else:
# debut de commande commentarisee : on cree un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
- commande_commentarisee_courante.append_text(ligne)
+ commande_commentarisee_courante.appendText(ligne)
#on passe a la ligne suivante
continue
if commande_courante :
# il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
#on l'ajoute au texte de la commande
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
elif commentaire_courant :
# il s'agit de la nieme ligne d'un commentaire entre deux commandes
# --> on ajoute cette ligne au commentaire courant
- commentaire_courant.append_text(ligne)
+ commentaire_courant.appendText(ligne)
else :
# il s'agit d'un nouveau commentaire entre deux commandes
# --> on le cree et il devient le commentaire courant
commentaire_courant = COMMENTAIRE(self)
- commentaire_courant.append_text(ligne)
+ commentaire_courant.appendText(ligne)
#on passe a la ligne suivante
continue
if commande_courante :
#on a une commande en cours. On l'enrichit ou on la termine
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
#la commande est terminee
- self.analyse_reel(commande_courante.texte)
+ self.analyseReel(commande_courante.texte)
commande_courante = None
#on passe a la ligne suivante
if affectation_courante != None :
#poursuite d'une affectation
- affectation_courante.append_text(ligne)
+ affectation_courante.appendText(ligne)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
# il peut s'agir d'une commande ou d'une affectation ...
# ou d'un EVAL !!!
- if self.is_eval(ligne):
+ if self.isEval(ligne):
# --> affectation de type EVAL
if affectation_courante : affectation_courante = None
affectation = AFFECTATION_EVAL(self)
- affectation.append_text(ligne)
+ affectation.appendText(ligne)
#on passe a la ligne suivante
continue
- if self.is_affectation(ligne):
+ if self.isAffectation(ligne):
#print( '--> affectation')
text=ligne
#traitement des commentaires en fin de ligne
if compos > 2:
#commentaire en fin de ligne
#on cree un nouveau commentaire avant le parametre
- COMMENTAIRE(self).append_text(ligne[compos:])
+ COMMENTAIRE(self).appendText(ligne[compos:])
text=ligne[:compos]
#si plusieurs instructions separees par des ; sur la meme ligne
inspos=line.find(u";")
sur la meme ligne : %s", ligne))
affectation_courante = AFFECTATION(self)
- affectation_courante.append_text(text)
+ affectation_courante.appendText(text)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
#on passe a la ligne suivante
continue
- if self.is_commande(ligne):
+ if self.isCommande(ligne):
# --> nouvelle commande
affectation_courante = None
commande_courante = COMMANDE(self)
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
#si la commande est complete, on la termine
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
#la commande est terminee
- self.analyse_reel(commande_courante.texte)
+ self.analyseReel(commande_courante.texte)
commande_courante = None
#on passe a la ligne suivante
continue
i=i+1
return chaine
- def construit_genea(self,texte):
+ def construitGenea(self,texte):
indiceC=0
mot=""
dict_reel_concept={}
# c est un ;
return dict_reel_concept
- def analyse_reel(self,commande) :
+ def analyseReel(self,commande) :
nomConcept=None
# On verifie qu on a bien un OPER
# et pas une MACRO
#nomConcept=epure1.split(u"=")[0]
#index=epure1.find(u"=")
#epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
- #dict_reel_concept=self.construit_genea(epure2)
+ #dict_reel_concept=self.construitGenea(epure2)
if self.appli:
- dict_reel_concept=construit_genea(epure2,self.appli.liste_simp_reel)
+ dict_reel_concept=construitGenea(epure2,self.appli.liste_simp_reel)
else:
dict_reel_concept={}
if nomConcept == "sansnom" :
if len(dict_reel_concept) != 0:
self.appli.dict_reels[nomConcept]=dict_reel_concept
- def get_texte(self,appli=None):
+ def getTexte(self,appli=None):
"""
Retourne le texte issu de l'analyse
"""
for obj in self.l_objets:
txt = txt+str(obj)
#else :
- except ParserException:
+ except parserException:
#Impossible de convertir le texte, on le retourne tel que
txt=self.texte
return txt