generator/generator_aplat.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 le plugin generateur de fichier au format
  22     aplat pour EFICAS.
  23
  24 """
  25 import traceback
  26 import types,string,re
  27
  28 from Noyau import N_CR
  29 from Noyau.N_utils import repr_float
  30 from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
  31 from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
  32 from Accas import GEOM,ASSD,MCNUPLET
  33 from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
  34
  35 def entryPoint():
  36    """
  37        Retourne les informations nécessaires pour le chargeur de plugins
  38
  39        Ces informations sont retournées dans un dictionnaire
  40    """
  41    return {
  42         # Le nom du plugin
  43           'name' : 'aplat',
  44         # La factory pour créer une instance du plugin
  45           'factory' : AplatGenerator,
  46           }
  47
  48
  49 class AplatGenerator:
  50    """
  51        Ce generateur parcourt un objet de type JDC et produit
  52        un fichier au format aplat
  53
  54        L'acquisition et le parcours sont réalisés par la méthode
  55        generator.gener(objet_jdc,format)
  56
  57        L'écriture du fichier au format ini par appel de la méthode
  58        generator.writefile(nom_fichier)
  59
  60        Ses caractéristiques principales sont exposées dans des attributs
  61        de classe :
  62
  63        - extensions : qui donne une liste d'extensions de fichier préconisées
  64
  65    """
  66    # Les extensions de fichier préconisées
  67    extensions=('.*',)
  68
  69    def __init__(self,cr=None):
  70       # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
  71       if cr :
  72          self.cr=cr
  73       else:
  74          self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
  75                          fin='fin CR format aplat pour eficas')
  76       self.init=''
  77       # Le séparateur utiisé
  78       self.sep='//'
  79       # Le texte au format aplat est stocké dans l'attribut text
  80       self.text=''
  81
  82    def writefile(self,filename):
  83       fp=open(filename,'w')
  84       fp.write(self.text)
  85       fp.close()
  86
  87    def gener(self,obj,format='brut'):
  88       """
  89           Retourne une représentation du JDC obj sous une
  90           forme qui est paramétrée par format.
  91           Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu
  92                        de generator
  93       """
  94       liste= self.generator(obj)
  95       if format == 'brut':
  96          self.text=liste
  97       elif format == 'standard':
  98          self.text=liste
  99       elif format == 'beautifie':
 100          self.text=liste
 101       else:
 102          raise "Format pas implémenté : "+format
 103       return self.text
 104
 105    def generator(self,obj):
 106       """
 107          Cette methode joue un role d'aiguillage en fonction du type de obj
 108          On pourrait utiliser les méthodes accept et visitxxx à la
 109          place (dépend des gouts !!!)
 110       """
 111       # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
 112       if isinstance(obj,PROC_ETAPE):
 113          return self.generPROC_ETAPE(obj)
 114       elif isinstance(obj,MACRO_ETAPE):
 115          return self.generMACRO_ETAPE(obj)
 116       elif isinstance(obj,FORM_ETAPE):
 117          return self.generFORM_ETAPE(obj)
 118       elif isinstance(obj,ETAPE):
 119          return self.generETAPE(obj)
 120       elif isinstance(obj,MCFACT):
 121          return self.generMCFACT(obj)
 122       elif isinstance(obj,MCList):
 123          return self.generMCList(obj)
 124       elif isinstance(obj,MCBLOC):
 125          return self.generMCBLOC(obj)
 126       elif isinstance(obj,MCSIMP):
 127          return self.generMCSIMP(obj)
 128       elif isinstance(obj,ASSD):
 129          return self.generASSD(obj)
 130       elif isinstance(obj,ETAPE_NIVEAU):
 131          return self.generETAPE_NIVEAU(obj)
 132       elif isinstance(obj,COMMENTAIRE):
 133          return self.generCOMMENTAIRE(obj)
 134       # Attention doit etre placé avant PARAMETRE (raison : héritage)
 135       elif isinstance(obj,PARAMETRE_EVAL):
 136          return self.generPARAMETRE_EVAL(obj)
 137       elif isinstance(obj,PARAMETRE):
 138          return self.generPARAMETRE(obj)
 139       elif isinstance(obj,EVAL):
 140          return self.generEVAL(obj)
 141       elif isinstance(obj,COMMANDE_COMM):
 142          return self.generCOMMANDE_COMM(obj)
 143       elif isinstance(obj,JDC):
 144          return self.generJDC(obj)
 145       elif isinstance(obj,MCNUPLET):
 146          return self.generMCNUPLET(obj)
 147       else:
 148          raise "Type d'objet non prévu",obj
 149
 150    def generJDC(self,obj):
 151       """
 152          Cette méthode convertit un objet JDC en une chaine de
 153          caractères à la syntaxe aplat
 154       """
 155       text=''
 156       if obj.definition.l_niveaux == ():
 157          # Il n'y a pas de niveaux
 158          for etape in obj.etapes:
 159             text=text+self.generator(etape)+'\n'
 160       else:
 161          # Il y a des niveaux
 162          for etape_niveau in obj.etapes_niveaux:
 163             text=text+self.generator(etape_niveau)+'\n'
 164       return text
 165
 166    def generCOMMANDE_COMM(self,obj):
 167       """
 168          Cette méthode convertit un COMMANDE_COMM
 169          en une chaine de caractères à la syntaxe aplat
 170       """
 171       l_lignes = string.split(obj.valeur,'\n')
 172       txt=''
 173       for ligne in l_lignes:
 174           txt = txt + '##'+ligne+'\n'
 175       return txt
 176
 177    def generEVAL(self,obj):
 178       """
 179          Cette méthode convertit un EVAL
 180          en une chaine de caractères à la syntaxe aplat
 181       """
 182       return 'EVAL("""'+ obj.valeur +'""")'
 183
 184    def generCOMMENTAIRE(self,obj):
 185       """
 186          Cette méthode convertit un COMMENTAIRE
 187          en une chaine de caractères à la syntaxe aplat
 188       """
 189       l_lignes = string.split(obj.valeur,'\n')
 190       txt=''
 191       for ligne in l_lignes:
 192         txt = txt + '#'+ligne+'\n'
 193       return txt
 194
 195    def generPARAMETRE_EVAL(self,obj):
 196       """
 197          Cette méthode convertit un PARAMETRE_EVAL
 198          en une chaine de caractères à la syntaxe aplat
 199       """
 200       if obj.valeur == None:
 201          return obj.nom + ' = None ;\n'
 202       else:
 203          return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
 204
 205    def generPARAMETRE(self,obj):
 206       """
 207          Cette méthode convertit un PARAMETRE
 208          en une chaine de caractères à la syntaxe aplat
 209       """
 210       if type(obj.valeur) == types.StringType:
 211         return obj.nom + " = '" + obj.valeur + "';\n"
 212       else:
 213         return obj.nom + ' = ' + str(obj.valeur) + ';\n'
 214
 215    def generETAPE_NIVEAU(self,obj):
 216       """
 217          Cette méthode convertit une étape niveau
 218          en une chaine de caractères à la syntaxe aplat
 219       """
 220       text=''
 221       if obj.etapes_niveaux == []:
 222         for etape in obj.etapes:
 223           text=text+self.generator(etape)+'\n'
 224       else:
 225         for etape_niveau in obj.etapes_niveaux:
 226           text=text+self.generator(etape_niveau)+'\n'
 227       return text
 228
 229    def gener_etape(self,obj):
 230       """
 231          Cette méthode est utilisé pour convertir les objets etape
 232          en une chaine de caractères à la syntaxe aplat
 233       """
 234       text=''
 235       for v in obj.mc_liste:
 236          text=text + self.generator(v)
 237       if text=='':
 238          return self.init+'\n'
 239       else:
 240          return text
 241
 242    def generETAPE(self,obj):
 243       """
 244          Cette méthode convertit une étape
 245          en une chaine de caractères à la syntaxe aplat
 246       """
 247       try:
 248         sdname= self.generator(obj.sd)
 249       except:
 250         sdname='sansnom'
 251       self.init = sdname + self.sep + obj.nom
 252       return self.gener_etape(obj)
 253
 254    def generMACRO_ETAPE(self,obj):
 255       """
 256          Cette méthode convertit une macro-étape
 257          en une chaine de caractères à la syntaxe aplat
 258       """
 259       try:
 260         if obj.sd == None:
 261           self.init = obj.nom
 262         else:
 263           sdname= self.generator(obj.sd)
 264           self.init = sdname + self.sep + obj.nom
 265       except:
 266         self.init = 'sansnom' + self.sep + obj.nom
 267
 268       return self.gener_etape(obj)
 269
 270    generPROC_ETAPE = generMACRO_ETAPE
 271
 272    generFORM_ETAPE = generMACRO_ETAPE
 273
 274    def generASSD(self,obj):
 275       """
 276           Convertit un objet dérivé d'ASSD en une chaine de caractères à la
 277           syntaxe aplat
 278       """
 279       return obj.get_name()
 280
 281    def generMCList(self,obj):
 282       """
 283           Convertit un objet MCList en une chaine de caractères à la
 284           syntaxe aplat
 285       """
 286       i=0
 287       text = ''
 288       init = self.init + self.sep + obj.nom
 289       old_init=self.init
 290       for data in obj.data :
 291         i=i+1
 292         self.init = init + self.sep + "occurrence n°"+`i`
 293         text = text + self.generator(data)
 294       self.init=old_init
 295       return text
 296
 297    def generMCSIMP(self,obj) :
 298       """
 299           Convertit un objet MCSIMP en une chaine de caractères à la
 300           syntaxe aplat
 301       """
 302       if type(obj.valeur) in (types.TupleType,types.ListType) :
 303          # On est en présence d'une liste de valeur
 304          rep = '('
 305          for val in obj.valeur:
 306            if type(val) == types.InstanceType :
 307              rep = rep + self.generator(val) +','
 308            else:
 309              rep = rep + `val`+','
 310          rep = rep + ')'
 311       elif type(obj.valeur) == types.InstanceType :
 312          # On est en présence d'une valeur unique de type instance
 313          rep = self.generator(obj.valeur)
 314       else :
 315          # On est en présence d'une valeur unique
 316          rep = `obj.valeur`
 317       return self.init + self.sep + obj.nom + ' :' + rep + '\n'
 318
 319    def generMCCOMPO(self,obj):
 320       """
 321           Convertit un objet MCCOMPO en une chaine de caractères à la
 322           syntaxe aplat
 323       """
 324       text = ''
 325       old_init=self.init
 326       self.init = self.init + self.sep + obj.nom
 327       for mocle in obj.mc_liste :
 328         text = text + self.generator(mocle)
 329       self.init=old_init
 330       return text
 331
 332    generMCFACT=generMCCOMPO
 333
 334    generMCBLOC=generMCCOMPO
 335
 336    generMCNUPLET=generMCCOMPO
 337
 338