From df01e7c87e1fbb35c77252489c474fb6de6627e5 Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Fri, 6 Oct 2006 08:54:38 +0000 Subject: [PATCH] PN Pour sauvegarde --- Traducteur/calcG.py | 51 +++++++++++++---- Traducteur/changeValeur.py | 102 ++++++++++++++++++++++++++++----- Traducteur/inseremocle.py | 34 ++++++++++- Traducteur/jdcparser.py | 112 +++++++++++++++++++++++++------------ Traducteur/load.py | 6 ++ Traducteur/regles.py | 60 +++++++++++++++++++- Traducteur/removemocle.py | 26 ++++++++- Traducteur/renamemocle.py | 16 ++++-- 8 files changed, 335 insertions(+), 72 deletions(-) diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py index 8a7aa47b..372784f2 100644 --- a/Traducteur/calcG.py +++ b/Traducteur/calcG.py @@ -1,10 +1,12 @@ # -*- coding: utf-8 -*- from parseur import FactNode +import logging dict_commande={} dict_contexte={} dict_contexte_option={} +import sys #-------------------------------------------------------------------------- def traitementRayon(jdc): #-------------------------------------------------------------------------- @@ -61,13 +63,25 @@ def chercheValeurSelonGenea2(jdc,liste_cherche_valeur): for mc in c.childNodes: if mc.name != fact:continue MonTexte=mc.getText(jdc) - #try : - if ( 1) : + try : + #if ( 1) : exec MonTexte in dict_contexte - monNomVariable=MonTexte.split("=")[1][0:-1] - if monNomVariable not in liste_valeurs : liste_valeurs.append(monNomVariable) - #except : - else : + 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 @@ -95,13 +109,26 @@ def chercheValeurSelonGenea3(jdc,liste_cherche_valeur): for lc in ll.childNodes: if lc.name !=mc : continue MonTexte=lc.getText(jdc) - #try : - if ( 1) : + try : + #if ( 1) : exec MonTexte in dict_contexte - monNomVariable=MonTexte.split("=")[1][0:-1] - if monNomVariable not in liste_valeurs : liste_valeurs.append(monNomVariable) - #except : - else : + #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 002f155c..8867ede3 100644 --- a/Traducteur/changeValeur.py +++ b/Traducteur/changeValeur.py @@ -15,25 +15,78 @@ def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): liste_ligne_MC=TexteMC.splitlines() indexLigneGlob=mc.lineno-1 indexTexteMC=0 - while indexLigneGlob < mc.endline - 1 : + 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.keys() : trouve=MaLigneTexte.find(Valeur) if trouve > -1 : - debut=MaLigneGlob.find(MaLigneTexte) + 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 : logging.error("OPTION de CALCG à verifier ligne %s" , indexLigneGlob) - break - if trouve > -1 : break + # break + #if trouve > -1 : break indexLigneGlob=indexLigneGlob+1 indexTexteMC=indexTexteMC+1 if (trouveUnMC == 0) and ( defaut == 1): logging.error("OPTION (defaut) de CALCG à verifier ligne %s" ,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 + for mcF in c.childNodes: + if mcF.name != fact : continue + l=mcF.childNodes[:] + l.reverse() + for ll in l: + trouveUnMC=0 + for mc in ll.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.keys() : + trouve=MaLigneTexte.find(Valeur) + if trouve > -1 : + 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 : + logging.error("OPTION de %s %s %s ligne %s" ,command,fact,motcle, indexLigneGlob) + indexLigneGlob=indexLigneGlob+1 + indexTexteMC=indexTexteMC+1 + if (trouveUnMC == 0) and ( defaut == 1): + logging.error("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno ) + jdc.reset(jdc.getSource()) + +#--------------------------------------------------------------------------------------- +def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste): +#--------------------------------------------------------------------------------------- + defaut=0 + if liste[-1] == "defaut" : + defaut=1 + ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,defaut) #-------------------------------------------------------------------------- def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste): @@ -51,15 +104,38 @@ def SuppressionValeurs(jdc, command,motcle,liste): if c.name != command : continue for mc in c.childNodes: if mc.name != motcle : continue - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() indexLigneGlob=mc.lineno-1 - while indexLigneGlob < mc.endline - 1 : - MaLigneGlob=jdc.getLines()[indexLigneGlob] - MaLigneTexte=liste_ligne_MC[indexTexteMC] + while indexLigneGlob < mc.endline : + MaLigneTexte = jdc.getLines()[indexLigneGlob] MaLigne=MaLigneTexte for Valeur in liste : - trouve=MaLigneTexte.find(Valeur) - debut=MaLigneGlob.find(MaLigneTexte) - index = -1 - while index < -1 * len(MaLigne) : + debutMC =MaLigne.find(motcle) + if debutMC ==-1 : debutMC=0 + debut1=MaLigne[0:debutMC] + chercheLigne=MaLigne[debutMC:] + trouve=chercheLigne.find(Valeur) + premier=0 + if trouve > 0 : + debut=debut1 + chercheLigne[0:trouve] + 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) + if premier == 1 : fin = fin + 1 # on supprime la , + finLigne = chercheLigne[fin:] + MaLigne=debLigne+finLigne + jdc.getLines()[indexLigneGlob]=MaLigne + indexLigneGlob=indexLigneGlob+1 + jdc.reset(jdc.getSource()) diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index ded8cf9f..a9aa0a4b 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -37,8 +37,8 @@ def insereMotCleDansFacteur(jdc,facteur,texte): #------------------------------------------------- if debug : print "insereMotCle ", texte , " dans ", facteur.name - ancien=jdc.getLine(facteur.lineno ) - + if texte[-1] == "\n" : texte=texte[0:-1] + ancien=jdc.getLine(facteur.lineno) # On va chercher la derniere ) pour ajouter avant # on va verifier s il il y a un , avant @@ -147,3 +147,33 @@ def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles): chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles) +#------------------------------------------------------------------------------------------------- +def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle, estunFacteur=0): +#------------------------------------------------------------------------------------------------- +# Cherche la commande +# Cherche le MCF +# cree le texte +# appelle insereMotCle pour ajouter le texte +# + if estunFacteur : + texte=nouveau+"=_F()," + else : + texte=nouveau + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: + if c.name != commande : continue + for mcF in c.childNodes: + if mcF.name != fact : continue + if ensemble.verif(c) == 0 : continue + l=mcF.childNodes[:] + l.reverse() + insereMotCleDansFacteur(jdc,mcF,texte) + jdc.reset(jdc.getSource()) + +#------------------------------------------------------------------------------------------- +def AjouteMotClefDansFacteurSiRegle(jdc,commande,fact,nouveau,liste_regles,estunFacteur=0): +#------------------------------------------------------------------------------------------- +# + mesRegles=regles.ensembleRegles(liste_regles) + AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,mesRegles,estunFacteur) diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py index 13553ff7..2ef3645c 100644 --- a/Traducteur/jdcparser.py +++ b/Traducteur/jdcparser.py @@ -20,10 +20,12 @@ from changeValeur import * from movemocle import * import calcG -atraiter=("IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", +atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G","AFFE_CHAR_MECA", "AFFE_CHAR_THER_F","IMPR_CO","DEFI_SQUELETTE","DEFI_FONCTION", - "CALC_THETA","AFFE_MODELE","DYNA_NON_LINE", + "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" ) #atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU", @@ -38,24 +40,7 @@ def traduc(infile,outfile): #Parse les mocles des commandes parseKeywords(root) - #removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","TOUT") - #removeMotCle(jdc,"STAT_NONLINE","SOLVEUR") - #renameMotCleInFact(jdc,"AFFE_MODELE","AFFE","PHENOMENE","TOTO") - #renameMotCleInFact(jdc,"AFFE_MODELE","AFFE","MODELISATION","TITI") - #renameMotCleInFact(jdc,"DEFI_GROUP","CREA_GROUP_NO","GROUP_MA","TUTU") - #removeMotCle(jdc,"LIRE_MAILLAGE","INFO") - #removeMotCle(jdc,"LIRE_MAILLAGE","UNITE") - #renameMotCle(jdc,"DEFI_MATERIAU","ELAS","ELASTIC") - #renameMotCle(jdc,"AFFE_MATERIAU","MAILLAGE","MAILL") - #removeMotCleInFact(jdc,"STAT_NONLINE","SOLV","METHOD") - #removeMotCle(jdc,"STAT_NONLINE","AFFE") - #renameCommande(jdc,"AFFE_CHAR_MECA","AFFE_CHAR_MECA_PN") - #renameCommande(jdc,"DEBUT","DEBUT_PN") - - # A decommenter a partir d ici - # les arguments sont jdc,ancien-nom-de-commande,nouveau-nom-de-commande - - + renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO") renameCommandeSiRegle(jdc,"CALC_FONCTION","INFO_FONCTION", ((("RMS","MAX","NOCI_SEISME","NORME","ECART-TYPE"),"existeMCFParmi"),)) # Les arguments sont - jdc, @@ -80,15 +65,15 @@ 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")) - - +# +# 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") - +# 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") @@ -96,34 +81,59 @@ 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") - - chercheOperInsereFacteur(jdc,"IMPR_CO","CONCEPT") +# + chercheOperInsereFacteurSiRegle(jdc,"IMPR_CO","CONCEPT",((("CO",),"existe"),)) moveMotClefInOperToFact(jdc,"IMPR_CO","CO","CONCEPT") renameMotCleInFact(jdc,"IMPR_CO","CONCEPT","CO","NOM") - - chercheOperInsereFacteur(jdc,"DEFI_SQUELETTE","CYCLIQUE") +# + chercheOperInsereFacteurSiRegle(jdc,"DEFI_SQUELETTE","CYCLIQUE",((("MODE_CYCL",),"existe"),)) moveMotClefInOperToFact(jdc,"DEFI_SQUELETTE","MODE_CYCL","CYCLIQUE") - +# removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL") removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL") + chercheOperInsereFacteurSiRegle(jdc,"CALC_G_LOCAL_T","LISSAGE",((("LISSAGE_G","LISSAGE_THETA","DEGRE"),"existeMCFParmi"),)) + 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) - +# 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") ChangementValeurAvecAvertissement(jdc,"CALC_G_THETA_T","OPTION",dtheta,lavertit) renameOper(jdc,"CALC_G_LOCAL_T","CALC_G") renameOper(jdc,"CALC_G_THETA_T","CALC_G") - - - # Attention cela necessite un traitement particulier et ne peut pas - # etre generalise tel quel + + # 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") @@ -132,8 +142,36 @@ def traduc(infile,outfile): moveMotClefInOperToFact(jdc,"CALC_G","FOND_FISS","THETA") moveMotClefInOperToFact(jdc,"CALC_G","R_INF_FO","THETA") moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA") - chercheOperInsereFacteurSiRegle(jdc,"CALC_G","LISSAGE",((("DEGRE",),"existe"),)) - moveMotClefInOperToFact(jdc,"CALC_G","DEGRE","LISSAGE") + moveMotClefInOperToFact(jdc,"CALC_G","R_INF","THETA") + moveMotClefInOperToFact(jdc,"CALC_G","R_SUP","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"} + 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) + +# + 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") + + removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),)) + + removeCommande(jdc,"DEFI_THER_JOULE") + 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'",)) + f=open(outfile,'w') f.write(jdc.getSource()) diff --git a/Traducteur/load.py b/Traducteur/load.py index e39bfd5e..adca2410 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -98,6 +98,12 @@ class JDC: self.lines=Ldebut+Lmilieu+Lfin + def supLignes(self,debut,fin): + #------------------------ + Ldebut=self.lines[0:debut-1] + Lfin=self.lines[fin:] + self.lines=Ldebut+Lfin + def remplaceLine(self,numeroLigne,nouveauTexte) : #------------------------------------------------ self.lines[numeroLigne]=nouveauTexte diff --git a/Traducteur/regles.py b/Traducteur/regles.py index f0fe4fca..87a98bee 100644 --- a/Traducteur/regles.py +++ b/Traducteur/regles.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- import logging import string +from parseur import FactNode debug=0 @@ -59,6 +60,38 @@ class existeMCFParmi : break return bool +#---------------------- +class existeMCsousMCF : +#---------------------- + def __init__(self,list_arg): + self.liste=list_arg; + self.MCF=self.liste[0] + self.MC=self.liste[1] + + def verif(self,commande): + bool=0 + for mcf in commande.childNodes : + if mcf.name != self.MCF : continue + l=mcf.childNodes[:] + l.reverse() + for ll in l: + for mc in ll.childNodes: + if mc.name != self.MC : continue + bool=1 + return bool + +#----------------------------------------- +class nexistepasMCsousMCF(existeMCsousMCF): +#----------------------------------------- + def __init__(self,list_arg): + existeMCsousMCF.__init__(self,list_arg) + + + def verif(self,commande): + bool=existeMCsousMCF.verif(self,commande) + if bool : return 0 + return 1 + #------------- class existe : #-------------- @@ -80,6 +113,31 @@ class existe : if bool == None : bool = 0 return bool +#------------------------------- +class MCsousMCFaPourValeur : +#------------------------------ + def __init__(self,list_arg): + assert (len(list_arg)==4) + self.genea=list_arg[0:-2] + self.MCF=list_arg[0] + self.MC=list_arg[1] + self.Val=list_arg[2] + self.Jdc=list_arg[3] + + def verif(self,commande): + bool=0 + for mcf in commande.childNodes : + if mcf.name != self.MCF : continue + l=mcf.childNodes[:] + l.reverse() + for ll in l: + for mc in ll.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} +dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur} SansRegle=pasDeRegle() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index 77bd8338..5aa9ddc3 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- import logging +import regles from parseur import FactNode #debug=1 @@ -8,9 +9,9 @@ debug=0 #avant de supprimer un autre mocle, on remet à jour l'arbre syntaxique (lineno,colno,etc.) -#--------------------------------- -def removeMotCle(jdc,command,mocle): -#--------------------------------- +#----------------------------------------------------------- +def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle): +#----------------------------------------------------------- #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() @@ -18,9 +19,28 @@ def removeMotCle(jdc,command,mocle): if c.name != command:continue for mc in c.childNodes: if mc.name != mocle:continue + if ensemble.verif(c) == 0 : continue removeMC(jdc,c,mc) jdc.reset(jdc.getSource()) + +#------------------------------------------------------- +def removeMotCleSiRegle(jdc,command,mocle,liste_regles) : +#------------------------------------------------------- + mesRegles=regles.ensembleRegles(liste_regles) + removeMotCle(jdc,command,mocle,mesRegles) + + +#-------------------------------- +def removeCommande(jdc,command): +#-------------------------------- + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: + if c.name != command:continue + jdc.supLignes(c.lineno,c.endline) + logging.error("Suppression de: %s, %s, %s",c.name,c.lineno,c.endline) + #--------------------------------- def removeMC(jdc,c,mc): diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index 016bcac3..eba0d342 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -9,15 +9,18 @@ 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): -#------------------------------------------- +#------------------------------------------------------ +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 - logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name) + if erreur : + logging.error("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name) + 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] jdc.getLines()[mc.lineno-1]=s[:mc.colno]+new_name+s[mc.colno+len(mocle):] diff=len(new_name) - len(mocle) @@ -25,6 +28,11 @@ def renameMotCle(jdc,command,mocle,new_name): jdc.reset(jdc.getSource()) +#------------------------------------------------------ +def renameMotCleAvecErreur(jdc,command,mocle,new_name): +#------------------------------------------------------ + renameMotCle(jdc,command,mocle,new_name,1) + #------------------------------------------- def renameOper(jdc,command,new_name): #------------------------------------------- -- 2.39.2