escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')")
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))
+#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.
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)
+# 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
+ #src = escapedQuotesRE.sub(u"**", src)
+ # le u met le bazar dans le translate
+ src = escapedQuotesRE.sub("**", 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:]
+ allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \
+ allstrings[i][-3:]
else:
allstrings[i] = allstrings[i][0]+ \
- allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \
- allstrings[i][-1]
+ allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \
+ allstrings[i][-1]
return "".join(allstrings)
#commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
pattern_2comments = re.compile(r"^\s*##.*")
+pattern_finComments = re.compile("^\s*##Fin Commentaire")
#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)
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
+ """Classe de base pour tous les objets créés lors de la conversion
+ 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
- sous une forme interprétable par EFICAS
+ Retourne une chaine de caracteres représentants self
+ sous une forme interprétable par EFICAS
"""
t=repr(self.texte)
return "COMMENTAIRE(u"+t+")\n"
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
- Peut donc retourner un entier négatif
+ 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 de l'affectation compréhensible par ACCAS
+ Retourne une expression de l'affectation compréhensible par ACCAS
et exploitable par EFICAS
"""
nom,valeur = string.split(self.texte,'=',1)
def __str__(self):
"""
- Retourne une expression de la commande commentarisée compréhensible par ACCAS
+ Retourne une expression de la commande commentarisée compréhensible par ACCAS
et exploitable par EFICAS
"""
return "COMMANDE_COMM(texte="+repr(self.texte)+")\n"
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)
class PARSEUR_PYTHON:
"""
- 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 générer un objet PARSEUR_PYTHON qui réalise l'analyse d'un texte
+ représentant un JDC Python en distinguant :
- les commentaires inter commandes
- les affectations
- les commandes
def is_affectation(self,texte):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
+ Méthode booléenne 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 procédure ...
return 0
amont,aval = string.split(texte,'=',1)
aval = string.strip(aval)
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):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
+ Méthode booléenne 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 procédure ...
return 0
amont,aval = string.split(texte,'=',1)
aval = string.strip(aval)
def is_commande(self,texte):
"""
- Méthode booléenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
+ Méthode booléenne 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 procédure ...
return 1
# A ce stade il faut avoir un OPER ou une MACRO, bref un '=' !
if '=' not in texte : return 0
else:
return 0
+ def is_modification_catalogue(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 "commentarisées").
"""
l_lignes = string.split(self.texte,'\n')
commentaire_courant = None
#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()
continue
if pattern_2comments.match(ligne):
- #on a trouvé une commande commentarisée : double commentaire sans rien devant a part des blancs
+ #on a trouvé une commande commentarisée : 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 commentarisé a l'intérieur d'une commande
+ # --> non traité pour l'instant : on l'ajoute simplement a la commande courante comme
# un commentaire ordinaire
commande_courante.append_text(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
+ if pattern_finComments.match(ligne) :
+ commande_commentarisee_courante = None
else:
- # debut de commande commentarisée : on crée un objet commande_commentarisee_courante
+ # debut de commande commentarisée : on crée un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
commande_commentarisee_courante.append_text(ligne)
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
+ # 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)
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 :
# il s'agit d'un nouveau commentaire entre deux commandes
- # --> on le crée et il devient le commentaire courant
+ # --> on le crée et il devient le commentaire courant
commentaire_courant = COMMENTAIRE(self)
commentaire_courant.append_text(ligne)
#on passe a la ligne suivante
continue
- # la ligne contient des données autre qu'un éventuel commentaire
+ # la ligne contient des données autre qu'un éventuel commentaire
if commentaire_courant :
- # on clot un éventuel commentaire courant
+ # on clot un éventuel commentaire courant
commentaire_courant = None
if commande_commentarisee_courante :
- # on clot une éventuelle commande commentarisee courante
+ # on clot une éventuelle commande commentarisee courante
commande_commentarisee_courante = None
if commande_courante :
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #la commande est terminée
- #print "fin de commande"
+ #la commande est terminée
self.analyse_reel(commande_courante.texte)
commande_courante = None
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #L'affectation est terminée
+ #L'affectation est terminée
affectation_courante=None
#on passe a la ligne suivante
continue
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
- #L'affectation est terminée
+ #L'affectation est terminée
affectation_courante=None
#on passe a la ligne suivante
continue
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
+
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)