From: eficas <> Date: Mon, 23 Jan 2006 09:18:39 +0000 (+0000) Subject: CCAR : corrections diverses du parseur X-Git-Tag: merge_mars_06~13 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=7ff4b78400ef7405141ff11ff2f9fc2a7bc9c5ff;p=tools%2Feficas.git CCAR : corrections diverses du parseur --- diff --git a/convert/autre_parseur.py b/convert/autre_parseur.py index 74bd9ef1..5f9cf5c9 100644 --- a/convert/autre_parseur.py +++ b/convert/autre_parseur.py @@ -67,7 +67,7 @@ class AFFECTATION(ENTITE_JDC): 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+")" @@ -107,7 +107,8 @@ class PARSEUR_PYTHON: - 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[a-z]+)' r'(\s+(?P[a-zA-Z_]\w*))?' @@ -117,6 +118,7 @@ class PARSEUR_PYTHON: r'(\s+(?P[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 @@ -131,23 +133,30 @@ class PARSEUR_PYTHON: 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): @@ -163,16 +172,16 @@ class PARSEUR_PYTHON: """ 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 @@ -183,7 +192,7 @@ class PARSEUR_PYTHON: 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) @@ -191,20 +200,9 @@ class PARSEUR_PYTHON: 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 @@ -213,33 +211,51 @@ class PARSEUR_PYTHON: 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 @@ -250,21 +266,25 @@ class PARSEUR_PYTHON: 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) @@ -276,21 +296,25 @@ class PARSEUR_PYTHON: 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) @@ -301,10 +325,16 @@ class PARSEUR_PYTHON: 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 @@ -312,36 +342,53 @@ class PARSEUR_PYTHON: # 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 @@ -351,6 +398,7 @@ class PARSEUR_PYTHON: 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 @@ -358,9 +406,11 @@ class PARSEUR_PYTHON: # 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 @@ -376,23 +426,35 @@ class PARSEUR_PYTHON: 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 @@ -401,7 +463,7 @@ class PARSEUR_PYTHON: if __name__ == "__main__" : import sys import cStringIO - text=''' + text=""" # # comment # comment @@ -478,8 +540,6 @@ for k in range(1,10): f=open("coque.geo","w") -''' - text=""" a = 1. b=3 @@ -558,22 +618,282 @@ MA= LIRE_MAILLAGE() 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)