Travaillant à l'Observatoire National de Radio-Astronomie des Etats-Unis au début des années 70, Charles Moore était chargé de programmer les premiers mini-ordinateurs 16 bits (type IBM 360) pour l'acquisition des données scientifiques et la maintenance des appareils de mesure.

Les langages évolués de l'époque comme le FORTRAN (à ne pas confondre avec l'objet de ce paragraphe) était trop lourds pour l'exécution de logiciels temps réel. Le langage machine était, quant à lui, suffisamment indigeste pour s'aventurer à réaliser des programmes toujours plus complexes.

C'est ainsi que Charles MOORE eut l'idée de créer un langage révolutionnaire dont les instructions de base correspondaient à une seule ligne de code en langage machine.

Ceci permit non seulement d'écrire des programmes en langage évolué avec quasiment les performances du langage machine mais en plus de réduire au maximum la taille mémoire qui était extrêmement faible à l'époque.

Charles MOORE voulut enregistrer son langage sous le nom de FOURTH pour langage de quatrième génération mais l'ordinateur qu'il utilisait n'autorisant que des noms de 5 lettres, il l'appela: FORTH.

Pour bien comprendre et utiliser au maximum les performances induites par le langage FORTH, il est important de maîtriser la notation polonaise inversée utilisée aussi dans les calculatrices fabriquées par Hewlett-Packard. La transmission des paramètres se fait essentiellement par une pile de structure dernier entré - premier sorti. Cette notion es ce qui a permis à Charles Moore de tirer le maximum de performances de son langage car il faut savoir que tout processeur digne de ce nom possède des instructions de manipulation de la mémoire sous forme de pile de ce type.

En plus de la classique pile de retour de sous-programmes gérée intrinsèquement par la plupart des processeurs, l'idée d'utiliser les mêmes instructions pour le passage des paramètres a conduit à créer une pile de données dont quelques instructions de bases sont les suivantes :

• DUP empile la copie du nombre se trouvant au sommet de la pile: n --> n,n (le sommet de la pile est à droite),
• DROP dépile le nombre se trouvant au sommet de la pile: n --> - (le trait signifie que la pile est vide par rapport au niveau précédent),
• SWAP inverse les 2 nombres du sommet de la pile: n1,n2 --> n2,n1
• OVER empile la copie du nombre situé au deuxième rang du sommet de la pile: n1,n2 --> n1,n2,n1
• ...

Les opérations telles que comparaisons ou additions consommeront directement les nombres situés au sommet de la pile :

• > compare les 2 nombres au sommet de la pile et laisse un booléen: n1,n2 --> -1 si n1>n2, 0 sinon
• - soustraction entière telle que: n1,n2 --> n1-n2
• * multiplication entière signée telle que: n1,n2 --> n1*n2
• ...

La structure de contrôle la plus basique est l'ensemble formé par IF, ELSE et THEN. IF teste le nombre au somme de la pile en le dépilant. Si il est différents de 0, les instructions placées entre IF et ELSE sont exécutées puis le programme se branche à la suite du mot THEN. Si il est nul, le programme se branche directement aux instructions se trouvant à la suite du mot ELSE. Plusieurs structures de ce type peuvent évidemment être imbriquées.

En FORTH, toutes les instructions peuvent être des programmes et réciproquement. Elles sont introduites dans la mémoire au fur et à mesure de leur compilation. Mise à par quelques instructions qui manipulent la pile de retour comme les structures de contrôle par exemple, toutes les instructions peuvent être interprétées à tout momen ce qui donne des facilités de mise au point considérables pour les développeurs. Inutile d'écrire un autre programme principal et de refaire une compilation pour voir si c'est le sous-programme qui fonctionne mal. Il suffit de lancer son exécution avec les paramètres adéquats.

Les instructions ou programmes ou sous-programmes sont insérés dans la mémoire avec un système de pointeurs qui les lient entre eux pour permettre à l'interpréteur (ou au compilateur selon le mode de fonctionnement) de les retrouver. La recherche commence en partant de la dernière instruction compilée et en remontant jusqu'à la première qui est souvent DUP. Si l'instruction n'existe pas, l'interpréteur/compilateur regarde si c'est un nombre et l'empile au sommet de la pile en mode interprétation ou le compile dans l'instruction en mode compilation. Pour créer une instruction, on utilise 2 instructions (en dehors de celles qui décrivent la séquence à exécuter):

• : suivi du nom de l'instruction et qui fait passer du mode interprétation au mode compilation,
• ; qui termine l'instruction et donc repasse en mode interprétation.

Enfin, pour ne pas être trop exhaustif dans cette présentation, sachez que le langage FORTH permet d'écrire des procédures récursives (ou ré-entrantes) ce qui en fait un langage vraiment très évolué. Voici l'exemple d'un programme de calcul de la factorielle d'un nombre entier faisan appel à cette notion de récursivité:

: FACTORIELLE
 DUP 1 >
  IF
   DUP 1 - FACTORIELLE *
 THEN
;

Pour illustrer cette introduction au langage FORTH, voici un écran présentant le développement de cette instruction:

La fenêtre d'interprétation (en gris clair) donne les valeurs calculées des factorielles de 5, de 4 et de 10 après compilation du fichier contenu dans la fenêtre d'édition (en bleu). La fenêtre de visualisation de la mémoire (en gris foncé) montre la taille occupée par cette instruction qui est de 46 octets.

Pour avoir plus de renseignement sur le FORTH, je vous invite à consulter la page des liens faisant référence aux principaux sites du net.