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