From a2ac5321669b7a6abc232cb8846bd01ab750ff43 Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Mon, 29 Mar 2021 12:17:12 +0200 Subject: [PATCH] reiindent Traducteur --- Traducteur/calcG.py | 198 ++++++++++--------- Traducteur/changeValeur.py | 368 ++++++++++++++++++------------------ Traducteur/dictErreurs.py | 54 +++--- Traducteur/inseremocle.py | 122 ++++++------ Traducteur/load.py | 22 +-- Traducteur/log.py | 16 +- Traducteur/mocles.py | 21 +- Traducteur/movemocle.py | 204 ++++++++++---------- Traducteur/parseur.py | 25 ++- Traducteur/regles.py | 52 ++--- Traducteur/removemocle.py | 34 ++-- Traducteur/renamemocle.py | 47 +++-- Traducteur/traduitV10V11.py | 30 +-- Traducteur/traduitV11V12.py | 44 ++--- Traducteur/traduitV7V8.py | 25 ++- Traducteur/traduitV8V9.py | 7 +- Traducteur/traduitV9V10.py | 12 +- Traducteur/utils.py | 6 +- Traducteur/visiteur.py | 2 +- 19 files changed, 641 insertions(+), 648 deletions(-) diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py index 0fb34d91..2549826d 100644 --- a/Traducteur/calcG.py +++ b/Traducteur/calcG.py @@ -1,4 +1,4 @@ -# -*- coding: utf-8 -*- +#### -*- coding: utf-8 -*- # Copyright (C) 2007-2017 EDF R&D # # This library is free software; you can redistribute it and/or @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # from Traducteur.parseur import FactNode -from Traducteur.load import jdcSet +from Traducteur.load import jdcSet import logging dict_commande={} @@ -29,129 +29,127 @@ import sys #-------------------------------------------------------------------------- def traitementRayon(jdc): #-------------------------------------------------------------------------- - + if "DEFI_FONCTION" not in jdcSet : return for c in jdc.root.childNodes: - if c.name != "DEFI_FONCTION" : continue - monTexte=jdc.getLines()[c.lineno-1] - monNomVariable=monTexte.split("=")[0] - aExecuter=monNomVariable+'=0' - dict_commande[monNomVariable]=c - exec aExecuter in dict_contexte + if c.name != "DEFI_FONCTION" : continue + monTexte=jdc.getLines()[c.lineno-1] + monNomVariable=monTexte.split("=")[0] + aExecuter=monNomVariable+'=0' + dict_commande[monNomVariable]=c + exec aExecuter in dict_contexte liste_MC=(("CALC_G","R_INF_FO"),("CALC_G","R_SUP_FO"),("CALC_G","MODULE_FO")) liste_achanger = chercheValeurSelonGenea2 (jdc,liste_MC) liste_MC=(("CALC_THETA","THETA_3D","R_INF_FO"),("CALC_THETA","THETA_3D","R_SUP_FO"),("CALC_THETA","THETA_3D","MODULE_FO")) liste_achanger2 = chercheValeurSelonGenea3 (jdc,liste_MC) liste_achanger=liste_achanger+liste_achanger2 for item in liste_achanger : - commande=dict_commande[item] - changeValeurABSCNiveau1(commande,jdc) + commande=dict_commande[item] + changeValeurABSCNiveau1(commande,jdc) #---------------------------------- def changeValeurABSCNiveau1(c,jdc): #---------------------------------- for child in c.childNodes: - if child.name != "NOM_PARA":continue - MonTexte=child.getText(jdc) - if len(MonTexte.splitlines()) > 1 : - print "Le Traducteur ne sait pas gerer" - assert(0) - MonTexte=jdc.getLines()[child.lineno-1] - debut=MonTexte.find("NOM_PARA") - debChaine=MonTexte[0:debut+8] - ancien=MonTexte[debut+8:] - egal,nomval,fin=ancien.split("'",2) - nouvelleLigne=debChaine+egal+"'ABSC'"+fin - jdc.getLines()[child.lineno-1]=nouvelleLigne - logging.info("renommage parametre ABSC ligne %d",child.lineno-1) + if child.name != "NOM_PARA":continue + MonTexte=child.getText(jdc) + if len(MonTexte.splitlines()) > 1 : + print "Le Traducteur ne sait pas gerer" + assert(0) + MonTexte=jdc.getLines()[child.lineno-1] + debut=MonTexte.find("NOM_PARA") + debChaine=MonTexte[0:debut+8] + ancien=MonTexte[debut+8:] + egal,nomval,fin=ancien.split("'",2) + nouvelleLigne=debChaine+egal+"'ABSC'"+fin + jdc.getLines()[child.lineno-1]=nouvelleLigne + logging.info("renommage parametre ABSC ligne %d",child.lineno-1) return - + #-------------------------------------------------------------------------- def chercheValeurSelonGenea2(jdc,liste_cherche_valeur): # #-------------------------------------------------------------------------- liste_valeurs=[] for genea in liste_cherche_valeur: - profondeur=len(genea) - if profondeur > 2 : - print "la methode chercheValeurSelonGenea ne convient" - print "pas pour cette généalogie" - assert(0) - command=genea[0] - fact=genea[1] - - for c in jdc.root.childNodes: - if c.name != command:continue - for mc in c.childNodes: - if mc.name != fact:continue - MonTexte=mc.getText(jdc) - try : - #if ( 1) : - exec MonTexte in dict_contexte - monNomVar=MonTexte.split("=")[1] - monNomVarOk=monNomVar - i=-1 - while (monNomVar[i] == "," or monNomVar[i] == " ") : - monNomVarOk=monNomVar[0:i] - i=i-1 - monNomVar=monNomVarOk - i=0 - while (monNomVar[i] == " ") : - monNomVarOk=monNomVar[1:] - i=i+1 - monNomVar=monNomVarOk - if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar) - except : - #else : - logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg") - pass + profondeur=len(genea) + if profondeur > 2 : + print "la methode chercheValeurSelonGenea ne convient" + print "pas pour cette genealogie" + assert(0) + command=genea[0] + fact=genea[1] + + for c in jdc.root.childNodes: + if c.name != command:continue + for mc in c.childNodes: + if mc.name != fact:continue + MonTexte=mc.getText(jdc) + try : + #if ( 1) : + exec MonTexte in dict_contexte + monNomVar=MonTexte.split("=")[1] + monNomVarOk=monNomVar + i=-1 + while (monNomVar[i] == "," or monNomVar[i] == " ") : + monNomVarOk=monNomVar[0:i] + i=i-1 + monNomVar=monNomVarOk + i=0 + while (monNomVar[i] == " ") : + monNomVarOk=monNomVar[1:] + i=i+1 + monNomVar=monNomVarOk + if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar) + except : + #else : + logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg") + pass return liste_valeurs - + #-------------------------------------------------------------------------- def chercheValeurSelonGenea3(jdc,liste_cherche_valeur): #-------------------------------------------------------------------------- liste_valeurs=[] for genea in liste_cherche_valeur: - profondeur=len(genea) - if profondeur > 3 : - print "la methode chercheValeurSelonGenea ne convient" - print "pas pour cette généalogie" - assert(0) - command=genea[0] - fact=genea[1] - mc=genea[2] - - for c in jdc.root.childNodes: - if c.name != command : continue - for mcf in c.childNodes: - if mcf.name != fact : continue - l=mcf.childNodes[:] - for ll in l: - for lc in ll.childNodes: - if lc.name !=mc : continue - MonTexte=lc.getText(jdc) - try : - #if ( 1) : - exec MonTexte in dict_contexte - #monNomVar=MonTexte.split("=")[1][0:-1] - monNomVar=MonTexte.split("=")[1] - monNomVarOk=monNomVar - i=-1 - while (monNomVar[i] == "," or monNomVar[i] == " ") : - monNomVarOk=monNomVar[0:i] - i=i-1 - monNomVar=monNomVarOk - i=0 - while (monNomVar[i] == " ") : - monNomVarOk=monNomVar[1:] - i=i+1 - monNomVar=monNomVarOk - if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar) - except : - #else : - logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg") - pass - return liste_valeurs - + profondeur=len(genea) + if profondeur > 3 : + print "la methode chercheValeurSelonGenea ne convient" + print "pas pour cette genealogie" + assert(0) + command=genea[0] + fact=genea[1] + mc=genea[2] + for c in jdc.root.childNodes: + if c.name != command : continue + for mcf in c.childNodes: + if mcf.name != fact : continue + l=mcf.childNodes[:] + for ll in l: + for lc in ll.childNodes: + if lc.name !=mc : continue + MonTexte=lc.getText(jdc) + try : + #if ( 1) : + exec MonTexte in dict_contexte + #monNomVar=MonTexte.split("=")[1][0:-1] + monNomVar=MonTexte.split("=")[1] + monNomVarOk=monNomVar + i=-1 + while (monNomVar[i] == "," or monNomVar[i] == " ") : + monNomVarOk=monNomVar[0:i] + i=i-1 + monNomVar=monNomVarOk + i=0 + while (monNomVar[i] == " ") : + monNomVarOk=monNomVar[1:] + i=i+1 + monNomVar=monNomVarOk + if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar) + except : + #else : + logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg") + pass + return liste_valeurs diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py index f9130016..50b0c9c9 100644 --- a/Traducteur/changeValeur.py +++ b/Traducteur/changeValeur.py @@ -20,7 +20,7 @@ from Traducteur.utils import lineToDict import logging from Traducteur.dictErreurs import ecritErreur -from Traducteur.load import jdcSet +from Traducteur.load import jdcSet from Traducteur.renamemocle import decaleLignesdeNBlancs from Traducteur.removemocle import removeMotCleInFact from Traducteur import regles @@ -32,45 +32,45 @@ def changementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): if command not in jdcSet : return boolChange=0 for c in jdc.root.childNodes: - if c.name != command : continue - trouveUnMC=0 - for mc in c.childNodes: - if mc.name != motcle : continue - trouveUnMC=1 - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-1 - indexTexteMC=0 - while indexLigneGlob < mc.endline : - if indexTexteMC > len(liste_ligne_MC)-1 : break - MaLigneGlob=jdc.getLines()[indexLigneGlob] - MaLigneTexte=liste_ligne_MC[indexTexteMC] - for Valeur in DictNouvVal : - MaLigneTexteDict=lineToDict(MaLigneTexte) - trouvecol=MaLigneTexte.find(Valeur) - if trouvecol > -1: - trouve=(Valeur==MaLigneTexteDict[trouvecol]) - else: - trouve=False - if trouve: - debut=MaLigneGlob.find(motcle) - if debut==-1 : debut=0 - Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur]) - Nouveau=MaLigneGlob[0:debut]+Nouveau - jdc.getLines()[indexLigneGlob]=Nouveau - MaLigneTexte=Nouveau # raccourci honteux mais ... - MaLigneGlob=Nouveau - if Valeur in liste : - ecritErreur((command,motcle,Valeur),indexLigneGlob) - else : - logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) - boolChange=1 - indexLigneGlob=indexLigneGlob+1 - indexTexteMC=indexTexteMC+1 - if (trouveUnMC == 0) and ( defaut == 1): - ecritErreur((command,motcle,"DEFAUT"),c.lineno) + if c.name != command : continue + trouveUnMC=0 + for mc in c.childNodes: + if mc.name != motcle : continue + trouveUnMC=1 + TexteMC=mc.getText(jdc) + liste_ligne_MC=TexteMC.splitlines() + indexLigneGlob=mc.lineno-1 + indexTexteMC=0 + while indexLigneGlob < mc.endline : + if indexTexteMC > len(liste_ligne_MC)-1 : break + MaLigneGlob=jdc.getLines()[indexLigneGlob] + MaLigneTexte=liste_ligne_MC[indexTexteMC] + for Valeur in DictNouvVal : + MaLigneTexteDict=lineToDict(MaLigneTexte) + trouvecol=MaLigneTexte.find(Valeur) + if trouvecol > -1: + trouve=(Valeur==MaLigneTexteDict[trouvecol]) + else: + trouve=False + if trouve: + debut=MaLigneGlob.find(motcle) + if debut==-1 : debut=0 + Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur]) + Nouveau=MaLigneGlob[0:debut]+Nouveau + jdc.getLines()[indexLigneGlob]=Nouveau + MaLigneTexte=Nouveau # raccourci honteux mais ... + MaLigneGlob=Nouveau + if Valeur in liste : + ecritErreur((command,motcle,Valeur),indexLigneGlob) + else : + logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) + boolChange=1 + indexLigneGlob=indexLigneGlob+1 + indexTexteMC=indexTexteMC+1 + if (trouveUnMC == 0) and ( defaut == 1): + ecritErreur((command,motcle,"DEFAUT"),c.lineno) if boolChange : jdc.reset(jdc.getSource()) - + #-------------------------------------------------------------------------------- def changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),ensemble=regles.SansRegle,defaut=0): #-------------------------------------------------------------------------------- @@ -86,7 +86,7 @@ def changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),ensemble= for ll in l: trouveUnMC=0 for mc in ll.childNodes: - if mc.name != motcle:continue + if mc.name != motcle:continue if ensemble.verif(c) == 0 : continue trouveUnMC=1 TexteMC=mc.getText(jdc) @@ -113,17 +113,17 @@ def changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),ensemble= MaLigneTexte=Nouveau # raccourci honteux mais ... MaLigneGlob=Nouveau if Valeur in liste : - ecritErreur((command,fact,motcle,Valeur),indexLigneGlob) + ecritErreur((command,fact,motcle,Valeur),indexLigneGlob) else : - logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) + logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) boolChange=1 indexLigneGlob=indexLigneGlob+1 indexTexteMC=indexTexteMC+1 if (trouveUnMC == 0) and ( defaut == 1): - logging.warning("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno ) - ecritErreur((command,fact,motcle,"DEFAUT"),c.lineno) + logging.warning("OPTION (defaut) de CALCG a verifier ligne %s" ,c.lineno ) + ecritErreur((command,fact,motcle,"DEFAUT"),c.lineno) if boolChange : jdc.reset(jdc.getSource()) - + #-------------------------------------------------------------------------------- def changementValeurDsMCFSiRegle(jdc,command,fact,motcle,DictNouvVal,liste_regles,defaut=0): #-------------------------------------------------------------------------------- @@ -131,14 +131,14 @@ def changementValeurDsMCFSiRegle(jdc,command,fact,motcle,DictNouvVal,liste_regle mesRegles=regles.ensembleRegles(liste_regles) liste=() changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,mesRegles,defaut) - + #--------------------------------------------------------------------------------------- def changementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste): #--------------------------------------------------------------------------------------- if command not in jdcSet : return defaut=0 - if liste[-1] == "defaut" : - defaut=1 + if liste[-1] == "defaut" : + defaut=1 changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,defaut) #-------------------------------------------------------------------------- @@ -146,8 +146,8 @@ def changementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste): #-------------------------------------------------------------------------- if command not in jdcSet : return defaut=0 - if liste[-1] == "defaut" : - defaut=1 + if liste[-1] == "defaut" : + defaut=1 changementValeur(jdc,command,motcle,DictNouvVal,liste,defaut) #-------------------------------------------------------------------------- @@ -157,52 +157,52 @@ def suppressionValeurs(jdc, command,motcle,liste): if command not in jdcSet : return boolChange=0 for c in jdc.root.childNodes: - if c.name != command : continue - for mc in c.childNodes: - if mc.name != motcle : continue - indexLigneGlob=mc.lineno-1 - while indexLigneGlob < mc.endline-1 : - MaLigneTexte = jdc.getLines()[indexLigneGlob] - MaLigne=MaLigneTexte - for Valeur in liste : - debutMC =MaLigne.find(motcle) - if debutMC ==-1 : debutMC=0 - debut1=MaLigne[0:debutMC] - chercheLigne=MaLigne[debutMC:] - trouve=chercheLigne.find(Valeur) - premier=0 - if trouve > 1 : #on a au moins une quote - debut=debut1 + chercheLigne[0:trouve-1] - index = -1 - while (-1 * index) < len(debut) : - if (debut[index] == "(") : - premier = 1 - if index == -1 : - index=len(debut) - else : - index=index+1 - break - if (debut[index] == "," ) : - break - if (debut[index] != " " ) : - assert(0) - index = index -1 - debLigne = debut[0:index] - fin=trouve+len(Valeur)+1 - if premier == 1 and chercheLigne[fin] == ',': fin = fin + 1 # on supprime la , - finLigne = chercheLigne[fin:] - MaLigne_tmp=debLigne+finLigne - # traitement ligne commancant par , - if len(MaLigne_tmp.strip()) > 0 : - if MaLigne_tmp.strip()[0]==',' : - MaLigne=MaLigne_tmp.strip()[1:] - else : - MaLigne=MaLigne_tmp[0:] - else : - MaLigne=MaLigne_tmp[0:] - boolChange=1 - jdc.getLines()[indexLigneGlob]=MaLigne - indexLigneGlob=indexLigneGlob+1 + if c.name != command : continue + for mc in c.childNodes: + if mc.name != motcle : continue + indexLigneGlob=mc.lineno-1 + while indexLigneGlob < mc.endline-1 : + MaLigneTexte = jdc.getLines()[indexLigneGlob] + MaLigne=MaLigneTexte + for Valeur in liste : + debutMC =MaLigne.find(motcle) + if debutMC ==-1 : debutMC=0 + debut1=MaLigne[0:debutMC] + chercheLigne=MaLigne[debutMC:] + trouve=chercheLigne.find(Valeur) + premier=0 + if trouve > 1 : #on a au moins une quote + debut=debut1 + chercheLigne[0:trouve-1] + index = -1 + while (-1 * index) < len(debut) : + if (debut[index] == "(") : + premier = 1 + if index == -1 : + index=len(debut) + else : + index=index+1 + break + if (debut[index] == "," ) : + break + if (debut[index] != " " ) : + assert(0) + index = index -1 + debLigne = debut[0:index] + fin=trouve+len(Valeur)+1 + if premier == 1 and chercheLigne[fin] == ',': fin = fin + 1 # on supprime la , + finLigne = chercheLigne[fin:] + MaLigne_tmp=debLigne+finLigne + # traitement ligne commancant par , + if len(MaLigne_tmp.strip()) > 0 : + if MaLigne_tmp.strip()[0]==',' : + MaLigne=MaLigne_tmp.strip()[1:] + else : + MaLigne=MaLigne_tmp[0:] + else : + MaLigne=MaLigne_tmp[0:] + boolChange=1 + jdc.getLines()[indexLigneGlob]=MaLigne + indexLigneGlob=indexLigneGlob+1 if boolChange : jdc.reset(jdc.getSource()) #---------------------------------------------- @@ -214,100 +214,100 @@ def appelleMacroSelonValeurConcept(jdc,macro,genea): motcle=genea[1] chaine="CO" for c in jdc.root.childNodes: - if c.name != macro : continue - for mcF in c.childNodes: - if mcF.name != fact : continue - l=mcF.childNodes[:] - l.reverse() - for ll in l: - trouveValeur=0 - for mc in ll.childNodes: - if mc.name != motcle:continue - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-2 - trouveTexteMC=0 - trouveegal=0 - trouvechaine=0 - trouveparent=0 - trouvequote=0 - while indexLigneGlob < mc.endline : - indexLigneGlob=indexLigneGlob+1 - MaLigneTexte=jdc.getLines()[indexLigneGlob] + if c.name != macro : continue + for mcF in c.childNodes: + if mcF.name != fact : continue + l=mcF.childNodes[:] + l.reverse() + for ll in l: + trouveValeur=0 + for mc in ll.childNodes: + if mc.name != motcle:continue + TexteMC=mc.getText(jdc) + liste_ligne_MC=TexteMC.splitlines() + indexLigneGlob=mc.lineno-2 + trouveTexteMC=0 + trouveegal=0 + trouvechaine=0 + trouveparent=0 + trouvequote=0 + while indexLigneGlob < mc.endline : + indexLigneGlob=indexLigneGlob+1 + MaLigneTexte=jdc.getLines()[indexLigneGlob] + + # on commence par chercher TABLE par exemple + # si on ne trouve pas on passe a la ligne suivante + if ( trouveTexteMC == 0 ) : + indice=MaLigneTexte.find(motcle) + if indice < 0 : continue + trouveTexteMC=1 + else : + indice=0 + + # on cherche = + aChercher=MaLigneTexte[indice:] + if (trouveegal == 0 ): + indice=aChercher.find("=") + if indice < 0 : continue + trouveegal = 1 + else : + indice = 0 + + # on cherche CO + aChercher2=aChercher[indice:] + if (trouvechaine == 0 ): + indice=aChercher2.find(chaine) + if indice < 0 : continue + trouvechaine = 1 + else : + indice = 0 - # on commence par chercher TABLE par exemple - # si on ne trouve pas on passe a la ligne suivante - if ( trouveTexteMC == 0 ) : - indice=MaLigneTexte.find(motcle) - if indice < 0 : continue - trouveTexteMC=1 - else : - indice=0 + #on cherche ( + aChercher3=aChercher2[indice:] + if (trouveparent == 0 ): + indice=aChercher3.find('(') + if indice < 0 : continue + trouveparent = 1 + else : + indice = 0 - # on cherche = - aChercher=MaLigneTexte[indice:] - if (trouveegal == 0 ): - indice=aChercher.find("=") - if indice < 0 : continue - trouveegal = 1 - else : - indice = 0 + #on cherche la ' + aChercher4=aChercher3[indice:] + if (trouvequote == 0 ): + indice=aChercher4.find("'") + indice2=aChercher4.find('"') + if (indice < 0) and (indice2 < 0): continue + if (indice < 0) : indice=indice2 + trouvequote = 1 + else : + indice = 0 - # on cherche CO - aChercher2=aChercher[indice:] - if (trouvechaine == 0 ): - indice=aChercher2.find(chaine) - if indice < 0 : continue - trouvechaine = 1 - else : - indice = 0 + trouveValeur=1 + aChercher5=aChercher4[indice+1:] + indice=aChercher5.find("'") + if indice < 0 : indice=aChercher5.find('"') + valeur=aChercher5[:indice] + break - #on cherche ( - aChercher3=aChercher2[indice:] - if (trouveparent == 0 ): - indice=aChercher3.find('(') - if indice < 0 : continue - trouveparent = 1 - else : - indice = 0 - - #on cherche la ' - aChercher4=aChercher3[indice:] - if (trouvequote == 0 ): - indice=aChercher4.find("'") - indice2=aChercher4.find('"') - if (indice < 0) and (indice2 < 0): continue - if (indice < 0) : indice=indice2 - trouvequote = 1 - else : - indice = 0 + if trouveValeur==0 : + logging.error("Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable") + return - trouveValeur=1 - aChercher5=aChercher4[indice+1:] - indice=aChercher5.find("'") - if indice < 0 : indice=aChercher5.find('"') - valeur=aChercher5[:indice] - break - - if trouveValeur==0 : - logging.error("Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable") - return - - if boolChange : - jdc.reset(jdc.getSource()) - logging.error("Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles") - return + if boolChange : + jdc.reset(jdc.getSource()) + logging.error("Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles") + return - boolChange=1 - ligneaTraiter=jdc.getLines()[c.lineno-1] - debut=ligneaTraiter[0:c.colno] - suite=valeur+"=" - fin=ligneaTraiter[c.colno:] - ligne=debut+suite+fin - jdc.getLines()[c.lineno-1]=ligne - nbBlanc=len(valeur)+1 - if c.lineno < c.endline: - decaleLignesdeNBlancs(jdc,c.lineno,c.endline-1,nbBlanc) + boolChange=1 + ligneaTraiter=jdc.getLines()[c.lineno-1] + debut=ligneaTraiter[0:c.colno] + suite=valeur+"=" + fin=ligneaTraiter[c.colno:] + ligne=debut+suite+fin + jdc.getLines()[c.lineno-1]=ligne + nbBlanc=len(valeur)+1 + if c.lineno < c.endline: + decaleLignesdeNBlancs(jdc,c.lineno,c.endline-1,nbBlanc) if boolChange : jdc.reset(jdc.getSource()) #---------------------------------------------- diff --git a/Traducteur/dictErreurs.py b/Traducteur/dictErreurs.py index 1f057c3e..82fc058f 100644 --- a/Traducteur/dictErreurs.py +++ b/Traducteur/dictErreurs.py @@ -19,7 +19,7 @@ # import logging -from Traducteur.load import jdcSet +from Traducteur.load import jdcSet def ecritErreur(listeGena,ligne=None) : @@ -29,23 +29,23 @@ def ecritErreur(listeGena,ligne=None) : maCle=maCle+"_"+Mot #try : if ( 1 == 1) : - maClef=maCle[1:] + maClef=maCle[1:] if maClef in dict_erreurs : - if ligne != None : - logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) - else : - logging.warning("%s",dict_erreurs[maClef]) + if ligne != None : + logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) + else : + logging.warning("%s",dict_erreurs[maClef]) else : - maCle="" - for Mot in listeGena[:-1] : - maCle=maCle+"_"+Mot - maClef=maCle[1:] - maClef=maCle+"_"+"VALEUR" - if maClef in dict_erreurs : - if ligne != None : - logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) - else : - logging.warning("%s",dict_erreurs[maClef]) + maCle="" + for Mot in listeGena[:-1] : + maCle=maCle+"_"+Mot + maClef=maCle[1:] + maClef=maCle+"_"+"VALEUR" + if maClef in dict_erreurs : + if ligne != None : + logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) + else : + logging.warning("%s",dict_erreurs[maClef]) #except : # pass @@ -53,10 +53,10 @@ def genereErreurPourCommande(jdc,listeCommande) : commands= jdc.root.childNodes[:] commands.reverse() for c in commands: - if type(listeCommande)==list: + if type(listeCommande)==list: for Mot in listeCommande : - if c.name != Mot :continue - ecritErreur((Mot,),c.lineno) + if c.name != Mot :continue + ecritErreur((Mot,),c.lineno) else: if c.name != listeCommande :continue ecritErreur((listeCommande,),c.lineno) @@ -70,9 +70,9 @@ def genereErreurMotCleInFact(jdc,command,fact,mocle): for ll in l: for n in ll.childNodes: if n.name != mocle: - continue - else : - ecritErreur((command,fact,mocle,),c.lineno) + continue + else : + ecritErreur((command,fact,mocle,),c.lineno) def genereErreurMCF(jdc,command,fact): for c in jdc.root.childNodes: @@ -80,7 +80,7 @@ def genereErreurMCF(jdc,command,fact): for mc in c.childNodes: if mc.name != fact: continue - else : + else : ecritErreur((command,fact,),c.lineno) def genereErreurValeur(jdc,command,fact,list_valeur): @@ -90,9 +90,9 @@ def genereErreurValeur(jdc,command,fact,list_valeur): if mc.name != fact:continue texte=mc.getText(jdc) for valeur in list_valeur: - trouve=texte.find(valeur) - if trouve > -1 : - logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,mc.lineno) + trouve=texte.find(valeur) + if trouve > -1 : + logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,mc.lineno) def genereErreurValeurDsMCF(jdc,command,fact,mocle,list_valeur): for c in jdc.root.childNodes: @@ -106,5 +106,5 @@ def genereErreurValeurDsMCF(jdc,command,fact,mocle,list_valeur): texte=n.getText(jdc) for valeur in list_valeur: trouve=texte.find(valeur) - if trouve > -1 : + if trouve > -1 : logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,n.lineno) diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index 98448b99..19dc1ceb 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -19,7 +19,7 @@ # import logging from Traducteur.parseur import FactNode -from Traducteur.load import jdcSet +from Traducteur.load import jdcSet from Traducteur.dictErreurs import ecritErreur from Traducteur import regles debug=0 @@ -28,14 +28,14 @@ debug=0 #----------------------------------- def insereMotCle(jdc,recepteur,texte): #----------------------------------- -# appelle la methode selon la classe +# appelle la methode selon la classe # du recepteur if recepteur.name not in jdcSet : return if recepteur.__class__.__name__ == "Command" : - if debug : print " Ajout de ", texte, "dans la commande : " ,recepteur.name - insereMotCleDansCommande(jdc,recepteur,texte) - return + if debug : print (" Ajout de ", texte, "dans la commande : " ,recepteur.name ) + insereMotCleDansCommande(jdc,recepteur,texte) + return #-------------------------------------------- @@ -44,27 +44,27 @@ def insereMotCleDansCommande(jdc,command,texte): # insere le texte comme 1er mot cle # de la commande if command.name not in jdcSet : return - if debug : print "insereMotCle ", texte , " dans ", command.name + if debug : print ("insereMotCle ", texte , " dans ", command.name) numcol=chercheDebut1Mot(jdc,command) if numcol > 0 : - jdc.splitLine(command.lineno,numcol) + jdc.splitLine(command.lineno,numcol) indice = -1 - while texte[indice] == " " or texte[indice] == "\n": - indice = indice -1 + while texte[indice] == " " or texte[indice] == "\n": + indice = indice -1 if texte[indice] != "," : texte=texte+"," texteinfo=texte texte=texte+'\n' - jdc.addLine(texte,command.lineno) + jdc.addLine(texte,command.lineno) logging.info("Insertion de : %s ligne %d", texteinfo,command.lineno) - if numcol > 0 : # Les mots clefs etaient sur la même ligne + if numcol > 0 : # Les mots clefs etaient sur la meme ligne jdc.joinLineandNext(command.lineno) #------------------------------------------------------------- def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): #---------------------------------------------------------------- - if debug : print "insereMotCle ", texte , " dans ", facteur.name + if debug : print ("insereMotCle ", texte , " dans ", facteur.name) - if texte[-1] == "\n" : texte=texte[0:-1] + if texte[-1] == "\n" : texte=texte[0:-1] ancien=jdc.getLine(facteur.lineno) # On va chercher la derniere ) pour ajouter avant @@ -73,16 +73,16 @@ def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): # on en met une indice = -1 - while texte[indice] == " " : - indice = indice -1 - if texte[indice] != "," : - texte=texte+"," + while texte[indice] == " " : + indice = indice -1 + if texte[indice] != "," : + texte=texte+"," if (texte.find("#") > -1) and (texte.find("#") < texte.find(",")) : - texte=texte+"\n," - + texte=texte+"\n," + texteinfo=texte texte=texte+"\n" - + ligneaCouper=facteur.lineno while ligneaCouper < facteur.endline + 1 : trouve=0 @@ -93,31 +93,31 @@ def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): longueur=len(ancien) indice=ancien.find("_F") indiceParcours=0 - # pour ne pas tenir compte des autres noms + # pour ne pas tenir compte des autres noms # Attention si 2 MCF sur la meme ligne (la 1ere) if trouveF == 0 : if ((ligneaCouper!=facteur.lineno) or ((ancien.find(facteur.name) < indice ) or (ancien.find(facteur.name) < 0))) : - trouveF=1 - indiceParcours=indice + 2 - # attention pour regler DEFI_FONCTION .. + trouveF=1 + indiceParcours=indice + 2 + # attention pour regler DEFI_FONCTION .. else : - indiceDeCoupe=indiceDeCoupe+indice+2 - ancien=ancien[indice +2:] - continue + indiceDeCoupe=indiceDeCoupe+indice+2 + ancien=ancien[indice +2:] + continue if trouveF == 1 : indiceDeCoupe=indiceDeCoupe+indice # print "indice de Parcours" ,indiceParcours - # print ancien[indiceParcours] - # print ancien[indiceParcours+1] - # print ancien[indiceParcours+2] + # print ancien[indiceParcours] + # print ancien[indiceParcours+1] + # print ancien[indiceParcours+2] while indiceParcours < longueur : if ancien[indiceParcours] == "(" : trouveP=1 - # print "trouve" + # print ("trouve". break if ancien[indiceParcours] != " " : trouveP=0 - # print "mouv" + # print ("mouv") break indiceParcours = indiceParcours+1 trouve = trouveP * trouveF @@ -143,18 +143,18 @@ def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): #----------------------------------- def chercheDebut1Mot(jdc,command): #----------------------------------- -# Retourne le numero de colonne si le 1er mot clef est +# Retourne le numero de colonne si le 1er mot clef est # sur la meme ligne que le mot clef facteur # -1 sinon assert (command.childNodes != []) debut=-1 node1=command.childNodes[0] if hasattr(node1,"lineno"): - if node1.lineno == command.lineno : - debut=node1.colno + if node1.lineno == command.lineno : + debut=node1.colno else: - debut=chercheDebutFacteur(jdc,command) - if debut == -1 and debug : print "attention!!! pb pour trouver le debut dans ", command + debut=chercheDebutFacteur(jdc,command) + if debut == -1 and debug : print ("attention!!! pb pour trouver le debut dans ", command) return debut #----------------------------------- @@ -165,14 +165,14 @@ def chercheDebutFacteur(jdc,facteur): debut=ligne.find("_F") if debut > -1 : debut=debut + 3 return debut - + #----------------------------------- def chercheAlignement(jdc,command): #----------------------------------- # Retourne le nb de blanc # pour aligner sur le 1er mot clef fils - assert (command.childNodes != []) + assert (command.childNodes != []) node1=command.childNodes[0] nbBlanc=node1.colno return " "*nbBlanc @@ -185,10 +185,10 @@ def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle, # appelle insereMotCle pour ajouter le texte # boolChange=0 - if estunFacteur : - texte=nouveau+"=_F()," + if estunFacteur : + texte=nouveau+"=_F()," else : - texte=nouveau + texte=nouveau if nomcommande not in jdcSet : return commands= jdc.root.childNodes[:] commands.reverse() @@ -218,7 +218,7 @@ def chercheOperInsereMotCleSiRegle(jdc,nomcommande,nouveau,liste_regles, estunFa mesRegles=regles.ensembleRegles(liste_regles) chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur) - + #--------------------------------------------------------------------------------------------------------- def chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1): #--------------------------------------------------------------------------------------------------------- @@ -235,10 +235,10 @@ def ajouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle # appelle insereMotCle pour ajouter le texte # if commande not in jdcSet : return - if estunFacteur : - texte=nouveau+"=_F()," + if estunFacteur : + texte=nouveau+"=_F()," else : - texte=nouveau + texte=nouveau commands= jdc.root.childNodes[:] commands.reverse() boolChange=0 @@ -271,19 +271,19 @@ def ajouteMotClefDansFacteurCourantSiRegle(jdc,commande,fact,nouveau,liste_regle for c in commands: if c.name != commande : continue for mcF in c.childNodes: - if mcF.name != fact : continue - l=mcF.childNodes[:] - l.reverse() - for ll in l: - if ensemble.verif(ll) == 0 : continue - boolChange=1 - n=ll.childNodes[0] - ligneaCouper=n.lineno-1 - numcol=n.colno - jdc.splitLine(ligneaCouper+1,numcol) - texte=nouveau+",\n" - jdc.addLine(texte,ligneaCouper+1) - logging.info("Insertion de %s dans %s : ligne %d", nouveau,c.name,ligneaCouper+1) - if numcol > 0 : - jdc.joinLineandNext(ligneaCouper+1) + if mcF.name != fact : continue + l=mcF.childNodes[:] + l.reverse() + for ll in l: + if ensemble.verif(ll) == 0 : continue + boolChange=1 + n=ll.childNodes[0] + ligneaCouper=n.lineno-1 + numcol=n.colno + jdc.splitLine(ligneaCouper+1,numcol) + texte=nouveau+",\n" + jdc.addLine(texte,ligneaCouper+1) + logging.info("Insertion de %s dans %s : ligne %d", nouveau,c.name,ligneaCouper+1) + if numcol > 0 : + jdc.joinLineandNext(ligneaCouper+1) if boolChange : jdc.reset(jdc.getSource()) diff --git a/Traducteur/load.py b/Traducteur/load.py index 2375e805..97128e83 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -28,7 +28,7 @@ jdcSet=sets.Set() class JDCTrad: - """Cet objet conserve toutes les informations relatives à un fichier de commandes .comm""" + """Cet objet conserve toutes les informations relatives a un fichier de commandes .comm""" def __init__(self,src,atraiter): #---------------------------------------- @@ -52,14 +52,14 @@ class JDCTrad: def reset(self,src): #----------------------- - # reconstruction + # reconstruction self.init(src,self.atraiter) self.parseKeywords() def getSource(self): #----------------------- # retourne la concatenation de - # toutes les lignes + # toutes les lignes return "".join(self.getLines()) def getLine(self,linenum): @@ -69,7 +69,7 @@ class JDCTrad: def getLines(self): #---------------------------- - # retourne toutes les lignes + # retourne toutes les lignes return self.lines def addLine(self,ligne,numero) : @@ -86,13 +86,13 @@ class JDCTrad: #---------------------------------------------- # coupe la ligne numeroLigne en 2 a numeroColonne # ajoute des blancs en debut de 2nde Ligne pour - # aligner + # aligner numeroLigne = numeroLigne -1 Ldebut=self.lines[0:numeroLigne] if len(self.lines) > numeroLigne : - Lfin=self.lines[numeroLigne+1:] + Lfin=self.lines[numeroLigne+1:] else : - Lfin=[] + Lfin=[] Lsplit=self.lines[numeroLigne] LigneSplitDebut=Lsplit[0:numeroColonne]+"\n" LigneSplitFin=" "*numeroColonne+Lsplit[numeroColonne:] @@ -106,17 +106,17 @@ class JDCTrad: # enleve les blancs de debut de la ligne (numeroLigne +1) Ldebut=self.lines[0:numeroLigne-1] if len(self.lines) > numeroLigne : - Lfin=self.lines[numeroLigne+1:] + Lfin=self.lines[numeroLigne+1:] else : - Lfin=[] + Lfin=[] ligneMilieuDeb=self.lines[numeroLigne - 1 ] ligneMilieuDeb=ligneMilieuDeb[0:-1] ligneMilieuFin=self.lines[numeroLigne] for i in range(len(ligneMilieuFin)): if ligneMilieuFin[i] != " " : - ligneMilieuFin=ligneMilieuFin[i:] - break + ligneMilieuFin=ligneMilieuFin[i:] + break Lmilieu=[ligneMilieuDeb+ligneMilieuFin,] self.lines=Ldebut+Lmilieu+Lfin diff --git a/Traducteur/log.py b/Traducteur/log.py index 15b0f9c1..21c4ab61 100644 --- a/Traducteur/log.py +++ b/Traducteur/log.py @@ -23,23 +23,23 @@ import os logger=logging.getLogger() def initialise(flog=None): - if flog == None : - MonHome=os.environ['HOME'] - MaDir=MonHome+"/Eficas_install" - try : + if flog == None : + MonHome=os.environ['HOME'] + MaDir=MonHome+"/Eficas_install" + try : os.mkdir(MaDir) - except : + except : pass - try : + try : os.listdir(MaDir) flog=MaDir+"/convert.log" - except : + except : flog='/tmp/convert.log' hdlr=logging.FileHandler(flog,'w') formatter = logging.Formatter('%(levelname)s: %(message)s') hdlr.setFormatter(formatter) - logger.addHandler(hdlr) + logger.addHandler(hdlr) logger.setLevel(logging.INFO) return hdlr diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py index 08b2c765..ad5d9bd4 100644 --- a/Traducteur/mocles.py +++ b/Traducteur/mocles.py @@ -32,7 +32,7 @@ def parseFact(match,c,kw): submatch=match[2] lastpar=match[0]+lastParen(c.src[match[0]:]) if type(submatch[0][0]) ==types.IntType: - #mot cle facteur isolé + #mot cle facteur isole no=FactNode() kw.addChild(no) for ii in range(len(submatch)-1): @@ -84,7 +84,7 @@ def parseFact(match,c,kw): #----------------------- def parseKeywords(root): #----------------------- - """A partir d'un arbre contenant des commandes, ajoute les noeuds + """A partir d'un arbre contenant des commandes, ajoute les noeuds fils correspondant aux mocles de la commande """ #print "parseKeywords" @@ -103,9 +103,9 @@ def parseKeywords(root): visitor.walk(ast, matchFinder) #print matchFinder.matches if len(matchFinder.matches) > 1: - # plusieurs mocles trouvés : - # un mocle commence au début du keyword (matchFinder.matches[i][0]) - # et finit juste avant le keyword suivant + # plusieurs mocles trouves : + # un mocle commence au debut du keyword (matchFinder.matches[i][0]) + # et finit juste avant le keyword suivant # (matchFinder.matches[i+1][0]]) for i in range(len(matchFinder.matches)-1): if debug:print "texte:",c.src[matchFinder.matches[i][0]:matchFinder.matches[i+1][0]] @@ -122,8 +122,8 @@ def parseKeywords(root): if submatch: parseFact(matchFinder.matches[i],c,kw) - # dernier mocle : - # il commence au debut du dernier keyword + # dernier mocle : + # il commence au debut du dernier keyword # (matchFinder.matches[i+1][0]) et # finit avant la parenthese fermante de la commande (c.lastParen) @@ -142,9 +142,9 @@ def parseKeywords(root): parseFact(matchFinder.matches[i+1],c,kw) elif len(matchFinder.matches) == 1: - #un seul mocle trouve : - # il commence au début du keyword (matchFinder.matches[0][0]) et - # finit juste avant la parenthese fermante de la + #un seul mocle trouve : + # il commence au debut du keyword (matchFinder.matches[0][0]) et + # finit juste avant la parenthese fermante de la # commande (c.lastParen) if debug:print "texte:",c.src[matchFinder.matches[0][0]:c.lastParen] x,y=indexToCoordinates(c.src,matchFinder.matches[0][0]) @@ -161,4 +161,3 @@ def parseKeywords(root): parseFact(matchFinder.matches[0],c,kw) else: pass - diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index d75ae999..b6b8d919 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -61,7 +61,7 @@ def moveMotCleFromFactToFactMulti(jdc,oper,factsource,mocle,liste_factcible): #---------------------------------------------------------------------------- # exemple type STAT_NON_LINE et RESI_INTER_RELA for factcible in liste_factcible : - moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible) + moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible) removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) @@ -77,35 +77,35 @@ def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): if c.name != oper : continue cible=None for mc in c.childNodes: - if mc.name != factcible : - continue - else : - cible=mc - break + if mc.name != factcible : + continue + else : + cible=mc + break if cible==None : - if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée" + continue for mc in c.childNodes: - source=None - if mc.name != factsource: - continue - else : - source=mc - break + source=None + if mc.name != factsource: + continue + else : + source=mc + break if source==None : - if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée" + continue if debug : print "Changement pour ", oper, " ", factsource, " ",mocle, "cible et source trouvées" l=source.childNodes[:] for ll in l: - for n in ll.childNodes: - if n.name != mocle:continue - MonTexte=n.getText(jdc); - inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) - boolChange=1 - logging.info("Changement de place %s ligne %s vers %s",n.name, n.lineno, cible.name) + for n in ll.childNodes: + if n.name != mocle:continue + MonTexte=n.getText(jdc); + inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) + boolChange=1 + logging.info("Changement de place %s ligne %s vers %s",n.name, n.lineno, cible.name) if boolChange : jdc.reset(jdc.getSource()) removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) @@ -126,25 +126,25 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible,plusieursFois=True): if c.name != oper : continue cible=None for mc in c.childNodes: - if mc.name != factcible : - continue - else : - cible=mc - break + if mc.name != factcible : + continue + else : + cible=mc + break if cible==None : - if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" + continue source=None for mc in c.childNodes: - if mc.name != mocle: - continue - else : - source=mc - break + if mc.name != mocle: + continue + else : + source=mc + break if source==None : - if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" + continue MonTexte=source.getText(jdc); boolChange=1 inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte,plusieursFois) @@ -164,51 +164,51 @@ def copyMotClefInOperToFact(jdc,oper,mocle,factcible): if c.name != oper : continue cible=None for mc in c.childNodes: - if mc.name != factcible : - continue - else : - cible=mc - break + if mc.name != factcible : + continue + else : + cible=mc + break if cible==None : - if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" + continue source=None for mc in c.childNodes: - if mc.name != mocle: - continue - else : - source=mc - break + if mc.name != mocle: + continue + else : + source=mc + break if source==None : - if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" - continue + if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" + continue MonTexte=source.getText(jdc); boolChange=1 inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) if boolChange : jdc.reset(jdc.getSource()) - + #---------------------------------------------------------------------- def moveMCFToCommand(jdc,command,factsource,commandcible,factcible): #---------------------------------------------------------------------- # exemple CONTACT en 10 -# CONTACT devient commande DEFI_CONTACT/ZONE -# +# CONTACT devient commande DEFI_CONTACT/ZONE +# if command not in jdcSet : return boolChange=0 commands= jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command : continue - for mcF in c.childNodes: - if mcF.name != factsource : continue - l=mcF.getText(jdc) - texte=l.replace(factsource,factcible) - texte='xxxx='+commandcible+'('+texte+')\n' - jdc.splitLine(c.lineno,0) - jdc.addLine(texte,c.lineno) - logging.info("Deplacement de %s dans %s ligne %s",factsource,commandcible,c.lineno) - boolChange=1 + if c.name != command : continue + for mcF in c.childNodes: + if mcF.name != factsource : continue + l=mcF.getText(jdc) + texte=l.replace(factsource,factcible) + texte='xxxx='+commandcible+'('+texte+')\n' + jdc.splitLine(c.lineno,0) + jdc.addLine(texte,c.lineno) + logging.info("Deplacement de %s dans %s ligne %s",factsource,commandcible,c.lineno) + boolChange=1 if boolChange : jdc.reset(jdc.getSource()) jdcSet.add(commandcible) @@ -221,26 +221,26 @@ def fusionMotCleToFact(jdc,command,listeMc,factcible,defaut=0): commands= jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command : continue - list_val=[] - trouveUnMC=0 - for mc in c.childNodes: - if mc.name not in listeMc : continue - val=mc.getText(jdc).split("=")[1].split(",")[0] - list_val.append(val) - trouveUnMC=1 - if trouveUnMC : - TexteMC=factcible+"=(" - for val in list_val : TexteMC=TexteMC+val+"," - TexteMC=TexteMC[:-1]+")," - inseremocle.insereMotCle(jdc,c,TexteMC) - jdc.reset(jdc.getSource()) - boolChange=1 + if c.name != command : continue + list_val=[] + trouveUnMC=0 + for mc in c.childNodes: + if mc.name not in listeMc : continue + val=mc.getText(jdc).split("=")[1].split(",")[0] + list_val.append(val) + trouveUnMC=1 + if trouveUnMC : + TexteMC=factcible+"=(" + for val in list_val : TexteMC=TexteMC+val+"," + TexteMC=TexteMC[:-1]+")," + inseremocle.insereMotCle(jdc,c,TexteMC) + jdc.reset(jdc.getSource()) + boolChange=1 if boolChange : jdc.reset(jdc.getSource()) - for mc in listeMc : - removemocle.removeMotCle(jdc,command,mc) - jdc.reset(jdc.getSource()) + for mc in listeMc : + removemocle.removeMotCle(jdc,command,mc) + jdc.reset(jdc.getSource()) #----------------------------------------------------- def fusionMotCleInFact(jdc,command,fact,listeMc,new_name,defaut=0): @@ -268,9 +268,9 @@ def fusionMotCleInFact(jdc,command,fact,listeMc,new_name,defaut=0): boolChange=1 if boolChange : jdc.reset(jdc.getSource()) - for mc in listeMc : - removemocle.removeMotCleInFact(jdc,command,fact,mc) - jdc.reset(jdc.getSource()) + for mc in listeMc : + removemocle.removeMotCleInFact(jdc,command,fact,mc) + jdc.reset(jdc.getSource()) #----------------------------------------------------- def fusionMCFToMCF(jdc,command,listeMcF,factcible,defaut=0): @@ -312,7 +312,7 @@ def fusionMCFToMCF(jdc,command,listeMcF,factcible,defaut=0): boolChange=1 if boolChange : jdc.reset(jdc.getSource()) - for mcF in listeMcF : + for mcF in listeMcF : removemocle.removeMotCle(jdc,command,mcF) jdc.reset(jdc.getSource()) @@ -326,21 +326,21 @@ def eclaMotCleToFact(jdc,command,motcle,mot1,mot2,defaut=0): if command not in jdcSet : return boolChange=0 for c in jdc.root.childNodes: - if c.name != command : continue - trouveUnMC=0 - for mc in c.childNodes: - if mc.name != motcle : continue - trouveUnMC=1 - TexteMC=mc.getText(jdc) - indexLigneGlob=mc.lineno-1 - MaLigneGlob=jdc.getLines()[indexLigneGlob] - Ligne=TexteMC.split('(')[1].split(')')[0].split(',') - motcle1=mot1+"="+Ligne[0] - motcle2=mot2+"=("+Ligne[1]+','+Ligne[2]+','+Ligne[3]+')' - texte=motcle+'=_F('+motcle1+','+motcle2+')' - num=lastParen(TexteMC) - Nouveau=MaLigneGlob.replace(TexteMC[0:num],texte) - jdc.getLines()[indexLigneGlob]=Nouveau - logging.info("Transformation de %s dans %s ligne %s",motcle,command,c.lineno) - boolChange=1 + if c.name != command : continue + trouveUnMC=0 + for mc in c.childNodes: + if mc.name != motcle : continue + trouveUnMC=1 + TexteMC=mc.getText(jdc) + indexLigneGlob=mc.lineno-1 + MaLigneGlob=jdc.getLines()[indexLigneGlob] + Ligne=TexteMC.split('(')[1].split(')')[0].split(',') + motcle1=mot1+"="+Ligne[0] + motcle2=mot2+"=("+Ligne[1]+','+Ligne[2]+','+Ligne[3]+')' + texte=motcle+'=_F('+motcle1+','+motcle2+')' + num=lastParen(TexteMC) + Nouveau=MaLigneGlob.replace(TexteMC[0:num],texte) + jdc.getLines()[indexLigneGlob]=Nouveau + logging.info("Transformation de %s dans %s ligne %s",motcle,command,c.lineno) + boolChange=1 if boolChange : jdc.reset(jdc.getSource()) diff --git a/Traducteur/parseur.py b/Traducteur/parseur.py index e715f2a9..3a525a2f 100644 --- a/Traducteur/parseur.py +++ b/Traducteur/parseur.py @@ -110,14 +110,14 @@ class Keyword(Node): debut=jdc.getLines()[self.lineno-1][self.colno:] fin = jdc.getLines()[self.endline-1][:self.endcol] texte=debut - lignecourante=self.lineno + lignecourante=self.lineno while lignecourante < self.endline -1 : texte = texte + jdc.getLines()[lignecourante] lignecourante = lignecourante + 1 - if chaineBlanche(fin) == 0 : - texte=texte + fin + if chaineBlanche(fin) == 0 : + texte=texte + fin if texte[-1] == "\n" : - texte=texte[0:-1] + texte=texte[0:-1] else: texte = jdc.getLines()[self.lineno-1][self.colno:self.endcol] return texte @@ -147,7 +147,7 @@ def parser(src,atraiter): #------------------------ """Parse le texte src et retourne un arbre syntaxique (root). - Cet arbre syntaxique a comme noeuds (childNodes) les commandes à traiter (liste atraiter) + Cet arbre syntaxique a comme noeuds (childNodes) les commandes a traiter (liste atraiter) """ lines=src.splitlines(1) maskedSrc=maskStringsAndComments(src) @@ -155,8 +155,8 @@ def parser(src,atraiter): root=JDCNode(src) - # (a) dans un premier temps on extrait les commandes et on les insère - # dans un arbre (root) les noeuds fils sont stockés dans + # (a) dans un premier temps on extrait les commandes et on les insere + # dans un arbre (root) les noeuds fils sont stockes dans # root.childNodes (liste) lineno=0 for line in maskedLines: @@ -171,16 +171,16 @@ def parser(src,atraiter): if m and (m.group(2) in atraiter): root.addChild(Command(m.group(2),lineno,m.start(2),m.end(4))) - #(b) dans un deuxième temps , on récupère le texte complet de la commande - # jusqu'à la dernière parenthèse fermante + #(b) dans un deuxieme temps , on recupere le texte complet de la commande + # jusqu'a la derniere parenthese fermante - # iterateur sur les lignes physiques masquées + # iterateur sur les lignes physiques masquees iterlines=iter(maskedLines) linenum=0 for c in root.childNodes: lineno=c.lineno - colno=c.colno # début de la commande + colno=c.colno # debut de la commande while linenum < lineno: line=iterlines.next() linenum=linenum+1 @@ -200,7 +200,7 @@ def parser(src,atraiter): hangingComments ^= line.count('"""') % 2 hangingComments ^= line.count("'''") % 2 - + if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0: raise UnbalancedBracesException() @@ -271,4 +271,3 @@ def lastParen2(src): if level == 0: #derniere parenthese fermante return i - diff --git a/Traducteur/regles.py b/Traducteur/regles.py index dd11ff29..034844f7 100644 --- a/Traducteur/regles.py +++ b/Traducteur/regles.py @@ -60,7 +60,7 @@ class pasDeRegle(ensembleRegles): Vérification """ return 1 - + #------------ class regle : @@ -79,7 +79,7 @@ class regle : """ f = self.fonction(self.list_args) return f.verif(commande) - + #--------------------- class existeMCFParmi : #--------------------- @@ -95,7 +95,7 @@ class existeMCFParmi : """ bool = 0 for c in commande.childNodes : - if c.name in self.listeMCF : + if c.name in self.listeMCF : bool = 1 break return bool @@ -116,7 +116,7 @@ class nexistepasMCFParmi(existeMCFParmi) : bool = existeMCFParmi.verif(self, commande) if bool : return 0 return 1 - + #---------------------- class existeMCsousMCF : #---------------------- @@ -134,7 +134,7 @@ class existeMCsousMCF : """ bool = 0 for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + if mcf.name != self.MCF : continue l = mcf.childNodes[:] l.reverse() for ll in l: @@ -173,7 +173,7 @@ class nexistepasMCsousMCF(existeMCsousMCF): """ def __init__(self, list_arg): existeMCsousMCF.__init__(self, list_arg) - + def verif(self, commande): """ @@ -191,7 +191,7 @@ class nexistepasMCsousMCFcourant(existeMCsousMCFcourant): """ def __init__(self, list_arg): existeMCsousMCFcourant.__init__(self, list_arg) - + def verif(self, commande): """ @@ -218,7 +218,7 @@ class existe : if niveau == len(self.genea) : return 1 texte = self.genea[niveau] for c in commande.childNodes : - if c.name == texte : + if c.name == texte : niveau = niveau+1 return self.chercheMot(niveau, c) return None @@ -248,7 +248,7 @@ class nexistepas : if niveau == len(self.genea) : return 1 texte = self.genea[niveau] for c in commande.childNodes : - if c.name == texte : + if c.name == texte : niveau = niveau+1 return self.chercheMot(niveau, c) return None @@ -281,7 +281,7 @@ class MCsousMCFaPourValeur : """ bool = 0 for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + if mcf.name != self.MCF : continue l = mcf.childNodes[:] l.reverse() for ll in l: @@ -324,7 +324,7 @@ class MCsousMCFcourantaPourValeur : class MCsousMCFaPourValeurDansListe : #---------------------------- """ - Égalité du mot-clé simple à une valeur dans une liste + Égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ def __init__(self, list_arg): @@ -341,7 +341,7 @@ class MCsousMCFaPourValeurDansListe : """ bool = 0 for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + if mcf.name != self.MCF : continue l = mcf.childNodes[:] l.reverse() for ll in l: @@ -351,13 +351,13 @@ class MCsousMCFaPourValeurDansListe : for Val in self.LVal: if (TexteMC.find(Val) < 0 ): continue bool = 1 - return bool + return bool #----------------------------- class MCsousMCFcourantaPourValeurDansListe : #---------------------------- """ - Égalité du mot-clé simple à une valeur dans une liste + Égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ def __init__(self, list_arg): @@ -371,7 +371,7 @@ class MCsousMCFcourantaPourValeurDansListe : """ Vérification """ - bool = 0 + bool = 0 l = mcf.childNodes[:] l.reverse() for mc in l: @@ -380,40 +380,40 @@ class MCsousMCFcourantaPourValeurDansListe : for Val in self.LVal: if (TexteMC.find(Val) < 0 ): continue bool = 1 - return bool + return bool #----------------------------------------- class MCsousMCFcourantnaPasPourValeurDansListe(MCsousMCFcourantaPourValeurDansListe) : #----------------------------------------- """ - Non égalité du mot-clé simple à une valeur dans une liste + Non égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ def __init__(self, list_arg): MCsousMCFcourantaPourValeurDansListe.__init__(self, list_arg) - + def verif(self, commande): bool = MCsousMCFcourantaPourValeurDansListe.verif(self, commande) if bool : return 0 return 1 - + #----------------------------------------- class MCsousMCFnaPasPourValeurDansListe(MCsousMCFaPourValeurDansListe) : #----------------------------------------- """ - Non égalité du mot-clé simple à une valeur dans une liste + Non égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ def __init__(self, list_arg): MCsousMCFaPourValeurDansListe.__init__(self, list_arg) - + def verif(self, commande): bool = MCsousMCFaPourValeurDansListe.verif(self, commande) if bool : return 0 return 1 - + #------------------------------ class MCaPourValeur : #------------------------------ @@ -432,7 +432,7 @@ class MCaPourValeur : """ bool = 0 for mc in commande.childNodes : - if mc.name != self.MC : continue + if mc.name != self.MC : continue TexteMC = mc.getText(self.Jdc) if (TexteMC.find(self.Val) < 0 ): continue bool = 1 @@ -442,7 +442,7 @@ class MCaPourValeur : class MCnaPasPourValeur(MCaPourValeur) : #----------------------------------------- """ - Non égalité du mot-clé à une valeur + Non égalité du mot-clé à une valeur """ def __init__(self, list_arg): MCaPourValeur.__init__(self, list_arg) @@ -473,7 +473,7 @@ class MCaPourValeurDansListe : """ bool = 0 for mc in commande.childNodes : - if mc.name != self.MC : continue + if mc.name != self.MC : continue TexteMC = mc.getText(self.Jdc) #print "TexteMC=",type(TexteMC),TexteMC #print "LVal=",type(self.LVal),self.LVal @@ -488,7 +488,7 @@ class MCaPourValeurDansListe : class MCnaPasPourValeurDansListe(MCaPourValeurDansListe) : #----------------------------------------- """ - Non égalité du mot-clé à une valeur dans une liste + Non égalité du mot-clé à une valeur dans une liste """ def __init__(self, list_arg): MCaPourValeurDansListe.__init__(self, list_arg) diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index f9da5345..6694cc1d 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -25,8 +25,8 @@ from Traducteur.load import jdcSet debug=0 #debug=1 -#on n'a qu'un mocle par commande. On peut donc supprimer le mocle sans trop de précautions (a part iterer a l'envers sur les commandes) -#avant de supprimer un autre mocle, on remet à jour l'arbre syntaxique (lineno,colno,etc.) +#on n'a qu'un mocle par commande. On peut donc supprimer le mocle sans trop de precautions (a part iterer a l'envers sur les commandes) +#avant de supprimer un autre mocle, on remet a jour l'arbre syntaxique (lineno,colno,etc.) #----------------------------------------------------------------------- @@ -67,7 +67,7 @@ def removeMotCleAvecErreur(jdc,command,mocle) : #-------------------------------------------------------------- if command not in jdcSet : return removeMotCle(jdc,command,mocle,erreur=1) - + #-------------------------------------------------------------------- def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0): @@ -98,7 +98,7 @@ def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles): if command not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) removeCommande(jdc,command,mesRegles,1) - + #--------------------------------- def removeMC(jdc,c,mc): #--------------------------------- @@ -110,7 +110,7 @@ def removeMC(jdc,c,mc): jdc.getLines()[mc.lineno-1]=jdc.getLines()[mc.lineno-1][:mc.colno] jdc.getLines()[mc.endline-1]=jdc.getLines()[mc.endline-1][mc.endcol:] - #attention : supprimer les lignes à la fin + #attention : supprimer les lignes a la fin jdc.getLines()[mc.lineno:mc.endline-1]=[] else: if debug:print "mocle sur une ligne--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:mc.endcol] @@ -121,7 +121,7 @@ def removeMC(jdc,c,mc): #--------------------------------------------------------------------------------- def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0): #---------------------------------------------------------------------------------- - # on itere sur les commandes a l'envers pour ne pas polluer + # on itere sur les commandes a l'envers pour ne pas polluer # les numeros de ligne avec les modifications if command not in jdcSet : return commands= jdc.root.childNodes[:] @@ -183,7 +183,7 @@ def removeMotCleInFactCourantSiRegle(jdc,command,fact,mocle,liste_regles,erreur= removeMC(jdc,c,n) if boolChange : jdc.reset(jdc.getSource()) - + #------------------------------------------ def fusionne(jdc,numLigne): #------------------------------------------ @@ -198,18 +198,18 @@ def fusionne(jdc,numLigne): texte=jdc.getLines()[numLigne] fusion=1 while (index < len(texte)) : - if texte[index] not in (" ",",",")",";","\n") : - fusion=0 - break - index=index+1 - + if texte[index] not in (" ",",",")",";","\n") : + fusion=0 + break + index=index+1 + if fusion == 0 : return; texte=jdc.getLines()[numLigne -1] if texte.find("#") < 0 : - fusion=1 + fusion=1 else : - fusion=0 - - if fusion : - jdc.joinLineandNext(numLigne) + fusion=0 + + if fusion : + jdc.joinLineandNext(numLigne) diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index 188a24a6..2372bf41 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -20,14 +20,14 @@ import logging import sys from Traducteur.parseur import FactNode -from Traducteur.load import jdcSet +from Traducteur.load import jdcSet from Traducteur import regles from Traducteur.dictErreurs import ecritErreur #debug=1 debug=0 -#on n'a qu'un mocle par commande. -#en fin de traitement, on remet à jour l'arbre syntaxique (lineno,colno,etc.) +#on n'a qu'un mocle par commande. +#en fin de traitement, on remet a jour l'arbre syntaxique (lineno,colno,etc.) #-------------------------------------------------------------------------------- def renameMotCle(jdc,command,mocle,new_name, erreur=0,ensemble=regles.SansRegle): @@ -42,16 +42,16 @@ def renameMotCle(jdc,command,mocle,new_name, erreur=0,ensemble=regles.SansRegle) boolChange=1 if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno if erreur : - ecritErreur((command,mocle),c.lineno) + ecritErreur((command,mocle),c.lineno) else : - logging.info("Renommage de: %s %s ligne %d en %s",c.name,mc.name,mc.lineno,new_name) + logging.info("Renommage de: %s %s ligne %d en %s",c.name,mc.name,mc.lineno,new_name) s=jdc.getLines()[mc.lineno-1] jdc.getLines()[mc.lineno-1]=s[:mc.colno]+new_name+s[mc.colno+len(mocle):] diff=len(new_name) - len(mocle) decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff) if boolChange : jdc.reset(jdc.getSource()) - + #------------------------------------------------------ def renameMotCleAvecErreur(jdc,command,mocle,new_name): #------------------------------------------------------ @@ -87,14 +87,14 @@ def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): #---------------------------------------------------------- ligne = premiere + 1 while ligne < derniere : - s=jdc.getLines()[ligne] - if nbBlanc > 0 : - jdc.getLines()[ligne] = nbBlanc*" " + s - else : - toutblancs=-1*nbBlanc*" " - if jdc.getLines()[ligne][0:-1*nbBlanc] == toutblancs: - jdc.getLines()[ligne] = s[-1*nbBlanc:] - ligne=ligne+1 + s=jdc.getLines()[ligne] + if nbBlanc > 0 : + jdc.getLines()[ligne] = nbBlanc*" " + s + else : + toutblancs=-1*nbBlanc*" " + if jdc.getLines()[ligne][0:-1*nbBlanc] == toutblancs: + jdc.getLines()[ligne] = s[-1*nbBlanc:] + ligne=ligne+1 #--------------------------------------------------------------------------------------------- def renameMotCleInFact(jdc,command,fact,mocle,new_name, ensemble=regles.SansRegle, erreur=0): @@ -116,9 +116,9 @@ def renameMotCleInFact(jdc,command,fact,mocle,new_name, ensemble=regles.SansRegl jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):] boolChange=1 if erreur : - ecritErreur((command,fact,mocle),c.lineno) + ecritErreur((command,fact,mocle),c.lineno) else : - logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) + logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) if boolChange : jdc.reset(jdc.getSource()) @@ -149,13 +149,13 @@ def renameMotCleInFactCourantSiRegle(jdc,command,fact,mocle,new_name,liste_regle jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):] boolChange=1 if erreur : - ecritErreur((command,fact,mocle),c.lineno) + ecritErreur((command,fact,mocle),c.lineno) else : - logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) + logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) if boolChange : jdc.reset(jdc.getSource()) - - + + #----------------------------------------------------------------- def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): #----------------------------------------------------------------- @@ -165,9 +165,9 @@ def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): boolChange=0 if debug : if ensemble != regles.SansRegle : - logging.info("traitement de %s renomme en %s sous conditions", command, new_name) + logging.info("traitement de %s renomme en %s sous conditions", command, new_name) else : - logging.info("traitement de %s renomme en %s ", command, new_name) + logging.info("traitement de %s renomme en %s ", command, new_name) for c in jdc.root.childNodes: if c.name != command:continue if ensemble.verif(c) == 0 : continue @@ -182,8 +182,7 @@ def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): #----------------------------------------------------------- def renameCommandeSiRegle(jdc,command,new_name,liste_regles): #----------------------------------------------------------- - + if command not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) renameCommande(jdc,command,new_name,mesRegles) - diff --git a/Traducteur/traduitV10V11.py b/Traducteur/traduitV10V11.py index aeb62ea8..f15f7b13 100755 --- a/Traducteur/traduitV10V11.py +++ b/Traducteur/traduitV10V11.py @@ -221,11 +221,11 @@ atraiter=( "THER_LINEAIRE", "THER_NON_LINE", "THER_NON_LINE_MO", - + "CALC_CHAMPNO", "CALC_METANO", "CALC_ERREURNO", - + ) dict_erreurs={ @@ -497,7 +497,7 @@ def traduc(infile,outfile,flog=None): suppressionValeurs(jdc,"CALC_CHAMP","ACOUSTIQUE",list(set(lTOUT)-set(lACOUSTIQUE))) suppressionValeurs(jdc,"CALC_CHAMP","ERREUR",list(set(lTOUT)-set(lERREUR))) suppressionValeurs(jdc,"CALC_CHAMP","META",list(set(lTOUT)-set(lMETA))) - ## ajout CALC_META ou CALC_ERREUR + ## ajout CALC_META ou CALC_ERREUR lMOTCLE=[] lMOTCLE=["reuse","RESULTAT","TOUT_ORDRE","NUME_ORDRE","NUME_MODE","NOEUD_CMP","NOM_CAS", "INST","FREQ","LIST_INST","LIST_FREQ","LIST_ORDRE","CRITERE","PRECISION","EXCIT"] @@ -506,10 +506,10 @@ def traduc(infile,outfile,flog=None): llistMETA=list(lMOTCLE) llistMETA.extend(["META",]) for mc in llistMETA : - copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") + copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") moveMCFToCommand(jdc,"CALC_CHAMP","TEMPORAIRE","CALC_META","TEMPORAIRE") for mc in llistMETA : - moveMotCleFromFactToFather(jdc,"CALC_META","TEMPORAIRE",mc) + moveMotCleFromFactToFather(jdc,"CALC_META","TEMPORAIRE",mc) removeCommandeSiRegle(jdc,"CALC_META",((("META","COMP_INCR","ETAT_INIT"),"nexistepasMCFParmi"),)) renameMotCle(jdc,"CALC_META","META","OPTION") removeMotCle(jdc,"CALC_META","TEMPORAIRE",pasDeRegle(),0) @@ -519,10 +519,10 @@ def traduc(infile,outfile,flog=None): llistERREUR=list(lMOTCLE) llistERREUR.extend(["ERREUR","SOLVEUR","RESU_DUAL","PREC_ESTI","TYPE_ESTI"]) for mc in llistERREUR : - copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") + copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") moveMCFToCommand(jdc,"CALC_CHAMP","TEMPORAIRE","CALC_ERREUR","TEMPORAIRE") for mc in llistERREUR : - moveMotCleFromFactToFather(jdc,"CALC_ERREUR","TEMPORAIRE",mc) + moveMotCleFromFactToFather(jdc,"CALC_ERREUR","TEMPORAIRE",mc) removeCommandeSiRegle(jdc,"CALC_ERREUR",((("ERREUR"),"nexistepasMCFParmi"),)) renameMotCle(jdc,"CALC_ERREUR","ERREUR","OPTION") removeMotCle(jdc,"CALC_ERREUR","TEMPORAIRE",pasDeRegle(),0) @@ -703,7 +703,7 @@ def traduc(infile,outfile,flog=None): suppressionValeurs(jdc,"CALC_CHAMPNO","FORCE",list(set(lTOUT)-set(lFORCE))) suppressionValeurs(jdc,"CALC_CHAMPNO","ERREUR",list(set(lTOUT)-set(lERREUR))) suppressionValeurs(jdc,"CALC_CHAMPNO","META",list(set(lTOUT)-set(lMETA))) - ## ajout CALC_METANO ou CALC_ERREURNO + ## ajout CALC_METANO ou CALC_ERREURNO lMOTCLE=[] lMOTCLE=["reuse","RESULTAT","TOUT_ORDRE","NUME_ORDRE","NUME_MODE","NOEUD_CMP","NOM_CAS", "INST","FREQ","LIST_INST","LIST_FREQ","LIST_ORDRE","CRITERE","PRECISION","EXCIT"] @@ -712,10 +712,10 @@ def traduc(infile,outfile,flog=None): llistMETA=list(lMOTCLE) llistMETA.append("META") for mc in llistMETA : - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") + copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") moveMCFToCommand(jdc,"CALC_CHAMPNO","TEMPORAIRE","CALC_METANO","TEMPORAIRE") for mc in llistMETA : - moveMotCleFromFactToFather(jdc,"CALC_METANO","TEMPORAIRE",mc) + moveMotCleFromFactToFather(jdc,"CALC_METANO","TEMPORAIRE",mc) removeCommandeSiRegle(jdc,"CALC_METANO",((("META"),"nexistepasMCFParmi"),)) renameMotCle(jdc,"CALC_METANO","META","OPTION") removeMotCle(jdc,"CALC_METANO","TEMPORAIRE",pasDeRegle(),0) @@ -725,10 +725,10 @@ def traduc(infile,outfile,flog=None): llistERREUR=list(lMOTCLE) llistERREUR.append("ERREUR") for mc in llistERREUR : - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") + copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") moveMCFToCommand(jdc,"CALC_CHAMPNO","TEMPORAIRE","CALC_ERREURNO","TEMPORAIRE") for mc in llistERREUR : - moveMotCleFromFactToFather(jdc,"CALC_ERREURNO","TEMPORAIRE",mc) + moveMotCleFromFactToFather(jdc,"CALC_ERREURNO","TEMPORAIRE",mc) removeCommandeSiRegle(jdc,"CALC_ERREURNO",((("ERREUR"),"nexistepasMCFParmi"),)) renameMotCle(jdc,"CALC_ERREURNO","ERREUR","OPTION") removeMotCle(jdc,"CALC_ERREURNO","TEMPORAIRE",pasDeRegle(),0) @@ -1126,7 +1126,7 @@ def traduc(infile,outfile,flog=None): #### traitement de FORMULE ############################## # Rien à faire - + #### traitement de GENE_ACCE_SEISME ############################## # Rien à faire, n'existe pas en 10 @@ -1353,7 +1353,7 @@ def traduc(infile,outfile,flog=None): renameMotCleInFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","STOP_FREQ_VIDE","STOP_BANDE_VIDE",pasDeRegle(),0) # Renommage critere de Sturm changementValeurDsMCF(jdc,"MACRO_MODE_MECA","VERI_MODE","STURM",{"OUI":"GLOBAL",}) - + #### traitement de MACRO_PROJ_BASE ############################## renameMotCle(jdc,"MACRO_PROJ_BASE","PROFIL","STOCKAGE") # Renommage de la commande @@ -1434,7 +1434,7 @@ def traduc(infile,outfile,flog=None): #### traitement de POST_BORDET ############################## # Rien à faire - + #### traitement de POST_CHAMP ############################## # Rien à faire, n'existe pas en 10 diff --git a/Traducteur/traduitV11V12.py b/Traducteur/traduitV11V12.py index 37212deb..e64fad7c 100755 --- a/Traducteur/traduitV11V12.py +++ b/Traducteur/traduitV11V12.py @@ -107,7 +107,7 @@ atraiter=( "SIMU_POINT_MAT", "TEST_COMPOR", "THER_NON_LINE", - "DEFI_PART_FETI" + "DEFI_PART_FETI" ) dict_erreurs={ @@ -162,7 +162,7 @@ def traduc(infile,outfile,flog=None): #Parse les mocles des commandes parseKeywords(root) - + #### traitement de DEFI_PART_PA_OPS ############################## genereErreurPourCommande(jdc,"DEFI_PART_PA_OPS") @@ -177,7 +177,7 @@ def traduc(infile,outfile,flog=None): #### traitement de AFFE_CHAR_MECA ############################## # Suppression du mot-clé METHODE - removeMotCle(jdc,"AFFE_CHAR_MECA","METHODE",pasDeRegle(),0) + removeMotCle(jdc,"AFFE_CHAR_MECA","METHODE",pasDeRegle(),0) # Suppression des mot-clés LIAISON_XFEM removeMotCle(jdc,"AFFE_CHAR_MECA","LIAISON_XFEM",pasDeRegle(),0) removeMotCle(jdc,"AFFE_CHAR_MECA","CONTACT_XFEM",pasDeRegle(),0) @@ -270,9 +270,9 @@ def traduc(infile,outfile,flog=None): #### traitement de CREA_MAILLAGE ############################## renameMotCle(jdc,"CREA_MAILLAGE","CREA_GROUP_MA","CREA_MAILLE") genereErreurMCF(jdc,"CREA_MAILLAGE","ECLA_PG") - + lMCLEF=['COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1', - 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE','QUAD_LINE', + 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE','QUAD_LINE', 'REPERE','RESTREINT','PENTA15_18'] genereErreurMCF(jdc,"CREA_MAILLAGE","DETR_GROUP_MA") removeMotCleInFactSiRegle(jdc,"CREA_MAILLAGE","DETR_GROUP_MA","NB_MAILLE",((lMCLEF,"nexistepasMCFParmi"),)) @@ -284,7 +284,7 @@ def traduc(infile,outfile,flog=None): removeMotCleInFact(jdc,"DEBUT","CODE","NOM",pasDeRegle(),0) #### traitement de DEFI_COMPOR ############################## - genereErreurValeur(jdc,"DEFI_COMPOR","LOCALISATION",["'RL'",]) + genereErreurValeur(jdc,"DEFI_COMPOR","LOCALISATION",["'RL'",]) genereErreurValeur(jdc,"DEFI_COMPOR","RELATION_KIT",["'RVMIS_ISOT_CINE'",]) genereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MULTIFIBRE","RELATION",["'LABORD_1D'"]) genereErreurMCF(jdc,"DEFI_COMPOR","POLYCRISTAL") @@ -309,8 +309,8 @@ def traduc(infile,outfile,flog=None): genereErreurMCF(jdc,"DEFI_MATER_GC","MAZARS") #### traitement de DEFI_MATERIAU ############################## - lMLA=["F_MRR_RR", "C_MRR_RR", "F_MTT_TT", "C_MTT_TT", "F_MZZ_ZZ", - "C_MZZ_ZZ", "F_MRT_RT", "C_MRT_RT", "F_MRZ_RZ", "C_MRZ_RZ", + lMLA=["F_MRR_RR", "C_MRR_RR", "F_MTT_TT", "C_MTT_TT", "F_MZZ_ZZ", + "C_MZZ_ZZ", "F_MRT_RT", "C_MRT_RT", "F_MRZ_RZ", "C_MRZ_RZ", "F_MTZ_TZ", "C_MTZ_TZ",] for param in lMLA: removeMotCleInFact(jdc,"DEFI_MATERIAU","META_LEMA_ANI",param,pasDeRegle(),0) @@ -320,15 +320,15 @@ def traduc(infile,outfile,flog=None): for mcle in lMDC: removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC",mcle,pasDeRegle(),0) removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC_IRRA",mcle,pasDeRegle(),0) - + removeMotCleInFact(jdc,"DEFI_MATERIAU","UMAT","NB_VALE",pasDeRegle(),0) removeMotCleInFact(jdc,"DEFI_MATERIAU","UMAT_FO","NB_VALE",pasDeRegle(),0) listeMc=["C"+str(i) for i in range(1,198)] fusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT",listeMc,"LISTE_COEF") fusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT_FO",listeMc,"LISTE_COEF") - - removeMotCle(jdc,"DEFI_MATERIAU","LABORD_1D",pasDeRegle(),0) - + + removeMotCle(jdc,"DEFI_MATERIAU","LABORD_1D",pasDeRegle(),0) + genereErreurMCF(jdc,"DEFI_MATERIAU","DIS_VISC") lDISC=["PUIS_DX", "PUIS_DY", "PUIS_DZ", "PUIS_RX", "PUIS_RY", "PUIS_RZ", "COEF_DX", "COEF_DY", "COEF_DZ", "COEF_RX", "COEF_RY", "COEF_RZ"] @@ -383,7 +383,7 @@ def traduc(infile,outfile,flog=None): #### traitement de EXTR_TABLE ############################## changementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"MATR_ELEM":"MATR_TANG_ELEM"}) changementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"CODE_RETOUR":"CODE_RETOUR_INTE"}) - + #### traitement de FACTORISER ############################## renameMotCle(jdc,"FACTORISER","ELIM_LAGR2","ELIM_LAGR") changementValeur(jdc,"FACTORISER","ELIM_LAGR",{"OUI":"LAGR2",}) @@ -427,7 +427,7 @@ def traduc(infile,outfile,flog=None): #### traitement de MACR_ECREVISSE ############################## genereErreurMCF(jdc,"MACR_ECREVISSE","COMP_INCR") - #### traitement de MACR_INFO_MAIL ############################## + #### traitement de MACR_INFO_MAIL ############################## changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_6":"V11_2"}) changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N":"V11_N"}) changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N_PERSO":"V11_N_PERSO"}) @@ -468,7 +468,7 @@ def traduc(infile,outfile,flog=None): moveMotCleFromFactToFact(jdc,"MODE_ITER_INV","CALC_FREQ",mcle,"SOLVEUR_MODAL") moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","PREC_JACOBI","SOLVEUR_MODAL") moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","PREC_BATHE","SOLVEUR_MODAL") - + removeMotCle(jdc,"MODE_ITER_INV","CALC_MODE",pasDeRegle(),0) chercheOperInsereMotCleSiRegle(jdc,"MODE_ITER_INV","OPTION='AJUSTE'",((("OPTION",),"nexistepas"),),0) @@ -493,7 +493,7 @@ def traduc(infile,outfile,flog=None): moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_FREQ","DIM_SOUS_ESPACE","SOLVEUR_MODAL") moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","COEF_DIM_ESPACE","SOLVEUR_MODAL") moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","DIM_SOUS_ESPACE","SOLVEUR_MODAL") - + removeMotCleInFactSiRegle(jdc,"MODE_ITER_SIMULT","CALC_FREQ","APPROCHE", ((("SOLVEUR_MODAL","METHODE",["QZ"],jdc),"MCsousMCFnaPasPourValeurDansListe")or (("SOLVEUR_MODAL","METHODE",),"nexistepasMCsousMCF"), @@ -564,7 +564,7 @@ def traduc(infile,outfile,flog=None): changementValeur(jdc,com,"OPTION",{"FORC_INT_ELEM":"FORC_INTE_ELEM"}) removeMotCleInFactSiRegle(jdc,com,"COMPORTEMENT","NB_VARI",((("COMPORTEMENT","RELATION","'MFRONT'",jdc),"MCsousMCFaPourValeur"),)) - + #### traitement de TEST_COMPOR ############################## genereErreurPourCommande(jdc,"TEST_COMPOR") @@ -574,9 +574,9 @@ def traduc(infile,outfile,flog=None): #### traitement de C_SOLVEUR ############################## lCOM=['CALC_ERREUR', 'CALC_FORC_AJOU', 'CALC_IFS_DNL', 'CALC_MATR_AJOU', 'CALC_PRECONT', - 'CREA_ELEM_SSD', 'DEFI_BASE_MODALE', 'DYNA_LINE_HARM', 'DYNA_LINE_TRAN', 'DYNA_NON_LINE', - 'DYNA_TRAN_MODAL', 'INFO_MODE', 'MACR_ASCOUF_CALC', 'MACR_ASPIC_CALC', 'MACRO_BASCULE_SCHEMA', - 'MACRO_MATR_AJOU', 'MECA_STATIQUE', 'MODE_ITER_SIMULT', 'MODE_ITER_INV', 'MODE_STATIQUE', + 'CREA_ELEM_SSD', 'DEFI_BASE_MODALE', 'DYNA_LINE_HARM', 'DYNA_LINE_TRAN', 'DYNA_NON_LINE', + 'DYNA_TRAN_MODAL', 'INFO_MODE', 'MACR_ASCOUF_CALC', 'MACR_ASPIC_CALC', 'MACRO_BASCULE_SCHEMA', + 'MACRO_MATR_AJOU', 'MECA_STATIQUE', 'MODE_ITER_SIMULT', 'MODE_ITER_INV', 'MODE_STATIQUE', 'STAT_NON_LINE', 'THER_LINEAIRE', 'THER_NON_LINE', 'THER_NON_LINE_MO', 'CALC_ERC_DYN','CALC_MODES',] for com in lCOM: # Suppression de ELIM_LAGR2 @@ -589,11 +589,11 @@ def traduc(infile,outfile,flog=None): lMCLE=["NB_REORTHO_DD","NMAX_ITER","INFO_FETI","RESI_RELA","PARTITION"] for mocle in lMCLE: genereErreurMotCleInFact(jdc,com,"SOLVEUR",mocle) - + #### traitement de DEFI_PART_FETI ############################## genereErreurMCF(jdc,"DEFI_PART_FETI","EXCIT") removeMotCle(jdc,"DEFI_PART_FETI","EXCIT",pasDeRegle(),0) - removeMotCle(jdc,"DEFI_PART_FETI","CORRECTION_CONNEX",pasDeRegle(),0) + removeMotCle(jdc,"DEFI_PART_FETI","CORRECTION_CONNEX",pasDeRegle(),0) genereErreurPourCommande(jdc,"DEFI_PART_FETI") renameCommande(jdc,"DEFI_PART_FETI","DEFI_PARTITION", ) diff --git a/Traducteur/traduitV7V8.py b/Traducteur/traduitV7V8.py index 5f3b6888..d0a79658 100644 --- a/Traducteur/traduitV7V8.py +++ b/Traducteur/traduitV7V8.py @@ -86,11 +86,11 @@ dict_erreurs={ "CALC_CHAM_ELEM":"reecrire la partie SOUR_ELGA_ELEC", "CALC_G_THETA_T_OPTION_VALEUR":"verifier la valeur d OPTION", "CALC_G_THETA_T_OPTION_DEFAUT":"verifier la valeur d OPTION donnee a la place du defaut", - "CALC_G_MODELE":"Mot Clef MODELE supprimé sous CALC_G", - "CALC_G_DEPL":"Mot Clef DEPL supprimé sous CALC_G", - "CALC_G_CHAM_MATER":"Mot Clef CHAM_MATER supprimé sous CALC_G", - "CALC_G_CARA_ELEM":"Mot Clef CARA_ELEM supprimé sous CALC_G", - "CALC_G_RESULTAT=XXX,":"Mot Clef RESULTAT à completer sous CALC_G", + "CALC_G_MODELE":"Mot Clef MODELE supprime sous CALC_G", + "CALC_G_DEPL":"Mot Clef DEPL supprime sous CALC_G", + "CALC_G_CHAM_MATER":"Mot Clef CHAM_MATER supprime sous CALC_G", + "CALC_G_CARA_ELEM":"Mot Clef CARA_ELEM supprime sous CALC_G", + "CALC_G_RESULTAT=XXX,":"Mot Clef RESULTAT a completer sous CALC_G", "AFFE_MODELE_AFFE_MODELISATION_VALEUR":"verifier la valeur de MODELISATION", "STAT_NON_LINE_COMP_INCR_RELATION_VALEUR":"verifier la valeur de RELATION", "STAT_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR":"verifier la valeur de RELATION_KIT", @@ -129,7 +129,7 @@ def traduc(infile,outfile,flog=None): #Parse les mocles des commandes parseKeywords(root) - + ####################### traitement erreurs ######################## genereErreurPourCommande(jdc,("DEBUT","POST_RCCM","DIST_LIGN_3D","IMPR_OAR","COMB_CHAM_NO","COMB_CHAM_ELEM")) @@ -256,7 +256,7 @@ def traduc(infile,outfile,flog=None): moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_THETA","LISSAGE") moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_G","LISSAGE") moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","DEGRE","LISSAGE") - + dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"} changementValeur(jdc,"CALC_G_LOCAL_T","OPTION",dlocal) # @@ -268,13 +268,13 @@ def traduc(infile,outfile,flog=None): renameOper(jdc,"CALC_G_THETA_T","CALC_G") # Attention cela necessite un traitement particulier et ne peut pas etre generalise tel quel - # Attention egalement doit etre fait avant le regroupement dans THETA + # Attention egalement doit etre fait avant le regroupement dans THETA calcG.traitementRayon(jdc) renameMotCle(jdc,"CALC_G","THETA","THETA_OLD") chercheOperInsereFacteur(jdc,"CALC_G","THETA") moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA") renameMotCleInFact(jdc,"CALC_G","THETA","THETA_OLD","THETA") - + moveMotClefInOperToFact(jdc,"CALC_G","FOND_FISS","THETA") moveMotClefInOperToFact(jdc,"CALC_G","R_INF_FO","THETA") moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA") @@ -297,7 +297,7 @@ def traduc(infile,outfile,flog=None): removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","ASSE_GRIL",jdc),"MCsousMCFaPourValeur"),)) removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","3D_JOINT_CT",jdc),"MCsousMCFaPourValeur"),)) renameMotCleInFact(jdc,"AFFE_MODELE","AFFE_SOUS_STRUC","MAILLE","SUPER_MAILLE") - + ####################### traitement PROJ_MESU_MODAL ####################### removeMotCleInFact(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_PARA") removeMotCleInFactSiRegleAvecErreur(jdc,"AFFE_CHAR_MECA","CONTACT","FROTTEMENT",((("CONTACT","METHODE","CONTRAINTE",jdc),"MCsousMCFaPourValeur"),)) @@ -316,7 +316,7 @@ def traduc(infile,outfile,flog=None): moveMotClefInOperToFact(jdc,"CALC_ELEM","ANGLE","REPE_COQUE") moveMotClefInOperToFact(jdc,"CALC_ELEM","PLAN","REPE_COQUE") - + ####################### traitement EXTR_MODE ####################### ajouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF"))) @@ -508,7 +508,7 @@ def main(): parser = optparse.Optionparser(usage=usage) parser.add_option('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier à traduire") + help="Le fichier a traduire") parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm', help="Le fichier traduit") @@ -517,4 +517,3 @@ def main(): if __name__ == '__main__': main() - diff --git a/Traducteur/traduitV8V9.py b/Traducteur/traduitV8V9.py index 224e781b..092e6c19 100644 --- a/Traducteur/traduitV8V9.py +++ b/Traducteur/traduitV8V9.py @@ -85,7 +85,7 @@ def traduc(infile,outfile,flog=None): #Parse les mocles des commandes parseKeywords(root) - + ####################### traitement erreurs ######################## genereErreurPourCommande(jdc,("POST_RCCM","DEFI_MATERIAU","TEST_FICHIER","DYNA_NON_LINE","DEFI_FISS_XFEM","POST_MAIL_XFEM")) @@ -204,7 +204,7 @@ def traduc(infile,outfile,flog=None): renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","K_VP","UN_SUR_K") renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","SEDVP1","ALPHA_D") renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","SEDVP2","BETA_D") - # GLRC + # GLRC renameCommandeSiRegle(jdc,"DEFI_MATERIAU","DEFI_GLRC", ((("GLRC_DAMAGE","GLRC_ACIER",),"existeMCFParmi"),)) ######################################################################### @@ -425,7 +425,7 @@ def main(): parser = optparse.Optionparser(usage=usage) parser.add_option('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier à traduire") + help="Le fichier a traduire") parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm', help="Le fichier traduit") @@ -434,4 +434,3 @@ def main(): if __name__ == '__main__': main() - diff --git a/Traducteur/traduitV9V10.py b/Traducteur/traduitV9V10.py index 45570a61..11db2ccd 100755 --- a/Traducteur/traduitV9V10.py +++ b/Traducteur/traduitV9V10.py @@ -56,16 +56,16 @@ atraiter=("AFFE_CARA_ELEM","AFFE_CHAR_CINE","AFFE_CHAR_MECA","AFFE_CHAR_MECA_F", dict_erreurs={ # STA10 # - "AFFE_CHAR_MECA_CONTACT":"Attention, modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", - "AFFE_CHAR_MECA_LIAISON_UNILATER":"Attention, modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", - "AFFE_CHAR_MECA_F_LIAISON_UNILATER":"Attention, modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_CONTACT":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_LIAISON_UNILATER":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_F_LIAISON_UNILATER":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", "AFFE_CHAR_MECA_GRAPPE_FLUIDE":"Resorption de GRAPPE_FLUIDE en version 10", "DEFI_MATERIAU_LMARC":"Resorption loi LMARC en version 10", "DEFI_MATERIAU_LMARC_FO":"Resorption loi LMARC en version 10", "POST_ZAC":"Resorption POST_ZAC en version 10", "AFFE_CHAR_MECA_ARLEQUIN":"Resorption ARLEQUIN en version 10", - "PROJ_CHAMP_CHAM_NO":"Attention, verifier pour PROJ_CHAMP la présence de MODELE1/MAILLAGE1 et MODELE2/MAILLAGE2", + "PROJ_CHAMP_CHAM_NO":"Attention, verifier pour PROJ_CHAMP la presence de MODELE1/MAILLAGE1 et MODELE2/MAILLAGE2", "COMB_SISM_MODAL_COMB_MULT_APPUI":"Attention, verifier GROUP_APPUI pour COMB_SISM_MODAL car on est dans le cas MULTI_APPUI=DECORRELE", @@ -103,7 +103,7 @@ dict_erreurs={ "MACR_ASPIQ_CALC_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans MACR_ASPIQ_CALC", "SIMU_POINT_MAT_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans SIMU_POINT_MAT", - "CALC_ELEM_SENSIBILITE":"Le post-traitement SENSIBILITE est à supprimer de CALC_ELEM et à faire via CALC_SENSI", + "CALC_ELEM_SENSIBILITE":"Le post-traitement SENSIBILITE est a supprimer de CALC_ELEM et a faire via CALC_SENSI", "CALC_MISS_OPTION":"Attention, transfert MACRO_MISS_3D en CALC_MISS : utiliser un DEFI_SOL_MISS pour obtenir TABLE_SOL", } @@ -737,7 +737,7 @@ def main(): parser = optparse.Optionparser(usage=usage) parser.add_option('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier à traduire") + help="Le fichier a traduire") parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm', help="Le fichier traduit") diff --git a/Traducteur/utils.py b/Traducteur/utils.py index 9ab9601c..31ab5e87 100644 --- a/Traducteur/utils.py +++ b/Traducteur/utils.py @@ -28,8 +28,8 @@ def indexToCoordinates(src, index): return x, y def lineToDict(line): - """Transforme une ligne (string) en un dictionnaire de mots - repérés par le numéro de la colonne""" + """Transforme une ligne (string) en un dictionnaire de mots + reperes par le numero de la colonne""" words = re.split("(\w+)", line) h = {};i = 0 @@ -39,7 +39,7 @@ def lineToDict(line): return h def dictToLine(d): - """Transformation inverse: à partir d'un dictionnaire retourne une ligne""" + """Transformation inverse: a partir d'un dictionnaire retourne une ligne""" cols = d cols.sort() return "".join([d[colno]for colno in cols]) diff --git a/Traducteur/visiteur.py b/Traducteur/visiteur.py index b58fcba9..b1e8aa2f 100644 --- a/Traducteur/visiteur.py +++ b/Traducteur/visiteur.py @@ -71,7 +71,7 @@ class KeywordFinder(MatchFinder): self._matches = [] self.visit(child) if self._matches: - # Pour eviter les tuples et listes ordinaires, + # Pour eviter les tuples et listes ordinaires, # on ne garde que les visites fructueuses matchlist.append(self._matches) self._matches=matchlist -- 2.39.2