generator/Formatage.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 """
  22     Ce module contient la classe Formatage qui permet le formatage d'une
  23     liste de chaines de caractères dans une syntaxe représentative d'un
  24     jeu de commandes en un texte présentable
  25 """
  26 import types,string
  27
  28 class Formatage :
  29   """
  30      Cette classe contient toutes les méthodes nécessaires au formatage
  31      de la chaine de caracteres issue d'un generator en un fichier
  32      'lisible' ie avec indentations
  33
  34      L'objet attend en parametre du constructeur (argument l_jdc) une representation
  35      du jeu de commandes sous la forme d'une liste.
  36
  37      Chaque element de la liste est la representation d'une etape.
  38
  39      La representation d'une etape est une liste dont le premier element est une chaine de
  40      caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple).
  41      Les elements suivants sont les representations des mots cles simples et facteurs.
  42      Elle se termine avec un element de fin : ");"
  43
  44      La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple).
  45
  46      La representation d'un mot cle facteur est semblable à celle de l'étape : premier element
  47      caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples.
  48      Elle se termine avec un element de fin : ")" ou "),".
  49   """
  50   def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72):
  51     # l_jdc représente le jeu de commandes brut sous forme de liste
  52     self.l_jdc = l_jdc
  53     self.jdc_fini =''
  54     self.count = 0
  55     self.sep=sep
  56     self.l_max=l_max
  57     if mode == '.py':
  58        self.sep = '='
  59        self.l_max = 132
  60     elif code == 'ASTER':
  61        self.sep = ':'
  62        self.l_max = 72
  63
  64   def formate_jdc(self):
  65     for etape in self.l_jdc:
  66       self.count = self.count+1
  67       self.texte_etape = ''
  68       if type(etape)==types.ListType:
  69         # L'etape est sous la forme d'une liste dont le premier element est une chaine
  70         self.indent=[]
  71         self.indent.append(len(etape[0]))
  72         self.indent_courant = self.indent[0]
  73         self.texte_etape = '\n' + etape[0]
  74         if len(etape)>1 :
  75           self.formate_etape(etape[1:])
  76       else :
  77         # L'etape est deja sous forme de chaine de caracteres
  78         self.indent=[]
  79         self.texte_etape = etape
  80       self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
  81     return self.jdc_fini
  82
  83
  84
  85   def formate_etape(self,liste):
  86     """
  87         Enrichissement de la chaine de caracteres representant l'etape (attribut
  88         texte_etape de l'objet Formatage).
  89         Les elements a ajouter sont dans l'argument liste de la methode.
  90         L'objet "liste" à traiter a été produit par le module generator. En particulier
  91         les parenthèses et les virgules ont été produites par ce module
  92     """
  93     l_patterns_fin_etape = ( ');' , ');\n' )
  94     l_patterns_fin_mcf   = ( ')'  , '),'   )
  95
  96     ind = 0
  97     for element in liste :
  98       if type(element) == types.ListType:
  99
 100         # il s'agit d'un mot-clé facteur
 101         # on écrit son nom (element[0])
 102         longueur = self.longueur(self.texte_etape)
 103         try:
 104           increment = len(('\n'+self.indent_courant*' ')*ind + element[0])
 105         except:
 106           print 'ERREUR'
 107           print liste
 108           print element
 109         self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + element[0]
 110         length = len(self.indent)
 111         self.indent.insert(length,self.indent[length-1]+len(element[0]))
 112         self.indent_courant = self.indent[length]
 113         # on écrit ses fils
 114         self.formate_etape(element[1:])
 115       elif type(element) == types.StringType:
 116
 117         # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
 118
 119         if element in l_patterns_fin_mcf :
 120               self.traite_mcfact(s_mcfact=element,ind=ind)
 121         elif element in l_patterns_fin_etape :
 122               self.traite_etape(s_etape=element,ind=ind)
 123         else :
 124               self.traite_mcsimp(s_mcsimp=element,ind=ind)
 125
 126       ind = 1
 127
 128   def traite_etape(self,s_etape,ind) :
 129       """
 130           Traite une partie du jdc formaté : s_etape, une chaîne de caractères
 131           contenant une étape
 132           L'attribut self.texte_etape est modifié (complété) par le traitement
 133           L'attribut self.indent est modifié par le traitement
 134           L'attribut self.indent_courant est modifié par le traitement
 135       """
 136       length = len(self.indent)
 137       if length > 1:
 138           last = self.indent[length-1]
 139           self.indent.remove(last)
 140           self.indent_courant=self.indent[length-2]
 141       else :
 142           self.indent_courant=self.indent[0]
 143       self.texte_etape = self.texte_etape + string.strip(s_etape)
 144
 145   def traite_mcfact(self,s_mcfact,ind) :
 146       """
 147           Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères
 148           contenant un mot-clef facteur.
 149           L'attribut self.texte_etape est modifié (complété) par le traitement
 150           L'attribut self.indent est modifié par le traitement
 151           L'attribut self.indent_courant est modifié par le traitement
 152       """
 153       self.texte_etape = self.texte_etape + string.strip(s_mcfact)
 154       length = len(self.indent)
 155       if length > 1:
 156            last = self.indent[length-1]
 157            self.indent.remove(last)
 158            self.indent_courant=self.indent[length-2]
 159       else :
 160            self.indent_courant=self.indent[0]
 161       return
 162
 163
 164   def traite_mcsimp(self,s_mcsimp,ind) :
 165       """
 166           Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères
 167           contenant un mot-clef simple.
 168           L'attribut self.texte_etape est modifié (complété) par le traitement
 169       """
 170       longueur = self.longueur(self.texte_etape)
 171       increment = len(('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp))
 172       #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
 173       if ((1-ind)*longueur+increment)  <= self.l_max :
 174           self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
 175       else :
 176           # il faut couper ...
 177           nom,valeur = string.split(s_mcsimp,self.sep,1)
 178           chaine = self.creer_chaine(nom,valeur,'\n'+self.indent_courant*' ',ind)
 179           #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
 180           self.texte_etape = self.texte_etape + chaine
 181       return
 182
 183
 184   def longueur(self,texte):
 185     """
 186        texte est une string qui peut contenir des retours chariots
 187        Cette méthode retourne la longueur de la dernière ligne de texte
 188     """
 189     liste = string.split(texte,'\n')
 190     return len(liste[-1])
 191
 192   def creer_chaine(self,nom,valeur,increment,ind):
 193     """
 194         La methode creer_chaine reconstitue un objet Eficas à partir de
 195              - son nom,
 196              - sa valeur.
 197     """
 198     s=''
 199     if len(increment + nom + self.sep) <= self.l_max:
 200       texte = increment*ind
 201       label = nom + self.sep
 202       s=texte + label
 203       longueur = len(increment + label)
 204
 205       if '(' not in valeur:
 206         # il s'agit d'une vraie chaîne de caractères
 207         val = len(valeur)
 208         texte = (self.l_max-2-val)*' '+valeur
 209         s=s+'\n'+texte
 210
 211       elif ',' in valeur:
 212         # il s'agit d'une liste
 213         liste = string.split(valeur,',')
 214         i=0
 215         for arg in liste :
 216           ajout = string.strip(arg)
 217           if len(ajout) == 0 : continue
 218           longueur = self.longueur(texte = (texte + label)) + len(ajout +',') + (1-i)*len(increment)
 219           if longueur  <= self.l_max:
 220               if ajout[-1] != ')':
 221                 texte = texte + ajout +','
 222               else :
 223                 texte = texte + ajout
 224           else :
 225             i=1
 226             if ajout[-1] != ')':
 227               texte = texte  + increment + (len(label)+2)*' ' + ajout  + ','
 228             else :
 229               texte = texte  + increment + (len(label)+2)*' ' + ajout
 230
 231         s=s+texte
 232         s =  s + ','
 233
 234       else :
 235         # On a une ( mais pas de , . On passe la chaine sans modification
 236         val = len(valeur)
 237         texte = (self.l_max-2-val)*' '+valeur
 238         s=s+'\n'+texte
 239
 240     return s