Traducteur/inseremocle.py

   1 # -*- coding: utf-8 -*-
   2 import logging
   3 from parseur import FactNode
   4 from dictErreurs import jdcSet
   5 from dictErreurs import EcritErreur
   6 import string
   7 import regles
   8 debug=0
   9
  10
  11 #-----------------------------------
  12 def insereMotCle(jdc,recepteur,texte):
  13 #-----------------------------------
  14 # appelle la methode selon la classe
  15 # du recepteur
  16
  17     if recepteur.name  not in jdcSet : return
  18     if recepteur.__class__.__name__ == "Command" :
  19        if debug : print " Ajout de ", texte, "dans la commande : " ,recepteur.name
  20        insereMotCleDansCommande(jdc,recepteur,texte)
  21        return
  22
  23
  24 #--------------------------------------------
  25 def insereMotCleDansCommande(jdc,command,texte):
  26 #---------------------------------------------
  27 # insere le texte comme 1er mot cle
  28 # de la commande
  29     if command.name  not in jdcSet : return
  30     if debug : print "insereMotCle ", texte , " dans ", command.name
  31     numcol=chercheDebut1Mot(jdc,command)
  32     if numcol > 0 :
  33        jdc.splitLine(command.lineno,numcol)
  34     indice = -1
  35     while texte[indice] == " " :
  36        indice = indice -1
  37     if texte[indice] != "," : texte=texte+","
  38     texteinfo=texte
  39     texte=texte+'\n'
  40     jdc.addLine(texte,command.lineno)
  41     logging.info("Insertion de : %s ligne %d", texteinfo,command.lineno)
  42     if numcol > 0 :             # Les mots clefs etaient sur la même ligne
  43         jdc.joinLineandNext(command.lineno)
  44
  45 #---------------------------------------------
  46 def insereMotCleDansFacteur(jdc,facteur,texte):
  47 #-------------------------------------------------
  48     if debug : print "insereMotCle ", texte , " dans ", facteur.name
  49
  50     if texte[-1] == "\n" : texte=texte[0:-1]
  51     ancien=jdc.getLine(facteur.lineno)
  52
  53     # On va chercher la derniere ) pour ajouter avant
  54     # on va verifier s il il y a un , avant
  55     # si le texte ne finit pas par une ","
  56     # on en met une
  57
  58     indice = -1
  59     while texte[indice] == " " :
  60        indice = indice -1
  61     if texte[indice] != "," :
  62        texte=texte+","
  63     if (texte.find("#") > -1) and (texte.find("#") < texte.find(",")) :
  64           texte=texte+"\n,"
  65
  66     texteinfo=texte
  67     texte=texte+"\n"
  68
  69     ligneaCouper=facteur.lineno
  70     trouve=0
  71     trouveF=0
  72     trouveP=0
  73     while ligneaCouper < facteur.endline + 1 :
  74        indiceDeCoupe=0
  75        while  ancien.find("_F") > 0 :
  76           longueur=len(ancien)
  77           indice=ancien.find("_F")
  78           indiceParcours=0
  79           # pour ne pas tenir compte des autres noms
  80           # Attention si 2 MCF sur la meme ligne (la 1ere)
  81           if trouveF == 0 :
  82             if ((ligneaCouper!=facteur.lineno) or ((ancien.find(facteur.name) < indice ) or (ancien.find(facteur.name) < 0))) :
  83                trouveF=1
  84                indiceParcours=indice + 2
  85           # attention pour regler DEFI_FONCTION ..
  86             else :
  87                indiceDeCoupe=indiceDeCoupe+indice+2
  88                ancien=ancien[indice +2:]
  89                continue
  90
  91           if trouveF == 1 :
  92              indiceDeCoupe=indiceDeCoupe+indice
  93     #         print "indice de Parcours" ,indiceParcours
  94     #         print ancien[indiceParcours]
  95     #         print ancien[indiceParcours+1]
  96     #         print ancien[indiceParcours+2]
  97              while  indiceParcours < longueur :
  98                if ancien[indiceParcours] == "(" :
  99                 trouveP=1
 100     #            print "trouve"
 101                 break
 102                if ancien[indiceParcours] != " " :
 103                 trouveP=0
 104     #            print "mouv"
 105                 break
 106                indiceParcours = indiceParcours+1
 107           trouve = trouveP * trouveF
 108           if trouve : break
 109           ancien=ancien[indice+1:]
 110
 111        trouve = trouveP * trouveF
 112        if trouve : break
 113        ligneaCouper=ligneaCouper+1
 114        ancien=jdc.getLine(ligneaCouper)
 115
 116     if trouve :
 117        debut=indiceDeCoupe + 3
 118        jdc.splitLine(ligneaCouper,debut)
 119     else :
 120        print "Le traducteur ne sait pas faire"
 121        assert 0
 122
 123     # enleve les blancs en debut de texte
 124     i = 0
 125     while i < len(texte) :
 126       if texte[i] != " " : break
 127       i = i +1
 128
 129     jdc.addLine(texte,ligneaCouper)
 130     jdc.joinLineandNext(ligneaCouper)
 131     logging.info("Insertion de %s ligne %d", texteinfo,ligneaCouper)
 132     # Gestion du cas particulier du mot clef facteur vide
 133     if facteur.childNodes == []:
 134        jdc.joinLineandNext(facteur.lineno)
 135
 136
 137 #-----------------------------------
 138 def chercheDebut1Mot(jdc,command):
 139 #-----------------------------------
 140 # Retourne le numero de colonne si le 1er mot clef est
 141 # sur la meme ligne que le mot clef facteur
 142 # -1 sinon
 143     assert (command.childNodes != [])
 144     debut=-1
 145     node1=command.childNodes[0]
 146     if hasattr(node1,"lineno"):
 147        if node1.lineno == command.lineno :
 148           debut=node1.colno
 149     else:
 150        debut=chercheDebutFacteur(jdc,command)
 151     if debut == -1 and debug : print "attention!!! pb pour trouver le debut dans ", command
 152     return debut
 153
 154 #-----------------------------------
 155 def chercheDebutFacteur(jdc,facteur):
 156 #-----------------------------------
 157     debut=-1
 158     ligne=jdc.getLines()[facteur.lineno]
 159     debut=ligne.find("_F")
 160     if debut >  -1 : debut=debut + 3
 161     return debut
 162
 163
 164 #-----------------------------------
 165 def chercheAlignement(jdc,command):
 166 #-----------------------------------
 167 # Retourne le nb de blanc
 168 # pour aligner sur le 1er mot clef fils
 169     assert (command.childNodes != [])
 170     node1=command.childNodes[0]
 171     nbBlanc=node1.colno
 172     return " "*nbBlanc
 173
 174 #---------------------------------------------------------------------------------------------------------
 175 def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle, estunFacteur=1, erreur=0):
 176 #--------------------------------------------------------------------------------------------------------
 177 # Cherche l oper
 178 # cree le texte
 179 # appelle insereMotCle pour ajouter le texte
 180 #
 181     boolChange=0
 182     if estunFacteur :
 183       texte=nouveau+"=_F(),"
 184     else :
 185       texte=nouveau
 186     if nomcommande  not in jdcSet : return
 187     commands= jdc.root.childNodes[:]
 188     commands.reverse()
 189     for c in commands:
 190         if c.name != nomcommande:continue
 191         if ensemble.verif(c) == 0 : continue
 192         if erreur : EcritErreur((nomcommande,nouveau),c.lineno)
 193         boolChange=1
 194         insereMotCle(jdc,c,texte)
 195     if boolChange : jdc.reset(jdc.getSource())
 196
 197 #----------------------------------------------------------------------------------------
 198 def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1):
 199 #----------------------------------------------------------------------------------------
 200 # Cherche l oper
 201 # cree le texte
 202 # appelle insereMotCle pour ajouter le texte
 203 #
 204     if nomcommande  not in jdcSet : return
 205     mesRegles=regles.ensembleRegles(liste_regles)
 206     chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur)
 207
 208 #---------------------------------------------------------------------------------------------------------
 209 def chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1):
 210 #---------------------------------------------------------------------------------------------------------
 211     if nomcommande  not in jdcSet : return
 212     mesRegles=regles.ensembleRegles(liste_regles)
 213     chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur,erreur=1)
 214
 215 #-------------------------------------------------------------------------------------------------
 216 def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle, estunFacteur=0):
 217 #-------------------------------------------------------------------------------------------------
 218 # Cherche la commande
 219 # Cherche le MCF
 220 # cree le texte
 221 # appelle insereMotCle pour ajouter le texte
 222 #
 223     if commande  not in jdcSet : return
 224     if estunFacteur :
 225       texte=nouveau+"=_F(),"
 226     else :
 227       texte=nouveau
 228     commands= jdc.root.childNodes[:]
 229     commands.reverse()
 230     boolChange=0
 231     for c in commands:
 232         if c.name != commande : continue
 233         for mcF in c.childNodes:
 234           if mcF.name != fact : continue
 235           if ensemble.verif(c) == 0 : continue
 236           l=mcF.childNodes[:]
 237           l.reverse()
 238           boolChange=1
 239           insereMotCleDansFacteur(jdc,mcF,texte)
 240     if boolChange : jdc.reset(jdc.getSource())
 241
 242 #-------------------------------------------------------------------------------------------
 243 def AjouteMotClefDansFacteurSiRegle(jdc,commande,fact,nouveau,liste_regles,estunFacteur=0):
 244 #-------------------------------------------------------------------------------------------
 245 #
 246     if commande  not in jdcSet : return
 247     mesRegles=regles.ensembleRegles(liste_regles)
 248     AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,mesRegles,estunFacteur)
 249