			Les structures de contr“le
			**************************

1 Les boucles
*************

do ... loop
-----------
	x  y  do ... loop  :  ex‚cute la boucle avec y comme indice de d‚part,
l'indice est incr‚ment‚ de 1 … chaque loop et la boucle se poursuit tant que
l'indice est inf‚rieur … x. Par exemple: 10  2  do ... loop, l'indice prendra les
valeurs de 2 … 9.

do ... +loop
------------
	x  y  do ... +loop  :  ex‚cute la boucle avec y comme indice de d‚part,
l'indice est incr‚ment‚ de la valeur trouv‚e sur la pile par +loop et se
poursuit tant que l'indice est inf‚rieur … x (si l'incr‚ment est positif) ou tant
que l'indice est sup‚rieur ou ‚gal … x (si l'incr‚ment est n‚gatif). Par
exemple:	16  2  do ... 4 +loop		indice=2, 6, 10, 14
		6  18  do ... -3 +loop	indice=18, 15, 12, 9, 6.

do  ... ifloop
--------------
	x  y  do  ...  ifloop  : ‚x‚cute la boucle avec y comme indice de d‚part.
Si ifloop rencontre une valeur fausse sur la pile (z‚ro), la boucle s'arrˆte sans
incr‚mentation et la valeur du dernier indice est laiss‚e sur la pile. Si au
contraire la valeur rencontr‚e est vraie (autre que 0), l'incr‚mentation de 1
se fait et la boucle se poursuit tant que l'indice est inf‚rieur … x. La valeur
renvoy‚e est alors x si la condition a toujours ‚t‚ vraie.

list ... dolist ... lloop
-------------------------
	Il y a deux syntaxes possibles:

	1)  list ... (valeurs d‚pos‚es) ... dolist ... (corps de la boucle) ... lloop :
Le corps de la boucle est ‚x‚cut‚, l'indice prenant successivement les valeurs
d‚pos‚es sur la pile entre list et dolist. Par exemple:
	list  12  14  -1 -3  dolist  ...  lloop  :  indice=12, 14, -1, -3.

	2)  adr n dolist  ...  lloop  :  les valeurs de l'indice sont rang‚es …
l'adresse adr sur 4 octets chacune (c'est le format d'un tableau d'entiers cr‚‚
avec array), n est le nombre de valeurs … prendre (c'est … dire le nombre de
bouclages).

i  j  k
-------
	Ce sont les noms des indices de boucles. Lorsqu'une boucle est ouverte
elle se voit attribuer l'indice i. Si une boucle est ouverte … l'int‚rieur d'une
autre, elle prend l'indice i, celle imm‚diatement avant prend l'indice j. Si une
troisiŠme boucle est ouverte dans les deux autres, elle prend l'indice i, la
pr‚c‚dente l'indice j, et la plus ext‚rieure l'indice k. Exemple:
	102 100 do
		i . cr				\ i centaines
		12 10 do
			i . space   		\ ici i devient dizaine
			j . cr			\ j est la centaine
			2  0  do
				i . space	\ ici i devient unit‚
				j . space	\ j devient dizaine
				k . cr		\ k devient centaine
			loop
			i . space		\ i est redevenu dizaine
			j . cr			\ j redevenu centaine
		loop
		i . cr				\ i est redevenu centaine
	loop

	Ces indices sont applicables aux boucles pr‚sent‚es pr‚c‚dement.

ndo ... nloop
-------------
	n  ndo ... nloop  :  ex‚cute la boucle n fois sans qu'on puisse utiliser
d'indice dans le corps de la boucle. Cette boucle est alors plus rapide que
do/loop.

leave
-----
	permet de quitter pr‚matur‚ment une boucle, la sortie se fera dŠs le
prochain loop, +loop ou nloop.

begin ... again
---------------
	Le corps de la boucle sera ex‚cut‚ ind‚finiment (sauf sortie avec exit
ou quit).

begin ... until
---------------
	Le corps de la boucle sera ex‚cut‚ jusqu'a ce que la valeur prise sur la
pile par until soit vraie (autre que 0). Exemple:  begin  mousek  until, attend
une pression sur l'un des boutons de la souris.

begin ... while ... repeat
--------------------------
	La boucle contient une condition de sortie en son milieu. On sort dŠs
que la condition prise par while est fausse (z‚ro).
	adr p !			\ p pointe sur une adresse quelconque
	.b size			\ on manipule des octets
	begin
		p )+@	\ ramŠne la valeur point‚e par p, p incr‚ment‚
		?dup		\ doubl‚e si non nulle
	while			\ tant qu'elle est diff‚rente de z‚ro
		emit		\ sort le caractŠre correspondant
	repeat			\ au suivant
	Cette boucle a donc affich‚ une chaine se trouvant … l'adresse adr et
se terminant par un octet nul.

2 Les tests
***********

if  ...  then
-------------
	Si la condition trouv‚e par if sur la pile est vraie (non nulle), alors la
partie entre if et then est ex‚cut‚e. Si non, on saute directement …prŠs then
(en FORTH then signifie ensuite, et non alors).

if  ...  else  ... then
-----------------------
	Si la condition trouv‚e par if sur la pile est vraie (non nulle) la partie
entre if et else est ex‚cut‚e, sinon, c'est la partie entre else et then qui l'est.
	x 0>
	if
		." Positif"
	else
		." N‚gatif ou nul"
	then
	Affiche en toutes lettres le signe de x.

case  of  endof  endcase
------------------------
	x case
		x1 of ... endof
		x2 of ... endof
   		...
		xn of ... endof
		(partie par d‚faut)
	endcase
	La valeur x trouv‚e par case est successivement compar‚e … x1, x2, ...
xn. DŠs qu'il y a ‚galit‚, la partie comprise entre les of et endof suivants est
ex‚cut‚e ensuite on saute aprŠs le endcase. Si aucune valeur xi n'a convenu,
c'est la partie par d‚faut qui est ex‚cut‚e. C'est uniquement dans la partie
par d‚faut que x est laiss‚ sur la pile (a vous de le d‚piler ou de l'utiliser).
	key %hff and			\ lit une touche et conserve le code ASCII
	case
		65  of  ." C'est le A" endof     	\ le A a pour code ASCII 65
		66  of  ." C'est le B" endof		\ le B c'est 66
		drop					\ autre touche jet‚e
		." Touche incorrecte"		\ message d'erreur
	endcase

>of  <of  <>of
--------------
	Permettent de remplacer of (dont le seul test est l'‚galit‚) par d'autres
tests >of : x est il sup‚rieur … xi?, <of : x est-il inf‚rieur … xi?, <>of : x est-il
diff‚rent de xi?
	x case					\ retient x
		0  >of  ." Positif" endof	\ x>0?
		0  <of  ." N‚gatif" endof	\ x<0?
		drop ." Nul"			\ seul cas restant, x=0
	endcase

->  and->   or->  ->.
---------------------
	Cette structure permet de r‚aliser des tests complexes en ‚vitant les
calculs inutiles. Par exemple je veux ex‚cuter un sous programme seulement
si deux conditions sont simultan‚ment vraies. Si la premiŠre est fausse, la
seconde est inutile … v‚rifier. De mˆme, je veux ex‚cuter un sous programme
si l'une ou l'autre de deux conditions est vraie. Si la premiŠre est d‚j… vraie,
la seconde est inutile.
	->  	calcul1
	and->	calcul2
	and->	calcul3
	etc..
	->.
	Renvoit -1 (vrai) si toutes les conditions sont vraies, 0 dŠs que l'une
est fausse. Chaque calcul ne doit laisser sur la pile qu'une valeur (0=faux,
autre=vrai). Le plus int‚ressant est de placer en premier les conditions ayant
le moins de chances de se v‚rifier (selon le programme) et d'‚viter ainsi les
tests inutiles.
	->	calcul1
	or->	calcul2
	or->	calcul3
	etc...
	->.
	Renvoit -1 (vrai) si l'une des conditions est vraie, 0 si toutes sont
fausses. Chaque calcul ne doit laisser sur la pile qu'une valeur (0=faux,
autre=vrai). Le plus int‚ressant est de placer en premier les conditions ayant
le plus de chances de se r‚aliser (selon le programme) afin de quitter la
structure au plus vite et d'‚viter les tests inutiles.
	Ces deux structures sont imbricables:
	->
		->  A  and->  B  ->.
	or->
		C  not
	or->
		-> D  and-> E not ->.
	->.
	Ceci teste la condition (A et B) ou (non C) ou (D et non E).

3 Autres commandes
******************

exit
----
	permet de sortir pr‚matur‚ment d'un mot. exit ne doit pas se trouver
… l'int‚rieur d'une structure utilisant la pile des retours (boucle avec do...).

quit
----
	arrˆte toute ex‚cution et revient … l'interpr‚teur.

system
------
	quitte l'interpr‚teur.