# -*- coding: utf-8 -*-
from parseur import FactNode
+import logging
dict_commande={}
dict_contexte={}
dict_contexte_option={}
+import sys
#--------------------------------------------------------------------------
def traitementRayon(jdc):
#--------------------------------------------------------------------------
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
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
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):
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())
#-------------------------------------------------
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
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)
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",
#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,
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")
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")
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())
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
# -*- coding: utf-8 -*-
import logging
import string
+from parseur import FactNode
debug=0
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 :
#--------------
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()
# -*- coding: utf-8 -*-
import logging
+import regles
from parseur import FactNode
#debug=1
#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()
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):
#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)
jdc.reset(jdc.getSource())
+#------------------------------------------------------
+def renameMotCleAvecErreur(jdc,command,mocle,new_name):
+#------------------------------------------------------
+ renameMotCle(jdc,command,mocle,new_name,1)
+
#-------------------------------------------
def renameOper(jdc,command,new_name):
#-------------------------------------------
