DEBUT();
-#Pas trouve shellpanel
+#Pas trouve shellpanel
MAIL=LIRE_MAILLAGE();
DEPL2 = FORMULE(NOM_PARA='INST',VALE='sin(OMEGAA*INST)/(OMEGAA**xx)')
DEPLACE2=CALC_FONC_INTERP( FONCTION=DEPL2,
LIST_PARA=L_INST,
- NOM_PARA='INST',
+ NOM_PARA='INST',
PROL_DROITE='LINEAIRE',
PROL_GAUCHE='LINEAIRE',
NOM_RESU='DEPL' )
VALE : ( 0. 1.
5. 2. )
);
-
+
e_grm = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
VALE : ( 0. 1.
5. 2. )
);
-
+
al_grm = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
VALE : ( 0. 1.
5. 2. )
);
-
+
% Tube guide
e_tu = DEFI_FONCTION ( NOM_PARA : 'TEMP'
5. 2.
)
);
-
+
nu_cr = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
NU : nu_gre
ALPHA : al_gre
RHO : 7800. )
- GRAN_IRRA:( FLUX_L :fluxax1
+ GRAN_IRRA:( FLUX_L :fluxax1
FLUX_TN :fluxrd1
FONC_MULT:flux_f1
A : 0.
UN_SUR_K : 0.
UN_SUR_M : 0.
QSR_K : 1. )
- );
+ );
% Grilles de melange
FONC_MULT: flux_f1
A : 0.
S : 1.)
- LEMAITRE : ( N : 0.
+ LEMAITRE : ( N : 0.
UN_SUR_K : 0.
UN_SUR_M : 0.
- QSR_K : 2.)
+ QSR_K : 2.)
- );
+ );
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
VALE : ( 0. 1.
5. 2. )
);
-
+
e_grm = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
VALE : ( 0. 1.
5. 2. )
);
-
+
al_grm = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
VALE : ( 0. 1.
5. 2. )
);
-
+
% Tube guide
e_tu = DEFI_FONCTION ( NOM_PARA : 'TEMP'
5. 2.
)
);
-
+
nu_cr = DEFI_FONCTION ( NOM_PARA : 'TEMP'
PROL_DROIT : 'CONSTANT'
PROL_GAUCHE : 'CONSTANT'
NU : nu_gre
ALPHA : al_gre
RHO : 7800. )
- GRAN_IRRA:( FLUX_L :fluxax1
+ GRAN_IRRA:( FLUX_L :fluxax1
FLUX_TN :fluxrd1
FONC_MULT:flux_f1
A : 0.
UN_SUR_K : 0.
UN_SUR_M : 0.
QSR_K : 1. )
- );
+ );
% Grilles de melange
FONC_MULT: flux_f1
A : 0.
S : 1.)
- LEMAITRE : ( N : 0.
+ LEMAITRE : ( N : 0.
UN_SUR_K : 0.
UN_SUR_M : 0.
- QSR_K : 2.)
+ QSR_K : 2.)
- );
+ );
%
% AFFECTATION DES MATERIAUX A CHAUD - CYCLE
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
- --> sans objet pour les commandes commentarisées
+ avant étape, sinon enlève la référence à ces concepts
+ --> sans objet pour les commandes commentarisées
"""
pass
-
+
def control_sdprods(self,d):
"""sans objet pour les commandes commentarisées"""
pass
texte = reste
return operateur,reste
elif texte[0] == '-':
- # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
- try :
- args,reste = self.cherche_args(texte[1:])
- except InterpreteurException,e:
+ # Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
+ try :
+ args,reste = self.cherche_args(texte[1:])
+ except InterpreteurException,e:
raise InterpreteurException,str(e)
- if not args :
- # Il ne s'agit pas de '-' comme opérateur unaire --> on retourne None
- return None,texte
- else:
- identificateur = '-'
- args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
+ if not args :
+ # Il ne s'agit pas de '-' comme opérateur unaire --> on retourne None
+ return None,texte
+ else:
+ identificateur = '-'
+ args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
formule_operateur = (identificateur,'',self.t_formule[2],args)
operateur = Interpreteur_Formule(formule = formule_operateur,
constantes = self.new_constantes,
if self.item < 0:
isvalid = 0
try:
- longueur= len(self.param_pere.dict_valeur) - 1
+ longueur= len(self.param_pere.dict_valeur) - 1
except:
longueur=0
if self.item > longueur :
JdC = JDC_CATA(code='HOMARD',
execmodul=None,
regles = (AU_MOINS_UN('DONNEES_HOMARD'),),
- )
+ )
# Type le plus general
class entier (ASSD):pass
# 2. Les fichiers en entree/sortie
#
FICHIERS = FACT(statut='o',
- NOM_MED_MAILLAGE_N = SIMP(statut='o' ,typ='TXM',
- fr="Nom du fichier contenant le maillage à adapter",
- ang="File name including the in-mesh"),
- NOM_MED_MAILLAGE_NP1 = SIMP(statut='o' ,typ='TXM',
+ NOM_MED_MAILLAGE_N = SIMP(statut='o' ,typ='TXM',
+ fr="Nom du fichier contenant le maillage à adapter",
+ ang="File name including the in-mesh"),
+ NOM_MED_MAILLAGE_NP1 = SIMP(statut='o' ,typ='TXM',
fr="Nom du fichier qui contiendra le maillage adapté",
ang="File name for resulting out-mesh"),
- INFORMATION = SIMP(statut='o' ,typ='TXM',
+ INFORMATION = SIMP(statut='o' ,typ='TXM',
fr="Nom du fichier contenant les informations de sortie",
ang="Log File"),
),
ang="Groups which define the boundary" ),
) ,
fichier_frontiere=BLOC ( condition = "NOM_MED_MAILLAGE_FRONTIERE != None" ,
- FIC_FRON = SIMP(statut='f',typ='TXM',
- fr="Nom du fichier MED contenant le maillage frontiere",
- ang="MED File including the boundary mesh" ),
+ FIC_FRON = SIMP(statut='f',typ='TXM',
+ fr="Nom du fichier MED contenant le maillage frontiere",
+ ang="MED File including the boundary mesh" ),
),
#
),
JdC = JDC_CATA(code='HOMARD',
execmodul=None,
regles = (AU_MOINS_UN('DONNEES_HOMARD'),),
- )
+ )
# Type le plus general
class entier (ASSD):pass
regles=( UN_PARMI('TYPE_RAFFINEMENT_LIBRE','TYPE_DERAFFINEMENT_UNIFORME','TYPE_RAFFINEMENT_UNIFORME','INFORMATION'),
### EXCLUS('TYPE_RAFFINEMENT_LIBRE','INFORMATION'),
### EXCLUS('TYPE_RAFFINEMENT_UNIFORME','INFORMATION'),
- ),
+ ),
#
TYPE_RAFFINEMENT_LIBRE = FACT(statut='f',
RAFFINEMENT = SIMP (statut='o',typ='TXM',
ang="Choice of unrefinement mode.",
into=("NON","LIBRE",),),
- b_adaptation = bloc_adaptation(),
- b_indicateur_d_erreur = indicateur_d_erreur(),
- b_critere_de_raffinement = critere_de_raffinement(),
- b_critere_de_deraffinement = critere_de_deraffinement(),
- b_niveau_minimum = niveau_minimum(),
- b_niveau_maximum = niveau_maximum(),
+ b_adaptation = bloc_adaptation(),
+ b_indicateur_d_erreur = indicateur_d_erreur(),
+ b_critere_de_raffinement = critere_de_raffinement(),
+ b_critere_de_deraffinement = critere_de_deraffinement(),
+ b_niveau_minimum = niveau_minimum(),
+ b_niveau_maximum = niveau_maximum(),
),
RAFFINEMENT = SIMP (statut='o',typ='TXM',
fr="Choix du mode de raffinement.",
ang="Choice of refinement mode.",
- defaut="UNIFORME",
+ defaut="UNIFORME",
into=("UNIFORME",),),
DERAFFINEMENT = SIMP(statut='o',typ='TXM',
fr="Choix du mode de deraffinement.",
ang="Choice of unrefinement mode.",
- defaut="NON",
+ defaut="NON",
into=("NON",),),
- b_adaptation = bloc_adaptation(),
- b_niveau_minimum = niveau_minimum(),
- b_niveau_maximum = niveau_maximum(),
+ b_adaptation = bloc_adaptation(),
+ b_niveau_minimum = niveau_minimum(),
+ b_niveau_maximum = niveau_maximum(),
),
RAFFINEMENT = SIMP (statut='o',typ='TXM',
fr="Choix du mode de raffinement.",
ang="Choice of refinement mode.",
- defaut="NON",
+ defaut="NON",
into=("NON",),),
DERAFFINEMENT = SIMP(statut='o',typ='TXM',
fr="Choix du mode de deraffinement.",
ang="Choice of unrefinement mode.",
- defaut="UNIFORME",
+ defaut="UNIFORME",
into=("UNIFORME",),),
- b_adaptation = bloc_adaptation(),
- b_niveau_minimum = niveau_minimum(),
- b_niveau_maximum = niveau_maximum(),
+ b_adaptation = bloc_adaptation(),
+ b_niveau_minimum = niveau_minimum(),
+ b_niveau_maximum = niveau_maximum(),
),
#
INFORMATION =SIMP(statut='f',typ='TXM',
ang="Groups which define the boundary" ),
) ,
fichier_frontiere=BLOC ( condition = "NOM_MED_MAILLAGE_FRONTIERE != None" ,
- FIC_FRON = SIMP(statut='f',typ='TXM',
- fr="Nom du fichier MED contenant le maillage frontiere",
- ang="MED File including the boundary mesh" ),
+ FIC_FRON = SIMP(statut='f',typ='TXM',
+ fr="Nom du fichier MED contenant le maillage frontiere",
+ ang="MED File including the boundary mesh" ),
),
#
#
# Cas particulier des opérateurs obligatoirement réentrants
#
if self.definition.reentrant == 'o':
- self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
+ self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
self.sdnom=self.sd.nom
self.fin_modif()
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
- # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
- if isinstance(sd,self.get_type_produit()) :
+ # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
+ if isinstance(sd,self.get_type_produit()) :
self.sd = self.reuse = sd
self.sdnom = sd.nom
self.fin_modif()
return 1,"Opérateur facultativement réentrant et concept existant trouvé"
- else:
- return 0,"Concept déjà existant et de mauvais type"
+ else:
+ return 0,"Concept déjà existant et de mauvais type"
else :
# il faut enlever le lien vers une SD existante car si on passe ici
- # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
- # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
- if self.reuse :
+ # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
+ if self.reuse :
old_reuse=self.reuse
- self.sd = self.reuse = self.sdnom = None
+ self.sd = self.reuse = self.sdnom = None
#
# On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
# mais est utilisé en mode non réentrant
old_nom=self.sd.nom
if string.find(old_nom,'sansnom') :
# Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
- # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
- # on peut donc le nommer sans test préalable
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
+ # on peut donc le nommer sans test préalable
if self.parent.get_sd_autour_etape(nom,self):
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
# Renommage du concept : Il suffit de changer son attribut nom pour le nommer
- self.sd.nom=nom
+ self.sd.nom=nom
self.sdnom=nom
self.parent.update_concept_after_etape(self,self.sd)
self.fin_modif()
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ avant étape, sinon enlève la référence à ces concepts
"""
#print "verif_existence_sd",self.sd
for motcle in self.mc_liste :
if len(self.mc_liste) == 0:
# pas de fils pour self --> la FORMULE est incomplète
return None,None,None
- type_retourne="REEL"
+ type_retourne="REEL"
if len(self.mc_liste) > 0:
child = self.mc_liste[0] # child est un MCSIMP
corps = child.getval()
- else:
- corps = None
+ else:
+ corps = None
if len(self.mc_liste) > 1:
- child = self.mc_liste[1]
+ child = self.mc_liste[1]
l_args= child.getval()
- else :
- l_args=None
+ else :
+ l_args=None
return type_retourne,l_args,corps
def get_nom(self):
#for argument in l_arguments:
# argument = string.strip(argument)
# try:
- # nom=argument
+ # nom=argument
# typ,nom = string.split(argument,':')
# #pas de vérification sur le nom de l'argument
# #vérification du type de l'argument
"""
if not corps :
corps = self.corps
- if not arguments :
- arguments = self.arguments
+ if not arguments :
+ arguments = self.arguments
formule=(self.get_nom(),self.type_retourne,arguments,corps)
# on récupère la liste des constantes et des autres fonctions prédéfinies
# et qui peuvent être utilisées dans le corps de la formule courante
return 0,"Pas de nom donné à la FORMULE"
if len(nom) > 8 :
return 0,"Un nom de FORMULE ne peut dépasser 8 caractères"
- if nom[0] > "0" and nom[0] < "9" :
- return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
+ if nom[0] > "0" and nom[0] < "9" :
+ return 0,"Un nom de FORMULE ne peut pas commencer par un chiffre"
sd = self.parent.get_sd_autour_etape(nom,self)
if sd :
return 0,"Un concept de nom %s existe déjà !" %nom
def verif_formule_python(self,formule=None):
"""
- Pour l instant ne fait qu un compile python
- il serait possible d ajouter des tests sur les arguments
- ou le type retourne mais ...
- """
+ Pour l instant ne fait qu un compile python
+ il serait possible d ajouter des tests sur les arguments
+ ou le type retourne mais ...
+ """
if not formule :
formule = (None,None,None,None)
test_nom,erreur_nom = self.verif_nom(formule[0])
else:
args = None
test_arguments,erreur_arguments = self.verif_arguments(args)
- corps=formule[3]
- erreur_formule= ''
- test_formule=1
- try :
- compile(corps,'<string>','eval')
- except :
- erreur_formule= "le corps de la formule n'est pas une formule python valide"
- test_formule=0
+ corps=formule[3]
+ erreur_formule= ''
+ test_formule=1
+ try :
+ compile(corps,'<string>','eval')
+ except :
+ erreur_formule= "le corps de la formule n'est pas une formule python valide"
+ test_formule=0
erreur = ''
test = test_nom*test_arguments*test_formule
if not test :
self.build_mc()
self.mc_liste=[]
if len(formule) < 4 :
- return O
+ return O
arguments=formule[3]
- if arguments[0] == '(' :
- arguments=arguments[1:]
- if arguments[-1] == ')' :
- arguments=arguments[:-1]
- self.arguments=tuple(arguments.split(','))
+ if arguments[0] == '(' :
+ arguments=arguments[1:]
+ if arguments[-1] == ')' :
+ arguments=arguments[:-1]
+ self.arguments=tuple(arguments.split(','))
- i=1
- for k,v in self.definition.entites.items():
- child=self.definition.entites[k](None,nom=k,parent=self)
- new_valeur=formule[i+1]
- if i+1 == 3 :
- child.valeur = self.arguments
- else :
- child.valeur = new_valeur
- child.state = 'modified'
- self.mc_liste.append(child)
- i=i+1
-
+ i=1
+ for k,v in self.definition.entites.items():
+ child=self.definition.entites[k](None,nom=k,parent=self)
+ new_valeur=formule[i+1]
+ if i+1 == 3 :
+ child.valeur = self.arguments
+ else :
+ child.valeur = new_valeur
+ child.state = 'modified'
+ self.mc_liste.append(child)
+ i=i+1
+
self.corps = formule[2]
self.type_retourne = formule[1]
- sd = self.get_sd_prod()
+ sd = self.get_sd_prod()
if sd:
sd.nom = formule[0]
self.init_modif()
- return 1
+ return 1
def active(self):
"""
Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
suite à la disparition du concept sd
Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
- sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
- utilisé dans le corps de la fonction
+ sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas
+ utilisé dans le corps de la fonction
"""
self.init_modif()
def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
"""
Retourne la liste des concepts avant etape d'1 type de base acceptable
- Attention different de la routine précédente : 1 seul type passé en parametre
- Teste sur issubclass et par sur le type permis
+ Attention different de la routine précédente : 1 seul type passé en parametre
+ Teste sur issubclass et par sur le type permis
"""
d=self.get_contexte_avant(etape)
l=[]
d=self.get_contexte_avant(etape)
for k,v in d.items():
if issubclass(v.__class__,LASSD):
- if k == valeur :
- return k
- # Attention pour enlever les . a la fin des pretendus reels
- if k == valeur[0:-1] :
- return v
+ if k == valeur :
+ return k
+ # Attention pour enlever les . a la fin des pretendus reels
+ if k == valeur[0:-1] :
+ return v
return None
def est_permis(self,v,types_permis):
objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
self.etapes.insert(pos,objet)
- # il faut vérifier que les concepts utilisés par objet existent bien
- # à ce niveau d'arborescence
- objet.verif_existence_sd()
+ # il faut vérifier que les concepts utilisés par objet existent bien
+ # à ce niveau d'arborescence
+ objet.verif_existence_sd()
objet.update_mc_global()
self.active_etapes()
self.editmode=0
l_mc = []
for etape in self.etapes :
if etape.isactif() :
- if not etape.isvalid() :
- l = etape.get_liste_mc_inconnus()
- if l : l_mc.extend(l)
+ if not etape.isvalid() :
+ l = etape.get_liste_mc_inconnus()
+ if l : l_mc.extend(l)
return l_mc
def get_genealogie(self):
else :
# dans ce cas on est en mode copie d'un motcle
objet = name
- # Appel de la methode qui fait le menage dans les references
- # sur les concepts produits (verification que les concepts existent
- # dans le contexte de la commande courante).
- objet.verif_existence_sd()
+ # Appel de la methode qui fait le menage dans les references
+ # sur les concepts produits (verification que les concepts existent
+ # dans le contexte de la commande courante).
+ objet.verif_existence_sd()
# On verifie que l'ajout d'objet est autorise
if self.ispermis(objet) == 0:
self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,
- self.nom))
+ self.nom))
self.fin_modif()
return 0
# on normalize l'objet
objet=objet.normalize()
# Le mot cle n'existe pas encore. On l'ajoute a la position
- # demandee (pos)
+ # demandee (pos)
if pos == None :
self.mc_liste.append(objet)
else :
l_mc = []
if self.reste_val != {}:
for k,v in self.reste_val.items() :
- l_mc.append([self,k,v])
+ l_mc.append([self,k,v])
for child in self.mc_liste :
if child.isvalid() : continue
l_child = child.get_liste_mc_inconnus()
for mc in l_child:
- l = [self]
- l.extend(mc)
- l_mc.append(l)
+ l = [self]
+ l.extend(mc)
+ l_mc.append(l)
return l_mc
def deep_update_condition_bloc(self):
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ avant étape, sinon enlève la référence à ces concepts
"""
for motcle in self.mc_liste :
motcle.verif_existence_sd()
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ avant étape, sinon enlève la référence à ces concepts
"""
for motcle in self.data :
motcle.verif_existence_sd()
#PN
# ajout du elif
elif type(val) == types.InstanceType and val.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
- txt = txt + i*','+ str(val)
+ txt = txt + i*','+ str(val)
else:
txt = txt + i*','+ myrepr.repr(val)
i=1
objet = eval(new_valeur,d)
return objet,1
except Exception:
- itparam=self.cherche_item_parametre(new_valeur)
- if itparam:
- return itparam,1
- try :
- object=eval(new_valeur.valeur,d)
- except :
- pass
+ itparam=self.cherche_item_parametre(new_valeur)
+ if itparam:
+ return itparam,1
+ try :
+ object=eval(new_valeur.valeur,d)
+ except :
+ pass
if CONTEXT.debug : traceback.print_exc()
return None,0
def cherche_item_parametre (self,new_valeur):
try:
- nomparam=new_valeur[0:new_valeur.find("[")]
- indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
- for p in self.jdc.params:
- if p.nom == nomparam :
- if int(indice) < len(p.get_valeurs()):
- itparam=parametre.ITEM_PARAMETRE(p,int(indice))
- return itparam
- return None
- except:
- return None
+ nomparam=new_valeur[0:new_valeur.find("[")]
+ indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
+ for p in self.jdc.params:
+ if p.nom == nomparam :
+ if int(indice) < len(p.get_valeurs()):
+ itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+ return itparam
+ return None
+ except:
+ return None
def update_concept(self,sd):
if type(self.valeur) in (types.ListType,types.TupleType) :
step.reset_context()
#print "set_valeur_co",new_objet
return 1,"Concept créé"
-
+
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ avant étape, sinon enlève la référence à ces concepts
"""
#print "verif_existence_sd"
# Attention : possible probleme avec include
l=[]
for sd in self.valeur:
if isinstance(sd,ASSD) :
- if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
- l.append(sd)
- else:
- l.append(sd)
+ if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
+ l.append(sd)
+ else:
+ l.append(sd)
if len(l) < len(self.valeur):
self.init_modif()
self.valeur=tuple(l)
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
- if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
+ if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
self.init_modif()
- self.valeur = None
+ self.valeur = None
self.fin_modif()
def get_min_max(self):
def verif_typeihm(self,val,cr='non'):
try :
val.eval()
- return 1
+ return 1
except :
traceback.print_exc()
- pass
+ pass
return self.verif_type(val,cr)
def verif_typeliste(self,val,cr='non') :
verif=0
for v in val :
- verif=verif+self.verif_typeihm(v,cr)
+ verif=verif+self.verif_typeihm(v,cr)
return verif
- =================================================
- Procédure d'installation d'EFICAS
- =================================================
+ =================================================
+ Procédure d'installation d'EFICAS
+ =================================================
Pré-requis :
------------
- - Python 2.1 ou supérieur avec Tkinter
- - PMW 8.0.5 ou supérieur
+ - Python 2.1 ou supérieur avec Tkinter
+ - PMW 8.0.5 ou supérieur
Installation :
--------------
2°) Décompressez ce fichier comme suit :
- gunzip eficas.tar.gz
- tar xvf eficas.tar
+ gunzip eficas.tar.gz
+ tar xvf eficas.tar
3°) Vous devriez désormais voir 4 éléments :
- - 1 fichier README_install
- - 1 fichier install.py
- - 1 fichier code_aster.gif
- - 1 répertoire /Eficas
+ - 1 fichier README_install
+ - 1 fichier install.py
+ - 1 fichier code_aster.gif
+ - 1 répertoire /Eficas
4°) Reportez-vous au fichier README_install pour la suite des actions à entreprendre.
\r
\r
- =================================================\r
- Procédure d'installation d'EFICAS \r
- =================================================\r
+ =================================================\r
+ Procédure d'installation d'EFICAS \r
+ =================================================\r
\r
Pour lancer la procédure d'installation, tapez :\r
\r
- python install.py\r
+ python install.py\r
\r
Vous pouvez remplacer 'python' par le chemin d'accès de votre interpréteur Python.\r
\r
fichier de configuration d'EFICAS qui s'appelle editeur.ini et qui se trouvera, une fois EFICAS,\r
installé, dans le répertoire Eficas/Aster\r
\r
-- Répertoire d'installation : répertoire dans lequel vous voulez installer Eficas\r
-- Répertoire de travail : répertoire de travail temporaire d'EFICAS\r
-- Répertoire matériaux : répertoire dans lequel se trouvent les catalogues matériaux d'ASTER\r
-- Répertoire doc Aster : répertoire dans lequel se trouve le manuel U4 de la doc Aster (format pdf)\r
- ex : /logiciels/aster/NEW6/doc/pdf/u4\r
-- Exécutable Acrobat Reader : chemin d'accès complet à l'exécutable Acrobat Reader\r
+- Répertoire d'installation : répertoire dans lequel vous voulez installer Eficas\r
+- Répertoire de travail : répertoire de travail temporaire d'EFICAS\r
+- Répertoire matériaux : répertoire dans lequel se trouvent les catalogues matériaux d'ASTER\r
+- Répertoire doc Aster : répertoire dans lequel se trouve le manuel U4 de la doc Aster (format pdf)\r
+ ex : /logiciels/aster/NEW6/doc/pdf/u4\r
+- Exécutable Acrobat Reader : chemin d'accès complet à l'exécutable Acrobat Reader\r
\r
\r
-Catalogues Aster : EFICAS installe par défaut le catalogue Aster v6 qui se trouve en\r
- Eficas/Aster/Cata.\r
- Si vous voulez en installer d'autres, il faut qu'ils se trouvent dans ce même répertoire\r
- ou qu'il y ait un lien dans ce répertoire vers le fichier.\r
- Pour ajouter d'autres catalogues, il faut aller modifier directement le fichier editeur.ini\r
+Catalogues Aster : EFICAS installe par défaut le catalogue Aster v6 qui se trouve en\r
+ Eficas/Aster/Cata.\r
+ Si vous voulez en installer d'autres, il faut qu'ils se trouvent dans ce même répertoire\r
+ ou qu'il y ait un lien dans ce répertoire vers le fichier.\r
+ Pour ajouter d'autres catalogues, il faut aller modifier directement le fichier editeur.ini\r
\r
- \r
+ \r
\r
-Lancement d'EFICAS : le fichier à lancer est Eficas/Aster/eficas_aster.py\r
- il faut le lancer précédé du chemin d'accès à l'interpréteur Python comme\r
- pour la procédure d'installation.\r
+Lancement d'EFICAS : le fichier à lancer est Eficas/Aster/eficas_aster.py\r
+ il faut le lancer précédé du chemin d'accès à l'interpréteur Python comme\r
+ pour la procédure d'installation.\r
\r
\r
self.install_running = 0\r
return\r
except :\r
- traceback.print_exc()\r
+ traceback.print_exc()\r
self.install_running = 0\r
self.afficher_fatale("Impossible de copier certains fichiers")\r
\r
cata = """catalogues = (('ASTER','v6',rep_cata + 'cata_STA6.py','python','defaut'),)\n"""\r
f.write(cata)\r
f.close()\r
- \r
+ \r
\r
def move_files(self):\r
"""\r
JdC = JDC_CATA(code='HOMARD',
execmodul=None,
regles = (AU_MOINS_UN('DONNEES_HOMARD'),),
- )
+ )
# Type le plus general
#class entier (ASSD):pass
#
regles=( AU_MOINS_UN('TYPE_RAFFINEMENT_LIBRE','TYPE_RAFFINEMENT_UNIFORME'),
EXCLUS('TYPE_RAFFINEMENT_LIBRE','TYPE_RAFFINEMENT_UNIFORME'),),
- TYPE_RAFFINEMENT_LIBRE = FACT(statut='f',
- RAFFINEMENT = SIMP(statut='o',typ='TXM',
+ TYPE_RAFFINEMENT_LIBRE = FACT(statut='f',
+ RAFFINEMENT = SIMP(statut='o',typ='TXM',
position='global',
fr="Choix du mode de raffinement.",
ang="Choice of refinement mode.",
into=("LIBRE","UNIFORME",) ),
- DERAFFINEMENT = SIMP(statut='o',typ='TXM',
+ DERAFFINEMENT = SIMP(statut='o',typ='TXM',
position='global',
fr="Choix du mode de deraffinement.",
ang="Choice of unrefinement mode.",
into=("LIBRE",), ),),
- TYPE_RAFFINEMENT_UNIFORME = FACT(statut='f',
- RAFFINEMENT = SIMP(statut='o',typ='TXM',
+ TYPE_RAFFINEMENT_UNIFORME = FACT(statut='f',
+ RAFFINEMENT = SIMP(statut='o',typ='TXM',
fr="Choix du mode de raffinement.",
ang="Choice of refinement mode.",
into=("NON","NON-CONFORME","NON-CONFORME-INDICATEUR") ),
- DERAFFINEMENT = SIMP(statut='o',typ='TXM',
+ DERAFFINEMENT = SIMP(statut='o',typ='TXM',
fr="Choix du mode de deraffinement.",
ang="Choice of unrefinement mode.",
into=("UNIFORME","NON",), ),),
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: MakeNomComplet.py,v 1.2 2003/03/07 14:30:48 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: MakeNomComplet.py,v 1.3 2004/09/10 15:52:03 eficas Exp $" )
developpeur.sortie.write( "\n" )
try :
- print basename( "/toto/main.py" )
- print "ERREUR"
+ print basename( "/toto/main.py" )
+ print "ERREUR"
sys.exit(5)
except Exception,e :
print str(e)
- print "OKAY"
+ print "OKAY"
pass
print "FIN NORMALE DE "+__name__
sys.exit(0)
# -*- coding: utf-8 -*-
-# $Header: /home/eficas/CVSROOT/EficasV1/Tools/foztools/foztools.py,v 1.1.1.1 2002/03/26 09:08:47 eficas Exp $
+# $Header: /home/eficas/CVSROOT/EficasV1/Tools/foztools/foztools.py,v 1.2 2004/09/10 15:52:08 eficas Exp $
###########################################################################
# This is a set of Python widgets, built on top of pythonTk. They are
#
###########################################################################
-__version__ = "$Revision: 1.1.1.1 $"
+__version__ = "$Revision: 1.2 $"
import Tkinter
Tk=Tkinter
class Slider:
def __init__(self, master=None, orientation="horizontal", min=0, max=100,
- width=100, height=25, autoLabel="true", appearance="sunken",
- fillColor="blue", background="black", labelColor="yellow",
- labelText="", labelFormat="%d%%", value=50, bd=2):
- # preserve various values
- self.master=master
- self.orientation=orientation
- self.min=min
- self.max=max
- self.width=width
- self.height=height
- self.autoLabel=autoLabel
- self.fillColor=fillColor
- self.labelColor=labelColor
- self.background=background
- self.labelText=labelText
- self.labelFormat=labelFormat
- self.value=value
- self.frame=Tk.Frame(master, relief=appearance, bd=bd)
- self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
- highlightthickness=0, background=background)
- self.scale=self.canvas.create_rectangle(0, 0, width, height,
- fill=fillColor)
- self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
- height / 2, text=labelText,
- anchor="c", fill=labelColor)
- self.update()
- self.canvas.pack(side='top', fill='x', expand='no')
+ width=100, height=25, autoLabel="true", appearance="sunken",
+ fillColor="blue", background="black", labelColor="yellow",
+ labelText="", labelFormat="%d%%", value=50, bd=2):
+ # preserve various values
+ self.master=master
+ self.orientation=orientation
+ self.min=min
+ self.max=max
+ self.width=width
+ self.height=height
+ self.autoLabel=autoLabel
+ self.fillColor=fillColor
+ self.labelColor=labelColor
+ self.background=background
+ self.labelText=labelText
+ self.labelFormat=labelFormat
+ self.value=value
+ self.frame=Tk.Frame(master, relief=appearance, bd=bd)
+ self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
+ highlightthickness=0, background=background)
+ self.scale=self.canvas.create_rectangle(0, 0, width, height,
+ fill=fillColor)
+ self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
+ height / 2, text=labelText,
+ anchor="c", fill=labelColor)
+ self.update()
+ self.canvas.pack(side='top', fill='x', expand='no')
def update(self):
- # Trim the values to be between min and max
- value=self.value
- if value > self.max:
- value = self.max
- if value < self.min:
- value = self.min
- # Preserve the new value
- c=self.canvas
- # Adjust the rectangle
- if self.orientation == "horizontal":
- c.coords(self.scale,
- 0, 0,
- float(value) / self.max * self.width, self.height)
- else:
- c.coords(self.scale,
- 0, self.height - (float(value) / self.max*self.height),
- self.width, self.height)
- # Now update the colors
- c.itemconfig(self.scale, fill=self.fillColor)
- c.itemconfig(self.label, fill=self.labelColor)
- # And update the label
- if self.autoLabel=="true":
- c.itemconfig(self.label, text=self.labelFormat % value)
- else:
- c.itemconfig(self.label, text=self.labelFormat % self.labelText)
- c.update_idletasks()
+ # Trim the values to be between min and max
+ value=self.value
+ if value > self.max:
+ value = self.max
+ if value < self.min:
+ value = self.min
+ # Preserve the new value
+ c=self.canvas
+ # Adjust the rectangle
+ if self.orientation == "horizontal":
+ c.coords(self.scale,
+ 0, 0,
+ float(value) / self.max * self.width, self.height)
+ else:
+ c.coords(self.scale,
+ 0, self.height - (float(value) / self.max*self.height),
+ self.width, self.height)
+ # Now update the colors
+ c.itemconfig(self.scale, fill=self.fillColor)
+ c.itemconfig(self.label, fill=self.labelColor)
+ # And update the label
+ if self.autoLabel=="true":
+ c.itemconfig(self.label, text=self.labelFormat % value)
+ else:
+ c.itemconfig(self.label, text=self.labelFormat % self.labelText)
+ c.update_idletasks()
class Indicator:
def __init__(self, master=None, width=25, height=25, appearance="sunken",
- onColor="green", offColor="black", onLabelColor="black",
- offLabelColor="green", onLabelText="", offLabelText="",
- on=1, bd=2):
- # preserve various values
- self.master=master
- self.onColor=onColor
- self.offColor=offColor
- self.onLabelColor=onLabelColor
- self.offLabelColor=offLabelColor
- self.onLabelText=onLabelText
- self.offLabelText=offLabelText
- self.on=on
- self.frame=Tk.Frame(master, relief=appearance, bd=bd)
- self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
- highlightthickness=0)
- self.light=self.canvas.create_rectangle(0, 0, width, height,
- fill=onLabelColor)
- self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
- height / 2, text=onLabelText,
- anchor="c", fill=onLabelColor)
- self.update()
- self.canvas.pack(side="top", fill='x', expand='no')
+ onColor="green", offColor="black", onLabelColor="black",
+ offLabelColor="green", onLabelText="", offLabelText="",
+ on=1, bd=2):
+ # preserve various values
+ self.master=master
+ self.onColor=onColor
+ self.offColor=offColor
+ self.onLabelColor=onLabelColor
+ self.offLabelColor=offLabelColor
+ self.onLabelText=onLabelText
+ self.offLabelText=offLabelText
+ self.on=on
+ self.frame=Tk.Frame(master, relief=appearance, bd=bd)
+ self.canvas=Tk.Canvas(self.frame, height=height, width=width, bd=0,
+ highlightthickness=0)
+ self.light=self.canvas.create_rectangle(0, 0, width, height,
+ fill=onLabelColor)
+ self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
+ height / 2, text=onLabelText,
+ anchor="c", fill=onLabelColor)
+ self.update()
+ self.canvas.pack(side="top", fill='x', expand='no')
def update(self):
- c=self.canvas
- # now update the status
- if self.on:
- c.itemconfig(self.light, fill=self.onColor)
- c.itemconfig(self.label, fill=self.onLabelColor)
- c.itemconfig(self.label, text=self.onLabelText)
- else:
- c.itemconfig(self.light, fill=self.offColor)
- c.itemconfig(self.label, fill=self.offLabelColor)
+ c=self.canvas
+ # now update the status
+ if self.on:
+ c.itemconfig(self.light, fill=self.onColor)
+ c.itemconfig(self.label, fill=self.onLabelColor)
+ c.itemconfig(self.label, text=self.onLabelText)
+ else:
+ c.itemconfig(self.light, fill=self.offColor)
+ c.itemconfig(self.label, fill=self.offLabelColor)
c.itemconfig(self.label, text=self.offLabelText)
- c.update_idletasks()
+ c.update_idletasks()
def toggle(self):
- self.on=not self.on
- self.update()
+ self.on=not self.on
+ self.update()
def turnon(self):
- self.on=1
- self.update()
+ self.on=1
+ self.update()
def turnoff(self):
- self.on=0
- self.update()
+ self.on=0
+ self.update()
class Blinker(Indicator):
def __init__(self, master=None, blinkrate=1, enabled=1, width=25,
- height=25, appearance="sunken", onColor="green",
- offColor="black", onLabelColor="black", offLabelColor="green",
- onLabelText="", offLabelText="", on=1, bd=2):
- self.blinkrate=blinkrate
- self.enabled=enabled
- Indicator.__init__(self, master, width=width, height=height,
- appearance=appearance, onColor=onColor,
- offColor=offColor, onLabelColor=onLabelColor,
- offLabelColor=offLabelColor,
- onLabelText=onLabelText,
- offLabelText=offLabelText, on=on, bd=bd)
+ height=25, appearance="sunken", onColor="green",
+ offColor="black", onLabelColor="black", offLabelColor="green",
+ onLabelText="", offLabelText="", on=1, bd=2):
+ self.blinkrate=blinkrate
+ self.enabled=enabled
+ Indicator.__init__(self, master, width=width, height=height,
+ appearance=appearance, onColor=onColor,
+ offColor=offColor, onLabelColor=onLabelColor,
+ offLabelColor=offLabelColor,
+ onLabelText=onLabelText,
+ offLabelText=offLabelText, on=on, bd=bd)
def update(self):
- if self.enabled:
- self.on=not self.on
+ if self.enabled:
+ self.on=not self.on
Indicator.update(self)
- self.frame.after(self.blinkrate * 1000, self.update)
+ self.frame.after(self.blinkrate * 1000, self.update)
def main():
class Test:
- def __init__(self):
- win = Tk.Frame()
- win.master.title("Slider Demo")
- self.progress1=Slider(win, fillColor="red", labelColor="yellow",
- value=0, width=200, height=15,
- appearance="sunken", autoLabel="false",
- labelFormat="%s",
- labelText="Gary.Foster@corp.sun.com",
- orientation="horizontal", bd=3)
- self.progress2=Slider(win, fillColor="blue", labelColor="black",
- background="white", value=250, width=50,
- height=200, appearance="raised", max=250,
- labelFormat="%d", orientation="vertical", bd=4)
- self.progress1.frame.pack()
- self.progress2.frame.pack()
- win.pack()
- self.progress1.frame.after(1000, self.update)
- self.increment1=1
- self.increment2=-1
+ def __init__(self):
+ win = Tk.Frame()
+ win.master.title("Slider Demo")
+ self.progress1=Slider(win, fillColor="red", labelColor="yellow",
+ value=0, width=200, height=15,
+ appearance="sunken", autoLabel="false",
+ labelFormat="%s",
+ labelText="Gary.Foster@corp.sun.com",
+ orientation="horizontal", bd=3)
+ self.progress2=Slider(win, fillColor="blue", labelColor="black",
+ background="white", value=250, width=50,
+ height=200, appearance="raised", max=250,
+ labelFormat="%d", orientation="vertical", bd=4)
+ self.progress1.frame.pack()
+ self.progress2.frame.pack()
+ win.pack()
+ self.progress1.frame.after(1000, self.update)
+ self.increment1=1
+ self.increment2=-1
- def update(self, event=None):
- bar1=self.progress1
- bar2=self.progress2
+ def update(self, event=None):
+ bar1=self.progress1
+ bar2=self.progress2
- bar1.value=bar1.value+self.increment1
- if bar1.value > bar1.max:
- self.increment1=-1
- bar1.fillColor="green"
- bar1.labelColor="red"
- if bar1.value < bar1.min:
- self.increment1=1
- bar1.fillColor="red"
- bar1.labelColor="yellow"
- bar1.update()
- bar1.frame.after(100, self.update)
+ bar1.value=bar1.value+self.increment1
+ if bar1.value > bar1.max:
+ self.increment1=-1
+ bar1.fillColor="green"
+ bar1.labelColor="red"
+ if bar1.value < bar1.min:
+ self.increment1=1
+ bar1.fillColor="red"
+ bar1.labelColor="yellow"
+ bar1.update()
+ bar1.frame.after(100, self.update)
- bar2.value=bar2.value+self.increment2
- if bar2.value > bar2.max:
- self.increment2=-1
- if bar2.value < bar2.min:
- self.increment2=1
- bar2.update()
+ bar2.value=bar2.value+self.increment2
+ if bar2.value > bar2.max:
+ self.increment2=-1
+ if bar2.value < bar2.min:
+ self.increment2=1
+ bar2.update()
t = Test()
Tk.mainloop()
# -*- coding: utf-8 -*-
"""
- $Id: __init__.py,v 1.4 2003/03/06 14:36:11 eficas Exp $
+ $Id: __init__.py,v 1.5 2004/09/10 15:52:08 eficas Exp $
Le package UTILITES contient les fonctions permettant
d'instrumenter un script :
##__all__ = [ "ici" , "message" , "scrute" , "pause" , "appels" ]
try :
- from developpeur import *
+ from developpeur import *
except :
- pass
+ pass
from ici import *
from execute import *
from pause import *
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: appels.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: appels.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
for e in trace[2:-1] :
fic,numero,fonc,inst = e
position=fic+":"+str(numero)+":"
- if len(position)>lmax : lmax=len(position)
+ if len(position)>lmax : lmax=len(position)
lmax += 1 # Pour eloigner les informations du nom du fichier
for e in trace[1:-1] :
return
else :
- APPELS = NULL
+ APPELS = NULL
import os
def hostname() :
- return os.uname()[1]
+ return os.uname()[1]
group_eficas=108
group_salome=107
DEVELOPPEUR=d_dev[ os.getuid() ]
import sys
sortie=sys.stderr
- sortie.write( "import de "+__name__+" : $Id: developpeur.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ sortie.write( "import de "+__name__+" : $Id: developpeur.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
sortie.write( "\n" )
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
if DEVELOPPEUR :
import scrute
import types
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: execute.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: execute.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
developpeur.sortie.flush()
import sys
sortie=sys.stderr
-sortie.write( "import de "+__name__+" : $Id: funcname.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+sortie.write( "import de "+__name__+" : $Id: funcname.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
sortie.write( "\n" )
def get_nombre_de_blancs( str ) :
####print "RECHERCHE de la classe de "+filename+" ligne : ",lineno
if lineno>0 :
try :
- f=open( filename , 'r' )
- except Exception,e :
- print ">>>>",str(e)
- sys.stdout.flush()
- sys.exit(17)
+ f=open( filename , 'r' )
+ except Exception,e :
+ print ">>>>",str(e)
+ sys.stdout.flush()
+ sys.exit(17)
s = f.read()
f.close()
elif re.search( "^class ", line ) != None :
classname = re.sub( "^class *" , "" , line )
classname = re.sub( " *[(:].*$" , "" , classname )
- current_func = ""
+ current_func = ""
elif current_func != "" and re.search( "^[^ \t]", line ) != None :
- current_func = ""
- classname = ""
+ current_func = ""
+ classname = ""
k = k+1
if current_func == "" : current_func="__main__"
return classname ,current_func
def __init__ ( self , *args ) :
- # le premier argument est optionnel (c'est un nom de fonction
+ # le premier argument est optionnel (c'est un nom de fonction
# qu'on peut reconstituer avec le nom du fichier et le numéro de ligne.
k=0
self.name = None
assert(args[k]!=None)
assert(args[k]!="")
- self.filename = args[k] # recuperation du nom du fichier source
+ self.filename = args[k] # recuperation du nom du fichier source
k = k+1
assert(args[k]>0)
- self.lineno = args[k] # recupération du numero de ligne
+ self.lineno = args[k] # recupération du numero de ligne
self.classname,funcname = get_classname( self.filename, self.lineno )
if self.name == None : self.name = funcname
if __name__ == "__main__" :
- print 'FUNCNAME("","funcname.py", 68)='+str(FUNCNAME("","funcname.py", 63) )
- print 'FUNCNAME("funcname.py", 68)='+str(FUNCNAME("funcname.py", 63) )
+ print 'FUNCNAME("","funcname.py", 68)='+str(FUNCNAME("","funcname.py", 63) )
+ print 'FUNCNAME("funcname.py", 68)='+str(FUNCNAME("funcname.py", 63) )
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: ici.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: ici.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
else :
- ICI = NULL
+ ICI = NULL
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: message.py,v 1.2 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: message.py,v 1.3 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: modification.py,v 1.1 2003/03/06 14:36:11 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: modification.py,v 1.2 2004/09/10 15:52:08 eficas Exp $" )
developpeur.sortie.write( "\n" )
import ici
une attente.
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: pause.py,v 1.2 2003/03/06 14:36:12 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: pause.py,v 1.3 2004/09/10 15:52:09 eficas Exp $" )
developpeur.sortie.write( "\n" )
import sys
"""
try :
- from developpeur import DEVELOPPEUR
+ from developpeur import DEVELOPPEUR
except :
- DEVELOPPEUR=None
+ DEVELOPPEUR=None
def NULL( *l_args, **d_args ) : pass
if DEVELOPPEUR :
import developpeur
- developpeur.sortie.write( "import de "+__name__+" : $Id: scrute.py,v 1.2 2003/03/06 14:36:12 eficas Exp $" )
+ developpeur.sortie.write( "import de "+__name__+" : $Id: scrute.py,v 1.3 2004/09/10 15:52:09 eficas Exp $" )
developpeur.sortie.write( "\n" )
import re
import linecache
tables.py:tables.tag
- python Translate.py -force tables.tag
+ python Translate.py -force tables.tag
))
# Sometimes, the user (e.g., me) writes:
- # 'fred' = Table:
+ # 'fred' = Table:
# instead of:
- # 'fred' = Table is:
+ # 'fred' = Table is:
# Unfortunately, without the "is", it would get too confusing whether
# we actually wanted an if block...
t_bad_tableblock = ('tableblock',Table,
))
# Sometimes, the use (e.g., me again) write:
- # 'fred' IsIn jim
+ # 'fred' IsIn jim
# instead of:
- # 'fred' = IsIn jim
+ # 'fred' = IsIn jim
# Whilst I'm not entirely convinced that "=" is the best character
# to use here, I think we do need something!
t_bad_tuple = ('tuple',Table,
left,right = dict["onfalse"]
self.onfalse = self.text[left:right]
else:
- self.onfalse = None # "MatchFail"
+ self.onfalse = None # "MatchFail"
if dict["ontrue"]:
left,right = dict["ontrue"]
self.ontrue = self.text[left:right]
else:
- self.ontrue = None # "next"
+ self.ontrue = None # "next"
def only_in_block(self):
"""Return true if we can only occur inside a block."""
left,right = dict["onfalse"]
self.onfalse = self.text[left:right]
else:
- self.onfalse = None # "MatchFail"
+ self.onfalse = None # "MatchFail"
if dict["ontrue"]:
left,right = dict["ontrue"]
self.ontrue = self.text[left:right]
else:
- self.ontrue = None # "next"
+ self.ontrue = None # "next"
def only_in_block(self):
"""Return true if we can only occur inside a block."""
"SubTable is not allowed outside a block at line %d"%\
(self.lineno)
- self.items = [] # all lines within this block
- self.business = [] # just those that are "our business"
+ self.items = [] # all lines within this block
+ self.business = [] # just those that are "our business"
self.label_dict = {} # remember our labels and their locations
self.next_index = 0 # 'business' line indices
self.inner_indent = None
# commen
# commen
a=3
- # qqqqqqqqqqqqqqqq
+ #qqqqqqqqqqqqqqqqqqqqqqqq
c=5
b=5
xyz=cos(10)
MA=LIRE_MAILLAGE(INFO=1)
MA=LIRE_MAILLAGE(
-INFO=1)
+ NFO=1)
MA=LIRE_MAILLAGE(#comme
-INFO=1)
+ NFO=1)
MA=\
LIRE_MAILLAGE(INFO=1)
MA= LIRE_MAILLAGE()
nom = string.lstrip(n)
if valeur[-1] == '\n': valeur = valeur[:-1]
# valeur = string.strip(valeur)
- ## traitement des "
-# if valeur[0]=='"':
-# valeur=valeur[1:-1]
-# if valeur[-1]=='"':
-# valeur=valeur[0:-2]
+ ## traitement des "
+# if valeur[0]=='"':
+# valeur=valeur[1:-1]
+# if valeur[-1]=='"':
+# valeur=valeur[0:-2]
return n + ' = PARAMETRE(nom=\''+nom+'\',valeur='+valeur+')\n'
#e=ENTITE_JDC(self)
#e.append_text(ligne)
#--> poursuite d'une affectation
- # PN -- pour Empecher une erreur pas propre
- if affectation_courante != None :
+ # PN -- pour Empecher une erreur pas propre
+ if affectation_courante != None :
affectation_courante.append_text(ligne)
#affectation_courante.append_text(ligne)
valeur=valeur+texte[nouvelindice]
nouvelindice=nouvelindice+1
if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
+ nouvelindice=nouvelindice -1
break
if mot in self.appli.liste_simp_reel:
if valeur[0] != "'":
else :
nouvelindice=nouvelindice+1
if nouvelindice == len(texte) :
- nouvelindice=nouvelindice -1
+ nouvelindice=nouvelindice -1
break
if tuple :
valeur=texte[indiceC+1:nouvelindice+1]
