			Les structures de contrle
			**************************

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

do ... loop
-----------
	x  y  do ... loop  :  excute la boucle avec y comme indice de dpart,
l'indice est incrment de 1  chaque loop et la boucle se poursuit tant que
l'indice est infrieur  x. Par exemple: 10  2  do ... loop, l'indice prendra les
valeurs de 2  9.

do ... +loop
------------
	x  y  do ... +loop  :  excute la boucle avec y comme indice de dpart,
l'indice est incrment de la valeur trouve sur la pile par +loop et se
poursuit tant que l'indice est infrieur  x (si l'incrment est positif) ou tant
que l'indice est suprieur ou gal  x (si l'incrment est ngatif). 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  : xcute la boucle avec y comme indice de dpart.
Si ifloop rencontre une valeur fausse sur la pile (zro), la boucle s'arrte sans
incrmentation et la valeur du dernier indice est laisse sur la pile. Si au
contraire la valeur rencontre est vraie (autre que 0), l'incrmentation de 1
se fait et la boucle se poursuit tant que l'indice est infrieur  x. La valeur
renvoye est alors x si la condition a toujours t vraie.

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

	1)  list ... (valeurs dposes) ... dolist ... (corps de la boucle) ... lloop :
Le corps de la boucle est xcut, l'indice prenant successivement les valeurs
dposes 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 ranges 
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'intrieur d'une
autre, elle prend l'indice i, celle immdiatement avant prend l'indice j. Si une
troisime boucle est ouverte dans les deux autres, elle prend l'indice i, la
prcdente l'indice j, et la plus extrieure 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 prsentes prcdement.

ndo ... nloop
-------------
	n  ndo ... nloop  :  excute 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 prmaturment une boucle, la sortie se fera ds le
prochain loop, +loop ou nloop.

begin ... again
---------------
	Le corps de la boucle sera excut indfiniment (sauf sortie avec exit
ou quit).

begin ... until
---------------
	Le corps de la boucle sera excut 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 ds
que la condition prise par while est fausse (zro).
	adr p !			\ p pointe sur une adresse quelconque
	.b size			\ on manipule des octets
	begin
		p )+@	\ ramne la valeur pointe par p, p incrment
		?dup		\ double si non nulle
	while			\ tant qu'elle est diffrente de zro
		emit		\ sort le caractre 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 trouve par if sur la pile est vraie (non nulle), alors la
partie entre if et then est excute. Si non, on saute directement prs then
(en FORTH then signifie ensuite, et non alors).

if  ...  else  ... then
-----------------------
	Si la condition trouve par if sur la pile est vraie (non nulle) la partie
entre if et else est excute, sinon, c'est la partie entre else et then qui l'est.
	x 0>
	if
		." Positif"
	else
		." Ngatif 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 dfaut)
	endcase
	La valeur x trouve par case est successivement compare  x1, x2, ...
xn. Ds qu'il y a galit, la partie comprise entre les of et endof suivants est
excute ensuite on saute aprs le endcase. Si aucune valeur xi n'a convenu,
c'est la partie par dfaut qui est excute. C'est uniquement dans la partie
par dfaut que x est laiss sur la pile (a vous de le dpiler 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 jete
		." 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 suprieur  xi?, <of : x est-il infrieur  xi?, <>of : x est-il
diffrent de xi?
	x case					\ retient x
		0  >of  ." Positif" endof	\ x>0?
		0  <of  ." Ngatif" endof	\ x<0?
		drop ." Nul"			\ seul cas restant, x=0
	endcase

->  and->   or->  ->.
---------------------
	Cette structure permet de raliser des tests complexes en vitant les
calculs inutiles. Par exemple je veux excuter un sous programme seulement
si deux conditions sont simultanment vraies. Si la premire est fausse, la
seconde est inutile  vrifier. De mme, je veux excuter un sous programme
si l'une ou l'autre de deux conditions est vraie. Si la premire est dj vraie,
la seconde est inutile.
	->  	calcul1
	and->	calcul2
	and->	calcul3
	etc..
	->.
	Renvoit -1 (vrai) si toutes les conditions sont vraies, 0 ds que l'une
est fausse. Chaque calcul ne doit laisser sur la pile qu'une valeur (0=faux,
autre=vrai). Le plus intressant est de placer en premier les conditions ayant
le moins de chances de se vrifier (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 intressant est de placer en premier les conditions ayant
le plus de chances de se raliser (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 prmaturment d'un mot. exit ne doit pas se trouver
 l'intrieur d'une structure utilisant la pile des retours (boucle avec do...).

quit
----
	arrte toute excution et revient  l'interprteur.

system
------
	quitte l'interprteur.