From: Pascale Noyret Date: Tue, 10 Oct 2006 07:52:27 +0000 (+0000) Subject: PN pour sauvegarde X-Git-Tag: CC_param_poursuite~5 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=0a2bd90505eed888dcdb0cd1fd28197ee22f8483;p=modules%2Feficas.git PN pour sauvegarde --- diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py index 4f462f4d..05c76a6f 100644 --- a/Traducteur/calcG.py +++ b/Traducteur/calcG.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- from parseur import FactNode +from dictErreurs import jdcSet import logging dict_commande={} @@ -10,6 +11,8 @@ 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] @@ -134,36 +137,3 @@ def chercheValeurSelonGenea3(jdc,liste_cherche_valeur): return liste_valeurs -#-------------------------------------------------------------------------- -def traitementOption(jdc): -#-------------------------------------------------------------------------- - dtheta={"CALC_G_LAGR":"G_LAGR_GLOB", "G_BILINEAIRE":"G_BILI_GLOB", "CALC_G_MAX":"G_MAX_GLOB", "CALC_G":"CALC_G_MAX"} - dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"} - - for c in jdc.root.childNodes: - if c.name != "CALC_G_THETA_T" and c.name != "CALC_G_LOCAL_T" : continue - if c.name == "CALC_G_LOCAL_T" : - DictNouvVal=dlocal - else : - DictNouvVal=dtheta - for mc in c.childNodes: - if mc.name != "OPTION" : continue - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-1 - indexTexteMC=0 - while indexLigneGlob < mc.endline - 1 : - MaLigneGlob=jdc.getLines()[indexLigneGlob] - MaLigneTexte=liste_ligne_MC[indexTexteMC] - for Valeur in DictNouvVal.keys() : - trouve=MaLigneTexte.find(Valeur) - if trouve > -1 : - debut=MaLigneGlob.find(MaLigneTexte) - Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur]) - Nouveau=MaLigneGlob[0:debut]+Nouveau - jdc.getLines()[indexLigneGlob]=Nouveau - logging.info("Changement de %s par %s ligne %d",Valeur,DictNouvVal[Valeur],indexLigneGlob) - break - if trouve > -1 : break - indexLigneGlob=indexLigneGlob+1 - indexTexteMC=indexTexteMC+1 diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py index 818437be..31ce3459 100644 --- a/Traducteur/changeValeur.py +++ b/Traducteur/changeValeur.py @@ -1,12 +1,15 @@ # -*- coding: utf-8 -*- import logging from dictErreurs import EcritErreur +from dictErreurs import jdcSet #-------------------------------------------------------------------------- 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 @@ -35,16 +38,19 @@ def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): 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) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #-------------------------------------------------------------------------------- def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0): #-------------------------------------------------------------------------------- + if command not in jdcSet : return + boolChange=0 for c in jdc.root.childNodes: if c.name != command : continue for mcF in c.childNodes: @@ -78,16 +84,18 @@ def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0) EcritErreur((command,fact,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): logging.error("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno ) EcritErreur((command,fact,motcle,"DEFAUT"),c.lineno) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #--------------------------------------------------------------------------------------- def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste): #--------------------------------------------------------------------------------------- + if command not in jdcSet : return defaut=0 if liste[-1] == "defaut" : defaut=1 @@ -96,6 +104,7 @@ def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal #-------------------------------------------------------------------------- def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste): #-------------------------------------------------------------------------- + if command not in jdcSet : return defaut=0 if liste[-1] == "defaut" : defaut=1 @@ -105,6 +114,8 @@ def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste): def SuppressionValeurs(jdc, command,motcle,liste): #-------------------------------------------------------------------------- + if command.name not in jdcSet : return + boolChange=0 for c in jdc.root.childNodes: if c.name != command : continue for mc in c.childNodes: @@ -141,6 +152,7 @@ def SuppressionValeurs(jdc, command,motcle,liste): if premier == 1 : fin = fin + 1 # on supprime la , finLigne = chercheLigne[fin:] MaLigne=debLigne+finLigne + boolChange=1 jdc.getLines()[indexLigneGlob]=MaLigne indexLigneGlob=indexLigneGlob+1 - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index 1528dc4c..ece9a0c8 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- import logging from parseur import FactNode +from dictErreurs import jdcSet import string import regles debug=0 @@ -12,6 +13,7 @@ def insereMotCle(jdc,recepteur,texte): # 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) @@ -23,6 +25,7 @@ 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 numcol=chercheDebut1Mot(jdc,command) if numcol > 0 : @@ -131,14 +134,17 @@ def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle): # cree le texte # appelle insereMotCle pour ajouter le texte # + boolChange=0 texte=nouveau+"=_F()," + if nomcommande not in jdcSet : return commands= jdc.root.childNodes[:] commands.reverse() for c in commands: if c.name != nomcommande:continue if ensemble.verif(c) == 0 : continue + boolChange=1 insereMotCle(jdc,c,texte) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------------------------ def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles): @@ -147,6 +153,7 @@ def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles): # cree le texte # appelle insereMotCle pour ajouter le texte # + if nomcommande not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles) @@ -159,12 +166,14 @@ def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle # cree le texte # appelle insereMotCle pour ajouter le texte # + if commande not in jdcSet : return if estunFacteur : texte=nouveau+"=_F()," else : texte=nouveau commands= jdc.root.childNodes[:] commands.reverse() + boolChange=0 for c in commands: if c.name != commande : continue for mcF in c.childNodes: @@ -172,12 +181,14 @@ def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle if ensemble.verif(c) == 0 : continue l=mcF.childNodes[:] l.reverse() + boolChange=1 insereMotCleDansFacteur(jdc,mcF,texte) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------------------------------------------- def AjouteMotClefDansFacteurSiRegle(jdc,commande,fact,nouveau,liste_regles,estunFacteur=0): #------------------------------------------------------------------------------------------- # + if commande not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,mesRegles,estunFacteur) diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py index 1093d363..2a9d764c 100644 --- a/Traducteur/jdcparser.py +++ b/Traducteur/jdcparser.py @@ -30,7 +30,7 @@ atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", "CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU", "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM", "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL", - "CREA_RESU", + "CREA_RESU","DIST_LIGN_3D", ) #atraiter=( "IMPR_GENE",) @@ -41,25 +41,22 @@ def traduc(infile,outfile): #Parse les mocles des commandes parseKeywords(root) + + ####################### traitement erreurs ####################### + GenereErreurPourCommande(jdc,("MACR_LIGN_COUPE","POST_RCCM","DIST_LIGN_3D")) + ####################### traitement CALC_META ####################### renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO") + + ####################### traitement CALC_FONCTION ####################### removeMotCleSiRegle(jdc,"CALC_FONCTION","NOM_PARA",((("MAX"),"existeMCFParmi"),)) renameCommandeSiRegle(jdc,"CALC_FONCTION","INFO_FONCTION", ((("RMS","MAX","NOCI_SEISME","NORME","ECART-TYPE"),"existeMCFParmi"),)) - # Les arguments sont - jdc, - # - nom de la procedure (pas teste avec autre chose) - # - nom du mot clef facteur contenant, - # - nom du mot cle simple - # Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer + ####################### traitement IMPR_GENE ####################### moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","UNITE") moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","FORMAT") - # Les arguments sont - jdc - # - nom de l operateur (pas teste avec autre chose) - # - nom du mot clef facteur source, - # - nom du mot cle simple - # - liste de mots clef facteur arrivée possible - # Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer + ####################### traitement STAT/DYNA_NON_LINE ####################### moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) @@ -68,15 +65,25 @@ def traduc(infile,outfile): moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS")) -# -# + + dStatNonLine={"ELAS":"ELAS_THER"} + lavertit=("ELAS") + ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP-INCR","RELATION_KIT",dStatNonLine,lavertit) + + lavertit=("CHABOCHE","ASSE_COMBU") + dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB","ASSE_COMBU":"XXX_IRA"} + ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit) + + ####################### traitement DEFI_MATERIAU ####################### renameMotCle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA") moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",)) moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",)) moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",)) moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",)) removeMotCle(jdc,"DEFI_MATERIAU","FLU_IRRA") -# + renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","CHABOCHE","CINx_CHAB") + + ####################### traitement DEFI_MATERIAU ####################### renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A") renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B") renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S") @@ -84,14 +91,23 @@ def traduc(infile,outfile): moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",)) moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",)) removeMotCle(jdc,"DEFI_MATERIAU","GRAN_IRRA") -# + + ####################### traitement DEFI_MATERIAU ####################### + chercheOperInsereFacteurSiRegle(jdc,"DEFI_MATERIAU","ELAS",((("CABLE",),"existe"),)) + moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","E", ("ELAS",)) + moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","NU", ("ELAS",)) + moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","RHO",("ELAS",)) + + ####################### traitement IMPR_CO ####################### chercheOperInsereFacteurSiRegle(jdc,"IMPR_CO","CONCEPT",((("CO",),"existe"),)) moveMotClefInOperToFact(jdc,"IMPR_CO","CO","CONCEPT") renameMotCleInFact(jdc,"IMPR_CO","CONCEPT","CO","NOM") -# + + ####################### traitement DEFI_SQUELETTE ####################### chercheOperInsereFacteurSiRegle(jdc,"DEFI_SQUELETTE","CYCLIQUE",((("MODE_CYCL",),"existe"),)) moveMotClefInOperToFact(jdc,"DEFI_SQUELETTE","MODE_CYCL","CYCLIQUE") -# + + ####################### traitement AFFE_CHAR_* ####################### removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL") removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL") removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL") @@ -101,10 +117,10 @@ def traduc(infile,outfile): moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_G","LISSAGE") moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","DEGRE","LISSAGE") -# + ####################### traitement CALC_G ####################### dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"} ChangementValeur(jdc,"CALC_G_LOCAL_T","OPTION",dlocal) -# + # dtheta={"CALC_G_LAGR":"G_LAGR_GLOB", "G_BILINEAIRE":"G_BILI_GLOB", "CALC_G_MAX":"G_MAX_GLOB","CALC_G":"CALC_G_GLOB"} # Attention si le defaut doit generer un avertissement Il faut le mettre comme dernier mot de la liste lavertit=("CALC_G_LAGR","CALC_G","defaut") @@ -127,58 +143,44 @@ def traduc(infile,outfile): moveMotClefInOperToFact(jdc,"CALC_G","R_SUP","THETA") moveMotClefInOperToFact(jdc,"CALC_G","FISSURE","THETA") - dcalcelemno={"ERRE_ELGA_NORE":"ERRE_ELEM_SIGM","ERRE_ELEM_NOZ1":"ERZ1_ELEM_SIGM","ERRE_ELEM_NOZ2":"ERZ2_ELEM_SIGM","ERRE_ELNO_ELGA":"ERRE_ELNO_ELEM","ERRE_NOEU_ELGA":"ERRE_NOEU_ELEM","ERTH_ELEM_TEMP":"ERRE_ELEM_TEMP","ERTH_ELNO_ELEM":"ERRE_ELNO_ELEM"} - - #Affe_modele + ####################### traitement AFFE_MODELE ####################### daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT","OHNO":"VISC_TAHERI"} lavertit=("OHNO") ChangementValeurDsMCFAvecAvertissement(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele,lavertit) removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),)) - + ####################### 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"),)) - - dStatNonLine={"ELAS":"ELAS_THER"} - lavertit=("ELAS") - ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP-INCR","RELATION_KIT",dStatNonLine,lavertit) - lavertit=("CHABOCHE","ASSE_COMBU") - dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB","ASSE_COMBU":"XXX_IRA"} - ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit) - -# -# + ####################### traitement CALC_ELEM / CALC_NO ####################### + dcalcelemno={"ERRE_ELGA_NORE":"ERRE_ELEM_SIGM","ERRE_ELEM_NOZ1":"ERZ1_ELEM_SIGM","ERRE_ELEM_NOZ2":"ERZ2_ELEM_SIGM","ERRE_ELNO_ELGA":"ERRE_ELNO_ELEM","ERRE_NOEU_ELGA":"ERRE_NOEU_ELEM","ERTH_ELEM_TEMP":"ERRE_ELEM_TEMP","ERTH_ELNO_ELEM":"ERRE_ELNO_ELEM"} ChangementValeur(jdc,"CALC_ELEM","OPTION",dcalcelemno) ChangementValeur(jdc,"CALC_NO","OPTION",dcalcelemno) ChangementValeurDsMCF(jdc,"IMPR_RESU","RESU","NOM_CHAM",dcalcelemno) ChangementValeur(jdc,"TEST_RESU","RESU",dcalcelemno) removeMotCleAvecErreur(jdc,"TEST_RESU","UNITE") - GenereErreurPourCommande(jdc,("MACR_LIGN_COUPE","POST_RCCM")) -# - renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","CHABOCHE","CINx_CHAB") - + ####################### traitement EXTR_MODE ####################### AjouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF"))) + ####################### traitement DYNA_TRAN_EXPLI ####################### chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT") + ####################### traitement CREA_RESU ####################### dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"} lavertit=("HYDR_ELGA",) ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dcrearesu,lavertit) + ####################### traitement DEBUT ####################### removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),)) + ####################### traitement DEFI_THER_JOULE ####################### removeCommande(jdc,"DEFI_THER_JOULE") - removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),)) - removeCommande(jdc,"DIST_LIGN_3D") - - # Pour Tests - #removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","TOUT") - #SuppressionValeurs(jdc,"CALC_ELEM","OPTION",("'ERRE_ELGA_NORE'","'ERRE_ELNO_ELGA'")) - #SuppressionValeurs(jdc,"CALC_NO","OPTION",("'ERRE_NOEU_ELGA'",)) + ####################### traitement CALC_CHAM_ELEM ####################### + removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),)) f=open(outfile,'w') f.write(jdc.getSource()) diff --git a/Traducteur/load.py b/Traducteur/load.py index adca2410..b8f0a5aa 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- import os +import re import parseur from mocles import parseKeywords diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py index 6e304bc7..7d2aafeb 100644 --- a/Traducteur/mocles.py +++ b/Traducteur/mocles.py @@ -5,6 +5,7 @@ import types from parseur import Keyword, FactNode, lastparen, lastparen2,maskStringsAndComments from visiteur import KeywordFinder, visitor from utils import indexToCoordinates +import traceback debug=0 @@ -69,6 +70,9 @@ def parseKeywords(root): """A partir d'un arbre contenant des commandes, ajoute les noeuds fils correspondant aux mocles de la commande """ + #print "parseKeywords" + #traceback.print_stack(limit=5) + matchFinder=KeywordFinder() for c in root.childNodes: diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index 1c4a8d09..f4bd73d0 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -4,6 +4,7 @@ import logging import removemocle import inseremocle from parseur import FactNode +from dictErreurs import jdcSet debug=0 #----------------------------------------------------- @@ -11,6 +12,8 @@ def moveMotCleFromFactToFather(jdc,command,fact,mocle): #----------------------------------------------------- # exemple type : IMPR_GENE + if command not in jdcSet : return + boolChange=0 for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -21,10 +24,11 @@ def moveMotCleFromFactToFather(jdc,command,fact,mocle): if n.name != mocle:continue if debug : print "Changement de place :", n.name, n.lineno, n.colno MonTexte=n.getText(jdc); + boolChange=1 inseremocle.insereMotCle(jdc,c,MonTexte) logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) removemocle.removeMotCleInFact(jdc,command,fact,mocle) @@ -34,14 +38,15 @@ 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) - jdc.reset(jdc.getSource()) removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) #---------------------------------------------------------------------------- def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): #---------------------------------------------------------------------------- + if oper not in jdcSet : return if debug : print "moveMotCleFromFactToFact pour " ,oper,factsource,mocle,factcible + boolChange=0 commands= jdc.root.childNodes[:] commands.reverse() for c in commands: @@ -75,8 +80,10 @@ def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): if n.name != mocle:continue MonTexte=n.getText(jdc); inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) + boolChange=1 logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno) logging.info("vers : %s", cible.name) + if boolChange : jdc.reset(jdc.getSource()) @@ -86,7 +93,9 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible): #------------------------------------------------------ # Attention le cas type est THETA_OLD dans calc_G + if oper not in jdcSet : return if debug : print "movemocleinoper pour " ,oper,mocle,factcible + boolChange=9 commands= jdc.root.childNodes[:] commands.reverse() for c in commands: @@ -113,6 +122,7 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible): 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) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) removemocle.removeMotCle(jdc,oper,mocle) diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index fef3dfa2..b6b84b08 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -3,6 +3,7 @@ import logging import regles from parseur import FactNode from dictErreurs import EcritErreur +from dictErreurs import jdcSet #debug=1 debug=0 @@ -14,6 +15,8 @@ debug=0 def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle,erreur = 0): #----------------------------------------------------------------------- #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 + boolChange=0 commands= jdc.root.childNodes[:] commands.reverse() for c in commands: @@ -22,43 +25,52 @@ def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle,erreur = 0): if mc.name != mocle:continue if ensemble.verif(c) == 0 : continue if erreur : EcritErreur((command,mocle),c.lineno) + boolChange=1 removeMC(jdc,c,mc) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------- def removeMotCleSiRegle(jdc,command,mocle,liste_regles) : #------------------------------------------------------- + if command not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) removeMotCle(jdc,command,mocle,mesRegles,erreur=0) #---------------------------------------------------------------- def removeMotCleSiRegleAvecErreur(jdc,command,mocle,liste_regles) : #-------------------------------------------------------------- + if command not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) removeMotCle(jdc,command,mocle,mesRegles,erreur=1) #---------------------------------------------------------------- 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): #-------------------------------------------------------------------- + if command not in jdcSet : return + boolChange=0 commands= jdc.root.childNodes[:] commands.reverse() for c in commands: if c.name != command:continue if ensemble.verif(c) == 0 : continue + boolChange=1 if erreur : EcritErreur((command,),c.lineno) jdc.supLignes(c.lineno,c.endline) logging.error("Suppression de: %s, %s, %s",c.name,c.lineno,c.endline) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------------- def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles): #------------------------------------------------------------- + if command not in jdcSet : return mesRegles=regles.ensembleRegles(liste_regles) removeCommande(jdc,command,mesRegles,1) @@ -86,8 +98,10 @@ def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0 #---------------------------------------------------------------------------------- # 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[:] commands.reverse() + boolChange=0 for c in commands: if c.name != command:continue for mc in c.childNodes: @@ -99,13 +113,15 @@ def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0 if n.name != mocle:continue if ensemble.verif(c) == 0 : continue if erreur : EcritErreur((command,fact,mocle),c.lineno) + boolChange=1 removeMC(jdc,c,n) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------------------ def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles): #------------------------------------------------------------------ + if command not in jdcSet : return erreur=0 mesRegles=regles.ensembleRegles(liste_regles) removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur) @@ -113,6 +129,7 @@ def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles): #---------------------------------------------------------------------- def removeMotCleInFactSiRegleAvecErreur(jdc,command,fact,mocle,liste_regles): #---------------------------------------------------------------------- + if command not in jdcSet : return erreur=1 mesRegles=regles.ensembleRegles(liste_regles) removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur) diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index 1f613fc3..f6dab579 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -2,6 +2,7 @@ import logging import sys from parseur import FactNode +from dictErreurs import jdcSet import regles from dictErreurs import EcritErreur #debug=1 @@ -13,10 +14,13 @@ debug=0 #-------------------------------------------------------------------------------- def renameMotCle(jdc,command,mocle,new_name, erreur=0): #-------------------------------------------------------------------------------- + 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 != mocle:continue + boolChange=1 if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno if erreur : EcritErreur((command,mocle),c.lineno) @@ -27,25 +31,30 @@ def renameMotCle(jdc,command,mocle,new_name, erreur=0): diff=len(new_name) - len(mocle) decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #------------------------------------------------------ def renameMotCleAvecErreur(jdc,command,mocle,new_name): #------------------------------------------------------ + if command not in jdcSet : return renameMotCle(jdc,command,mocle,new_name,1) #------------------------------------------- def renameOper(jdc,command,new_name): #------------------------------------------- + if command not in jdcSet : return + jdcSet.add(new_name) + boolChange=0 for c in jdc.root.childNodes: if c.name != command:continue if debug:print "Renommage de:",c.name,c.lineno,c.colno logging.info("Renommage de: %s, %s, %s, en %s",c.name,c.lineno,c.colno,new_name) + boolChange=1 s=jdc.getLines()[c.lineno-1] jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):] diff=len(new_name) - len(command) decaleLignesdeNBlancs(jdc,c.lineno,c.endline,diff) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #---------------------------------------------------------- def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): @@ -64,6 +73,8 @@ def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): #---------------------------------------------------------- def renameMotCleInFact(jdc,command,fact,mocle,new_name): #---------------------------------------------------------- + if command not in jdcSet : return + boolChange=0 for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -76,14 +87,18 @@ def renameMotCleInFact(jdc,command,fact,mocle,new_name): if n.name != mocle:continue s=jdc.getLines()[n.lineno-1] jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):] + boolChange=1 logging.info("Renommage de: %s, %s, %s, en %s",n.name,n.lineno,n.colno,new_name) - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #----------------------------------------------------------------- def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): #----------------------------------------------------------------- # nom de la commande "ancien format" , nom de la commande " nouveau format " + if command not in jdcSet : return + jdcSet.add(new_name) + boolChange=0 if debug : if ensemble != regles.SansRegle : logging.info("Traitement de %s renomme en %s sous conditions", command, new_name) @@ -92,17 +107,19 @@ def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): for c in jdc.root.childNodes: if c.name != command:continue if ensemble.verif(c) == 0 : continue + boolChange=1 if debug:print "Renommage de:",c.name,new_name ,c.lineno,c.colno logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,"",c.lineno,c.colno,new_name) s=jdc.getLines()[c.lineno-1] jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):] - jdc.reset(jdc.getSource()) + if boolChange : jdc.reset(jdc.getSource()) #----------------------------------------------------------- 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)