From: Pascale Noyret Date: Fri, 1 Sep 2006 15:19:22 +0000 (+0000) Subject: PN : merge des developpements X-Git-Tag: CC_param_poursuite~18 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=b39bab4316f76e0349be3ad63dcb1de40c6ddcff;p=modules%2Feficas.git PN : merge des developpements --- diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index b8d345b4..4f131280 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -2,83 +2,71 @@ import logging from parseur import FactNode import string -debug=1 +import regles +debug=0 #----------------------------------- -def inseremotcle(jdc,recepteur,texte): +def insereMotCle(jdc,recepteur,texte): #----------------------------------- # appelle la methode selon la classe # du recepteur if recepteur.__class__.__name__ == "Command" : if debug : print " Ajout de ", texte, "dans la commande : " ,recepteur.name - inseremotcleincommand(jdc,recepteur,texte) + insereMotCleDansCommande(jdc,recepteur,texte) return #-------------------------------------------- -def inseremotcleincommand(jdc,command,texte): +def insereMotCleDansCommande(jdc,command,texte): #--------------------------------------------- # insere le texte comme 1er mot cle # de la commande - if debug : print "inseremotcle ", texte , " dans ", command.name - numcol=chercheDebut1mot(jdc,command) + if debug : print "insereMotCle ", texte , " dans ", command.name + numcol=chercheDebut1Mot(jdc,command) if numcol > 0 : jdc.splitLine(command.lineno,numcol) - debut=chercheAlignement(jdc,command) - texte=debut+texte+"\n" + texte=texte+'\n' jdc.addLine(texte,command.lineno) if numcol > 0 : # Les mots clefs etaient sur la même ligne jdc.joinLineandNext(command.lineno) #--------------------------------------------- -def inseremotcleinfacteur(jdc,facteur,texte): +def insereMotCleDansFacteur(jdc,facteur,texte): #------------------------------------------------- - if debug : print "inseremotcle ", texte , " dans ", facteur.name + if debug : print "insereMotCle ", texte , " dans ", facteur.name + ancien=jdc.getLine(facteur.lineno ) - # On va chercher la dernier ) pour ajouter avant + + # On va chercher la derniere ) pour ajouter avant # on va verifier s il il y a un , avant - ligne,col,boolvirgule=chercheDerniereParenthese(jdc,facteur) - if col > 0 : - jdc.splitLine(ligne,col) - if boolvirgule == 0 : - jdc.addLine(",\n",ligne) - jdc.joinLineandNext(ligne) + # si le texte ne finit pas par une "," + # on en met une + + indice = -1 + while texte[indice] == " " : + indice = indice -1 + if texte[indice] != "," : texte=texte+"," + texte=texte+"\n" debut=ancien.find("_F") + 3 - aligne=debut*" " + jdc.splitLine(facteur.lineno,debut) + # enleve les blancs en debut de texte i = 0 while i < len(texte) : if texte[i] != " " : break i = i +1 - texte=aligne+texte+"\n" - jdc.addLine(texte,ligne) - jdc.joinLineandNext(ligne+1) - -#--------------------------------------- -def chercheDerniereParenthese(jdc,facteur): -#--------------------------------------- - ligne=facteur.endline-1 - col=-1 - boolvirgule=0 - trouveParent=0 - while ( trouveParent == 0) : - texte=jdc.getLine(ligne) - col=texte.rfind(")") - if col < 0 : - ligne=ligne-1 - else : - trouveParent=1 - indice=col -1 - while ( indice > -1 and texte[indice] == " " ): - indice = indice -1 - if texte[indice]=="," : - boolvirgule = 1 - return (ligne,col,boolvirgule) + + jdc.addLine(texte,facteur.lineno) + jdc.joinLineandNext(facteur.lineno) + # Gestion du cas particulier du mot clef facteur vide + if facteur.childNodes == []: + jdc.joinLineandNext(facteur.lineno) + #----------------------------------- -def chercheDebut1mot(jdc,command): +def chercheDebut1Mot(jdc,command): #----------------------------------- # Retourne le numero de colonne si le 1er mot clef est # sur la meme ligne que le mot clef facteur @@ -90,12 +78,12 @@ def chercheDebut1mot(jdc,command): if node1.lineno == command.lineno : debut=node1.colno else: - debut=chercheDebutfacteur(jdc,command) + debut=chercheDebutFacteur(jdc,command) if debut == -1 and debug : print "attention!!! pb pour trouver le debut dans ", command return debut #----------------------------------- -def chercheDebutfacteur(jdc,facteur): +def chercheDebutFacteur(jdc,facteur): #----------------------------------- debut=-1 ligne=jdc.getLines()[facteur.lineno] @@ -104,7 +92,6 @@ def chercheDebutfacteur(jdc,facteur): return debut - #----------------------------------- def chercheAlignement(jdc,command): #----------------------------------- @@ -115,4 +102,30 @@ def chercheAlignement(jdc,command): nbBlanc=node1.colno return " "*nbBlanc +#------------------------------------------------------------------------------ +def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle): +#------------------------------------------------------------------------------ +# Cherche l oper +# cree le texte +# appelle insereMotCle pour ajouter le texte +# + texte=nouveau+"=_F()," + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: + if c.name != nomcommande:continue + if ensemble.verif(c) == 0 : continue + insereMotCle(jdc,c,texte) + jdc.reset(jdc.getSource()) + +#------------------------------------------------------------------------ +def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles): +#------------------------------------------------------------------------ +# Cherche l oper +# cree le texte +# appelle insereMotCle pour ajouter le texte +# + mesRegles=regles.ensembleRegles(liste_regles) + chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles) + diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py index d6a1651d..e1a201fe 100644 --- a/Traducteur/jdcparser.py +++ b/Traducteur/jdcparser.py @@ -7,12 +7,17 @@ from mocles import parseKeywords import removemocle import renamemocle import movemocle +import inseremocle -#atraiter=("DEBUT","LIRE_MAILLAGE","AFFE_MODELE","DEFI_GROUP", -# "AFFE_MATERIAU","DEFI_MATERIAU","STAT_NONLINE", -# ) +atraiter=("IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", + "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G", + ) -atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU") + +#atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU", +# "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",) +#atraiter=( "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G",) +#atraiter=( "IMPR_GENE",) filename="toto.comm" jdc=getJDC(filename,atraiter) root=jdc.root @@ -20,30 +25,32 @@ root=jdc.root #Parse les mocles des commandes parseKeywords(root) -#removemocle.removemocleinfact(jdc,"AFFE_MATERIAU","AFFE","TOUT") -#removemocle.removemocle(jdc,"STAT_NONLINE","SOLVEUR") -#renamemocle.renamemocleinfact(jdc,"AFFE_MODELE","AFFE","PHENOMENE","TOTO") -#renamemocle.renamemocleinfact(jdc,"AFFE_MODELE","AFFE","MODELISATION","TITI") -#renamemocle.renamemocleinfact(jdc,"DEFI_GROUP","CREA_GROUP_NO","GROUP_MA","TUTU") -#removemocle.removemocle(jdc,"LIRE_MAILLAGE","INFO") -#removemocle.removemocle(jdc,"LIRE_MAILLAGE","UNITE") -#renamemocle.renamemocle(jdc,"DEFI_MATERIAU","ELAS","ELASTIC") -#renamemocle.renamemocle(jdc,"AFFE_MATERIAU","MAILLAGE","MAILL") -#removemocle.removemocleinfact(jdc,"STAT_NONLINE","SOLV","METHOD") -#removemocle.removemocle(jdc,"STAT_NONLINE","AFFE") -#renamemocle.renamecommande(jdc,"AFFE_CHAR_MECA","AFFE_CHAR_MECA_PN") -#renamemocle.renamecommande(jdc,"DEBUT","DEBUT_PN") +#removemocle.removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","TOUT") +#removemocle.removeMotCle(jdc,"STAT_NONLINE","SOLVEUR") +#renamemocle.renameMotCleInFact(jdc,"AFFE_MODELE","AFFE","PHENOMENE","TOTO") +#renamemocle.renameMotCleInFact(jdc,"AFFE_MODELE","AFFE","MODELISATION","TITI") +#renamemocle.renameMotCleInFact(jdc,"DEFI_GROUP","CREA_GROUP_NO","GROUP_MA","TUTU") +#removemocle.removeMotCle(jdc,"LIRE_MAILLAGE","INFO") +#removemocle.removeMotCle(jdc,"LIRE_MAILLAGE","UNITE") +#renamemocle.renameMotCle(jdc,"DEFI_MATERIAU","ELAS","ELASTIC") +#renamemocle.renameMotCle(jdc,"AFFE_MATERIAU","MAILLAGE","MAILL") +#removemocle.removeMotCleInFact(jdc,"STAT_NONLINE","SOLV","METHOD") +#removemocle.removeMotCle(jdc,"STAT_NONLINE","AFFE") +#renamemocle.renameCommande(jdc,"AFFE_CHAR_MECA","AFFE_CHAR_MECA_PN") +#renamemocle.renameCommande(jdc,"DEBUT","DEBUT_PN") + +# A decommenter a partir d ici # les arguments sont jdc,ancien-nom-de-commande,nouveau-nom-de-commande -renamemocle.renamecommande(jdc,"CALC_FONCTION","INFO_FONCTION") +renamemocle.renameCommande(jdc,"CALC_FONCTION","INFO_FONCTION") # Les arguments sont - jdc, # - nom de la procedure (pas teste avec autre chose) # - nom du mot clef facteur contenant, # - nom du mot cle simple # Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer -movemocle.movemoclefromfacttofather(jdc,"IMPR_GENE","GENE","UNITE") -movemocle.movemoclefromfacttofather(jdc,"IMPR_GENE","GENE","FORMAT") +movemocle.moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","UNITE") +movemocle.moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","FORMAT") # Les arguments sont - jdc # - nom de l operateur (pas teste avec autre chose) @@ -51,23 +58,36 @@ movemocle.movemoclefromfacttofather(jdc,"IMPR_GENE","GENE","FORMAT") # - nom du mot cle simple # - liste de mots clef facteur arrivée possible # Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer -movemocle.movemoclefromfacttofactmulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - - -renamemocle.renamemocle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA") -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",)) -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",)) -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",)) -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",)) -removemocle.removemocle(jdc,"DEFI_MATERIAU","FLU_IRRA") - -renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A") -renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B") -renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S") -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_A",("LEMAITRE_IRRA",)) -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",)) -movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",)) -removemocle.removemocle(jdc,"DEFI_MATERIAU","GRAN_IRRA") +movemocle.moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) + + +renamemocle.renameMotCle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA") +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",)) +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",)) +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",)) +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",)) +removemocle.removeMotCle(jdc,"DEFI_MATERIAU","FLU_IRRA") + +renamemocle.renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A") +renamemocle.renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B") +renamemocle.renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S") +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_A",("LEMAITRE_IRRA",)) +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",)) +movemocle.moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",)) +removemocle.removeMotCle(jdc,"DEFI_MATERIAU","GRAN_IRRA") + +#renamemocle.renameOper(jdc,"CALC_G_LOCAL_T","CALC_G") +renamemocle.renameOper(jdc,"CALC_G_THETA_T","CALC_G") +renamemocle.renameMotCle(jdc,"CALC_G","THETA","THETA_OLD") +inseremocle.chercheOperInsereFacteur(jdc,"CALC_G","THETA") + +movemocle.moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA") +renamemocle.renameMotCleInFact(jdc,"CALC_G","THETA","THETA_OLD","THETA") +movemocle.moveMotClefInOperToFact(jdc,"CALC_G","FOND_FISS","THETA") +movemocle.moveMotClefInOperToFact(jdc,"CALC_G","R_INF_FO","THETA") +movemocle.moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA") +inseremocle.chercheOperInsereFacteurSiRegle(jdc,"CALC_G","LISSAGE",((("DEGRE",),"existe"),)) +movemocle.moveMotClefInOperToFact(jdc,"CALC_G","DEGRE","LISSAGE") f=open("tutu.comm",'w') diff --git a/Traducteur/load.py b/Traducteur/load.py index ca1f4c50..e39bfd5e 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -19,7 +19,7 @@ class JDC: def init(self,src,atraiter): #--------------------------- # construction de self.lines - self.root=parseur.parser(src,atraiter) + self.root=parseur.Parser(src,atraiter) self.lines=src.splitlines(1) def parseKeywords(self): @@ -57,8 +57,7 @@ class JDC: Lmilieu=[ligne,] Lfin=self.lines[numero:] self.lines=Ldebut+Lmilieu+Lfin - src=self.getSource() - self.reset(src) + def splitLine(self,numeroLigne,numeroColonne) : #---------------------------------------------- @@ -77,8 +76,6 @@ class JDC: Lmilieu=[LigneSplitDebut,LigneSplitFin] self.lines=Ldebut+Lmilieu+Lfin - src=self.getSource() - self.reset(src) def joinLineandNext(self,numeroLigne) : #-------------------------------------- @@ -100,8 +97,10 @@ class JDC: Lmilieu=[ligneMilieuDeb+ligneMilieuFin,] self.lines=Ldebut+Lmilieu+Lfin - src=self.getSource() - self.reset(src) + + def remplaceLine(self,numeroLigne,nouveauTexte) : + #------------------------------------------------ + self.lines[numeroLigne]=nouveauTexte def getJDC(filename,atraiter): #---------------------------_ diff --git a/Traducteur/log.py b/Traducteur/log.py index 80396639..35b5cfeb 100644 --- a/Traducteur/log.py +++ b/Traducteur/log.py @@ -3,7 +3,6 @@ import logging logger=logging.getLogger() hdlr=logging.FileHandler('convert.log','w') -#formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') formatter = logging.Formatter('%(levelname)s: %(message)s') hdlr.setFormatter(formatter) logger.addHandler(hdlr) diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py index f9429ad8..0898c8c7 100644 --- a/Traducteur/mocles.py +++ b/Traducteur/mocles.py @@ -2,13 +2,15 @@ import compiler import types -from parseur import Keyword,FactNode,lastparen,lastparen2 -from visiteur import KeywordFinder,visitor -from utils import indexToCoordinates +from parseur import Keyword, FactNode, lastparen, lastparen2 +from visiteur import KeywordFinder, visitor +from utils import indexToCoordinates debug=0 +#------------------------ def parseFact(match,c,kw): +#------------------------ submatch=match[2] lastpar=match[0]+lastparen(c.src[match[0]:]) if type(submatch[0][0]) ==types.IntType: @@ -61,9 +63,11 @@ def parseFact(match,c,kw): no.addChild(Keyword(e[1],lineno,colno,endline,endcol)) +#----------------------- def parseKeywords(root): - """A partir d'un arbre contenant des commandes, ajoute les noeuds fils correspondant aux mocles - de la commande +#----------------------- + """A partir d'un arbre contenant des commandes, ajoute les noeuds + fils correspondant aux mocles de la commande """ matchFinder=KeywordFinder() @@ -74,8 +78,10 @@ def parseKeywords(root): 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 (matchFinder.matches[i+1][0]]) + # plusieurs mocles trouvés : + # un mocle commence au début 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]] x,y=indexToCoordinates(c.src,matchFinder.matches[i][0]) @@ -90,8 +96,12 @@ def parseKeywords(root): submatch= matchFinder.matches[i][2] if submatch: parseFact(matchFinder.matches[i],c,kw) - #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) + + # 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) + if debug:print "texte:",c.src[matchFinder.matches[i+1][0]:c.lastparen] x,y=indexToCoordinates(c.src,matchFinder.matches[i+1][0]) lineno=y+c.lineno @@ -107,8 +117,10 @@ def parseKeywords(root): 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 commande (c.lastparen) + #un seul mocle trouve : + # il commence au début 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]) lineno=y+c.lineno diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index 8e07cbe7..5cfb385d 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -4,10 +4,13 @@ import logging import removemocle import inseremocle from parseur import FactNode -debug=1 +debug=0 -def movemoclefromfacttofather(jdc,command,fact,mocle): +#----------------------------------------------------- +def moveMotCleFromFactToFather(jdc,command,fact,mocle): +#----------------------------------------------------- # exemple type : IMPR_GENE + for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -18,21 +21,30 @@ def movemoclefromfacttofather(jdc,command,fact,mocle): if n.name != mocle:continue if debug : print "Changement de place :", n.name, n.lineno, n.colno MonTexte=n.getText(jdc); - inseremocle.inseremotcle(jdc,c,MonTexte) + inseremocle.insereMotCle(jdc,c,MonTexte) logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno) - removemocle.removemocleinfact(jdc,command,fact,mocle) + jdc.reset(jdc.getSource()) + removemocle.removeMotCleInFact(jdc,command,fact,mocle) + -def movemoclefromfacttofactmulti(jdc,oper,factsource,mocle,liste_factcible): +#---------------------------------------------------------------------------- +def moveMotCleFromFactToFactMulti(jdc,oper,factsource,mocle,liste_factcible): +#---------------------------------------------------------------------------- # exemple type STAT_NON_LINE et RESI_INTER_RELA for factcible in liste_factcible : - movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible) - removemocle.removemocleinfact(jdc,oper,factsource,mocle) + moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible) + jdc.reset(jdc.getSource()) + removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) -def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible): - if debug : print "movemoclefromfacttofact pour " ,oper,factsource,mocle,factcible - for c in jdc.root.childNodes: +#---------------------------------------------------------------------------- +def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible): +#---------------------------------------------------------------------------- + if debug : print "moveMotCleFromFactToFact pour " ,oper,factsource,mocle,factcible + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: if c.name != oper : continue cible=None for mc in c.childNodes: @@ -66,7 +78,49 @@ def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible): for n in ll.childNodes: if n.name != mocle:continue MonTexte=n.getText(jdc); - inseremocle.inseremotcleinfacteur(jdc,cible,MonTexte) + inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno) logging.info("vers : %s", cible.name) + + + +#------------------------------------------------------ +def moveMotClefInOperToFact(jdc,oper,mocle,factcible): +#------------------------------------------------------ +# Attention le cas type est THETA_OLD dans calc_G + + if debug : print "movemocleinoper pour " ,oper,mocle,factcible + commands= jdc.root.childNodes[:] + commands.reverse() + for c in commands: + if c.name != oper : continue + cible=None + for mc in c.childNodes: + if mc.name != factcible : + continue + else : + cible=mc + break + if cible==None : + logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible) + logging.info("Le mot clef cible %s n est pas présent", factcible) +# if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée" + continue + + source=None + for mc in c.childNodes: + if mc.name != mocle: + continue + else : + source=mc + break + if source==None : + logging.info("Pas de changement pour %s,%s,%s",oper, mocle,factcible) + logging.info("Le mot clef source %s n est pas présent", mocle) +# if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée" + continue + MonTexte=source.getText(jdc); + inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) + jdc.reset(jdc.getSource()) + removemocle.removeMotCle(jdc,oper,mocle) diff --git a/Traducteur/parseur.py b/Traducteur/parseur.py index 5b4a223f..2f772329 100644 --- a/Traducteur/parseur.py +++ b/Traducteur/parseur.py @@ -11,8 +11,11 @@ allchars = string.maketrans("", "") allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:] allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline)) +#------------------------------ def maskStringsAndComments(src): +#------------------------------ """Remplace tous les caracteres dans commentaires et strings par des * """ + src = escapedQuotesRE.sub("**", src) allstrings = stringsAndCommentsRE.split(src) # every odd element is a string or comment @@ -36,9 +39,13 @@ implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}')) linecontinueRE = re.compile(r"\\\s*(#.*)?$") emptyHangingBraces = [0,0,0,0,0] +#-------------------------------------- class UnbalancedBracesException: pass +#-------------------------------------- +#----------- class Node: +#----------- def __init__(self): self.childNodes=[] @@ -46,13 +53,22 @@ class Node: self.childNodes.append(node) -class FactNode(Node):pass +#------------------- +class FactNode(Node): +#------------------- + pass + + +#------------------- class JDCNode(Node): +#------------------- def __init__(self,src): Node.__init__(self) self.src=src +#------------------- class Command(Node): +#------------------- def __init__(self,name,lineno,colno,firstparen): Node.__init__(self) self.name=name @@ -60,7 +76,9 @@ class Command(Node): self.colno=colno self.firstparen=firstparen +#------------------- class Keyword(Node): +#------------------- def __init__(self,name,lineno,colno,endline,endcol): Node.__init__(self) self.name=name @@ -87,7 +105,9 @@ class Keyword(Node): texte = jdc.getLines()[self.lineno-1][self.colno:self.endcol] return texte +#------------------------- def chaineBlanche(texte) : +#------------------------- # retourne 1 si la chaine est composee de " " # retourne 0 sinon bool = 1 ; @@ -95,7 +115,9 @@ def chaineBlanche(texte) : if texte[i] != " " : bool = 0 return bool +#------------------- def printNode(node): +#------------------- if hasattr(node,'name'): print node.name else: @@ -103,7 +125,9 @@ def printNode(node): for c in node.childNodes: printNode(c) -def parser(src,atraiter): +#------------------------ +def Parser(src,atraiter): +#------------------------ """Parse le texte src et retourne un arbre syntaxique (root). Cet arbre syntaxique a comme noeuds (childNodes) les commandes à traiter (liste atraiter) @@ -114,8 +138,9 @@ def parser(src,atraiter): 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 root.childNodes (liste) + # (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 + # root.childNodes (liste) lineno=0 for line in maskedLines: lineno=lineno+1 @@ -129,16 +154,16 @@ def parser(src,atraiter): 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 deuxième temps , on récupère le texte complet de la commande + # jusqu'à la dernière parenthèse fermante - #iterateur sur les lignes physiques masquées + # iterateur sur les lignes physiques masquées iterlines=iter(maskedLines) linenum=0 for c in root.childNodes: lineno=c.lineno - colno=c.colno # début de la commande + colno=c.colno # début de la commande while linenum < lineno: line=iterlines.next() linenum=linenum+1 @@ -183,11 +208,14 @@ def parser(src,atraiter): return root +#----------------- def lastparen(src): +#----------------- """Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string La string doit contenir la premiere parenthese ouvrante """ + src=maskStringsAndComments(src) level=0 i,n=0,len(src) @@ -204,7 +232,9 @@ def lastparen(src): #derniere parenthese fermante return i +#------------------- def lastparen2(src): +#------------------- """Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string La string ne contient pas la premiere parenthese ouvrante diff --git a/Traducteur/regles.py b/Traducteur/regles.py new file mode 100644 index 00000000..035efb8e --- /dev/null +++ b/Traducteur/regles.py @@ -0,0 +1,72 @@ +# -*- coding: utf-8 -*- +import logging +import string +debug=0 + + +#-------------------- +class ensembleRegles: +#-------------------- + + def __init__(self,liste_regles): + self.liste=[] + for item in liste_regles : + args,clefRegle=item + r=regle(clefRegle,args) + self.liste.append(r) + + def verif(self,commande) : + bool=1 + for regle in self.liste : + result=regle.verif(commande) + bool=bool*result + return bool + +#-------------------------------- +class pasDeRegle(ensembleRegles): +#-------------------------------- + def __init__(self) : + pass + + def verif (self,commande) : + return 1 + + +#------------ +class regle : +#------------ + + def __init__(self,clef_regle,args): + self.fonction=dictionnaire_regle[clef_regle] + self.list_args=args + self.bool=0 + + def verif(self,commande): + f=self.fonction(self.list_args) + return f.verif(commande) + + +#------------- +class existe : +#-------------- + def __init__(self,list_arg): + self.genea=list_arg + + def cherche_mot(self,niveau,commande): + if commande == None : return 0 + if niveau == len(self.genea) : return 1 + texte=self.genea[niveau] + for c in commande.childNodes : + if c.name == texte : + niveau = niveau+1 + return self.cherche_mot(niveau,c) + return None + + def verif(self,commande): + bool=self.cherche_mot(0,commande) + if bool == None : bool = 0 + return bool + + +dictionnaire_regle={"existe":existe} +SansRegle=pasDeRegle() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index 4af3caee..ecb20f26 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -6,7 +6,11 @@ from parseur import FactNode debug=0 #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.) -def removemocle(jdc,command,mocle): + + +#--------------------------------- +def removeMotCle(jdc,command,mocle): +#--------------------------------- #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() @@ -14,28 +18,34 @@ def removemocle(jdc,command,mocle): if c.name != command:continue for mc in c.childNodes: if mc.name != mocle:continue - removemc(jdc,c,mc) + removeMC(jdc,c,mc) jdc.reset(jdc.getSource()) -def removemc(jdc,c,mc): +#--------------------------------- +def removeMC(jdc,c,mc): +#--------------------------------- if debug:print "Suppression de:",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol logging.info("Suppression de: %s, %s, %s, %s, %d, %d",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol) + if mc.endline > mc.lineno: if debug:print "mocle sur plusieurs lignes--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:] 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 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] s=jdc.getLines()[mc.lineno-1] jdc.getLines()[mc.lineno-1]=s[:mc.colno]+s[mc.endcol:] - fusionne(jdc,mc.lineno-1) - jdc.reset(jdc.getSource()) + fusionne(jdc,mc.lineno-1) -def removemocleinfact(jdc,command,fact,mocle): - #on itere sur les commandes a l'envers pour ne pas polluer les numeros de ligne avec les modifications +#-------------------------------------------- +def removeMotCleInFact(jdc,command,fact,mocle): +#--------------------------------------------- + # 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() for c in commands: @@ -47,11 +57,19 @@ def removemocleinfact(jdc,command,fact,mocle): for ll in l: for n in ll.childNodes: if n.name != mocle:continue - removemc(jdc,c,n) + removeMC(jdc,c,n) jdc.reset(jdc.getSource()) +#------------------------------------------ def fusionne(jdc,numLigne): +#------------------------------------------ +# fusionne la ligne numLigne et numLigne+1 +# si la ligne numLigne+1 ne contient que des parentheses +# fermantes +# Attention a la difference de numerotation +# jdc.getLines()[numLigne] donne la ligne numLigne -1 +# alors que joinLineandNext(numLigne) travaille sur le tableau index=0 texte=jdc.getLines()[numLigne] fusion=1 @@ -60,6 +78,7 @@ def fusionne(jdc,numLigne): fusion=0 break index=index+1 + if fusion : import load jdc.joinLineandNext(numLigne) diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index 871c07a9..d8bc5c6a 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -1,12 +1,15 @@ # -*- coding: utf-8 -*- import logging +import sys from parseur import FactNode debug=1 #on n'a qu'un mocle par commande. #en fin de traitement, on remet à jour l'arbre syntaxique (lineno,colno,etc.) -def renamemocle(jdc,command,mocle,new_name): +#------------------------------------------- +def renameMotCle(jdc,command,mocle,new_name): +#------------------------------------------- for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -15,10 +18,45 @@ def renamemocle(jdc,command,mocle,new_name): 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) + decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff) jdc.reset(jdc.getSource()) -def renamemocleinfact(jdc,command,fact,mocle,new_name): +#------------------------------------------- +def renameOper(jdc,command,new_name): +#------------------------------------------- + for c in jdc.root.childNodes: + print c.name + if c.name != command:continue + if debug:print "Renommage de:",c.name,c.lineno,c.colno + logging.info("Renommage de: %s, %s, %s, en %s",c.name,c.lineno,c.colno,new_name) + s=jdc.getLines()[c.lineno-1] + jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):] + diff=len(new_name) - len(command) + decaleLignesdeNBlancs(jdc,c.lineno,c.endline,diff) + #print jdc.getSource() + #import sys + #sys.exit(0) + jdc.reset(jdc.getSource()) + +#---------------------------------------------------------- +def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): +#---------------------------------------------------------- + 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 + +#---------------------------------------------------------- +def renameMotCleInFact(jdc,command,fact,mocle,new_name): +#---------------------------------------------------------- for c in jdc.root.childNodes: if c.name != command:continue for mc in c.childNodes: @@ -34,7 +72,9 @@ def renamemocleinfact(jdc,command,fact,mocle,new_name): jdc.reset(jdc.getSource()) -def renamecommande(jdc,command,new_name): +#---------------------------------------- +def renameCommande(jdc,command,new_name): +#---------------------------------------- # nom de la commande "ancien format" , nom de la commande " nouveau format " for c in jdc.root.childNodes: if c.name != command:continue @@ -45,4 +85,3 @@ def renamecommande(jdc,command,new_name): jdc.reset(jdc.getSource()) - diff --git a/Traducteur/utils.py b/Traducteur/utils.py index b78a4b07..e01f74bf 100644 --- a/Traducteur/utils.py +++ b/Traducteur/utils.py @@ -9,8 +9,9 @@ def indexToCoordinates(src, index): x = index-startOfLineIdx 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""" +def lineToDict(line): + """Transforme une ligne (string) en un dictionnaire de mots + repérés par le numéro de la colonne""" words = re.split("(\w+)", line) h = {};i = 0 @@ -19,7 +20,7 @@ def linetodict(line): i+=len(word) return h -def dicttoline(d): +def DictToLine(d): """Transformation inverse: à partir d'un dictionnaire retourne une ligne""" cols = d.keys() cols.sort() diff --git a/Traducteur/visiteur.py b/Traducteur/visiteur.py index 0d1030f9..0646c93a 100644 --- a/Traducteur/visiteur.py +++ b/Traducteur/visiteur.py @@ -51,7 +51,8 @@ class KeywordFinder(MatchFinder): self.matches = [] self.visit(child) if self.matches: - #Pour eviter les tuples et listes ordinaires, on ne garde que les visites fructueuses + # Pour eviter les tuples et listes ordinaires, + # on ne garde que les visites fructueuses matchlist.append(self.matches) self.matches=matchlist @@ -59,5 +60,6 @@ class KeywordFinder(MatchFinder): def visitName(self,node): self.popWordsUpTo(node.name) + def visitAssName(self,node): self.popWordsUpTo(node.name)