Editeur/analyse_catalogue.py

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