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
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]
return debut
-
#-----------------------------------
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)
+
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
#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)
# - 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')
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):
Lmilieu=[ligne,]
Lfin=self.lines[numero:]
self.lines=Ldebut+Lmilieu+Lfin
- src=self.getSource()
- self.reset(src)
+
def splitLine(self,numeroLigne,numeroColonne) :
#----------------------------------------------
Lmilieu=[LigneSplitDebut,LigneSplitFin]
self.lines=Ldebut+Lmilieu+Lfin
- src=self.getSource()
- self.reset(src)
def joinLineandNext(self,numeroLigne) :
#--------------------------------------
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):
#---------------------------_
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)
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:
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()
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])
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
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
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:
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:
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)
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
linecontinueRE = re.compile(r"\\\s*(#.*)?$")
emptyHangingBraces = [0,0,0,0,0]
+#--------------------------------------
class UnbalancedBracesException: pass
+#--------------------------------------
+#-----------
class Node:
+#-----------
def __init__(self):
self.childNodes=[]
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
self.colno=colno
self.firstparen=firstparen
+#-------------------
class Keyword(Node):
+#-------------------
def __init__(self,name,lineno,colno,endline,endcol):
Node.__init__(self)
self.name=name
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 ;
if texte[i] != " " : bool = 0
return bool
+#-------------------
def printNode(node):
+#-------------------
if hasattr(node,'name'):
print node.name
else:
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)
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
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
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)
#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
--- /dev/null
+# -*- 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()
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()
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:
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
fusion=0
break
index=index+1
+
if fusion :
import load
jdc.joinLineandNext(numLigne)
# -*- 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:
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:
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
jdc.reset(jdc.getSource())
-
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
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()
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
def visitName(self,node):
self.popWordsUpTo(node.name)
+
def visitAssName(self,node):
self.popWordsUpTo(node.name)
