[Résolu]L'objet TIMER perturbe les GOSUB et/ou les FREE ?

Bonjour,

Je rencontre un problème assez bizarre...
Voila j'ai écris quelques procédures que je suis en train de tester.
Je souhaiterai pouvoir quantifier (grossièrement) la durée d'exécution de celles-ci.

Donc j'ai créé un timer (bdt de 100ms) que j'active avant le lancement des procédures (DBG_ProcTimer_ON) et que je désactive en fin de traitement (DBG_ProcTimer_OFF). Ce timer incrémente un simple compteur que j'affiche en fin de traitement.

Si je lance mon programme sans l'activation du timer (mise en commentaire de la ligne 100) -> tout se passe bien.

Par contre si j'active le timer : j'obtiens un gros merdié avec des erreurs "virtuelles"...

Pourtant ce timer (on dehors de la durée d'exécution) ne devrait pas avoir d'incidence sur le bon déroulement du programme...

C'est peut-être lié avec l'utilisation de la commande FREE ou à l'utilisation intensive des GOSUB ?... scratch

Pour ceux qui veulent y jeter un coup d'oeil, voivi mon programme de test:

Code:: HIDE 0:HEIGHT 0,600:WIDTH 0,(SCREEN_X/2)-50:TOP 0,SCREEN_Y/3:LEFT 0,50

' ==============================================================================
' Procédures validées
' ==============================================================================
LABEL ABR_Insert
LABEL ABR_Profondeur
LABEL ABR_Recherche,ABR_RechercheIter
LABEL ABR_ParcoursInfixe
LABEL ABR_Hauteur

' Procédures de test :
LABEL TEST_Recherche
LABEL TEST_Profondeur
LABEL TEST_Affiche
LABEL TEST_AfficheLstResult
LABEL TEST_Hauteur

LABEL CreateObject
LABEL PILE_Clr
LABEL STRCMP
' ==============================================================================
' Procédures à valider
' ==============================================================================
LABEL AVL_RotD
LABEL AVL_RotG

' ==============================================================================
' CONSTANTES
' ==============================================================================
DIM DEBUG:DEBUG=1
DIM PILE:PILE=100
DIM LST_KEY:LST_KEY=101
DIM LST_RESULT: LST_RESULT=102
DIM DBG_TIMER
IF DEBUG = 0
DLIST PILE
ELSE
LIST PILE:FORM 1:PARENT PILE,1:LEFT 1, LEFT(0)+WIDTH(0)
LABEL DBG_ProcTimer,DBG_ProcTimer_OFF,DBG_ProcTimer_ON
DIM DBG_Duree
GOSUB CreateObject: DBG_TIMER=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
TIMER DBG_TIMER:TIMER_INTERVAL DBG_TIMER,100:ON_TIMER DBG_TIMER, DBG_ProcTimer
TIMER_OFF DBG_TIMER
END_IF

DIM RACINE:RACINE=1
DIM NB_MAX:NB_MAX=100
DIM NB_CHAMPS:NB_CHAMPS=4
DIM CLE:CLE=0
DIM GAUCHE:GAUCHE=1
DIM DROITE:DROITE=2
DIM HAUTEUR:HAUTEUR=3

DLIST LST_KEY
DLIST LST_RESULT

'
' 0 : cle
' 1 : gauche
' 2 : droite
' 3 : hauteur
DIM Arbre(NB_MAX,NB_CHAMPS-1),retour

SHOW 0
ITEM_ADD PILE,"Haut de pile"
DIM A$

' Cet ordre correspond pour l'instant à un arbre équilibré :

' DATA "Philippe","Hervé","William","Denis","Laurent","Thierry","Yvan","Bernard","Françoise","Jean","Nicolas"
' DATA "Roger","Vincent","Xavier","Zoé","Albert","Celine","Etienne","Gilles","Isabelle","Kevin"
' DATA "Martine","Odile","Quentin","Sophie","Ursule"
DATA "Denis","Bernard","Cédric","Alain","Fabien"
DATA "###"
'
' [P]
' _____________/ \_____________
' [H] [W]
' _____/ \_____ _____/ \_____
' [D] [L] [T] [Y]
' / \ / \ / \ / \
' [B] [F] [J] [N] [R] [V] [X] [Z]
' / \ / \ / \ / \ / \ /
' [A] [C] [E] [G] [I] [K] [M] [O] [Q] [S] [U]
'
' [01]
' _________________/\_________________
' [02] [03]
' _______/\_______ _______/\_______
' [04] [05] [06] [07]
' __/\__ __/\__ __/\__ __/\__
' [08] [09] [10] [11] [12] [13] [14] [15]
' /\ /\ /\ /\ /\ /
' [16][17] [18][19] [20][21] [22][23] [24][25] [26]

DIM I
IF DEBUG=1 THEN GOSUB DBG_ProcTimer_ON

PRINT "--- INSERTION -----------------------------------------"
PRINT "RACINE:";RACINE

READ A$
WHILE A$<>"###"
PRINT "Insertion de :"; A$
ITEM_ADD PILE,STR$(RACINE):ITEM_ADD PILE,A$:GOSUB ABR_Insert
READ A$
END_WHILE
PRINT:PRINT "--- RECHERCHE -----------------------------------------------"
ITEM_ADD PILE,"Albert":GOSUB TEST_Recherche
ITEM_ADD PILE,"Fabien":GOSUB TEST_Recherche
PRINT "--- AFFICHAGE -----------------------------------------------"
ITEM_ADD PILE,STR$(RACINE):ITEM_ADD PILE,STR$(0) : GOSUB TEST_Affiche
PRINT:PRINT "--- PROFONDEUR ----------------------------------------------"
ITEM_ADD PILE,"Albert":GOSUB TEST_Profondeur
ITEM_ADD PILE,"Denis":GOSUB TEST_Profondeur
ITEM_ADD PILE,"Bernard":GOSUB TEST_Profondeur
ITEM_ADD PILE,"Fabien":GOSUB TEST_Profondeur
ITEM_ADD PILE,"Alain":GOSUB TEST_Profondeur
PRINT:PRINT "--- PARCOURS INFIXE -----------------------------------------"
GOSUB ABR_ParcoursInfixe : GOSUB TEST_AfficheLstResult
PRINT:PRINT "--- HAUTEUR -------------------------------------------------"
ITEM_ADD PILE,STR$(RACINE):GOSUB TEST_Hauteur
ITEM_ADD PILE,STR$(Arbre(RACINE,GAUCHE)):GOSUB TEST_Hauteur
ITEM_ADD PILE,STR$(Arbre(RACINE,DROITE)):GOSUB TEST_Hauteur

IF DEBUG=1 THEN GOSUB DBG_ProcTimer_OFF
END

' ******************************************************************************
' ******************************************************************************
' ******************************************************************************

DBG_ProcTimer:
DBG_Duree = DBG_Duree + 1
RETURN
DBG_ProcTimer_ON:
DBG_Duree=0:TIMER_ON DBG_TIMER
RETURN
DBG_ProcTimer_OFF:
TIMER_OFF DBG_TIMER
PRINT "Durée:";DBG_Duree
RETURN

' ------------------------------------------------------------------------------
' ------------------------------------------------------------------------------
AVL_RotD:
IF VARIABLE("AVL_RotD_Pivot")=0 THEN DIM AVL_RotD_Pivot,AVL_RotD_id
AVL_RotD_id = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
AVL_RotD_pivot= Arbre(AVL_RotD_id,GAUCHE)
Arbre(AVL_RotD_id,GAUCHE)=Arbre(AVL_RotD_pivot,DROITE)
Arbre(AVL_RotD_pivot,DROITE)=AVL_RotD_id
ITEM_ADD PILE,STR$(AVL_RotD_pivot)
RETURN

' ------------------------------------------------------------------------------
' ------------------------------------------------------------------------------
AVL_RotG:
IF VARIABLE("AVL_RotG_Pivot")=0 THEN DIM AVL_RotG_Pivot,AVL_RotG_id
AVL_RotG_id = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
AVL_RotG_pivot = Arbre(AVL_RotG_id,DROITE)
Arbre(AVL_RotG_id,DROITE)=Arbre(AVL_RotG_pivot,GAUCHE)
Arbre(AVL_RotG_pivot,GAUCHE)=AVL_RotG_id
ITEM_ADD PILE,STR$(AVL_RotG_pivot)
RETURN

' ==============================================================================
' Affichage de l'arbre
' R
' |->A
' | |->C
' | |->D
' |->B
' |->E
' |->F
' ==============================================================================
TEST_Affiche:
IF VARIABLE("Test_affiche_hauteur")=0
DIM Test_affiche_hauteur,Test_affiche_i,Test_affiche_prof,Test_affiche_id
END_IF
Test_affiche_prof = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
Test_affiche_id=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
IF Test_affiche_prof<>0
FOR Test_affiche_i=0 TO Test_affiche_prof-1
PRINT " ";
NEXT Test_affiche_i
PRINT "|___ ";
END_IF
PRINT ITEM_READ$(LST_KEY,Arbre(Test_affiche_id,CLE))
IF Arbre(Test_affiche_id,DROITE)<>0
' sauvegarde du contexte
ITEM_ADD PILE,STR$(Test_affiche_id)
ITEM_ADD PILE,STR$(Test_affiche_prof)
' appel
ITEM_ADD PILE,STR$(Arbre(Test_affiche_id,DROITE)):ITEM_ADD PILE,STR$(Test_affiche_prof+1)
GOSUB TEST_Affiche
' restitution du contexte
Test_affiche_prof = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
Test_affiche_id=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
END_IF
IF Arbre(Test_affiche_id,GAUCHE)<>0
' sauvegarde du contexte
ITEM_ADD PILE,STR$(Test_affiche_id)
ITEM_ADD PILE,STR$(Test_affiche_prof)
' appel
ITEM_ADD PILE,STR$(Arbre(Test_affiche_id,GAUCHE)):ITEM_ADD PILE,STR$(Test_affiche_prof+1)
GOSUB TEST_Affiche
' restitution du contexte
Test_affiche_prof = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
Test_affiche_id=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
END_IF

RETURN

' ==============================================================================
' Retourne la hauteur d'un noeud
' ==============================================================================
ABR_Hauteur:
IF VARIABLE("ABR_Hauteur_entry")=0
DIM ABR_Hauteur_entry, ABR_Hauteur_id, ABR_Hauteur_max, ABR_Hauteur_cpt
ABR_Hauteur_id=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
ABR_Hauteur_entry=ABR_Hauteur_id
END_IF

if Arbre(ABR_Hauteur_id, GAUCHE)<>0
ABR_Hauteur_cpt=ABR_Hauteur_cpt+1
ABR_Hauteur_max=max(ABR_Hauteur_max,ABR_Hauteur_cpt)
ITEM_ADD PILE, STR$(ABR_Hauteur_id) : ' Sauvegarde dans la pile
ABR_Hauteur_id=Arbre(ABR_Hauteur_id, GAUCHE) : GOSUB ABR_Hauteur
' Restitution du contexte
ABR_Hauteur_id= ITEM_READ$(PILE, COUNT(PILE)) : GOSUB PILE_Clr
END_IF
IF Arbre(ABR_Hauteur_id, DROITE)<>0
ABR_Hauteur_cpt=ABR_Hauteur_cpt+1
ABR_Hauteur_max=max(ABR_Hauteur_max,ABR_Hauteur_cpt)
ITEM_ADD PILE, STR$(ABR_Hauteur_id)
ABR_Hauteur_id=Arbre(ABR_Hauteur_id, DROITE) : GOSUB ABR_Hauteur
ABR_Hauteur_id= ITEM_READ$(PILE, COUNT(PILE)): GOSUB PILE_Clr
END_IF
ABR_Hauteur_cpt=ABR_Hauteur_cpt-1
IF ABR_Hauteur_cpt=-1
ITEM_ADD PILE,STR$(ABR_Hauteur_max)
ABR_Hauteur_max=0
ABR_Hauteur_cpt=0
END_IF
IF ABR_Hauteur_id = ABR_Hauteur_entry
FREE ABR_Hauteur_entry : FREE ABR_Hauteur_id : FREE ABR_Hauteur_max : FREE ABR_Hauteur_cpt
END_IF
RETURN
TEST_Hauteur:
DIM TEST_Hauteur_id
TEST_Hauteur_id=Arbre(VAL(ITEM_READ$(PILE,COUNT(PILE))),CLE)
PRINT "Hauteur('";ITEM_READ$(LST_KEY,TEST_Hauteur_id);"')= ";
GOSUB ABR_Hauteur
PRINT ITEM_READ$(PILE,COUNT(PILE)) : GOSUB PILE_Clr
FREE TEST_Hauteur_id
RETURN

' ==============================================================================
' Retourne la profondeur d'un noeud
' h = Profondeur("Clé")
' ==============================================================================
ABR_Profondeur:
DIM ABR_Profondeur_return,ABR_Profondeur_val
GOSUB ABR_Recherche
ABR_Profondeur_val = VAL(ITEM_READ$(PILE,COUNT(PILE))): GOSUB PILE_Clr
ABR_Profondeur_return = VAL(ITEM_READ$(PILE,COUNT(PILE))): GOSUB PILE_Clr
IF ABR_Profondeur_val = 0 THEN ABR_Profondeur_return=0
ITEM_ADD PILE, STR$(ABR_Profondeur_return-1)
FREE ABR_Profondeur_return : FREE ABR_Profondeur_val
RETURN
TEST_Profondeur:
IF COUNT(PILE)=0 THEN "TEST_Profondeur: Erreur de pile":RETURN
PRINT "Profondeur('";ITEM_READ$(PILE,COUNT(PILE));"') = ";
GOSUB ABR_Profondeur
PRINT ITEM_READ$(PILE,COUNT(PILE)):GOSUB PILE_Clr
RETURN

' ==============================================================================
' Affiche la liste des résultats
' ==============================================================================
TEST_AfficheLstResult:
IF COUNT(LST_RESULT)<>0
DIM TEST_AfficheLstResult_i,TEST_AfficheLstResult_j
TEST_AfficheLstResult_j = VAL(ITEM_READ$(LST_RESULT,1))
PRINT ITEM_READ$(LST_KEY,Arbre(TEST_AfficheLstResult_j,CLE));
FOR TEST_AfficheLstResult_i = 2 TO COUNT(LST_RESULT)
TEST_AfficheLstResult_j = VAL(ITEM_READ$(LST_RESULT,TEST_AfficheLstResult_i))
PRINT ",";ITEM_READ$(LST_KEY,Arbre(TEST_AfficheLstResult_j,CLE));
NEXT TEST_AfficheLstResult_i
PRINT
FREE TEST_AfficheLstResult_i : FREE TEST_AfficheLstResult_j
END_IF
RETURN

' ==============================================================================
' Parcours de l'arbre dans l'ordre de la clé.
' Retour dans LST_RESULT
' ==============================================================================
ABR_ParcoursInfixe:
IF VARIABLE("ABR_ParcoursInfixe_entry")=0
DIM ABR_ParcoursInfixe_entry:ABR_ParcoursInfixe_entry=COUNT(PILE)
DIM Parcours_id: Parcours_id = RACINE
CLEAR LST_RESULT
END_IF
IF Arbre(Parcours_id, GAUCHE)<>0
ITEM_ADD PILE, STR$(Parcours_id) : Parcours_id = Arbre(Parcours_id, GAUCHE)
GOSUB ABR_ParcoursInfixe
Parcours_id = ITEM_READ$(PILE, COUNT(PILE)) : GOSUB PILE_Clr
END_IF
ITEM_ADD LST_RESULT,STR$(Parcours_id)
IF Arbre(Parcours_id, DROITE)<>0
ITEM_ADD PILE, STR$(Parcours_id) : Parcours_id = Arbre(Parcours_id, DROITE)
GOSUB ABR_ParcoursInfixe
Parcours_id = ITEM_READ$(PILE, COUNT(PILE)) : GOSUB PILE_Clr
END_IF
IF COUNT(PILE)=ABR_ParcoursInfixe_entry
FREE Parcours_id : FREE ABR_ParcoursInfixe_entry
END_IF
RETURN

' ==============================================================================
' Recherche d'un élément dans un arbre
' ==============================================================================
' resultat, nb_comparaisons = ABR_Recherche("clé")
' Renvoi 0 si pas trouvé sinon renvoi l'indice de LST_KEY
' Note : Renvoie 2 valeurs.
' ------------------------------------------------------------------------------
ABR_Recherche:
' Si 1er passage :
IF VARIABLE("ABR_Recherche_return")=0
DIM ABR_Recherche_value, ABR_Recherche_return
DIM ABR_Recherche_Nb , ABR_Recherche_key$, ABR_Recherche_id
ABR_Recherche_key$ = ITEM_READ$(PILE,COUNT(PILE)): GOSUB PILE_Clr
ITEM_ADD PILE,STR$(RACINE)
ABR_Recherche_Nb = 0
END_IF

ABR_Recherche_id = VAL(ITEM_READ$(PILE,COUNT(PILE))) : GOSUB PILE_Clr
IF ABR_Recherche_id = 0 :' Si on est arrivé sur une terminaison : on a pas trouvé !
ABR_Recherche_return = 0 : ABR_Recherche_id=-1
ELSE : ' comparaison des clés
ITEM_ADD PILE,ABR_Recherche_key$: ITEM_ADD PILE,ITEM_READ$(LST_KEY, Arbre(ABR_Recherche_id, 0))
GOSUB STRCMP
ABR_Recherche_Nb = ABR_Recherche_Nb + 1
ABR_Recherche_value = VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
SELECT ABR_Recherche_value
CASE -1: ITEM_ADD PILE,Arbre(ABR_Recherche_id,GAUCHE):GOSUB ABR_Recherche
CASE 1: ITEM_ADD PILE,Arbre(ABR_Recherche_id,DROITE):GOSUB ABR_Recherche
CASE 0: ABR_Recherche_return = ABR_Recherche_id : ABR_Recherche_id=-1
END_SELECT
END_IF

IF VARIABLE("ABR_Recherche_return")=0 THEN RETURN

ITEM_ADD PILE,STR$(ABR_Recherche_Nb) : ITEM_ADD PILE,STR$(ABR_Recherche_return)
FREE ABR_Recherche_value : FREE ABR_Recherche_return : FREE ABR_Recherche_Nb
FREE ABR_Recherche_key$ : FREE ABR_Recherche_id
RETURN
' ==============================================================================
' méthode itéractive:
ABR_RechercheIter:
DIM ABR_RechercheIter_id, ABR_RechercheIter_return, ABR_RechercheIter_Nb
ABR_RechercheIter_id = RACINE
ABR_RechercheIter_return = 1 : ABR_RechercheIter_Nb = 0
WHILE (ABR_RechercheIter_return <> 0) AND (ABR_RechercheIter_id <> 0)
ITEM_ADD PILE,ITEM_READ$(PILE,COUNT(PILE)) : ' lecture de s1
ITEM_ADD PILE,ITEM_READ$(LST_KEY,Arbre(ABR_RechercheIter_id,CLE)) : ' lecture de s2
GOSUB STRCMP : ABR_RechercheIter_Nb = ABR_RechercheIter_Nb + 1
' retour de comparaison
ABR_RechercheIter_return = VAL(ITEM_READ$(PILE, COUNT(PILE))) : GOSUB PILE_Clr
SELECT ABR_RechercheIter_return
CASE -1:ABR_RechercheIter_id = Arbre(ABR_RechercheIter_id, GAUCHE)
CASE 1: ABR_RechercheIter_id = Arbre(ABR_RechercheIter_id, DROITE)
END_SELECT
END_WHILE
GOSUB PILE_Clr : ' suppression de s1 dans la pile
ITEM_ADD PILE, STR$(ABR_RechercheIter_Nb) : ' ajout du résultat
ITEM_ADD PILE, STR$(ABR_RechercheIter_id) : ' ajout du résultat
FREE ABR_RechercheIter_id : FREE ABR_RechercheIter_return : FREE ABR_RechercheIter_Nb
RETURN

TEST_Recherche:
IF COUNT(PILE)=0 THEN MESSAGE "TEST_Recherche: Erreur":RETURN
DIM Test_recherche_str$, Test_recherche_result, Test_recherche_nbComp
' on garde ce paramètre dans la pile, car nécessaire pour l'appel à ABR_Recherche
Test_recherche_str$=ITEM_READ$(PILE,COUNT(PILE))
PRINT "Recherche('";Test_recherche_str$;"')= ";
GOSUB ABR_Recherche : ' result,nb_comp = ABR_Recherche("Clé")
' la procédure ABR_Recherche a ajouté 2 variables dans la pile :
Test_recherche_result=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
Test_recherche_nbComp=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
' Affichage du résultat
ITEM_ADD PILE,Test_recherche_str$ : ' sauvegarde provisoire de notre variable
Test_recherche_str$="Trouvé,"
IF Test_recherche_result=0 THEN Test_recherche_str$="Non trouvé,"
PRINT Test_recherche_str$;
PRINT " en ";Test_recherche_nbComp;" comparaison";
IF Test_recherche_nbComp>1 THEN PRINT "s";
IF Test_recherche_result>0
PRINT " : LST_KEY(";Test_recherche_result;")"
ELSE
PRINT
END_IF
' on récupère la sauvegarde de notre variable
Test_recherche_str$=ITEM_READ$(PILE,COUNT(PILE)):GOSUB PILE_Clr

PRINT "RechercheIter('";Test_recherche_str$;"')= ";
ITEM_ADD PILE,Test_recherche_str$: GOSUB ABR_RechercheIter
' la procédure ABR_Recherche a ajouté 2 variables dans la pile :
Test_recherche_result=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
Test_recherche_nbComp=VAL(ITEM_READ$(PILE,COUNT(PILE))):GOSUB PILE_Clr
' Affichage du résultat
Test_recherche_str$="Trouvé,"
IF Test_recherche_result=0 THEN Test_recherche_str$="Non trouvé,"
PRINT Test_recherche_str$;
PRINT " en ";Test_recherche_nbComp;" comparaison";
IF Test_recherche_nbComp>1 THEN PRINT "s";
IF Test_recherche_result>0
PRINT " : LST_KEY(";Test_recherche_result;")"
ELSE
PRINT
END_IF
PRINT
FREE Test_recherche_str$ : FREE Test_recherche_result : FREE Test_recherche_nbComp
RETURN

' ==============================================================================
' Insertion d'une nouvelle clé dans l'Arbre Binaire de Recherche
' ==============================================================================
ABR_Insert:
IF VARIABLE("ABR_Insert_id")=0
DIM ABR_Insert_id:ABR_Insert_id=-1
DIM ABR_Insert_str$,ABR_Insert_value
END_IF
IF ABR_Insert_id=-1
ABR_Insert_str$=ITEM_READ$(PILE,COUNT(PILE)): GOSUB PILE_Clr
END_IF
ABR_Insert_id=VAL(ITEM_READ$(PILE,COUNT(PILE))): GOSUB PILE_Clr

IF COUNT(LST_KEY)=0
ITEM_ADD LST_KEY,ABR_Insert_str$: Arbre(ABR_Insert_id,CLE)=COUNT(LST_KEY)
Arbre(ABR_Insert_id,GAUCHE)=0:Arbre(ABR_Insert_id,DROITE)=0
ABR_Insert_id=-1
ELSE
ITEM_ADD PILE,ABR_Insert_str$:ITEM_ADD PILE,ITEM_READ$(LST_KEY,Arbre(ABR_Insert_id,CLE)): GOSUB STRCMP
ABR_Insert_value = VAL(ITEM_READ$(PILE,COUNT(PILE))) : GOSUB PILE_Clr: ' pour STRCMP
SELECT ABR_Insert_value
CASE -1
IF Arbre(ABR_Insert_id,GAUCHE)=0
ITEM_ADD LST_KEY,ABR_Insert_str$
Arbre(ABR_Insert_id,GAUCHE)=COUNT(LST_KEY)
Arbre(COUNT(LST_KEY),CLE)=COUNT(LST_KEY)
Arbre(COUNT(LST_KEY),GAUCHE)=0:Arbre(COUNT(LST_KEY),DROITE)=0
ABR_Insert_id=-1
ELSE
ITEM_ADD PILE,STR$(Arbre(ABR_Insert_id,GAUCHE)):GOSUB ABR_Insert
END_IF
CASE 0
RETURN : ' pas de doublon pour l'instant
CASE 1
IF Arbre(ABR_Insert_id,DROITE)=0
ITEM_ADD LST_KEY,ABR_Insert_str$
Arbre(ABR_Insert_id,DROITE)=COUNT(LST_KEY)
Arbre(COUNT(LST_KEY),CLE)=COUNT(LST_KEY)
Arbre(COUNT(LST_KEY),GAUCHE)=0:Arbre(COUNT(LST_KEY),DROITE)=0
ABR_Insert_id=-1
ELSE
ITEM_ADD PILE,STR$(Arbre(ABR_Insert_id,DROITE)):GOSUB ABR_Insert
END_IF
END_SELECT
END_IF

RETURN

' ==============================================================================
' Supression du dernier élément de la pile
' ==============================================================================
PILE_Clr:
ITEM_DELETE PILE, COUNT(PILE)
RETURN

' ==============================================================================
' Comparaison de chaine de caractère
' ==============================================================================
' Retour = STRCMP(S1,S2)
' -1:inferieure 0:egale 1:superieure
' ------------------------------------------------------------------------------
STRCMP:
DIM STRCMP_s1$, STRCMP_s2$, STRCMP_return : ' déclaration des variables temporaires
STRCMP_s2$ = ITEM_READ$(PILE, COUNT(PILE)) : GOSUB PILE_Clr
STRCMP_s1$ = ITEM_READ$(PILE, COUNT(PILE)) : GOSUB PILE_Clr
' IF DEBUG = 1 THEN PRINT " -->compare(";STRCMP_s1$;",";STRCMP_s2$;")"
STRCMP_return = 1
IF (STRCMP_s1$ = STRCMP_s2$)
STRCMP_return = 0
ELSE
' création de notre liste temporaire
DIM STRCMP_lst : GOSUB CreateObject
STRCMP_lst = VAL(ITEM_READ$(PILE, COUNT(PILE))) : GOSUB PILE_Clr
DLIST STRCMP_lst
ITEM_ADD STRCMP_lst, STRCMP_s1$ : ITEM_ADD STRCMP_lst, STRCMP_s2$ : SORT STRCMP_lst
IF STRCMP_s1$ = ITEM_READ$(STRCMP_lst, 1) THEN STRCMP_return = -1
DELETE STRCMP_lst : FREE STRCMP_lst
END_IF
ITEM_ADD PILE, STRCMP_return
FREE STRCMP_s1$ : FREE STRCMP_s2$ : FREE STRCMP_return
RETURN

' ==============================================================================
' Recherche de n° d'objet disponible
' ==============================================================================
' retour = CreateObject()
' ------------------------------------------------------------------------------
CreateObject:
DIM CreateObject_id : CreateObject_id = 1
WHILE OBJECT_EXISTS(CreateObject_id) = 1 : CreateObject_id = CreateObject_id + 1 : END_WHILE
ITEM_ADD PILE, STR$(CreateObject_id) : FREE CreateObject_id
RETURN

Désolé, je suis au boulot et ce soir, je serais déjà occupé, mais bon courage Nardo

J'ai trouvé !
Erreur de débutant : J'essaye de faire fonctionner un timer avant l'execution du END...

Bien joué Nardo Smile

De toute manière, je ne peux pas faire ce que je souhaite.
Car il faudrait que mon traitement soit dans une procédure déclenchée sur évènement et donc durant toute la durée de celle-ci, le timer est bloqué...
comme le montre cet exemple :

Code:: LABEL Debut,Compte
DIM cpt,i
BUTTON 1:CAPTION 1,"Start"
ON_CLICK 1,Debut
TIMER 2:TIMER_OFF 2:ON_TIMER 2,Compte:TIMER_INTERVAL 2,100

END
Compte:
cpt=cpt+1
RETURN

Debut:
TIMER_ON 2
FOR i=0 TO 500
WAIT 1
NEXT i
TIMER_OFF 2
CAPTION 0,STR$(cpt)
RETURN

Sauf si tu appelles une DLL qui récupère (par l'API Windows par exemple) l'heure système que tu appelerais en début et en fin de traitement pour avoir la différence en milisecondes

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Le timer n'agit pas comme une interruption dans un système temps réel, il n'y a rien d'interruptible dans ta boucle (même le wait...), donc le code se déroule en entier avant d'exécuter le timer.

Pour ce genre d'application (mesure du temps) c'est dommage qu'on ne dispose pas d'une horloge avec une précision meilleure que la seconde comme actuellement, c'est un vrai manque. Il faudrait faire un peu d'assembleur mais ce n'est pas possible sous Panoramic.
En Basic il y avait la fonction TIMER qui donnait l'heure au 1/18e de seconde, c'était déjà ça.

Ou alors peut-être une dll, comme dit Jicehel... à appeler avant et après.

Suite à mes cogitations, je me suis fait une petite DLL qu me permet de calculer le TIME_USER (en ms) mais pas le CPU_TIME...
C'est toujours mieux que rien... Wink

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

CPU_TIME j'imagine ce que c'est, mais le TIME_USER, quès aco ?

Heu Nardo, je suis sûr que tu va mettre cette DLL sur ton site, je pense qu'elle servira beaucoup aussi pour les benchmark et les tests d'optimisations.

CPU_TIME : c'est le temps consacré par la CPU pour exécuter chaque instruction de ton programme
USER_TIME: c'est le temps total d'exécution de ton prog (qui varie en fct de la charge du micro)

Si tu as 0 application qui tourne: il n'y a que de ton prog, on peut dire que USER_TIME = CPU_TIME
Maintenant si tu te balades sur le net pendant l'execution de ton prog, USER_TIME > CPU_TIME

Je sais pas trop si je fais une DLL spécifique à cette fonction ou si je l'intègre dans Utils.dll
La taille de cette DLL commence à être conséquente... scratch

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Merci Nardo, je me coucherai moins idiot ce soir... (je n'ose pas dire plus intelligent).

Maintenant ça m'intéresse modérément, ce qui serait bien ce serait de pouvoir mesurer la durée entre l'instant t1 et l'instant t2, pour mesurer la durée d'exécution d'une partie de programme (et non d'un programme entier).

NB je ne comprends pas trop...

Citation :: CPU_TIME : c'est le temps consacré par la CPU pour exécuter chaque instruction de ton programme
USER_TIME: c'est le temps total d'exécution de ton prog (qui varie en fct de la charge du micro)
Si tu as 0 application qui tourne: il n'y a que de ton prog, on peut dire que USER_TIME = CPU_TIME

???

Disons que ton micro ne s'occupe pas que de ton programme,
il s'occupe par exemple de tous les évènements qui arrivent: la souris, le clavier, etc...

Le temps du micro est "tronçonné/partagé" en fct des applic qui tournent.

Le temps CPU, c'est le temps d'execution total de ton programme si le CPU est consacré à 100% à celui-ci...

J'ai mis en ligne sur mon site une petite DLL (rubrique divers) qui ne contient que cette fonction... (14Ko)

Citation :: ...ce serait de pouvoir mesurer la durée entre l'instant t1 et l'instant t2, pour mesurer la durée d'exécution d'une partie de programme...

Elle fait justement cela... Wink

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Je comprends mieux si "le temps CPU c'est le temps d'exécution total de ton programme..."
Et non pas comme tu avais dit "le temps d'exécution de chaque instruction du programme Very Happy

Nonobstant (j'aime bien ce mot, ça fait classe !), merci pour les précisions.

PS alors ta dll m'intéresse... en attendant une fonction Panoramic...

Ben c'est pas clair non plus "temps d'exécution total de ton programme"... Wink

Imaginons que les lignes de ton prog de calcul mis bout-à-bout s'exécutent en 200ms mais qu'a côté de ça, tu as µCro$oft internet explozer qui essaye péniblement de t'afficher un Flash, le spooler d'impression qui bosse comme un dur et d'autres programmmes inutiles (et donc indispensables) qui tournent, ton programme au final va mettre, vu côté utilisateur, 2 minutes pour te recracher son résultat (bon j'exagère un tout petit peu... Wink

)
Tu vas obtenir : temps CPU : 200ms et temps User : 2 minutes

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Ben oui, c'est la vie, ça je le comprends.

(incidemment j'ai regardé les dll de ton site, j'ai repéré le GetCount, GetMouseXY et Execute(Wait), intéressant tout ça).
Un truc qui me manque, c'est de ne pas pouvoir intercepter le clic droit avec Panoramic.
Exemple: j'ai une LIST, avec par exemple une liste de fichiers, avec ON_CLICK je fais une action, mais je voudrais pouvoir réagir sur le clic droit, par exemple afficher des renseignements sur le fichier. Malheureusement le ON_CLICK ne réagit que sur le clic gauche...
Je pensais au GetMouseXY, mais finalement ça ne m'aide pas... sauf à mettre un timer pour surveiller le clic mais je n'aime pas trop.

Là je peux pas faire grand chose sur l'évènement clic droit...
par contre je peux te faire une fonction qui t'ouvre la boite des propriétés de ton fichier...

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

C'est sympa, mais ça je peux le faire avec des moyens plus... triviaux. Par exemple si c'est une image (c'est mon cas) afficher ses caractéristiques, une imagette, etc.

Ce que je voudrais c'est brancher quelque part si l'utilisateur a cliqué du droit sur un article.
Dommage que Jack ne réagisse pas en ON_CLICK indifféremment sur droite ou gauche, quitte à tester ensuite dans le sous-programme si on veut les distinguer l'un de l'autre et faire un traitement particulier.
J'en avais déjà parlé, il y a bien des lunes...

Invité

Citation :: ON_CLICK indifféremment sur droite ou gauche

petit programme pour avoir un évènement sur le clic droit
Je suis en train de faire des essais, et je dois me servir d'un autre langage.
Ce n'est pas une dll, mais un programme.

Faire ce programme est une façon de l'apprendre.
télécharger le ZIP
J'ai oublié de dire qu'il s'agit de tester le clic droit, et de le rendre évènementiel, ceci grâce à l'évènement ON_CHANGE d'un edit.

J'ai remis le zip avec la fermeture depuis le programme. (pour la 1ère version, ce n'était pas le cas)
prg certainement à mettre à la poubelle, vu qu'un seul téléchargement, et c'est pas la première fois (et peut-être le mien par erreur). Je pense que je me suis fait des idées sur mon utilité, et qu'un break s'impose. Il y a suffisamment de gens compétents et qui valent mieux que moi, pour que je m'éclipse.

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Ne dis pas de bêtises cosmos, ton programme est intéressant, comme toujours.

Ton intervention m'avait échappé, mais ça ne répond pas tout à fait à ce que souhaiterais, c'est à dire une action sur le clic droit qui me donnerait le rang de l'article cliqué dans un LIST, exactement comme pour le clic gauche.

Je suis incapable de savoir quel article a été cliqué (du bouton droit) avec simplement les coordonnées du clic, c'est toujours le même problème, ça dépend de la fonte, mais surtout du fait s'il y a eu défilement ou non.

Toujours fidèle à sa mauvaise humeur le cosmos ! Very Happy

Mais non, on ne dénigre pas ton programme !!
Regarde, ma librairie AVL n'emballe pas les foules non plus :
Les gens se disent Kesako? C'est de la masturbation intellectuelle du 4eme degrés !
J'ai eu une réponse polie de ta part, de celle de Jicehel et de JL35 (histoire de dire c'est interessant mais j'en vois pas trop l'utilité...)

Je ne m'en vexe pas pour autant et je continu dans mon petit délire... Wink

Pareil, désolé Cosmos, j'essaye de regarder les posts à chaque fois, je ne sais pas pourquoi celui-ci m'a échappé... Ca semble répondre au besoin exprimé à première vue.
PS: Nardo, ton programme est très intéressant, mais en effet, actuellement, je n'ai pas d'idées pour l'exploiter, mais tu as raison de ne pas t'en offusquer, avec un truc que tu as mis sur ton site pour pouvoir faire de vrai recherches sur le forums, il y a bien un jour où on l'exploitera pour accéder rapidement à des données.

PS2: le seul truc qui est dommage, c'est que les fichiers que l'on partage ne sont parfois plus accessibles lorsque l'on fait les recherches.

Donc Cosmos, continue de faire tes propositions, à ce que j'en ai lu, sur ce coup là, tu es le seul a avoir trouver une solution acceptable (meême Nardo (et pourtant, des idées, il en a ...) n'a pas trouvé une solution simple pour ajouter une fonction à sa dll sur les souris pour le faire .... Smile

)

Oui je suis curieux de savoir comment tu as détourné l'evenement du champ EDIT planqué dans les -1000... Wink

C'est basé sur le même principe que l'IPC de Klaus ?
scratch

J'ai bien compris que tu utilises le presse-papier pour passer tes paramètres à ton executable, mais comment celui-ci accède à l'edit 2? scratch

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Moi j'avoue que je n'ai pas bien compris le fonctionnement et il me manque le mode d'emploi... je clique partout mais il ne se passe rien.

» Gosub with while[resolu] oubli du END
» Trop de gosub...
» Utilitaire Designer: générer une structure Panoramic valide
» Pour une coche "résolu" RESOLU
» problème avec les appels Gosub