=======================================================
Ides et autre algorithme pour la balance de structures
=======================================================

Voir aussi "../lib/tk/balanceNew.tcl"

La lenteur de la balance actuelle est due principalement a l'algorithme
utilis qui fait trop d'appels a Search_All, procdure qui cherche tous
les symboles d'un certain type (ouvrant ou fermant) dans un texte
donn. 

Search_All est d'abord appele deux fois pour obtenir :
- tous les symboles ouvrants avant la selection
- tous les symboles fermants
Search_All est ensuite appele  chaque fois qu'on a trouv un symbole
ouvrant et le fermant correspondant pour vrifier que le texte entre
ces deux symboles est correctement balanc. 

Pour remdier  a, on pourrait utiliser l'algorithme suivant qui a
l'avantage d'tre incrmental et d'utiliser des tableaux (accs plus
rapide qu' des listes). 

=====================================================================
Dfinir un tableau partenaire qui,  chaque symbole ouvrant,
associe le fermant correspondant (dans le fichier de mode).

Copier tout le texte dans une variable (pas trop gnant si le fichier
n'est pas norme).

Mettre dans un tableau SYM la liste de tous les symboles du texte.
Chaque lment SYM(i) du tableau sera lui-mme un tableau a 4 elements :
- type du symbole (ouvrant ou fermant)
- indice de debut 
- indice de fin
- symbole
Les indices vont de 0 a IMAX.

On repre l'indice gauche de la selection.
On cherche le symbole juste avant, lment I_SEL du tableau SYM.

# bool1 est un booleen qui sera mis a 1 seulement si on a trouve un
# "parenthesage" possible autour de la selection
bool1 = 0
j = I_SEL

Tant que bool1 = 0

    Tant que (j>=0) et (SYM(j) n'est pas un ouvrant)
        j = j-1
    endwhile
    # Si j est positif aprs cette boucle, on a le premier ouvrant
    # sinon il n'y en a pas
    
    Si j<0 "Plus de symboles ouvrants" ; return
    
    # bool2 est un boolen qui est mis a 1 si on trouve un fermant
    # qui corresponde a l'ouvrant trouve prcdemment et telle que
    # le texte entre les deux soit balanc
    # count doit etre a zero pour que ce soit le cas
    bool2 = 0
    count = -1 # On compte -1 pour un symbole ouvrant, +1 pour un fermant
    I_OUVR=j 
    k=j+1
    
    Tant que (k<=IMAX) et (bool2=0)
        Si SYM(k) n'est pas un fermant
            count=count-1
            k=k+1
        sinon count = count + 1
              Si SYM(k)=partenaire(SYM(I_OUVR)) et (count=0)
                  bool2=1
                  Si indice_droit(SYM(k)) > indice_droit(selection)
                      bool1=1
        endif
        
    Si k>IMAX  # On n'a pas trouv de fermant convenable
        "Impossible de balancer"
        return
    
    # Sinon on a un fermant convenable
    # Si bool1 = 1, on va sortir de la boucle while
    # Sinon ca signifie qu'on a trouv le fermant mais avant la fin de la
    # slection donc on recommence avec l'ouvrant suivant.
        
    j=j-1
                  
endwhile

# Si on arrive ici, alors on a trouv ce qu'on cherchait !         
On met a jour la slection pour pouvoir recommencer.

=====================================================================
