interpret

COUNT ( c-addr1 -- c-addr2 u )

Retourne la spécification de la chaîne comptée dont l'adresse est c-addr1.

Si c-addr1>=32768 la chaîne est dans la mémoire flash du MCU.

COUNT n'a pas accès à la mémoire EDS. Pour les chaînes en mémoire EDS il faut

utiliser ECOUNT.

arguments:

c-addr1 Adresse d'une chaîne de caractères comptée.

retourne:

c-addr2 Adresse du premier caractère de la chaîne.

u Longueur de la chaîne.

INTERPRET ( i*x c-addr u -- j*x )

Évaluation d'un tampon contenant du texte source par l'interpréteur/compilateur.

Ce mot est un facteur commun à EVALUATE et QUIT.

arguments:

i*x État initial de la pile des arguments avant le début de l'interpréation.

c-addr Adresse du premier caractère du tampon.

u Longueur du tampon.

retourne:

j*x État final de la pile des arguments à la fin de l'interprétation.

EVALUATE ( i*x c-addr u -- j*x )

Évaluation d'un texte source. Le contenu de SOURCE est sauvegardé

et restauré à la fin de cette évaluation.

arguments:

i*x Contenu initial de la pile des arguments avant l'évalulation de la chaîne.

c-addr Adresse du premier caractère de la chaîne à évaluer.

u Longueur de la chaîne à évaluer.

retourne:

j*x Contenu final de la pile après l'évaluation de la chaîne.

ABORT ( -- )

Vide la pile des arguments et appel QUIT.

Si une compilation est en cours annulle les effets de celle-ci.

arguments:

aucun

retourne:

rien Ne retourne pas mais branche sur QUIT

ABORT" ( cccc S: n -- )

Ne s'utilise qu'à l'intérieur d'une définition.

Compile le message cccc et le code qui permet d'afficher ce message suivit d'un ABORT

si 'n' est différent de zéro. Le texte cccc est délimité par le caractère ".

exemple:

: test abort" Ceci est un test!" ;
0 test \ il ne se passe rien
1 test ceci est un test!
\ le message a été affiché et ABORT exécuté.

arguments:

n Si <> 0 déclenche un ABORT avec message.

retourne:

rien

CLIP ( n+ -- )

Copie le contenu du tampon TIB dans le tampon PASTE.

Le contenu de PASTE est une chaîne comptée.

arguments:

n+ Nombre de caractères de la chaîne à copier.

retourne:

rien

GETCLIP ( -- n+ )

Copie la chaîne qui est dans le tampon PASTE dans le tampon TIB.

Retourne la longueur de la chaîne.

arguments:

aucun

retourne:

n+ Longueur de la chaîne.

QUIT ( -- )

Boucle de l'interpréteur/compilateur. En dépit de son nom cette boucle

ne quitte jamais. Il s'agit de l'interface avec l'utilisateur.

A l'entré la pile des retours est vidée et la variable STATE est mise à 0.

arguments:

aucun

retourne:

rien

Description

Mots utilisés par le compilateur.

HERE ( -- addr )

Retourne la valeur de la variable système DP (Data Pointer). Cette adresse

indique la position du premier octet libre dans la mémoire utlisateur.

arguments:

aucun

retourne:

addr Valeur de la variable DP.

ALIGN ( -- )

Si la variable système DP (Data Pointer) pointe sur une adresse impaire,

aligne cette valeur sur l'adresse paire supérieure.

Met 0 dans l'octet sauté.

arguments:

aucun

retourne:

rien

ALIGNED ( addr -- a-addr )

Si l'adrsse au sommet de la pile est impaire, aligne cette adresse sur la valeur paire supérieure.

arguments:

addr Adresse à vérifier.

retourne:

a-addr Adresse alignée.

SOURCE ( -- c-addr u )

Ce mot retourne l'adresse et la longueur du tampon qui est la source de

l'évaluation par l'interpréteur/compilateur.

arguments:

rien

retourne:

c-addr Adresse début du tampon.

u longueur du tampon.

SOURCE! ( c-addr u -- )

Sauvegarde les valeurs de la SOURCE.

arguments:

c-addr Adresse du début du tampon qui doit-être évalué.

u Longueur du tampon.

Description

Le dictionnaire est une liste chaînée, le début de la liste est indiqué par

la variable système LATEST.

L'entête du dictionnaire est une strcucture de la forme suivante:

champ	description
LFA	Contient l'adresse du champ NFA du prochain mot dans le dictionnaire.
NFA	Champ nom de longueur variable Le premier octet est la longueur du nom et contient aussi les attributs HIDDEN et IMMED. Le bit 7 est toujours à 1.
CFA	Adresse du code à exécuter pour ce mot.
PFA	Paramètres utitlisés par ce mot. Longueur variable.

Le premier octet du champ nom est un bitfield:

bits	description
4:0	Longueur du nom maximum 31 caractères
5	Attribut HIDDEN Si à 1 le mot n'est pas trouvé par FIND
6	Attribut IMMED Si à 1 il s'agit d'un mot immmédiat.
7	F_MARK toujours à 1 Permet à CFA>NFA de trouver le début du champ

NFA>LFA ( a-addr1 -- a-addr2 )

A partir de l'adresse NFA (Name Field Address) retourne

l'adresse LFA (Link Field Address).

arguments:

a-addr1 Adresse du champ NFA dans l'entête du dictionnaire.

retourne:

a-addr2 Adresse du champ LFA dans l'entête du dictionnaire.

NFA>CFA ( a-addr1 -- a-addr2 )

A partir de l'adresse NFA (Name Field Address) retourne

l'adresse CFA (Code Field Address).

arguments:

a-addr1 Adresse du champ NFA dans l'entête du dictionnaire.

retourne:

a-addr2 Adresse du champ CFA dans l'entête du dictionnaire.

>BODY ( a-addr1 -- a-addr2 )

A partir du CFA (Code Field Address) retourne l'adresse PFA (Parameter Field Address)

arguments:

a-addr1 Adresse du champ CFA dans l'entête du dictionnaire.

retourne:

a-addr2 Adresse du champ PFA (Parameter Field Address).

CFA>NFA ( a-addr1 -- a-addr2 )

Retourne l'adresse du NFA à partir du CFA.

Il n'y a pas de lien arrière entre le CFA et le NFA

Le bit F_MARK (bit 7) est utilisé pour marquer l'octet à la position NFA

Le CFA étant immédiatement après le nom, il suffit de

reculer octet par octet jusqu'à atteindre un octet avec le bit F_MARK==1

puisque les caractères du nom sont tous < 128. Le champ nom a une longueur

maximale de 32 caractères incluant l'octet longueur|attributs.

arguments:

a-addr1 Adresse du CFA dans l'entête du dictionnaire.

retourne:

a-addr2 Adresse du NFA dans l'entête du dictionnaire.

?EMPTY ( -- f )

Vérifie si le dictionnaire utilisateur est vide.

arguments:

aucun

retourne:

f Indicateur Booléean, retourne VRAI si dictionnaire utilisateur vide.

IMMEDIATE ( -- )

Met l'attribut IMMED à 1 dans l'entête du dernier mot défini.

Un mot immédiat est un mot qui est exécuté même lorsque STATE est en

mode compilation.

arguments:

aucun

retourne:

rien

HIDE ( -- )

Met l'attribut HIDDEN à 1 dans l'entête du dernier mot défini dans le dictionnaire.

Un mot avec l'attribut HIDDEN de peut-être localisé par FIND.

arguments:

aucun

retourne:

rien

REVEAL ( -- )

Met à 0 l'attribut HIDDEN dans l'entête du dictionnaire du dernier mot défini.

arguments:

aucun

retourne:

rien

ALLOT ( n -- )

Allocation/libération de mémoire dans l'espace utilisateur.

si n est négatif n octets seront libérés. Il s'agit simplement d'un ajustement

de la valeur de la variable DP.

arguments:

n Nombre d'octets

retourne:

rien Modifie la valeur de DP.

, ( x -- )

Alloue une cellule pour x à la position DP et dépose x dans cette cellule.

la Variable DP est incrémentée de la grandeur d'une cellule.

arguments:

x Valeur qui sera sauvegardée dans l'espace de donnée.

retourne:

rien

C, ( c -- )

Alloue l'espace nécessaire pour enregistré le caractère c.

Le caractère c est sauvegardé à la position DP et DP est incrémenté.

arguments:

c Caractère à sauvegardé dans l'espace de données.

retourne:

rien

' ( cccc S: -- a-addr )

Extrait le mot suivant du texte d'entrée et le recherche dans le dictionnaire.

Retourne l'adresse du CFA de ce mot.

arguments:

cccc chaîne de caractère dans le texte d'entrée qui représente le mot recherché.

retourne:

a-addr Adresse du CFA (Code Field Address) du mot recherché, 0 si non trouvé.

['] ( cccc S: -- )

Version immédiate de ' à utiliser à l'intérieur d'une définition pour

compiler le CFA d'un mot existant dans le dictionnaire.

arguments:

cccc Chaîne de caractère dans le texte d'entrée qui représente le mot recherché.

retourne:

rien Le CFA est compilé.

[ ( -- )

Mot immédiat.

Passe en mode interprétation en mettant la variable système STATE à zéro.

arguments:

aucun

retourne:

rien Modifie la valeur de la variable système STATE.

] ( -- )

Mot immédiat.

Passe en mode compilation en mettant la variable système STATE à -1

arguments:

aucun

retourne:

rien Modifie la valeur de la variable système STATE.

?WORD ( cccc S: -- a-addr 1 | -1 )

Analyse le texte d'entré pour en extraire le prochain mot.

Recherche ce mot dans le dictionnaire.

Retourne le CFA du nom et un indicateur.

Si le mot n'est pas dans le dictionnaire affiche le mot avec un point

d'interrogation et invoque ABORT.

arguments:

cccc Mot extrait du texte d'entrée.

retourne:

a-addr Le CFA du mot.

1 Si c'est mot immédiat ou

-1 Si le mot n'est pas immédiat.

POSTPONE ( cccc S: -- )

Mot immédiat à utiliser dans une définition.

Diffère la compilation du mot qui suis dans le texte d'entrée.

arguments:

cccc Mot extrait du texte d'entrée.

retourne:

rien

LITERAL ( x -- )

Mot immédiat qui compile la sémantique runtime d'un entier. Il n'a d'effet

qu'en mode compilation. Dans ce cas la valeur au sommet de la pile est compilée

avec la sémantique runtime qui empile un entier.

arguments:

x Valeur au sommet de la pile des arguments.

retourne:

rien x reste au sommet de la pile lorsque STATE=0 .

S" ( cccc S: -- )

Mot immédiat à n'utiliser qu'à l'intérieur d'une définition.

Lecture d'une chaîne litérale dans le texte d'entrée et compilation

de cette chaîne dans l'espace de donnée.

La sémentique rutime consiste à empiler l'adresse du premier caractère de la

chaîne et la longueur de la chaîne.

arguments:

cccc Chaîne terminée par " dans le texte d'entrée.

retourne:

rien

C" ( cccc S: -- )

Mot immédiat à n'utiliser qu'à l'intérieur d'une définition.

Lecture d'une chaîne litérale dans le texte d'entrée et compilation de cette

chaîne dans l'espace de donnée.

La sémantique runtime consiste à empiler l'adresse de la chaîne comptée.

arguments:

cccc Chaîne de caractères terminée par " dans le texte d'entrée.

retourne:

rien En runtime empile l'adresse du descripteur de la chaîne.

." ( cccc S: -- )

Mot immédiat.

Interprétation: imprime la chaîne litérale qui suis dans le flux d'entrée.

En compilation: compile la chaîne et la sémantique qui permet d'imprimer cette

chaîne lors de l'exécution du mot en cour de définition.

arguments:

cccc Chaîne terminée par " dans le texte d'entrée.

retourne:

rien

RECURSE ( -- )

Mot immédiat à n'utiliser qu'à l'intérieur d'une définition.

Compile un appel récursif du mot en cour de définition.

exemple:

\ définition de la fonction factorielle par récursion.

: fact dup 1 = if exit else dup 1- recurse * then ;

arguments:

aucun

retourne:

rien

DO ( n1 n2 -- )

Mot immédiat qui ne peut-être utilisé qu'à l'intérieur d'une définition.

Débute une boucle avec compteur. La valeur du compteur de boucle est incrémentée

à la fin de la boucle et comparée avec la limite. La boucle se termine lorsque

le compteur atteint ou dépasse la limite. La boucle s'exécute au moins 1 fois.

arguments:

n1 Valeur limite du compteur de boucle.

n2 Valeur initiale du compteur de boucle.

retourne:

rien

?DO runtime ( n1 n2 -- )

Mot immédiat qui ne peut-être utilisé qu'à l'intérieur d'une définition.

Débute une boucle avec compteur. Cependant contrairement à DO la boucle

Ne sera pas excétée si n2==n1. Le compteur de boucle est incrémenté à la fin

de la boucle et le contrôle de limite est affectué après l'incrémentation.

arguments:

n1 Limite

n2 Valeur initiale du compteur de boucle.

retourne:

rien

LEAVE runtime ( -- )

Mot immédiat qui ne peut-être utilisé qu'à l'intérieur d'une définition.

LEAVE est utilisé à l'intérieur des boucles avec compteur pour interrompre

prématurément la boucle.

exemple:

: test-leave 5 0 do i 3 > if leave else i . then loop ; \ imprime 0 1 2 3

arguments:

aucun

retourne:

rien

LOOP ( -- )

Mot immédiat à n'utiliser qu'a l'intérieur d'une définition.

Dernière instruction d'une boucle avec compteur.

Le compteur est incrémenté et ensuite comparé à la valeur limite.

En cas d'égalité le boucle est terminée.

arguments:

rien

retourne:

rien

+LOOP ( n -- )

Mot immédiat à n'utiliser qu'a l'intérieur d'une définition.

Dernière instruction de la boucle. La valeur n est ajoutée au compteur.

Ensuite cette valeur est comparée à la limite et termine la boucle si

la limite est atteinte ou dépassée.

arguments:

n Ajoute cette valeur au compteur de la boucle. Si I passe LIMIT quitte la boucle.

retourne:

rien

BEGIN ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Débute une boucle qui se termine par AGAIN, REPEAT ou UNTIL

arguments:

aucun

retourne:

rien

AGAIN ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Effectue un branchement inconditionnel au début de la boucle.

Une boucle créée avec BEGIN ... AGAIN ne peut-être interrompue que

par ABORT, ABORT" ou EXIT.

arguments:

aucun

retourne:

rien

UNTIL ( n -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Termine la boucle si n<>0.

arguments:

n Valeur qui contrôle la boucle. La boucle est terminée si n<>0.

retourne:

rien

REPEAT ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

S'utilise avec une structure de boucle BEGIN ... WHILE ... REPEAT

Comme AGAIN effectue un branchement inconditionnel au début de la boucle.

Cependant au moins un WHILE doit-être présent à l'intérieur de la boucle

car c'est le WHILE qui contrôle la sortie de boucle.

exemple:

: test-repeat 0 begin dup . 1+ dup 4 < while repeat drop ; \ imprime 0 1 2 3

arguments:

aucun

retourne:

rien

WHILE ( n -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Utilisé à l'intérieur d'une boucle BEGIN ... REPEAT, contrôle la sortie

de boucle. Tant que la valeur n au sommet de la pile est VRAI l'exécution

de la boucle se répète au complet lorsque REPEAT est atteint.

arguments:

n Contrôle la sortie de boucle. Si n==0 il y a sortie de boucle.

retourne:

rien

IF ( n -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Exécution du code qui suit le IF si et seulement is n<>0.

arguments:

n Valeur consommée par IF, si n<>0 les instructions entre IF et ELSE ou THEN sont exécutées.

retourne:

rien

THEN ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Termine le bloc d'instruction qui débute après un IF ou un ELSE.

arguments:

aucun

retourne:

rien

ELSE ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Termine le bloc d'instruction qui débute après un IF.

Les instructions entre le ELSE et le THEN qui suit sont excéutées si la valeur n contrôlée

par le IF est 0.

arguments:

aucun

retourne:

rien

CASE ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

Branchement conditionnel multiple par comparaison de la valeur au sommet

de la pile des arguments avec d'autres valeurs de test.

exemple:

: x

CASE

1 OF ... ENDOF

2 OF ... ENDOF

\ ... ( instructions par défaut ce bloc est optionnel.)

ENDCASE

3 x

Dans cette exemple on définit le mot x et ensuite on l'exécute en lui passant la

valeur 3 en arguments. Chaque valeur qui précède un OF est comparée avec 3 et

s'il y a égalité le bloc entre OF et ENDOF est exécuté. Seul le premier test

qui répond au critère d'égalité est exécuté. Si tous les test échous et qu'il

y a un bloc d'instruction entre le derner ENDOF et le ENDCASE c'est ce bloc

qui est exécuté.

arguments:

aucun

retourne:

rien

OF (x1 x2 -- |x1 )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

S'utilise à l'intérieur d'une structure CASE ... ENDCASE

Vérifie si x1==x2 En cas d'égalité les 2 valeurs sont consommée et

le bloc d'instruction qui suis le OF jusqu'au ENDOF est exécuté.

Si la condition d'égalité n'est pas vérifiée la valeur x1 est conservée

et l'exécution se poursuis après le prochain ENDOF.

arguments:

x1 Valeur de contrôle du case.

x2 Valeur de test du OF ... ENDOF

retourne:

|x1 x1 n'est pas consommé si la condition d'égalité n'est pas rencontrée.

ENDOF ( -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

S'utilise à l'intérieur d'une structure CASE ... ENDCASE

Termine un bloc d'instruction introduit par le mot OF

ENDOF branche après le ENDCASE

arguments:

aucun

retourne:

rien

ENDCASE ( x -- )

Mot immédiat à utiliser seulement à l'intérieur d'une définition.

S'utilise pour terminer une structure CASE ... ENDCASE.

ENDCASE n'est exécuté que si aucun bloc OF ... ENDOF n'a été exécuté.

Dans ce cas la valeur de contrôle qui est restée sur la pile est jeté.

arguments:

x Valeur de contrôle qui est restée sur la pile.

retourne:

rien

?COMPILE ( -- )

Mot immédiat.

Vérifie la valeur de la variable système STATE et si cette valeur est 0.

appelle ABORT" avec le message "compile only word". Ce mot débute la définition

de tous les mots qui ne doivent-être utilisés qu'en mode compilation.

arguments:

aucun

retourne:

rien

?NAME ( n -- )

Si n<>0 appelle ABORT" avec le message "name missing" .

?NAME est utilisé par les mots qui attendent un nom à leur suite.

exemple:

CREATE <ENTER> name missing

VARIABLE <ENTER> name missing

Les mots CREATE et VARIABLE doivent lire un nom à leur suite. ici il n'y avait

rien donc ?NAME a été invoqué.

arguments:

n Si n <> 0 exécute ABORT" name missing"

retourne:

rien

:NONAME ( -- a-addr )

Cré une définition sans nom dans l'espace de donnée.

et laisse son CFA sur la pile des arguments.

Met la variable STATE en mode compilation.

Le CFA de cette définition peut par exemple être assignée

à un mot créé avec DEFER.

exemple:

DEFER p2

:noname DUP * ; IS p2

2 p2 \ résultat 4

arguments:

aucun

retourne:

a-addr CFA de la nouvelle définition.

Cré une nouvelle entête dans le dictionnaire avec le nom qui suis dans le flux d'entrée.

Après l'exécution de ce mot HERE retourne l'adresse du CFA de ce mot. Le mot est créé

avec l'attribut HIDDEN activé.

arguments:

cccc Chaîne de caractère dans le texte d'entrée qui représente le nom du mot à créé.

retourne:

rien

FORGET ( cccc S: -- )

Extrait du texte d'entrée le mot suivant et supprime du dictionnaire ce mot

ainsi que tous ceux qui ont été définis après lui.

Les mots systèmes définis en mémoire FLASH ne peuvent-être supprimés.

arguments:

cccc Mot suivant dans le texte d'entrée.

arguments:

rien

MARKER ( cccc S: -- )

Extrait du texte d'entrée le mot suivant et cré un mot portant ce nom

dans le dictionnaire. Lorsque ce mot est invoqué il se supprime lui-même

ainsi que tous les mots qui ont été définis après lui.

arguments:

cccc Mot suivant dans le texte d'entrée.

arguments:

rien

: ( cccc S: -- )

Extrait le mot suivant du texte d'entrée et cré une nouvelle entête dans

le dictionnaire qui porte ce nom. Ce mot introduit une définition de haut niveau.

Modifie la variable système STATE pour passer en mode compilation.

arguments:

cccc Mot suivant dans le texte d'entrée.

retourne:

rien

CREATE ( cccc s: -- )

Extrait le mot suivant du texte d'entrée et cré une nouvelle entête dans le dictionnaire

Lorsque ce nouveau mot est exécuté il retourne l'adresse PFA. Cependant la sémantique

du mot peut-être étendue en utilisant le mot DOES>.

exemple:

\ le mot VECTOR sert à créer des tableaux de n éléments.

: VECTOR ( cccc S: n -- )

CREATE CELLS ALLOT DOES> SWAP CELLS PLUS ;

\ utilisation du mot VECTOR pour créer le tableau V1 de 5 éléments.

5 VECTOR V1

\ Met la valeur 35 dans l'élément d'indice 2 de V1

35 2 V1 !

arguments:

cccc Mot suivant dans le texte d'entrée.

retourne:

rien

DOES> ( -- )

Mot immédiat qui ne peut-être utilisé qu'à l'intérieur d'une définition.

Ce mot permet d'étendre l'action d'un mot créé avec CREATE. Surtout utile

pour définir des mots compilants. Un mot compilant est un mot qui sert à

créer une classe de mots. Par exemple les mots VARIABLE et CONSTANT sont

des mots compilants.

Voir le mot CREATE.

arguments:

aucun

retourne:

rien

; ( -- )

Termine une définition débutée par ":" ou :NONAME en compilant EXIT et en

remettant la valeur de la variable STATE à 0 pour passer en mode interprétation.

arguments:

aucun

retourne:

rien

VARIABLE ( cccc S: -- )

Mot compilant qui sert à créer des variables dans le dictionnaire.

Extrait le mot suivant du texte d'entrée et utilise ce mot comme nom

de la nouvelle variable. Les variables sont initialisées à 0.

arguments:

cccc Prochain mot dans le texte d'entrée. Nom de la variable.

retourne:

rien

CONSTANT ( cccc S: n -- )

Mot compilant qui sert à créer des constantes dans le dictionnaire.

Extrait le mot suivant du flux d'entrée et utilise ce mot comme nom

de la nouvelle constante. La constante est initialisée avec la valeur

qui est au sommet de la pile des arguments au moment de sa création.

arguments:

cccc Prochain mot dans le texte d'entrée. Nom de la constante.

n Valeur qui sera assignée à cette constante.

retourne:

rien

DEFER ( cccc S: -- )

Mot compilant.

Cré un nouveau mot dont l'action ne sera défini ultérieurement.

Cependant ce mot possède une action par défaut qui consiste à affiché

le message "Uninitialized defered word"

arguments:

cccc Prochain mot dans le texte d'entrée. Nom du nouveau mot.

retourne:

rien

DEFER! ( a-addr1 a-addr2 -- )

Défini l'action d'un mot créé avec DEFER.

exemple:

DEFER p2 \ le mot p2 est créé mais n'a pas d'action défini.

:noname dup * ; \ ( -- a-addr1 ) un mot sans nom viens d'être créé.

' p2 DEFER! \ ' p2 retourne le CFA de p2 et DEFER! affecte a-addr1 au PFA de P2.

2 p2 4 ok \ maintenant lorsque p2 est utilisé retourne le carré d'un entier.

arguments:

a-addr1 CFA de l'action que le mot doit exécuter.

a-addr2 CFA du mot différé.

retourne:

rien

DEFER@ ( a-addr1 -- a-addr2 )

Empile le CFA interprété par un mot défini avec DEFER dont le CFA est

au sommet de la pile des arguments.

arguments:

a-addr1 CFA du mot différé dont on veut obtenir l'action.

retourne:

a-addr2 CFA de l'action exécutée par le mot différé.

IS ( cccc S: a-addr -- )

Extrait le prochain mot du flux d'entrée. Recherche ce mot dans le dictionnaire.

Ce mot doit-être un mot créé avec DEFER. Lorsque ce mot est trouvé,

enregistre a-addr dans son PFA. a-addr est le CFA d'une action.

exemple:

\ création d'un mot différé qui peut effectuer différentes opérations arithmétiques.

DEFER MATH

' * IS MATH \ maintenant le mot MATH agit comme *

' + IS MATH \ maintenant le mot MATH agit comme +

arguments:

cccc Prochain mot dans le texte d'entrée. Correspond au nom d'un mot créé avec DEFER.

a-addr CFA de l'action à assigner à ce mot.

retourne:

rien

ACTION-OF ( cccc -- a-addr|0 )

Extrait le prochain mot du texte d'entrée et le recherche dans le dictionnaire.

Ce mot doit-être un mot créé avec DEFER. Si le mot est trouvé dans le dictinnaire

le CFA de son action est empilé.

arguments:

cccc Prochain mot dans le texte d'entrée. Nom recherché dans le dictionnaire.

retourne:

a-addr Adresse du CFA de l'action du mot différé. 0 si ce n'est pas un mot différé.

Index

>BODY
>COUNTED
>IN
'
+LOOP
,
."
:
:NONAME
;
?COMPILE
?DO
?EMPTY
?NAME
?WORD
ABORT
ABORT"
ACCEPT
ACTION-OF
ADR>IN
AGAIN
ALIGN
ALIGNED
ALLOT
BEGIN
C"
C,
CASE
CFA>NFA
CLIP
CONSTANT
COUNT
CREATE
DEFER
DEFER!
DEFER@
DO
DOES>
ELSE
ENDCASE
ENDOF
EVALUATE
FIND
FORGET
GETCLIP
HEADER
HERE
HIDE
HP
IF
IMMEDIATE
INTERPRET
IS
LEAVE
LITERAL
LOOP
MARKER
NFA>CFA
NFA>LFA
OF
PAD
PADSIZE
PARSE
PARSE-NAME
PASTE
POSTPONE
QUIT
RECURSE
REPEAT
REVEAL
S"
SOURCE
SOURCE!
STATE
THEN
TIB
TIBSIZE
UNTIL
VARIABLE
WHILE
WORD
WORDS
[
[']
]