X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=convert%2Fparseur_python.py;h=19d73256de77e60caf79b1e4929d2c6745ff8044;hb=0a3e507740b8094749648d8292fa83b10e2ea864;hp=15a0b7c9886b21df98c673e5d3f92b68f70836b4;hpb=8a68525fe5d4970b62f017979990e9a31eabd09b;p=tools%2Feficas.git

diff --git a/convert/parseur_python.py b/convert/parseur_python.py
index 15a0b7c9..19d73256 100644
--- a/convert/parseur_python.py
+++ b/convert/parseur_python.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2007-2013   EDF R&D
+# Copyright (C) 2007-2021   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
@@ -17,6 +17,13 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+    from builtins import str
+    from builtins import object
+except :
+    pass
 import sys,string,re
 import traceback
 from Extensions.i18n import tr
@@ -26,9 +33,15 @@ stringsAndCommentsRE =  \
       re.compile(u"(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|\'[^\']*\'|#.*?\n)", re.DOTALL)
 #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))
+import six
+if six.PY2 :
+    allchars = string.maketrans(u"", "")
+    allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
+    allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
+else :
+    allchars=bytes.maketrans(b"",b"")
+    allcharsExceptNewline = allchars[: allchars.index(b'\n')]+allchars[allchars.index(b'\n')+1:]
+    allcharsExceptNewlineTranstable = bytes.maketrans(allcharsExceptNewline, b'*'*len(allcharsExceptNewline))
 
 #if sys.platform[0:5]=="linux" :
 #   allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
@@ -36,24 +49,24 @@ allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*le
 #   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
        quotes et guillemets.
-       Le masquage est realise en remplacant les caracteres par des * 
+       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
     """
 # remplace les \\, les \" les \'  par **
 # supprime toutes les chaines ou commentaires ,y compris multiligne i
-# entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou # 
+# entre 3 ou 1 simples ou doubles quotes (ouvrantes fermantes) ou #
 # laisse les non fermantes ou non ouvrantes
-    #src = escapedQuotesRE.sub(u"**", src)
-    # le u met le bazar dans le translate
+# on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
+
     src = escapedQuotesRE.sub("**", src)
     allstrings = stringsAndCommentsRE.split(src)
-    # every odd element is a string or comment
-    for i in xrange(1, len(allstrings), 2):
+
+    # on a une liste d elements constituee successivement de  (string, comment)
+    for i in range(1, len(allstrings), 2):
         if allstrings[i].startswith(u"'''")or allstrings[i].startswith('"""'):
             allstrings[i] = allstrings[i][:3]+ \
                             allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \
@@ -69,7 +82,7 @@ implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}'))
 linecontinueRE = re.compile(r"\\\s*(#.*)?$")
 emptyHangingBraces = [0,0,0,0,0]
 
-class ParserException(Exception): pass
+class parserException(Exception): pass
 class FatalError(Exception): pass
 
 #commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
@@ -104,19 +117,19 @@ number_kw_pattern=re.compile(r"""
 )
 """,re.VERBOSE|re.MULTILINE)
 
-def construit_genea(texte,liste_mc):
+def construitGenea(texte,listeMc):
     """
        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
+         - Ne garde que les reels derriere un argument keyword dont le nom est dans listeMc
 
        >>> 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'])
+       >>> construitGenea(s,['a','x'])
        {0.000213: '21.3e-5'}
     """
     d={}
@@ -127,25 +140,25 @@ def construit_genea(texte,liste_mc):
             #argument keyword
             mot=m[:-1]
         else:
-            if mot not in liste_mc:continue
+            if mot not in listeMc:continue
             #valeur
             key=eval(m)
             if str(key) != m: d[key]=m
     return d
 
 
-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
+class ENTITE_JDC(object) :
+    """Classe de base pour tous les objets crees lors de la conversion
+       Tout objet derive est enregistre aupres de son pere a sa creation
     """
     def __init__(self,pere):
         self.texte = ''
         pere.l_objets.append(self)
 
-    def set_text(self,texte):
+    def setText(self,texte):
         self.texte = texte
 
-    def append_text(self,texte):
+    def appendText(self,texte):
         """
         Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
         """
@@ -159,8 +172,8 @@ class COMMENTAIRE(ENTITE_JDC):
 
     def __str__(self):
         """
-        Retourne une chaine de caractères représentants self
-        sous une forme interprétable par EFICAS
+        Retourne une chaine de caracteres representants self
+        sous une forme interpretable par EFICAS
         """
         t=repr(self.texte)
         return "COMMENTAIRE(u"+t+")\n"
@@ -168,7 +181,7 @@ class COMMENTAIRE(ENTITE_JDC):
         #s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
         #return s
 
-    def append_text(self,texte):
+    def appendText(self,texte):
         """
         Ajoute texte a self.texte en enlevant le # initial
         """
@@ -176,10 +189,10 @@ class COMMENTAIRE(ENTITE_JDC):
         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 = texte.split('#',1) # on decoupe suivant la premiere occurrence de #
             self.texte = self.texte +amont + aval
-        
+
 class COMMANDE(ENTITE_JDC):
 
     def __str__(self):
@@ -187,57 +200,59 @@ class COMMANDE(ENTITE_JDC):
         Retourne self.texte
         """
         return self.texte+'\n'
-        
-    def get_nb_par(self):
+
+    def getNbPar(self):
         """
-        Retourne la différence entre le nombre de parenthèses ouvrantes
-        et le nombre de parenthèses fermantes présentes dans self.texte
-        Peut donc retourner un entier négatif
+        Retourne la difference entre le nombre de parentheses ouvrantes
+        et le nombre de parentheses fermantes presentes dans self.texte
+        Peut donc retourner un entier negatif
         """
         # faire attention aux commentaires contenus dans self.texte
-        # qui peuvent eux-memes contenir des parenthèses !!!!
-        l_lignes = string.split(self.texte,'\n')
+        # qui peuvent eux-memes contenir des parentheses !!!!
+        l_lignes = self.texte.split('\n')
         nb = 0
         for ligne in l_lignes:
-            ligne = string.split(ligne,'#')[0]
-            nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
+            ligne = ligne.split('#')[0]
+            #nb = nb + (string.count(ligne,'(')-string.count(ligne,')'))
+
+            nb = nb + ( ligne.count('(') - ligne.count(')') )
         return nb
 
 class AFFECTATION(ENTITE_JDC):
 
-    def append_text(self,texte):
+    def appendText(self,texte):
         """
         Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
         PN et tout commentaire
         """
-        if texte[-1] == '\n' : texte = string.rstrip(texte[0:-1])
-        if texte[-1] == ';' : texte = string.rstrip(texte[0:-1])
+        if texte[-1] == '\n' : texte = texte[0:-1].rstrip()
+        if texte[-1] == ';'  : texte = texte[0:-1].rstrip()
         self.texte = self.texte+texte+'\n'
-        
+
     def __str__(self):
         """
-        Retourne une expression de l'affectation compréhensible par ACCAS
+        Retourne une expression de l'affectation comprehensible par ACCAS
         et exploitable par EFICAS
         """
-        nom,valeur = string.split(self.texte,'=',1)
-        n = string.rstrip(nom)
-        nom = string.lstrip(n)
+        nom,valeur = self.texte.split('=',1)
+        n = nom.rstrip()
+        nom = n.lstrip()
         if valeur[-1] == '\n': valeur = valeur[:-1]
         return n + ' = PARAMETRE(nom=\''+nom+'\',valeur='+valeur+')\n'
 
 class COMMANDE_COMMENTARISEE(ENTITE_JDC):
 
-    def append_text(self,texte):
+    def appendText(self,texte):
         """
         Ajoute texte a self.texte en enlevant les doubles commentaires
         """
-        texte = string.strip(texte)
-        texte = string.strip(texte[2:])
+        texte = texte.strip()
+        texte = texte[2:].strip()
         self.texte = self.texte+(len(self.texte)>0)*'\n'+texte
 
     def __str__(self):
         """
-        Retourne une expression de la commande commentarisée compréhensible par ACCAS
+        Retourne une expression de la commande commentarisee comprehensible par ACCAS
         et exploitable par EFICAS
         """
         return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
@@ -245,106 +260,111 @@ class COMMANDE_COMMENTARISEE(ENTITE_JDC):
 
 class AFFECTATION_EVAL(ENTITE_JDC):
 
-    def append_text(self,texte):
+    def appendText(self,texte):
         """
         Ajoute texte a self.texte en enlevant tout retour chariot
         """
         if texte[-1] == '\n' : texte = texte[1:-1]
         self.texte = self.texte+texte
-        
+
     def __str__(self):
         """
-        Retourne une expression du paramètre EVAL compréhensible par ACCAS
+        Retourne une expression du parametre EVAL comprehensible par ACCAS
         et exploitable par EFICAS
         """
-        nom,valeur = string.split(self.texte,'=',1)
-        nom = string.strip(nom)
+        nom,valeur = self.texte.split('=',1)
+        nom = nom.strip()
         if valeur[-1] == '\n': valeur = valeur[:-1]
-        valeur = string.strip(valeur)
+        valeur = valeur.strip()
         return nom+' = PARAMETRE_EVAL(nom=\''+nom+'\',valeur=\''+valeur+'\')\n\n'
-        
-class PARSEUR_PYTHON:
+
+class PARSEUR_PYTHON(object):
     """
-    Cette classe sert a générer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte 
-    représentant un JDC Python en distinguant :
+    Cette classe sert a generer un objet PARSEUR_PYTHON qui realise l'analyse d'un texte
+    representant un JDC Python en distinguant :
       - les commentaires inter commandes
       - les affectations
       - les commandes
     """
-    pattern_commande   = re.compile(r'^([A-Z][A-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)')
+    pattern_commande   = re.compile(r'^([A-Z][a-zA-Z0-9_]+)([ \t\r\f\v]*)\(([\w\W]*)')
     pattern_eval       = re.compile(r'^(EVAL)([ \t\r\f\v]*)\(([\w\W]*)')
     pattern_ligne_vide = re.compile(r'^[\t\r\f\v\n]+')
     pattern_name       = re.compile(r'[a-zA-Z_]\w*')
-    
+
     def __init__(self,texte):
         self.texte = texte
         self.l_objets=None
-        self.appli=None
+        self.appliEficas=None
 
-    def is_affectation(self,texte):
+    def isAffectation(self,texte):
         """
-        Méthode booléenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
+        Methode booleenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
         Aster, 0 sinon
         """
         if '=' not in texte : return 0
         if self.pattern_commande.match(texte):
-            # cas d'une procédure ...
+            # cas d'une procedure ...
             return 0
-        amont,aval = string.split(texte,'=',1)
-        aval = string.strip(aval)
+        amont,aval = texte.split('=',1)
+        aval = aval.strip()
+
+
         if self.pattern_commande.match(aval):
             return 0
         else:
-            s= string.strip(amont)
+            s= amont.strip()
             m= self.pattern_name.match(s)
             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):
+    def isEval(self,texte):
         """
-        Méthode booléenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
+        Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
         dans un jeu de commandes Aster, 0 sinon
         """
         if '=' not in texte : return 0
         if self.pattern_commande.match(texte):
-            # cas d'une procédure ...
+            # cas d'une procedure ...
             return 0
-        amont,aval = string.split(texte,'=',1)
-        aval = string.strip(aval)
+        amont,aval = texte.split('=',1)
+        aval = aval.strip()
         if not self.pattern_commande.match(aval) : return 0
         if self.pattern_eval.match(aval):
             return 1
         else:
             return 0
-            
-    def is_commande(self,texte):
+
+    def isCommande(self,texte):
         """
-        Méthode booléenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
+        Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
         Aster, 0 sinon
         """
         if self.pattern_commande.match(texte):
-            # cas d'une procédure ...
+            # cas d'une procedure ...
             return 1
         # A ce stade il faut avoir un OPER ou une MACRO, bref un '=' !
         if '=' not in texte : return 0
         # on a un texte de la forme xxxx = yyyyy
         # --> reste a analyser yyyy
-        amont,aval = string.split(texte,'=',1)
-        aval = string.strip(aval)
+        amont,aval = texte.split('=',1)
+        aval = aval.strip()
         if self.pattern_commande.match(aval):
             return 1
         else:
             return 0
 
+    def isModificationCatalogue(self,texte) :
+        if self.pattern_commande.match(texte):
+            return 1
+
     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").
+        et de commentaires (parmi lesquels des instructions "commentarisees").
         """
-        l_lignes = string.split(self.texte,'\n')
+        l_lignes = self.texte.split('\n')
         commentaire_courant             = None
         commande_courante               = None
         affectation_courante            = None
@@ -360,14 +380,13 @@ class PARSEUR_PYTHON:
 
         #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)):
@@ -377,36 +396,36 @@ class PARSEUR_PYTHON:
 
             hangingComments ^= line.count('"""') % 2
             hangingComments ^= line.count(u"'''") % 2
-            #print hangingComments,hangingBraces
-            if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0: 
-                raise ParserException()
+            #print (hangingComments,hangingBraces)
+            if hangingBraces[0] < 0 or hangingBraces[1] < 0 or hangingBraces[2] < 0:
+                raise parserException()
 
-            if string.strip(ligne) == '':
+            if ligne.strip() == '':
                 # il s'agit d'un saut de ligne
                 # --> on l'ignore
                 continue
 
             if pattern_2comments.match(ligne):
-                #on a trouvé une commande commentarisée : double commentaire sans rien devant a part des blancs
+                #on a trouve une commande commentarisee : double commentaire sans rien devant a part des blancs
                 if commentaire_courant:
                     #Si un commentaire ordinaire est en cours on le termine
                     commentaire_courant = None
 
                 if commande_courante :
-                    # on a un objet commentarisé a l'intérieur d'une commande
-                    # --> non traité pour l'instant : on l'ajoute simplement a la commande courante comme
+                    # on a un objet commentarise a l'interieur d'une commande
+                    # --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
                     # un commentaire ordinaire
-                    commande_courante.append_text(ligne)
+                    commande_courante.appendText(ligne)
                 elif commande_commentarisee_courante :
                     # commande_commentarisee en cours : on ajoute la ligne
-                    commande_commentarisee_courante.append_text(ligne)
-                    # on a 2 commandes commentarisées de suite
+                    commande_commentarisee_courante.appendText(ligne)
+                    # on a 2 commandes commentarisees de suite
                     if pattern_finComments.match(ligne) :
-                       commande_commentarisee_courante = None
+                        commande_commentarisee_courante = None
                 else:
-                    # debut de commande commentarisée : on crée un objet commande_commentarisee_courante
+                    # debut de commande commentarisee : on cree un objet commande_commentarisee_courante
                     commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
-                    commande_commentarisee_courante.append_text(ligne)
+                    commande_commentarisee_courante.appendText(ligne)
 
                 #on passe a la ligne suivante
                 continue
@@ -418,40 +437,39 @@ class PARSEUR_PYTHON:
                     commande_commentarisee_courante = None
 
                 if commande_courante :
-                    # il s'agit d'un commentaire a l'intérieur d'une commande --> on ne fait rien de special
-                    #on l'ajoute au texte de la commande 
-                    commande_courante.append_text(ligne)
+                    # il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
+                    #on l'ajoute au texte de la commande
+                    commande_courante.appendText(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)
+                    commentaire_courant.appendText(ligne)
                 else :
                     # il s'agit d'un nouveau commentaire entre deux commandes
-                    # --> on le crée et il devient le commentaire courant
+                    # --> on le cree et il devient le commentaire courant
                     commentaire_courant = COMMENTAIRE(self)
-                    commentaire_courant.append_text(ligne)
+                    commentaire_courant.appendText(ligne)
 
                 #on passe a la ligne suivante
                 continue
 
-            # la ligne contient des données autre qu'un éventuel commentaire
+            # la ligne contient des donnees autre qu'un eventuel commentaire
             if commentaire_courant :
-                # on clot un éventuel commentaire courant
+                # on clot un eventuel commentaire courant
                 commentaire_courant = None
 
             if commande_commentarisee_courante :
-                # on clot une éventuelle commande commentarisee courante
+                # on clot une eventuelle commande commentarisee courante
                 commande_commentarisee_courante = None
 
             if commande_courante :
                 #on a une commande en cours. On l'enrichit ou on la termine
-                commande_courante.append_text(ligne)
+                commande_courante.appendText(ligne)
                 if not linecontinueRE.search(line) \
                    and (hangingBraces == emptyHangingBraces) \
                    and not hangingComments:
-                    #la commande est terminée 
-                    #print "fin de commande"
-                    self.analyse_reel(commande_courante.texte)
+                    #la commande est terminee
+                    self.analyseReel(commande_courante.texte)
                     commande_courante = None
 
                 #on passe a la ligne suivante
@@ -459,192 +477,192 @@ class PARSEUR_PYTHON:
 
             if affectation_courante != None :
                 #poursuite d'une affectation
-                affectation_courante.append_text(ligne)
+                affectation_courante.appendText(ligne)
                 if not linecontinueRE.search(line) \
                    and (hangingBraces == emptyHangingBraces) \
                    and not hangingComments:
-                    #L'affectation est terminée
+                    #L'affectation est terminee
                     affectation_courante=None
                 #on passe a la ligne suivante
                 continue
 
             # il peut s'agir d'une commande ou d'une affectation ...
             # ou d'un EVAL !!!
-            if self.is_eval(ligne):
+            if self.isEval(ligne):
                 # --> affectation de type EVAL
                 if affectation_courante : affectation_courante = None
                 affectation = AFFECTATION_EVAL(self)
-                affectation.append_text(ligne)
+                affectation.appendText(ligne)
                 #on passe a la ligne suivante
                 continue
 
-            if self.is_affectation(ligne):
-                # --> affectation
+            if self.isAffectation(ligne):
+                #print( '--> affectation')
                 text=ligne
                 #traitement des commentaires en fin de ligne
                 compos=line.find(u"#")
                 if compos > 2:
                     #commentaire en fin de ligne
                     #on cree un nouveau commentaire avant le parametre
-                    COMMENTAIRE(self).append_text(ligne[compos:])
+                    COMMENTAIRE(self).appendText(ligne[compos:])
                     text=ligne[:compos]
                 #si plusieurs instructions separees par des ; sur la meme ligne
                 inspos=line.find(u";")
                 if inspos > 2:
                     #on garde seulement la premiere partie de la ligne
                     #si on a que des blancs apres le point virgule
-                    if string.strip(text[inspos:]) == ";":
+                    if text[inspos:].strip() == ";":
                         text=text[:inspos]
                     else:
                         raise FatalError(tr("Eficas ne peut pas traiter plusieurs instructions \
                                                  sur la meme ligne : %s", ligne))
 
                 affectation_courante = AFFECTATION(self)
-                affectation_courante.append_text(text)
+                affectation_courante.appendText(text)
                 if not linecontinueRE.search(line) \
                    and (hangingBraces == emptyHangingBraces) \
                    and not hangingComments:
-                    #L'affectation est terminée
+                    #L'affectation est terminee
                     affectation_courante=None
                 #on passe a la ligne suivante
                 continue
 
-            if self.is_commande(ligne):
+            if self.isCommande(ligne):
                 # --> nouvelle commande
                 affectation_courante = None
                 commande_courante = COMMANDE(self)
-                commande_courante.append_text(ligne)
-                #si la commande est complète, on la termine
+                commande_courante.appendText(ligne)
+                #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"
-                    self.analyse_reel(commande_courante.texte)
+                    #la commande est terminee
+                    self.analyseReel(commande_courante.texte)
                     commande_courante = None
                 #on passe a la ligne suivante
                 continue
 
+
     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=""
         while (i<len(texte)):
-          if (texte[i] == " " or texte[i] == "\n" or texte[i] == "\t") :
-             i=i+1
-          else :
-             chaine=chaine+texte[i]
-             i=i+1
-        return chaine 
-            
-    def construit_genea(self,texte):
+            if (texte[i] == " " or texte[i] == "\n" or texte[i] == "\t") :
+                i=i+1
+            else :
+                chaine=chaine+texte[i]
+                i=i+1
+        return chaine
+
+    def construitGenea(self,texte):
         indiceC=0
         mot=""
         dict_reel_concept={}
 
         # traitement pour chaque caractere
-        while (indiceC < len(texte)): 
-           c=texte[indiceC]
-           if ( c == "," or c == "(u" or c == ")"):
-              mot=""
-           elif ( c== "="):
-              #on doit trouver derriere soit une valeur soit une parenthese
-              valeur=""
-              nouvelindice=indiceC+1
-              if texte[nouvelindice] != "(u":
-                 #pas de parenthese ouvrante derriere un signe =, on a une valeur.
-                 while ( texte[nouvelindice] != "," and texte[nouvelindice] != ")"):
-                    valeur=valeur+texte[nouvelindice]
-                    nouvelindice=nouvelindice+1
-                    if nouvelindice == len(texte) :
-                        nouvelindice=nouvelindice -1
-                        break
-                 if mot in self.appli.liste_simp_reel:
-                    if valeur[0] != "'":
-                       try :
-                         clef=eval(valeur)
-                         if str(clef) != str(valeur) :
-                            dict_reel_concept[clef]=valeur
-                       except :
-                         pass
-                 mot=""
-                 indiceC=nouvelindice
-              else:
-                 #parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
-                 # s agit -il d un tuple 
-                 if texte[nouvelindice+1] != "(u":
-                    #le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
-                    tuple=False
-                    #on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
-                    #contenu dans le mot cle facteur
-                    while ( texte[nouvelindice] != "="):
-                       if texte[nouvelindice] == ")" :
-                          tuple=True
-                          break
-                       else :
-                          nouvelindice=nouvelindice+1
-                          if nouvelindice == len(texte) :
-                             nouvelindice=nouvelindice -1
-                             break
-                    if tuple :
-                       #cas du tuple de valeurs
-                       valeur=texte[indiceC+1:nouvelindice+1]
-                       indiceC=nouvelindice+1 
-                       if mot in self.appli.liste_simp_reel:
-                          valeur=valeur[1:-1]
-                          for val in valeur.split(',') :
-                          # Attention la derniere valeur est""
-                             try :
-                                if val[0] != "'":
-                                  clef=eval(val)
-                                  if str(clef) != str(val) :
-                                     dict_reel_concept[clef]=val
-                             except :
-                                  pass
-                       mot=""
-               # ou de ( imbriqueés
-                 else :
-                    #cas du mocle facteur simple ou 
+        while (indiceC < len(texte)):
+            c=texte[indiceC]
+            if ( c == "," or c == "(u" or c == ")"):
+                mot=""
+            elif ( c== "="):
+                #on doit trouver derriere soit une valeur soit une parenthese
+                valeur=""
+                nouvelindice=indiceC+1
+                if texte[nouvelindice] != "(u":
+                    #pas de parenthese ouvrante derriere un signe =, on a une valeur.
+                    while ( texte[nouvelindice] != "," and texte[nouvelindice] != ")"):
+                        valeur=valeur+texte[nouvelindice]
+                        nouvelindice=nouvelindice+1
+                        if nouvelindice == len(texte) :
+                            nouvelindice=nouvelindice -1
+                            break
+                    if mot in self.appliEficas.liste_simp_reel:
+                        if valeur[0] != "'":
+                            try :
+                                clef=eval(valeur)
+                                if str(clef) != str(valeur) :
+                                    dict_reel_concept[clef]=valeur
+                            except :
+                                pass
                     mot=""
-           else :
-              mot=mot+texte[indiceC]
-           indiceC=indiceC+1
+                    indiceC=nouvelindice
+                else:
+                    #parenthese ouvrante derriere un signe =, on a un tuple de valeur ou de mots cles facteurs.
+                    # s agit -il d un tuple
+                    if texte[nouvelindice+1] != "(u":
+                        #le suivant n'est pas une parenthese ouvrante : on a un tuple de valeurs ou un mot cle facteur
+                        tuple=False
+                        #on avance jusqu'a la fin du tuple de valeurs ou jusqu'a la fin du premier mot cle simple
+                        #contenu dans le mot cle facteur
+                        while ( texte[nouvelindice] != "="):
+                            if texte[nouvelindice] == ")" :
+                                tuple=True
+                                break
+                            else :
+                                nouvelindice=nouvelindice+1
+                                if nouvelindice == len(texte) :
+                                    nouvelindice=nouvelindice -1
+                                    break
+                        if tuple :
+                            #cas du tuple de valeurs
+                            valeur=texte[indiceC+1:nouvelindice+1]
+                            indiceC=nouvelindice+1
+                            if mot in self.appliEficas.liste_simp_reel:
+                                valeur=valeur[1:-1]
+                                for val in valeur.split(',') :
+                                # Attention la derniere valeur est""
+                                    try :
+                                        if val[0] != "'":
+                                            clef=eval(val)
+                                            if str(clef) != str(val) :
+                                                dict_reel_concept[clef]=val
+                                    except :
+                                        pass
+                            mot=""
+                    # ou de ( imbriquees
+                    else :
+                        #cas du mocle facteur simple ou
+                        mot=""
+            else :
+                mot=mot+texte[indiceC]
+            indiceC=indiceC+1
         # traitement du dernier inutile
-        # c est un ; 
+        # c est un ;
         return dict_reel_concept
 
-    def analyse_reel(self,commande) :
+    def analyseReel(self,commande) :
         nomConcept=None
         # On verifie qu on a bien un OPER
         # et pas une MACRO
         if commande.find(u"=") > commande.find(u"(u") :
-           return
+            return
         if commande.find(u"=") > 0:
-           #epure1=self.enleve(commande)
-           epure1=pattern_blancs.sub(u"",commande)
-           nomConcept,corps=epure1.split(u"=",1)
-           epure2=corps.replace(u"_F(u","(u")
-           #nomConcept=epure1.split(u"=")[0]
-           #index=epure1.find(u"=")
-           #epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
-           #dict_reel_concept=self.construit_genea(epure2)
-           if self.appli:
-             dict_reel_concept=construit_genea(epure2,self.appli.liste_simp_reel)
-           else:
-             dict_reel_concept={}
+            #epure1=self.enleve(commande)
+            epure1=pattern_blancs.sub(u"",commande)
+            nomConcept,corps=epure1.split(u"=",1)
+            epure2=corps.replace(u"_F(u","(u")
+            #nomConcept=epure1.split(u"=")[0]
+            #index=epure1.find(u"=")
+            #epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
+            #dict_reel_concept=self.construitGenea(epure2)
+            if self.appliEficas:
+                dict_reel_concept=construitGenea(epure2,self.appliEficas.liste_simp_reel)
+            else:
+                dict_reel_concept={}
         if nomConcept == "sansnom" :
-           nomConcept = ""
+            nomConcept = ""
         if nomConcept !=None :
-           if len(dict_reel_concept) != 0:
-              self.appli.dict_reels[nomConcept]=dict_reel_concept
+            if len(dict_reel_concept) != 0:
+                self.appliEficas.dict_reels[nomConcept]=dict_reel_concept
 
-    def get_texte(self,appli=None):
+    def getTexte(self,appliEficas=None):
         """
         Retourne le texte issu de l'analyse
         """
-        self.appli=appli
+        self.appliEficas=appliEficas
         try:
         #if 1:
             if not self.l_objets : self.analyse()
@@ -652,46 +670,27 @@ class PARSEUR_PYTHON:
             for obj in self.l_objets:
                 txt = txt+str(obj)
         #else :
-        except  ParserException:
+        except  parserException:
             #Impossible de convertir le texte, on le retourne tel que
             txt=self.texte
         return txt
 
 def test():
-  import parseur_python
-  import doctest
-  doctest.testmod(parseur_python)
+    #import parseur_python
+    import doctest
+    doctest.testmod(parseur_python)
 
 
 if __name__ == "__main__" :
     import time
     #fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
-    fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
-    fichier = '/local/chris/ASTER/Eficas/Eficas1_10/EficasV1/Tests/testcomm/b.comm'
-    fichier = '/local/chris/ASTER/instals/STA8.2/astest/forma12c.comm'
-    fichier = 'titi.comm'
-    fichier = '../Aster/sdls300a.comm'
-    fichier = '../Aster/az.comm'
-    texte = open(fichier,'r').read()
-    class appli:
-       dict_reels={}
-       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
+    #fichier = 'U:/Eficas_dev/Tests/test_eval.comm'
+    with open(fichier) as fd:
+        texte = fd.read()
+    class appliEficas(object):
+        dict_reels={}
+        liste_simp_reel=["VALE","VALE_C","GROUP_MA","RAYON"]
+    a=appliEficas()
+
     compile(txt, '<string>', 'exec')
-    print a.dict_reels
+    print((a.dict_reels))