try:
fn = getattr(self, tokenize.tok_name[ttype])
except AttributeError:
- print >>sys.stderr, "No match!", tokenize.tok_name[ttype], tstring
+ print( "No match!", tokenize.tok_name[ttype], tstring)
return
if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
return
def ERRORTOKEN(self, tstring):
- print "ERRORTOKEN", tstring
+ print ("ERRORTOKEN", tstring)
def NAME(self, tstring):
if self.buffer:
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
#comment
def f(x):
#comment
- if a==1:print "coucou"
for i in range(10): s=0
#com1
else:
t=text
txt = PARSEUR_PYTHON(t).get_texte()
- print txt
+ print (txt)
compile(txt,"<string>",'exec')
m=pattern_ligne.match(finLigne)
if m == None :
- #print "________________________________________________"
- print 'pb avec ****', finLigne , '**** dans ', ligne
- #print "________________________________________________"
+ #print( "________________________________________________")
+ print ('pb avec ****', finLigne , '**** dans ', ligne)
+ #print( "________________________________________________")
break
simpCas=self.traiteIdent(m.group('ident'))
elif pattern_texteSimple.match(finLigne):
m=pattern_texteSimple.match(finLigne)
else :
- #print "________________________________________________"
- print 'pb avec ****', finLigne , '**** dans ', ligne
- print "non match"
- #print "________________________________________________"
+ #print ("________________________________________________")
+ print ('pb avec ****', finLigne , '**** dans ', ligne)
+ print ("non match")
+ #print ("________________________________________________")
break
finLigne=m.group('reste')
self.dictSimp[simpCas]=valeur
- #print self.dictSimp
if 'TITLE' not in self.dictSimp.keys() :
import os
for simp in self.dictSimp.keys():
if simp in ListeSupprimeCasToEficas: continue
if simp not in self.dicoInverse.keys() :
- #print "************"
- print "pb avec dans dicoInverse", simp,'------'
- #print "************"
- #print poum
+ #print ( "************")
+ print ("pb avec dans dicoInverse", simp,'------')
+ #print ("************")
continue
listeGenea=self.dicoInverse[simp]
listeGeneaReverse=[]
listeGeneaReverse.reverse()
dicoTravail=dicoParMC
i=0
- #print (listeGeneaReverse[0:-1])
while i < len(listeGeneaReverse[0:-1]) :
mot=listeGeneaReverse[i]
i=i+1
dicoTravail[simp]=self.dictSimp[simp]
self.textePy=""
- #print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
- #print dicoParMC
- #print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
listeMC=self.tri(dicoParMC.keys())
for k in listeMC :
- #print "----------- traitement de " , k
self.textePy += str(k )+ "("
self.traiteMC(dicoParMC[k])
self.textePy += ");\n"
- #print "----------- "
appli.listeTelemac=self.dictSimp.keys()
# enleve les espaces de part et autre
# traduit du langage Telemac vers le langage Catalogue
#----------------------------------------
- #print ident
while ident[-1] == " " or ident[-1] == '\t' : ident=ident[0:-1]
while ident[0] == " " or ident[0] == '\t' : ident=ident[1:]
try : identCata=self.dicoCasToCata[ident]
except :
- print "---> ", "pb mot clef pour", ident
+ print ( "---> ", "pb mot clef pour", ident)
identCata=None
return identCata
if isinstance(obj,A_FACT.FACT): self.convertFACT(obj,kA,valeur)
elif isinstance(obj,A_BLOC.BLOC): self.convertBLOC(obj,kA,valeur)
elif isinstance(obj,A_SIMP.SIMP): self.convertSIMP(obj,kA,valeur)
- else : print "%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%"
+ else : print ("%%%%%%%%%%%\n", "pb conversion type pour", k, obj, "\n%%%%%%%%%%%")
- #print "_____________"
def convertFACT(self,obj,nom,valeur):
- #print "convertFACT", nom,valeur
if nom in TELEMACParser.__dict__.keys() :
apply(TELEMACParser.__dict__[nom],(self,))
return
def convertBLOC(self,obj,nom,valeur):
- print "BLOC "
- print nom
+ print ("ANOMALIE _________ BLOC ")
+ print (nom)
def convertSIMP(self,obj,nom,valeur):
#print 'in convertSIMP', nom,valeur
break
except:
if valeur != None :
- print "pb avec le type de ", obj.nom, obj.type, 'et la valeur ', valeur
+ print ("pb avec le type de ", obj.nom, obj.type, 'et la valeur ', valeur)
if 'Fichier' in obj.type or 'TXM' in obj.type or 'Repertoire' in obj.type :
valeur=str(valeur)
try : v=eval(v,{})
except : pass
if nom in TelemacdicoEn.keys():
- #print "est dans le dico des enum, valeurs multiples"
try : v=TelemacdicoEn[nom][v]
except : pass
newVal.append(v)
def tri(self, listeIn):
if len(listeIn) == 1 : return listeIn
if self.Ordre_Des_Commandes == None : return listeIn
- #print listeIn
listeOut=[listeIn[0],]
for k in listeIn[1:]:
#k=str(self.dicoFrancaisAnglais[kF])
return listeOut
def LIQUID_BOUNDARIES(self):
- print 'Liquid Boundaries'
texte_Boundaries="LIQUID_BOUNDARIES=( "
if 'PRESCRIBED_ELEVATIONS' in self.dictSimp.keys():
valeursPE=self.dictSimp["PRESCRIBED_ELEVATIONS"]
if valeursPF == None : valeursPF = listNulle
if valeursPV == None : valeursPV = listNulle
- #print valeursPE,valeursPF,valeursPV
for e in range(len(valeursPE)):
if valeursPE[e] != "" or valeursPE[e] != "\n" :
texte_Boundaries += "_F( BOUNDARY_TYPE= 'Prescribed Velocity',\n"
texte_Boundaries += "PRESCRIBED_VELOCITIES = " + str(valeursPV[e]) + "),\n"
continue
- print "pb texte_Boundaries avec la valeur numero ", e
+ print ("pb texte_Boundaries avec la valeur numero ", e)
texte_Boundaries +="),\n"
self.textePy += texte_Boundaries
def readfile(self,filename):
try:
self.read(filename)
- except Exception,e:
+ except Exception as e:
self.cr.fatal(tr("lecture du fichier impossible :")+str(e))
def convert(self,outformat,appli=None):
elif outformat == 'dict':
return self.getdict()
else:
- raise ExceptionException("Format de sortie : %s, non supporte", outformat)
+ raise Exception("Format de sortie : %s, non supporte", outformat)
def getdicttext(self):
au format python pour EFICAS.
Un plugin convertisseur doit fournir deux attributs de classe :
- extensions et formats et deux méthodes : readfile,convert.
+ extensions et formats et deux methodes : readfile,convert.
L'attribut de classe extensions est une liste d'extensions
- de fichiers préconisées pour ce type de format. Cette information
+ de fichiers preconisees pour ce type de format. Cette information
est seulement indicative.
L'attribut de classe formats est une liste de formats de sortie
- supportés par le convertisseur. Les formats possibles sont :
+ supportes par le convertisseur. Les formats possibles sont :
eval, dict ou exec.
- Le format eval est un texte source Python qui peut etre evalué. Le
- résultat de l'évaluation est un objet Python quelconque.
+ Le format eval est un texte source Python qui peut etre evalue. Le
+ resultat de l'evaluation est un objet Python quelconque.
Le format dict est un dictionnaire Python.
- Le format exec est un texte source Python qui peut etre executé.
+ Le format exec est un texte source Python qui peut etre execute.
- La méthode readfile a pour fonction de lire un fichier dont le
- nom est passé en argument de la fonction.
+ La methode readfile a pour fonction de lire un fichier dont le
+ nom est passe en argument de la fonction.
- convertisseur.readfile(nom_fichier)
- La méthode convert a pour fonction de convertir le fichier
- préalablement lu dans un objet du format passé en argument.
+ La methode convert a pour fonction de convertir le fichier
+ prealablement lu dans un objet du format passe en argument.
- objet=convertisseur.convert(outformat)
Ce convertisseur supporte le format de sortie dict
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'pyth',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : PythParser,
}
et retourne le texte au format outformat avec la
methode convertisseur.convert(outformat)
- Ses caractéristiques principales sont exposées dans 2 attributs
+ Ses caracteristiques principales sont exposees dans 2 attributs
de classe :
- - extensions : qui donne une liste d'extensions de fichier préconisées
- - formats : qui donne une liste de formats de sortie supportés
+ - extensions : qui donne une liste d'extensions de fichier preconisees
+ - formats : qui donne une liste de formats de sortie supportes
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.pyth',)
- # Les formats de sortie supportés (eval dict ou exec)
+ # Les formats de sortie supportes (eval dict ou exec)
formats=('dict',)
def __init__(self,cr=None):
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2013 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import sys,string,re
-import traceback
-from Extensions.i18n import tr
-import Accas
-
-# mot cles a traiter : Discretisations_In_Space
-from enumTelemac import dicoEnum
-
-escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
-stringsAndCommentsRE = \
- re.compile(u"(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|\'[^\']*\'|#.*?\n)", re.DOTALL)
-allchars = string.maketrans(u"", "")
-allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
-allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
-
-ordreEtapes=('INITIALIZATION', 'TIDE_PARAMETERS', 'INITIAL_STATE', 'NUMERICAL_PARAMETERS', 'PHYSICAL_PARAMETERS',)
-
-def maskStringsAndComments(src):
- """Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
- quotes et guillemets.
- Le masquage est realise en remplacant les caracteres par des *
- Attention : cette fonction doit etre utilisee sur un texte complet et pas ligne par ligne
- """
- src = escapedQuotesRE.sub(u"**", src)
- allstrings = stringsAndCommentsRE.split(src)
- # every odd element is a string or comment
- for i in xrange(1, len(allstrings), 2):
- if allstrings[i].startswith(u"'''")or allstrings[i].startswith('"""'):
- allstrings[i] = allstrings[i][:3]+ \
- allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \
- allstrings[i][-3:]
- else:
- allstrings[i] = allstrings[i][0]+ \
- allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \
- allstrings[i][-1]
-
- return "".join(allstrings)
-
-
-implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}'))
-linecontinueRE = re.compile(r"\\\s*(#.*)?$")
-emptyHangingBraces = [0,0,0,0,0]
-
-class ParserException(Exception): pass
-class FatalError(Exception): pass
-
-# ligne commençant par /
-pattern_commentaireTelemac = re.compile(r"^\s*/.*")
-# ligne commençant par &
-pattern_eperluetteTelemac = re.compile(r"^&.*")
-#commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_2comments = re.compile(r"^\s*##.*")
-#commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
-pattern_comment = re.compile(r"^\s*#.*")
-#fin de ligne ; suivi d'un nombre quelconque de blancs (pas multiligne)
-pattern_fin = re.compile(r"; *$")
-#pattern pour supprimer les blancs, tabulations et fins de ligne
-pattern_blancs = re.compile(r"[ \t\r\f\v]")
-#pattern_blancs = re.compile(r"[\s\n]")
-number_kw_pattern=re.compile(r"""
-(
- #groupe nombre decimal
- (?:
- #signe : on ignore le signe +
- [-]?
- #groupe (avec ?: n'apparait pas en tant que groupe dans le resultat)
- (?:
- #mantisse forme entiere.fractionnaire
- \d+(?:\.\d*)?
- |
- #ou forme .fractionnaire
- \.\d+
- )
- (?:[eE][+-]?\d+)?
- )
- |
- #argument keyword
- [a-zA-Z_]\w*=
-)
-""",re.VERBOSE|re.MULTILINE)
-
-def construit_genea(texte,liste_mc):
- """
- Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
-
- Realise un filtrage sur les reels :
-
- - Ne garde que les reels pour lesquels str ne donne pas une bonne representation.
- - Ne garde que les reels derriere un argument keyword dont le nom est dans liste_mc
-
- >>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
- ... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
- ... h=_F(x=34.6,y=-1)'''
- >>> construit_genea(s,['a','x'])
- {0.000213: '21.3e-5'}
- """
- d={}
- mot=""
- #on masque les strings et commentaires pour ne pas identifier de faux reels
- for m in number_kw_pattern.findall(maskStringsAndComments(texte)):
- if m[-1] == '=':
- #argument keyword
- mot=m[:-1]
- else:
- if mot not in liste_mc:continue
- #valeur
- key=eval(m)
- if str(key) != m: d[key]=m
- return d
-
-
-ListeMCAExclure=("Computation_Continued",)
-DicoMCAExclureSiValeur={"Computation_Continued" : "NO"}
-ListeMCARecalculer=('tt',)
-DicoMCARecalculerSiValeur={"Computation_Continued" : "YES"}
-DicoMCAReformater = {"Variables_For_Graphic_Printouts": "texteEnListe", \
- "Solver" : "remplaceEnum" }
-DicoPlusieursMC = {"Type_Of_Advection": "decoupeAdvection" ,\
- }
-
-class PARSEUR_CAS:
-
-
- pattern_ligne_vide = re.compile(r'^[\t\r\f\v\n]+')
-
- def __init__(self,texte):
- self.texte = texte
- self.l_objets=None
- self.appli=None
-
- def get_texte(self,appli=None):
- """
- Retourne le texte issu de l'analyse
- """
- self.appli=appli
- self.dicoInverse=self.appli.readercata.dicoInverse
-
- try:
- self.analyse()
- txt=self.texteComm
- except ParserException:
- #Impossible de convertir le texte, on le retourne tel que
- txt=self.texte
- return txt
-
- def analyse(self):
- """
- Eclate la chaine self.texte en self.l_objets une liste lignes d'instructions
- et de commentaires (parmi lesquels des instructions "commentarisées").
- """
- l_lignes = string.split(self.texte,'\n')
- affectation_courante = None
- self.l_objets = []
-
- #Masquage des commentaires et strings multilignes
- #srcMasked=maskStringsAndComments('\n'.join(l_lignes))
- #print srcMasked
- #masked_lines=srcMasked.split('\n')
-
- lineno=0
- self.listeNomValeur=[]
- for ligne in l_lignes :
- #line=masked_lines[lineno]
- lineno=lineno+1
-
- if string.strip(ligne) == '': continue
- if pattern_commentaireTelemac.match(ligne) : continue
- if pattern_eperluetteTelemac.match(ligne) : continue
- # On remplace les : par un =
- # On s assure que les = soient entoures d espace
- # On remplace les espaces successifs par un seul
- # On enleve les blancs en debut et fin de ligne
- # On remplace les ' ; ' par des ;
- ligne=ligne.replace(':','=')
- ligne=ligne.replace('=',' = ')
- ligne=re.sub(r';\s*',';',ligne)
- ligne=re.sub(r'\s*;',';',ligne)
- ligne=re.sub(r' \s*',' ',ligne)
- ligne=re.sub(r'^\s','',ligne)
- ligne=re.sub(r'\s$','',ligne)
- listeMot=ligne.split(" ")
- while listeMot != [] :
- nom,listeMot = self.construitNom(listeMot)
- valeur,listeMot = self.construitValeur(listeMot)
- bTraite, nom, valeur =self.verifieNom(nom,valeur)
- if bTraite : self.listeNomValeur.append((nom, valeur))
- self.construitTexteFinal()
-
-
- def construitNom(self,liste):
- nomEficas=''
- index=0
- for mot in liste :
- index+=1
- if mot in (":","=") : break
- motE=mot[0].upper()+mot[1:].lower()
- nomEficas+=motE+'_'
- nouveauNom=nomEficas[0:-1].replace('-','_')
- nouvelleListe=liste[index:]
- return nouveauNom,nouvelleListe
-
- def construitValeur(self,liste):
- index=0
- if liste[0][0]=="'" :
- valeur=''
- for mot in liste :
- index+=1
- valeur+=str(mot)+" "
- if mot[-1]=="'":
- valeur=valeur[0:-1]
- break
- elif liste[0].find(';') > -1 :
- valeur=liste[0].split(';')
- index=1
- else :
- valeur=liste[0]
- index=1
- nouvelleListe=liste[index:]
- return valeur,nouvelleListe
-
-
- def verifieNom(self,nom,valeur):
- if nom in ListeMCAExclure : return (False, nom, valeur)
- if nom in DicoMCAExclureSiValeur.keys() :
- if valeur != DicoMCAExclureSiValeur[nom] : print "prevoir Traitement pour ", nom, valeur
- return (False, nom, valeur)
-
- bTrue=True
- if nom in DicoMCAReformater.keys() :
- bTrue,nom,valeur=apply(PARSEUR_CAS.__dict__[DicoMCAReformater[nom]],(self,nom,valeur))
- if nom in DicoPlusieursMC.keys() :
- bTrue,nom,valeur=apply(PARSEUR_CAS.__dict__[DicoPlusieursMC[nom]],(self,nom,valeur))
- return (bTrue,nom,valeur)
- if nom not in self.dicoInverse.keys() :
- print "******** ", nom, " non encore connu ***********"
- bTrue=False
- return (bTrue, nom, valeur)
-
- def remplaceEnum(self,nom,valeur):
- newValeur=dicoEnum[nom][valeur]
- return (True,nom,newValeur)
-
-
-
- def texteEnListe(self,nom,valeur):
- print "je passe dans decoupeEnListe pour ", nom,valeur
- v1=re.sub(r'^\'','',valeur)
- v2=re.sub(r'\'$','',v1)
- newValeur=v2.split(',')
- return (True,nom,newValeur)
-
- def decoupeAdvection(self,nom,valeur):
- # on met a jour la liste des valeurs ici : il y a plusieurs MC calcule
- print "je passe dans decoupeAdvection pour",nom,valeur
- self.listeNomValeur.append(('Advection_Of_U_And_V',True))
- v=dicoEnum['Type_Of_Advection'][valeur[0]]
- self.listeNomValeur.append(('Type_Of_Advection_U_And_V',v) )
- if len(valeur)==1: return (False,nom,valeur)
-
- self.listeNomValeur.append(('Advection_Of_H',True))
- v=dicoEnum['Type_Of_Advection'][valeur[1]]
- self.listeNomValeur.append(('Type_Of_Advection_H',v))
- if len(valeur)==2: return (False,nom,valeur)
-
- self.listeNomValeur.append(('Advection_Of_Tracers',True))
- v=dicoEnum['Type_Of_Advection'][valeur[2]]
- self.listeNomValeur.append(('Type_Of_Advection_Tracers',v))
- if len(valeur)==3: return (False,nom,valeur)
-
- self.listeNomValeur.append(('Advection_Of_K_And_Epsilon',True))
- v=dicoEnum['Type_Of_Advection'][valeur[3]]
- self.listeNomValeur.append(('Type_Of_Advection_K_And_Epsilon',v))
- # on retourne False, l append est deja fait
- return (False,nom,valeur)
-
- def construitTexteFinal(self):
- self.dicoTexte={}
- self.dicoNature={}
- print self.listeNomValeur
- for nomMC,valeur in self.listeNomValeur:
- mc,objmc=self.dicoInverse[nomMC][0]
- if nomMC=="Solver_Option" : print self.dicoInverse[nomMC][0]
- self.dicoNature[mc]=objmc
- liste=self.dicoInverse[nomMC][1:]
- liste.reverse()
- dico=self.dicoTexte
- for (nom,obj) in liste:
- if isinstance(obj,Accas.A_BLOC.BLOC) :
- continue
- self.dicoNature[nom]=obj
- if not(isinstance(obj,Accas.A_PROC.PROC)) and not(isinstance(obj,Accas.A_FACT.FACT)) :
- print "******** ", nom,obj, "********"
- continue
- if not nom in dico.keys(): dico[nom]={}
- dico=dico[nom]
- dico[nomMC]=valeur
- self.texteComm=""
- for etape in ordreEtapes :
- print etape
- if etape in self.dicoTexte.keys():
- self.texteComm+=etape+"("
- self.traiteEtape(self.dicoTexte[etape])
- self.texteComm+=");\n"
- print self.texteComm
-
- def traiteEtape(self,dico):
- for mc in dico.keys() :
- valeur=dico[mc]
- if isinstance(self.dicoNature[mc],Accas.A_SIMP.SIMP):
- if 'TXM' in self.dicoNature[mc].type and valeur[0] !="'" : valeur="'"+valeur
- if 'TXM' in self.dicoNature[mc].type and valeur[-1] !="'" : valeur=valeur+"'"
- if 'Fichier' in self.dicoNature[mc].type and valeur[0] !="'" : valeur="'"+valeur
- if 'Fichier' in self.dicoNature[mc].type and valeur[-1] !="'" : valeur=valeur+"'"
- if 'Repertoire' in self.dicoNature[mc].type and valeur[0] !="'" : valeur="'"+valeur
- if 'Repertoire' in self.dicoNature[mc].type and valeur[-1] !="'" : valeur=valeur+"'"
- print self.dicoNature[mc].type
- #self.texteComm+=mc+" = '"+str(valeur)+"',"
- #else : self.texteComm+=mc+" = "+str(valeur)+","
- self.texteComm+=mc+" = "+str(valeur)+","
- continue
- self.texteComm+=mc+"=_F("
- self.traiteEtape(valeur)
- self.texteComm+="),\n"
# allcharsExceptNewlineTranstable = dict((ord(char), u'*') for char in allcharsExceptNewline)#
#else :
# allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
-# print 'Plateforme non geree'
def maskStringsAndComments(src):
"""Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
class ENTITE_JDC :
"""Classe de base pour tous les objets créés lors de la conversion
- Tout objet dérivé est enregistré auprès de son pere a sa création
+ Tout objet dérivé est enregistré aupres de son pere a sa création
"""
def __init__(self,pere):
self.texte = ''
def __str__(self):
"""
- Retourne une chaine de caractères représentants self
+ Retourne une chaine de caracteres représentants self
sous une forme interprétable par EFICAS
"""
t=repr(self.texte)
if texte[0] == '#':
self.texte = self.texte+texte[1:]
else:
- # le dièse n'est pas sur le premier caractere
- amont,aval = string.split(texte,'#',1) # on découpe suivant la première occurrence de #
+ # le diese n'est pas sur le premier caractere
+ amont,aval = string.split(texte,'#',1) # on découpe suivant la premiere occurrence de #
self.texte = self.texte +amont + aval
class COMMANDE(ENTITE_JDC):
def get_nb_par(self):
"""
- Retourne la différence entre le nombre de parenthèses ouvrantes
- et le nombre de parenthèses fermantes présentes dans self.texte
+ Retourne la différence entre le nombre de parentheses ouvrantes
+ et le nombre de parentheses fermantes présentes dans self.texte
Peut donc retourner un entier négatif
"""
# faire attention aux commentaires contenus dans self.texte
- # qui peuvent eux-memes contenir des parenthèses !!!!
+ # qui peuvent eux-memes contenir des parentheses !!!!
l_lignes = string.split(self.texte,'\n')
nb = 0
for ligne in l_lignes:
def __str__(self):
"""
- Retourne une expression du paramètre EVAL compréhensible par ACCAS
+ Retourne une expression du parametre EVAL compréhensible par ACCAS
et exploitable par EFICAS
"""
nom,valeur = string.split(self.texte,'=',1)
if m is None : return 0
if m.start() != 0 :return 0
if m.end() != len(s):return 0
- #print texte,amont,aval
return 1
def is_eval(self,texte):
#Masquage des commentaires et strings multilignes
srcMasked=maskStringsAndComments('\n'.join(l_lignes))
- #print srcMasked
masked_lines=srcMasked.split('\n')
lineno=0
for ligne in l_lignes :
line=masked_lines[lineno]
lineno=lineno+1
- #print "ligne:",line
+ #print ("ligne:",line)
# mise a jour du nombre total de parentheses ouvertes (non fermees)
# et du nombre de commentaires non termines
for i in range(len(implicitContinuationChars)):
hangingComments ^= line.count('"""') % 2
hangingComments ^= line.count(u"'''") % 2
- #print hangingComments,hangingBraces
+ #print (hangingComments,hangingBraces)
if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
raise ParserException()
#on l'ajoute au texte de la commande
commande_courante.append_text(ligne)
elif commentaire_courant :
- # il s'agit de la nième ligne d'un commentaire entre deux commandes
+ # il s'agit de la nieme ligne d'un commentaire entre deux commandes
# --> on ajoute cette ligne au commentaire courant
commentaire_courant.append_text(ligne)
else :
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
#la commande est terminée
- #print "fin de commande"
self.analyse_reel(commande_courante.texte)
commande_courante = None
affectation_courante = None
commande_courante = COMMANDE(self)
commande_courante.append_text(ligne)
- #si la commande est complète, on la termine
+ #si la commande est complete, on la termine
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #la commande est terminée
- #print "fin de commande"
+ #la commande est terminee
self.analyse_reel(commande_courante.texte)
commande_courante = None
#on passe a la ligne suivante
continue
- #if self.is_modification_catalogue(ligne) :
- # print ligne
def enleve (self,texte) :
"""Supprime de texte tous les caracteres blancs, fins de ligne, tabulations
- Le nouveau texte est retourné
+ Le nouveau texte est retourne
"""
i=0
chaine=""
except :
pass
mot=""
- # ou de ( imbriqueés
+ # ou de ( imbriquees
else :
#cas du mocle facteur simple ou
mot=""
liste_simp_reel=["VALE","VALE_C","GROUP_MA","RAYON"]
a=appli()
- if 1:
- t0=time.clock()
- txt = PARSEUR_PYTHON(texte).get_texte(a)
- print t0,time.clock()-t0
- else:
- import hotshot, hotshot.stats
- prof = hotshot.Profile(u"stones.prof")
- txt = prof.runcall(PARSEUR_PYTHON(texte).get_texte,a)
- prof.close()
- stats = hotshot.stats.load(u"stones.prof")
- stats.strip_dirs()
- stats.sort_stats('time', 'calls')
- stats.print_stats(20)
-
- print txt
compile(txt, '<string>', 'exec')
- print a.dict_reels
+ print (a.dict_reels)
