Ihm/I_JDC.py

   1 """
   2 """
   3 # Modules Python
   4 import types,traceback
   5 import string,linecache
   6
   7 # Modules Eficas
   8 import I_OBJECT
   9 from Noyau.N_ASSD import assd
  10 from Noyau.N_ETAPE import ETAPE
  11 from Noyau.N_CO import CO
  12 from Noyau.N_Exception import AsException
  13 from Extensions import commentaire,parametre,parametre_eval
  14
  15 class JDC(I_OBJECT.OBJECT):
  16    """
  17    """
  18    def __init__(self):
  19       self.editmode=0
  20       self.etapes_niveaux=[]
  21       self.niveau=self
  22       self.params=[]
  23       self.fonctions=[]
  24
  25    def get_cmd(self,nomcmd):
  26       """
  27           Retourne l'objet de type COMMANDE de nom nomcmd
  28       """
  29       for cata in self.cata:
  30          if hasattr(cata,nomcmd):
  31             return getattr(cata,nomcmd)
  32
  33    def get_sd_avant_du_bon_type(self,etape,types_permis):
  34       """
  35           Retourne la liste des concepts avant etape d'un type acceptable
  36       """
  37       d=self.get_contexte_avant(etape)
  38       l=[]
  39       for k,v in d.items():
  40         if type(v) != types.InstanceType : continue
  41         if assd in types_permis or CO in types_permis :
  42           l.append(k)
  43           continue
  44         for type_ok in types_permis:
  45           if type_ok in ('R','I','C','TXM') and v in self.params : l.append(k)
  46           elif type_ok == 'R' and v.__class__.__name__ == 'reel' : l.append(k)
  47           elif type_ok == 'I' and v.__class__.__name__ == 'entier' : l.append(k)
  48           elif type_ok == 'C' and v.__class__.__name__ == 'complexe' : l.append(k)
  49           elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' : l.append(k)
  50           elif type(type_ok) != types.ClassType : continue
  51           elif v.__class__ == type_ok or issubclass(v.__class__,type_ok): l.append(k)
  52       l.sort()
  53       return l
  54
  55    def addentite(self,name,pos):
  56       """
  57           Ajoute une entite :
  58           Si name est le nom d une commande ou un commentaire ajoute
  59           une etape au JDC
  60           Sinon remonte une erreur
  61       """
  62       self.init_modif()
  63       self.editmode=1
  64       if name == "COMMENTAIRE" :
  65         # ajout d'un commentaire
  66         self.set_current_step()
  67         ind = 1
  68         for child in self.etapes :
  69           if isinstance(child,commentaire.COMMENTAIRE):
  70             ind = ind+1
  71         objet = commentaire.COMMENTAIRE('',parent=self)
  72         objet.nom = "_comm_"+`ind`
  73         if pos == None : pos = 0
  74         self.etapes.insert(pos,objet)
  75         self.editmode=0
  76         self.active_etapes()
  77         return objet
  78       elif name == "PARAMETRE":
  79         # ajout d'un parametre
  80         self.set_current_step()
  81         nom_param = '_param_'+str(len(self.params)+1)
  82         objet = parametre.PARAMETRE(nom=nom_param)
  83         if pos == None : pos = 0
  84         self.etapes.insert(pos,objet)
  85         self.editmode=0
  86         self.active_etapes()
  87         return objet
  88       elif name == "PARAMETRE_EVAL":
  89         # ajout d'un parametre EVAL
  90         self.set_current_step()
  91         nom_param = '_param_'+str(len(self.params)+1)
  92         objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
  93         if pos == None : pos = 0
  94         self.etapes.insert(pos,objet)
  95         self.editmode=0
  96         self.active_etapes()
  97         return objet
  98       elif type(name)==types.InstanceType:
  99         # on est dans le cas où on veut ajouter une commande déjà
 100         # existante (par copie donc)
 101         # on est donc nécessairement en mode editeur ...
 102         objet = name
 103         objet.jdc = objet.parent = self
 104         #XXX current_step n'existe plus. A priori le parent devrait etre self
 105         # ainsi que le step courant.
 106         #objet.parent = self.current_step
 107         self.set_current_step()
 108         if isinstance(objet,ETAPE):
 109           if objet.nom_niveau_definition == 'JDC':
 110             # l'objet dépend directement du JDC
 111             objet.niveau = self
 112           else:
 113             # l'étape dépend d'un niveau et non directement du JDC :
 114             # il faut l'enregistrer dans le niveau de parent
 115             objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
 116             objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
 117         self.etapes.insert(pos,objet)
 118         self.active_etapes()
 119         self.editmode=0
 120         return objet
 121       else :
 122         # On veut ajouter une nouvelle commande
 123         try:
 124           self.set_current_step()
 125           cmd=self.get_cmd(name)
 126           # L'appel a make_objet n'a pas pour effet d'enregistrer l'étape
 127           # auprès du step courant car editmode vaut 1
 128           e=cmd.make_objet()
 129           if pos == None : pos = 0
 130           self.etapes.insert(pos,e)
 131           self.reset_current_step()
 132           self.editmode=0
 133           self.active_etapes()
 134           return e
 135         except:
 136           traceback.print_exc()
 137           self.reset_current_step()
 138           self.editmode=0
 139           raise AsException("Impossible d ajouter la commande "+name)
 140
 141    def set_current_step(self):
 142       CONTEXT.unset_current_step()
 143       CONTEXT.set_current_step(self)
 144
 145    def reset_current_step(self):
 146       CONTEXT.unset_current_step()
 147
 148    def liste_mc_presents(self):
 149       return []
 150
 151    def get_sd_avant_etape(self,nom_sd,etape):
 152       return self.get_contexte_avant(etape).get(nom_sd,None)
 153
 154    def get_sd_apres_etape(self,nom_sd,etape):
 155       """
 156            Cette méthode retourne la SD de nom nom_sd qui est éventuellement
 157             définie apres etape
 158       """
 159       ietap=self.etapes.index(etape)
 160       for e in self.etapes[ietap+1:]:
 161         sd=e.get_sdprods(nom_sd)
 162         if sd:
 163           if hasattr(e,'reuse'):
 164             if e.reuse != sd:
 165               return sd
 166       return None
 167
 168    def get_sd_autour_etape(self,nom_sd,etape):
 169       """
 170            Fonction: retourne la SD de nom nom_sd qui est éventuellement
 171             définie avant ou apres etape
 172            Permet de vérifier si un concept de meme nom existe dans le périmètre
 173            d'une étape
 174       """
 175       sd=self.get_sd_avant_etape(nom_sd,etape)
 176       if sd:return sd
 177       return self.get_sd_apres_etape(nom_sd,etape)
 178
 179    def active_etapes(self):
 180       """
 181           Cette méthode a pour fonction de désactiver les étapes qui doivent
 182           l'être cad, dans le cas d'ASTER, les étapes qui ne sont pas
 183           comprises entre le premier DEBUT/POURSUITE et le premier FIN
 184           et rendre actives les autres
 185       """
 186       if self.definition.code == 'ASTER' :
 187          # Seulement pour ASTER :
 188          # Avant DEBUT actif vaut 0
 189          # Apres DEBUT et avant le 1er FIN actif vaut 1
 190          # Apres le 1er FIN actif vaut -1
 191          actif=0
 192       else:
 193          actif=1
 194       for etape in self.etapes:
 195         if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
 196         if actif == 1:
 197            etape.active()
 198         else:
 199            etape.inactive()
 200         if etape.nom == 'FIN':actif=-1
 201
 202    def suppentite(self,etape) :
 203       """
 204           Cette methode a pour fonction de supprimer une étape dans
 205           un jeu de commandes
 206       """
 207       self.init_modif()
 208       self.etapes.remove(etape)
 209       if etape.niveau is not self:
 210         # Dans ce cas l'étape est enregistrée dans un niveau
 211         # Il faut la désenregistrer
 212         etape.niveau.unregister(etape)
 213       etape.supprime_sdprods()
 214       self.active_etapes()
 215
 216    def del_sdprod(self,sd):
 217       """
 218           Supprime la SD sd de la liste des sd et des dictionnaires de contexte
 219       """
 220       if sd in self.sds : self.sds.remove(sd)
 221       if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
 222
 223    def delete_concept(self,sd):
 224       """
 225           Inputs :
 226              sd=concept detruit
 227           Fonction :
 228              Mettre a jour les etapes du JDC suite à la disparition du
 229              concept sd
 230              Seuls les mots cles simples MCSIMP font un traitement autre
 231              que de transmettre aux fils
 232       """
 233       for etape in self.etapes :
 234         etape.delete_concept(sd)
 235
 236    def analyse(self):
 237       self.compile()
 238       if not self.cr.estvide():return
 239       self.exec_compile()
 240       self.active_etapes()
 241
 242    def register(self,etape):
 243       """
 244            Cette méthode ajoute  etape dans la liste
 245            des etapes self.etapes et retourne l identificateur d'étape
 246            fourni par l appel a g_register
 247            A quoi sert editmode ?
 248            - Si editmode vaut 1, on est en mode edition de JDC. On cherche
 249            à enregistrer une étape que l'on a créée avec eficas (en passant
 250            par addentite) auquel cas on ne veut récupérer que son numéro
 251            d'enregistrement et c'est addentité qui l'enregistre dans
 252            self.etapes à la bonne place...
 253            - Si editmode vaut 0, on est en mode relecture d'un fichier de
 254            commandes et on doit enregistrer l'étape à la fin de self.etapes
 255            (dans ce cas l'ordre des étapes est bien l'ordre chronologique
 256            de leur création   )
 257       """
 258       if not self.editmode:
 259          self.etapes.append(etape)
 260       else:
 261          pass
 262       return self.g_register(etape)
 263
 264    def register_parametre(self,param):
 265       """
 266           Cette méthode sert à ajouter un paramètre dans la liste des paramètres
 267       """
 268       self.params.append(param)
 269
 270    def delete_param(self,param):
 271       """
 272           Supprime le paramètre param de la liste des paramètres
 273           et du contexte gobal
 274       """
 275       if param in self.params : self.params.remove(param)
 276       if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
 277
 278    def get_parametres_fonctions_avant_etape(self,etape):
 279       """
 280           Retourne deux éléments :
 281           - une liste contenant les noms des paramètres (constantes ou EVAL)
 282             définis avant etape
 283           - une liste contenant les formules définies avant etape
 284       """
 285       l_constantes = []
 286       l_fonctions = []
 287       # on récupère le contexte avant etape
 288       # on ne peut mettre dans les deux listes que des éléments de ce contexte
 289       d=self.get_contexte_avant(etape)
 290       # construction de l_constantes
 291       for param in self.params:
 292         nom = param.nom
 293         if not nom : continue
 294         if d.has_key(nom): l_constantes.append(nom)
 295       # construction de l_fonctions
 296       for form in self.fonctions:
 297         nom = form.nom
 298         if not nom : continue
 299         if d.has_key(nom): l_fonctions.append(form.get_formule())
 300       # on retourne les deux listes
 301       return l_constantes,l_fonctions
 302
 303    def get_nb_etapes_avant(self,niveau):
 304       """
 305           Retourne le nombre d etapes avant le debut de niveau
 306       """
 307       nb=0
 308       for niv in self.etapes_niveaux:
 309         if niv == niveau:break
 310         nb=nb+len(niv.etapes)
 311       return nb
 312
 313    def send_message(self,message):
 314       if self.appli:
 315          self.appli.send_message(message)
 316
 317 #XXX ne semble pas servir pour JDC
 318 #   def reevalue_sd_jdc(self):
 319       #"""
 320           #Avec la liste des SD qui ont été supprimées, propage la disparition de ces
 321           #SD dans toutes les étapes et descendants
 322       #"""
 323       #l_sd = self.diff_contextes()
 324       #if len(l_sd) == 0 : return
 325       #for sd in l_sd:
 326         #self.jdc.delete_concept(sd)
 327
 328    def init_modif(self):
 329       """
 330       Méthode appelée au moment où une modification va être faite afin de
 331       déclencher d'éventuels traitements pré-modification
 332       """
 333       self.state = 'modified'
 334
 335    def fin_modif(self):
 336       pass
 337
 338    def get_liste_mc_inconnus(self):
 339      """
 340      Retourne une liste contenant les mots-clés inconnus à la relecture du JDC
 341      """
 342      # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
 343      l_mc = []
 344      for etape in self.etapes :
 345          if etape.isactif() :
 346             if not etape.isvalid() :
 347                l = etape.get_liste_mc_inconnus()
 348                if l : l_mc.extend(l)
 349      return l_mc
 350
 351    def get_file(self,unite=None,fic_origine=''):
 352       """
 353           Retourne le nom du fichier correspondant à un numero d'unité
 354           logique (entier) ainsi que le source contenu dans le fichier
 355       """
 356       if self.appli :
 357          # Si le JDC est relié à une application maitre, on délègue la recherche
 358          file,text = self.appli.get_file(unite,fic_origine)
 359       else:
 360          file = None
 361          if unite != None:
 362             if os.path.exists("fort."+str(unite)):
 363                file= "fort."+str(unite)
 364          if file == None :
 365             raise AsException("Impossible de trouver le fichier correspondant \
 366                                a l unite %s" % unite)
 367          if not os.path.exists(file):
 368             raise AsException("%s n'est pas un fichier existant" % unite)
 369          fproc=open(file,'r')
 370          text=fproc.read()
 371          fproc.close()
 372       text=string.replace(text,'\r\n','\n')
 373       linecache.cache[file]=0,0,string.split(text,'\n'),file
 374       return file,text
 375