matrice coloree

[tools/eficas.git] / convert / parseur_python.py

diff --git a/convert/parseur_python.py b/convert/parseur_python.py
index ba49c2e806c382ec39fbe8a71daddd83390aa949..19d73256de77e60caf79b1e4929d2c6745ff8044 100644 (file)
--- a/convert/parseur_python.py
+++ b/convert/parseur_python.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 # -*- 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
 #
 # 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
 #
 #
 # 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
 import sys,string,re
 import traceback
 from Extensions.i18n import tr


@@ -24,33 +31,47 @@ from Extensions.i18n import tr
 escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
 stringsAndCommentsRE =  \
       re.compile(u"(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|\'[^\']*\'|#.*?\n)", re.DOTALL)
 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:]
-if sys.platform[0:5]=="linux" :
-   allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
-elif sys.platform[0:3]=="win" :
-   allcharsExceptNewlineTranstable = dict((ord(char), u'*') for char in allcharsExceptNewline)#string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
+#stringsAndCommentsRE =  \
+#      re.compile(u"(\"\"\".*\"\"\"|'''.*'''|\"[^\"]*\"|\'[^\']*\'|#.*\n)", re.DOTALL)
+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 :
 else :

-   allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
-   print 'Plateforme non geree'
+    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))
+#elif sys.platform[0:3]=="win" :
+#   allcharsExceptNewlineTranstable = dict((ord(char), u'*') for char in allcharsExceptNewline)#
+#else :
+#   allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))

 
 def maskStringsAndComments(src):
     """Masque tous les caracteres de src contenus dans des commentaires ou des strings multilignes (triples
        quotes et guillemets.
 
 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
     """
        Attention : cette fonction doit etre utilisee sur un texte complet et pas ligne par ligne
     """

-    src = escapedQuotesRE.sub(u"**", src)
+# 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 #
+# laisse les non fermantes ou non ouvrantes
+# on prend 1 sur 2 en raison du split qui donne python, commentaire, python, commentaire...
+
+    src = escapedQuotesRE.sub("**", src)

     allstrings = stringsAndCommentsRE.split(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)+ \
                             allstrings[i][-3:]
         else:
         if allstrings[i].startswith(u"'''")or allstrings[i].startswith('"""'):
             allstrings[i] = allstrings[i][:3]+ \
                             allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \
                             allstrings[i][-3:]
         else:

-            test= allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)
-            #test +\

             allstrings[i] = allstrings[i][0]+ \
                             allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \
                             allstrings[i][-1]
             allstrings[i] = allstrings[i][0]+ \
                             allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \
                             allstrings[i][-1]


@@ -61,7 +82,7 @@ implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}'))
 linecontinueRE = re.compile(r"\\\s*(#.*)?$")
 emptyHangingBraces = [0,0,0,0,0]
 
 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)
 class FatalError(Exception): pass
 
 #commentaire double precede d'un nombre quelconque de blancs (pas multiligne)


@@ -96,19 +117,19 @@ number_kw_pattern=re.compile(r"""
 )
 """,re.VERBOSE|re.MULTILINE)
 
 )
 """,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.
     """
        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)'''
 
        >>> 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={}
        {0.000213: '21.3e-5'}
     """
     d={}


@@ -119,25 +140,25 @@ def construit_genea(texte,liste_mc):
             #argument keyword
             mot=m[:-1]
         else:
             #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
 
 
             #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 __init__(self,pere):
         self.texte = ''
         pere.l_objets.append(self)
 

-    def set_text(self,texte):
+    def setText(self,texte):

         self.texte = 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
         """
         """
         Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
         """


@@ -151,8 +172,8 @@ class COMMENTAIRE(ENTITE_JDC):
 
     def __str__(self):
         """
 
     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"
         """
         t=repr(self.texte)
         return "COMMENTAIRE(u"+t+")\n"


@@ -160,7 +181,7 @@ class COMMENTAIRE(ENTITE_JDC):
         #s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
         #return s
 
         #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
         """
         """
         Ajoute texte a self.texte en enlevant le # initial
         """


@@ -168,10 +189,10 @@ class COMMENTAIRE(ENTITE_JDC):
         if texte[0] == '#':
             self.texte = self.texte+texte[1:]
         else:
         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
             self.texte = self.texte +amont + aval

-        
+

 class COMMANDE(ENTITE_JDC):
 
     def __str__(self):
 class COMMANDE(ENTITE_JDC):
 
     def __str__(self):


@@ -179,57 +200,59 @@ class COMMANDE(ENTITE_JDC):
         Retourne self.texte
         """
         return self.texte+'\n'
         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
         """
         # 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:
         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):
 
         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
         """
         """
         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'
         self.texte = self.texte+texte+'\n'

-        
+

     def __str__(self):
         """
     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
         """
         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):
 
         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
         """
         """
         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):
         """
         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"
         et exploitable par EFICAS
         """
         return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"


@@ -237,106 +260,111 @@ class COMMANDE_COMMENTARISEE(ENTITE_JDC):
 
 class AFFECTATION_EVAL(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
         """
         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):
         """
     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
         """
         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]
         if valeur[-1] == '\n': valeur = valeur[:-1]

-        valeur = string.strip(valeur)
+        valeur = valeur.strip()

         return nom+' = PARAMETRE_EVAL(nom=\''+nom+'\',valeur=\''+valeur+'\')\n\n'
         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
     """
       - 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*')
     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
     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):
         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
             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:
         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
             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
 
             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):
         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
             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
         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):
         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
             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
 
         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
     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
         commentaire_courant             = None
         commande_courante               = None
         affectation_courante            = None


@@ -352,14 +380,13 @@ class PARSEUR_PYTHON:
 
         #Masquage des commentaires et strings multilignes
         srcMasked=maskStringsAndComments('\n'.join(l_lignes))
 
         #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
         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)):
             # mise a jour du nombre total de parentheses ouvertes (non fermees)
             # et du nombre de commentaires non termines
             for i in range(len(implicitContinuationChars)):


@@ -369,36 +396,36 @@ class PARSEUR_PYTHON:
 
             hangingComments ^= line.count('"""') % 2
             hangingComments ^= line.count(u"'''") % 2
 
             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):
                 # 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 :
                 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
                     # un commentaire ordinaire

-                    commande_courante.append_text(ligne)
+                    commande_courante.appendText(ligne)

                 elif commande_commentarisee_courante :
                     # commande_commentarisee en cours : on ajoute la 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) :
                     if pattern_finComments.match(ligne) :

-                       commande_commentarisee_courante = None
+                        commande_commentarisee_courante = None

                 else:
                 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 = COMMANDE_COMMENTARISEE(self)

-                    commande_commentarisee_courante.append_text(ligne)
+                    commande_commentarisee_courante.appendText(ligne)

 
                 #on passe a la ligne suivante
                 continue
 
                 #on passe a la ligne suivante
                 continue


@@ -410,40 +437,39 @@ class PARSEUR_PYTHON:
                     commande_commentarisee_courante = None
 
                 if commande_courante :
                     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 :
                 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
                     # --> 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
                 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 = COMMENTAIRE(self)

-                    commentaire_courant.append_text(ligne)
+                    commentaire_courant.appendText(ligne)

 
                 #on passe a la ligne suivante
                 continue
 
 
                 #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 :
             if commentaire_courant :

-                # on clot un éventuel commentaire courant
+                # on clot un eventuel commentaire courant

                 commentaire_courant = None
 
             if commande_commentarisee_courante :
                 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_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:
                 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
                     commande_courante = None
 
                 #on passe a la ligne suivante


@@ -451,192 +477,192 @@ class PARSEUR_PYTHON:
 
             if affectation_courante != None :
                 #poursuite d'une affectation
 
             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:
                 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 !!!
                     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 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
 
                 #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
                 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
                     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)
                         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:
                 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
 
                     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)
                 # --> 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:
                 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
 
                     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
     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)):
         """
         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
         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=""
                     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
         # traitement du dernier inutile

-        # c est un ; 
+        # c est un ;

         return dict_reel_concept
 
         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") :
         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:
         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" :
         if nomConcept == "sansnom" :

-           nomConcept = ""
+            nomConcept = ""

         if nomConcept !=None :
         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
         """
         """
         Retourne le texte issu de l'analyse
         """

-        self.appli=appli
+        self.appliEficas=appliEficas

         try:
         #if 1:
             if not self.l_objets : self.analyse()
         try:
         #if 1:
             if not self.l_objets : self.analyse()


@@ -644,46 +670,27 @@ class PARSEUR_PYTHON:
             for obj in self.l_objets:
                 txt = txt+str(obj)
         #else :
             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():
             #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'
 
 
 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')
     compile(txt, '<string>', 'exec')

-    print a.dict_reels
+    print((a.dict_reels))