Flash FORTH: guide rapide de références

published: 13 August 2025 / updated 13 August 2025

article: 18 mai 2019 / mis à jour 09 juin 2019

Interpréteur

L’interprète externe recherche des mots et des nombres délimités par les espaces blancs Tout est interprété comme un mot ou un nombre. Les nombres sont poussés sur la pile. Les noms de mots sont limités à 15 caractères. Certains mots sont utilisables seulement en compilation et ne peuvent être utilisés en interprétation. Ces mots seront colorés en rouge.

Données et pile

La pile de données (S:) est directement accessible et compte 32 cellules de 16 bits pour contenir les valeurs numériques. Les fonctions obtiennent leurs arguments depuis la pile et y laissnt également les résultats. Il y a aussi une pile de retour (R:) pouvant être utilisée pour le stockage temporaire.

Notation

n, n1, n2, n3: Entiers à cellule unique (16 bits).
u, u1, u2: Entiers non signés (16 bits).
x, x1, x2, x3: Elément à cellule unique (16 bits).
c: Valeur de caractère (8 bits).
d ud: Signé et non signé à double cellule (32 bits).
tut: Triple-cell signé et non signé (48 bits).
q uq: Quad-cell signé et non signé (64 bits).
f: Booléen
flag: 0 est faux, -1 est vrai.
flt flt1 flt3: Valeur en virgule flottante (32 bits).
sur PIC24-30-33 uniquement, avec option de construction.
addr, addr1, addr2: adresses 16 bits.
a-addr: adresse alignée sur les cellules.
c-addr: adresse de caractère ou d'octet.

Nombres et valeurs

2: dépose le nombre entier deux sur la pile. ( -- 2)
#255: dépose le nombre décimal 255 sur la pile. ( -- 255)
%11: dépose le nombre entier trois dans la pile. ( -- 3)
$10: dépose le nombre entier seize sur la pile. ( -- 16)
23.: dépose le double numéro sur la pile. ( -- 23 0)
decimal: sélectionne le format numérique sur la base 10. ( --)
hex: sélectionne le format numérique sur hexadécimal. ( --)
bin: sélectionne le format numérique sur binaire. ( --)
s>d: extension signée valeur simple en double. (n -- d)
Puisque les doubles nombres ont les bits les plus importants dans la cellule au-dessus des bits les moins significatifs, vous pouvez déposer la cellule du haut pour récupérer la valeur simple, à condition que la valeur ne soit pas trop grande pour être dans une cellule simple.
d>q: Étend un nombre de deux à quatre cellules. (d - q)
Requiert que qmath.h soit chargé. PIC18, PIC24-30-33.

Affichage des données

.: Afficher un nombre. ( n --)
u.: Afficher 16 bits non signé. ( u --)
u.r: Affiche 16 bits avec largeur de champ n, 0
d.: Afficher nombre 32 bits. ( d -- )
ud.: Afficher nombre 32 bits non signé. ( ud --)
.s: Afficher le contenu de la pile (de manière non destructive).
.st: Affiche la chaîne d'état pour la base, la section de données actuelle et le contenu de la pile. ( --)
?: Afficher le contenu à l'adresse. ( addr --) PIC24-30-33
dump: Affiche la mémoire de l'adresse, pour u octets. ( addr u --)

Manipulation de pile

dup: duplique valeur au sommet de la pile ( x -- x x )
?dup: duplique l’élément supérieur si différent de zéro. ( x -- 0 | x x)
swap: échange les deux éléments au sommet de la pile. ( x1 x2 -- x2 x1)
over: Copie le deuxième élément en haut. ( x1 x2 -- x1 x2 x1)
drop: Éliminer le premier élément. ( X -- )
nip: Retirez x1 de la pile. ( x1 x2 -- x2)
rot: Pour faire pivoter les trois principaux éléments. ( x1 x2 x3 -- x2 x3 x1)
tuck: Insérez x2 sous x1 dans la pile. ( x1 x2 -- x2 x1 x2)
pick: Dupliquez le deuxième élément en haut. ( xu ... x0 u -- xu ... x0 xu)
2dup: Dupliquer l’élément supérieur à deux cellules. ( d -- d d)
2swap: Échangez les deux premiers éléments à double cellule. ( d1 d2 -- d2 d1)
2over: Copiez le deuxième élément double en haut. ( d1 d2 -- d1 d2 d1)
2drop: Jeter le premier élément à double cellule. ( d -- )
>r: Envoyer pour retourner la pile. S :( n -) R :( - n)
r>: Prendre de la pile de retour. S :( - n) R :( n -)
r@: Copie le premier élément de la pile de retour. S :( - n) R :( n - n)
rdrop: Jeter le premier élément de la pile de retours. S :( -) R :( n -)
sp@: laisse le pointeur de la pile de données. (- addr)
sp!: Définissez le pointeur de la pile de données sur adresse. (addr -)

Opérateurs

Arithmétiques 16 bits

+: addition. ( n1 n2 -- n1+n2 ) sum
-: Soustrac. ( n1 n2 -- n1-n2 ) difference
*: Multiplication ( n1 n2 -- n1*n2 ) produit
/: Division. ( n1 n2 -- n1/n2 ) quotient
mod: division. ( n1 n2 -- n.rem ) reste
/mod: division. ( n1 n2 -- n.rem n.quot )
u/: division non signée 16/16 à 16-bit. ( u1 u2 -- u2/u1 )
u/mod: division non signée. ( u1 u2 -- u.rem u.quot )
16-bit/16-bit à 16-bit
1: dépose 1 sur la pile. ( -- 1 )
1+: ajoute 1. ( n -- n1 )
1-: soustrait 1. ( n -- n1 )
2+: ajoute deux. ( n -- n1 )
2-: soustrait 2 de n. ( n -- n1 )
2*: multiplie par 2; décalage gauche de 1 bit. ( u -- u1 )
2/: divise par 2; décalage droit de 1 bit. ( u -- u1 )
*/: échelle. ( n1 n2 n3 -- n1*n2/n3 )
u*/mod: échelle non signée u1*u2/u3 ( u1 u2 u3 -- u.rem u.quot )
utilise un résultat intermédiaire 32-bit .
abs: valeur absolue. ( n -- u )
negate: val négative n. ( n -- -n )
?negate: val négative n1 si n2 est négatif. ( n1 n2 -- n3 )
min: dépose val mini. ( n1 n2 -- n )
max: dépose val maxi. ( n1 n2 -- n )
umin: minimum non signé. ( u1 u2 -- u )
umax: maximum non signé. ( u1 u2 -- u )

Arithmétiques 32 bits

Certains de ces mots requièrent core.txt, math.txt and qmath.txt.

d+: addition 32 bits. ( d1 d2 -- d1+d2 )
d-: sousctraction 32 bits. ( d1 d2 -- d1-d2 )
m+: addition val 16 bits à une valeur 32 bits. ( d1 n -- d2 )
m*: multiplication 16*16 à 32-bit. ( n n -- d )
d2*: multiplie par 2. ( d -- d )
d2/: divise par 2. ( d -- d )
um*: multiplication non signée 16x16 vers 32 bit. ( u1 u2 -- ud )
ud*: multiplication non signée 32x16 vers 32-bit. ( ud u -- ud )
um/mod: division non signée. ( ud u1 -- u.rem u.quot )
32-bit/16-bit to 16-bit
ud/mod: division non signée. ( ud u1 -- u.rem ud.quot )
32-bit/16-bit to 32-bit
fm/mod: division. ( d n -- n.rem n.quot )
sm/rem: dimision symétrique. ( d n -- n.rem n.quot )
32-bit/16-bit vers 16-bit.
m*/: échelle avec résultat intermédiaire triple. d2 = d1*n1/n2 ( d1 n1 n2 -- d2 )
um*/: échelle avec résultat intermédiaire triple. ud2 = ud1*u1/u2 ( ud1 u1 u2 -- ud2)
dabs: val absolue. ( d -- ud )
dnegate: 32 bits négatif. ( d -- -d )
?dnegate: négatif d si n est négatif. ( d n -- -d )

Tests sur valeurs

=: laisse true si x1 x2 sont égaux. ( x1 x2 -- f )
<>: laisse true si x1 x2 ne sont aps égaux. ( x1 x2 -- f )
<: laisse true si n1 inférieur à n2. ( n1 n2 -- f )
>: laisse true si n1 supérieur à n2. ( n1 n2 -- f )
0=: laisse true si n is zero. ( n -- f )
inversion logique.
0<: laisse true si n is negative. ( n -- f )
within: laisse true si xl <= x < xh. ( x xl xh -- f )
u<: laisse true si u1 < u2. ( u1 u2 -- f )
u>: laisse true si u1 > u2. ( u1 u2 -- f )
d=: laisse true si d1 d2 sont égaux. ( d1 d2 -- f )
d0=: laisse true si d est nul. ( d -- f )
d0<: laisse true si d est négatif. ( d -- f )
d<: laisse true si d1 < d2. ( d1 d2 -- f )
d>: laisse true si d1 > d2. ( d1 d2 -- f )

Opérateurs sur bits

invert: complément à un. ( x -- x )
dinvert: inversion 32 bits. ( du -- du )
and: ET logique. ( x1 x2 -- x )
or: OU logique. ( x1 x2 -- x )
xor: OU eXclusif logique. ( x -- x )
lshift: décalage gauche u bits. ( x1 u -- x2 )
rshift: décalage droite u bits. ( x1 u -- x2 )

Mémoire

En règle générale, le microcontrôleur a trois contextes de mémoire distincts: Flash, EEPROM et SRAM. FlashForth unit ces mémoires espaces dans un seul espace d'adressage de 64 Ko.

Carte mémoire AVR8

Toutes les opérations sont limitées à 64 Ko d'espace d'adressage divisée en:

$0000: (RAMSIZE-1) SRAM
RAMSIZE: (RAMSIZE+EEPROMSIZE-1) EEPROM
($ffff-FLASHSIZE+1): $ffff Flash

L’espace SRAM comprend l’espace IO et une fonction spéciale registres. Le marqueur de mémoire haute pour le contexte Flash est définie par le taille combinée de la zone de démarrage et du noyau Flash FORTH.

Contexte mémoire

ram: sélectionne l'espace mémoire SRAM. ( -- )
eeprom: sélectionne l'espace mémoire EEPROM. ( -- )
flash: sélectionne l'espace mémoire Flash. ( -- )
fl-: désactive l'écriture dans Flash, EEPROM. ( -- )
fl+: active l'écriture dans Flash, EEPROM, par défaut. ( -- )
iflush: vide le tampon d'écriture. ( -- )
here: dépose le pointeur courant du dictionnaire. ( -- addr )
align: Aligner le pointeur de dictionnaire de la section de données actuelle sur la limite de cellule. ( -- )
hi: dépose la limite haute de l'espace courant de données. ( -- u )

Accès mémoire

!: stocke x dans address. ( x a-addr -- )
@: récupère x depuis address. ( a-addr -- x )
@+: Récupére contenu de addr et incrémenter addr de la tailel du contenu. ( a-addr1 -- a-addr2 x )
2!: stocke val 32 bits to address. ( x1 x2 a-addr -- )
2@: récupère val 32 bits de address. ( a-addr -- x1 x2 )
c!: stocke caractère à address. ( c addr -- )
c@: récupère caractère depuis address. ( addr -- c )
c@+: récupère char, incrémente address. ( addr1 -- addr2 c )
+!: Add n à valeur dans address. ( n addr -- )
-@: récupère val depuis addr et décrémente addr de 2. ( addr1 -- addr2 x )
>a: écris dans registre A. ( x -- )
a>: lis depuis le registre A. ( -- x )

Accès octets en RAM

mset: Définir les bits dans le registre de fichiers avec masque c. ( c addr -- )
mclr: Effacer les bits dans le registre de fichiers avec masque c. ( c addr -- )
mtst: AND fichier registre octet avec masque c. ( c addr -- x )

Ce qui suit vient de bit.txt

-->

Dictionnaire

Gestion du dictionnaire

marker -my-mark: Marque un emplacement dictionnaire et état allocation mémoire avec -my-mark
-my-mark: Remet le dictionnaire à l'état avant la création de -my-mark
empty: Restaure le dictionnaire et la mémoire allouée ( ---)
words: Liste les mots du dictionnaire ( -- )

Définition constantes et variables

constant name: définition nouvelle constante. ( n -- )
2constant name: définition constante double. ( x x -- )
name: dépose la valeur sur la pile ( -- n)

Exemples

Définition de mots spéciaux

create name: Crée le mot name et stocke le pointeur courant de données/
allot: définit la partie exécution d'un mot créé par create

Exemple de tableaux

Opérations mémoire

Constantes prédéfinies

Variables prédéfinies

Compilateur

Fonctions de définition

Commentaires

Exemples de définitions deux-points

: carre ( n -- n**2 )  \ création nouveau mot carre 
    dup * ;            \ ce que fait le nouveau mot 
: poke0 ( -- )         \ Exemple utilisant l'assembleur PIC18 
    [ $f8a 0 a, bsf, ] ;

Boucles et branchements

Exemples de boucles

decimal 
: sumdo 
    0 100 0 
    do i + loop ;  \ sumdo dépose 4950 
: sumfor 
    0 100 0 
    do r@ + loop ; \ sumfor dépose  4950 
: print-twos 
    10 0 
    do i u. 2 +loop ;

Unstructured flow control

Interaction avec l'utilisateur

Multitâche

Mots à charger depuis task.txt

task:: Définir une nouvelle tâche dans l'espace mémoire flash
( tibsize stacksize rstacksize addsize -- )
Utilisez ram xxx allot pour laisser de la place pour le PAD de la tâche précédemment définie.
La tâche OPERATOR n'utilise pas PAD.
tinit: Initialise une zone utilisateur et la relie à la boucle de tâches. ( taskloop-addr task-addr -- )
Notez que cela ne peut être exécuté qu'à partir de la tâche opérateur.
task: laisse l'adresse de la table de définition de tâche. ( -- addr)
run: exécute une tâche en l'insérant après opérateur dans la liste chaînée alternée. ( tâche-addr --)
Ne peut être exécuté qu'à partir de la tâche opérateur.
end: Supprimer une tâche de la liste des tâches. ( task-addr -- )
Ne peut être exécuté qu'à partir de la tâche opérateur.
single: Termine toutes les tâches sauf la tâche opérateur. ( -- )
Supprime toutes les tâches de la liste des tâches.
Ne peut être exécuté qu'à partir de la tâche opérateur.
tasks: liste toutes les tâches en cours d'exécution. ( -- )
pause: Passe à la tâche suivante dans la liste des tâches.
Inactif dans la tâche opérateur si toutes les tâches le permettent. ( -- )
his: Accéder aux variables utilisateur d'une autre tâche.
( task.addr vvar.addr -- addr )
load: Leave the CPU load on the stack. ( -- n ) Load is percentage of time that the CPU is busy.
Updated every 256 milliseconds.
load+: Activer le voyant de charge sur l’AVR8. ( -- )
load-: Désactiver le voyant de charge sur l’AVR8. ( -- )
busy: Mode inactif du processeur non autorisé. ( -- )
idle: processeur inactif est autorisé. ( -- )
operator: dépose l'adresse de la tâche opérateur. ( -- addr )
ulink: lien vers la prochaine tâche. ( -- addr )

Assembleur structuré

Pour utiliser un grand nombre des mots répertoriés dans les sections suivantes, chargez le fichier texte asm.txt. L'assembleur de chaque famille de processeurs fournit le même ensemble de mots de contrôle ow structurés, cependant, la nles conditionnels qui vont avec ces mots sont quelque peu spécifiques au processeur.

if, xxx else, yyy then,: exécution conditionnelle. ( cc -- )
begin, xxx again,: boucle indéfinie. ( -- )
begin, xxx cc until,: boucle tantq ue condition vraie. ( -- )

Mots assembleurs pour la famille AVR8

Pour les instructions ATmega, Rd indique la destination (et source), Rr désigne le registre de source, Rw désigne un code de paire de registres, K désigne des données constantes, k est une adresse constante, b est un bit dans le registre, x, Y, Z sont des registres d’adresses indirectes, A est un Adresse d'emplacement d'E/S, et q est un déplacement (6 bits) pour un accès direct.

adresser.

Constantes de registres

Z: ( -- 0 )
Z+: ( -- 1 )
-Z: ( -- 2 )
Y: ( -- 8 )
Y+: ( -- 9 )
-Y: ( -- 10 )
X: ( -- 12 )
X+: ( -- 13 )
-X: ( -- 14 )
XH:XL: ( -- 01 )
YH:YL: ( -- 02 )
ZH:ZL: ( -- 03 )
R0: ( -- 0 )
R16: ( -- 16 )
R1: ( -- 1 )
R17: ( -- 17 )
R2: ( -- 2 )
R18: ( -- 18 )
R3: ( -- 3 )
R19: ( -- 19 )
R4: ( -- 4 )
R20: ( -- 20 )
R5: ( -- 5 )
R21: ( -- 21 )
R6: ( -- 6 )
R22: ( -- 22 )
R7: ( -- 7 )
R23: ( -- 23 )
R8: ( -- 8 )
R24: ( -- 24 )
R9: ( -- 9 )
R25: ( -- 25 )
R10: ( -- 10 )
R26: ( -- 26 )
R11: ( -- 11 )
R27: ( -- 27 )
R12: ( -- 12 )
R28: ( -- 28 )
R13: ( -- 13 )
R29: ( -- 29 )
R14: ( -- 14 )
R30: ( -- 30 )
R15: ( -- 15 )
R31: ( -- 31 )