generator/generator_aplat.py

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