import convert
plugins=pluginloader.PluginLoader(convert)
-
#
from __future__ import absolute_import
from __future__ import print_function
-try :
- from future import standard_library
- standard_library.install_aliases()
+try :
+ from future import standard_library
+ standard_library.install_aliases()
except :
- pass
-try :
- from builtins import str
+ pass
+try :
+ from builtins import str
except :
- pass
+ pass
from builtins import object
import sys,re,tokenize
import io
# le diese n'est pas sur le premier caractere
amont,aval = texte.split('#',1) # on decoupe suivant la premiere occurrence de #
self.texte = self.texte +amont + aval
-
+
class AFFECTATION(ENTITE_JDC):
def appendText(self,texte):
Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
"""
self.texte = self.texte+texte
-
+
def __str__(self):
"""
Retourne une expression de l'affectation comprehensible par ACCAS
"""
return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
-
+
next = {}
next['if'] = next['elif'] = 'elif', 'else', 'end'
next['while'] = next['for'] = 'else', 'end'
class PARSEUR_PYTHON(object):
"""
- Cette classe sert a creer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ Cette classe sert a creer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
representant un JDC Python en distinguant :
- les commentaires inter commandes
- les affectations
def getOptions(self):
m= self.optionprog.match(self.line)
if m:
- option=m.group(1)
- name=option[1:]
- flag=(option[0] == '+')
- if name == "affectation": self.affectation_flag=flag
- if name == "comment": self.comment_flag=flag
- if name == "all":
- self.comment_flag=flag
- self.affectation_flag=flag
+ option=m.group(1)
+ name=option[1:]
+ flag=(option[0] == '+')
+ if name == "affectation": self.affectation_flag=flag
+ if name == "comment": self.comment_flag=flag
+ if name == "all":
+ self.comment_flag=flag
+ self.affectation_flag=flag
def readline(self):
self.line= self.texte.readline()
def updateIndent(self):
#print "updateIndent",len(self.indent_list[-1]),len(self.buffer_indent)
if len(self.indent_list[-1]) > len(self.buffer_indent):
- self.out=self.out+(len(self.indent_list[-1]) - len(self.buffer_indent))*" "
- self.buffer_indent=self.indent_list[-1]
+ self.out=self.out+(len(self.indent_list[-1]) - len(self.buffer_indent))*" "
+ self.buffer_indent=self.indent_list[-1]
def doIndent(self):
#print "indentation dans doIndent",len(self.indent_list)
self.out=self.out+self.indent_list[-1]
self.buffer_indent=self.indent_list[-1]
if self.lastcol+len(self.indent_list[-1]) > self.thiscol:
- self.lastcol=self.thiscol
+ self.lastcol=self.thiscol
else:
- self.lastcol=self.lastcol+len(self.indent_list[-1])
+ self.lastcol=self.lastcol+len(self.indent_list[-1])
self.please_indent = None
def flush_buffer(self):
#if self.buffer:
# print len(self.indent_list),self.please_indent
for ob in self.buffer:
- self.out= self.out+ str(ob)
- self.doIndent()
+ self.out= self.out+ str(ob)
+ self.doIndent()
self.buffer=[]
self.objet_courant=None
def NL(self, tstring):
if self.affectation:
- if self.paren_level == 0:
- # affectation en cours mais complete
- self.out= self.out+ str(self.affectation_courante)
- self.affectation_courante=None
- self.please_indent=1
- self.affectation=0
- else:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- return
-
+ if self.paren_level == 0:
+ # affectation en cours mais complete
+ self.out= self.out+ str(self.affectation_courante)
+ self.affectation_courante=None
+ self.please_indent=1
+ self.affectation=0
+ else:
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ return
+
if self.objet_courant:
- self.objet_courant=None
- self.buffer.append(tstring)
+ self.objet_courant=None
+ self.buffer.append(tstring)
# self.please_indent = None
- return
+ return
self.output(tstring)
self.please_indent = 1
def COMMENT(self, tstring):
liste= string.split(self.line,"##",1)
if len(liste) > 1:
- # On a trouve un double commentaire
- before,after=liste
- if self.affectation:
- # affectation en cours, on ignore
- pass
- elif self.paren_level > 0:
- self.output(tstring)
- elif self.comment_flag and not self.pattern_ligne_non_blanche.search(before):
- # il s'agit d'une commande commentarisee
- if self.objet_courant == None:
- if not self.buffer:self.buffer_indent=self.indent_list[-1]
- self.objet_courant=COMMANDE_COMMENTARISEE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- elif isinstance(self.objet_courant,COMMENTAIRE):
- self.objet_courant=COMMANDE_COMMENTARISEE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- # commentaire inline
- self.output(tstring)
- self.please_indent = 1
- return
+ # On a trouve un double commentaire
+ before,after=liste
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(before):
+ # il s'agit d'une commande commentarisee
+ if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
+ self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant,COMMENTAIRE):
+ self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
else:
- # On a un commentaire simple
- new_line = self.line.split('#')[0]
- if self.affectation:
- # affectation en cours, on ignore
- pass
- elif self.paren_level > 0:
- self.output(tstring)
- elif self.comment_flag and not self.pattern_ligne_non_blanche.search(new_line):
- # commentaire precede de blancs
- if self.objet_courant == None:
- if not self.buffer:self.buffer_indent=self.indent_list[-1]
- self.objet_courant=COMMENTAIRE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- elif isinstance(self.objet_courant,COMMANDE_COMMENTARISEE):
- self.objet_courant=COMMENTAIRE()
- self.buffer.append(self.objet_courant)
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- self.objet_courant.appendText(tstring)
- self.please_indent = None
- else:
- # commentaire inline
- self.output(tstring)
- self.please_indent = 1
- return
+ # On a un commentaire simple
+ new_line = self.line.split('#')[0]
+ if self.affectation:
+ # affectation en cours, on ignore
+ pass
+ elif self.paren_level > 0:
+ self.output(tstring)
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(new_line):
+ # commentaire precede de blancs
+ if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
+ self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ elif isinstance(self.objet_courant,COMMANDE_COMMENTARISEE):
+ self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ self.objet_courant.appendText(tstring)
+ self.please_indent = None
+ else:
+ # commentaire inline
+ self.output(tstring)
+ self.please_indent = 1
+ return
def ERRORTOKEN(self, tstring):
print("ERRORTOKEN", tstring)
def NAME(self, tstring):
if self.buffer:
- self.updateIndent()
+ self.updateIndent()
self.flush_buffer()
if self.affectation ==1:
- # on a une expression du type NAME=NAME
- # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
- # on en prend le chemin : on met affectation a 3 pour le signaler
- # on attend d'en savoir plus
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=3
- return
+ # on a une expression du type NAME=NAME
+ # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
+ # on en prend le chemin : on met affectation a 3 pour le signaler
+ # on attend d'en savoir plus
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=3
+ return
elif self.affectation ==4:
- # on a une expression qui commence par NAME=NAME(NAME
- # il s'agit tres probablement d'une commande
- # on annule l'affectation en cours
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=5
- return
+ # on a une expression qui commence par NAME=NAME(NAME
+ # il s'agit tres probablement d'une commande
+ # on annule l'affectation en cours
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=5
+ return
elif self.affectation == 2:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=2
- return
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=2
+ return
self.affectation=0
self.name=None
- if self.paren_level == 0 and self.affectation_flag:
- # si on est en dehors de parentheses et en mode transformation d'affectation
- # on initialise l'attribut name qui indique une affectation en cours
- self.name=tstring
+ if self.paren_level == 0 and self.affectation_flag:
+ # si on est en dehors de parentheses et en mode transformation d'affectation
+ # on initialise l'attribut name qui indique une affectation en cours
+ self.name=tstring
self.output(tstring)
def ident(self, tstring):
def NUMBER(self, tstring):
self.flush_buffer()
if self.affectation>=1:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=2
- return
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=2
+ return
self.output(tstring)
def OP(self,tstring):
if tstring in (')',']','}'): self.paren_level=self.paren_level-1
if tstring == '=' and self.affectation ==5:
- # on a une expression qui commence par NAME=NAME(NAME=)
- # il peut s'agir d'une commande
- # on annule l'affectation en cours
- self.out= self.out+ self.affectation_courante.texte
- self.affectation_courante=None
- self.name=None
- self.affectation=0
+ # on a une expression qui commence par NAME=NAME(NAME=)
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out= self.out+ self.affectation_courante.texte
+ self.affectation_courante=None
+ self.name=None
+ self.affectation=0
elif tstring == ')' and self.affectation ==4:
- # on a une expression qui commence par NAME=NAME()
- # il peut s'agir d'une commande
- # on annule l'affectation en cours
- self.out= self.out+ self.affectation_courante.texte
- self.affectation_courante=None
- self.affectation=0
+ # on a une expression qui commence par NAME=NAME()
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out= self.out+ self.affectation_courante.texte
+ self.affectation_courante=None
+ self.affectation=0
elif tstring == '(' and self.affectation == 3:
- # on a deja trouve NAME=NAME
- # on passe affectation a 4
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=4
- return
+ # on a deja trouve NAME=NAME
+ # on passe affectation a 4
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=4
+ return
elif tstring == ';' and self.affectation>=1:
- # l'affectation est terminee
- self.out= self.out+ str(self.affectation_courante)
- self.affectation_courante=None
- self.please_indent=1
- self.affectation=0
+ # l'affectation est terminee
+ self.out= self.out+ str(self.affectation_courante)
+ self.affectation_courante=None
+ self.please_indent=1
+ self.affectation=0
elif self.affectation>=1:
- # on complete l'affectation
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=2
- return
+ # on complete l'affectation
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=2
+ return
self.affectation=0
- if self.name and tstring=='=':
- self.affectation=1
- self.affectation_courante=AFFECTATION()
- self.affectation_courante.name=self.name
+ if self.name and tstring=='=':
+ self.affectation=1
+ self.affectation_courante=AFFECTATION()
+ self.affectation_courante.name=self.name
self.output(tstring)
ENDMARKER = ident
def INDENT(self, tstring):
#tstring=str(len(self.indent_list))*len(tstring)
- self.indent_list.append(tstring)
+ self.indent_list.append(tstring)
#print "indentation dans INDENT",len(self.indent_list),len(tstring)
self.affectation=0
if self.buffer:
- self.updateIndent()
+ self.updateIndent()
self.flush_buffer()
def DEDENT(self, tstring):
#print "DEDENT",tstring,len(tstring)
if self.buffer:
- self.out= self.out+ str(self.buffer[0])
- if len(self.buffer) > 1:
- for ob in self.buffer[1:]:
- self.doIndent()
- self.out= self.out+ str(ob)
- self.buffer=[]
- self.objet_courant=None
- self.please_indent=1
+ self.out= self.out+ str(self.buffer[0])
+ if len(self.buffer) > 1:
+ for ob in self.buffer[1:]:
+ self.doIndent()
+ self.out= self.out+ str(ob)
+ self.buffer=[]
+ self.objet_courant=None
+ self.please_indent=1
self.affectation=0
- self.indent_list = self.indent_list[:-1]
+ self.indent_list = self.indent_list[:-1]
#print "indentation dans DEDENT",len(self.indent_list)
def STRING(self, tstring):
self.flush_buffer()
if self.affectation>=1:
- # affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.appendText(tstring)
- self.affectation=2
- return
+ # affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
+ self.affectation=2
+ return
self.output(tstring)
if __name__ == "__main__" :
FILTRE=(
_F( NOM_PARA = 'QUANTITE',
VALE_K = 'MAXIMUM'),),
- # commentaire
+ # commentaire
NOM_PARA='VMIS', # comm
VALE=1.9669824189084E9,
REFERENCE='NON_REGRESSION',
#comm
if t:
- a=5
+ a=5
#comm
if 1:
a=2
f=open("coque.geo","w")
#comm
- if 1:
+ if 1:
if 2:
if 3:
a=1
"""
if len(sys.argv)== 2:
- progname, input = sys.argv
- f=open(input)
- t=f.read()
- f.close()
+ progname, input = sys.argv
+ f=open(input)
+ t=f.read()
+ f.close()
else:
- t=text
+ t=text
txt = PARSEUR_PYTHON(t).getTexte()
print (txt)
compile(txt,"<string>",'exec')
from convert.convert_python import Pythonparser
try:
- basestring
+ basestring
except NameError:
- basestring = str
+ basestring = str
pattern_comment_slash = re.compile(r"^\s*/")
pattern_comment_slash_vide = re.compile(r"^\s*/\s*$")
def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {
- 'name' : 'TELEMAC',
- 'factory' : TELEMACparser
- }
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {
+ 'name' : 'TELEMAC',
+ 'factory' : TELEMACparser
+ }
class TELEMACparser(Pythonparser):
- """
- This converter works like Pythonparser, except that it also initializes all
- model variables to None in order to avoid Python syntax errors when loading
- a file with a different or inexistent definition of variables.
- """
-
-
-
- def convert(self, outformat, appliEficas=None):
-
-
- from Accas import A_BLOC, A_FACT, A_SIMP
- try :
- self.dicoCasToCata = appliEficas.readercata.dicoCasToCata
- except :
- self.dicoCasToCata = {}
- print ('pas de dicoCasToCata')
- self.dicoInverse = appliEficas.readercata.dicoInverse
- self.dicoMC = appliEficas.readercata.dicoMC
- self.Ordre_Des_Commandes = appliEficas.readercata.Ordre_Des_Commandes
- try :
- self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
- except :
- self.TelemacdicoEn = {}
- print ('pas de TelemacdicoEn')
- try :
- self.DicoEnumCasFrToEnumCasEn = appliEficas.readercata.DicoEnumCasFrToEnumCasEn
- except :
- self.DicoEnumCasFrToEnumCasEn = {}
- print ('pas de DicoEnumCasFrToEnumCasEn')
-
-
- if appliEficas.langue=='fr' :
- #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
- for k in self.DicoEnumCasFrToEnumCasEn :
- self.TelemacdicoEn[k]=self.DicoEnumCasFrToEnumCasEn[k]
-
- text=""
- self.dictSimp={}
-
- l_lignes_texte_all = self.text.split('\n')
- l_lignes_texte = []
- listeComment = []
- dicoComment={}
- dicoCommentSimp={}
- dicoCommentMC={}
- texteComment=""
- debut=True
- trouveComment = 0
- for l in l_lignes_texte_all :
- if pattern_eta.match(l) : continue
- if pattern_fin.match(l) : continue
- if pattern_blanc.match(l) : continue
-
- if not(pattern_comment_slash.match(l)):
- l_lignes_texte.append(l)
- if trouveComment :
- if debut: dicoComment['debut']=texteComment
- else : dicoComment[l]=texteComment
- trouveComment = 0
- texteComment=""
- if debut : debut = False
-
- if pattern_comment_slash.match(l):
- #if pattern_comment_slash_vide.match(l) : continue
- if pattern_comment_tiret.match(l) : continue
- texteComment+=l.replace ('/','',1)
- texteComment+='\n'
- trouveComment=1
-
- if texteComment != "" : dicoComment['fin']= texteComment
-
-
- l_lignes=[]
- i=0
- while (i < len(l_lignes_texte)) :
- ligne=l_lignes_texte[i]
- i=i+1
- if not(pattern_finit_par_virgule_ou_affect.match(ligne)):
- l_lignes.append(ligne)
- continue
- nouvelle_ligne=ligne
- while (i < len(l_lignes_texte)):
- ligne_traitee=l_lignes_texte[i]
- i=i+1
- nouvelle_ligne += ligne_traitee
- if not(pattern_finit_par_virgule_ou_affect.match(ligne_traitee)):
- l_lignes.append(nouvelle_ligne)
- break
-
-
- for ligne in l_lignes :
- if pattern_comment_slash.match(ligne) : continue
- #PN : deja teste
- #if pattern_eta.match(ligne) : continue
- #if pattern_fin.match(ligne) : continue
- #if pattern_blanc.match(ligne) : continue
-
-
- finLigne=ligne
- while finLigne != "" :
- if pattern_comment_slash.match(finLigne) : finLigne=""; continue
- valeur=""
- if pattern_variables.match(finLigne) :
- m=pattern_variables.match(finLigne)
- simpCas=self.traiteIdent(m.group('ident'))
- valeur=m.group('valeur')
- finLigne=m.group('reste')
- self.dictSimp[simpCas]=valeur
- continue
-
-
- m=pattern_ligne.match(finLigne)
- if m == None :
- #print( "________________________________________________")
- print ('pb avec ****', finLigne , '**** dans ', ligne)
- #print( "________________________________________________")
- break
-
- simpCas=self.traiteIdent(m.group('ident'))
- if not simpCas :
- finLigne=m.group('reste')
- continue
-
- finLigne=m.group('reste')
- # attention, l ordre des if est important
- if pattern_liste.match(finLigne) :
- m=pattern_liste.match(finLigne)
- elif pattern_liste_texte.match(finLigne) :
- m=pattern_liste_texte.match(finLigne)
- elif pattern_texteQuote.match(finLigne) :
- m=pattern_texteQuote.match(finLigne)
- elif pattern_flottant.match(finLigne) :
- m=pattern_flottant.match(finLigne)
- elif pattern_texteVide.match(finLigne):
- m=pattern_texteVide.match(finLigne)
- elif pattern_texteSimple.match(finLigne):
- m=pattern_texteSimple.match(finLigne)
- else :
- #print ("________________________________________________")
- print ('pb avec ****', finLigne , '**** dans ', ligne)
- print ("non match")
- #print ("________________________________________________")
- break
-
-
- valeur=m.group('valeur')
- if pattern_blanc.match(valeur) : valeur=None
-
- if pattern_flottant.match(finLigne) :
- valeur=re.sub("d","e",valeur)
- valeur=re.sub("D","E",valeur)
-
- if pattern_liste.match(finLigne) or pattern_liste_texte.match(finLigne):
- valeur=valeur.split(";")
-
-
- finLigne=m.group('reste')
- self.dictSimp[simpCas]=valeur
-
- if ligne in dicoComment.keys():
- dicoCommentSimp[simpCas]=dicoComment[ligne]
-
- if 'TITLE' not in self.dictSimp :
- import os
- #self.dictSimp['TITLE']=os.path.basename(self.filename)
-
-
- dicoParMC={}
- for simp in self.dictSimp:
- if simp in TELEMACparser.__dict__ : TELEMACparser.__dict__[simp](self,)
-
- for simp in self.dictSimp:
- if simp not in self.dicoInverse :
- #print ( "************")
- print ("pb avec dans dicoInverse", simp,'------')
- print("dicoInverse",sorted(self.dicoInverse.keys()))
- #print ("************")
- continue
- listeGenea=self.dicoInverse[simp]
- listeGeneaReverse=[]
- for (u,v) in listeGenea :
- if isinstance(v,A_BLOC.BLOC): continue
- listeGeneaReverse.append(u)
- listeGeneaReverse.reverse()
- dicoTravail=dicoParMC
- i=0
- if simp in dicoCommentSimp :
- MC=listeGeneaReverse[0]
- if MC in dicoCommentMC : dicoCommentMC[MC]+dicoCommentSimp[simp]
- else : dicoCommentMC[MC]=dicoCommentSimp[simp]
- while i < len(listeGeneaReverse[0:-1]) :
- mot=listeGeneaReverse[i]
+ """
+ This converter works like Pythonparser, except that it also initializes all
+ model variables to None in order to avoid Python syntax errors when loading
+ a file with a different or inexistent definition of variables.
+ """
+
+
+
+ def convert(self, outformat, appliEficas=None):
+ from Accas import A_BLOC, A_FACT, A_SIMP
+ try :
+ self.dicoCasToCata = appliEficas.readercata.dicoCasToCata
+ except :
+ self.dicoCasToCata = {}
+ print ('pas de dicoCasToCata')
+ self.dicoInverse = appliEficas.readercata.dicoInverse
+ self.dicoMC = appliEficas.readercata.dicoMC
+ self.Ordre_Des_Commandes = appliEficas.readercata.Ordre_Des_Commandes
+ try :
+ self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn
+ except :
+ self.TelemacdicoEn = {}
+ print ('pas de TelemacdicoEn')
+ try :
+ self.DicoEnumCasFrToEnumCasEn = appliEficas.readercata.DicoEnumCasFrToEnumCasEn
+ except :
+ self.DicoEnumCasFrToEnumCasEn = {}
+ print ('pas de DicoEnumCasFrToEnumCasEn')
+
+
+ if appliEficas.langue=='fr' :
+ #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
+ for k in self.DicoEnumCasFrToEnumCasEn :
+ self.TelemacdicoEn[k]=self.DicoEnumCasFrToEnumCasEn[k]
+
+ text=""
+ self.dictSimp={}
+
+ l_lignes_texte_all = self.text.split('\n')
+ l_lignes_texte = []
+ listeComment = []
+ dicoComment={}
+ dicoCommentSimp={}
+ dicoCommentMC={}
+ texteComment=""
+ debut=True
+ trouveComment = 0
+ for l in l_lignes_texte_all :
+ if pattern_eta.match(l) : continue
+ if pattern_fin.match(l) : continue
+ if pattern_blanc.match(l) : continue
+
+ if not(pattern_comment_slash.match(l)):
+ l_lignes_texte.append(l)
+ if trouveComment :
+ if debut: dicoComment['debut']=texteComment
+ else : dicoComment[l]=texteComment
+ trouveComment = 0
+ texteComment=""
+ if debut : debut = False
+
+ if pattern_comment_slash.match(l):
+ #if pattern_comment_slash_vide.match(l) : continue
+ if pattern_comment_tiret.match(l) : continue
+ texteComment+=l.replace ('/','',1)
+ texteComment+='\n'
+ trouveComment=1
+
+ if texteComment != "" : dicoComment['fin']= texteComment
+
+ l_lignes=[]
+ i=0
+ while (i < len(l_lignes_texte)) :
+ ligne=l_lignes_texte[i]
i=i+1
- if mot not in dicoTravail: dicoTravail[mot]={}
- dicoTravail=dicoTravail[mot]
- dicoTravail[simp]=self.dictSimp[simp]
-
- self.textePy=""
- listeMC=self.tri(list(dicoParMC.keys()))
- for k in listeMC :
- if k in dicoCommentMC :
+ if not(pattern_finit_par_virgule_ou_affect.match(ligne)):
+ l_lignes.append(ligne)
+ continue
+ nouvelle_ligne=ligne
+ while (i < len(l_lignes_texte)):
+ ligne_traitee=l_lignes_texte[i]
+ i=i+1
+ nouvelle_ligne += ligne_traitee
+ if not(pattern_finit_par_virgule_ou_affect.match(ligne_traitee)):
+ l_lignes.append(nouvelle_ligne)
+ break
+
+
+ for ligne in l_lignes :
+ if pattern_comment_slash.match(ligne) : continue
+ #PN : deja teste
+ #if pattern_eta.match(ligne) : continue
+ #if pattern_fin.match(ligne) : continue
+ #if pattern_blanc.match(ligne) : continue
+
+
+ finLigne=ligne
+ while finLigne != "" :
+ if pattern_comment_slash.match(finLigne) : finLigne=""; continue
+ valeur=""
+ if pattern_variables.match(finLigne) :
+ m=pattern_variables.match(finLigne)
+ simpCas=self.traiteIdent(m.group('ident'))
+ valeur=m.group('valeur')
+ finLigne=m.group('reste')
+ self.dictSimp[simpCas]=valeur
+ continue
+
+ m=pattern_ligne.match(finLigne)
+ if m == None :
+ #print( "________________________________________________")
+ print ('pb avec ****', finLigne , '**** dans ', ligne)
+ #print( "________________________________________________")
+ break
+
+ simpCas=self.traiteIdent(m.group('ident'))
+ if not simpCas :
+ finLigne=m.group('reste')
+ continue
+
+ finLigne=m.group('reste')
+ # attention, l ordre des if est important
+ if pattern_liste.match(finLigne) :
+ m=pattern_liste.match(finLigne)
+ elif pattern_liste_texte.match(finLigne) :
+ m=pattern_liste_texte.match(finLigne)
+ elif pattern_texteQuote.match(finLigne) :
+ m=pattern_texteQuote.match(finLigne)
+ elif pattern_flottant.match(finLigne) :
+ m=pattern_flottant.match(finLigne)
+ elif pattern_texteVide.match(finLigne):
+ m=pattern_texteVide.match(finLigne)
+ elif pattern_texteSimple.match(finLigne):
+ m=pattern_texteSimple.match(finLigne)
+ else :
+ #print ("________________________________________________")
+ print ('pb avec ****', finLigne , '**** dans ', ligne)
+ print ("non match")
+ #print ("________________________________________________")
+ break
+
+
+ valeur=m.group('valeur')
+ if pattern_blanc.match(valeur) : valeur=None
+
+ if pattern_flottant.match(finLigne) :
+ valeur=re.sub("d","e",valeur)
+ valeur=re.sub("D","E",valeur)
+
+ if pattern_liste.match(finLigne) or pattern_liste_texte.match(finLigne):
+ valeur=valeur.split(";")
+
+ finLigne=m.group('reste')
+ self.dictSimp[simpCas]=valeur
+
+ if ligne in dicoComment.keys():
+ dicoCommentSimp[simpCas]=dicoComment[ligne]
+
+ if 'TITLE' not in self.dictSimp :
+ import os
+ #self.dictSimp['TITLE']=os.path.basename(self.filename)
+
+
+ dicoParMC={}
+ for simp in self.dictSimp:
+ if simp in TELEMACparser.__dict__ : TELEMACparser.__dict__[simp](self,)
+
+ for simp in self.dictSimp:
+ if simp not in self.dicoInverse :
+ #print ( "************")
+ print ("pb avec dans dicoInverse", simp,'------')
+ print("dicoInverse",sorted(self.dicoInverse.keys()))
+ #print ("************")
+ continue
+ listeGenea=self.dicoInverse[simp]
+ listeGeneaReverse=[]
+ for (u,v) in listeGenea :
+ if isinstance(v,A_BLOC.BLOC): continue
+ listeGeneaReverse.append(u)
+ listeGeneaReverse.reverse()
+ dicoTravail=dicoParMC
+ i=0
+ if simp in dicoCommentSimp :
+ MC=listeGeneaReverse[0]
+ if MC in dicoCommentMC : dicoCommentMC[MC]+dicoCommentSimp[simp]
+ else : dicoCommentMC[MC]=dicoCommentSimp[simp]
+ while i < len(listeGeneaReverse[0:-1]) :
+ mot=listeGeneaReverse[i]
+ i=i+1
+ if mot not in dicoTravail: dicoTravail[mot]={}
+ dicoTravail=dicoTravail[mot]
+ dicoTravail[simp]=self.dictSimp[simp]
+
+ self.textePy=""
+ listeMC=self.tri(list(dicoParMC.keys()))
+ for k in listeMC :
+ if k in dicoCommentMC :
commentaire="COMMENTAIRE("+repr(dicoCommentMC[k])+")\n"
self.textePy+=commentaire
- self.textePy += str(k )+ "("
- self.traiteMC(dicoParMC[k])
- self.textePy += ");\n"
-
-
- # ne sert plus
- #appliEficas.listeTelemac=self.dictSimp
- appliEficas.listeTelemac={}
- if 'debut' in dicoComment :
- commentaire="COMMENTAIRE("+repr(dicoComment['debut'])+")\n"
- self.textePy=commentaire+self.textePy
- if 'fin' in dicoComment :
- commentaire="COMMENTAIRE("+repr(dicoComment['fin'])+")\n"
- self.textePy=self.textePy+commentaire
-
- #print (self.textePy)
- return self.textePy
-
-
- #----------------------------------------
- def traiteIdent(self,ident):
- # enleve les espaces de part et autre
- # traduit du langage Telemac vers le langage Catalogue
- #----------------------------------------
- while ident[-1] == " " or ident[-1] == '\t' : ident=ident[0:-1]
- while ident[0] == " " or ident[0] == '\t' : ident=ident[1:]
- try : identCata=self.dicoCasToCata[ident]
- except :
+ self.textePy += str(k )+ "("
+ self.traiteMC(dicoParMC[k])
+ self.textePy += ");\n"
+
+ # ne sert plus
+ #appliEficas.listeTelemac=self.dictSimp
+ appliEficas.listeTelemac={}
+ if 'debut' in dicoComment :
+ commentaire="COMMENTAIRE("+repr(dicoComment['debut'])+")\n"
+ self.textePy=commentaire+self.textePy
+ if 'fin' in dicoComment :
+ commentaire="COMMENTAIRE("+repr(dicoComment['fin'])+")\n"
+ self.textePy=self.textePy+commentaire
+
+ #print (self.textePy)
+ return self.textePy
+
+
+ #----------------------------------------
+ def traiteIdent(self,ident):
+ # enleve les espaces de part et autre
+ # traduit du langage Telemac vers le langage Catalogue
+ #----------------------------------------
+ while ident[-1] == " " or ident[-1] == '\t' : ident=ident[0:-1]
+ while ident[0] == " " or ident[0] == '\t' : ident=ident[1:]
+ try : identCata=self.dicoCasToCata[ident]
+ except :
print ( "---> ", "pb mot clef pour", ident)
identCata=None
- return identCata
-
-
- def traiteMC(self,dico) :
- from Accas import A_BLOC, A_FACT, A_SIMP
- for k in dico :
- valeur= dico[k]
- if k not in self.dicoMC : kA=self.dicoFrancaisAnglais[k]
- else : kA=k
- obj=self.dicoMC[kA]
- if isinstance(obj,A_FACT.FACT): self.convertFACT(obj,kA,valeur)
- elif isinstance(obj,A_BLOC.BLOC): self.convertBLOC(obj,kA,valeur)
- elif isinstance(obj,A_SIMP.SIMP): self.convertSIMP(obj,kA,valeur)
- else : print ("%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%")
-
-
- def convertFACT(self,obj,nom,valeur):
- # traitement LIQUID_BOUNDARIES
- if nom in TELEMACparser.__dict__ :
- TELEMACparser.__dict__[nom](self,)
- return
- self.textePy += nom + "=_F( "
- self.traiteMC(valeur)
- self.textePy += '),\n'
-
-
- def convertBLOC(self,obj,nom,valeur):
- print ("ANOMALIE _________ BLOC ")
- print (nom)
-
- def convertSIMP(self,obj,nom,valeur):
- #print ('in convertSIMP', nom,valeur)
- #if nom in ("PRESCRIBED_FLOWRATES", "PRESCRIBED_VELOCITIES", "PRESCRIBED_ELEVATIONS" ): return
- if obj.max==1 :
- if hasattr(obj.type[0],'ntuple') :
- lval=[]
- for v in valeur :
- try : v=eval(v,{})
- except : pass
- lval.append(v)
- self.textePy += nom + "=" + str(lval) +","
- return
- if 'TXM' in obj.type :
-
- if pattern_ContientDouble.match(str(valeur)):
- valeur=re.sub("''","\'\'",str(valeur))
- self.textePy += nom + "=" + str(valeur) +","
- return
- valeur=str(valeur)
-
- # ceinture et bretelle si les re sont correctes -)
- while valeur[-1] == " " or valeur[-1] == '\t' : valeur=valeur[0:-1]
- while valeur[0] == " " or valeur[0] == '\t' : valeur=valeur[1:]
-
-
-
- # Pour les enum
- try : valeur=eval(valeur,{})
- except : pass
-
- if nom in self.TelemacdicoEn:
- try :
- valeur=self.TelemacdicoEn[nom][valeur]
- self.textePy += nom + "= '" + str(valeur) +"',"
- return
- except : pass
-
-
- if obj.into != [] and obj.into != None and not('R' in obj.type) and not('I' in obj.type):
- for possible in obj.into :
- try :
- if possible.upper() == valeur.upper():
- valeur=possible
- break
- v=valeur[0].upper()+valeur[1:].lower()
- v2=tr(v)
- if possible.upper() == v2.upper():
- valeur=possible
- break
- except:
- if valeur != None :
- print ("pb avec le type de ", obj.nom, obj.type, 'et la valeur ', valeur)
-
- if 'Fichier' in obj.type or 'TXM' in obj.type or 'Repertoire' in obj.type or 'FichierOuRepertoire' in obj.type :
- valeur=str(valeur)
- if valeur == "" or valeur == " " :
- self.textePy += nom + "= '" + str(valeur) +"' ,"
- return
- while valeur[-1] == " " : valeur=valeur[0:-1]
- while valeur[0] == " " : valeur=valeur[1:]
- self.textePy += nom + "= '" + str(valeur) +"' ,"
- return
-
- if bool in obj.type :
- if valeur == True : self.textePy += nom + "= True,"
- elif valeur == False : self.textePy += nom + "= False,"
- elif pattern_oui.match(valeur) : self.textePy += nom + "= True,"
- elif pattern_non.match(valeur) : self.textePy += nom + "= False,"
- else : self.textePy += nom + "= None,"
+ return identCata
+
+
+ def traiteMC(self,dico) :
+ from Accas import A_BLOC, A_FACT, A_SIMP
+ for k in dico :
+ valeur= dico[k]
+ if k not in self.dicoMC : kA=self.dicoFrancaisAnglais[k]
+ else : kA=k
+ obj=self.dicoMC[kA]
+ if isinstance(obj,A_FACT.FACT): self.convertFACT(obj,kA,valeur)
+ elif isinstance(obj,A_BLOC.BLOC): self.convertBLOC(obj,kA,valeur)
+ elif isinstance(obj,A_SIMP.SIMP): self.convertSIMP(obj,kA,valeur)
+ else : print ("%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%")
+
+ def convertFACT(self,obj,nom,valeur):
+ # traitement LIQUID_BOUNDARIES
+ if nom in TELEMACparser.__dict__ :
+ TELEMACparser.__dict__[nom](self,)
return
- self.textePy += nom + "=" + str(valeur) +","
-
- else :
- if valeur == () or valeur ==[] or pattern_listeVide.match(str(valeur)) :
- self.textePy += nom + "= None,"
- return
-
- # les 4 lignes suivantes sont probablement inutiles
- while valeur[-1] == " " or valeur[-1]=="'" : valeur=valeur[0:-1]
- while valeur[0] == " " or valeur[-0]=="'" : valeur=valeur[1:]
- oldValeur=valeur
- if isinstance(valeur, basestring) :
- if ";" in valeur : valeur=valeur.split(';')
- else : valeur=valeur.split(',')
-
- if len(valeur)< 2 and pattern_flottant.match(oldValeur):
- # Attention : on attend une liste mais on a une seule valeur!
- try : oldValeur=eval(oldValeur,{})
- except : pass
- if nom in self.TelemacdicoEn :
- v=self.TelemacdicoEn[nom][oldValeur]
- self.textePy += nom + "= ('" + str(v) +"',),"
- else :
- self.textePy += nom + "= (" + str(oldValeur) +",),"
- return
-
-
- if valeur == None : return
- newVal=[]
- for v in valeur :
- try : v=eval(v,{})
+ self.textePy += nom + "=_F( "
+ self.traiteMC(valeur)
+ self.textePy += '),\n'
+
+
+ def convertBLOC(self,obj,nom,valeur):
+ print ("ANOMALIE _________ BLOC ")
+ print (nom)
+
+ def convertSIMP(self,obj,nom,valeur):
+ #print ('in convertSIMP', nom,valeur)
+ #if nom in ("PRESCRIBED_FLOWRATES", "PRESCRIBED_VELOCITIES", "PRESCRIBED_ELEVATIONS" ): return
+ if obj.max==1 :
+ if hasattr(obj.type[0],'ntuple') :
+ lval=[]
+ for v in valeur :
+ try : v=eval(v,{})
+ except : pass
+ lval.append(v)
+ self.textePy += nom + "=" + str(lval) +","
+ return
+ if 'TXM' in obj.type :
+
+ if pattern_ContientDouble.match(str(valeur)):
+ valeur=re.sub("''","\'\'",str(valeur))
+ self.textePy += nom + "=" + str(valeur) +","
+ return
+ valeur=str(valeur)
+
+ # ceinture et bretelle si les re sont correctes -)
+ while valeur[-1] == " " or valeur[-1] == '\t' : valeur=valeur[0:-1]
+ while valeur[0] == " " or valeur[0] == '\t' : valeur=valeur[1:]
+
+
+
+ # Pour les enum
+ try : valeur=eval(valeur,{})
except : pass
+
if nom in self.TelemacdicoEn:
- try : v=self.TelemacdicoEn[nom][v]
- except : pass
- newVal.append(v)
- self.textePy += nom + "=" + str(newVal) +","
-
-
-
- def tri(self, listeIn):
- if len(listeIn) == 1 : return listeIn
- if self.Ordre_Des_Commandes == None : return listeIn
- listeOut=[listeIn[0],]
- for k in listeIn[1:]:
- #k=str(self.dicoFrancaisAnglais[kF])
- ordreK=self.Ordre_Des_Commandes.index(k)
- i=0
- while i < len(listeOut):
- #ordreI=self.Ordre_Des_Commandes.index(self.dicoFrancaisAnglais[listeOut[i]])
- ordreI=self.Ordre_Des_Commandes.index(listeOut[i])
- if ordreK < ordreI : break
- i=i+1
- #listeOut.insert(i,kF)
- listeOut.insert(i,k)
- return listeOut
-
-# def BOUNDARY_CONDITIONS(self):
-# texte_Boundaries="BOUNDARY_CONDITIONS=_F(LIQUID_BOUNDARIES=( "
-# if 'PRESCRIBED_ELEVATIONS' in self.dictSimp:
-# valeursPE=self.dictSimp["PRESCRIBED_ELEVATIONS"]
-# if not type(valeursPE)==list : valeursPE = (valeursPE,)
-# longueur=len(self.dictSimp["PRESCRIBED_ELEVATIONS"])
-# else : valeursPE=None
-# if 'PRESCRIBED_FLOWRATES' in self.dictSimp:
-# valeursPF=self.dictSimp["PRESCRIBED_FLOWRATES"]
-# if not type(valeursPF)==list : valeursPF = (valeursPF,)
-# longueur=len(self.dictSimp["PRESCRIBED_FLOWRATES"])
-# else : valeursPF=None
-# if 'PRESCRIBED_VELOCITIES' in self.dictSimp:
-# valeursPV=self.dictSimp["PRESCRIBED_VELOCITIES"]
-# if not type(valeursPV)==list : valeursPV = (valeursPV,)
-# longueur=len(self.dictSimp["PRESCRIBED_VELOCITIES"])
-# else : valeursPV=None
-#
-# if valeursPE == None and valeursPF == None and valeursPV == None :
-# texte_Boundaries +="),\n"
-# return
-#
-# if valeursPE == None or valeursPF == None or valeursPV == None :
-# listNulle=[]
-# for i in range(longueur) : listNulle.append('0')
-#
-#
-# if valeursPE == None : valeursPE = listNulle
-# if valeursPF == None : valeursPF = listNulle
-# if valeursPV == None : valeursPV = listNulle
-#
-#
-# for e in range(len(valeursPE)):
-# if valeursPE[e] != "" or valeursPE[e] != "\n" :
-# if eval(valeursPE[e],{}) != 0 :
-# texte_Boundaries += "_F(BOUNDARY_TYPE = 'Prescribed Elevations',\n"
-# texte_Boundaries += "PRESCRIBED_ELEVATIONS = " + str(valeursPE[e]) + "),\n"
-# continue
-#
-# if valeursPF[e] != "" or valeursPF[e] != "\n" :
-# if eval(valeursPF[e],{}) != 0 :
-# texte_Boundaries += "_F(BOUNDARY_TYPE = 'Prescribed Flowrates',\n"
-# texte_Boundaries += "PRESCRIBED_FLOWRATES = " + str(valeursPF[e]) + "),\n"
-# continue
-#
-# if valeursPV[e] != "" or valeursPV[e] != "\n" :
-# if eval(valeursPV[e],{})!=0 :
-# texte_Boundaries += "_F( BOUNDARY_TYPE= 'Prescribed Velocity',\n"
-# texte_Boundaries += "PRESCRIBED_VELOCITIES = " + str(valeursPV[e]) + "),\n"
-# continue
-# print ("pb texte_Boundaries avec la valeur numero ", e)
-#
-# texte_Boundaries +="),),"
-# self.textePy += texte_Boundaries
-#
+ try :
+ valeur=self.TelemacdicoEn[nom][valeur]
+ self.textePy += nom + "= '" + str(valeur) +"',"
+ return
+ except : pass
+
+
+ if obj.into != [] and obj.into != None and not('R' in obj.type) and not('I' in obj.type):
+ for possible in obj.into :
+ try :
+ if possible.upper() == valeur.upper():
+ valeur=possible
+ break
+ v=valeur[0].upper()+valeur[1:].lower()
+ v2=tr(v)
+ if possible.upper() == v2.upper():
+ valeur=possible
+ break
+ except:
+ if valeur != None :
+ print ("pb avec le type de ", obj.nom, obj.type, 'et la valeur ', valeur)
+
+ if 'Fichier' in obj.type or 'TXM' in obj.type or 'Repertoire' in obj.type or 'FichierOuRepertoire' in obj.type :
+ valeur=str(valeur)
+ if valeur == "" or valeur == " " :
+ self.textePy += nom + "= '" + str(valeur) +"' ,"
+ return
+ while valeur[-1] == " " : valeur=valeur[0:-1]
+ while valeur[0] == " " : valeur=valeur[1:]
+ self.textePy += nom + "= '" + str(valeur) +"' ,"
+ return
+
+ if bool in obj.type :
+ if valeur == True : self.textePy += nom + "= True,"
+ elif valeur == False : self.textePy += nom + "= False,"
+ elif pattern_oui.match(valeur) : self.textePy += nom + "= True,"
+ elif pattern_non.match(valeur) : self.textePy += nom + "= False,"
+ else : self.textePy += nom + "= None,"
+ return
+ self.textePy += nom + "=" + str(valeur) +","
+
+ else :
+ if valeur == () or valeur ==[] or pattern_listeVide.match(str(valeur)) :
+ self.textePy += nom + "= None,"
+ return
+
+ # les 4 lignes suivantes sont probablement inutiles
+ while valeur[-1] == " " or valeur[-1]=="'" : valeur=valeur[0:-1]
+ while valeur[0] == " " or valeur[-0]=="'" : valeur=valeur[1:]
+ oldValeur=valeur
+ if isinstance(valeur, basestring) :
+ if ";" in valeur : valeur=valeur.split(';')
+ else : valeur=valeur.split(',')
+
+ if len(valeur)< 2 and pattern_flottant.match(oldValeur):
+ # Attention : on attend une liste mais on a une seule valeur!
+ try : oldValeur=eval(oldValeur,{})
+ except : pass
+ if nom in self.TelemacdicoEn :
+ v=self.TelemacdicoEn[nom][oldValeur]
+ self.textePy += nom + "= ('" + str(v) +"',),"
+ else :
+ self.textePy += nom + "= (" + str(oldValeur) +",),"
+ return
+
+
+ if valeur == None : return
+ newVal=[]
+ for v in valeur :
+ try : v=eval(v,{})
+ except : pass
+ if nom in self.TelemacdicoEn:
+ try : v=self.TelemacdicoEn[nom][v]
+ except : pass
+ newVal.append(v)
+ self.textePy += nom + "=" + str(newVal) +","
+
+
+
+ def tri(self, listeIn):
+ if len(listeIn) == 1 : return listeIn
+ if self.Ordre_Des_Commandes == None : return listeIn
+ listeOut=[listeIn[0],]
+ for k in listeIn[1:]:
+ #k=str(self.dicoFrancaisAnglais[kF])
+ ordreK=self.Ordre_Des_Commandes.index(k)
+ i=0
+ while i < len(listeOut):
+ #ordreI=self.Ordre_Des_Commandes.index(self.dicoFrancaisAnglais[listeOut[i]])
+ ordreI=self.Ordre_Des_Commandes.index(listeOut[i])
+ if ordreK < ordreI : break
+ i=i+1
+ #listeOut.insert(i,kF)
+ listeOut.insert(i,k)
+ return listeOut
def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {
- 'name' : 'xml',
- 'factory' : XMLparser
- }
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {
+ 'name' : 'xml',
+ 'factory' : XMLparser
+ }
class XMLparser:
- """
- This converter works like Pythonparser, except that it is supposed to read XML
- """
+ """
+ This converter works like Pythonparser, except that it is supposed to read XML
+ """
- def __init__(self,cr=None):
- self.text=''
- if cr : self.cr=cr
- else: self.cr=N_CR.CR(debut='CR convertisseur format XML',
- fin='fin CR format XML')
+ def __init__(self,cr=None):
+ print ('dans XML convert')
+ self.text=''
+ if cr : self.cr=cr
+ else: self.cr=N_CR.CR(debut='CR convertisseur format XML',
+ fin='fin CR format XML')
- def readfile(self,filename):
- self.filename=filename
- try:
- self.text=open(filename).read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- return
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ with open(filename) as fd :
+ self.text=fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ return
- def convert(self, outformat, appliEficas=None):
- # ici on ne fait rien
- # on le fera a la creation du JDC
- try:
+ def convert(self, outformat, appliEficas=None):
+ # ici on ne fait rien
+ # on le fera a la creation du JDC
+ try:
return self.text
- except EficasException:
+ except EficasException:
# Erreur lors de la conversion
l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
sys.exc_info()[2])
self.cr.exception(tr("Impossible de convertir le fichier XML\n %s", ''.join(l)))
return ""
-
-
-
-
-
from __future__ import absolute_import
-#from Extensions.i18n import tr
-#from Extensions import localisation
+from Extensions.i18n import tr
+from Extensions import localisation
from .convert_python import Pythonparser
from Noyau import N_CR
try:
- basestring
+ basestring
except NameError:
- basestring = str
+ basestring = str
def entryPoint():
- """
- Return a dictionary containing the description needed to load the plugin
- """
- return {
- 'name' : 'dico',
- 'factory' : Dicoparser
- }
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {
+ 'name' : 'dico',
+ 'factory' : Dicoparser
+ }
class Dicoparser(Pythonparser):
- """
- This converter initializes model variable from a python dictionnary
- """
+ """
+ This converter initializes model variable from a python dictionnary
+ """
- def __init__(self,cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le
- # compte-rendu standard
- self.text=''
- self.textePy=''
- if cr :
- self.cr=cr
- else:
- self.cr=N_CR.CR(debut='CR convertisseur format dico',
- fin='fin CR format dico')
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text=''
+ self.textePy=''
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format dico',
+ fin='fin CR format dico')
- def readfile(self,filename):
- self.filename=filename
- try:
- self.text=open(filename).read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- return
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ with open(filename) as fd :
+ self.text=fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ return
- def convert(self,outformat,appli=None):
- monTexteDico={}
- exec (self.text,globals(),monTexteDico)
- if len(monTexteDico.keys()) != 1 :
- self.cr.exception(tr("Impossible de traiter le fichier %s" ,str(filename)))
- self.cr.fatal(tr("Impossible de traiter le fichier %s" ,str(filename)))
- return
- self.textePy=""
- monDico=monTexteDico[monTexteDico.keys()[0]]
- for commande in monDico :
- valeurs=monDico[commande]
- if valeurs.has_key('NomDeLaSdCommande') :
- # cas d un oper
- self.textePy+=valeurs['NomDeLaSdCommande']+' = '+commande+'('
- del valeurs['NomDeLaSdCommande']
- else :
- self.textePy+=commande+'('
- for mot in valeurs :
- if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
- else : self.textePy += mot+' = ' +str(valeurs[mot])+','
- self.textePy+=');\n' # fin de la commande
- #print (self.textePy)
- return self.textePy
-
- def traiteMCFact(self,mot,valeurs):
- self.textePy += mot + '=_F('
- for mot in valeurs :
- if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
- else : self.textePy +=mot+' = ' +str(valeurs[mot])+','
- self.textePy +='),'
+ def convert(self,outformat,appli=None):
+ monTexteDico={}
+ exec (self.text,globals(),monTexteDico)
+ if len(monTexteDico.keys()) != 1 :
+ self.cr.exception(tr("Impossible de traiter le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible de traiter le fichier %s" ,str(filename)))
+ return
+ self.textePy=""
+ monDico=monTexteDico[monTexteDico.keys()[0]]
+ for commande in monDico :
+ valeurs=monDico[commande]
+ if valeurs.has_key('NomDeLaSdCommande') :
+ # cas d un oper
+ self.textePy+=valeurs['NomDeLaSdCommande']+' = '+commande+'('
+ del valeurs['NomDeLaSdCommande']
+ else :
+ self.textePy+=commande+'('
+ for mot in valeurs :
+ if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
+ else : self.textePy += mot+' = ' +str(valeurs[mot])+','
+ self.textePy+=');\n' # fin de la commande
+ #print (self.textePy)
+ return self.textePy
+ def traiteMCFact(self,mot,valeurs):
+ self.textePy += mot + '=_F('
+ for mot in valeurs :
+ if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
+ else : self.textePy +=mot+' = ' +str(valeurs[mot])+','
+ self.textePy +='),'
from .convert_python import Pythonparser
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'MAP',
- # La factory pour creer une instance du plugin
- 'factory' : Pythonparser,
- }
-
-
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'MAP',
+ # La factory pour creer une instance du plugin
+ 'factory' : Pythonparser,
+ }
Le format eval est un texte source Python qui peut etre evalue. Le
resultat de l'evaluation est un objet Python quelconque.
Le format dict est un dictionnaire Python.
- Le format exec est un texte source Python qui peut etre execute.
+ Le format exec est un texte source Python qui peut etre execute.
La methode readfile a pour fonction de lire un fichier dont le
nom est passe en argument de la fonction.
"""
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import sys,traceback
from Extensions.eficas_exception import EficasException
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'pyth',
- # La factory pour creer une instance du plugin
- 'factory' : Pythparser,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'pyth',
+ # La factory pour creer une instance du plugin
+ 'factory' : Pythparser,
+ }
class Pythparser(object):
- """
- Ce convertisseur lit un fichier au format pyth avec la
- methode readfile : convertisseur.readfile(nom_fichier)
- et retourne le texte au format outformat avec la
- methode convertisseur.convert(outformat)
-
- Ses caracteristiques principales sont exposees dans 2 attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
- - formats : qui donne une liste de formats de sortie supportes
- """
- # Les extensions de fichier preconisees
- extensions=('.pyth',)
- # Les formats de sortie supportes (eval dict ou exec)
- formats=('dict',)
-
- def __init__(self,cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
- if cr :
- self.cr=cr
- else:
- self.cr=N_CR.CR(debut='CR convertisseur format pyth',
- fin='fin CR format pyth')
- self.g={}
-
- def readfile(self,filename):
- self.filename=filename
- try:
- self.text=open(filename).read()
- except:
- self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s",str( filename)))
- return
- self.g={}
- try:
- exec(self.text, self.g)
- except EficasException as e:
- l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
- s= ''.join(l[2:])
- s= s.replace('"<string>"','"<%s>"'%self.filename)
- self.cr.fatal(tr("Erreur a l'evaluation :\n %s", s))
-
- def convert(self,outformat,appliEficas=None):
- if outformat == 'dict':
- return self.getdict()
- else:
- raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
-
- def getdict(self):
- d={}
- for k,v in list(self.g.items()):
- if k[0] != '_':d[k]=v
- return d
+ """
+ Ce convertisseur lit un fichier au format pyth avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caracteristiques principales sont exposees dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ - formats : qui donne une liste de formats de sortie supportes
+ """
+ # Les extensions de fichier preconisees
+ extensions=('.pyth',)
+ # Les formats de sortie supportes (eval dict ou exec)
+ formats=('dict',)
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format pyth',
+ fin='fin CR format pyth')
+ self.g={}
+
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ with open(filename) as fd :
+ self.text=fd.read()
+ except:
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s",str( filename)))
+ return
+ self.g={}
+ try:
+ exec(self.text, self.g)
+ except EficasException as e:
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
+ s= ''.join(l[2:])
+ s= s.replace('"<string>"','"<%s>"'%self.filename)
+ self.cr.fatal(tr("Erreur a l'evaluation :\n %s", s))
+
+ def convert(self,outformat,appliEficas=None):
+ if outformat == 'dict':
+ return self.getdict()
+ else:
+ raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
+
+ def getdict(self):
+ d={}
+ for k,v in list(self.g.items()):
+ if k[0] != '_':d[k]=v
+ return d
Le format eval est un texte source Python qui peut etre evalue. Le
resultat de l'evaluation est un objet Python quelconque.
Le format dict est un dictionnaire Python.
- Le format exec est un texte source Python qui peut etre execute.
+ Le format exec est un texte source Python qui peut etre execute.
La methode readfile a pour fonction de lire un fichier dont le
nom est passe en argument de la fonction.
"""
from __future__ import absolute_import
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import sys,traceback
from .parseur_python import PARSEUR_PYTHON
from Extensions.eficas_exception import EficasException
def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'python',
- # La factory pour creer une instance du plugin
- 'factory' : Pythonparser,
- }
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'python',
+ # La factory pour creer une instance du plugin
+ 'factory' : Pythonparser,
+ }
class Pythonparser(object):
- """
- Ce convertisseur lit un fichier au format python avec la
- methode readfile : convertisseur.readfile(nom_fichier)
- et retourne le texte au format outformat avec la
- methode convertisseur.convert(outformat)
-
- Ses caracteristiques principales sont exposees dans 2 attributs
- de classe :
- - extensions : qui donne une liste d'extensions de fichier preconisees
- - formats : qui donne une liste de formats de sortie supportes
- """
- # Les extensions de fichier preconisees
- extensions=('.py',)
- # Les formats de sortie supportes (eval dict ou exec)
- # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
- # Le format execnoparseur est du python executable (commande exec) non converti
- formats=('exec','execnoparseur')
-
- def __init__(self,cr=None):
- # Si l'objet compte-rendu n'est pas fourni, on utilise le
- # compte-rendu standard
- self.text=''
- if cr :
- self.cr=cr
- else:
- self.cr=N_CR.CR(debut='CR convertisseur format python',
- fin='fin CR format python')
-
- def readfile(self,filename):
- self.filename=filename
- try:
- self.text=open(filename).read()
- except:
- self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
- return
-
- def convert(self,outformat,appliEficas=None):
- if outformat == 'exec':
- try:
- #import cProfile, pstats, StringIO
- #pr = cProfile.Profile()
- #pr.enable()
- l= PARSEUR_PYTHON(self.text).getTexte(appliEficas)
-
- #pr.disable()
- #s = StringIO.StringIO()
- #sortby = 'cumulative'
- #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- #ps.print_stats()
- #print (s.getValue())
-
- return l
- except EficasException:
- # Erreur lors de la conversion
- l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
- sys.exc_info()[2])
- self.cr.exception(tr("Impossible de convertir le fichier Python qui doit contenir des erreurs.\n\
- On retourne le fichier non converti. Prevenir la maintenance.\n\n %s", ''.join(l)))
- # On retourne neanmoins le source initial non converti (au cas ou)
+ """
+ Ce convertisseur lit un fichier au format python avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caracteristiques principales sont exposees dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ - formats : qui donne une liste de formats de sortie supportes
+ """
+ # Les extensions de fichier preconisees
+ extensions=('.py',)
+ # Les formats de sortie supportes (eval dict ou exec)
+ # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
+ # Le format execnoparseur est du python executable (commande exec) non converti
+ formats=('exec','execnoparseur')
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text=''
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format python',
+ fin='fin CR format python')
+
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ with open(filename) as fd :
+ self.text=fd.read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ return
+
+ def convert(self,outformat,appliEficas=None):
+ if outformat == 'exec':
+ try:
+ #import cProfile, pstats, StringIO
+ #pr = cProfile.Profile()
+ #pr.enable()
+ l= PARSEUR_PYTHON(self.text).getTexte(appliEficas)
+
+ #pr.disable()
+ #s = StringIO.StringIO()
+ #sortby = 'cumulative'
+ #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ #ps.print_stats()
+ #print (s.getValue())
+
+ return l
+ except EficasException:
+ # Erreur lors de la conversion
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
+ sys.exc_info()[2])
+ self.cr.exception(tr("Impossible de convertir le fichier Python qui doit contenir des erreurs.\n\
+ On retourne le fichier non converti. Prevenir la maintenance.\n\n %s", ''.join(l)))
+ # On retourne neanmoins le source initial non converti (au cas ou)
+ return self.text
+ elif outformat == 'execnoparseur':
return self.text
- elif outformat == 'execnoparseur':
- return self.text
- else:
- raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
- return None
+ else:
+ raise EficasException(tr("Format de sortie : %s, non supporte", outformat))
+ return None
from __future__ import absolute_import
from __future__ import print_function
try :
- from builtins import str
- from builtins import object
+ from builtins import str
+ from builtins import object
except :
- pass
+ pass
import sys,string,re
import traceback
from Extensions.i18n import tr
#stringsAndCommentsRE = \
# re.compile(u"(\"\"\".*\"\"\"|'''.*'''|\"[^\"]*\"|\'[^\']*\'|#.*\n)", re.DOTALL)
import six
-if six.PY2 :
+if six.PY2 :
allchars = string.maketrans(u"", "")
allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
-else :
+else :
allchars=bytes.maketrans(b"",b"")
allcharsExceptNewline = allchars[: allchars.index(b'\n')]+allchars[allchars.index(b'\n')+1:]
allcharsExceptNewlineTranstable = bytes.maketrans(allcharsExceptNewline, b'*'*len(allcharsExceptNewline))
def maskStringsAndComments(src):
"""Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
quotes et guillemets.
- Le masquage est realise en remplacant les caracteres par des *
+ Le masquage est realise en remplacant les caracteres par des *
Attention : cette fonction doit etre utilisee sur un texte complet et pas ligne par ligne
"""
# remplace les \\, les \" les \' par **
# supprime toutes les chaines ou commentaires ,y compris multiligne i
-# entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
+# entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
# laisse les non fermantes ou non ouvrantes
# on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
# le diese n'est pas sur le premier caractere
amont,aval = texte.split('#',1) # on decoupe suivant la premiere occurrence de #
self.texte = self.texte +amont + aval
-
+
class COMMANDE(ENTITE_JDC):
def __str__(self):
Retourne self.texte
"""
return self.texte+'\n'
-
+
def getNbPar(self):
"""
Retourne la difference entre le nombre de parentheses ouvrantes
if texte[-1] == '\n' : texte = texte[0:-1].rstrip()
if texte[-1] == ';' : texte = texte[0:-1].rstrip()
self.texte = self.texte+texte+'\n'
-
+
def __str__(self):
"""
Retourne une expression de l'affectation comprehensible par ACCAS
"""
if texte[-1] == '\n' : texte = texte[1:-1]
self.texte = self.texte+texte
-
+
def __str__(self):
"""
Retourne une expression du parametre EVAL comprehensible par ACCAS
if valeur[-1] == '\n': valeur = valeur[:-1]
valeur = valeur.strip()
return nom+' = PARAMETRE_EVAL(nom=\''+nom+'\',valeur=\''+valeur+'\')\n\n'
-
+
class PARSEUR_PYTHON(object):
"""
- Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+ Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
representant un JDC Python en distinguant :
- les commentaires inter commandes
- les affectations
pattern_eval = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
pattern_ligne_vide = re.compile(r'^[\t\r\f\v\n]+')
pattern_name = re.compile(r'[a-zA-Z_]\w*')
-
+
def __init__(self,texte):
self.texte = texte
self.l_objets=None
return 1
else:
return 0
-
+
def isCommande(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
def isModificationCatalogue(self,texte) :
if self.pattern_commande.match(texte):
- return 1
+ return 1
def analyse(self):
"""
hangingComments ^= line.count('"""') % 2
hangingComments ^= line.count(u"'''") % 2
#print (hangingComments,hangingBraces)
- if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
+ if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
raise parserException()
if ligne.strip() == '':
commande_commentarisee_courante.appendText(ligne)
# on a 2 commandes commentarisees de suite
if pattern_finComments.match(ligne) :
- commande_commentarisee_courante = None
+ commande_commentarisee_courante = None
else:
# debut de commande commentarisee : on cree un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
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
+ #on l'ajoute au texte de la commande
commande_courante.appendText(ligne)
elif commentaire_courant :
# il s'agit de la nieme ligne d'un commentaire entre deux commandes
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #la commande est terminee
+ #la commande est terminee
self.analyseReel(commande_courante.texte)
commande_courante = None
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #la commande est terminee
+ #la commande est terminee
self.analyseReel(commande_courante.texte)
commande_courante = None
#on passe a la ligne suivante
continue
-
+
def enleve (self,texte) :
"""Supprime de texte tous les caracteres blancs, fins de ligne, tabulations
Le nouveau texte est retourne
i=0
chaine=""
while (i<len(texte)):
- if (texte[i] == " " or texte[i] == "\n" or texte[i] == "\t") :
- i=i+1
- else :
- chaine=chaine+texte[i]
- i=i+1
- return chaine
-
+ if (texte[i] == " " or texte[i] == "\n" or texte[i] == "\t") :
+ i=i+1
+ else :
+ chaine=chaine+texte[i]
+ i=i+1
+ return chaine
+
def construitGenea(self,texte):
indiceC=0
mot=""
dict_reel_concept={}
# traitement pour chaque caractere
- while (indiceC < len(texte)):
- c=texte[indiceC]
- if ( c == "," or c == "(u" or c == ")"):
- mot=""
- elif ( c== "="):
- #on doit trouver derriere soit une valeur soit une parenthese
- valeur=""
- nouvelindice=indiceC+1
- if texte[nouvelindice] != "(u":
- #pas de parenthese ouvrante derriere un signe =, on a une valeur.
- while ( texte[nouvelindice] != "," and texte[nouvelindice] != ")"):
- valeur=valeur+texte[nouvelindice]
- nouvelindice=nouvelindice+1
- if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
- break
- if mot in self.appliEficas.liste_simp_reel:
- if valeur[0] != "'":
- try :
- clef=eval(valeur)
- if str(clef) != str(valeur) :
- dict_reel_concept[clef]=valeur
- except :
- pass
- mot=""
- indiceC=nouvelindice
- else:
- #parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
- # s agit -il d un tuple
- if texte[nouvelindice+1] != "(u":
- #le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
- tuple=False
- #on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
- #contenu dans le mot cle facteur
- while ( texte[nouvelindice] != "="):
- if texte[nouvelindice] == ")" :
- tuple=True
- break
- else :
- nouvelindice=nouvelindice+1
- if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
- break
- if tuple :
- #cas du tuple de valeurs
- valeur=texte[indiceC+1:nouvelindice+1]
- indiceC=nouvelindice+1
- if mot in self.appliEficas.liste_simp_reel:
- valeur=valeur[1:-1]
- for val in valeur.split(',') :
- # Attention la derniere valeur est""
- try :
- if val[0] != "'":
- clef=eval(val)
- if str(clef) != str(val) :
- dict_reel_concept[clef]=val
- except :
- pass
- mot=""
- # ou de ( imbriquees
- else :
- #cas du mocle facteur simple ou
+ while (indiceC < len(texte)):
+ c=texte[indiceC]
+ if ( c == "," or c == "(u" or c == ")"):
+ mot=""
+ elif ( c== "="):
+ #on doit trouver derriere soit une valeur soit une parenthese
+ valeur=""
+ nouvelindice=indiceC+1
+ if texte[nouvelindice] != "(u":
+ #pas de parenthese ouvrante derriere un signe =, on a une valeur.
+ while ( texte[nouvelindice] != "," and texte[nouvelindice] != ")"):
+ valeur=valeur+texte[nouvelindice]
+ nouvelindice=nouvelindice+1
+ if nouvelindice == len(texte) :
+ nouvelindice=nouvelindice -1
+ break
+ if mot in self.appliEficas.liste_simp_reel:
+ if valeur[0] != "'":
+ try :
+ clef=eval(valeur)
+ if str(clef) != str(valeur) :
+ dict_reel_concept[clef]=valeur
+ except :
+ pass
mot=""
- else :
- mot=mot+texte[indiceC]
- indiceC=indiceC+1
+ indiceC=nouvelindice
+ else:
+ #parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
+ # s agit -il d un tuple
+ if texte[nouvelindice+1] != "(u":
+ #le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
+ tuple=False
+ #on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
+ #contenu dans le mot cle facteur
+ while ( texte[nouvelindice] != "="):
+ if texte[nouvelindice] == ")" :
+ tuple=True
+ break
+ else :
+ nouvelindice=nouvelindice+1
+ if nouvelindice == len(texte) :
+ nouvelindice=nouvelindice -1
+ break
+ if tuple :
+ #cas du tuple de valeurs
+ valeur=texte[indiceC+1:nouvelindice+1]
+ indiceC=nouvelindice+1
+ if mot in self.appliEficas.liste_simp_reel:
+ valeur=valeur[1:-1]
+ for val in valeur.split(',') :
+ # Attention la derniere valeur est""
+ try :
+ if val[0] != "'":
+ clef=eval(val)
+ if str(clef) != str(val) :
+ dict_reel_concept[clef]=val
+ except :
+ pass
+ mot=""
+ # ou de ( imbriquees
+ else :
+ #cas du mocle facteur simple ou
+ mot=""
+ else :
+ mot=mot+texte[indiceC]
+ indiceC=indiceC+1
# traitement du dernier inutile
- # c est un ;
+ # c est un ;
return dict_reel_concept
def analyseReel(self,commande) :
# On verifie qu on a bien un OPER
# et pas une MACRO
if commande.find(u"=") > commande.find(u"(u") :
- return
+ return
if commande.find(u"=") > 0:
- #epure1=self.enleve(commande)
- epure1=pattern_blancs.sub(u"",commande)
- nomConcept,corps=epure1.split(u"=",1)
- epure2=corps.replace(u"_F(u","(u")
- #nomConcept=epure1.split(u"=")[0]
- #index=epure1.find(u"=")
- #epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
- #dict_reel_concept=self.construitGenea(epure2)
- if self.appliEficas:
- dict_reel_concept=construitGenea(epure2,self.appliEficas.liste_simp_reel)
- else:
- dict_reel_concept={}
+ #epure1=self.enleve(commande)
+ epure1=pattern_blancs.sub(u"",commande)
+ nomConcept,corps=epure1.split(u"=",1)
+ epure2=corps.replace(u"_F(u","(u")
+ #nomConcept=epure1.split(u"=")[0]
+ #index=epure1.find(u"=")
+ #epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
+ #dict_reel_concept=self.construitGenea(epure2)
+ if self.appliEficas:
+ dict_reel_concept=construitGenea(epure2,self.appliEficas.liste_simp_reel)
+ else:
+ dict_reel_concept={}
if nomConcept == "sansnom" :
- nomConcept = ""
+ nomConcept = ""
if nomConcept !=None :
- if len(dict_reel_concept) != 0:
- self.appliEficas.dict_reels[nomConcept]=dict_reel_concept
+ if len(dict_reel_concept) != 0:
+ self.appliEficas.dict_reels[nomConcept]=dict_reel_concept
def getTexte(self,appliEficas=None):
"""
return txt
def test():
- #import parseur_python
- import doctest
- doctest.testmod(parseur_python)
+ #import parseur_python
+ import doctest
+ doctest.testmod(parseur_python)
if __name__ == "__main__" :
import time
#fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
#fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
- texte = open(fichier,'r').read()
+ with open(fichier) as fd:
+ texte = fd.read()
class appliEficas(object):
- dict_reels={}
- liste_simp_reel=["VALE","VALE_C","GROUP_MA","RAYON"]
+ dict_reels={}
+ liste_simp_reel=["VALE","VALE_C","GROUP_MA","RAYON"]
a=appliEficas()
compile(txt, '<string>', 'exec')
