From: pascale.noyret Date: Thu, 25 Mar 2021 15:31:58 +0000 (+0100) Subject: reindent sur convert X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=80052d9b23b95a358d144dbbfa95603d77615296;p=tools%2Feficas.git reindent sur convert --- diff --git a/convert/__init__.py b/convert/__init__.py index 04ceb33d..6ed222f1 100644 --- a/convert/__init__.py +++ b/convert/__init__.py @@ -30,4 +30,3 @@ from Extensions import pluginloader import convert plugins=pluginloader.PluginLoader(convert) - diff --git a/convert/autre_parseur.py b/convert/autre_parseur.py index aaa4377c..62e442d9 100644 --- a/convert/autre_parseur.py +++ b/convert/autre_parseur.py @@ -19,15 +19,15 @@ # 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 @@ -65,7 +65,7 @@ class COMMENTAIRE(ENTITE_JDC): # 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): @@ -73,7 +73,7 @@ class AFFECTATION(ENTITE_JDC): 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 @@ -100,7 +100,7 @@ class COMMANDE_COMMENTARISEE(ENTITE_JDC): """ return "COMMANDE_COMM(texte="+repr(self.texte)+")\n" - + next = {} next['if'] = next['elif'] = 'elif', 'else', 'end' next['while'] = next['for'] = 'else', 'end' @@ -112,7 +112,7 @@ start = 'if', 'while', 'for', 'try', 'def', 'class' 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 @@ -155,14 +155,14 @@ class PARSEUR_PYTHON(object): 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() @@ -226,8 +226,8 @@ class PARSEUR_PYTHON(object): 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) @@ -235,141 +235,141 @@ class PARSEUR_PYTHON(object): 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): @@ -380,11 +380,11 @@ class PARSEUR_PYTHON(object): 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): @@ -393,45 +393,45 @@ class PARSEUR_PYTHON(object): 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 @@ -439,37 +439,37 @@ class PARSEUR_PYTHON(object): 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__" : @@ -528,7 +528,7 @@ TEST_TABLE( TABLE=RELV[k], FILTRE=( _F( NOM_PARA = 'QUANTITE', VALE_K = 'MAXIMUM'),), - # commentaire + # commentaire NOM_PARA='VMIS', # comm VALE=1.9669824189084E9, REFERENCE='NON_REGRESSION', @@ -770,7 +770,7 @@ for k in range(1,10): #comm if t: - a=5 + a=5 #comm if 1: a=2 @@ -818,7 +818,7 @@ for k in range(1,10): f=open("coque.geo","w") #comm - if 1: + if 1: if 2: if 3: a=1 @@ -896,12 +896,12 @@ def POST_GOUJ_ops(self,TABLE): """ 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,"",'exec') diff --git a/convert/convert_TELEMAC.py b/convert/convert_TELEMAC.py index b77b3639..4bded48e 100644 --- a/convert/convert_TELEMAC.py +++ b/convert/convert_TELEMAC.py @@ -27,9 +27,9 @@ from Extensions.i18n import tr 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*$") @@ -75,458 +75,395 @@ from Extensions import localisation 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 diff --git a/convert/convert_XML.py b/convert/convert_XML.py index c19648ab..2b7cb3c3 100644 --- a/convert/convert_XML.py +++ b/convert/convert_XML.py @@ -30,49 +30,46 @@ from Noyau import N_CR 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 "" - - - - - diff --git a/convert/convert_dico.py b/convert/convert_dico.py index 0e8e7675..61d54be2 100644 --- a/convert/convert_dico.py +++ b/convert/convert_dico.py @@ -19,82 +19,82 @@ 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 +='),' diff --git a/convert/convert_map.py b/convert/convert_map.py index c4bad148..09264ce3 100644 --- a/convert/convert_map.py +++ b/convert/convert_map.py @@ -24,15 +24,13 @@ from __future__ import absolute_import 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, + } diff --git a/convert/convert_pyth.py b/convert/convert_pyth.py index 9a73c09c..80bcd820 100644 --- a/convert/convert_pyth.py +++ b/convert/convert_pyth.py @@ -34,7 +34,7 @@ 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. @@ -49,10 +49,10 @@ """ 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 @@ -61,68 +61,69 @@ from Extensions.i18n import tr 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('""','"<%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('""','"<%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 diff --git a/convert/convert_python.py b/convert/convert_python.py index 510721e9..c0ee8a6d 100644 --- a/convert/convert_python.py +++ b/convert/convert_python.py @@ -34,7 +34,7 @@ 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. @@ -49,10 +49,10 @@ """ 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 @@ -61,82 +61,83 @@ from Extensions.i18n import tr 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 diff --git a/convert/parseur_python.py b/convert/parseur_python.py index c577c58e..1d0d749f 100644 --- a/convert/parseur_python.py +++ b/convert/parseur_python.py @@ -20,10 +20,10 @@ 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 @@ -34,11 +34,11 @@ stringsAndCommentsRE = \ #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)) @@ -53,12 +53,12 @@ else : 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... @@ -192,7 +192,7 @@ class COMMENTAIRE(ENTITE_JDC): # 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): @@ -200,7 +200,7 @@ class COMMANDE(ENTITE_JDC): Retourne self.texte """ return self.texte+'\n' - + def getNbPar(self): """ Retourne la difference entre le nombre de parentheses ouvrantes @@ -228,7 +228,7 @@ class AFFECTATION(ENTITE_JDC): 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 @@ -266,7 +266,7 @@ class AFFECTATION_EVAL(ENTITE_JDC): """ 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 @@ -277,10 +277,10 @@ class AFFECTATION_EVAL(ENTITE_JDC): 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 @@ -290,7 +290,7 @@ class PARSEUR_PYTHON(object): 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 @@ -335,7 +335,7 @@ class PARSEUR_PYTHON(object): 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 @@ -357,7 +357,7 @@ class PARSEUR_PYTHON(object): def isModificationCatalogue(self,texte) : if self.pattern_commande.match(texte): - return 1 + return 1 def analyse(self): """ @@ -397,7 +397,7 @@ class PARSEUR_PYTHON(object): 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() == '': @@ -421,7 +421,7 @@ class PARSEUR_PYTHON(object): 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) @@ -438,7 +438,7 @@ class PARSEUR_PYTHON(object): 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 @@ -468,7 +468,7 @@ class PARSEUR_PYTHON(object): 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 @@ -536,13 +536,13 @@ class PARSEUR_PYTHON(object): 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 @@ -550,87 +550,87 @@ class PARSEUR_PYTHON(object): i=0 chaine="" while (i', 'exec')