PN : modif pour integrer les mot-clefs qui dépendent d'autres

[tools/eficas.git] / generator / Formatage.py

diff --git a/generator/Formatage.py b/generator/Formatage.py
index aaa531a5d0cb58638bd50111ede8c40190dd7077..07737d89081327a1f834e4e9c9b78b290eaa010b 100644 (file)
--- a/generator/Formatage.py
+++ b/generator/Formatage.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-

 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG


@@ -29,6 +30,22 @@ class Formatage :
      Cette classe contient toutes les méthodes nécessaires au formatage
      de la chaine de caracteres issue d'un generator en un fichier
      'lisible' ie avec indentations
      Cette classe contient toutes les méthodes nécessaires au formatage
      de la chaine de caracteres issue d'un generator en un fichier
      'lisible' ie avec indentations

+
+     L'objet attend en parametre du constructeur (argument l_jdc) une representation
+     du jeu de commandes sous la forme d'une liste.
+
+     Chaque element de la liste est la representation d'une etape.
+
+     La representation d'une etape est une liste dont le premier element est une chaine de
+     caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple).
+     Les elements suivants sont les representations des mots cles simples et facteurs.
+     Elle se termine avec un element de fin : ");"
+
+     La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple).
+
+     La representation d'un mot cle facteur est semblable à celle de l'étape : premier element
+     caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples.
+     Elle se termine avec un element de fin : ")" ou "),".

   """
   def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72):
     # l_jdc représente le jeu de commandes brut sous forme de liste
   """
   def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72):
     # l_jdc représente le jeu de commandes brut sous forme de liste


@@ -49,6 +66,7 @@ class Formatage :
       self.count = self.count+1
       self.texte_etape = ''
       if type(etape)==types.ListType:
       self.count = self.count+1
       self.texte_etape = ''
       if type(etape)==types.ListType:

+        # L'etape est sous la forme d'une liste dont le premier element est une chaine

         self.indent=[]
         self.indent.append(len(etape[0]))
         self.indent_courant = self.indent[0]
         self.indent=[]
         self.indent.append(len(etape[0]))
         self.indent_courant = self.indent[0]


@@ -56,17 +74,31 @@ class Formatage :
         if len(etape)>1 :
           self.formate_etape(etape[1:])
       else :
         if len(etape)>1 :
           self.formate_etape(etape[1:])
       else :

+        # L'etape est deja sous forme de chaine de caracteres

         self.indent=[]
         self.texte_etape = etape
       self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
     return self.jdc_fini
         self.indent=[]
         self.texte_etape = etape
       self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
     return self.jdc_fini

+  
+  

 
   def formate_etape(self,liste):
 
   def formate_etape(self,liste):

+    """
+        Enrichissement de la chaine de caracteres representant l'etape (attribut
+       texte_etape de l'objet Formatage).
+        Les elements a ajouter sont dans l'argument liste de la methode.
+       L'objet "liste" à traiter a été produit par le module generator. En particulier
+       les parenthèses et les virgules ont été produites par ce module
+    """
+    l_patterns_fin_etape = ( ');' , ');\n' )
+    l_patterns_fin_mcf   = ( ')'  , '),'   )
+

     ind = 0
     for element in liste :
       if type(element) == types.ListType:
     ind = 0
     for element in liste :
       if type(element) == types.ListType:

+

         # il s'agit d'un mot-clé facteur
         # il s'agit d'un mot-clé facteur

-        # on écrit son nom
+        # on écrit son nom (element[0])

         longueur = self.longueur(self.texte_etape)
         try:
           increment = len(('\n'+self.indent_courant*' ')*ind + element[0])
         longueur = self.longueur(self.texte_etape)
         try:
           increment = len(('\n'+self.indent_courant*' ')*ind + element[0])


@@ -81,39 +113,74 @@ class Formatage :
         # on écrit ses fils
         self.formate_etape(element[1:])
       elif type(element) == types.StringType:
         # on écrit ses fils
         self.formate_etape(element[1:])
       elif type(element) == types.StringType:

-        # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),'
-        if element == ')' or element == '),':
-          self.texte_etape = self.texte_etape + string.strip(element)
-          length = len(self.indent)
-          if length > 1:
-            last = self.indent[length-1]
-            self.indent.remove(last)
-            self.indent_courant=self.indent[length-2]
-          else :
-            self.indent_courant=self.indent[0]
-        elif element == ');':
-          length = len(self.indent)
-          if length > 1:
-            last = self.indent[length-1]
-            self.indent.remove(last)
-            self.indent_courant=self.indent[length-2]
-          else :
-            self.indent_courant=self.indent[0]
-          self.texte_etape = self.texte_etape + string.strip(element)
+
+        # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
+
+        if element in l_patterns_fin_mcf :
+              self.traite_mcfact(s_mcfact=element,ind=ind)
+        elif element in l_patterns_fin_etape :
+              self.traite_etape(s_etape=element,ind=ind)

         else :
         else :

-          longueur = self.longueur(self.texte_etape)
-          increment = len(('\n'+self.indent_courant*' ')*ind + string.strip(element))
-          #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(element)
-          if ((1-ind)*longueur+increment)  <= self.l_max :
-            self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + string.strip(element)
-          else :
-            # il faut couper ...
-            nom,valeur = string.split(element,self.sep,1)
-            chaine = self.creer_chaine(nom,valeur,'\n'+self.indent_courant*' ',ind)+','
-            #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(element)
-            self.texte_etape = self.texte_etape + chaine
+              self.traite_mcsimp(s_mcsimp=element,ind=ind)
+

       ind = 1
       ind = 1

-      
+
+  def traite_etape(self,s_etape,ind) :
+      """
+          Traite une partie du jdc formaté : s_etape, une chaîne de caractères
+          contenant une étape
+          L'attribut self.texte_etape est modifié (complété) par le traitement
+          L'attribut self.indent est modifié par le traitement
+          L'attribut self.indent_courant est modifié par le traitement
+      """
+      length = len(self.indent)
+      if length > 1:
+          last = self.indent[length-1]
+          self.indent.remove(last)
+          self.indent_courant=self.indent[length-2]
+      else :
+          self.indent_courant=self.indent[0]
+      self.texte_etape = self.texte_etape + string.strip(s_etape)
+
+  def traite_mcfact(self,s_mcfact,ind) :
+      """
+          Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères
+          contenant un mot-clef facteur.
+          L'attribut self.texte_etape est modifié (complété) par le traitement
+          L'attribut self.indent est modifié par le traitement
+          L'attribut self.indent_courant est modifié par le traitement
+      """
+      self.texte_etape = self.texte_etape + string.strip(s_mcfact)
+      length = len(self.indent)
+      if length > 1:
+           last = self.indent[length-1]
+           self.indent.remove(last)
+           self.indent_courant=self.indent[length-2]
+      else :
+           self.indent_courant=self.indent[0]
+      return
+
+
+  def traite_mcsimp(self,s_mcsimp,ind) :
+      """
+          Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères
+          contenant un mot-clef simple.
+          L'attribut self.texte_etape est modifié (complété) par le traitement
+      """
+      longueur = self.longueur(self.texte_etape)
+      increment = len(('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp))
+      #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
+      if ((1-ind)*longueur+increment)  <= self.l_max :
+          self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
+      else :
+          # il faut couper ...
+          nom,valeur = string.split(s_mcsimp,self.sep,1)
+          chaine = self.creer_chaine(nom,valeur,'\n'+self.indent_courant*' ',ind)
+          #self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
+          self.texte_etape = self.texte_etape + chaine
+      return
+
+

   def longueur(self,texte):
     """ 
        texte est une string qui peut contenir des retours chariots
   def longueur(self,texte):
     """ 
        texte est une string qui peut contenir des retours chariots


@@ -123,18 +190,25 @@ class Formatage :
     return len(liste[-1])
 
   def creer_chaine(self,nom,valeur,increment,ind):
     return len(liste[-1])
 
   def creer_chaine(self,nom,valeur,increment,ind):

+    """
+        La methode creer_chaine reconstitue un objet Eficas à partir de
+             - son nom,
+             - sa valeur.
+    """

     s=''
     if len(increment + nom + self.sep) <= self.l_max:
       texte = increment*ind
       label = nom + self.sep
       s=texte + label
       longueur = len(increment + label)
     s=''
     if len(increment + nom + self.sep) <= self.l_max:
       texte = increment*ind
       label = nom + self.sep
       s=texte + label
       longueur = len(increment + label)

-      if len(string.split(valeur,'(')) == 1:
+
+      if '(' not in valeur:

         # il s'agit d'une vraie chaîne de caractères
         val = len(valeur)
         texte = (self.l_max-2-val)*' '+valeur
         s=s+'\n'+texte
         # il s'agit d'une vraie chaîne de caractères
         val = len(valeur)
         texte = (self.l_max-2-val)*' '+valeur
         s=s+'\n'+texte

-      else :
+
+      elif ',' in valeur:

         # il s'agit d'une liste
         liste = string.split(valeur,',')
         i=0
         # il s'agit d'une liste
         liste = string.split(valeur,',')
         i=0


@@ -150,9 +224,17 @@ class Formatage :
           else :
             i=1
             if ajout[-1] != ')':
           else :
             i=1
             if ajout[-1] != ')':

-              texte = texte  + increment + (len(label)+2)*' ' + ajout +','
+              texte = texte  + increment + (len(label)+2)*' ' + ajout  + ','

             else :
               texte = texte  + increment + (len(label)+2)*' ' + ajout
             else :
               texte = texte  + increment + (len(label)+2)*' ' + ajout

-      s=s+texte
-    return s

 
 

+        s=s+texte
+        s =  s + ','
+
+      else :
+        # On a une ( mais pas de , . On passe la chaine sans modification
+        val = len(valeur)
+        texte = (self.l_max-2-val)*' '+valeur
+        s=s+'\n'+texte
+
+    return s