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