Retourne une expression de l'affectation compréhensible par ACCAS
et exploitable par EFICAS
"""
- t=repr(self.texte)
+ #t=repr(self.texte)
t=self.texte
return "PARAMETRE(nom='"+self.name+"',valeur="+t+")"
- les commandes
"""
# au moins 1 caractère non blanc ou non tabulation
- pattern_ligne_non_blanche = re.compile(r'^[\w\t]+')
+ #pattern_ligne_non_blanche = re.compile(r'^[\w\t]+')
+ pattern_ligne_non_blanche = re.compile(r'[^ \t]+')
kwprog = re.compile(
r'^\s*(?P<kw>[a-z]+)'
r'(\s+(?P<id>[a-zA-Z_]\w*))?'
r'(\s+(?P<id>[a-zA-Z_]\w*))?'
r'[^\w]')
wsprog = re.compile(r'^[ \t]*')
+ optionprog=re.compile(r'#\s*parse:\s*([^\n\'"]*)$')
def __init__(self,texte):
# on verifie que le texte fourni se compile correctement
self.indentation=0
self.paren_level=0
self.affectation=0
- for i in range(5):
- self.indent_list.append(' '*i)
+ self.indent_list=[""]
self.objet_courant=None
- self.stack=[]
+ self.affectation_flag=1
+ self.comment_flag=1
+ self.buffer=[]
+ self.buffer_indent=""
+
+ def getoptions(self):
+ m= self.optionprog.match(self.line)
+ if m:
+ option=m.group(1)
+ name=option[1:]
+ flag=(option[0] == '+')
+ if name == "affectation": self.affectation_flag=flag
+ if name == "comment": self.comment_flag=flag
+ if name == "all":
+ self.comment_flag=flag
+ self.affectation_flag=flag
def readline(self):
self.line= self.texte.readline()
#print "line:",self.line
- self.indentation=len(self.stack)
- m = self.kwprog.match(self.line)
- if m:
- kw = m.group('kw')
- if kw in start:
- self.stack.append((kw, kw))
- elif next.has_key(kw) and self.stack:
- kwa,kwb=self.stack[-1]
- self.stack.append((kwa, kw))
+ # option ?
+ self.getoptions()
return self.line
def get_texte(self,appli=None):
"""
ttype, tstring, spos, epos, line = tk
thisrow, thiscol = spos
- #print spos, epos,tokenize.tok_name[ttype]
+ #print spos, epos,tokenize.tok_name[ttype],self.lastrow, self.lastcol
if thisrow > self.lastrow:
# si plusieurs lignes (>1)
self.out=self.out+"\n" * (thisrow - self.lastrow - 1)
self.lastcol = 0
- #if thiscol > self.lastcol :
- # self.out=self.out+ " " * (thiscol - self.lastcol)
- # self.please_indent = None
+# if thiscol > self.lastcol :
+# self.out=self.out+ " " * (thiscol - self.lastcol)
+# self.please_indent = None
self.thiscol=thiscol
#self.nextrow, self.nextcol = epos
print >>sys.stderr, "No match!", tokenize.tok_name[ttype], tstring
return
- if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and ttype != tokenize.COMMENT and self.please_indent:
+ if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
self.do_indent()
fn(tstring)
def output(self,tstring):
#print "output",tstring
- #if self.thiscol > self.lastcol :
- # self.out=self.out+ " " * (self.thiscol - self.lastcol)
- # self.please_indent = None
- #self.thiscol=0
- #self.lastrow, self.lastcol=self.nextrow, self.nextcol
- if self.objet_courant:
- #print str(self.objet_courant)
- self.out=self.out+self.indent_list[self.indentation]
- self.out= self.out+ str(self.objet_courant)
- self.objet_courant=None
- self.lastcol=self.thiscol
if self.thiscol > self.lastcol :
- # print self.thiscol,self.lastcol
+ #print self.thiscol,self.lastcol
self.out=self.out+ " " * (self.thiscol - self.lastcol)
self.lastcol=self.thiscol
def output_com(self,tstring):
self.out=self.out+tstring
+ def update_indent(self):
+ #print "update_indent",len(self.indent_list[-1]),len(self.buffer_indent)
+ if len(self.indent_list[-1]) > len(self.buffer_indent):
+ self.out=self.out+(len(self.indent_list[-1]) - len(self.buffer_indent))*" "
+ self.buffer_indent=self.indent_list[-1]
+
def do_indent(self):
- #print "indentation=",self.indentation
- if self.objet_courant:
- self.out=self.out+self.indent_list[self.indentation]
- #self.out=self.out+self.indent_list[-1]
- self.out= self.out+ str(self.objet_courant)
- self.objet_courant=None
+ #print "indentation dans do_indent",len(self.indent_list)
- #self.lastcol=len(self.indent_list[-1])
- #self.lastcol=self.indentation
- self.lastcol=self.thiscol
- self.out=self.out+self.indent_list[self.indentation]
- #self.out=self.out+self.indent_list[-1]
+ self.out=self.out+self.indent_list[-1]
+ self.buffer_indent=self.indent_list[-1]
+ if self.lastcol+len(self.indent_list[-1]) > self.thiscol:
+ self.lastcol=self.thiscol
+ else:
+ self.lastcol=self.lastcol+len(self.indent_list[-1])
self.please_indent = None
+ def flush_buffer(self):
+ #if self.buffer:
+ # print len(self.indent_list),self.please_indent
+ for ob in self.buffer:
+ self.out= self.out+ str(ob)
+ self.do_indent()
+ self.buffer=[]
+ self.objet_courant=None
+
def NL(self, tstring):
if self.affectation:
if self.paren_level == 0:
# affectation en cours mais complète
self.out= self.out+ str(self.affectation_courante)
self.affectation_courante=None
+ self.please_indent=1
self.affectation=0
else:
# affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
return
+ if self.objet_courant:
+ self.objet_courant=None
+ self.buffer.append(tstring)
+ # self.please_indent = None
+ return
self.output(tstring)
self.please_indent = 1
before,after=liste
if self.affectation:
# affectation en cours, on ignore
- #self.affectation_courante.append_text(tstring)
pass
elif self.paren_level > 0:
self.output(tstring)
- elif not self.pattern_ligne_non_blanche.match(before):
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(before):
# il s'agit d'une commande commentarisée
if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
self.objet_courant.append_text(tstring)
+ self.please_indent = None
elif isinstance(self.objet_courant,COMMENTAIRE):
- self.output_com(str(self.objet_courant))
self.objet_courant=COMMANDE_COMMENTARISEE()
+ self.buffer.append(self.objet_courant)
self.objet_courant.append_text(tstring)
+ self.please_indent = None
else:
self.objet_courant.append_text(tstring)
+ self.please_indent = None
else:
# commentaire inline
self.output(tstring)
new_line = string.split(self.line,'#')[0]
if self.affectation:
# affectation en cours, on ignore
- #self.affectation_courante.append_text(tstring)
pass
elif self.paren_level > 0:
self.output(tstring)
- elif not self.pattern_ligne_non_blanche.match(new_line):
+ elif self.comment_flag and not self.pattern_ligne_non_blanche.search(new_line):
# commentaire précédé de blancs
if self.objet_courant == None:
+ if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
self.objet_courant.append_text(tstring)
+ self.please_indent = None
elif isinstance(self.objet_courant,COMMANDE_COMMENTARISEE):
- self.output_com(str(self.objet_courant))
self.objet_courant=COMMENTAIRE()
+ self.buffer.append(self.objet_courant)
self.objet_courant.append_text(tstring)
+ self.please_indent = None
else:
self.objet_courant.append_text(tstring)
+ self.please_indent = None
else:
# commentaire inline
self.output(tstring)
print "ERRORTOKEN",tstring
def NAME(self, tstring):
+ if self.buffer:
+ self.update_indent()
+ self.flush_buffer()
+
if self.affectation ==1:
- # on ne veut pas des expressions qui commencent par NAME=NAME(NAME
+ # on a une expression du type NAME=NAME
+ # on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
# on en prend le chemin : on met affectation a 3 pour le signaler
# on attend d'en savoir plus
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=3
return
# on a une expression qui commence par NAME=NAME(NAME
# il s'agit tres probablement d'une commande
# on annule l'affectation en cours
- self.out= self.out+ self.affectation_courante.texte
- self.affectation_courante=None
- self.affectation=0
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.append_text(tstring)
+ self.affectation=5
+ return
elif self.affectation == 2:
# affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=2
return
self.affectation=0
self.name=None
- if self.paren_level == 0: self.name=tstring
+ if self.paren_level == 0 and self.affectation_flag:
+ # si on est en dehors de parentheses et en mode transformation d'affectation
+ # on initialise l'attribut name qui indique une affectation en cours
+ self.name=tstring
self.output(tstring)
def ident(self, tstring):
+ self.flush_buffer()
self.affectation=0
self.output(tstring)
def NUMBER(self, tstring):
+ self.flush_buffer()
if self.affectation>=1:
# affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=2
return
self.output(tstring)
def OP(self,tstring):
+ self.flush_buffer()
if tstring in ('(','[','{'): self.paren_level=self.paren_level+1
if tstring in (')',']','}'): self.paren_level=self.paren_level-1
- if tstring == ')' and self.affectation ==4:
+ if tstring == '=' and self.affectation ==5:
+ # on a une expression qui commence par NAME=NAME(NAME=)
+ # il peut s'agir d'une commande
+ # on annule l'affectation en cours
+ self.out= self.out+ self.affectation_courante.texte
+ self.affectation_courante=None
+ self.name=None
+ self.affectation=0
+ elif tstring == ')' and self.affectation ==4:
# on a une expression qui commence par NAME=NAME()
# il peut s'agir d'une commande
# on annule l'affectation en cours
elif tstring == '(' and self.affectation == 3:
# on a deja trouve NAME=NAME
# on passe affectation a 4
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=4
return
# l'affectation est terminee
self.out= self.out+ str(self.affectation_courante)
self.affectation_courante=None
+ self.please_indent=1
self.affectation=0
elif self.affectation>=1:
# on complete l'affectation
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=2
return
NEWLINE=NL
def INDENT(self, tstring):
-# self.indent_list.append(tstring)
+ #tstring=str(len(self.indent_list))*len(tstring)
+ self.indent_list.append(tstring)
+ #print "indentation dans INDENT",len(self.indent_list),len(tstring)
self.affectation=0
- self.do_indent()
+ if self.buffer:
+ self.update_indent()
+ self.flush_buffer()
def DEDENT(self, tstring):
- self.affectation=0
- if self.objet_courant:
- self.out=self.out+self.indent_list[self.indentation]
- self.out= self.out+ str(self.objet_courant)
+ #print "DEDENT",tstring,len(tstring)
+ if self.buffer:
+ self.out= self.out+ str(self.buffer[0])
+ if len(self.buffer) > 1:
+ for ob in self.buffer[1:]:
+ self.do_indent()
+ self.out= self.out+ str(ob)
+ self.buffer=[]
self.objet_courant=None
- del self.stack[0]
- self.indentation=self.indentation-1
-# self.indent_list = self.indent_list[:-1]
+ self.please_indent=1
+
+ self.affectation=0
+ self.indent_list = self.indent_list[:-1]
+ #print "indentation dans DEDENT",len(self.indent_list)
def STRING(self, tstring):
+ self.flush_buffer()
if self.affectation>=1:
# affectation en cours, on ajoute
+ if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
self.affectation_courante.append_text(tstring)
self.affectation=2
return
if __name__ == "__main__" :
import sys
import cStringIO
- text='''
+ text="""
#
# comment
# comment
f=open("coque.geo","w")
-'''
- text="""
a = 1.
b=3
TFIN = 1.790 # Temps fin pour le calcul
PAS = 0.001 # pas de temps du calcul
+# parse: -affectation
DS1=[None]*5
DS2=[None]*5
DS3=[None]*5
DS4=[None]*5
CHS1=[None]*5
CHS2=[None]*5
-
-
+MO=AFFE_MODELE( MAILLAGE=MA,
+ #test de validateur GEOM (typ=grma) avec grma derive de GEOM
+ AFFE=(_F(GROUP_MA = ('LI1'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'DIS_TR'),
+ ),
+ INFO=2,);
for k in range(1,5):
DS1[k] = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_DEPL_R',
RESULTAT= MODESTA1, NUME_ORDRE=k, NOM_CHAM = 'DEPL');
+if x==1:
+ print "coucou"
+elif x==2:
+ print "coucou"
+elif x==2:
+ print "coucou"
+elif x==2:
+ print "coucou"
+else:
+ print "coucou"
+# parse: +affectation
+ff=23 # parametre bidon
-"""
+# parse: -all
+a=45
+#commment1
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +all
+b=45
+#commment2
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: -comment
+c=45
+#commment3
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+# parse: +comment
+d=45
+#commment5
+##toto = FORMULE(REEL='(REEL:A) = A',
+## X=2
+## );
+p=sin(ff)
+e=toto(a=1)
+e=toto(a=1,b=3)
+e=toto(1,b=3)
+e=toto(a,b=3)
+e=toto()
+sensible=[2.1E11, 0.3, 1.E-6, 1.E-6, ]
+
+n=len(sensible)
+# parse: -affectation
+
+PS=[None]*n
+
+for i in range(n):
+ PS[i]=DEFI_PARA_SENSI(VALE=sensible[i])
+# parse: +affectation
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ )#
+#
+FIN()
+#
+
+TEST_RESU(RESU=(_F(RESULTAT = U3L,
+ INST = 1.0,
+ NOM_CHAM = 'DEPL',
+ GROUP_NO = 'PPA',
+ NOM_CMP = 'DX',
+ VALE = 2.86E-5,
+ PRECISION = 5.E-2,
+ REFERENCE = 'AUTRE_ASTER',
+ VERSION = '7.1.11',
+ ),
+ )
+ ) #a
+
+titi = FORMULE(REEL='(REEL:A) = A',
+) # commentaire inline
+titi = FORMULE(REEL='(REEL:A) = A',
+ ) # commentaire inline
+
+def f(x):return x
+#comment
+def f(x):
+#comment
+ if a==1:print "coucou"
+ for i in range(10): s=0
+
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+ if w==4:
+#comm
+
+ if k:
+
+#comm
+ if g:
+
+#comm
+
+ if t:
+ a=5
+#comm
+if 1:
+ a=2
+ b=3
+ # commenta
+else:
+ # commen
+ # commen
+ a=3
+ # qqqqqqqqqqqqqqqq
+ c=5
+
+b=5
+
+if 1:
+ a=2
+ # commenta
+else:
+ a=3
+if 1:
+ if 2:
+ if 3:
+ a=1
+ elif 4:
+ b=1
+ else:
+ c=5
+ elif 3:
+ x=1
+ else:
+ y=4
+elif 4:
+ s=1
+else:
+ t=9
+#com1
+#com2
+
+#com3
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+a=1
+##commendcomm
+for k in range(1,10):
+
+ # Appel a GMSH pour le maillage
+
+ f=open("coque.geo","w")
+#comm
+
+ if a==1:
+
+ #comm
+
+ for i in x:
+#comm
+##commendcomm
+#comm
+##commendcomm
+#comm
+ if x==3:
+#comm
+ r=1
+
+ if 1:
+ if 2:
+ if 3:
+ a=1
+ else:
+ a=6
+
+if 1:
+ if 2:
+ if 3:
+ r=1
+ # comm
+ else:
+ x=7
+ toto(a=1,
+b=3)
+SUP_=dict([(grand,0.) for grand in grand_obs])
+
+for k in range(1,ns+1):
+ x=toto(a=1,b=2)
+# comm
+ if 1:
+ #com
+
+ #com
+ x=1
+ #com
+
+ #com
+ ##com
+ elif 3:
+ ##com
+ x=1
+ else:
+ y=3
+
+def f():
+ return
+########################################################################
+
+########################################################################
+# macro commande de post-traitement (ex POST_GOUJ2E)
+# calcul des reactions cumulees suivant les filets
+
+def POST_GOUJ_ops(self,TABLE):
+ ier=0
+
+"""
if len(sys.argv)== 2:
progname, input = sys.argv
f=open(input)
