Traducteur/regles.py

   1 # -*- coding: utf-8 -*-
   2 import logging
   3 import string
   4 #from parseur import FactNode
   5 debug=0
   6
   7
   8 #--------------------
   9 class ensembleRegles:
  10 #--------------------
  11
  12    def __init__(self,liste_regles):
  13       self.liste=[]
  14       for item in liste_regles :
  15          args,clefRegle=item
  16          r=regle(clefRegle,args)
  17          self.liste.append(r)
  18
  19    def verif(self,commande) :
  20        bool=1
  21        for regle in self.liste :
  22          result=regle.verif(commande)
  23          bool=bool*result
  24        return bool
  25
  26 #--------------------------------
  27 class pasDeRegle(ensembleRegles):
  28 #--------------------------------
  29    def __init__(self) :
  30      pass
  31
  32    def verif (self,commande) :
  33      return 1
  34
  35
  36 #------------
  37 class regle :
  38 #------------
  39
  40    def __init__(self,clef_regle,args):
  41       self.fonction=dictionnaire_regle[clef_regle]
  42       self.list_args=args
  43       self.bool=0
  44
  45    def verif(self,commande):
  46        f=self.fonction(self.list_args)
  47        return f.verif(commande)
  48
  49 #---------------------
  50 class existeMCFParmi :
  51 #---------------------
  52    def __init__(self,list_arg):
  53       self.listeMCF=list_arg;
  54
  55    def verif(self,commande):
  56       bool=0
  57       for c in commande.childNodes :
  58          if c.name in self.listeMCF :
  59             bool=1
  60             break
  61       return bool
  62
  63 #----------------------
  64 class existeMCsousMCF :
  65 #----------------------
  66    def __init__(self,list_arg):
  67       self.liste=list_arg;
  68       self.MCF=self.liste[0]
  69       self.MC=self.liste[1]
  70
  71    def verif(self,commande):
  72       bool=0
  73       for mcf in commande.childNodes :
  74          if mcf.name != self.MCF : continue
  75          l=mcf.childNodes[:]
  76          l.reverse()
  77          for ll in l:
  78             for mc in ll.childNodes:
  79                if mc.name != self.MC : continue
  80                bool=1
  81       return bool
  82
  83 #----------------------
  84 class existeMCsousMCFcourant :
  85 #----------------------
  86    def __init__(self,list_arg):
  87       self.liste=list_arg;
  88       self.MC=self.liste[0]
  89
  90    def verif(self,mcf):
  91       bool=0
  92       l=mcf.childNodes[:]
  93       l.reverse()
  94       for mc in l:
  95          if mc.name != self.MC : continue
  96          bool=1
  97       return bool
  98
  99 #-----------------------------------------
 100 class nexistepasMCsousMCF(existeMCsousMCF):
 101 #-----------------------------------------
 102    def __init__(self,list_arg):
 103        existeMCsousMCF.__init__(self,list_arg)
 104
 105
 106    def verif(self,commande):
 107        bool=existeMCsousMCF.verif(self,commande)
 108        if bool : return 0
 109        return 1
 110
 111 #-----------------------------------------
 112 class nexistepasMCsousMCFcourant(existeMCsousMCFcourant):
 113 #-----------------------------------------
 114    def __init__(self,list_arg):
 115        existeMCsousMCFcourant.__init__(self,list_arg)
 116
 117
 118    def verif(self,commande):
 119        bool=existeMCsousMCFcourant.verif(self,commande)
 120        if bool : return 0
 121        return 1
 122
 123 #-------------
 124 class existe :
 125 #--------------
 126    def __init__(self,list_arg):
 127       self.genea=list_arg
 128
 129    def cherche_mot(self,niveau,commande):
 130       if commande == None            : return 0
 131       if niveau   == len(self.genea) : return 1
 132       texte=self.genea[niveau]
 133       for c in commande.childNodes :
 134           if c.name == texte :
 135              niveau = niveau+1
 136              return self.cherche_mot(niveau,c)
 137       return None
 138
 139    def verif(self,commande):
 140       bool=self.cherche_mot(0,commande)
 141       if bool == None : bool = 0
 142       return bool
 143
 144 #-------------
 145 class nexistepas :
 146 #--------------
 147    def __init__(self,list_arg):
 148       self.genea=list_arg
 149
 150    def cherche_mot(self,niveau,commande):
 151       if commande == None            : return 0
 152       if niveau   == len(self.genea) : return 1
 153       texte=self.genea[niveau]
 154       for c in commande.childNodes :
 155           if c.name == texte :
 156              niveau = niveau+1
 157              return self.cherche_mot(niveau,c)
 158       return None
 159
 160    def verif(self,commande):
 161       bool=self.cherche_mot(0,commande)
 162       if bool : return 0
 163       return 1
 164
 165 #-------------------------------
 166 class MCsousMCFaPourValeur :
 167 #------------------------------
 168    def __init__(self,list_arg):
 169       assert (len(list_arg)==4)
 170       self.genea=list_arg[0:-2]
 171       self.MCF=list_arg[0]
 172       self.MC=list_arg[1]
 173       self.Val=list_arg[2]
 174       self.Jdc=list_arg[3]
 175
 176    def verif(self,commande):
 177       bool=0
 178       for mcf in commande.childNodes :
 179          if mcf.name != self.MCF : continue
 180          l=mcf.childNodes[:]
 181          l.reverse()
 182          for ll in l:
 183             for mc in ll.childNodes:
 184                if mc.name != self.MC : continue
 185                TexteMC=mc.getText(self.Jdc)
 186                if (TexteMC.find(self.Val) < 0 ): continue
 187                bool=1
 188       return bool
 189
 190 #-------------------------------
 191 class MCsousMCFcourantaPourValeur :
 192 #------------------------------
 193    def __init__(self,list_arg):
 194       assert (len(list_arg)==3)
 195       self.genea=list_arg[0:-1]
 196       self.MC=list_arg[0]
 197       self.Val=list_arg[1]
 198       self.Jdc=list_arg[2]
 199
 200    def verif(self,mcf):
 201       bool=0
 202       l=mcf.childNodes[:]
 203       l.reverse()
 204       for mc in l:
 205         if mc.name != self.MC : continue
 206         TexteMC=mc.getText(self.Jdc)
 207         if (TexteMC.find(self.Val) < 0 ): continue
 208         bool=1
 209       return bool
 210
 211
 212 #-----------------------------
 213 class MCsousMCFaPourValeurDansListe :
 214 #----------------------------
 215    def __init__(self,list_arg):
 216       assert (len(list_arg)==4)
 217       self.genea=list_arg[0:-2]
 218       self.MCF=list_arg[0]
 219       self.MC=list_arg[1]
 220       self.LVal=list_arg[2]
 221       self.Jdc=list_arg[3]
 222
 223    def verif(self,commande):
 224       bool=0
 225       for mcf in commande.childNodes :
 226          if mcf.name != self.MCF : continue
 227          l=mcf.childNodes[:]
 228          l.reverse()
 229          for ll in l:
 230             for mc in ll.childNodes:
 231                if mc.name != self.MC : continue
 232                TexteMC=mc.getText(self.Jdc)
 233                for Val in self.LVal:
 234                    if (TexteMC.find(Val) < 0 ): continue
 235                    bool=1
 236       return bool
 237
 238 #-----------------------------
 239 class MCsousMCFcourantaPourValeurDansListe :
 240 #----------------------------
 241    def __init__(self,list_arg):
 242       assert (len(list_arg)==3)
 243       self.genea=list_arg[0:-1]
 244       self.MC=list_arg[0]
 245       self.LVal=list_arg[1]
 246       self.Jdc=list_arg[2]
 247
 248    def verif(self,mcf):
 249       bool=0
 250       l=mcf.childNodes[:]
 251       l.reverse()
 252       for mc in l:
 253         if mc.name != self.MC : continue
 254         TexteMC=mc.getText(self.Jdc)
 255         for Val in self.LVal:
 256            if (TexteMC.find(Val) < 0 ): continue
 257            bool=1
 258       return bool
 259
 260 #-------------------------------
 261 class MCaPourValeur :
 262 #------------------------------
 263    def __init__(self,list_arg):
 264       assert (len(list_arg)==3)
 265       self.MC=list_arg[0]
 266       self.Val=list_arg[1]
 267       self.Jdc=list_arg[2]
 268
 269    def verif(self,commande):
 270       bool=0
 271       for mc in commande.childNodes :
 272          if mc.name != self.MC : continue
 273          TexteMC=mc.getText(self.Jdc)
 274          if (TexteMC.find(self.Val) < 0 ): continue
 275          bool=1
 276       return bool
 277
 278 dictionnaire_regle={"existe":existe,"nexistepas":nexistepas,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCsousMCFaPourValeurDansListe":MCsousMCFaPourValeurDansListe,"MCaPourValeur":MCaPourValeur,"existeMCsousMCFcourant":existeMCsousMCFcourant,"nexistepasMCsousMCFcourant":nexistepasMCsousMCFcourant,"MCsousMCFcourantaPourValeur":MCsousMCFcourantaPourValeur,"MCsousMCFcourantaPourValeurDansListe":MCsousMCFcourantaPourValeurDansListe}
 279 SansRegle=pasDeRegle()