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