Editeur/analyse_catalogue.py

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