		Les instructions arithmtiques sur la pile
		******************************************

	Le FORTH repose sur l'utilisation d'une pile, pour chaque fonction
excute on doit au pralable empiler les paramtres d'entre et on
rcuprera sur cette mme pile les paramtres de sortie (si il y en a).

1 Les mouvements de la pile
***************************

	Chaque nombre rencontr par l'interprteur est simplement dpos
sur la pile, les fonctions utilisent toujours comme paramtres les dernires
valeurs dposes (le sommet de la pile). Afin de ramener au sommet la
valeur voulue, il existe plusieurs mots permettant de modifier l'ordre des
valeurs sur la pile:

dup
---
	duplique la valeur au sommet de la pile.

?dup
----
	duplique le sommet de la pile si il est non nul.

drop
----
	jette le sommet de la pile.

swap
----
	permute les deux valeurs au sommet de la pile.

dropm
-----
	n dropm  :  jette n valeurs du sommet de la pile.

dupm
----
	n dupm  :  duplique les n valeurs du sommet de la pile.

rot
---
	a  b  c  rot  :  effectue une permutation circulaire sur 3 valeurs, on
obtient c  a  b.

roll
----
	n  roll  :  effectue un permutation circulaire sur n valeurs (la premire
devient la dernire).

over
----
	duplique la deuxime valeur par dessus la premire.

pick
----
	n  pick  :  duplique la valeur de rang n par dessus le sommet de la
pile.


sp!
---
	vide entirement la pile.

.s
--
	affiche le contenu de la pile (le sommet tant l'lment  gauche).
L'affichage de "*" signale un dbordement infrieur de pile (trop de valeurs
dpiles). Il faut immdiatement utiliser sp!.


2 Les oprations de base
************************

	Chacune de ces oprations dpile d'abord ses paramtres, seul le
rsultat reste sur la pile.

+
	a  b  +  :  fournit a+b sur la pile.

-
	a  b  -  : fournit a-b sur la pile.

*
	a  b  *  :  fournit a*b sur la pile.

/
	a  b  /  :  fournit a/b sur la pile.

mod
---
	a  b  mod  :  fournit le reste de la division de a par b.

/mod
----
	a  b  /mod  :  fournit d'abord le quotient, puis au sommet le reste de
la division de a par b.

w/
--
	a  b  w/  :  divise a par b avec les limites suivantes : b et le quotient
doivent tre dans l'intervalle [-32768,32767], c'est  dire tenir sur 2 octets.
L'opration est plus rapide que /.

w*
--
	a  b  w*  :  fournit a*b plus rapidement que * si a et b sont dans
l'intervalle [-32768,32767].

w/mod
-----
	a  b  w/mod  :  avec les limitations de w/, fournit le quotient et le
reste de a/b.

1+
--
	augmente la valeur au sommet de 1.

1-
--
	diminue la valeur au sommet de 1.

2+
--
	augmente la valeur au sommet de 2.

2-
--
	diminue la valeur au sommet de 2.

2*
--
	multiplie par 2 la valeur au sommet.

2/
--
	divise par 2 la valeur au sommet.

0<
--
	renvoit 1 (vrai) si la valeur au sommet est ngative, 0 (faux) sinon.

0>
--
	renvoit 1 (vrai) si la valeur au sommet est positive, 0 (faux) sinon.

0=
--
	renvoit 1 si la valeur au sommet est nulle, 0 sinon.

>
	a  b  >  :  renvoit 1 si a>b, 0 sinon.

<
	a  b  <  :  renvoit 1 si a<b, 0 sinon.

=
	a  b  =  :  renvoit 1 si a=b, 0 sinon.

<>
--
	a  b  <>  : renvoit 1 si a est diffrent de b, 0 sinon.

min
---
	a  b  min  : renvoit le plus petit de a et b.

max
---
	a  b  max  : renvoit le plus grand de a et b.

and
---
	a  b  and  :  effectue un ET logique entre a et b.

or
--
	a  b  or  :  effectue un OU logique entre a et b.


xor
---
	a  b  xor  :  effectue un OU EXCLUSIF logique entre a et b.

not
---
	effectue un NON logique sur le sommet de la pile.

negate
------
	fournit l'oppos du nombre au sommet de la pile.

+-
--
	a  b  +-  :  applique la rgle des signes de b sur a:
		si b<0, a est chang en son oppos
		si b>0, a reste tel quel.
	b est dpil et seul reste a ventuellement modifi.

abs
---
	fournit la valeur absolue du sommet de la pile.

<seg>
-----
	x  a  b  <seg>  :  renvoit 1 si x est entre a et b  (a et b inclus), 0
sinon.

>seg<
-----
	x  a  b  >seg<  :  renvoit 1 si x est entre a et b  (a et b exclus), 0
sinon.

4 Travail sur plusieurs piles
*****************************

	Il existe deux piles en FORTH, la pile des donnes (celle utilise pour
les calculs courants) et la pile des retours. Cette deuxime pile est gre de
manire interne et conserve les adresse de retour d'un sous programme, les
donnes d'une boucle etc... On peut accder  cette seconde pile pour peu
qu'elle retrouve son tat initial avant un mot l'utilisant (fin de boucle, fin de
mot... )

r0
--
	dpose sur la pile des donnes l'adresse de base de la pile des retours.
Cette pile est descendante (on empile  l'aide de -(a4) et on dpile avec
(a4)+), c'est--dire que la base est au dessus de la pile elle-mme.

rp@
---
	dpose sur la pile des donnes l'adresse du pointeur de la pile des
retours. Cette adresse est donc infrieure  r0.

>r
--
	dplace le sommet de la pile des donnes sur le sommet de la pile des
retours. Utile pour carter momentanment une valeur.


r@
--
	copie le sommet de la pile des retours sur la pile des donnes (la
valeurs reste donc encore sur la pile des retours).

r>
--
	dplace le sommet de la pile des retours sur la pile des donnes.

rp!
---
	vide la pile des retours ( ne pas faire en plein milieu d'un
programme, son utilisation est rserve  un nettoyage si un programme s'est
interrompu prmaturment lors d'une erreur).

	L'utilisation de cette deuxime pile est limite et peut tre fatale pour
un programme. On peut tre amen  crer d'autres piles de donnes qui
n'auront plus les contraintes de la pile des retours. Une deuxime pile peut
aussi s'avrer utile lors de la mise au point d'un programme pour conserver
des valeurs prises en cours d'excution sans perturber son droulement.

&stack
------
	n &stack XXX  :  cre un mot XXX qui sera une pile contenant au
maximum n entiers de 4 octets (un rel compte pour 2 entiers=8 octets). A
l'excution XXX laisse sur la pile courante l'adresse de sa propre base.

current
-------
	XXX current  :  la pile XXX de vient la pile courante, toutes les
oprations se font dans cette nouvelle pile maintenant.

stack0
------
	pile du FORTH, par exemple :  stack0  current  , permet de revenir 
la pile normale. Cette pile de 4096 octets contient jusqu'a 1024 entiers ou
512 rels.

>st
---
	x  XXX  >st  :  dplace la valeur x de la pile courante sur la pile XXX.

st>
---
	XXX  st>  :  dplace le sommet de la pile XXX sur la pile courante.

s0
--
	dpose sur la pile la base de la pile courante. Les piles de donnes
sont descendantes comme la pile des retours (on empile avec -(a6) et on
dpile avec (a6)+).

sp@
---
	dpose sur la pile courante le pointeur de la pile courante, cette
valeur est infrieure  s0.

depth
-----
	dpose sur la pile courante le nombre d'entiers prsents sur cette pile.

5 Les nombres rels
*******************

	Ils sont au format IEEE double (celui du MC68882). Tous les calculs
seront effectus avec cette prcision. Pour spcifier au FORTH qu'on utilise
un nombre rel il faut le faire prcder de %f. Un nombre rel utilise 8 octets
sur la pile, la place de deux entiers.

f+  f-  f*  f/  fneg
--------------------
	remplacent +, -, *, / et negate pour les rels.

f=  f>
------
	remplacent = et > pour les rels.

fdup  fdrop  fswap  fover  frot  fpick  f>r  r>f
------------------------------------------------
	remplacent dup, drop, swap, over, rot, pick >r, r>  pour les rels.

itof  ftoi
----------
	transforment l'entier (int) en rel (fl) ou le contraire. La conversion
vers un entier est faite par troncature.

sin  cos  tan  atn
------------------
	calculent le sinus, le cosinus, la tangente ou l'arctangente d'un rel.
Les angles sont en radians.

sincos
------
	calcule simultanment le sinus et le cosinus d'un angle. Le cosinus est
au smomet de la pile.

pi
--
	dpose la valeur de pi sur la pile.

exp  log
--------
	calcule l'exponentielle ou le logarithme nprien d'un rel.

1/x  x^2  sqr
-------------
	calcule l'inverse, le carr ou la racine carre d'un nombre.

x^y
---
	x  y  x^y  :  calcule x  la puissance y.

fabs  int  frac  round
-----------------------
	calcule la valeur absolue, la partie entire, la partie fractionnaire ou
l'arrondi d'un rel (le rsultat reste au format rel).

f*2^n
-----
	x  n  f*2^n  :  multiplie le rel x par 2^n (n tant au format entier).
Pour multiplier par 4 on utlise n=2, par 32 c'est n=5, pour diviser par 2 on
utilise n=-1 etc... Cette opration est extrmement rapide par rapport  f*
puisqu'il suffit de raliser une addition sur l'exposant du rel.

sign
----
	renvoit le signe d'un nombre rel. 1 si il est positif, -1 si il est ngatif,
0 si il est nul. La valeur renvoye est un entier.

setdigits
---------
	n setdigits  :  fixe, pour les rels, le nombre de chiffres  afficher. Ceci
n'influe pas sur la prcision des calculs.

fval
----
	chaine  fval  :  transforme une chaine de caractres en un nombre rel
(les caractres %f devant le rel ne sont pas ncessaires). Fonction utile en
liaison avec input$ pour l'entre de paramtres rels.