Traducteur/changeValeur.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2017   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 from Traducteur.utils import lineToDict
  21 import logging
  22 from Traducteur.dictErreurs import ecritErreur
  23 from Traducteur.load import jdcSet
  24 from Traducteur.renamemocle import decaleLignesdeNBlancs
  25 from Traducteur.removemocle import removeMotCleInFact
  26 from Traducteur import regles
  27
  28
  29 #--------------------------------------------------------------------------
  30 def changementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
  31 #--------------------------------------------------------------------------
  32     if command  not in jdcSet : return
  33     boolChange=0
  34     for c in jdc.root.childNodes:
  35         if c.name != command  : continue
  36         trouveUnMC=0
  37         for mc in c.childNodes:
  38             if mc.name != motcle : continue
  39             trouveUnMC=1
  40             TexteMC=mc.getText(jdc)
  41             liste_ligne_MC=TexteMC.splitlines()
  42             indexLigneGlob=mc.lineno-1
  43             indexTexteMC=0
  44             while indexLigneGlob < mc.endline  :
  45                 if indexTexteMC > len(liste_ligne_MC)-1 : break
  46                 MaLigneGlob=jdc.getLines()[indexLigneGlob]
  47                 MaLigneTexte=liste_ligne_MC[indexTexteMC]
  48                 for Valeur in DictNouvVal :
  49                     MaLigneTexteDict=lineToDict(MaLigneTexte)
  50                     trouvecol=MaLigneTexte.find(Valeur)
  51                     if trouvecol > -1:
  52                         trouve=(Valeur==MaLigneTexteDict[trouvecol])
  53                     else:
  54                         trouve=False
  55                     if trouve:
  56                         debut=MaLigneGlob.find(motcle)
  57                         if debut==-1 : debut=0
  58                         Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
  59                         Nouveau=MaLigneGlob[0:debut]+Nouveau
  60                         jdc.getLines()[indexLigneGlob]=Nouveau
  61                         MaLigneTexte=Nouveau # raccourci honteux mais ...
  62                         MaLigneGlob=Nouveau
  63                         if Valeur in liste :
  64                             ecritErreur((command,motcle,Valeur),indexLigneGlob)
  65                         else :
  66                             logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
  67                         boolChange=1
  68                 indexLigneGlob=indexLigneGlob+1
  69                 indexTexteMC=indexTexteMC+1
  70         if (trouveUnMC == 0) and ( defaut == 1):
  71             ecritErreur((command,motcle,"DEFAUT"),c.lineno)
  72     if boolChange : jdc.reset(jdc.getSource())
  73
  74 #--------------------------------------------------------------------------------
  75 def changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),ensemble=regles.SansRegle,defaut=0):
  76 #--------------------------------------------------------------------------------
  77
  78     if command  not in jdcSet : return
  79     boolChange=0
  80     for c in jdc.root.childNodes:
  81         if c.name != command  : continue
  82         for mcF in c.childNodes:
  83             if mcF.name != fact : continue
  84             l=mcF.childNodes[:]
  85             l.reverse()
  86             for ll in l:
  87                 trouveUnMC=0
  88                 for mc in ll.childNodes:
  89                     if mc.name != motcle:continue
  90                     if ensemble.verif(c) == 0 : continue
  91                     trouveUnMC=1
  92                     TexteMC=mc.getText(jdc)
  93                     liste_ligne_MC=TexteMC.splitlines()
  94                     indexLigneGlob=mc.lineno-1
  95                     indexTexteMC=0
  96                     while indexLigneGlob < mc.endline  :
  97                         if indexTexteMC > len(liste_ligne_MC)-1 : break
  98                         MaLigneGlob=jdc.getLines()[indexLigneGlob]
  99                         MaLigneTexte=liste_ligne_MC[indexTexteMC]
 100                         for Valeur in DictNouvVal :
 101                             MaLigneTexteDict=lineToDict(MaLigneTexte)
 102                             trouvecol=MaLigneTexte.find(Valeur)
 103                             if trouvecol > -1:
 104                                 trouve=(Valeur==MaLigneTexteDict[trouvecol])
 105                             else:
 106                                 trouve=False
 107                             if trouve:
 108                                 debut=MaLigneGlob.find(motcle)
 109                                 if debut==-1 : debut=0
 110                                 Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
 111                                 Nouveau=MaLigneGlob[0:debut]+Nouveau
 112                                 jdc.getLines()[indexLigneGlob]=Nouveau
 113                                 MaLigneTexte=Nouveau # raccourci honteux mais ...
 114                                 MaLigneGlob=Nouveau
 115                                 if Valeur in liste :
 116                                     ecritErreur((command,fact,motcle,Valeur),indexLigneGlob)
 117                                 else :
 118                                     logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
 119                         boolChange=1
 120                         indexLigneGlob=indexLigneGlob+1
 121                         indexTexteMC=indexTexteMC+1
 122                 if (trouveUnMC == 0) and ( defaut == 1):
 123                     logging.warning("OPTION  (defaut) de CALCG a verifier ligne %s" ,c.lineno )
 124                     ecritErreur((command,fact,motcle,"DEFAUT"),c.lineno)
 125     if boolChange : jdc.reset(jdc.getSource())
 126
 127 #--------------------------------------------------------------------------------
 128 def changementValeurDsMCFSiRegle(jdc,command,fact,motcle,DictNouvVal,liste_regles,defaut=0):
 129 #--------------------------------------------------------------------------------
 130     if command not in jdcSet : return
 131     mesRegles=regles.ensembleRegles(liste_regles)
 132     liste=()
 133     changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,mesRegles,defaut)
 134
 135 #---------------------------------------------------------------------------------------
 136 def changementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste):
 137 #---------------------------------------------------------------------------------------
 138     if command  not in jdcSet : return
 139     defaut=0
 140     if liste[-1] == "defaut" :
 141         defaut=1
 142     changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,defaut)
 143
 144 #--------------------------------------------------------------------------
 145 def changementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste):
 146 #--------------------------------------------------------------------------
 147     if command  not in jdcSet : return
 148     defaut=0
 149     if liste[-1] == "defaut" :
 150         defaut=1
 151     changementValeur(jdc,command,motcle,DictNouvVal,liste,defaut)
 152
 153 #--------------------------------------------------------------------------
 154 def suppressionValeurs(jdc, command,motcle,liste):
 155 #--------------------------------------------------------------------------
 156
 157     if command not in jdcSet : return
 158     boolChange=0
 159     for c in jdc.root.childNodes:
 160         if c.name != command  : continue
 161         for mc in c.childNodes:
 162             if mc.name != motcle : continue
 163             indexLigneGlob=mc.lineno-1
 164             while indexLigneGlob < mc.endline-1  :
 165                 MaLigneTexte = jdc.getLines()[indexLigneGlob]
 166                 MaLigne=MaLigneTexte
 167                 for Valeur in liste :
 168                     debutMC =MaLigne.find(motcle)
 169                     if debutMC ==-1 : debutMC=0
 170                     debut1=MaLigne[0:debutMC]
 171                     chercheLigne=MaLigne[debutMC:]
 172                     trouve=chercheLigne.find(Valeur)
 173                     premier=0
 174                     if trouve > 1 : #on a au moins une quote
 175                         debut=debut1 + chercheLigne[0:trouve-1]
 176                         index = -1
 177                         while (-1 * index) < len(debut) :
 178                             if (debut[index] == "(")  :
 179                                 premier = 1
 180                                 if index == -1 :
 181                                     index=len(debut)
 182                                 else :
 183                                     index=index+1
 184                                 break
 185                             if (debut[index] == "," ) :
 186                                 break
 187                             if (debut[index] != " " ) :
 188                                 assert(0)
 189                             index = index -1
 190                         debLigne = debut[0:index]
 191                         fin=trouve+len(Valeur)+1
 192                         if premier == 1 and chercheLigne[fin] == ',': fin = fin + 1 # on supprime la ,
 193                         finLigne = chercheLigne[fin:]
 194                         MaLigne_tmp=debLigne+finLigne
 195                         # traitement ligne commancant par ,
 196                         if len(MaLigne_tmp.strip()) > 0 :
 197                             if MaLigne_tmp.strip()[0]==',' :
 198                                 MaLigne=MaLigne_tmp.strip()[1:]
 199                             else :
 200                                 MaLigne=MaLigne_tmp[0:]
 201                         else :
 202                             MaLigne=MaLigne_tmp[0:]
 203                         boolChange=1
 204                     jdc.getLines()[indexLigneGlob]=MaLigne
 205                 indexLigneGlob=indexLigneGlob+1
 206     if boolChange : jdc.reset(jdc.getSource())
 207
 208 #----------------------------------------------
 209 def appelleMacroSelonValeurConcept(jdc,macro,genea):
 210 #----------------------------------------------
 211     if macro  not in jdcSet : return
 212     boolChange=0
 213     fact=genea[0]
 214     motcle=genea[1]
 215     chaine="CO"
 216     for c in jdc.root.childNodes:
 217         if c.name != macro  : continue
 218         for mcF in c.childNodes:
 219             if mcF.name != fact : continue
 220             l=mcF.childNodes[:]
 221             l.reverse()
 222             for ll in l:
 223                 trouveValeur=0
 224                 for mc in ll.childNodes:
 225                     if mc.name != motcle:continue
 226                     TexteMC=mc.getText(jdc)
 227                     liste_ligne_MC=TexteMC.splitlines()
 228                     indexLigneGlob=mc.lineno-2
 229                     trouveTexteMC=0
 230                     trouveegal=0
 231                     trouvechaine=0
 232                     trouveparent=0
 233                     trouvequote=0
 234                     while indexLigneGlob < mc.endline  :
 235                         indexLigneGlob=indexLigneGlob+1
 236                         MaLigneTexte=jdc.getLines()[indexLigneGlob]
 237
 238                         # on commence par chercher TABLE par exemple
 239                         # si on ne trouve pas on passe a la ligne suivante
 240                         if ( trouveTexteMC == 0 ) :
 241                             indice=MaLigneTexte.find(motcle)
 242                             if indice < 0 : continue
 243                             trouveTexteMC=1
 244                         else :
 245                             indice=0
 246
 247                         # on cherche =
 248                         aChercher=MaLigneTexte[indice:]
 249                         if (trouveegal == 0 ):
 250                             indice=aChercher.find("=")
 251                             if indice < 0 : continue
 252                             trouveegal = 1
 253                         else :
 254                             indice = 0
 255
 256                         # on cherche CO
 257                         aChercher2=aChercher[indice:]
 258                         if (trouvechaine == 0 ):
 259                             indice=aChercher2.find(chaine)
 260                             if indice < 0 : continue
 261                             trouvechaine = 1
 262                         else :
 263                             indice = 0
 264
 265                         #on cherche (
 266                         aChercher3=aChercher2[indice:]
 267                         if (trouveparent == 0 ):
 268                             indice=aChercher3.find('(')
 269                             if indice < 0 : continue
 270                             trouveparent = 1
 271                         else :
 272                             indice = 0
 273
 274                         #on cherche la '
 275                         aChercher4=aChercher3[indice:]
 276                         if (trouvequote == 0 ):
 277                             indice=aChercher4.find("'")
 278                             indice2=aChercher4.find('"')
 279                             if (indice < 0) and (indice2 < 0): continue
 280                             if (indice < 0) : indice=indice2
 281                             trouvequote = 1
 282                         else :
 283                             indice = 0
 284
 285                         trouveValeur=1
 286                         aChercher5=aChercher4[indice+1:]
 287                         indice=aChercher5.find("'")
 288                         if indice < 0 :  indice=aChercher5.find('"')
 289                         valeur=aChercher5[:indice]
 290                         break
 291
 292                 if trouveValeur==0 :
 293                     logging.error("Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable")
 294                     return
 295
 296                 if boolChange :
 297                     jdc.reset(jdc.getSource())
 298                     logging.error("Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles")
 299                     return
 300
 301                 boolChange=1
 302                 ligneaTraiter=jdc.getLines()[c.lineno-1]
 303                 debut=ligneaTraiter[0:c.colno]
 304                 suite=valeur+"="
 305                 fin=ligneaTraiter[c.colno:]
 306                 ligne=debut+suite+fin
 307                 jdc.getLines()[c.lineno-1]=ligne
 308                 nbBlanc=len(valeur)+1
 309                 if c.lineno < c.endline:
 310                     decaleLignesdeNBlancs(jdc,c.lineno,c.endline-1,nbBlanc)
 311     if boolChange : jdc.reset(jdc.getSource())
 312
 313 #----------------------------------------------
 314 def changeTouteValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
 315 #----------------------------------------------
 316     if macro  not in jdcSet : return
 317     boolChange=0