Editeur/analyse_catalogue.py

   1 #@ MODIF analyse_catalogue Accas  DATE 02/07/2001   AUTEUR D6BHHJP J.P.LEFEBVRE
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
   5 #              SEE THE FILE "LICENSE.TERMS" FOR INFORMATION ON USAGE AND
   6 #              REDISTRIBUTION OF THIS FILE.
   7 # ======================================================================
   8 from string import split,strip,lowercase,uppercase
   9 import re,string,cPickle,os
  10
  11 from Noyau.N_CR import CR
  12
  13 #
  14 __Id__="$Id: analyse_catalogue.py,v 1.13.18.3 2001/06/19 12:24:48 iliade Exp $"
  15 __version__="$Name: FR_28_06_10_00 $"
  16 #
  17 l_noms_commandes = ['OPER','PROC','MACRO','FORM']
  18 l_noms_composes=['FACT','BLOC','NUPL','FORM']
  19 l_noms_simples=['SIMP',]
  20 l_noms=l_noms_composes+l_noms_simples
  21
  22 def elimine_commentaires(text):
  23         """ Elimine les lignes de commentaires dans text
  24         Attention : supprime sauvagement tous les caractères entre # et le retour chariot ..."""
  25         comments = re.compile(r'#[^\n]*')
  26         return comments.sub('',text)
  27
  28 def cherche_nom(text):
  29         Whitespace = r'[ \f\t]*'
  30         Name = r'[a-zA-Z_]\w*'
  31         myexpr = '('+Name+')'+Whitespace+'='+Whitespace+'$'
  32         a=re.search(myexpr,text)
  33         return a.group(1)
  34
  35 def cherche_args(text):
  36         text = strip(text)
  37         longueur = len(text)
  38         if text[0] != '(':
  39                 return 'erreur !'
  40         else :
  41                 nbpar = 1
  42                 for i in range(1,longueur) :
  43                         if text[i] =='(':
  44                                 nbpar = nbpar + 1
  45                         elif text[i] == ')':
  46                                 nbpar = nbpar - 1
  47                         else :
  48                                 continue
  49                         if nbpar == 0:
  50                                 break
  51                 if nbpar != 0 :
  52                         return 'erreur !','erreur !'
  53                 else :
  54                         try :
  55                                 return text[1:i],text[i+1:] # on enlève les première et dernière parenthèses
  56                         except :
  57                                 return text[1:i],''
  58
  59 class ENTITE :
  60         def cherche_enfants(self):
  61                 try :
  62                         self.text = strip(self.text)
  63                         liste = re.split('=',self.text,1)
  64                         if len(liste)>1 :
  65                                 arg1=liste[0]
  66                                 reste=liste[1]
  67                                 reste = strip(reste)
  68                                 if reste[0:4] in l_noms :
  69                                         nom_mc = cherche_nom(arg1+'=')
  70                                         arg_mc, self.text = cherche_args(reste[4:])
  71                                         self.cree_mc(nom_mc,arg_mc,reste[0:4])
  72                                 else :
  73                                         self.text = reste
  74                                 self.cherche_enfants()
  75                         else :
  76                                 # pas de = rencontré
  77                                 return
  78                 except Exception,e:
  79                         self.cr.fatal("Erreur rencontrée dans recherche_enfants :%s" %str(e))
  80
  81         def cree_mc(self,nom_mc,arg_mc,test):
  82                 if test in l_noms_composes :
  83                         mc = FACT_CATA(nom_mc,arg_mc,self)
  84                         self.children.append(mc)
  85                 elif test in l_noms_simples :
  86                         mc = SIMP_CATA(nom_mc,self)
  87                         self.children.append(mc)
  88                 else :
  89                         print 'erreur dans la création du mot-clé :',nom_mc
  90
  91         def construit_liste_dico(self):
  92                 l=[]
  93                 d={}
  94                 if len(self.children)==0:
  95                         self.liste = l
  96                         self.dico = d
  97                         return
  98                 try :
  99                         for child in self.children:
 100                                 l.append(child.nom)
 101                                 d[child.nom]=child
 102                         self.liste = l
 103                         self.dico = d
 104                 except:
 105                         print 'erreur :',self.nom,self.__class__
 106
 107 class COMMANDE_CATA(ENTITE) :
 108         def __init__(self,nom,args,parent):
 109                 self.nom = nom
 110                 self.args = args
 111                 self.children = []
 112                 self.text = args
 113                 self.cr = CR()
 114                 self.cr.debut = "Début commande %s" %self.nom
 115                 self.cr.fin = "Fin commande %s" %self.nom
 116                 self.cherche_enfants()
 117                 self.construit_liste_dico()
 118                 parent.cr.add(self.cr)
 119
 120         def affiche(self):
 121                 texte_cmd = '\n'
 122                 texte_cmd = texte_cmd + 'Commande :' + self.nom + '\n'
 123                 for child in self.children :
 124                         texte_cmd = texte_cmd + child.affiche(1)
 125                 return texte_cmd
 126
 127 class SIMP_CATA :
 128         def __init__(self,nom,parent):
 129                 self.nom = nom
 130                 self.cr = CR()
 131                 self.cr.debut = "Début mot-clé simple %s" %self.nom
 132                 self.cr.fin = "Fin mot-clé simple %s" %self.nom
 133                 parent.cr.add(self.cr)
 134
 135         def affiche(self,ind):
 136                 sep = ' '*5
 137                 return sep*ind+self.nom+'\n'
 138
 139 class FACT_CATA(ENTITE) :
 140         def __init__(self,nom,args,parent):
 141                 self.nom=nom
 142                 self.args=args
 143                 self.children = []
 144                 self.text=args
 145                 self.cr = CR()
 146                 self.cr.debut = "Début mot-clé facteur ou bloc %s" %self.nom
 147                 self.cr.fin = "Fin mot-clé facteur ou bloc %s" %self.nom
 148                 self.cherche_enfants()
 149                 self.construit_liste_dico()
 150                 parent.cr.add(self.cr)
 151
 152         def affiche(self,ind):
 153                 sep = ' '*5
 154                 text = ''
 155                 text = text + sep*ind+self.nom+'\n'
 156                 for child in self.children :
 157                         text = text + child.affiche(ind+1)
 158                 return text
 159
 160 class CATALOGUE_CATA:
 161         def __init__(self,parent,fichier):
 162                 self.parent = parent
 163                 self.fichier=fichier
 164                 self.cr = CR()
 165                 self.cr.debut = "Début compte-rendu catalogue %s" %self.fichier
 166                 self.cr.fin = "Fin compte-rendu catalogue %s" %self.fichier
 167                 self.ouvrir_fichier()
 168                 self.liste_commandes=[]
 169                 self.liste_textes_commandes=[]
 170
 171         def ouvrir_fichier(self):
 172                 try :
 173                         f=open(self.fichier,'r')
 174                         self.texte_complet=f.read()
 175                         f.close()
 176                 except e:
 177                         print "Impossible d'ouvrir le fichier :",self.fichier
 178                         print e
 179                         self.cr.fatal("Impossible d'ouvrir le fichier :%s" %self.fichier)
 180
 181         def constr_list_txt_cmd(self,text):
 182                 text = elimine_commentaires(text)
 183                 pattern = '\) *;'
 184                 liste=re.split(pattern,text)
 185                 for i in range(0,len(liste)-1):
 186                         self.liste_textes_commandes.append(liste[i]+')')
 187
 188         def analyse_commande_old(self,text):
 189                 #if strip(text) == '' or strip(text) ==')': return
 190                 liste = re.split('OPER *\(',text,1)
 191                 if len(liste) < 2 :
 192                         liste = re.split('PROC *\(',text,1)
 193                 if len(liste) < 2 :
 194                         liste = re.split('MACRO *\(',text,1)
 195                 if len(liste) < 2 :
 196                         print "le texte à analyser n'est pas celui d'une commande ou d'un opérateur",text
 197                         self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
 198                         return
 199                 debut = liste[0]
 200                 fin = liste[1]
 201                 nom_cmd = cherche_nom(debut)
 202                 if nom_cmd == 'erreur !':
 203                         print "Erreur dans la recherche du nom de la commande :",debut
 204                 args_cmd,toto = cherche_args('('+fin)
 205                 if args_cmd == 'erreur !':
 206                         print "Erreur dans la recherche des args de la commande :",debut
 207                 cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
 208                 self.liste_commandes.append(cmd)
 209
 210         def analyse_commande(self,text):
 211                 #if strip(text) == '' or strip(text) ==')': return
 212                 for nom_cmd in l_noms_commandes:
 213                         liste = re.split(nom_cmd+' *\(',text,1)
 214                         if len(liste) == 2 : break
 215                 if len(liste) < 2 :
 216                         print "le texte à analyser n'est pas celui d'une commande connue :"+str(l_noms_commandes),text
 217                         self.cr.fatal("le texte à analyser n'est pas celui d'une commande ou d'un opérateur :%s" %text)
 218                         return
 219                 debut = liste[0]
 220                 fin = liste[1]
 221                 nom_cmd = cherche_nom(debut)
 222                 if nom_cmd == 'erreur !':
 223                         print "Erreur dans la recherche du nom de la commande :",debut
 224                 args_cmd,toto = cherche_args('('+fin)
 225                 if args_cmd == 'erreur !':
 226                         print "Erreur dans la recherche des args de la commande :",debut
 227                         print fin
 228                 cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
 229                 self.liste_commandes.append(cmd)
 230
 231         def analyse_texte(self,texte):
 232                 self.constr_list_txt_cmd(texte)
 233                 try:
 234                         self.parent.configure_barre(len(self.liste_textes_commandes))
 235                 except:
 236                         pass
 237                 for texte_commande in self.liste_textes_commandes :
 238                         try:
 239                                 self.parent.update_barre()
 240                         except:
 241                                 pass
 242                         self.analyse_commande(texte_commande)
 243                 self.construit_liste_dico()
 244
 245         def ecrit_lcmd(self):
 246                 f=open('U:\\EFICAS\\Accas\\cata.txt','w')
 247                 for cmd in self.liste_commandes :
 248                         f.write(cmd.affiche())
 249                 f.close()
 250
 251         def construit_liste_dico(self):
 252                 l=[]
 253                 d={}
 254                 for cmd in self.liste_commandes:
 255                         l.append(cmd.nom)
 256                         d[cmd.nom]=cmd
 257                 self.liste = l
 258                 self.dico = d
 259
 260         def report(self):
 261                 """ retourne l'objet rapport du catalogue de commande """
 262                 return self.cr
 263
 264 def analyse_catalogue(parent,nom_cata):
 265         cata = CATALOGUE_CATA(parent,nom_cata)
 266         cata.analyse_texte(cata.texte_complet)
 267         return cata
 268
 269 def analyse_catalogue_commande(parent,nom_cata):
 270         cata = CATALOGUE_CATA(parent,nom_cata)
 271         cata.analyse_commande(cata.texte_complet)
 272         cata.construit_liste_dico()
 273         return cata
 274
 275
 276 def make_cata_pickle(fic_cata):
 277   """
 278   Lance l'analyse de l'ordre des mots-clés dans le catalogue dont le nom
 279   est passé en argument et sauvegarde ces infos dans le fichier pickle relu
 280   par Eficas
 281   """
 282   fic_cata_p = os.path.splitext(fic_cata)[0]+'_pickled.py'
 283   cata_ordonne = analyse_catalogue(None,fic_cata)
 284   f = open(fic_cata_p,'w+')
 285   p = cPickle.Pickler(f)
 286   p.dump(cata_ordonne.dico)
 287   f.close()
 288
 289 if __name__ == "__main__" :
 290         import profile
 291         profile.run("analyse_catalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304