Le TERMINATE récalcitrant

Sujet: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 5:43

Salut tout le monde.
@Jack
Je rencontre toujours le même problème avec TERMINATE
On en a discuté ici et tu as indiqué que tu as corrigé le bug.
Cependant, ce bug revient toujours.
Voici un code (voir ci-bas) qui fait un plantage à tous les coups (au moins chez moi !) avec TERMINATE
Ligne 12

Code:: if scancode <> 0 then terminate

1) Si je sors par <ECHAP>
Access violation at adress 005A9C64 in module ‘PANORAMIC.exe.
Read of adress 00000040
Si je ferme la boîte de cette erreur par OK

Access violation at address 005A9816 in module ‘PANORAMIC.exe’.
Write of address 0000004C
Et aucun moyen de s’en sortir sauf tuer le process par <CRTL> <SHIFT> <ESC>

2) si je sors par un click
Access violation at address 005A9816 in module ‘PANORAMIC.exe’.
Write of address 0000004C
Et aucun moyen de s’en sortir sauf tuer le process par <CRTL> <SHIFT> <ESC>

Remarquez les erreurs selon la sortie par <ESC> ou par un click:
Read of adress …
Et
Write of address

Maintenant, si je modifie la ligne 12 (en ajoutant END après TERMINATE)

Code:: if scancode <> 0 then terminate : end

Là tout se passe bien et on sort du programme comme il se doit : ni message d’erreur, ni plantage, ni le désagréable ‘bing’

Remarque :
Le son émis par TERMINATE est en réalité le son Arrêt critique.wav émis par Windows (et non par PANORAMIC) quand l’événement Arrêt critique survient.

Pardon Jack, si j’insiste car c’est désagréable d’utiliser le gestionnaire de tâches de Window pour pouvoir tuer un programme qui plante !

Voici le code qui illustre le bug

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0
While Papydall = egal_a_lui_meme : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
   if scancode <> 0 then terminate : end : ' Enlevez le END et le plantage est assuré
end_while
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================

EDIT :
Ligne 12
Si je mets END en REM

Code:: if scancode <> 0 then terminate : rem end

Ou

Code:: if scancode <> 0 then terminate : ' end

Access violation … Read …
En fermant la boite par OK, on sort du programme sans plantage ni ‘bing’

Mademoiselle END est-elle nécessaire pour que Madame TERMINATE veuille bien se comporter comme on s'y attend ? Laughing

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 7:12

Intéressant ce END après TERMINATE, bien qu'en principe si end est après terminate il ne devrait pas être lu ???
Je vais tester ça dans mes prochains programmes.
Ton code montre bien le problème. je remarque qu'on a bien le END qui arrête le programme principale et que le second est nécessaire pour la sortie
A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 9:11

@Papydall,

J'ai remarqué que tu fais une sortie du programme un peu "hard".

Regarde ton code modifié. (serte la musique de fin est toujours là, mais sous W10 c'est une musique plus agréable...)

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
label fin
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0 : on_close 0,fin : caption 0,"Clic pour arrêter"
While Papydall = egal_a_lui_meme : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
' if scancode <> 0 then terminate : end : ' Enlevez le END et le plantage est assuré
   if scancode <> 0 then exit_while
end_while
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================
fin:
  terminate
return

A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 13:15

Jean Claude a écrit:: J'ai remarqué que tu fais une sortie du programme un peu "hard".

Code:: if scancode <> 0 then terminate

Je ne vois rien de si « hard » !
J’ai bien le droit de quitter mon programme en utilisant une commande (TERMINATE en l’occurrence) qui est sensée arrêter définitivement le programme en cours et libérer la mémoire utilisée par le programme.

Si je modifie le code comme ceci, TERMINATE aime bien trouver END à la suite pour se taire !

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0 : caption 0,"Clic pour arrêter"
While Papydall = egal_a_lui_meme : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
' if scancode <> 0 then terminate : end : ' Enlevez le END et le plantage est assuré
   if scancode <> 0 then exit_while
end_while

terminate : end : ' OK , tout est bien qui finit bien
' Mais si on enlève END , le programme se termine mais il y a toujours le désagréable son .
' Si on fait appel à une SUB Fin(),
' la remarque du END après TERMINATE pour supprimer le son reste valable
Fin()
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================
SUB fin()
  terminate : end : ' OK , mais sans END , on entend le mauvais son 'bing'
END_SUB
rem ============================================================================

Je pense que le problème est dans le codage de TERMINATE.
Bon, on peut toujours contourner le problème comme je l'ai montré, mais, selon moi, ça reste un BUG
Jack, si tu veux bien te pencher sur ce cas ...

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 14:11

Ce que je voulais dire, c'est que fermer le programme à l'intérieur d'une boucle c'est pas très bon.
Nous avons à disposition toutes les commandes EXIT_....

Il n'es reste pas moins que ton END change bien le comportement de terminate pour ce programme.

A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 16:04

Je pense que le problème n'est pas dans TERMINATE, mais plutôt dans SCANCODE qu'il faut éviter à tout prix. Regarde ceci:

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0
label start, abort
button 1 : caption 1,"Start" : on_click 1,start
on_click 0,abort
end
start:
hide 1
' While Papydall = egal_a_lui_meme : ' C'est original comme condition !
While 1=1 : ' C'est original comme condition !
x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
pause 20
end_while
return
abort:
terminate

rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
2d_fill_color rnd(255),rnd(255),rnd(255)
2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================

Clique simplement sur "Start". Puis, pour arrêter,tu cliques n'importe où... plus de problème !

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 17:01

Klaus a écrit:: Clique simplement sur "Start". Puis, pour arrêter,tu cliques n'importe où... plus de problème !

Pardon Klaus, mais le problème du son Arrêt critique.wav est toujours là.
Pourquoi Windows considère-t-il qu’il s’agit d’un Arrêt critique ?
Que le problème soit dans TERMINATE, dans SCANCODE ou ailleurs, il y a du pain sur la planche pour Jack.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 17:29

Une modification du code : pas de SCANCODE, pas de ON_CLICK, mais l’utilisation de la variable système INKEY$.
Pour sortir de la boucle infernale, TAPPER sur le clavier.
Remarque : INKEY$ retourne la touche tapée sur le clavier, mais n’attend pas , contrairement à INPUT qui suspend le déroulement du programme.

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
caption 0,"Pour arrêter, tappez sur le clavier"
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0
While acos(-1) = 4*atn(1) : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
   if inkey$ <> "" then terminate : end
end_while
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================

Le même problème : Si TERMINATE n’est pas suivi de END, on entend le son de l’Arrêt critique.
Par contre avec TERMINATE : END , il n’y a aucune critique.

Remarque:
Je n'utilise presque jamais dans mes code la variable système INKEY$, sauf ici pour montrer une fois de plus que l' I love you

entre TERMINATE et END est intime .

Invité

Je fais un programme depuis quelques mois, et n'ayant pas beaucoup de temps, et avec la fatigue en fin de journée, je n'avance pas. Mais ce programme que j'ai déjà causé, qui n'a aucun évènnement, fonctionne avec scancode et inkey$. Je n'ai plus de problème de message d'erreur, de blocage, de violation, etc... Le programme s’arrête normalement sans son, comme cela est le cas pour tout autre logiciel.

Même si on a remis en doute mes remarques sur la méthode de Panoramic sur les évènements, je reste convaincu, que c'est à ce niveau qu'il faut regarder. Chaque fois que j'ai fait des grands programmes, j'ai eu des violations, et j'en passe. Celui-ci fait actuellement plus de 5000 lignes, mais certaines sub sont mis de côtées, pour essayer d'autre façon de coder, donc peut-être qu'il n'y a que 4000 lignes d'actifs, mais le déroulement est normal. Je réfute le fait que ce soit scancode ou inkey$ qui est la cause, mais certainement la lecture de ceux-ci dans les évènements.

Maintenant ce sont mes constatations, mais peut-être que quelque chose m'échappe. Si d'ici Noël j'ai bien avancé, on pourra faire des comparaisons.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 18:43

Moi de mon coté j'insiste sur la sortie de la boucle.
Scancode n'est pas en cause.
Et je le prouve.

Essai 2 fois ce code tout simple, Papydall,
la première fois laisse la boucle aller au bout et la deuxième fois fais un clic
et essais ensuite en activant la ligne 4 et en désactivant la 5.

Code:: dim n%
for n%=1 to 30
print n% : pause 100
' if scancode <> 0 then terminate :' end
if scancode <> 0 then exit_for
next n%
terminate

Tel que ci-dessus le code n'a aucun END

A+

PS: Salut Cosmos, tu te fais rare Very Happy

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 19:07

@Papydall:

Citation :: Pardon Klaus, mais le problème du son Arrêt critique.wav est toujours là.
Pourquoi Windows considère-t-il qu’il s’agit d’un Arrêt critique ?
Que le problème soit dans TERMINATE, dans SCANCODE ou ailleurs, il y a du pain sur la planche pour Jack.

Oui, il y a bien un son, en sortie. C'est un problème ancien, toujours pas réglé. Mais il n'y a aucun plantage - violation de mémoire ou autre.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 19:10

Je crois que j'ai une piste, pour moi il y a un bug avec TERMINATE placé dans un sous-programme.

TERMINATE doit être impérativement placé en fin de code..

Tel quel, le programme ci-dessous ne fait pas tout le boulot et Windows détecte l'anomalie d'ou le beep.
Suivez le conseil de la ligne 17 et observez la différence.

Code:: memo 1 : left 1,50
dim n%
label fin, start, bricole

gosub start

END
rem =============================================
start:
for n%=1 to 30
print n% : pause 100
if scancode <> 0 then exit_for
next n%
gosub bricole
RETURN

' déplacez les 3 lignes ci dessous à la fin du code
fin:
terminate
return

bricole:
for n%=1 to 30
item_add 1,n% : pause 100
if scancode <> 0 then exit_for
next n%
gosub fin
RETURN

A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 19:48

@papydall:
Quand j'exécute ton premier source, je n'ai aucun plantage.
J'ai essayé sur plusieurs PC sans observer ce que vous observez ...

_________________

username : panoramic@jack-panoramic password : panoramic123

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 19:59

Bonsoir a tous !

Je viens de faire aussi le test et comme pour Jack, je n'ai aucun problème.
Je suis sous WIN 7 32bits et la dernière version de Panoramic bien sûr !

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 20:12

Je ne comprends pas

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 20:17

MEA CULPA !

Rectificatif : Je n'avais pas remarqué qu'il fallait retirer le END dans le code ! Suspect

Effectivement, j'ai bien le même probleme.

Désolé pour l'incompréhension. drunken

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 20:19

~~d'abord, je m'excuse car dans mon intervention précédente j'ai oublié de publier le code (c'est la faute de ma femme ) . Il faut que je le refasse.~~
en réalité j'ai utilisé le bouton caché (donc, balises HIDE)

Ensuite:
Pour reproduire le Bug signalé par Papydall, il faut changer la ligne 11 comme il l'indique dans le code.

çà donne ceci:

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0
While Papydall = egal_a_lui_meme : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
   if scancode <> 0 then terminate :' end : ' Enlevez le END et le plantage est assuré
end_while
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================

A+

PS: on s'est croisé Minibug, ça confirme....

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 20:41

Code:: rem ============================================================================
dim x0,y0,x1,x2,x3,y1,y2,z
dim Papydall, egal_a_lui_meme
full_space 0 : x0 = width(0)/2 : y0 = height(0)/2-25 : z = height(0)/2 - 50
2d_fill_on : color 0,0,0,0
While Papydall = egal_a_lui_meme : ' C'est original comme condition !
   x1 = rnd(z) : y1 = rnd(z) : x2 = rnd(z) : y2 = rnd(z)
   DrawRectangleAt(x1,y1,x2,y2) : DrawRectangleAt(0-x1,y1,0-x2,y2)
   DrawRectangleAt(x1,0-y1,x2,0-y2) : DrawRectangleAt(0-x1,0-y1,0-x2,0-y2)
   pause 20
   if scancode <> 0 then terminate
end_while
end
rem ============================================================================
SUB DrawRectangleAt(x1,y1,x2,y2)
   2d_fill_color rnd(255),rnd(255),rnd(255)
   2d_rectangle x0+x1,y0+y1,x0+x2,y0+y2 : 2d_circle x0+x2,y0+y2,25
END_SUB
rem ============================================================================

Si je sors par <ESC> : plantage et la validation par OK déclenche le même message et je dois tuer le process

Si je sors par un click : Message d'erreur

Après validation par OK, le programme se termine cette fois sans plantage.

Puis en ajoutant END après TERMINATE, ça se passe comme il faut avec <ESC> ou avec Click

Code:: if scancode <> 0 then terminate : end

Suis-je le seul à avoir ce comportement?

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 20:48

J'insiste à nouveau, la sortie de la boucle n'est pas correct !

Voici 2 codes pour le démontrer.

Le premier, il n'est pas bon, ça bug

Code:: memo 1 : left 1,100
dim n%
label start, continuer, fin

gosub start

END
rem ============================================
fin:
  terminate
return

start:
   for n%=1 to 30
   print n% : pause 100
   if scancode <> 0 then gosub continuer
   next n%
return

continuer:
   for n%=1 to 30
   item_add 1,n% : pause 100
   if scancode <> 0 then exit_for
   next n%
   gosub fin
return

Le deuxième, ça baigne....

Code:: memo 1 : left 1,100
dim n%
label start, continuer, fin

gosub start

END
rem ============================================
fin:
  terminate
return

start:
   for n%=1 to 30
   print n% : pause 100
   if scancode <> 0 then exit_for
   next n%
gosub continuer
return

continuer:
   for n%=1 to 30
   item_add 1,n% : pause 100
   if scancode <> 0 then exit_for
   next n%
   gosub fin
return

J'arrête là, j'en ai marre de ne pas être entendu, ni même vérifié.

A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 21:04

c'est un tout petit peu hors sujet, mais il faut que ça soit signalé...

Jean Claude a écrit:: d'abord, je m'excuse car dans mon intervention précédente j'ai oublié de publier le code (c'est la faute de ma femme Very Happy ) . Il faut que je le refasse.

Mille excuse à ma femme, car curieusement mon code apparaît bien quand je suis connecté au forum, mais pas si je le suis pas drunken

Et bizarrement ce n'est pas le cas pour les autres messages que j'ai postés.

Je ne sais pas si pour vous c'est pareil.... ?

Fin du demi-hors sujet.

PS: j'ai trouvé et corrigé ce problème. Le code est maintenant visible juste avant l'intervention de Jack.
J'ai cliqué par inattention, sur le bouton caché du coup mon code était entre 2 balises HIDE.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 21:13

@Jean-Claude:

Citation :: J'insiste à nouveau, la sortie de la boucle n'est pas correct !
Voici 2 codes pour le démontrer.
Le premier, il n'est pas bon, ça bug

Je ne constate pas la même chose. Chez moi, les deux codes fonctionnent parfaitement, pas deplantage. Par contre, le premier génère bien un son en sortie, alors que le second se termine dans son.

Constat sous W10, avec Panoramic dernière version.

Par contre, si tu modifies le premier code comme suit:

Code:: memo 1 : left 1,100
dim n%
label start, continuer, fin

gosub start

END
rem ============================================
fin:
terminate
return

start:
on_click 0,continuer
for n%=1 to 30
print n% : pause 100
' if scancode <> 0 then gosub continuer
next n%
return

continuer:
on_click 0,fin
for n%=1 to 30
item_add 1,n% : pause 100
' if scancode <> 0 then exit_for
next n%
gosub fin
return

et tu utilises le clic gauche dans la form 0 au lieu de la frappe d'une touche, alors le programme se termine bien et il n'y a pas de son !

C'est SCAN_CODE qui est à l'origine des problèmes, pas autre chose.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 21:49

Non Klaus, je ne suis pas d'accord

Regarde c'est ton programme que tu viens de poster, légèrement modifié..

Code:: memo 1 : left 1,100
dim n%
label start, continuer, fin

gosub start

END
rem ============================================

start:
  on_click 0,continuer
  for n%=1 to 30
   print n% : pause 100
' if scancode <> 0 then gosub continuer
  next n%
return

continuer:
  on_click 0,fin
  for n%=1 to 30
   item_add 1,n% : pause 100
' if scancode <> 0 then exit_for
  next n%
  gosub fin
return

fin:
  terminate
' return

En plaçant TERMINATE à la fin du code et sans return, çà marche ! ?????

A+

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 22:07

C'est vrai: par de plantage, et pas de son. Et si, dans cette version, on enlève le commentaire devant le RETURN dans la toute dernière ligne, il y a à nouveau le son !

J'en conviens: il y a bien un problème avec TERMINATE. Cela est d'ailleurs signalé depuis longtemps, et malgré une version annoncée par Jacl comme la "correction" de ce problème, ça continue.

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 23:36

Dans tous les cas, si j'ajoute END après TERMINATE, il n'y a plus de son.

Ce que je pense:
Du point de vue algorithmique, on doit avoir la possibilité de terminer un programme de n'importe quel endroit (à l'intérieur d'une boucle, à l'intérieur d'un sous-programme, etc..) en arrêtant tous les événements en cours, libérant la mémoire occupée par le programme et redonner la main au système d'exploitation.

Je pense qu'il manque quelque chose à TERMINATE.
Pourquoi avec TERMINATE : END l'arrêt est bon, alors qu'avec TERMINATE tout court, il y a émission d'un son (et parfois un plantage)?

Sujet: Re: Le TERMINATE récalcitrant Ven 2 Oct 2015 - 23:44

Une nouvelle tentative: utiliser la fonction KillProcesByHandle de KGF.dll, à la place de TERMINATE. Résultat: plus de son ! Cette fonction fait ce que TERMINATE devrait faire !

Code:: memo 1 : left 1,100
dim n%
label start, continuer, fin

gosub start

END
rem ============================================

start:
on_click 0,continuer
for n%=1 to 30
print n% : pause 100
' if scancode <> 0 then gosub continuer
next n%
return

continuer:
on_click 0,fin
for n%=1 to 30
item_add 1,n% : pause 100
' if scancode <> 0 then exit_for
next n%
gosub fin
return

fin:
dll_on "KGF.dll"
dim res%
res% = dll_call1("KillProcessByHandle",handle(0))
' terminate
' return

Voici le code de cette fonction:

Code:: function KillProcessByHandle(hWindowHandle: HWND):integer; stdcall; export; // KGF64
var
hprocessID: INTEGER;
processHandle: THandle;
DWResult: DWORD;
begin
try
SendMessageTimeout(hWindowHandle, WM_CLOSE, 0, 0, SMTO_ABORTIFHUNG or SMTO_NORMAL, 5000, DWResult);
if isWindow(hWindowHandle) then begin
{ Get the process identifier for the window}
GetWindowThreadProcessID(hWindowHandle, @hprocessID);
if hprocessID <> 0 then begin
{ Get the process handle }
processHandle := OpenProcess(PROCESS_TERMINATE or PROCESS_QUERY_INFORMATION, False, hprocessID);
if processHandle <> 0 then begin
{ Terminate the process }
TerminateProcess(processHandle, 0);
CloseHandle(ProcessHandle);
end;
end;
end;
finally
end;
result := 0;
end;

Bon, c'est "brutal", mais efficace.

Qu'est-ce que vous en pensez ?

» un picture récalcitrant, please help svp ;)
» DIR_REMOVE récalcitrant...
» Le guillemet récalcitrant.
» Tuer un processus récalcitrant
» Petit désagrément avec TERMINATE