From: Pascale Noyret Date: Mon, 9 Oct 2006 07:06:28 +0000 (+0000) Subject: PN chgt des logs X-Git-Tag: CC_param_poursuite~6 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=476d1a66c6c09bce7ceba44ef7f3dd027875f9be;p=tools%2Feficas.git PN chgt des logs --- diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py index 372784f2..4f462f4d 100644 --- a/Traducteur/calcG.py +++ b/Traducteur/calcG.py @@ -42,6 +42,7 @@ def changeValeurABSCNiveau1(c,jdc): 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 #-------------------------------------------------------------------------- @@ -161,6 +162,7 @@ def traitementOption(jdc): 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 diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py index 8867ede3..818437be 100644 --- a/Traducteur/changeValeur.py +++ b/Traducteur/changeValeur.py @@ -1,5 +1,7 @@ # -*- coding: utf-8 -*- import logging +from dictErreurs import EcritErreur + #-------------------------------------------------------------------------- def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): @@ -30,18 +32,18 @@ def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): MaLigneTexte=Nouveau # raccourci honteux mais ... MaLigneGlob=Nouveau if Valeur in liste : - logging.error("OPTION de CALCG à verifier ligne %s" , indexLigneGlob) - # break - #if trouve > -1 : break + EcritErreur((command,motcle,"VALEUR"),indexLigneGlob) + else : + logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) 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,motcle,"DEFAUT"),c.lineno) jdc.reset(jdc.getSource()) -#-------------------------------------------------------------------------- +#-------------------------------------------------------------------------------- def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0): -#-------------------------------------------------------------------------- +#-------------------------------------------------------------------------------- for c in jdc.root.childNodes: if c.name != command : continue @@ -73,11 +75,14 @@ def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0) MaLigneTexte=Nouveau # raccourci honteux mais ... MaLigneGlob=Nouveau if Valeur in liste : - logging.error("OPTION de %s %s %s ligne %s" ,command,fact,motcle, indexLigneGlob) + EcritErreur((command,fact,motcle,"VALEUR"),indexLigneGlob) + else : + logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob) 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()) #--------------------------------------------------------------------------------------- diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index a9aa0a4b..1528dc4c 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -29,6 +29,7 @@ def insereMotCleDansCommande(jdc,command,texte): jdc.splitLine(command.lineno,numcol) texte=texte+'\n' jdc.addLine(texte,command.lineno) + logging.info("insertion de %s ligne %d", texte,command.lineno) if numcol > 0 : # Les mots clefs etaient sur la même ligne jdc.joinLineandNext(command.lineno) @@ -56,10 +57,12 @@ def insereMotCleDansFacteur(jdc,facteur,texte): while ligneaCouper < facteur.endline + 1 : if ancien.find("_F") > 0 : indice=ancien.find("_F") - # pour ne pas tenir compte - if ancien[indice+2] in ("("," ") : - trouve=1 - break + # pour ne pas tenir compte des autres noms + # Attention si 2 MCF sur la meme ligne (la 1ere) + if ((ligneaCouper!=facteur.lineno) or (ancien.find(facteur.name) < indice)) : + if ancien[indice+2] in ("("," ") : + trouve=1 + break ligneaCouper=ligneaCouper+1 ancien=jdc.getLine(ligneaCouper) @@ -78,6 +81,7 @@ def insereMotCleDansFacteur(jdc,facteur,texte): jdc.addLine(texte,ligneaCouper) jdc.joinLineandNext(ligneaCouper) + logging.info("insertion de %s ligne %d", texte,ligneaCouper) # Gestion du cas particulier du mot clef facteur vide if facteur.childNodes == []: jdc.joinLineandNext(facteur.lineno) diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py index 2ef3645c..1093d363 100644 --- a/Traducteur/jdcparser.py +++ b/Traducteur/jdcparser.py @@ -18,6 +18,9 @@ from renamemocle import * from inseremocle import * from changeValeur import * from movemocle import * +from dictErreurs import GenereErreurPourCommande + +# Demander a emmanuel pour affe_char_ther et test_resu import calcG atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", @@ -25,12 +28,11 @@ atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", "AFFE_CHAR_THER_F","IMPR_CO","DEFI_SQUELETTE","DEFI_FONCTION", "CALC_THETA","AFFE_MODELE","DYNA_NON_LINE","CALC_ELEM", "CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU", - "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT" + "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM", + "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL", + "CREA_RESU", ) -#atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU", -# "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",) -#atraiter=( "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",) #atraiter=( "IMPR_GENE",) def traduc(infile,outfile): @@ -41,6 +43,7 @@ def traduc(infile,outfile): parseKeywords(root) renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO") + 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, @@ -91,6 +94,7 @@ def traduc(infile,outfile): # removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL") removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL") + removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL") chercheOperInsereFacteurSiRegle(jdc,"CALC_G_LOCAL_T","LISSAGE",((("LISSAGE_G","LISSAGE_THETA","DEGRE"),"existeMCFParmi"),)) moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_THETA","LISSAGE") @@ -111,29 +115,6 @@ def traduc(infile,outfile): # Attention cela necessite un traitement particulier et ne peut pas etre generalise tel quel # Attention egalement doit etre fait avant le regroupement dans THETA calcG.traitementRayon(jdc) - - #Affe_modele - daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT","OHNO":"VISC_TAHERI"} - lavertit=("OHNO") - ChangementValeurDsMCFAvecAvertissement(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele,lavertit) - removeMotCleSiRegle(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),)) - - - #--> MACR_LIGN_COUPE + POST_RCCM avertissement - #removeMotCle(jdc,"PROJ_MESU_MODAL","NOM_PARA") - #removeMotCle(jdc,"AFFE_CHAR_MECA",CONTACT", "FROTTEMENT" si METHODE ="CONTRAINTE" - - # dStatNonLine={"ELAS":"ELAS_THER"} - # lavertit=("ELAS_THER") - # STAT_NON_LINE mCF COMP-INCR contient le mot cle RELATION_KIT - # la valeur de ELAS COMP ELAS devient ELAS - # STAT_NON_LINE mCF COMP-INCR contient le mot cle RELATION contient ASSE_COMBU __> erreur - # suppresion de CALC_CHAM_ELEM si OPTION = "SOUR_ELGA_ELEC" + erreur - - # CALC_FONCTION NOM_PARA a supprimer si MCF MAX - # dCREA-RESU={"HYDR_ELGA":"HYDR_NOEUD_ELGA"} -# -# renameMotCle(jdc,"CALC_G","THETA","THETA_OLD") chercheOperInsereFacteur(jdc,"CALC_G","THETA") moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA") @@ -144,27 +125,53 @@ def traduc(infile,outfile): moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA") moveMotClefInOperToFact(jdc,"CALC_G","R_INF","THETA") 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 + 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"),)) + + + 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) + +# +# 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") - lavertit=("CHABOCHE") - dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB"} - ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit) AjouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF"))) chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT") + dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"} + lavertit=("HYDR_ELGA",) + ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dcrearesu,lavertit) + removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),)) removeCommande(jdc,"DEFI_THER_JOULE") + removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),)) removeCommande(jdc,"DIST_LIGN_3D") # Pour Tests diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index 5cfb385d..1c4a8d09 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -54,8 +54,6 @@ def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): cible=mc break if cible==None : - logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle) - logging.info("Le mot clef cible %s n est pas présent", factcible) if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée" continue @@ -67,8 +65,6 @@ def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): source=mc break if source==None : - logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle) - logging.info("Le mot clef source %s n est pas présent", factsource) if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée" continue @@ -103,9 +99,7 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible): cible=mc break if cible==None : - logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible) - logging.info("Le mot clef cible %s n est pas présent", factcible) -# if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" + if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" continue source=None @@ -116,9 +110,7 @@ def moveMotClefInOperToFact(jdc,oper,mocle,factcible): source=mc break if source==None : - logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible) - logging.info("Le mot clef source %s n est pas présent", mocle) -# if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" + if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" continue MonTexte=source.getText(jdc); inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) diff --git a/Traducteur/regles.py b/Traducteur/regles.py index 87a98bee..9cddcfda 100644 --- a/Traducteur/regles.py +++ b/Traducteur/regles.py @@ -46,9 +46,9 @@ class regle : f=self.fonction(self.list_args) return f.verif(commande) -#------------------ +#--------------------- class existeMCFParmi : -#------------------ +#--------------------- def __init__(self,list_arg): self.listeMCF=list_arg; @@ -138,6 +138,23 @@ class MCsousMCFaPourValeur : bool=1 return bool +#------------------------------- +class MCaPourValeur : +#------------------------------ + def __init__(self,list_arg): + assert (len(list_arg)==3) + self.MC=list_arg[0] + self.Val=list_arg[1] + self.Jdc=list_arg[2] + + def verif(self,commande): + bool=0 + for mc in commande.childNodes : + if mc.name != self.MC : continue + TexteMC=mc.getText(self.Jdc) + if (TexteMC.find(self.Val) < 0 ): continue + bool=1 + return bool -dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur} +dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCaPourValeur":MCaPourValeur} SansRegle=pasDeRegle() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index 5aa9ddc3..fef3dfa2 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -2,6 +2,7 @@ import logging import regles from parseur import FactNode +from dictErreurs import EcritErreur #debug=1 debug=0 @@ -9,9 +10,9 @@ debug=0 #avant de supprimer un autre mocle, on remet à jour l'arbre syntaxique (lineno,colno,etc.) -#----------------------------------------------------------- -def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle): -#----------------------------------------------------------- +#----------------------------------------------------------------------- +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 commands= jdc.root.childNodes[:] commands.reverse() @@ -20,6 +21,7 @@ def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle): for mc in c.childNodes: if mc.name != mocle:continue if ensemble.verif(c) == 0 : continue + if erreur : EcritErreur((command,mocle),c.lineno) removeMC(jdc,c,mc) jdc.reset(jdc.getSource()) @@ -28,19 +30,37 @@ def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle): def removeMotCleSiRegle(jdc,command,mocle,liste_regles) : #------------------------------------------------------- mesRegles=regles.ensembleRegles(liste_regles) - removeMotCle(jdc,command,mocle,mesRegles) + removeMotCle(jdc,command,mocle,mesRegles,erreur=0) +#---------------------------------------------------------------- +def removeMotCleSiRegleAvecErreur(jdc,command,mocle,liste_regles) : +#-------------------------------------------------------------- + mesRegles=regles.ensembleRegles(liste_regles) + removeMotCle(jdc,command,mocle,mesRegles,erreur=1) + +#---------------------------------------------------------------- +def removeMotCleAvecErreur(jdc,command,mocle) : +#-------------------------------------------------------------- + removeMotCle(jdc,command,mocle,erreur=1) + -#-------------------------------- -def removeCommande(jdc,command): -#-------------------------------- +#-------------------------------------------------------------------- +def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0): +#-------------------------------------------------------------------- commands= jdc.root.childNodes[:] commands.reverse() for c in commands: if c.name != command:continue + if ensemble.verif(c) == 0 : continue + 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) +#------------------------------------------------------------- +def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles): +#------------------------------------------------------------- + mesRegles=regles.ensembleRegles(liste_regles) + removeCommande(jdc,command,mesRegles,1) #--------------------------------- def removeMC(jdc,c,mc): @@ -61,9 +81,9 @@ def removeMC(jdc,c,mc): jdc.getLines()[mc.lineno-1]=s[:mc.colno]+s[mc.endcol:] fusionne(jdc,mc.lineno-1) -#-------------------------------------------- -def removeMotCleInFact(jdc,command,fact,mocle): -#--------------------------------------------- +#--------------------------------------------------------------------------------- +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 commands= jdc.root.childNodes[:] @@ -77,10 +97,27 @@ def removeMotCleInFact(jdc,command,fact,mocle): for ll in l: for n in ll.childNodes: if n.name != mocle:continue + if ensemble.verif(c) == 0 : continue + if erreur : EcritErreur((command,fact,mocle),c.lineno) removeMC(jdc,c,n) jdc.reset(jdc.getSource()) +#------------------------------------------------------------------ +def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles): +#------------------------------------------------------------------ + erreur=0 + mesRegles=regles.ensembleRegles(liste_regles) + removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur) + +#---------------------------------------------------------------------- +def removeMotCleInFactSiRegleAvecErreur(jdc,command,fact,mocle,liste_regles): +#---------------------------------------------------------------------- + erreur=1 + mesRegles=regles.ensembleRegles(liste_regles) + removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur) + + #------------------------------------------ def fusionne(jdc,numLigne): #------------------------------------------ diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index eba0d342..1f613fc3 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -3,22 +3,23 @@ import logging import sys from parseur import FactNode import regles +from 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.) -#------------------------------------------------------ +#-------------------------------------------------------------------------------- def renameMotCle(jdc,command,mocle,new_name, erreur=0): -#------------------------------------------------------ +#-------------------------------------------------------------------------------- for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: if mc.name != mocle:continue if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno if erreur : - logging.error("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name) + EcritErreur((command,mocle),c.lineno) else : logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name) s=jdc.getLines()[mc.lineno-1] @@ -36,9 +37,6 @@ def renameMotCleAvecErreur(jdc,command,mocle,new_name): #------------------------------------------- def renameOper(jdc,command,new_name): #------------------------------------------- - logging.info("Traitement de %s renomme en %s ", command, new_name) - logging.info ("_________________________________________________") - logging.info (" ") for c in jdc.root.childNodes: if c.name != command:continue if debug:print "Renommage de:",c.name,c.lineno,c.colno @@ -66,9 +64,6 @@ def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): #---------------------------------------------------------- def renameMotCleInFact(jdc,command,fact,mocle,new_name): #---------------------------------------------------------- - logging.info("Traitement de %s sous %s de %s renomme en %s ", mocle,fact,command, new_name) - logging.info ("_______________________________________________________________________") - logging.info (" ") for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -89,12 +84,11 @@ def renameMotCleInFact(jdc,command,fact,mocle,new_name): def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): #----------------------------------------------------------------- # nom de la commande "ancien format" , nom de la commande " nouveau format " - if ensemble != regles.SansRegle : - 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 ("_______________________________________________________________________") - logging.info (" ") + if debug : + if ensemble != regles.SansRegle : + 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) for c in jdc.root.childNodes: if c.name != command:continue if ensemble.verif(c) == 0 : continue @@ -104,7 +98,6 @@ def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle): jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):] jdc.reset(jdc.getSource()) - logging.info (" ") #----------------------------------------------------------- def renameCommandeSiRegle(jdc,command,new_name,liste_regles):