1 # -*- coding: utf-8 -*-
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
20 # ======================================================================
24 import types,traceback,sys,os
25 import string,linecache
30 from Noyau.N_ASSD import ASSD
31 #from Noyau.N_LASSD import LASSD
32 from Noyau.N_ETAPE import ETAPE
33 from Noyau.N_Exception import AsException
34 from Extensions import commentaire,parametre,parametre_eval
40 class JDC(I_OBJECT.OBJECT):
45 self.etapes_niveaux=[]
49 self._etape_context=None
50 self.recorded_units={}
51 self.old_recorded_units={}
53 def get_index(self,objet):
55 Retourne la position d'objet dans la liste self
57 return self.etapes.index(objet)
59 def get_sd_avant_du_bon_type(self,etape,types_permis):
61 Retourne la liste des concepts avant etape d'un type acceptable
63 d=self.get_contexte_avant(etape)
66 if type(v) != types.InstanceType and not isinstance(v,object): continue
67 # On considère que seul assd indique un type quelconque pas CO
68 elif self.assd in types_permis :
70 elif self.est_permis(v,types_permis):
75 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
77 Retourne la liste des concepts avant etape d'1 type de base acceptable
78 Attention different de la routine précédente : 1 seul type passé en parametre
79 Teste sur issubclass et par sur le type permis
81 d=self.get_contexte_avant(etape)
84 typeverif=self.cata[0].__dict__[type]
88 if issubclass(v.__class__,typeverif):
93 def cherche_list_avant(self,etape,valeur):
94 d=self.get_contexte_avant(etape)
96 if issubclass(v.__class__,LASSD):
99 # Attention pour enlever les . a la fin des pretendus reels
100 if k == valeur[0:-1] :
104 def est_permis(self,v,types_permis):
105 for type_ok in types_permis:
106 if type_ok in ('R','I','C','TXM') and v in self.params :
108 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
110 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
112 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
114 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
116 elif type(type_ok) != types.ClassType and not isinstance(type_ok,type):
118 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
122 def addentite(self,name,pos):
125 Si name est le nom d une commande ou un commentaire ajoute
127 Sinon remonte une erreur
131 if name == "COMMENTAIRE" :
132 # ajout d'un commentaire
133 self.set_current_step()
135 for child in self.etapes :
136 if isinstance(child,commentaire.COMMENTAIRE):
138 objet = commentaire.COMMENTAIRE('',parent=self)
139 objet.nom = "_comm_"+`ind`
140 if pos == None : pos = 0
141 self.etapes.insert(pos,objet)
144 CONNECTOR.Emit(self,"add",objet)
147 elif name == "PARAMETRE":
148 # ajout d'un parametre
149 self.set_current_step()
150 nom_param = '_param_'+str(len(self.params)+1)
151 objet = parametre.PARAMETRE(nom=nom_param)
152 if pos == None : pos = 0
153 self.etapes.insert(pos,objet)
157 CONNECTOR.Emit(self,"add",objet)
160 elif name == "PARAMETRE_EVAL":
161 # ajout d'un parametre EVAL
162 self.set_current_step()
163 nom_param = '_param_'+str(len(self.params)+1)
164 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
165 if pos == None : pos = 0
166 self.etapes.insert(pos,objet)
170 CONNECTOR.Emit(self,"add",objet)
173 elif type(name)==types.InstanceType:
174 # on est dans le cas où on veut ajouter une commande déjà
175 # existante (par copie donc)
176 # on est donc nécessairement en mode editeur ...
178 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
180 self.set_current_step()
181 if isinstance(objet,ETAPE):
182 if objet.nom_niveau_definition == 'JDC':
183 # l'objet dépend directement du JDC
186 # l'étape dépend d'un niveau et non directement du JDC :
187 # il faut l'enregistrer dans le niveau de parent
188 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
189 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
190 self.etapes.insert(pos,objet)
191 # il faut vérifier que les concepts utilisés par objet existent bien
192 # à ce niveau d'arborescence
193 objet.verif_existence_sd()
194 objet.update_mc_global()
198 CONNECTOR.Emit(self,"add",objet)
202 # On veut ajouter une nouvelle commande
204 self.set_current_step()
205 cmd=self.get_cmd(name)
206 # L'appel a make_objet n'a pas pour effet d'enregistrer l'étape
207 # auprès du step courant car editmode vaut 1
208 # Par contre elle a le bon parent grace a set_current_step
210 if pos == None : pos = 0
211 self.etapes.insert(pos,e)
212 self.reset_current_step()
216 CONNECTOR.Emit(self,"add",e)
219 except AsException,e:
220 self.reset_current_step()
222 raise AsException("Impossible d ajouter la commande "+name + '\n' +str(e))
224 traceback.print_exc()
225 self.reset_current_step()
227 raise AsException("Impossible d ajouter la commande "+name)
230 #print "JDC.close",self
231 for etape in self.etapes:
232 if hasattr(etape,"close"):etape.close()
233 CONNECTOR.Emit(self,"close")
235 def set_current_step(self):
236 CONTEXT.unset_current_step()
237 CONTEXT.set_current_step(self)
239 def reset_current_step(self):
240 CONTEXT.unset_current_step()
242 def liste_mc_presents(self):
245 def get_sd_avant_etape(self,nom_sd,etape):
246 return self.get_contexte_avant(etape).get(nom_sd,None)
248 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
250 Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
251 définie apres etape en tenant compte des concepts detruits
252 Si avec vaut 'non' exclut etape de la recherche
254 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
255 ietap=self.etapes.index(etape)
256 if avec == 'non':ietap=ietap+1
258 for e in self.etapes[ietap:]:
261 autre_sd=d.get(nom_sd,None)
263 # Le concept a ete detruit. On interrompt la recherche car il n'y a
264 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
266 if autre_sd is not sd :
267 # L'etape produit un concept different de meme nom. La situation n'est
268 # pas saine (sauf peut etre si reuse ???)
269 if hasattr(e,'reuse') and e.reuse == autre_sd:
270 # Le concept etant reutilise, on interrompt la recherche.
271 # On considere qu'il n'y a pas de nouveau concept defini
272 # meme si dans les etapes suivantes le concept est detruit
273 # et un concept de meme nom créé.
274 # AVERIFIER : avec reuse le concept devrait etre le meme
275 # le passage par ici est tres improbable
278 # Le concept est produit par l'etape (Il y a conflit potentiel).
279 # Le concept est redefini par une etape posterieure.
281 # Pas de destruction du concept ni de redefinition. On retourne le
285 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
287 Cette méthode retourne la SD de nom nom_sd qui est éventuellement
289 Si avec vaut 'non' exclut etape de la recherche
291 ietap=self.etapes.index(etape)
292 if avec == 'non':ietap=ietap+1
293 for e in self.etapes[ietap:]:
294 sd=e.get_sdprods(nom_sd)
296 if hasattr(e,'reuse'):
301 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
303 Fonction: retourne la SD de nom nom_sd qui est éventuellement
304 définie avant ou apres etape
305 Permet de vérifier si un concept de meme nom existe dans le périmètre
307 Si avec vaut 'non' exclut etape de la recherche
309 sd=self.get_sd_avant_etape(nom_sd,etape)
311 return self.get_sd_apres_etape(nom_sd,etape,avec)
313 def get_contexte_apres(self,etape):
315 Retourne le dictionnaire des concepts connus apres etape
316 On tient compte des commandes qui modifient le contexte
317 comme DETRUIRE ou les macros
318 Si etape == None, on retourne le contexte en fin de JDC
320 if not etape: return self.get_contexte_avant(etape)
322 d=self.get_contexte_avant(etape)
323 if etape.isactif():etape.update_context(d)
324 self.index_etape_courante=self.index_etape_courante+1
327 def active_etapes(self):
329 Cette méthode a pour fonction de désactiver les étapes qui doivent
330 l'être cad, dans le cas d'ASTER, les étapes qui ne sont pas
331 comprises entre le premier DEBUT/POURSUITE et le premier FIN
332 et rendre actives les autres
334 if self.definition.code == 'ASTER' :
335 # Seulement pour ASTER :
336 # Avant DEBUT actif vaut 0
337 # Apres DEBUT et avant le 1er FIN actif vaut 1
338 # Apres le 1er FIN actif vaut -1
342 for etape in self.etapes:
343 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
348 if etape.nom == 'FIN':actif=-1
350 def suppentite(self,etape) :
352 Cette methode a pour fonction de supprimer une étape dans
354 Retourne 1 si la suppression a pu être effectuée,
355 Retourne 0 dans le cas contraire
357 #print "suppentite",self
358 #PN correction de bugs
359 if etape not in self.etapes:
363 index_etape=self.etapes.index(etape)
364 self.etapes.remove(etape)
366 if etape.niveau is not self:
367 # Dans ce cas l'étape est enregistrée dans un niveau
368 # Il faut la désenregistrer
369 etape.niveau.unregister(etape)
371 etape.supprime_sdprods()
376 # Apres suppression de l'etape il faut controler que les etapes
377 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
379 index_etape=index_etape-1
380 etape=self.etapes[index_etape]
383 self.control_context_apres(etape)
386 CONNECTOR.Emit(self,"supp",etape)
390 def control_context_apres(self,etape):
392 Cette méthode verifie que les etapes apres l'etape etape
393 ont bien des concepts produits acceptables (pas de conflit de
395 Si des concepts produits ne sont pas acceptables ils sont supprimés.
396 Effectue les verifications sur les etapes du jdc mais aussi sur les
397 jdc parents s'ils existent.
399 #print "control_context_apres",self,etape
400 #Regularise les etapes du jdc apres l'etape etape
401 self.control_jdc_context_apres(etape)
403 def control_jdc_context_apres(self,etape):
405 Methode semblable a control_context_apres mais ne travaille
406 que sur les etapes et sous etapes du jdc
408 #print "control_jdc_context_apres",self,etape
410 # on demarre de la premiere etape
413 index_etape=self.etapes.index(etape)+1
416 etape=self.etapes[index_etape]
418 #derniere etape du jdc : rien a faire
421 context=self.get_contexte_avant(etape)
423 for e in self.etapes[index_etape:]:
424 e.control_sdprods(context)
425 e.update_context(context)
429 if not self.cr.estvide():return
433 def register_parametre(self,param):
435 Cette méthode sert à ajouter un paramètre dans la liste des paramètres
437 self.params.append(param)
439 def register_fonction(self,fonction):
441 Cette méthode sert à ajouter une fonction dans la liste des fonctions
443 self.fonctions.append(fonction)
445 def delete_param(self,param):
447 Supprime le paramètre param de la liste des paramètres
450 if param in self.params : self.params.remove(param)
451 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
453 def get_parametres_fonctions_avant_etape(self,etape):
455 Retourne deux éléments :
456 - une liste contenant les noms des paramètres (constantes ou EVAL)
458 - une liste contenant les formules définies avant etape
462 # on récupère le contexte avant etape
463 # on ne peut mettre dans les deux listes que des éléments de ce contexte
464 d=self.get_contexte_avant(etape)
465 # construction de l_constantes
466 for param in self.params:
468 if not nom : continue
469 if d.has_key(nom): l_constantes.append(nom)
470 # construction de l_fonctions
471 for form in self.fonctions:
473 if not nom : continue
474 if d.has_key(nom): l_fonctions.append(form.get_formule())
476 # on ajoute les concepts produits par DEFI_VALEUR
477 # XXX On pourrait peut etre faire plutot le test sur le type
478 # de concept : entier, reel, complexe, etc.
479 for k,v in d.items():
480 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
481 l_constantes.append(k)
483 # on retourne les deux listes
484 return l_constantes,l_fonctions
486 def get_nb_etapes_avant(self,niveau):
488 Retourne le nombre d etapes avant le debut de niveau
491 for niv in self.etapes_niveaux:
492 if niv == niveau:break
493 nb=nb+len(niv.etapes)
496 def send_message(self,message):
498 self.appli.send_message(message)
500 def init_modif(self):
502 Méthode appelée au moment où une modification va être faite afin de
503 déclencher d'éventuels traitements pré-modification
505 #print "init_modif",self
506 self.state = 'modified'
509 #print "fin_modif",self
510 CONNECTOR.Emit(self,"valid")
514 def deep_update_condition_bloc(self):
515 # pour le moment, on ne fait rien
516 raise "Not implemented"
518 def update_condition_bloc(self):
519 # pour le moment, on ne fait rien
520 raise "Not implemented"
522 def get_liste_mc_inconnus(self):
524 Retourne une liste contenant les mots-clés inconnus à la relecture du JDC
526 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
528 for etape in self.etapes :
530 if not etape.isvalid() :
531 l = etape.get_liste_mc_inconnus()
532 if l : l_mc.extend(l)
535 def get_genealogie(self):
537 Retourne la liste des noms des ascendants de l'objet self
538 jusqu'à la première ETAPE parent.
542 def get_liste_cmd(self):
544 Retourne la liste des commandes du catalogue
546 return self.niveau.definition.get_liste_cmd()
548 def get_groups(self):
550 Retourne la liste des groupes
552 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
554 def set_etape_context(self,etape):
556 Positionne l'etape qui sera utilisee dans NommerSdProd pour
557 decider si le concept passé pourra etre nommé
559 self._etape_context=etape
561 def reset_context(self):
563 Cette methode reinitialise le contexte glissant pour pouvoir
564 tenir compte des modifications de l'utilisateur : création
565 de commandes, nommage de concepts, etc.
567 #print "reset_context",self,self.nom
568 self.current_context={}
569 self.index_etape_courante=0
570 # for etape in self.etapes:
571 # etape.reset_context()
573 def del_sdprod(self,sd):
575 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
577 #print "del_sdprod",self,sd
578 #print "del_sdprod",self.sds
579 #print "del_sdprod",self.g_context
580 #print "del_sdprod",self.sds_dict
581 if sd in self.sds : self.sds.remove(sd)
582 if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
583 if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
585 def del_param(self,param):
587 Supprime le paramètre param de la liste des paramètres
590 if param in self.params : self.params.remove(param)
591 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
593 def del_fonction(self,fonction):
595 Supprime la fonction fonction de la liste des fonctions
598 if fonction in self.fonctions : self.fonctions.remove(fonction)
599 if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
601 def append_sdprod(self,sd):
603 Ajoute la SD sd à la liste des sd en vérifiant au préalable qu'une SD de
604 même nom n'existe pas déjà
606 if sd == None or sd.nom == None:return
608 o=self.sds_dict.get(sd.nom,None)
609 if isinstance(o,ASSD):
610 raise AsException("Nom de concept deja defini : %s" % sd.nom)
611 self.sds_dict[sd.nom]=sd
612 self.g_context[sd.nom] = sd
613 if sd not in self.sds : self.sds.append(sd)
615 def append_param(self,param):
617 Ajoute le paramètre param à la liste des params
618 et au contexte global
620 # il faudrait vérifier qu'un paramètre de même nom n'existe pas déjà !!!
621 if param not in self.params : self.params.append(param)
622 self.g_context[param.nom]=param
624 def append_fonction(self,fonction):
626 Ajoute la fonction fonction à la liste des fonctions
627 et au contexte global
629 # il faudrait vérifier qu'une fonction de même nom n'existe pas déjà !!!
630 if fonction not in self.fonctions : self.fonctions.append(fonction)
631 self.g_context[fonction.nom]=fonction
633 def delete_concept(self,sd):
638 Mettre a jour les etapes du JDC suite à la disparition du
640 Seuls les mots cles simples MCSIMP font un traitement autre
641 que de transmettre aux fils
643 #print "delete_concept",self,sd
644 for etape in self.etapes :
645 etape.delete_concept(sd)
647 def replace_concept_after_etape(self,etape,old_sd,sd):
649 Met à jour les étapes du JDC qui sont après etape en fonction
650 du remplacement du concept sd
652 index = self.etapes.index(etape)+1
653 if index == len(self.etapes) :
654 return # etape est la dernière étape du jdc ...on ne fait rien !
655 for child in self.etapes[index:]:
656 child.replace_concept(old_sd,sd)
658 def update_concept_after_etape(self,etape,sd):
660 Met à jour les étapes du JDC qui sont après etape en fonction
661 de la modification (principalement nommage) du concept sd
664 #On traite toutes les etapes
667 index = self.etapes.index(etape)+1
668 if index == len(self.etapes) :
669 return # etape est la dernière étape du jdc ...on ne fait rien !
670 for child in self.etapes[index:]:
671 child.update_concept(sd)
673 def dump_state(self):
674 print "JDC.state: ",self.state
675 for etape in self.etapes :
676 print etape.nom+".state: ",etape.state
678 def change_unit(self,unit,etape,old_unit):
679 #print "change_unit",unit,etape,old_unit
680 #print id(self.recorded_units),self.recorded_units
681 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
682 self.record_unit(unit,etape)
684 def record_unit(self,unit,etape):
685 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
686 #print "record_unit",unit,etape
689 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
691 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
692 #print id(self.recorded_units),self.recorded_units
693 #print self.recorded_units.get(None,(None,"",{}))[2]
694 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
696 def changefichier(self,fichier):
699 def eval_in_context(self,valeur,etape):
700 """ Tente d'evaluer valeur dans le contexte courant de etape
701 Retourne le parametre valeur inchange si l'evaluation est impossible
703 #contexte initial du jdc
704 context=self.condition_context.copy()
705 #contexte courant des concepts. Il contient les parametres
706 context.update(self.get_contexte_avant(etape))
708 objet = eval(valeur,context)
711 #traceback.print_exc()
715 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
717 #print "supprime",self
718 Noyau.N_JDC.JDC.supprime(self)
721 # self.const_context={}
725 # self.current_context={}
726 # self.condition_context={}
727 # self.etapes_niveaux=[]
731 # self._etape_context=None
734 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
735 def register(self,etape):
737 Cette méthode ajoute etape dans la liste
738 des etapes self.etapes et retourne l identificateur d'étape
739 fourni par l appel a g_register
741 A quoi sert editmode ?
742 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
743 à enregistrer une étape que l'on a créée avec eficas (en passant
744 par addentite) auquel cas on ne veut récupérer que son numéro
745 d'enregistrement et c'est addentité qui l'enregistre dans
746 self.etapes à la bonne place...
747 - Si editmode vaut 0, on est en mode relecture d'un fichier de
748 commandes et on doit enregistrer l'étape à la fin de self.etapes
749 (dans ce cas l'ordre des étapes est bien l'ordre chronologique
752 if not self.editmode:
753 self.etapes.append(etape)
756 return self.g_register(etape)
758 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
759 def NommerSdprod(self,sd,sdnom,restrict='non'):
761 Nomme la SD apres avoir verifie que le nommage est possible :
763 Si le nom est deja utilise, leve une exception
764 Met le concept créé dans le concept global g_context
766 # XXX En mode editeur dans EFICAS, le nommage doit etre géré différemment
767 # Le dictionnaire g_context ne représente pas le contexte
768 # effectif avant une étape.
769 # Il faut utiliser get_contexte_avant avec indication de l'étape
771 # Cette etape est indiquee par l'attribut _etape_context qui a ete
772 # positionné préalablement par un appel à set_etape_context
774 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
776 if self._etape_context:
777 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
779 o=self.sds_dict.get(sdnom,None)
781 if isinstance(o,ASSD):
782 raise AsException("Nom de concept deja defini : %s" % sdnom)
784 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
785 # Ajoute a la creation (appel de reg_sd).
786 self.sds_dict[sdnom]=sd
789 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
790 if restrict == 'non':
791 self.g_context[sdnom]=sd
793 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
794 def delete_concept_after_etape(self,etape,sd):
796 Met à jour les étapes du JDC qui sont après etape en fonction
797 de la disparition du concept sd
799 index = self.etapes.index(etape)+1
800 if index == len(self.etapes) :
801 return # etape est la dernière étape du jdc ...on ne fait rien !
802 for child in self.etapes[index:]:
803 child.delete_concept(sd)
805 #ATTENTION SURCHARGE : les methodes ci-dessous surchargent des methodes de Noyau et Validation : a reintegrer
807 def get_file(self,unite=None,fic_origine=''):
809 Retourne le nom du fichier correspondant à un numero d'unité
810 logique (entier) ainsi que le source contenu dans le fichier
813 # Si le JDC est relié à une application maitre, on délègue la recherche
814 file,text= self.appli.get_file(unite,fic_origine)
818 if os.path.exists("fort."+str(unite)):
819 file= "fort."+str(unite)
821 raise AsException("Impossible de trouver le fichier correspondant"
822 " a l unite %s" % unite)
823 if not os.path.exists(file):
824 raise AsException("%s n'est pas un fichier existant" % unite)
828 #if file == None : return None,None
829 text=string.replace(text,'\r\n','\n')
831 linecache.cache[file]=0,0,string.split(text,'\n'),file