Ficlのソースを表示

このハンドブックは、Ficl（Forth-Inspired Command Language）の使用方法と機能を包括的に解説するものです。Ficlは、リソースの制約がある組み込みシステム向けに設計された、ANS Forthに基づく拡張可能な言語インタプリタです。

Ficlは、Forthのシンプルさと柔軟性を活かしつつ、幅広いユーザーに向けて設計されています。本書では、Ficlの基本構文から始め、段階的に高度なトピックや応用例を解説していきます。これにより、組み込みシステムや小規模プロジェクトにおいて、効率的かつ迅速な開発が可能となります。

本書は、Ficlの初心者から経験豊富なプログラマーまで幅広い読者を対象とし、基本概念や実用的な例を通してFiclの理解を深め、プロジェクトでの活用をサポートします。

== 導入 ==
まず Ficl の処理系を導入しましょう。

=== FreeBSD ===
Portsコレクションの lang/ficl から導入できます。

=== ソースコードを入手してインストール ===
GNU/Linux には、あまり Ficl をパッケージ化しているディストリビューションはないようです。

ソースコードを入手して、ビルドしインストールしましょう。

:<syntaxhighlight lang=bash line>
$ mkdir ~/ficl
$ cd ficl
$ wget https://downloads.sourceforge.net/project/ficl/ficl-all/ficl4.1/ficl-4.1.0.tar.gz
$ tar zxvBpf ficl-4.1.0.tar.gz 
$ cd ficl-4.1.0/
$ make
$ ./ficl
$ sudo install -c ficl /usr/local/bin/
</syntaxhighlight>

=== Ficlの起動と終了 ===
Ficlを起動して使用する方法は、通常のForthシステムと似ていますが、具体的な手順についてはFiclの実装に依存します。一般的な方法を以下に示します。

:<syntaxhighlight lang=text line>
$ ficl
loading CORE EXT words 
loading SEARCH & SEARCH-EXT words 
loading Johns-Hopkins locals 
loading MARKER 
loading ficl O-O extensions 
loading ficl utility classes 
loading ficl string class 
Ficl version 4.1.0
Apr 15 2024 
ok> 1 2 3 * + . cr ↵
7 
ok> bye ↵
$
</syntaxhighlight>

: シェルから <code>ficl</code> をタイプして起動します。
: <code>ok> </code> が Ficl のプロンプトでこの状態が解釈モード（Interpretation mode）です。
: ここでは、<code>1 2 3 * + . cr </code>を入力して、値<code>7</code>を得ています。
: Ficlは、<code>bye</code> で終了します。

=== ファイルの実行 ===
あらかじめファイルに書かれたコードの実行は、コマンドラインからファイル名を与えます。

:<syntaxhighlight lang=text line>
$ cat hello.fr 
\ hello.fr:
.( Hello, world!) cr
bye

$ ficl hello.fr 
loading CORE EXT words 
loading SEARCH & SEARCH-EXT words 
loading Johns-Hopkins locals 
loading MARKER 
loading ficl O-O extensions 
loading ficl utility classes 
loading ficl string class 
Ficl version 4.1.0
Apr 15 2024 
loading hello.fr 
Hello, world!
</syntaxhighlight>

ソースの最後に <code>bye</code> がないと <code>ok> </code> が出て解釈モードになります。

== 構文の基礎 ==

Ficlの構文は、基本的なスタックベースの逆ポーランド記法に基づいています。このセクションでは、Ficlの基本的な構文について説明します。

{{See also|Forth}}

=== スタックとワード ===

Ficlでは、スタックが中心的な役割を果たします。数値やデータはスタックにプッシュ（積み上げ）され、ワード（単語）はスタックから値をポップ（取り出し）して処理します。ワードは辞書に登録された名前付きのコードであり、それぞれが特定の機能を持ちます。ワードは、Ficlプログラムの基本的なビルディングブロックです。

=== 命令の形式 ===

Ficlの命令は基本的に次の形式を取ります：

:<syntaxhighlight lang=forth>
<引数1> <引数2> ... <引数n> <ワード>
</syntaxhighlight>

ここで、<code><引数></code>はスタックにプッシュされる値やデータを表し、<code><ワード></code>はこれらの引数を処理する特定の命令を示します。

=== コメント ===

Ficlでは、コメントは括弧で囲んで表現されます。例えば：

:<syntaxhighlight lang=forth>
( これはコメントです )
</syntaxhighlight>

<code>\</code> から行末までもコメントです

:<syntaxhighlight lang=forth>
3 4 + \ 3 + 4 の結果をスタックトップに残す
</syntaxhighlight>

コメントはインタプリタに無視されます。

=== スタックエフェクト ===

Ficlの各ワードは、スタック上で特定の操作を行います。ワードのドキュメントでは、それがスタックに対してどのような影響を与えるかを示す記述があります。例えば：

:<syntaxhighlight lang=forth>
+ ( a b -- c )
</syntaxhighlight>

この記述は、<code>+</code>ワードが2つの引数（<code>a</code>と<code>b</code>）を消費し、1つの結果（<code>c</code>）をスタックに残すことを意味します。

=== 例 ===

以下は、Ficlでの簡単な計算の例です：

:<syntaxhighlight lang=forth>
3 4 + .
</syntaxhighlight>

この例では、<code>3</code>と<code>4</code>がスタックにプッシュされ、<code>+</code>ワードが実行されてスタック上で加算が行われます。最後の<code>.</code>はスタックのトップの値を出力するワードです。

:{|
|-
!コード!!style='width:3em'| 3 !!style='width:3em'| 4 !!style='width:3em'| + !!style='width:3em'| .
|-
!スタックトップ
|style="border:1px solid black; text-align:center"| 3 ||style="border:1px solid black; text-align:center"| 4 ||style="border:1px solid black; text-align:center"| 7 || 
|-
!
|   ||style="border:1px solid black; text-align:center"| 3 ||   || 
|-
!出力
|   ||  ||  ||style="text-align:center; font-weight: bold"| 7 
|}

以上がFiclの基本的な構文についての概要です。次のセクションでは、さらに詳細なワードの説明をします。

=== スタック操作 ===

Ficlでは、以下のような基本的なスタック操作がサポートされています：

* <code>dup</code> : スタックのトップにある値を複製する
* <code>drop</code> : スタックのトップから値を削除する
* <code>swap</code> : スタックのトップの2つの値を交換する
* <code>over</code> : スタックの2つ目の値をトップに複製する
* <code>rot</code> : スタックのトップの3つの値を回転させる

これらの操作を組み合わせて、さまざまな計算や処理を行うことができます。

=== ワードの定義 ===
ワードはFiclプログラムの基本的な構成要素です。新しいワードを定義するには、<code>:</code>（コロン）を使用します。例えば、以下のようにして新しいワードを定義します：

:<syntaxhighlight lang=forth>
: double ( n -- n*2 ) 2 * ;
</syntaxhighlight>

この例では、<code>double</code>というワードはスタックから値を取り出して2倍にし、結果をスタックに戻します。

=== ワードの実装 ===
ワードの実装は、<code>:</code>（コロン）で始まり、<code>:</code>から<code>;</code>（セミコロン）までの間に記述されます。これは新しいワードの開始と終了を示します。例えば、上記の<code>double</code>ワードは、<code>2 * ;</code>で実装されています。<code>2 *</code>はスタックから値を取り出して2倍にし、<code>;</code>はワードの定義の終了を示します。

=== スタックエフェクトのコメント ===
ワードの定義には、<code>(</code>と<code>)</code>で囲まれたコメントが含まれることが一般的です。これにより、ワードが期待するスタックの状態を説明することができます。例えば、<code>( n -- n*2 )</code>は、<code>double</code>がスタックから整数を取り出し、その2倍の値をスタックに戻すことを示しています。

=== ワードの使用 ===
定義されたワードは、Ficlプログラム内で他のワードと同様に使用できます。例えば、先ほど定義した<code>double</code>ワードは、以下のようにして使用できます：

:<syntaxhighlight lang=forth>
5 double .
</syntaxhighlight>

このコードは、スタックに<code>5</code>をプッシュし、それを<code>double</code>ワードで処理して結果を表示します。

これがFiclにおける基本的なワード定義の手順です。ワード定義を使ってFiclプログラムを効果的に構築するためには、これらの手順を理解し、適切に使用することが重要です。

=== 文字列処理 ===
ワード <code>."</code> は、Ficlにおいて文字列を表示するために使用されるワードです。このワードはダブルクォート (<code>"</code>) で囲まれた文字列を表示します。


<code>."</code> はコンパイル時に使用されると、コンパイラによって文字列リテラルが生成されます。このリテラルは実行時に評価され、文字列が表示されます。

=== 使用例 ===

以下は <code>."</code> の基本的な使用例です：

:<syntaxhighlight lang=forth>
: say-hello ( -- )
 ." Hello, world!" cr
;
say-hello \ Hello, world!
</syntaxhighlight>

このコードでは、<code>Hello, world!</code> という文字列が表示されます。<code>cr</code> は改行を意味し、表示された文字列の後に改行が挿入されます。

=== 条件分岐 ===

Ficlにおける条件分岐は、主にスタックの状態を調べることで実現されます。Ficlでは条件分岐に <code>IF</code>、<code>ELSE</code>、<code>THEN</code> というワードの組み合わせが使われます。ここでは、基本的な条件分岐の使い方を説明します。

==== IF-ELSE-THEN ====

Ficlでは、<code>IF</code>、<code>ELSE</code>、<code>THEN</code> を組み合わせて条件分岐を行います。基本的な構文は以下の通りです：

:<syntaxhighlight lang=forth>
IF
    (true branch)
ELSE
    (false branch)
THEN
</syntaxhighlight>

* <code>IF</code> は条件式を評価し、その結果が真（非ゼロ）であれば、true branch（真の場合の処理）が実行されます。
* <code>ELSE</code> は条件が偽（ゼロ）である場合に実行される処理を指定します。<code>ELSE</code> は省略可能です。
* <code>THEN</code> は条件分岐の終了を示します。

==== 条件分岐の例 ====

例として、スタックのトップにある値が正かどうかを判定して処理を分岐するプログラムを示します。

:<syntaxhighlight lang=forth>
: check-positive ( n -- )
    0<
    IF
        ." Negative" cr
    ELSE
        ." Positive" cr
    THEN ;
</syntaxhighlight>

この例では、<code>check-positive</code> という新しいワードを定義しています。このワードはスタックから整数を1つ取り出し、その値が正（0より大きい）かどうかを判定します。

* <code>0<</code> はスタックトップの値が0未満かどうかを評価します。結果は真（非ゼロ）または偽（ゼロ）となります。
* <code>IF</code> は条件が真の場合（つまり負の値の場合）に <code>" Negative"</code> というメッセージを表示します。
* <code>ELSE</code> は条件が偽の場合（つまり正の値またはゼロの場合）に <code>" Positive"</code> というメッセージを表示します。ここでは省略しています。
* <code>THEN</code> は条件分岐の終了を示します。

この例を使用すると、以下のようにして条件分岐を行うことができます：

:<syntaxhighlight lang=forth>
5 check-positive
</syntaxhighlight>

このコードは <code>Positive</code> を出力します。同様に、負の値を入力すると <code>Negative</code> が出力されます。

これがFiclにおける基本的な条件分岐の使い方です。条件に応じて処理を切り替えるために <code>IF</code>、<code>ELSE</code>、<code>THEN</code> を適切に使用することで、柔軟なプログラミングが可能です。

=== 多方向分岐 ===
Ficlには <code>CASE</code> ワードがあり、複数の条件に基づいて分岐するために使用されます。<code>CASE</code> ワードは、与えられた値に対して複数の条件を評価し、一致する条件に応じて異なる処理を実行します。ここでは、Ficlにおける <code>CASE</code> ワードの基本的な使い方を説明します。

==== CASE-OF-ENDOF-ENDCASE ====

Ficlにおける <code>CASE</code> 文の基本的な使い方は次の通りです：

:<syntaxhighlight lang=forth>
value
CASE
    constant1 OF
        (condition1 code)
    ENDOF
    constant2 OF
        (condition2 code)
    ENDOF
    ...
    constantN OF
        (conditionN code)
    ENDOF
        (default code)
    ENDCASE
</syntaxhighlight>

* <code>value</code> は条件式であり、この値に基づいて <code>CASE</code> 文が評価されます。
* <code>OF</code> は個々の条件節の開始を示します。
* <code>ENDOF</code> は個々の条件節の終了を示します。
* <code>DEFAULT</code> はどの条件にも一致しない場合のデフォルトの処理を指定します。
* <code>ENDCASE</code> は <code>CASE</code> 文の終了を示します。

各条件節は、<code>constant</code> が <code>value</code> と一致する場合に実行されるコードを含みます。

==== CASE-OF-ENDOF-ENDCASEの例 ====

例として、<code>value</code> の値に応じて異なるメッセージを出力する <code>CASE</code> 文を示します。

:<syntaxhighlight lang=forth>
: print-message ( n -- )
    CASE
        1 OF
            ." One" cr
        ENDOF
        2 OF
            ." Two" cr
        ENDOF
        3 OF
            ." Three" cr
        ENDOF
            ." Other" cr
    ENDCASE ;

5 print-message
</syntaxhighlight>

この例では、<code>print-message</code> という新しいワードを定義しています。このワードはスタックから整数を取り出し、その値に応じて異なるメッセージを出力します。

* <code>CASE</code> ブロック内の <code>1 OF</code> は、<code>value</code> が <code>1</code> の場合に実行されるコードを定義しています。
* <code>ENDOF</code> は各条件節の終了を示します。
* <code>DEFAULT</code> はどの条件にも一致しない場合に実行されるデフォルトのコードを定義しています。

上記の例を実行すると、<code>5</code> を入力した場合は <code>Other</code> というメッセージが出力されます。他の値を入力すると、対応するメッセージが出力されます。

これがFiclにおける <code>CASE</code> ワードの基本的な使い方です。<code>CASE</code> 文を使用することで、複数の条件に基づいて柔軟にプログラムを制御することができます。

=== ループ ===

Ficlでは、繰り返し処理を行うためのワードもサポートされています。例えば、以下のように使用します：

:<syntaxhighlight lang=forth>
: 10times
10 0 do
    i .
loop
;
</syntaxhighlight>

この例では、0から9までの数値を順番にスタックにプッシュして、<code>loop</code>までの間に繰り返し処理が行われます。<code>i</code>はループカウンタを示し、<code>.</code>はカウンタの値を出力します。

以上が、Ficlの基本的なワードの概要です。これらの基礎を理解することで、Ficlを使用してさまざまな計算や制御構造を実装することができます。詳細な操作や応用例については、Ficlのドキュメントやチュートリアルを参照してください。

== Ficlのパース戦略 ==

Ficlのパーサーは、他のFORTHとは異なり、拡張可能なパーサーチェーンを持っています。具体的には、Ficlのパーサーは1つの巨大な関数ではなく、単純なトークナイザーと一連のパースステップで構成されています。パースステップは、特定の種類のトークンを処理し、トークンに適切な操作を行います。

パーサーは次のように動作します。
# 新しいトークン（内部に空白のないテキストの文字列）を読み込みます。
# パーサーチェーン内の各パースステップに対して、そのトークンを渡してパースステップを呼び出します。パースステップがトークンを適切に処理した場合、次のトークンに進みます。
# パーサーがすべてのパースステップを試し、どれもトークンを処理しなかった場合、トークンは不正であり、エラーが表示され、仮想マシンがリセットされます。

パースステップは、ネイティブ関数またはFiclスクリプト関数として書くことができます。新しいパースステップはいつでもチェーンに追加できます。

そして、デフォルトのFiclパーサーチェーンは、以下のようになっています。
* <code>?word</code>: ローカル変数辞書やシステム辞書でトークンを検索し、見つかればそれに対応する処理を行います。
* <code>?prefix</code>: プレフィックスが有効な場合に、トークンの先頭部分を既知のプレフィックスのリストと一致させ、関連付けられた処理を行います。
* <code>?number</code>: トークンを数値に変換しようとします。
* <code>?float</code>: トークンを浮動小数点数に変換しようとします。

これらのパースステップは、Ficlの柔軟性を高め、新しい機能を追加する際にも役立ちます。

=== prefixの追加 ===

Ficlでは、ユーザーコードで prefix を新たに作ることが出来ます。

:<syntaxhighlight lang=forth>
ok> start-prefixes
ok> : 0b  2 __tempbase ; immediate
ok> end-prefixes   
ok> 0b1100 . cr
12 
ok> 
</syntaxhighlight>
ここでは 0b を前置する二進数リテラルを定義しています。

== ANS Forthへの準拠状況 ==
Ficlは、Forth言語の実装であり、ANS Forth規格に準拠していますが、完全に準拠しているわけではありません。以下は、FiclがANS Forthにどの程度準拠しているかを示す一般的な概要です。

# '''コアワードの実装:''' FiclはANS Forthのコアワードの多くを実装しています。これにはスタック操作、制御構造、データ型、変数、定数などが含まれます。
# '''ワードセット:''' FiclはANS Forthの基本的なワードセットに加えて、いくつかの追加のワードセットもサポートしています。これには、Forthの実行環境やアプリケーション開発を支援するための拡張機能が含まれます。
# '''標準準拠度の程度:''' FiclはANS Forthの基本的な機能には準拠していますが、すべての機能や拡張機能を実装しているわけではありません。特定の機能やワードがサポートされていない場合もあります。
# '''Ficl固有の拡張:''' Ficlは独自の拡張機能や機能を持っており、これらはANS Forthとは異なる場合があります。Ficlは独自のニーズや要件に合わせてカスタマイズされています。

したがって、FiclはANS Forthとの互換性を重視していますが、完全な準拠ではないことに留意する必要があります。特定のプロジェクトや環境でFiclを使用する場合は、詳細なドキュメントやリファレンスを参照して、サポートされている機能や動作を理解することが重要です。

機能の準拠状況は、ワード<code>ENVRIRONMENT?</code>を使って問い合わせることが出来ます。

:<syntaxhighlight lang=forth line>
.( address-unit-bits) bl emit s" address-unit-bits" environment?  [if] . [then] cr
.( core) bl emit s" core" environment?  [if] . [then] cr
.( core-ext) bl emit s" core-ext" environment?  [if] . [then] cr
.( /counted-string) bl emit s" /counted-string" environment?  [if] . [then] cr
.( exception) bl emit s" exception" environment?  [if] . [then] cr
.( exception-ext) bl emit s" exception-ext" environment?  [if] . [then] cr
.( ficl-robust) bl emit s" ficl-robust" environment?  [if] . [then] cr
.( file) bl emit s" file" environment?  [if] . [then] cr
.( file-ext) bl emit s" file-ext" environment?  [if] . [then] cr
.( floating) bl emit s" floating" environment?  [if] . [then] cr
.( floating-ext) bl emit s" floating-ext" environment?  [if] . [then] cr
.( floating-stack) bl emit s" floating-stack" environment?  [if] . [then] cr
.( floored) bl emit s" floored" environment?  [if] . [then] cr
.( /hold) bl emit s" /hold" environment?  [if] . [then] cr
.( #locals) bl emit s" #locals" environment?  [if] . [then] cr
.( locals) bl emit s" locals" environment?  [if] . [then] cr
.( locals-ext) bl emit s" locals-ext" environment?  [if] . [then] cr
.( max-char) bl emit s" max-char" environment?  [if] . [then] cr
.( max-n) bl emit s" max-n" environment?  [if] . [then] cr
.( max-d) bl emit s" max-d" environment?  [if] . [then] cr
.( max-u) bl emit s" max-u" environment?  [if] u. [then] cr
.( memory-alloc) bl emit s" memory-alloc" environment?  [if] . [then] cr
.( /pad) bl emit s" /pad" environment?  [if] . [then] cr
.( return-stack-cells) bl emit s" return-stack-cells" environment?  [if] . [then] cr
.( search-order) bl emit s" search-order" environment?  [if] . [then] cr
.( search-order-ext) bl emit s" search-order-ext" environment?  [if] . [then] cr
.( stack-cells) bl emit s" stack-cells" environment?  [if] . [then] cr
.( tools) bl emit s" tools" environment?  [if] . [then] cr
.( tools-ext) bl emit s" tools-ext" environment?  [if] . [then] cr
.( wordlists) bl emit s" wordlists" environment?  [if] . [then] cr
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text line>
address-unit-bits 8 
core -1 
core-ext 0 
/counted-string 256 
exception -1 
exception-ext -1 
ficl-robust 2 
file -1 
file-ext -1 
floating 0 
floating-ext 0 
floating-stack 128 
floored 0 
/hold 256 
#locals 64 
locals -1 
locals-ext -1 
max-char 255 
max-n 2147483647 
max-d 2147483647 
max-u 4294967295 
memory-alloc -1 
/pad 256 
return-stack-cells 128 
search-order -1 
search-order-ext -1 
stack-cells 128 
tools -1 
tools-ext 0 
wordlists 16 
</syntaxhighlight>

== 倍長整数 ==
Ficlは、「'''Providing names from the Double-Number word set'''<ref name=ans>[https://ficl.sourceforge.net/dpans.html ficl standards compliance]</ref>」としており「Double-Number word setの一部を提供する標準システム」とラベル付けされます。

; 実装されているワード
: [[#two-constant|2constant]] [[#two-value|2value]] [[#two-literal|2literal]] [[#two-variable|2variable]] [[#d-negate|dnegate]]

; 倍長整数リテラル
: 倍長整数は専用のリテラルを持っています。
: 倍長整数リテラルは整数リテラルに <code>.</code> を補うことで表現します。
:; 倍長整数リテラルの例
::<syntaxhighlight lang=forth>
0. 1. -2.
</syntaxhighlight>

;実行例
:<syntaxhighlight lang=text line>
ok> 123. 456. .s
[data stack has 4 entries, top at 0x5643495da440]
[0x5643495da440   0]:          456 (0x000001c8)
[0x5643495da438   1]:            0 (0x00000000)
[0x5643495da430   2]:          123 (0x0000007b)
[0x5643495da428   3]:            0 (0x00000000)
[data stack base at 0x5643495da428]
ok> -1. -2. .s
[data stack has 8 entries, top at 0x5643495da460]
[0x5643495da460   0]:           -2 (0xfffffffffffffffe)
[0x5643495da458   1]:            0 (0x00000000)
[0x5643495da450   2]:           -1 (0xffffffffffffffff)
[0x5643495da448   3]:            0 (0x00000000)
[0x5643495da440   4]:          456 (0x000001c8)
[0x5643495da438   5]:            0 (0x00000000)
[0x5643495da430   6]:          123 (0x0000007b)
[0x5643495da428   7]:            0 (0x00000000)
[data stack base at 0x5643495da428]
ok> 
</syntaxhighlight>

== 浮動小数点数 ==
Ficlは、「'''Providing names from the Floating-Point word set'''<ref name=ans />」としており「Floating-Point Extensions word setの一部を提供する標準システム」とラベル付けされます。

Ficlは、データスタックとは別にフローティングポイントスタック（FPスタック）を持ちます。

:<syntaxhighlight lang=text line>
ok> 3.14e 5e fdup f* f* f. cr
78.500000 
ok> 1e 2e 3e 4e 5e f.s
[float stack has 5 entries, top at 0x558b5e04ccc8]
[0x558b5e04ccc8   0]         5.000000 (0x5d82d24540a00000)
[0x558b5e04ccc0   1]         4.000000 (0x5d82d24540800000)
[0x558b5e04ccb8   2]         3.000000 (0x5d82d24540400000)
[0x558b5e04ccb0   3]         2.000000 (0x5d82d24540000000)
[0x558b5e04cca8   4]         1.000000 (0x5d82d2453f800000)
[float stack base at 0x558b5e04cca8]
ok> f+ f+ f+ f+ f.s
[float stack has 1 entries, top at 0x558b5e04cca8]
[0x558b5e04cca8   0]        15.000000 (0x5d82d24541700000)
[float stack base at 0x558b5e04cca8]
</syntaxhighlight>
浮動小数点数関係のワードは原則的に<code>f</code>を名前に前置します。

== アライメント ==
ドキュメントおよびソースコードのコメントでは <code>FICL_ALIGN</code> を参照すると書かれていますが、実際は <code>FICL_PLATFORM_ALIGNMENT</code> が参照されています。

これは実行時にも
:<syntaxhighlight lang=text line>
ok> s" FICL_PLATFORM_ALIGNMENT" environment?  [if] . [then] cr
8 
</syntaxhighlight>
のように参照できます。

== オブジェクト指向プログラミング ==

=== Ficlのオブジェクト指向（OO）システムの特徴 ===

* '''遅延バインドと早期バインド:''' Ficlのオブジェクトは通常遅延バインドされます。これは、特定のオブジェクトに対して常に適切なメソッドが呼び出されることを保証します。しかし、コンパイル時にオブジェクトのクラスがわかる場合は、早期バインドも利用できます。
* '''単一継承、集約、およびオブジェクトの配列:''' FiclのOOPは単一継承をサポートし、さらに集約やオブジェクトの配列も可能です。
* '''独立したメソッド名前空間:''' クラスごとに独立したメソッド名前空間があり、メソッドはそのクラスまたはオブジェクトのコンテキスト内でのみ可視です。サブクラスではメソッドをオーバーライドまたは追加することができます。
* '''クラスとオブジェクトの統一された構文:''' Ficlでは、すべてのクラスがオブジェクトであり、クラスメソッドにはサブクラス化やインスタンス化などの機能が含まれます。
* '''既存のデータ構造のラッピング:''' Ficlはオブジェクトラッパーを使用して既存のデータ構造を適応できます。Cで書かれてインスタンス化されたデータ構造をFiclクラスでモデル化し、そのインスタンスを作成することができます。

=== Ficlのオブジェクト指向プログラミングの概念 ===

この文書では、オブジェクト指向プログラミングの基本的な概念や用語に触れています。オブジェクト指向プログラミングに馴染みがない場合は、一般的な概要を参照することをお勧めします。

=== Ficlのオブジェクトモデル ===

Ficlの全てのクラスは、共通の基本クラスである<code>OBJECT</code>から派生しています。すべてのクラスは<code>METACLASS</code>のインスタンスでもあります。これは、Ficlがクラスもオブジェクトとして扱うことを意味します。<code>METACLASS</code>はクラスに送信されるメッセージのためのメソッドを実装します。

=== Ficlのオブジェクト指向構文チュートリアル ===

==== オブジェクトの作成とクラスの定義 ====

まずは、オブジェクトを作成しクラスを定義する方法から始めましょう。

# クラスの定義
#:クラスを定義するには、基底クラスから<code>END-CLASS</code>までの間にフィールドとメソッドを定義します。例えば、complexクラスを定義するとします。
#; complex.fr
#:<syntaxhighlight lang=forth>
only
also oop definitions

object --> sub complex
  cell: .real
  cell: .imag
  
  : init ( f: real imag -- )
    locals| class inst |
    inst class --> .real f!
    inst class --> .imag f!
  ;

  : @ ( -- f: real imag )
    locals| class inst |
    inst class --> .real f@
    inst class --> .imag f@
  ;

  : . ( f: -- f: )
    locals| class inst |
    inst class --> @ f. f.
  ;

end-class

3e 4e complex --> new cplx
cplx --> . cr \ 3.000000 4.000000 
</syntaxhighlight>
#:ここでは、<code>complex</code>というクラスが定義されています。<code>.real</code>と<code>.imag</code>は各軸の座標を示すインスタンス変数です。<code>init</code>メソッドは初期化時に呼び出され、<code>@</code>は各軸の値をフロートスタックに積むメソッドです。<code>.</code>メソッドは各軸の値を表示します。
# オブジェクトのインスタンス化
#: 定義したクラスを使用してオブジェクトをインスタンス化します。
#:<syntaxhighlight lang=forth>
3e 4e complex --> new cplx
</syntaxhighlight>
#:これにより、<code>complex</code>クラスのインスタンスである<code>cplx</code>オブジェクトが作成されます。
#:ここではフィールドの初期値をフロートスタックを経由して渡しています。
# メソッドの呼び出し
#: 作成したオブジェクトに対してメソッドを呼び出す方法を示します。
#:<syntaxhighlight lang=forth>
cplx --> . cr \ 3.000000 4.000000 
</syntaxhighlight>
#:<code>cplx --> .</code>のように、オブジェクト名に続けてメソッドを指定することで、対応するメソッドが実行されます。

==== クラス間の継承 ====

Ficlでは単一継承がサポートされています。既存のクラスを拡張して新しいクラスを定義することができます。

:<syntaxhighlight lang=forth>
OBJECT --> SUB C1
: M1   { 2:THIS -- }  ." C1's M1" CR ;
END-CLASS

C1 --> SUB C2
: M1   { 2:THIS -- }  ." C2's M1" CR ;
END-CLASS
</syntaxhighlight>

上記の例では、<code>C1</code>クラスをベースにして<code>C2</code>クラスを定義しています。<code>M1</code>メソッドが<code>C1</code>から<code>C2</code>でオーバーライドされています。

==== オブジェクト指向プログラミングの利点 ====

Ficlのオブジェクト指向プログラミングを活用することで、データと操作がひとつのまとまりとして扱えるため、コードの保守性や再利用性が向上します。また、クラスやオブジェクトの階層構造を使ってシステムを設計することで、問題をより効率的に解決できるようになります。

== 不足している標準ワードの追加 ==

Ficlは、ANS Forthに基いていますがすべての標準を実装してはいません。
このため適宜、必要なワードを追加する必要が生じます。
特に浮動小数点数に関するワードは基本的なワードセットにとどまっています。

=== FABSを実装 ===
浮動小数点数の絶対値を返すワード FABS は Ficl では未実装です。
FABS は比較的簡単な機能なので Forth で実装してみます。

; fabs.fr
:<syntaxhighlight lang=forth>
: fabs ( F: x -- | x | )
  fdup 0e f< if fnegate else
  fdup 0e f= if fdrop 0e then then 
;
</syntaxhighlight>
: 0.0 と一致したら 0.0 を返しているのは、-0.0 対策です。

使ってみます

:<syntaxhighlight lang=text>
$ ./ficl fabs.fr 
loading CORE EXT words 
loading SEARCH & SEARCH-EXT words 
loading Johns-Hopkins locals 
loading MARKER 
loading ficl O-O extensions 
loading ficl utility classes 
loading ficl string class 
Ficl version 4.1.0
Apr 16 2024 
loading fabs.fr 

ok> -12.3e fabs f. cr
12.300000 
ok> 42.1e fabs f. cr
42.099998 
ok> see fabs
: fabs
   0   fdup (instruction 177)
   1   0.0e (instruction 34)
   2   f< (instruction 190)
   3   branch0 8
   5   fnegate (instruction 159)
   6   branch 15
   8   fdup (instruction 177)
   9   0.0e (instruction 34)
  10   f= (instruction 192)
  11   branch0 15
  13   fdrop (instruction 175)
  14   0.0e (instruction 34)
;
ok> see abs
: abs
   0   dup (instruction 45)
   1   0< (instruction 83)
   2   branch0 5
   4   negate (instruction 62)
;
ok> 
</syntaxhighlight>

=== FSQRTを実装（Ficlを改造） ===
浮動小数点数の平方根を返すワード FSQRT は Ficl では未実装です。
FSQRT は Forth で実装するには手強いのでCで実装します。

; float.c の差分
:<syntaxhighlight lang=dpatch>
$ diff -rud --show-c-function float.c.orig float.c
--- float.c.orig        2010-09-14 03:43:04.000000000 +0900
+++ float.c     2024-04-16 10:44:21.236338034 +0900
@@ -159,7 +159,7 @@ static ficlInteger ficlFloatStackDisplay
 {
     struct stackContext *context = (struct stackContext *)c;
     char buffer[64];
*    sprintf(buffer, "[0x%08x %3d] %16f (0x%08x)\n", cell, context->count++, (double)(cell->f), cell->i);
+    sprintf(buffer, "[0x%08lx %3d] %16f (0x%08lx)\n", (long unsigned)cell, context->count++, (double)(cell->f), (long)cell->i);
     ficlVmTextOut(context->vm, buffer);
        return FICL_TRUE;
 }
@@ -400,6 +400,22 @@ int ficlVmParseFloatNumber( ficlVm *vm,
 }
 
 
+/*******************************************************************
+** Floating-point Square root.
+** fsqrt ( F: r -- sqrt(r) )
+*******************************************************************/
+static void ficlPrimitiveFSqrt(ficlVm *vm)
+{
+    FICL_STACK_CHECK(vm->floatStack, 1, 1);
+
+    float f = ficlStackPopFloat(vm->floatStack);
+ 
+    f = sqrt(f);
+    
+    ficlStackPushFloat(vm->floatStack, f);
+}
+
 #if FICL_WANT_LOCALS
 
 static void ficlPrimitiveFLocalParen(ficlVm *vm)
@@ -439,6 +455,8 @@ void ficlSystemCompileFloat(ficlSystem *
     ficlDictionarySetPrimitive(dictionary, "f.s",       ficlVmDisplayFloatStack,  FICL_WORD_DEFAULT);
     ficlDictionarySetPrimitive(dictionary, "fe.",       ficlPrimitiveEDot,           FICL_WORD_DEFAULT);
 
+    ficlDictionarySetPrimitive(dictionary, "fsqrt",     ficlPrimitiveFSqrt,           FICL_WORD_DEFAULT);
+    
 #if FICL_WANT_LOCALS
     ficlDictionarySetPrimitive(dictionary, "(flocal)",   ficlPrimitiveFLocalParen,     FICL_WORD_COMPILE_ONLY);
     ficlDictionarySetPrimitive(dictionary, "(f2local)",  ficlPrimitiveF2LocalParen,  FICL_WORD_COMPILE_ONLY);</syntaxhighlight>

ビルドの上、使ってみます。

:<syntaxhighlight lang=shell-session>
$ ./ficl
loading CORE EXT words 
loading SEARCH & SEARCH-EXT words 
loading Johns-Hopkins locals 
loading MARKER 
loading ficl O-O extensions 
loading ficl utility classes 
loading ficl string class 
Ficl version 4.1.0
Apr 16 2024 
ok> 2e fsqrt f. cr
1.414214 
ok> 3e fdup f* 4e fdup f* f+ fsqrt f. cr
5.000000 
ok> see fsqrt
fsqrt is a primitive
ok> 
</syntaxhighlight>

=== FSQRTを実装（Johns-Hopkins localsを使用しFiclで実装）===
前項では、Ficlを改造してCレベルの実装しましたが、Ficlのコードだけで実装してみました。
とは言うものの、FloatスタックをFOVERなどを駆使して実装するのは興味深いのですが技巧的になりすぎるので、ここでは Johns-Hopkins localsを使用し名前付き引数と名前付きローカル変数を使ってライトに実装しました。

:<syntaxhighlight lang=forth>
: fabs ( F: x -- | x | )
  fdup 0e f< if fnegate else
  fdup 0e f= if fdrop 0e then then 
;

-1e fabs f. cr  / 1.000000 
0e fabs f. cr   / 0.000000 
42e fabs f. cr  / 42.000000 

: fsqrt { f:x | f:guess f:last -- √x }
 x 0e f< if  \ 負の数の平方根は定義されていないため、NaNを返す
     0e 0e f/
 else
   x 0e f= if  \ 零の平方根は零なのでそのまま返す
     0e
   else  \ ニュートン法を使って平方根を計算する
     x 2e f/ to guess \ 初期推定値として x の半分を使う

     begin
        guess to last
        x last f/ last f+ 2e f/ to guess  \ ニュートン法の更新式
        last guess f- fabs 1e-8 f>  \ 誤差が許容範囲内になったら計算結果を返す
     while
     repeat
     guess
   then
 then
;

.( -1.0 FSQRT ) -1e fsqrt f. cr  \ -1.0 FSQRT -nan 
.( 0.0 FSQRT )   0e fsqrt f. cr  \ 0.0 FSQRT 0.000000 
.( 1.0 FSQRT )   1e fsqrt f. cr  \ 1.0 FSQRT 1.000000 
.( 2.0 FSQRT )   2e fsqrt f. cr  \ 2.0 FSQRT 1.414214 
.( 3.0 FSQRT )   3e fsqrt f. cr  \ 3.0 FSQRT 1.732051 
.( 4.0 FSQRT )   4e fsqrt f. cr  \ 4.0 FSQRT 2.000000 
</syntaxhighlight>

<code>{ f:x | f:guess f:last -- √x }</code> は、コメントではなく、Johns-Hopkins localsというFiclの引数とローカル変数を扱う仕組み <code>{</code> を利用しています。

具体的には:

* <code>f:x</code> は、ワード本体で使用される浮動小数点数の引数<var>x</var>を宣言しています。
* <code>|</code> は、入力引数とローカル変数を分ける記号です。
* <code>f:guess f:last</code> は、ローカル変数として<var>guess</var>と<var>last</var>という2つの浮動小数点数変数を宣言しています。
* <code>-- √x</code> は、このワードの出力が<var>x</var>の平方根であることを示すスタックコメントです。

ワード<code>to ( x -- )</code> は、つづく名前を持つローカル変数にスタックからポップした値をアサインします。kのとき使用されるスタックは f: で指定されていればフロートスタックが使われます。

Johns-Hopkins localsを使うと、記述性・可読性が向上しますがANS Forthの機能でないのが悩ましいところです。

{{コラム|ニュートン法を用いて実数の平方根を求めるアルゴリズム|2=ニュートン法（またはニュートン・ラフソン法）を使用して実数の平方根を求めるアルゴリズムは、与えられた数 <math> x </math> の平方根 <math> \sqrt{x} </math> を見つける手法です。ニュートン法は、方程式 <math> f(y) = 0 </math> の解を数値的に近似するための反復的な手法であり、ここでは <math> f(y) = y^2 - x </math> として考えます。

具体的な手順は以下の通りです：

# '''初期推定値の設定:''' 平方根の推定値 <math> y_0 </math> を選びます。この値は <math> x </math> の近似値である必要がありますが、一般的には <math> x </math> よりも小さい値が使われます。例えば、<math> y_0 = x/2 </math> とすることが一般的です。
# '''反復計算:''' 反復的に以下の式を用いて推定値を修正します。
#:<math>y_{n+1} = y_n - \frac{f(y_n)}{f'(y_n)}</math>
#::ここで、
#:<math> f(y) = y^2 - x </math>
#::は <math> y </math> の関数であり、
#:<math> f'(y) = \frac{df}{dy} = 2y </math>
#::は <math> f(y) </math> の導関数です。
# '''収束条件の確認:''' 収束条件を満たすまで反復計算を行います。通常は、<math> |y_{n+1} - y_n| </math> が非常に小さい値（上に例では、<math> 10^{-8} </math> よりも小さい）になったときに反復を終了します。
}}

== トラブルシューティング ==
=== よくある問題と対処法 ===
=== エラーメッセージの意味と対応 ===

== 附録 ==

=== 全ワード一覧 ===

{| class='sortable wikitable'
|+ Ficlの全ワード一覧
! ワード || スタック操作 || カテゴリ || 種別 || 読み || 説明
|-
| <syntaxhighlight lang=forth inline>!</syntaxhighlight> || ( x a-addr -- ) || core || primitive || store || x を a-addr に保存 
|-
| <syntaxhighlight lang=forth inline>#</syntaxhighlight> || ( ud1 -- ud2 ) || core || primitive || {{Anchor|number-sign}} || ud2 = u1 / BASE ⇒ <# [[#number-sign-greater|#>]]
|-
| <syntaxhighlight lang=forth inline>#></syntaxhighlight> || ( xd -- c-addr u ) || core || primitive || {{Anchor|number-sign-greater}} || 数値文字列変換 ⇒ <# [[#number-sign|#]]
|-
| <syntaxhighlight lang=forth inline>#s</syntaxhighlight> || ( ud1 -- ud2 ) || core || primitive || {{Anchor|number-sign-s}} ||[[#number-sign|#]]に従ってud1の1桁をud2(商)がゼロになるまで変換します。⇒ [[#less-number-sign|<#]] [[#number-sign-greater|#>]]
|-
| <syntaxhighlight lang=forth inline>'</syntaxhighlight> || ( "<spaces>name" -- xt ) || core || primitive || {{Anchor|tick}} || name の実行トークン xt を返す
|-
| <syntaxhighlight lang=forth inline>(</syntaxhighlight> ||( "ccc<paren>" -- ) || core || primitive immediate || {{Anchor|paren}} || <code>)</code> までがコメント
|-
| <syntaxhighlight lang=forth inline>(+loop)</syntaxhighlight> || ( -- ) || ficl || primitive compile-only || {{Anchor|paren-plus-loop-paren}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>(.")</syntaxhighlight> || ( -- ) || ficl || primitive compile-only || {{Anchor|paren-dot-quote-paren}} || ficl独自:  
|-
| <syntaxhighlight lang=forth inline>(2constant)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(2constant)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(2literal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(2literal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(2local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(2local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(;)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(;)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(?do)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(?do)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@2Local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@2Local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@2Local0)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@2Local0)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@f2Local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@f2Local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@fLocal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@fLocal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@local0)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@local0)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(@local1)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(@local1)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(To2Local0)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(To2Local0)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(branch)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(branch)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(branch-final)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(branch-final)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(branch0)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(branch0)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(branch0-final)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(branch0-final)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(c")</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(c")}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(colon)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(colon)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(constant)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(constant)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(create)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(create)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(do)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(do)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(does)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(does)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(exit)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(exit)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(f2constant)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(f2constant)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(f2local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(f2local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(fconstant)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(fconstant)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(fliteral)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(fliteral)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(flocal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(flocal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(link)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(link)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(literal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(literal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(local)</syntaxhighlight> || ( c-addr u -- ) || core || primitive compile-only || {{Anchor|paren-local-paren}} || u <> 0 なら c-addr のローカル変数を宣言、u = 0 ならスコープ終了
|-
| <syntaxhighlight lang=forth inline>(loop)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(loop)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(of)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(of)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(parse-step)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(parse-step)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(to2Local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(to2Local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(toF2Local)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(toF2Local)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(toFLocal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(toFLocal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(toLocal)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(toLocal)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(toLocal0)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(toLocal0)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(toLocal1)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(toLocal1)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(unlink)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(unlink)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(user)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(user)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>(variable)</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|(variable)}} || desc. 
|-
| <syntaxhighlight lang=forth inline>*</syntaxhighlight> || ( n1 n2 -- n3 ) || core || primitive || {{Anchor|star}} || n3 = n1 n2
|-
| <syntaxhighlight lang=forth inline>*/</syntaxhighlight> || ( n1 n2 n3 -- n4 ) || core || primitive || {{Anchor|star-slash}} || n4 = n1 * n2 / n3
|-
| <syntaxhighlight lang=forth inline>*/mod</syntaxhighlight> || ( n1 n2 n3 -- n4 n5 ) || core || primitive || {{Anchor|star-slash-mod}} || n4 = n1 * n2 / n3, n5 = n1 * n2 % n3
|-
| <syntaxhighlight lang=forth inline>+</syntaxhighlight> || ( n1 n2 -- n3 ) || core || primitive || {{Anchor|plus}} || n3 = n1 + n2 
|-
| <syntaxhighlight lang=forth inline>+!</syntaxhighlight> || ( n a-addr -- ) || core || primitive || {{Anchor|plus-store}} || *a-addr += n
|-
| <syntaxhighlight lang=forth inline>+loop</syntaxhighlight> || ( C: do-sys -- ) || core || primitive immediate compile-only || {{Anchor|plus-loop}} || ⇒ [[#do|do]]
|-
| <syntaxhighlight lang=forth inline>,</syntaxhighlight> || ( x -- ) || core || primitive || {{Anchor|comma}} || データスペースにセルを1つ確保し、そのセルにxを保存する。
|-
| <syntaxhighlight lang=forth inline>-</syntaxhighlight> || ( n1 n2 -- n3 ) || core || primitive || {{Anchor|minus}} || n3 = n1 - n2
|-
| <syntaxhighlight lang=forth inline>-roll</syntaxhighlight> || ( n -- ) || ficl || primitive || {{Anchor|minus-roll}} || ⇒ [[#roll|roll]] 
|-
| <syntaxhighlight lang=forth inline>-rot</syntaxhighlight> || ( n -- ) || ficl || primitive || {{Anchor|minus-rote}} || ⇒ [[#rote|rot]]
|-
| <syntaxhighlight lang=forth inline>.</syntaxhighlight> || ( n -- ) || core || primitive || {{Anchor|dot}} || n をフリーフィールドフォーマットで表示 
|-
| <syntaxhighlight lang=forth inline>."</syntaxhighlight> || ( "ccc<quote>" -- ) || core || primitive immediate compile-only || {{Anchor|dot-quote}} || " をデリミタにパースした内容を表示 
|-
| <syntaxhighlight lang=forth inline>.(</syntaxhighlight> || ( "ccc<paren>" -- ) || core || primitive immediate || {{Anchor|dot-paren}} || ) をデリミタにパースした内容を表示 
|-
| <syntaxhighlight lang=forth inline>.env</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|.env}} || desc. 
|-
| <syntaxhighlight lang=forth inline>.hash</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|.hash}} || desc. 
|-
| <syntaxhighlight lang=forth inline>.s</syntaxhighlight> || ( -- ) || tools || primitive || {{Anchor|dot-s}} || データスタックの内容を１要素１行でトップから表示
|-
| <syntaxhighlight lang=forth inline>.s-simple</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|dot-s-simple}} || データスタックの内容を１行で表示
|-
| <syntaxhighlight lang=forth inline>.ver</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|mnum}} || Ficlのバージョンを Ficl version 4.1.0 の書式で表示
|-
| <syntaxhighlight lang=forth inline>/</syntaxhighlight> || ( n1 n2 -- n3 ) || core || primitive || {{Anchor|slash}} || n3 = n1 / n2 
|-
| <syntaxhighlight lang=forth inline>/mod</syntaxhighlight> || ( n1 n2 -- n3 n4 ) || core || primitive || {{Anchor|slash-mod}} || n3 = n1 / n2, n4 = n1 % n2 
|-
| <syntaxhighlight lang=forth inline>0<</syntaxhighlight> || ( n -- flag ) || core || primitive || {{Anchor|zero-less}} || flag = n < 0 ? true : false
|-
| <syntaxhighlight lang=forth inline>0<></syntaxhighlight> || ( n -- flag ) || core || primitive || {{Anchor|zero-not-equals}} || flag = n != 0 ? true : false
|-
| <syntaxhighlight lang=forth inline>0=</syntaxhighlight> || ( n -- flag ) || core || primitive || {{Anchor|zero-not-equals}} || flag = n == 0 ? true : false
|-
| <syntaxhighlight lang=forth inline>0></syntaxhighlight> || ( n -- flag ) || core || primitive || {{Anchor|zero-greater}} || flag = n > 0 ? true : false
|-
| <syntaxhighlight lang=forth inline>1+</syntaxhighlight> || ( n1 -- n2) || core || primitive || {{Anchor|one-plus}} || n2 = n1 + 1 
|-
| <syntaxhighlight lang=forth inline>1-</syntaxhighlight> || ( n1 -- n2 ) || core || primitive || {{Anchor|one-minus}} || n2 = n1 - 1  
|-
| <syntaxhighlight lang=forth inline>2!</syntaxhighlight> || ( x1 x2 a-addr -- ) || core || primitive || {{Anchor|two-store}} || *a-addr = x1, *(a-addr + 1) = x2 ⇒ [[#two-fetch|2@]] 
|-
| <syntaxhighlight lang=forth inline>2*</syntaxhighlight> || ( n1 -- n2 ) || core || primitive || {{Anchor|two-star}} || n2 = n1 * 2 
|-
| <syntaxhighlight lang=forth inline>2+</syntaxhighlight> || ( n1 -- n2 ) || ficl || primitive || {{Anchor|two-plus}} || n2 = n1 + 2
|-
| <syntaxhighlight lang=forth inline>2-</syntaxhighlight> || ( n1 -- n2 ) || ficl || primitive || {{Anchor|two-minus}} || n2 = n1 - 2
|-
| <syntaxhighlight lang=forth inline>2/</syntaxhighlight> || ( n1 -- n2 ) || core || primitive || {{Anchor|two-slash}} || n2 = n1 / 2
|-
| <syntaxhighlight lang=forth inline>2>r</syntaxhighlight> || ( x1 x2 -- ) ( R: -- x1 x2 ) || core || primitive compile-only || {{Anchor|two-to-r}} || データスタックからリターンスタックにセルペアを移動 ⇒ [[#to-r|>r]]
|-
| <syntaxhighlight lang=forth inline>2@</syntaxhighlight> || ( a-addr -- x1 x2 ) || core || primitive || {{Anchor|two-fetch}} || x1 = *a-addr, x2 = *(a-addr + 1) ⇒ [[#two-store|2!]] 
|-
| <syntaxhighlight lang=forth inline>2constant</syntaxhighlight> || ( x1 x2 "<spaces>name" -- ) || core || primitive || {{Anchor|two-constant}} || セルペア定数の定義 ⇒ [[#constant|constant]]
|-
| <syntaxhighlight lang=forth inline>2drop</syntaxhighlight> || ( x1 x2 -- ) || core || primitive || {{Anchor|two-drop}} || セルペアをデータスタックから削除 ⇒ [[#drop|drop]]
|-
| <syntaxhighlight lang=forth inline>2dup</syntaxhighlight> || ( x1 x2 -- x1 x2 x1 x2 ) || core || primitive || {{Anchor|two-dupe}} || セルペアを複製 ⇒ [[#dupe|dup]]
|-
| <syntaxhighlight lang=forth inline>2literal</syntaxhighlight> || ( x1 x2 -- ) || core || primitive immediate || {{Anchor|two-literal}} || セルペアリテラル ⇒ [[#literal|literal]]
|-
| <syntaxhighlight lang=forth inline>2local</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>bl word count (2local)</syntaxhighlight> || {{Anchor|two-local}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>2over</syntaxhighlight> || ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 ) || core || primitive || {{Anchor|two-over}} || セルペア x1 x2 をスタックトップに複製 ⇒ [[#over|over]]
|-
| <syntaxhighlight lang=forth inline>2r@</syntaxhighlight> || ( -- x1 x2 ) ( R: x1 x2 -- x1 x2 ) || core ext || primitive compile-only || {{Anchor|two-r-fetch}} || セルペア x1 x2 をリターンスタックからデータスタックに複製 ⇒ [[#r-fetch|r@]] 
|-
| <syntaxhighlight lang=forth inline>2swap</syntaxhighlight> || ( x1 x2 x3 x4 -- x3 x4 x1 x2 ) || core || primitive || {{Anchor|two-swap}} || スタックトップの２つのセルペアを入れ替え ⇒ [[#swap|swap]]
|-
| <syntaxhighlight lang=forth inline>2value</syntaxhighlight> || ( x1 x2 "<spaces>name" -- ) || double ext || primitive immediate || {{Anchor|two-value}} || セルペアに名前をつけます ⇒ [[#value|value]] [[#to|to]]
|-
| <syntaxhighlight lang=forth inline>2variable</syntaxhighlight> || ( "<spaces>name" -- ) || double || primitive immediate || {{Anchor|two-variable}} || セルペア変数を宣言 ⇒ [[#variable|variable]] [[#two-store|2!]] [[#two-fetch|2@]]
|-
| <syntaxhighlight lang=forth inline>:</syntaxhighlight> || ( C: "<spaces>name" -- colon-sys ) || core || primitive || {{Anchor|colon}} || ワード定義開始 ⇒ [[#semicolon|;]]
|-
| <syntaxhighlight lang=forth inline>:noname</syntaxhighlight> || ( C: -- colon-sys ) ( S: -- xt ) || core ext || primitive || {{Anchor|colon-no-name}} || [[#colon|:]] までのワード列をコンパイルしスタックに残す
|-
| <syntaxhighlight lang=forth inline>;</syntaxhighlight> || ( C: colon-sys -- ) || core || primitive immediate compile-only || {{Anchor|semicolon}} || [[#colon|:]] あるいは [[#colon-no-name|:noname]] を終了
|-
| <syntaxhighlight lang=forth inline><</syntaxhighlight> || ( n1 n2 -- flag ) || core || primitive || {{Anchor|less-than}} || flag = n1 < n2 ? true : false
|-
| <syntaxhighlight lang=forth inline><#</syntaxhighlight> || ( -- ) || core || kind || {{Anchor|less-number-sign}} || 数値文字列化開始 ⇒ [[#number-sign-greater|#>]]
|-
| <syntaxhighlight lang=forth inline><></syntaxhighlight> || ( n1 n2 -- flag )( -- ) || core ext || <syntaxhighlight lang=forth inline>= 0=</syntaxhighlight> || {{Anchor|not-equals}} || flag = n1 != n2 ? true : false
<!-- 内部表現用？
|-
| <syntaxhighlight lang=forth inline><prefixes></syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|mnum}} || desc. 
 -->
|-
| <syntaxhighlight lang=forth inline>=</syntaxhighlight> || ( n1 n2 -- flag ) || core || kind || {{Anchor|equals}} || flag = n1 != n2 ? true : false
|-
| <syntaxhighlight lang=forth inline>></syntaxhighlight> || ( n1 n2 -- flag ) || core || primitive || {{Anchor|greater-than}} ||  flag = n1 > n2 ? true : false
|-
| <syntaxhighlight lang=forth inline>>body</syntaxhighlight> || ( xt -- a-addr ) || core || primitive || {{Anchor|to-body}} || a-addr は、[[#create|create]] が定義したxtの直後に[[#here|here]]して得られるアドレス
|-
| <syntaxhighlight lang=forth inline>>float</syntaxhighlight> || ( c-addr u -- true | false ) ( F: -- r | ~ ) || floating || primitive || {{Anchor|to-float}} || c-addr u で指定された文字列を、内部の浮動小数点数表現に変換
|-
| <syntaxhighlight lang=forth inline>>in</syntaxhighlight> || ( -- a-addr ) || core || primitive || {{Anchor|to-in}} || a-addr は、入力バッファの先頭からパース領域の先頭までのオフセット(文字数)を含むセルのアドレス
|-
| <syntaxhighlight lang=forth inline>>name</syntaxhighlight> || ( a-addr -- w-addr u) || ficl || primitive || {{Anchor|to-name}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>>number</syntaxhighlight> || ( ud1 c-addr1 u1 -- ud2 c-addr2 u2 )
 || core || primitive || {{Anchor|to-number}} || 文字列数値変換の１桁分
|-
| <syntaxhighlight lang=forth inline>>r</syntaxhighlight> || ( x -- ) ( R: -- x ) || core || primitive compile-only || {{Anchor|to-r}} || データスタックからリターンスタックにxを移動 ⇒ [[#two-to-r|2>r]] [[#from-r|r>]]
|-
| <syntaxhighlight lang=forth inline>>search</syntaxhighlight> || ( wid -- ) || ficl || primitive || {{Anchor|to-search}} || ficl独自: wid をsearch orderにプッシュします。
|-
| <syntaxhighlight lang=forth inline>?</syntaxhighlight> || ( a-addr -- ) || tools || <syntaxhighlight lang=forth inline>@ .</syntaxhighlight> || {{Anchor|question}} || *a-addr を表示
|-
| <syntaxhighlight lang=forth inline>?do</syntaxhighlight> || ( C: -- [[#do-sys|do-sys]] ) || core ext || primitive immediate compile-only || {{Anchor|question-do}} || : ... ?do ... loop ;
|-
| <syntaxhighlight lang=forth inline>?dup</syntaxhighlight> || ( x -- 0 <nowiki>|</nowiki> x x ) || core || primitive || {{Anchor|question-dupe}} || スタックトップが0でなければ複製 ⇒ [[#dupe|dup]] 
|-
| <syntaxhighlight lang=forth inline>?float</syntaxhighlight> || ( c-addr u -- x*i flag ) || ficl || primitive || {{Anchor|question-float}} || トークンを浮動小数点数に変換しようとする。 
|-
| <syntaxhighlight lang=forth inline>?number</syntaxhighlight> || ( c-addr u -- x*i flag ) || ficl || primitive || {{Anchor|question-number}} || トークンを数値に変換しようとする。
|-
| <syntaxhighlight lang=forth inline>?object</syntaxhighlight> || ( x-addr -- flag ) || ficl || primitive || {{Anchor|question-object}} || x-addr がオブジェクトを参照していたら flag は true
|-
| <syntaxhighlight lang=forth inline>?prefix</syntaxhighlight> || ( c-addr u -- x*i flag ) || ficl || primitive || {{Anchor|question-prefix}} || プレフィックスが有効な場合に、トークンの先頭部分を既知のプレフィックスのリスト <prefixes> から検索し、関連付けられた処理を行う。
|-
| <syntaxhighlight lang=forth inline>?word</syntaxhighlight> || ( c-addr u -- x*i flag ) || ficl || primitive || {{Anchor|question-word}} || ローカル変数辞書やシステム辞書でトークンを検索し、見つかればそれに対応する処理を行う。
|-
| <syntaxhighlight lang=forth inline>@</syntaxhighlight> || ( a-addr -- x ) || core || primitive || {{Anchor|fetch}} || x = *a-addr
|-
| <syntaxhighlight lang=forth inline>[</syntaxhighlight> || ( -- ) || core || primitive immediate compile-only || {{Anchor|left-bracket}} || 解釈モードに遷移 ⇒ [[#right-bracket|]]] [[#literal|literal]]
|-
| <syntaxhighlight lang=forth inline>[']</syntaxhighlight> || ( "<spaces>name" -- ) || core || primitive immediate compile-only || {{Anchor|bracket-tick}} || name の xt をスタックに残す
|-
| <syntaxhighlight lang=forth inline>[char]</syntaxhighlight> || ( "<spaces>name" -- ) || core || primitive immediate compile-only || {{Anchor|mnum}} || name の最初の一文字をスタックに残す
|-
| <syntaxhighlight lang=forth inline>[else]</syntaxhighlight> || ( "<spaces>name ..." -- ) || tools ext || softcore || {{Anchor|bracket-else}} || 解釈モードで実行可能な [[#else|else]]
|-
| <syntaxhighlight lang=forth inline>[endif]</syntaxhighlight> || ( -- ) || ficl || immediate || {{Anchor|bracket-endif}} || 解釈モードで実行可能な [[#endif|endif]] 
|-
| <syntaxhighlight lang=forth inline>[if]</syntaxhighlight> || ( flag <nowiki>|</nowiki> flag "<spaces>name ..." -- ) || tools ext || immediate || {{Anchor|bracket-if}} || 解釈モードで実行可能な [[#if|if]] 
|-
| <syntaxhighlight lang=forth inline>[then]</syntaxhighlight> || ( -- ) || tools ext || immediate || {{Anchor|bracket-then}} || 解釈モードで実行可能な [[#then|then]] 
|-
| <syntaxhighlight lang=forth inline>\</syntaxhighlight> || ( "ccc<eol>" -- ) || core || primitive immediate || {{Anchor|backslash}} || コメント（行末まで） 
|-
| <syntaxhighlight lang=forth inline>]</syntaxhighlight> || ( -- ) || core || primitive || {{Anchor|right-bracket}} || ⇒ [[#left-bracket|[]] [[#literal|literal]]
|-
| <syntaxhighlight lang=forth inline>__tempbase</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|__tempbase}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>abort</syntaxhighlight> ||  ( i * x -- ) ( R: j * x -- ) || exception ext || primitive || {{Anchor|abort}} || <syntaxhighlight lang=forth inline>empty quit</syntaxhighlight>
|-
| <syntaxhighlight lang=forth inline>abort"</syntaxhighlight> || ( "ccc<quote>" -- ) || exception ext || immediate || {{Anchor|abort-quote}} || ( i * x x1 -- <nowiki>|</nowiki> i * x ) ( R: j * x -- <nowiki>|</nowiki> j * x )  x1 が真の場合、-2 [[#throw|throw]] の機能を実行します。例外スタックに例外フレームがない場合、ccc を表示します。
|-
| <syntaxhighlight lang=forth inline>abs</syntaxhighlight> || ( n -- u ) || core || primitive || {{Anchor|abs}} || u = | n | 
|-
| <syntaxhighlight lang=forth inline>accept</syntaxhighlight> || ( c-addr n1 -- n2 ) || core || primitive || {{Anchor|accept}} || 最大で n1 文字の文字列を受け取る。 n2 は実際に受け取った文字数

|-
| <syntaxhighlight lang=forth inline>add-parse-step</syntaxhighlight> || （ xt -- ） || ficl || primitive || {{Anchor|add-parse-step}} || パースチェーンにパースステップを追加する。xtはパースステップとして使用するFiclワードのアドレス（実行トークン）。
|-
| <syntaxhighlight lang=forth inline>again</syntaxhighlight> || ( C: dest -- ) || core ext || primitive immediate compile-only || {{Anchor|again}} || ex.  : x ... [[#begin|begin]] ... again ... ; [[#exit|exit]] などで脱出しない限り永久ループ 
|-
| <syntaxhighlight lang=forth inline>align</syntaxhighlight> || ( -- ) || core || primitive || {{Anchor|align}} || データスペースポインタをアライメント 
|-
| <syntaxhighlight lang=forth inline>aligned</syntaxhighlight> || ( addr -- a-addr ) || core || primitive || {{Anchor|aligned}} || a-addr に、addr 以上の最初の整列されたアドレスを返す
|-
| <syntaxhighlight lang=forth inline>allocate</syntaxhighlight> || ( u -- a-addr ior ) || memory || primitive || {{Anchor|allocate}} || u アドレス単位の領域確保。ior が 0 なら a-addr に先頭アドレスを、それ以外は実装定義の I/O 結果コードでa-addrは無効
|-
| <syntaxhighlight lang=forth inline>allot</syntaxhighlight> || ( n -- ) || core || primitive || {{Anchor|allot}} || データスペースポインタ を n 勧めます。n が負なら開放します。
|-
| <syntaxhighlight lang=forth inline>also</syntaxhighlight> || ( -- ) || search ext || <syntaxhighlight lang=forth inline>search> dup >search >search</syntaxhighlight> || {{Anchor|also}} || サーチオーダーの先頭を複製 
|-
| <syntaxhighlight lang=forth inline>and</syntaxhighlight> || ( x1 x2 -- x3 ) || core || primitive || {{Anchor|and}} || x3 = x1 & x2
|-
| <syntaxhighlight lang=forth inline>base</syntaxhighlight> || ( -- a-addr ) || core || primitive || {{Anchor|base}} || a-addr は、現在の数値変換基数(2...36) を格納するセルのアドレス
|-
| <syntaxhighlight lang=forth inline>begin</syntaxhighlight> || ( C: -- dest ) || core || primitive immediate compile-only || {{Anchor|begin}} || ex.  : x ... begin ... [[#again|again]] ... ; [[#exit|exit]] などで脱出しない限り永久ループ 
|-
| <syntaxhighlight lang=forth inline>bin</syntaxhighlight> || ( fam1 -- fam2 ) || file || <syntaxhighlight lang=forth inline>8 or</syntaxhighlight> || {{Anchor|bin}} || ファイルアクセス方法 fam1 を変更し、追加で "binary"、つまり行指向でないファイルアクセス方法を選択し、アクセス方法 fam2 を提供します。
|-
| <syntaxhighlight lang=forth inline>bl</syntaxhighlight> || ( -- char ) || core || primitive || {{Anchor|bl}} || スペースのキャラクターコードをスタックに積む 
|-
| <syntaxhighlight lang=forth inline>body></syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|body-from}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>brand-wordlist</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>last-word >name drop wid-set-name</syntaxhighlight> || {{Anchor|brand-wordlist}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>break</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|break}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>bye</syntaxhighlight> || ( -- ) || tools ext || primitive || {{Anchor|bye}} || ホストオペレーションシステムに復帰 
|-
| <syntaxhighlight lang=forth inline>c!</syntaxhighlight> || ( char c-addr -- ) || core || primitive || {{Anchor|c-store}} || c-addr に char を格納
|-
| <syntaxhighlight lang=forth inline>c"</syntaxhighlight> || ( "ccc<quote>" -- ) || core || primitive immediate || {{Anchor|c-quote}} || 文字列 ccc で構成されるカウント付き文字列 c-addr を返す
|-
| <syntaxhighlight lang=forth inline>c,</syntaxhighlight> || ( char -- ) || core || primitive || {{Anchor|c-comma}} || データスペースに1文字分のスペースを確保し、char をそのスペースに格納する
|-
| <syntaxhighlight lang=forth inline>c@</syntaxhighlight> || ( c-addr -- char ) || code || primitive || {{Anchor|c-fetch}} || c-addr に格納された文字を取得
|-
| <syntaxhighlight lang=forth inline>case</syntaxhighlight> || ( C: -- [[#case-sys|case-sys]] ) || core ext || primitive immediate compile-only || {{Anchor|case}} || 例 [[#colon|:]] x ... case test1 [[#of|of]] ... [[#endof|endof]] testn [[#of|of]] ... [[#endof|endof]] ... ( default ) [[#endcase|endcase]]  ... [[#semicolon|;]] 
|-
| <syntaxhighlight lang=forth inline>catch</syntaxhighlight> || ( i * x xt -- j * x 0 <nowiki>|</nowiki> i * x n ) || exception || primitive || {{Anchor|catch}} || 例外スタックに例外フレームをプッシュし、次に xt の実行トークン（[[#execute|execute]] と同様に）を実行します。xt の実行中に [[#throw|throw]] が実行された場合、catch の直後の地点に制御が転送されるようにします。
----
xt の実行が正常に完了した場合（つまり、この catch によってプッシュされた例外フレームが throw の実行によってポップされなかった場合）、例外フレームをポップし、データスタックの先頭にゼロを返します。xt execute によって返されるスタックアイテムの上に、0 が返されます。それ以外の場合は、実行意味論の残りの部分は throw によって与えられます。
|-
| <syntaxhighlight lang=forth inline>cd</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|cd}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>cell+</syntaxhighlight> || ( a-addr1 -- a-addr2 ) || core || primitive || {{Anchor|cell-plus}} || アドレス単位でセルのサイズを a-addr1 に追加し、a-addr2 を得る
|-
| <syntaxhighlight lang=forth inline>cells</syntaxhighlight> || ( n1 -- n2 ) || core || primitive || {{Anchor|cells}} || n2 に、n1 個のセルのサイズをアドレス単位で表したものを残す
|-
| <syntaxhighlight lang=forth inline>char</syntaxhighlight> || ( "<spaces>name" -- char ) || core || primitive || {{Anchor|char}} || 先頭の空白デリミタをスキップし、スペースで区切られた名前を解析し、その最初の文字の値をスタックに格納する。
|-
| <syntaxhighlight lang=forth inline>char+</syntaxhighlight> || ( c-addr1 -- c-addr2 ) || core || primitive || {{Anchor|char-plus}} || c-addr1 に文字のアドレス単位でのサイズを追加し、c-addr2 を得る。
|-
| <syntaxhighlight lang=forth inline>chars</syntaxhighlight> || ( n1 -- n2 ) || core || primitive || {{Anchor|chars}} || n2 に、n1 文字のアドレス単位でのサイズを返す。
|-
| <syntaxhighlight lang=forth inline>clock</syntaxhighlight> || ( -- clk ) || ficl || primitive || {{Anchor|clock}} || clk = clock(3). 
|-
| <syntaxhighlight lang=forth inline>clocks/sec</syntaxhighlight> || ( -- cps ) || ficl || primitive || {{Anchor|clocks-per-sec}} || cps = CLOCKS_PER_SEC.. 
|-
| <syntaxhighlight lang=forth inline>close-file</syntaxhighlight> || ( fileid -- ior ) || file || primitive || {{Anchor|close-file}} || fileid で識別されるファイルを閉じる。ior は実装定義の I/O 結果コード。 ⇒ [[#open-file|open-file]]
|-
| <syntaxhighlight lang=forth inline>compare</syntaxhighlight> || ( c-addr1 u1 c-addr2 u2 -- n ) || string || primitive || {{Anchor|compare}} || c-addr1 u1 の文字列を、c-addr2 u2 の文字列と比較。nは-1,0あるいは1。
|-
| <syntaxhighlight lang=forth inline>compare-insensitive</syntaxhighlight> || ( c-addr1 u1 c-addr2 u2 -- n ) || ficl || primitive || {{Anchor|compare-insensitive}} || [[#compare|compare]] と異なり大文字小文字を区別しません。
|-
| <syntaxhighlight lang=forth inline>compile,</syntaxhighlight> || ( xt -- ) || core ext || <syntaxhighlight lang=forth inline>,</syntaxhighlight> || {{Anchor|compile-comma}} || 現在の定義の実行セマンティクスに、xt で表される定義の実行セメンテックスを追加。
|-
| <syntaxhighlight lang=forth inline>compile-only</syntaxhighlight> || ( -- ) || ficl || compile-only || {{Anchor|compile-only}} || ficl独自: 最も最近に定義されたワードをコンパイル状態の間のみ実行可能としてマークします。
|-
| <syntaxhighlight lang=forth inline>constant</syntaxhighlight> || ( x "<spaces>name" -- ) || ficl || primitive || {{Anchor|const}} || 先頭の空白デリミタをスキップし、空白で区切られた名前を解析します。定数 name の定義を作成する。
----
実行時: ( -- x ) x をスタックにプッシュする。 ⇒ [[#2constant|2constant]] [[#f-constant|fconstant]]
|-
| <syntaxhighlight lang=forth inline>convert</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>char+ literal 65535  >number drop</syntaxhighlight> || {{Anchor|convert}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>count</syntaxhighlight> || ( c-addr1 -- c-addr2 u ) || core || primitive || {{Anchor|count}} || c-addr1 に格納されたカウント付き文字列の文字列仕様を返す。c-addr2 は c-addr1 の次の文字のアドレス。u は c-addr1 の文字の内容、c-addr2 の文字列の長さを文字数で表す。
|-
| <syntaxhighlight lang=forth inline>cr</syntaxhighlight> || ( -- ) || core || primitive || {{Anchor|c-r}} || 次の出力が次の行の先頭に表示されるようにする。
|-
| <syntaxhighlight lang=forth inline>create</syntaxhighlight> || ( "<spaces>name" -- ) || core || primitive || {{Anchor|create}} || 先頭の空白デリミタをスキップし空白で区切られた名前を解析します。name の実行セマンティクスを以下で定義されるように持つ定義を作成する。データスペースポインタがアラインされていない場合、それをアラインするのに十分なデータ領域を予約する。新しいデータスペースポインタが name のデータフィールドを定義する。CREATE は name のデータフィールドにデータ領域を割り当てない。
----
実行時: ( -- a-addr ) a-addr は name のデータフィールドのアドレス。name の実行セマンティクスは [[#does|does>]] を使用して拡張することができる。
|-
| <syntaxhighlight lang=forth inline>create-file</syntaxhighlight> || ( c-addr u fam -- fileid ior ) || file || primitive || {{Anchor|create-file}} || 文字列 c-addr と u で指定された名前のファイルを作成し、ファイルアクセス方法 fam で開く。fam の値の意味は実装依存。同じ名前のファイルが既に存在する場合、空のファイルとして再作成する。
ファイルが正常に作成および開かれた場合、ior はゼロ、fileid はその識別子であり、ファイルはファイルの先頭に位置づけられている。
それ以外の場合、ior は実装定義の I/O 結果コードであり、fileid は未定義。
|-
| <syntaxhighlight lang=forth inline>debug</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth>
: debug
  ' debug-xt
;
immediate
</syntaxhighlight> || {{Anchor|debug}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>debug-xt</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|debug-xt}} || ficl独自: 
|-
| <syntaxhighlight lang=forth inline>decimal</syntaxhighlight> || ( -- ) || core || primitive || {{Anchor|decimal}} || 数値変換基数を十進数に設定する
|-
| <syntaxhighlight lang=forth inline>definitions</syntaxhighlight> || ( -- ) || search || primitive || {{Anchor|definitions}} || コンパイルされたワードリストを検索順序の最初のワードリストと同じにする。後続の定義の名前がコンパイルされたワードリストに配置されることを指定する。検索順序の後続の変更は、コンパイルされたワードリストに影響を与えない。
|-
| <syntaxhighlight lang=forth inline>delete-file</syntaxhighlight> || ( c-addr u -- ior ) || file || primitive || {{Anchor|delete-file}} || 文字列 c-addr u で指定されたファイルを削除する。ior は、実装定義の I/O 結果コード。
|-
| <syntaxhighlight lang=forth inline>depth</syntaxhighlight> || ( -- +n ) || core || primitive || {{Anchor|depth}} || +n は、+n がスタックに置かれる前にデータスタックに含まれる単一セル値の数。
|-
| <syntaxhighlight lang=forth inline>dnegate</syntaxhighlight> || ( d1 -- d2 ) || double || primitive || {{Anchor|d-negate}} || d2 は d1 の符号反転。 
|-
| <syntaxhighlight lang=forth inline>do</syntaxhighlight> || ( C: -- [[#do-sys|do-sys]] ) || core || primitive || {{Anchor|do}} || do-sys を制御フロー・スタックに配置します。以下に示すランタイムの意味論を現在の定義に追加します。[[#loop|loop]] のような do-sys の消費者によって解決されるまで、セマンティクスは不完全です。
----
実行時: 
( n1 <nowiki>|</nowiki> u1 n2 <nowiki>|</nowiki> u2 -- ) ( R: -- [[#loop-sys|loop-sys]] ) インデックス n2 <nowiki>|</nowiki> u2 およびリミット n1 <nowiki>|</nowiki> u1 を持つループ制御パラメータを設定します。n1 <nowiki>|</nowiki> u1 と n2 <nowiki>|</nowiki> u2 が両方とも同じ型でない場合、曖昧な状態が存在します。ループ制御パラメータが破棄されるまで、すでに返り値スタックにあるものは利用できなくなります。
|-
| <syntaxhighlight lang=forth inline>do-vocabulary</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>
: do-vocabulary
   (does)
   @
   search>
   drop
   >search
;</syntaxhighlight> || {{Anchor|do-vocabulary}} || ficl独自:
|-
| <syntaxhighlight lang=forth inline>doLocal</syntaxhighlight> || ( -- ) || ficl || primitive immediate compile-only || {{Anchor|do-local}} || desc. 
|-
| <syntaxhighlight lang=forth inline>does></syntaxhighlight> || ( C: colon-sys1 -- colon-sys2 ) || core || primitive immediate compile-only || {{Anchor|does}} || コンパイル時:
(C: colon-sys1 -- colon-sys2) 現在の定義に以下のランタイムの意味論を追加します。現在の定義が DOES> のコンパイルによって辞書内で見つけられるかどうかは、実装によって定義されます。colon-sys1 を消費し、colon-sys2 を生成します。以下に示す初期化の意味論を現在の定義に追加します。
----
ランタイム: ( -- ) ( R: nest-sys1 -- ) 最新の定義（name と呼ばれる）の実行セマンティクスを、以下に示す name の実行セマンティクスで置き換えます。nest-sys1 で指定された呼び出し定義に制御を戻します。name が CREATE または CREATE を呼び出すユーザー定義のワードで定義されていない場合、曖昧な状態が存在します。
|-
| <syntaxhighlight lang=forth inline>drop</syntaxhighlight> || ( x -- ) || core || primitive || {{Anchor|drop}} || スタックから x を削除 ⇒ [[#two-drop|2drop]] [[#f-drop|fdrop]]
|-
| <syntaxhighlight lang=forth inline>dump</syntaxhighlight> || ( addr u -- ) || tools || <syntaxhighlight lang=forth inline>
: dump  ( addr u -- )
    0 ?do
        dup c@ . 1+
        i 7 and 7 = if cr endif
    loop drop
;
</syntaxhighlight> || {{Anchor|dump}} || addr から始まる u 個の連続するアドレスの内容を表示します。 
|-
| <syntaxhighlight lang=forth inline>dup</syntaxhighlight> || ( x -- x x ) || core || primitive || {{Anchor|dupe}} || x を複製 ⇒ [[#two-dupe|2dup]] [[#f-dupe|fdup]]
|-
| <syntaxhighlight lang=forth inline>else</syntaxhighlight> || (C: orig1 -- orig2) || core || primitive immediate compile-only || {{Anchor|mnum}} || コンパイル時:
(C: orig1 -- orig2) 新しい未解決の逆参照 orig2 の場所を制御フロー・スタックに置きます。以下に示すランタイムの意味論を現在の定義に追加します。orig2 が解決されるまで（たとえば、[[#then|then]] によって）、意味論は不完全です。追加されたランタイムの意味論の後に続く場所を使って、逆参照 orig1 を解決します。
----
実行時: ( -- ) 
orig2 の解決によって指定された場所で実行を継続します。 
|-
| <syntaxhighlight lang=forth inline>emit</syntaxhighlight> || ( x -- ) || core || primitive || {{Anchor|emit}} || emit
|-
| <syntaxhighlight lang=forth inline>empty</syntaxhighlight> || ( xn..x1 -- ) || ficl || <syntaxhighlight lang=forth inline>
: empty ( xn..x1 -- ) depth 0 ?do drop loop ;
</syntaxhighlight> || {{Anchor|empty}} || スタックをクリア
|-
| <syntaxhighlight lang=forth inline>end-locals</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>: end-locals  ( -- )  0 0 (local) ;  immediate</syntaxhighlight> || {{Anchor|end-locals}} || ローカル変数の使用を終了
|-
| <syntaxhighlight lang=forth inline>end-prefixes</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>
: end-prefixes
  save-current
  @
  set-current
;</syntaxhighlight> || {{Anchor|end-prefixes}} || プレフィックス定義の終了を宣言し、[[#start-prefixes|start-prefixes]] が呼び出される前に使用されていたワードリストに戻るようにFicl仮想マシンに指示する。
|-
| <syntaxhighlight lang=forth inline>endcase</syntaxhighlight> || (C: [[#case-sys|case-sys]] -- ) || core ext || primitive immediate compile-only || {{Anchor|endcase}} || コンパイル時:
(C: case-sys -- ) [[#case|case]]...[[#of|of]]...[[#endof|endof]]...endcase 構造の終わりをマークします。全体の構造を解決するために case-sys を使用します。以下に示すランタイムの意味論を現在の定義に追加します。
----
ランタイム: (x -- ) case セレクタ x を破棄し、実行を継続します。
|-
| <syntaxhighlight lang=forth inline>endif</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|endif}} || [[#then|then]] のシノニム
|-
| <syntaxhighlight lang=forth inline>endof</syntaxhighlight> || ( C: case-sys1 of-sys -- case-sys2 )
|| core ext || primitive immediate compile-only || {{Anchor|endof}} || コンパイル時:
(C: case-sys1 of-sys -- case-sys2) case 構造の of...endof 部分の終わりをマークします。次の制御の転送のための次の場所は、of-sys によって指定された参照を解決します。以下に示すランタイムの意味論を現在の定義に追加します。case-sys1 を case-sys2 で置き換え、endcase で解決するために制御フロー・スタックに置きます。
----
実行時: ( -- ) case-sys2 のコンシューマによって指定された場所で実行を継続します。
|-
| <syntaxhighlight lang=forth inline>env-2constant</syntaxhighlight> || ( x1 x2 "<spaces>name" -- ) || ficl || primitive || {{Anchor|env-two-constant}} || ficl独自: 先頭の空白デリミタをスキップし、空白で区切られた名前を解析します。環境 name の定義を作成する。
----
実行時: ( -- x1 x2 ) environment? によって x1 x2 をスタックにプッシュする。
|-
| <syntaxhighlight lang=forth inline>env-constant</syntaxhighlight> || ( x "<spaces>name" -- ) || ficl || primitive || {{Anchor|env-constant}} || ficl独自: 先頭の空白デリミタをスキップし、空白で区切られた名前を解析します。環境 name の定義を作成する。
----
実行時: ( -- x ) environment? によって x をスタックにプッシュする。
|-
| <syntaxhighlight lang=forth inline>environment?</syntaxhighlight> || ( c-addr u -- false <nowiki>|</nowiki> i * x true ) || core || primitive || {{Anchor|environment-quote}} || c-addr u で表す文字列に対応する環境を探し、なければ false が、あれば値と true がスタックに積まれる。
|-
| <syntaxhighlight lang=forth inline>erase</syntaxhighlight> || ( addr u -- ) || core || <syntaxhighlight lang=forth inline>: erase   ( addr u -- )    0 fill ;</syntaxhighlight> || {{Anchor|erase}} || uがゼロより大きい場合、addrから始まるメモリの連続するu個のアドレスユニットの各ビットをクリアします。
|-
| <syntaxhighlight lang=forth inline>evaluate</syntaxhighlight> || ( i * x c-addr u -- j * x ) || core || kind || {{Anchor|evaluate}} || c-addrとuによって記述される文字列を、入力ソースおよび入力バッファとして設定し、>INをゼロに設定して解釈します。他のスタック効果は、実行されたワードによるものです。
|-
| <syntaxhighlight lang=forth inline>execute</syntaxhighlight> || ( i * x xt -- j * x ) || core || primitive || {{Anchor|execute}} || スタックからxtを取り除き、それが識別する意味を実行します。他のスタック効果は、実行されたワードによるものです。
|-
| <syntaxhighlight lang=forth inline>exit</syntaxhighlight> || ( -- ) ( R: nest-sys -- ) || core || primitive immediate compile-only || {{Anchor|exit}} || nest-sysで指定された呼び出し定義に制御を返します。
|-
| <syntaxhighlight lang=forth inline>exit-inner</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|exit-inner}} || ficl独自: execXTに、内側のループが完了したことを通知します。
|-
| <syntaxhighlight lang=forth inline>expect</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|expect}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f!</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f-store}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f*</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f*}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f*i</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f*i}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f+</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f+}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f+!</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f+!}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f+i</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f+i}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f-</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f-}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f-i</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f-i}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f-roll</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f-roll}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f-rot</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f-rot}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f.</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f.}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f.s</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f.s}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f/</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f/}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f/i</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f/i}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f0<</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|mnum}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f0=</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f0=}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f0></syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f0>}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2!</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2!}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2@</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2@}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2constant</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2constant}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2drop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2drop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2dup</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2dup}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2over</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2over}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2swap</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2swap}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f2value</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f2value}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f<</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|mnum}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f=</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f=}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f></syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f>}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f?dup</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f?dup}} || desc. 
|-
| <syntaxhighlight lang=forth inline>f@</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|f@}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fallthrough</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fallthrough}} || desc. 
|-
| <syntaxhighlight lang=forth inline>false</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|false}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fconstant</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fconstant}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fdepth</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fdepth}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fdrop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fdrop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fdup</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fdup}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fe.</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fe.}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficl-named-wordlist</syntaxhighlight> || ( hash-size name -- ) || ficl || <syntaxhighlight lang=forth inline>
: ficl-named-wordlist  \ ( hash-size name -- ) run: ( -- wid )
    ficl-wordlist dup create , brand-wordlist does> @ ;</syntaxhighlight> || {{Anchor|ficl-named-wordlist}} || ficl独自: ワードリストの名前を取り、その名前を wid としてプッシュするワードを作成します。
|-
| <syntaxhighlight lang=forth inline>ficl-set-current</syntaxhighlight> || ( wid -- old-wid ) || ficl || <syntaxhighlight lang=forth inline>
: ficl-set-current   ( wid -- old-wid )  
    get-current swap set-current ; 
</syntaxhighlight> || {{Anchor|ficl-set-current}} || ficl独自: wid をコンパイルワードリストとして設定し、以前のコンパイルワードリストをスタックに残します。
|-
| <syntaxhighlight lang=forth inline>ficl-vocabulary</syntaxhighlight> || ( nBins "name" -- ) || ficl || <syntaxhighlight lang=forth inline>
: ficl-vocabulary   ( nBuckets name -- )  
    ficl-named-wordlist do-vocabulary ; 
</syntaxhighlight> || {{Anchor|ficl-vocabulary}} || ficl独自: 指定されたハッシュテーブルのビン数で ficl-wordlist を作成し、名前にバインドし、その名前に語彙のセマンティクスを関連付けます。
|-
| <syntaxhighlight lang=forth inline>ficl-wordlist</syntaxhighlight> || ( nBins -- wid ) || ficl || primitive || {{Anchor|ficl-wordlist}} || ficl独自: 指定されたハッシュテーブルのビン数でワードリストを作成し、そのワードリストのアドレスをスタックに残します。
|-
| <syntaxhighlight lang=forth inline>ficlInstruction0</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction0}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction1</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction1}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction10</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction10}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction11</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction11}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction12</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction12}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction13</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction13}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction14</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction14}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction15</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction15}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction16</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction16}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction2</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction2}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction3</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction3}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction4</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction4}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction5</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction5}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction6</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction6}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction7</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction7}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction8</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction8}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstruction9</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstruction9}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionExitInnerLoop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionExitInnerLoop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionF0</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionF0}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionF1</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionF1}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionFNeg1</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionFNeg1}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionInvalid</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionInvalid}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg1</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg1}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg10</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg10}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg11</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg11}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg12</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg12}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg13</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg13}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg14</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg14}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg15</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg15}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg16</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg16}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg2</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg2}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg3</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg3}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg4</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg4}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg5</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg5}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg6</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg6}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg7</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg7}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg8</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg8}} || desc. 
|-
| <syntaxhighlight lang=forth inline>ficlInstructionNeg9</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|ficlInstructionNeg9}} || desc. 
|-
| <syntaxhighlight lang=forth inline>file-position</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|file-position}} || desc. 
|-
| <syntaxhighlight lang=forth inline>file-size</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|file-size}} || desc. 
|-
| <syntaxhighlight lang=forth inline>file-status</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|file-status}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fill</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fill}} || desc. 
|-
| <syntaxhighlight lang=forth inline>find</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|find}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fliteral</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fliteral}} || desc. 
|-
| <syntaxhighlight lang=forth inline>float></syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|float>}} || desc. 
|-
| <syntaxhighlight lang=forth inline>float>int</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|float>int}} || desc. 
|-
| <syntaxhighlight lang=forth inline>flush-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|flush-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fm/mod</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fm/mod}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fnegate</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fnegate}} || desc. 
|-
| <syntaxhighlight lang=forth inline>forget</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|forget}} || desc. 
|-
| <syntaxhighlight lang=forth inline>forget-wid</syntaxhighlight> || ( wid -- ) || ficl || primitive || {{Anchor|forget-wid}} || ficl独自: 指定されたワードリストを反復処理し、その xt アドレスが HERE、つまり辞書のフィルポインタの値以上のすべての定義をアンリンクします。
|-
| <syntaxhighlight lang=forth inline>forth</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|forth}} || desc. 
|-
| <syntaxhighlight lang=forth inline>forth-wordlist</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|forth-wordlist}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fover</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fover}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fpick</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fpick}} || desc. 
|-
| <syntaxhighlight lang=forth inline>free</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|free}} || desc. 
|-
| <syntaxhighlight lang=forth inline>froll</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|froll}} || desc. 
|-
| <syntaxhighlight lang=forth inline>frot</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|frot}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fsqrt</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fsqrt}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fswap</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fswap}} || desc. 
|-
| <syntaxhighlight lang=forth inline>fvalue</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|fvalue}} || desc. 
|-
| <syntaxhighlight lang=forth inline>get-current</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|get-current}} || desc. 
|-
| <syntaxhighlight lang=forth inline>get-order</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|get-order}} || desc. 
|-
| <syntaxhighlight lang=forth inline>hash</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|hash}} || desc. 
|-
| <syntaxhighlight lang=forth inline>here</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|here}} || desc. 
|-
| <syntaxhighlight lang=forth inline>hex</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|hex}} || desc. 
|-
| <syntaxhighlight lang=forth inline>hidden</syntaxhighlight> || ( -- wid ) || ficl || primitive || {{Anchor|hidden}} || ficl独自: ficl が提供するワードの実装要因を格納するためのワードリストです。
|-
| <syntaxhighlight lang=forth inline>hide</syntaxhighlight> || ( -- current-wid-was ) || ficl || <syntaxhighlight lang=forth inline>
: hide     hidden dup >search ficl-set-current ;
</syntaxhighlight> || {{Anchor|hide}} || ficl独自: 隠されたワードリストを検索順序にプッシュし、それを現在のコンパイルワードリストとして設定します（ficl-set-current を使用）。
|-
| <syntaxhighlight lang=forth inline>hold</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|hold}} || desc. 
|-
| <syntaxhighlight lang=forth inline>i</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|i}} || desc. 
|-
| <syntaxhighlight lang=forth inline>i-f</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|i-f}} || desc. 
|-
| <syntaxhighlight lang=forth inline>i/f</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|i/f}} || desc. 
|-
| <syntaxhighlight lang=forth inline>if</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|if}} || desc. 
|-
| <syntaxhighlight lang=forth inline>immediate</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|immediate}} || desc. 
|-
| <syntaxhighlight lang=forth inline>include</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|include}} || desc. 
|-
| <syntaxhighlight lang=forth inline>include-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|include-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>included</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|included}} || desc. 
|-
| <syntaxhighlight lang=forth inline>int>float</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|int>float}} || desc. 
|-
| <syntaxhighlight lang=forth inline>interpret</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|interpret}} || desc. 
|-
| <syntaxhighlight lang=forth inline>invert</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|invert}} || desc. 
|-
| <syntaxhighlight lang=forth inline>j</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|j}} || desc. 
|-
| <syntaxhighlight lang=forth inline>k</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|k}} || desc. 
|-
| <syntaxhighlight lang=forth inline>last-word</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|last-word}} || desc. 
|-
| <syntaxhighlight lang=forth inline>leave</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|leave}} || desc. 
|-
| <syntaxhighlight lang=forth inline>literal</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|literal}} || desc. 
|-
| <syntaxhighlight lang=forth inline>load</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|load}} || desc. 
|-
| <syntaxhighlight lang=forth inline>local</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|local}} || desc. 
|-
| <syntaxhighlight lang=forth inline>locals|</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|locals|}} || desc. 
|-
| <syntaxhighlight lang=forth inline>lookup</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|lookup}} || desc. 
|-
| <syntaxhighlight lang=forth inline>loop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|loop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>lshift</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|lshift}} || desc. 
|-
| <syntaxhighlight lang=forth inline>m*</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|m*}} || desc. 
|-
| <syntaxhighlight lang=forth inline>marker</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|marker}} || desc. 
|-
| <syntaxhighlight lang=forth inline>max</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|max}} || desc. 
|-
| <syntaxhighlight lang=forth inline>min</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|min}} || desc. 
|-
| <syntaxhighlight lang=forth inline>mod</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|mod}} || desc. 
|-
| <syntaxhighlight lang=forth inline>move</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|move}} || desc. 
|-
| <syntaxhighlight lang=forth inline>nUser</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|nUser}} || desc. 
|-
| <syntaxhighlight lang=forth inline>negate</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|negate}} || desc. 
|-
| <syntaxhighlight lang=forth inline>nip</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|nip}} || desc. 
|-
| <syntaxhighlight lang=forth inline>objectify</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|objectify}} || desc. 
|-
| <syntaxhighlight lang=forth inline>of</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|of}} || desc. 
|-
| <syntaxhighlight lang=forth inline>on-step</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|on-step}} || desc. 
|-
| <syntaxhighlight lang=forth inline>only</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|only}} || desc. 
|-
| <syntaxhighlight lang=forth inline>oo</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|oo}} || desc. 
|-
| <syntaxhighlight lang=forth inline>oop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|oop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>open-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|open-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>or</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|or}} || desc. 
|-
| <syntaxhighlight lang=forth inline>order</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|order}} || desc. 
|-
| <syntaxhighlight lang=forth inline>over</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|over}} || desc. 
|-
| <syntaxhighlight lang=forth inline>pad</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|pad}} || desc. 
|-
| <syntaxhighlight lang=forth inline>parse</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|parse}} || desc. 
|-
| <syntaxhighlight lang=forth inline>parse-order</syntaxhighlight> || ( -- ) || ficl || primitive || {{Anchor|parse-order}} || パースステップのリストを呼び出される順序で表示
|-
| <syntaxhighlight lang=forth inline>parse-word</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|parse-word}} || desc. 
|-
| <syntaxhighlight lang=forth inline>pick</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|pick}} || desc. 
|-
| <syntaxhighlight lang=forth inline>postpone</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|postpone}} || desc. 
|-
| <syntaxhighlight lang=forth inline>previous</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|previous}} || desc. 
|-
| <syntaxhighlight lang=forth inline>pwd</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|pwd}} || desc. 
|-
| <syntaxhighlight lang=forth inline>q!</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|q!}} || desc. 
|-
| <syntaxhighlight lang=forth inline>q@</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|q@}} || desc. 
|-
| <syntaxhighlight lang=forth inline>quit</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|quit}} || desc. 
|-
| <syntaxhighlight lang=forth inline>r.s</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|r.s}} || desc. 
|-
| <syntaxhighlight lang=forth inline>r/o</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|r/o}} || desc. 
|-
| <syntaxhighlight lang=forth inline>r/w</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|r/w}} || desc. 
|-
| <syntaxhighlight lang=forth inline>r></syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|r>}} || desc. 
|-
| <syntaxhighlight lang=forth inline>r@</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|r@}} || desc. 
|-
| <syntaxhighlight lang=forth inline>random</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|random}} || desc. 
|-
| <syntaxhighlight lang=forth inline>read-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|read-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>read-line</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|read-line}} || desc. 
|-
| <syntaxhighlight lang=forth inline>recurse</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|recurse}} || desc. 
|-
| <syntaxhighlight lang=forth inline>refill</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|refill}} || desc. 
|-
| <syntaxhighlight lang=forth inline>rename-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|rename-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>repeat</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|repeat}} || desc. 
|-
| <syntaxhighlight lang=forth inline>reposition-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|reposition-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>resize</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|resize}} || desc. 
|-
| <syntaxhighlight lang=forth inline>resize-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|resize-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>roll</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|roll}} || desc. 
|-
| <syntaxhighlight lang=forth inline>rot</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|rot}} || desc. 
|-
| <syntaxhighlight lang=forth inline>rshift</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|rshift}} || desc. 
|-
| <syntaxhighlight lang=forth inline>s"</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|s"}} || desc. 
|-
| <syntaxhighlight lang=forth inline>s>d</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|s>d}} || desc. 
|-
| <syntaxhighlight lang=forth inline>save-current</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|save-current}} || desc. 
|-
| <syntaxhighlight lang=forth inline>search-wordlist</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|search-wordlist}} || desc. 
|-
| <syntaxhighlight lang=forth inline>search></syntaxhighlight> || ( -- wid ) || ficl || primitive || {{Anchor|search>}} || ficl独自: search order から wid をポップします。
|-
| <syntaxhighlight lang=forth inline>see</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|see}} || desc. 
|-
| <syntaxhighlight lang=forth inline>see-xt</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|see-xt}} || desc. 
|-
| <syntaxhighlight lang=forth inline>seed-random</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|seed-random}} || desc. 
|-
| <syntaxhighlight lang=forth inline>set-current</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|set-current}} || desc. 
|-
| <syntaxhighlight lang=forth inline>set-order</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|set-order}} || desc. 
|-
| <syntaxhighlight lang=forth inline>sfind</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|sfind}} || desc. 
|-
| <syntaxhighlight lang=forth inline>show-prefixes</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>
: show-prefixes
   <prefixes>
   >search
   words
   search>
   drop
;</syntaxhighlight> || {{Anchor|show-prefixes}} || すべてのプレフィックスのリストを表示。各プレフィックスは、トークンの先頭でその名前が見つかった場合に実行されるFiclワード。
|-
| <syntaxhighlight lang=forth inline>sign</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|sign}} || desc. 
|-
| <syntaxhighlight lang=forth inline>sliteral</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|sliteral}} || desc. 
|-
| <syntaxhighlight lang=forth inline>sm/rem</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|sm/rem}} || desc. 
|-
| <syntaxhighlight lang=forth inline>source</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|source}} || desc. 
|-
| <syntaxhighlight lang=forth inline>source-id</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|source-id}} || desc. 
|-
| <syntaxhighlight lang=forth inline>space</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|space}} || desc. 
|-
| <syntaxhighlight lang=forth inline>spaces</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|spaces}} || desc. 
|-
| <syntaxhighlight lang=forth inline>span</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|span}} || desc. 
|-
| <syntaxhighlight lang=forth inline>spewhash</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|spewhash}} || desc. 
|-
| <syntaxhighlight lang=forth inline>sprintf</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|sprintf}} || desc. 
|-
| <syntaxhighlight lang=forth inline>start-prefixes</syntaxhighlight> || ( -- ) || ficl || <syntaxhighlight lang=forth inline>
: start-prefixes
  get-current
  save-current
  !
  <prefixes>
  set-current
;</syntaxhighlight> || {{Anchor|start-prefixes}} || プレフィックス定義の開始を宣言し、Ficl仮想マシンに<prefixes>ワードリストにコンパイルするように指示する。
|-
| <syntaxhighlight lang=forth inline>state</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|state}} || desc. 
|-
| <syntaxhighlight lang=forth inline>step-break</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|step-break}} || desc. 
|-
| <syntaxhighlight lang=forth inline>strcat</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|strcat}} || desc. 
|-
| <syntaxhighlight lang=forth inline>strcpy</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|strcpy}} || desc. 
|-
| <syntaxhighlight lang=forth inline>strdup</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|strdup}} || desc. 
|-
| <syntaxhighlight lang=forth inline>strlen</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|strlen}} || desc. 
|-
| <syntaxhighlight lang=forth inline>swap</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|swap}} || desc. 
|-
| <syntaxhighlight lang=forth inline>system</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|system}} || desc. 
|-
| <syntaxhighlight lang=forth inline>then</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|then}} || desc. 
|-
| <syntaxhighlight lang=forth inline>throw</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|throw}} || desc. 
|-
| <syntaxhighlight lang=forth inline>to</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|to}} || desc. 
|-
| <syntaxhighlight lang=forth inline>true</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|true}} || desc. 
|-
| <syntaxhighlight lang=forth inline>tuck</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|tuck}} || desc. 
|-
| <syntaxhighlight lang=forth inline>type</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|type}} || desc. 
|-
| <syntaxhighlight lang=forth inline>u.</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|u.}} || desc. 
|-
| <syntaxhighlight lang=forth inline>u<</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|mnum}} || desc. 
|-
| <syntaxhighlight lang=forth inline>um*</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|um*}} || desc. 
|-
| <syntaxhighlight lang=forth inline>um/mod</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|um/mod}} || desc. 
|-
| <syntaxhighlight lang=forth inline>unloop</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|unloop}} || desc. 
|-
| <syntaxhighlight lang=forth inline>until</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|until}} || desc. 
|-
| <syntaxhighlight lang=forth inline>user</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|user}} || desc. 
|-
| <syntaxhighlight lang=forth inline>value</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|value}} || desc. 
|-
| <syntaxhighlight lang=forth inline>variable</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|variable}} || desc. 
|-
| <syntaxhighlight lang=forth inline>vocabulary</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|vocabulary}} || desc. 
|-
| <syntaxhighlight lang=forth inline>w!</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|w!}} || desc. 
|-
| <syntaxhighlight lang=forth inline>w/o</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|w/o}} || desc. 
|-
| <syntaxhighlight lang=forth inline>w@</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|w@}} || desc. 
|-
| <syntaxhighlight lang=forth inline>while</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|while}} || desc. 
|-
| <syntaxhighlight lang=forth inline>wid-get-name</syntaxhighlight> || ( wid -- c-addr u ) || ficl || primitive || {{Anchor|wid-get-name}} || ficl独自: Ficl ワードリスト（2.05 以降）には、割り当てることができる名前のプロパティがあります。これは ORDER によって検索順序のワードリストの名前をリストするために使用されます。
|-
| <syntaxhighlight lang=forth inline>wid-set-name</syntaxhighlight> || ( c-addr wid -- ) || ficl || primitive || {{Anchor|wid-set-name}} || ficl独自: Ficl ワードリスト（2.05 以降）には、割り当てることができる名前のプロパティがあります。この名前は、\0 で終了する文字列（C スタイル）と仮定されます。これは簡便に Ficl がワード名を格納する方法です。 
|-
| <syntaxhighlight lang=forth inline>wid-set-super</syntaxhighlight> || ( wid -- ) || ficl || primitive || {{Anchor|wid-set-super}} || ficl独自: Ficl ワードリストには、標準 Forth で指定されていない親ワードリストポインタがあります。Ficl は通常、ワードリストを作成するときにこのポインタを NULL に初期化しますので、通常は効果がありません。このワードは、スタックのトップに指定されたワードリストへの親ポインタを設定します。icl の search-wordlist の実装は、検索時にワードリストの親リンクを逆にたどります
|-
| <syntaxhighlight lang=forth inline>within</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|within}} || desc. 
|-
| <syntaxhighlight lang=forth inline>word</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|word}} || desc. 
|-
| <syntaxhighlight lang=forth inline>wordlist</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|wordlist}} || desc. 
|-
| <syntaxhighlight lang=forth inline>words</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|words}} || desc. 
|-
| <syntaxhighlight lang=forth inline>write-file</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|write-file}} || desc. 
|-
| <syntaxhighlight lang=forth inline>write-line</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|write-line}} || desc. 
|-
| <syntaxhighlight lang=forth inline>x.</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|x.}} || desc. 
|-
| <syntaxhighlight lang=forth inline>xor</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|xor}} || desc. 
|-
| <syntaxhighlight lang=forth inline>{</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|{}} || desc. 
|-
| <syntaxhighlight lang=forth inline>{{</syntaxhighlight> || ( -- ) || ficl || kind || {{Anchor|{{}} || desc. 
|}

=== サンプルコード集 ===
=== 関連情報(書籍、Web サイトなど) ===

== 脚註 ==
<references />

[[Category:Forth]]
[[Category:プログラミング言語]]