Gforth ¶

1.1 Stability Goals ¶

(Gforthの安定性)Gforth の以前のバージョンで動作するプログラムは、 新しいバージョンでも動作するはずです。 ただし、 以下のようないくつかの注意点があります:

Gforth の内部データ構造 (コンパイル済みコードの表現を含む) は、 文書化されていない限り、 バージョン間で変更される可能性があります。

さらに、 私達は、 標準のワード (つまり、 標準のワードセットにある名前のワード)と、 永続的な Gforth 拡張機能として文書化されたワード(ワードセット名が gforth または gforth-<version> であるワード)(see Notation 参照)は、 保持する義務があると考えています。 他のワードは新しいリリースでは削除される可能性があります。

とりわけ、 あなたは locate を使用するか、 または、 Gforth のソース・コードを調べることでワードを見つけることができ、 スタック効果コメントの直後のコメントでワードセットを確認できます。 そのワードにワードセットがない場合、 それは内部実装であり、 将来のバージョンでは削除される可能性があります。 ワードセットが gforth-experimental または gforth-internal または gforth-obsolete の場合、 そのワードは将来のバージョンで削除される可能性があります。

あなたが永続的としてマークされていない特定のワードを使用したい場合、 私達にご連絡ください。 そのワードを永続的ワードとして追加することを検討します(または、このワードに代わる代替案を提案する場合もあります)。

2.1 Invoking Gforth ¶

Gforth は 2 つの部分から成ります。 実行可能「エンジン」(gforth または gforth-fast という名前)と、イメージ・ファイルです。 Gforth を開始するには、 通常は gforth とするだけです。 これにより、 デフォルトのイメージ・ファイル gforth.fi が自動的にロードされます。 他の多くの場合、 デフォルトの Gforth イメージは以下のように呼び出されます:

gforth [file | -e forth-code] ...

これにより、 ファイルの内容や、 (訳注:コマンドラインに記述された、) Forth コードが、 指定の順序で通訳(interpret)されます。

gforth エンジンに加えて、 gforth-fast というエンジンもあります。 これは高速ですが、 表示されるエラー・メッセージ(see Error messages)の情報が少なく、 そして、 一部のエラーのキャッチ(特に、 スタック・アンダーフローや整数除算エラーなど)が遅れて発生するか、 あるいはまったく発生しません。 デバッグ済みの、 パフォーマンスが重要なプログラムに対して使用するべきです。

さらに、 gforth-itc というエンジンがあり、 下位互換性が必要な状況(see Direct or Indirect Threaded?)で役に立ちます。

一般に、 コマンドラインは以下のようになります:

gforth[-fast] [engine options] [image options]

エンジン・オプションは、 コマンド・ラインの他の部分より前に指定する必要があります。 それらは以下のとおりです:

--image-file file ¶

-i file

デフォルトの gforth.fi の代わりに、 指定の Forth イメージ・ファイルをロードします(see Image Files)。

--appl-image file ¶

指定のイメージ・ファイルをロードし、 これ以降のコマンドライン引数は(エンジンのオプションとして処理するのではなく)、 すべてそのイメージが処理する為に残します。 これは、 gforthmi --application ... で構築された、 Unix 上で実行可能なアプリケーション・イメージを構築する場合に便利です。

--path path ¶

-p path

デフォルトである環境変数 GFORTHPATH 、 またはインストール時に指定されたパス(例: /usr/local/share/gforth/0.2.0:.)と作業ディレクトリ . の代わりに、 指定のパスを使用してイメージ・ファイルと Forth ソース・コード・ファイルを検索します。 パスは ‘:’ で区切られたディレクトリのリストとして指定されます(以前のバージョンには他の OS 用に ‘;’ がありましたが、 Cygwin は現在は /cygdrive/<letter> のみを受け入れ、 かつ、 私達は OS/2 や MS-DOS のサポートは終了してしまったため、 どこでも全部 ‘:’ になりました)。

--dictionary-size size ¶

-m size

イメージで指定されているデフォルト(通常は 256K)を使用する代わりに、 Forth ディクショナリー用のスペースに指定サイズ(size)のスペースを割り当てます。 このオプションと、下記のオプションのサイズ(size)指定は整数と単位で構成されます(例: 4M)。 単位は b (バイト)、 e (elementの略。セル単位)、 k (キロバイト)、 M (メガバイト)、 G (ギガバイト)、 T (テラバイト)のいずれかになります。 単位が指定されていない場合 e が使用されます。

--data-stack-size size ¶

-d size

イメージで指定されているデフォルト(通常は 16K) を使用する代わりに、 データ・スタックに指定のサイズ(size)のスペースを割り当てます。サイズ(size)指定は整数と単位で構成されます(例: 4M)。 単位は b (バイト)、 e (elementの略。セル単位)、 k (キロバイト)、 M (メガバイト)、 G (ギガバイト)、 T (テラバイト)のいずれかになります。 単位が指定されていない場合 e が使用されます。

--return-stack-size size ¶

-r size

イメージで指定されたデフォルト(通常は 15K)を使用する代わりに、 リターン・スタックに指定のサイズ(size)のスペースを割り当てます。 サイズ(size)指定は整数と単位で構成されます(例: 4M)。 単位は b (バイト)、 e (elementの略。セル単位)、 k (キロバイト)、 M (メガバイト)、 G (ギガバイト)、 T (テラバイト)のいずれかになります。 単位が指定されていない場合 e が使用されます。

--fp-stack-size size ¶

-f size

イメージで指定されているデフォルト(通常は 15.5K)を使用する代わりに、 浮動小数点スタックに指定のサイズ(size)のスペースを割り当てます。この場合、単位指定子 e は浮動小数点数を参照します。 サイズ(size)指定は整数と単位で構成されます(例: 4M)。 単位は b (バイト)、 e (elementの略。セル単位)、 k (キロバイト)、 M (メガバイト)、 G (ギガバイト)、 T (テラバイト)のいずれかになります。 単位が指定されていない場合 e が使用されます。

--locals-stack-size size ¶

-l size

イメージで指定されているデフォルト(通常は 14.5K)を使用する代わりに、 ローカル・スタック(locals stack)に指定サイズ(size)のスペースを割り当てます。 サイズ(size)指定は整数と単位で構成されます(例: 4M)。 単位は b (バイト)、 e (elementの略。セル単位)、 k (キロバイト)、 M (メガバイト)、 G (ギガバイト)、 T (テラバイト)のいずれかになります。 単位が指定されていない場合 e が使用されます。

--vm-commit ¶

通常 Gforth は、 ディクショナリーとスタックに十分な仮想メモリー(virtual memory)がない場合でも起動しようとします(OS がサポートしていれば MAP_NORESERVE を使用します)。 したがって、 あなたは非常に大きなディクショナリーやスタックを要求することができ、 利用可能なのを超える仮想メモリーを使用しない限り、 すべて問題ありません(ただし、それを超えて使用すると、 プロセスが強制終了(kill)されます)。 このオプションを使用すると、 OS のデフォルトの割り当てポリシーを使用するようになります。 とりわけ、 オーバーコミットしない OS (Solaris など) の場合、 これは、 大きなディクショナリーやスタックを要求することはできませんし、 要求すべきではないことを意味しますが、 しかし、 Gforth が正常に起動する事に成功したならば、 メモリー不足によって強制終了(kill)させられることはありません。

--help ¶

-h

コマンドライン・オプションに関するメッセージを出力します

--version ¶

-v

バージョンを出力して終了(exit)

--debug ¶

起動時のデバッグに役立ついくつかの情報を出力します。

--offset-image ¶

それ以外の場合に使用される位置とはわずかに異なる位置でディクショナリーを開始します (データ再配置可能イメージ(data-relocatable images)の作成に役立ちます see Data-Relocatable Image Files)。

--no-offset-im ¶

ディクショナリーを通常の位置で開始します。

--clear-dictionary ¶

イメージをロードする前に、 ディクショナリー内の全てのバイトを 0 に初期化します(see Data-Relocatable Image Files)。

--die-on-signal ¶

通常、 Gforth はほとんどのシグナル(例えば、 ユーザー割り込みの SIGINT や、 セグメンテーション違反 SIGSEGV)を Forth の THROW に変換することで処理します。 このオプションを使用すると、 Gforth はそのようなシグナルを受信すると終了(exit)します。 このオプションは、 (最初のシグナルから回復する前に別のシグナルが発生するなど、)エンジンやイメージがひどく壊れている可能性がある場合に役立ちます。 このオプションは、 そのような場合の無限ループを回避します。

--no-dynamic ¶

--dynamic

レプリケーション(replication)を伴う動的スーパー命令(dynamic superinstructions)を無効または有効にします(see Dynamic Superinstructions)。

--no-super ¶

動的スーパー命令(dynamic superinstructions)を無効にし、 動的レプリケーション(dynamic replication)のみを使用します。 これは、 スレッド化コード(threaded code)にパッチを適用する場合に便利です(see Dynamic Superinstructions)。

--ss-number=N ¶

エンジンにコンパイル済みの最初の N 個の静的スーパー命令(static superinstructions)のみを使用します(デフォルトでは全てを使用します。 注意: gforth-fast のみのオプションです)。 このオプションは、 静的スーパー命令(static superinstructions)のパフォーマンスへの影響を測定するのに役立ちます。

--ss-min-codesize ¶

--ss-min-ls

--ss-min-lsu

--ss-min-nexts

指定のメトリックを使用して、 静的スーパー命令の選択(static superinstruction selection)をするためにプリミティブまたは静的スーパー命令のコストを決定します。 Codesize はプリミティブまたは静的スーパー命令のネイティブ・コード・サイズ、 そして、 ls はロードとストアの数、 そして、 lsu はロードとストアと更新の数、 そして、 nexts は(動的スーパー命令を考慮しない)ディスパッチの数です。 ここで、 すべてのプリミティブまたは静的スーパー命令のコストは 1 です。 デフォルトでは、 動的コード生成を使用する場合は codesize、 それ以外の場合は nexts です。

--ss-greedy ¶

このオプションは、 静的スーパー命令のパフォーマンスへの影響を測定するのに役立ちます。 デフォルトでは、 静的スーパー命令の選択には最適な最短パス・アルゴリズム(shortest-path algorithm)が使用されます。 --ss-greedy を使用すると、 そのアルゴリズムは、 現在検討中の静的スーパー命令以降は静的スーパー命令に結合されないと想定するように変更されます。 --ss-min-nexts を使用すると、 その時点で利用可能な最長のスーパー命令を常に選択する貪欲なアルゴリズムと同じ結果が生成されます。 たとえば、スーパー命令 AB と BCD がある場合、 シーケンス A B C D に対して、 最適アルゴリズムは A BCD を選択し、 貪欲アルゴリズムは AB C D を選択します。

--print-metrics ¶

静的スーパー命令の選択中に使用されるいくつかのメトリックを出力します。 code size は、 動的に生成されたコードの実際のサイズです。 Metric codesize は、静的スーパー命令の選択によって確認できるコードサイズ・メトリック(codesize metrics)の合計で、 code size とは異なります。 これは、 すべてのプリミティブと静的スーパー命令が動的に生成されるコードにコンパイルされるわけではないことと、 マーカーがあるためです。 他のメトリクスは ss-min-... オプションに対応します。 このオプションは、--ss-... オプションの効果を評価するのに役立ちます。

上記にて説明したように、 デフォルト・イメージである gforth.fi のイメージ固有のコマンドライン引数は、 一連のファイル名と、 指定した順序で通訳(interpret)される -e forth-code オプションで構成されます。 -e forth-code または --evaluate forth-code オプションは Forth コードを評価(evaluate)します。 このオプションは引数を 1 つだけ取ります。 あなたが、もし、 さらに多くの Forth ワードを評価したい場合は、 ワードを引用符で囲むか、 -e を複数回使用する必要があります。 コマンド・ラインの処理後に(対話モードに入るのではなく、)終了(exit)するには、 コマンド・ラインに -e bye を追加します。 Forth プログラムではコマンド・ライン引数を処理することもできます(see OS command line arguments)。

複数のバージョンの Gforth がインストールされている場合、 gforth は最後にインストールされたバージョンを呼び出します。 gforth-<version> は特定のバージョンを呼び出します。 あなたの環境に環境変数 GFORTHPATH がある場合、 --path オプションを使用してこの環境変数をオーバーライドできます。

起動時、 イメージ・オプションを処理する前に、 環境変数 GFORTH_ENV で指定されたユーザー初期化ファイル、 またはその環境変数が設定されていない場合は(存在する場合、) ~/.config/gforthrc0 がインクルードされます。 GFORTH_ENV が「off」の場合は何もインクルードしません。 すべてのイメージ・オプションを処理した後、 ブート・メッセージを出力する直前に、 オプション --no-rc が指定されていない限り、 ホーム・ディレクトリのユーザー初期化ファイル ~/.config/gforthrc がインクルードされます。

警告レベルは以下のように設定できます

-W ¶

警告(warnings)をオフにする

-Won ¶

警告(warnings)をオンにする(レベル 1)

-Wall ¶

初心者向け警告をオンにする(レベル 2)

-Wpedantic ¶

細かい構文的な警告(pedantic warnings)をオンにする(レベル 3)

-Werror ¶

警告をエラーとして出す(レベル 4)

2.2 Leaving Gforth ¶

bye または (行の先頭で、) Ctrl-d または (--die-on-signal オプションを指定して Gforth を起動した場合、) Ctrl+C を入力すると、 Gforth を終了できます。 Gforth を終了すると、 あなたの定義とデータはすべて破棄されます。 Gforth を終了する前にシステムの状態を保存する方法については、 Image Files を参照してください。

bye ( – ) \ gforth を正常に終了する。

2.3 Help on Gforth ¶

Gforth には、 シンプルなテキストベースのオンライン・ヘルプ・システムがあります。

help ( "rest-of-line" –  ) gforth-1.0 “help”

名前が指定されていない場合は、 基礎的なヘルプが表示されます。 ドキュメント・ノード名に ‘::‘ が続く場合、 ノードの最初を表示します。 ワードの名前が指定されている場合、 そのワードのドキュメントが存在する場合はそのドキュメントを、 存在しない場合はソース・コードを表示します。 g を使用して、 help で表示された場所でエディタに入ります。 Help は現在の位置をマークするため、 n と b を使用してテキストの詳細を表示したり、 g を使用してエディターでドキュメントにアクセスしたりできます(see Locating source code definitions)。

authors ( –  ) gforth-1.0 “authors”

著者のリストを表示

license ( –  ) gforth-0.2 “license”

ライセンス声明を出力します

2.4 Command-line editing ¶

Gforth は、 テキスト・インタープリターに入力したすべての行を記録するヒストリ・ファイルを維持しています。 このファイルはセッションをまたいで保存され、 コマンドラインの再呼び出し機能を提供するために使用されます。 Ctrl-P を繰り返し入力すると、このセッション(または前のセッション)から古いコマンドを連続して呼び出すことができます。 コマンドライン編集機能の完全なリストは以下のとおりです:

• Ctrl-p (“previous”) (または「↑」上矢印)を使用して、 ヒストリ・バッファーから古い行を順に呼び出します。
• Ctrl-n (“next”)(または「↓」下矢印)を押すと、 ヒストリ・バッファーからより新しい行を連続して呼び出します。 以前に古い行に移動し、 それをテキスト解釈(text-interpretation)のために Gforth に与えた場合、 最初の編集コマンドとして「nextコマンド」を要求すると、 最後に選択した行の次の行が表示されます。
• Ctrl-f (または「→」右矢印)を使用して、 非破壊的にカーソルを右に移動します。
• Ctrl-b (または「←」左矢印)を使用して、 非破壊的にカーソルを左に移動します。
• Ctrl-h (backspace) カーソルの左側の文字を削除し、 桁を詰めます。
• Ctrl-k カーソルから行末までを削除 (“kill”) します。
• Ctrl-a カーソルを行頭に移動します。
• Ctrl-e カーソルを行末に移動します。
• RET (Ctrl-m) または LFD (Ctrl-j) 現在行を gforth へ送ります
• TAB 現在入力中のワードの、 可能なすべての全ワード補完をステップ実行します。
• Ctrl-d 空行で押すと Gforth を終了(terminate)します。 (bye 使用すると正常に終了します)。
• Ctrl-x (空行以外では Ctrl-d も使えます) カーソル位置の文字を削除します。

編集中、 表示可能な文字はカーソル位置の左側に挿入されます。 行は常に(「上書きモード」(overstrike)ではなく、)「挿入モード」(insert)です。

Unix システムでは、 ヒストリ・ファイルは デフォルトでは $HOME/.local/share/gforth/historyです²。 以下のコマンドを使用して、 ヒストリ・ファイルの名前と場所を確認できます:

history-file type \ Unix-class systems

history-file type \ Other systems
history-dir  type

あなたが長い定義を手入力した場合、 テキスト・エディターを使用してヒストリ・ファイルから Forth ソース・ファイルに貼り付け、 後で再利用できます。

Gforth はヒストリ・ファイルのサイズを決して削減しないため、 あなたは必要に応じて定期的にヒストリ・ファイルのサイズを削減する必要があります。

2.5 Environment variables ¶

Gforth は以下の環境変数を使用します:

• GFORTHHIST – (Unix系のみ) ヒストリ・ファイル .gforth-history のパスを指定。 デフォルト: $HOME/.local/share/gforth/history.
• GFORTHPATH – gforth イメージ・ファイルと Forth ソースコード・ファイル を検索するときに使用するパスを指定(通常 ‘.’ 、現在の作業ディレクトリ)。 パス区切り文字は ‘:’ です。 /usr/local/share/gforth/1.0:. みたいなのが典型です。
• LANG – LC_CTYPE 参照
• LC_ALL – LC_CTYPE 参照
• LC_CTYPE – Gforth の起動時にこの環境変数が “UTF-8” を含んでいる場合、 Gforth は内部で文字列に UTF-8 エンコーディングを使用し、 UTF-8 エンコーディングでの入力を期待し、 UTF-8 エンコーディングで出力を生成します。 それ以外の場合、 エンコーディングは 8 ビットです(see Xchars and Unicode)。 この環境変数が設定されていない場合、 Gforth は LC_ALL を調べ、 それも設定されていない場合は LANG を調べます。
• GFORTHSYSTEMPREFIX – C言語 の system() に渡す前に system の引数に何を付加するかを指定します。 デフォルト: Windows では "./$COMSPEC /c "で、他の OS では "" です。 このプレフィックスとコマンドは直接連結されるため、 間にスペースが必要な場合はプレフィックスに追加してください。
• GFORTH – gforthmi によって使用されます(See gforthmi)。
• GFORTHD – gforthmi によって使用されます(See gforthmi)。
• TMP, TEMP - (Unix系以外) ヒストリ・ファイルの場所として暗黙に使用されます。

すべての Gforth 環境変数は、 設定されていない場合、 デフォルトで適切な値になります。

2.6 Gforth files ¶

Gforth を Unix系にインストールすると、 デフォルトでは以下の場所にファイルがインストールされます:

• /usr/local/bin/gforth
• /usr/local/bin/gforthmi
• /usr/local/man/man1/gforth.1 - man page.
• /usr/local/info - the Info version of this manual.
• /usr/local/lib/gforth/<version>/... - Gforth .fi files.
• /usr/local/share/gforth/<version>/TAGS - Emacs TAGS file.
• /usr/local/share/gforth/<version>/... - Gforth source files.
• .../emacs/site-lisp/gforth.el - Emacs gforth mode.

configure のオプションを使用すると、 インストール先に違う場所を選択できます(どんなオプションがあるかは configure --help してください)。

2.7 Gforth in pipes ¶

Gforth は、他の場所で作成されたパイプラインを使用できます(以下で説明します)。 独自にパイプラインを作成することもできます(see Pipes)。

Gforth にパイプライン入力する場合、 プログラムは stdin から read-file または read-line を使用して読み取る必要があります(see General files)。 Key は入力の終わりを認識しません。 accept のようなワードは入力をエコーするため、 通常はパイプラインからの読み取りには役に立ちません。 あなたは、 (Forthのテキスト・インタープリターはパイプライン入力を通訳(interpret)しようとしてしまうため、)Forth内のコマンド・ラインを使用する機会はなく、 OSのコマンド・ライン・オプションを使用して Forth プログラムを呼び出す必要があります。

あなたは type、 emit、 cr などでパイプラインへ出力できます。

もう一方の端で既に閉じられているパイプラインに書き込むと、 Gforth は SIGPIPE シグナル(「パイプが壊れた」シグナル)を受け取ります。 Gforth はこれを例外 broken-pipe-error に変換します。 あなたのアプリケーションがその例外をキャッチしない場合、 システムはその例外をキャッチして、 通常は黙って終了(exit)します(Forth コマンド・ラインで作業している場合を除き、 エラー・メッセージを出力して終了します)。 これは通常、 望ましい動作です。

この振る舞いが気に入らない場合は、 自分で例外をキャッチし、 対応する必要があります。

ここで、 パイプライン内で使用できる Gforth の呼び出しの例を以下に示します:

gforth -e ": foo begin pad dup 10 stdin read-file throw dup while \
 type repeat ; foo bye"

この例では、 入力をそのまま出力にコピーするだけです。 この例を含む非常に単純なパイプラインは以下のようになります:

cat startup.fs |
gforth -e ": foo begin pad dup 80 stdin read-file throw dup while \
 type repeat ; foo bye"|
head

Gforth の stderr 出力に関連するパイプラインは機能しません。

2.8 Startup speed ¶

Gforth を CGI スクリプトやシェルスクリプトで使用する場合、 起動速度が問題になる場合があります。 libc-2.7 を搭載した 64 ビット Linux 2.6.27.8 上の 3GHz Core 2 Duo E8400 では、 gforth-fast -e bye でユーザー時間は 13.1 ミリ秒、システム時間は 1.2 ミリ秒かかります(gforth -e bye は、 下記で説明するオプションの一部を組み込んでいるため、 ユーザー時間は約 3.4 ミリ秒、 システム時間は 1.2 ミリ秒で起動がより高速になります)。

起動速度が問題になる場合は、 以下の改善方法を検討してください。 または、 起動の数を減らす方法(Fast-CGI の使用など)を検討することもできます。 以下の最初の手順では、 (コンパイル時間を含む)実行時間を犠牲にして起動時間を短縮するため、 それで利益が得られるかどうかはあなたのアプリケーションでのこれらの時間のバランスによって決まることに注意してください。

Gforth の起動速度に影響を及ぼす簡単な手順は、 実行時間(run-time)を増加させながらイメージの読み込み時間(image-loading time)を短縮する多数のオプションを使用してみることです。

最初に試す必要があるのは --ss-number=0 --ss-states=1 です。 このオプションは実行時の高速化が比較的わずかなのに、 起動時にかなりの時間がかかるためです。 gforth-fast --ss-number=0 --ss-states=1 -e bye には、 ユーザー時間が約 2.8 ミリ秒、 システム時間が約 1.5 ミリ秒かかります。

次のオプションは --no-dynamic です。 これは実行時間に大きな影響を及ぼします(いくつかのプラットフォームでは約 2 倍です)が、 それでも起動速度が若干速くなります。 gforth-fast -- ss-number=0 --ss-states=1 --no-dynamic -e bye は、 約 2.6 ミリ秒のユーザー時間と 1.2 ミリ秒のシステム時間を消費します。

起動速度を向上させるための次のステップは、 データ再配置可能イメージ(data-relocatable image)を使用することです(see Data-Relocatable Image Files)。 これにより、 イメージ内のコードの再配置コストが回避されます(ただし、 データの再配置コストは回避されません)。 イメージは、 使用している特定のバイナリ(つまり、 gforth、 gforth-fast、さらには特定のビルド)に固有であることに注意してください。 ./gforth-fast で動作するデータ再配置可能イメージを作成するには、 GFORTHD="./gforth-fast --no-dynamic" gforthmi gforthdr.fi とします(これには --no-dynamic が必要です。そうしないとこのイメージは機能しません)。 そして、 gforth-fast -i gforthdr.fi ... -e bye で実行します(上記で説明したフラグは、 再配置可能なコードでのみ機能するため、ここでは重要ではありません)。 gforth-fast -i gforthdr.fi -e bye では、 ユーザー時間は約 1.1 ミリ秒、 システム時間は約 1.2 ミリ秒かかります。

さらにもう 1 つのステップは、 再配置不可イメージ(non-relocatable image)を使用することで、 すべての再配置コストと書き換え時コピー(copy-on-write;COW)コストの一部を回避することです(see Non-Relocatable Image Files)。ただし、 アドレス空間のランダム化が行われているオペレーティング・システム(最近の Linux 等ではこれがデフォルト)や、 その他の理由でディクショナリーが移動した場合(OS カーネルの変更や、 ライブラリー更新などの場合)には機能しないという欠点があるため、 あまりお勧めできません。再配置不可イメージ(non-relocatable image)を作成するために gforth-fast --no-dynamic -e "savesystem gforthnr.fi bye" とします(ここでも --no-dynamic が必要です)。 そして、 gforth-fast -i gforthnr.fi ... -e bye として実行します(ここでも、 上記で説明したフラグは重要ではありません)。 gforth-fast -i gforthdr.fi -e bye はユーザー時間は約 0.9 ミリ秒、 システム時間は約 0.9 ミリ秒かかります。

実行するスクリプトに大量のコードが含まれている場合は、 起動時のコンパイルのコストを避けるために、 それをイメージにコンパイルすると有益な場合があります。

3.1 Starting Gforth ¶

あなたが Gforth を開始するには、その名前をタイプします:

gforth

これにより、 対話モードに入ります。 bye と入力すると Gforth を終了できます。 Gforth では、 bash と同様に、 コマンド・ラインを編集し、 カーソル・キーを使用してコマンド・ライン・ヒストリ(履歴)にアクセスできます。

3.2 Syntax ¶

word は、任意の文字のシーケンスです(空白(white space)を除く)。 ワードは空白(white space)で区切られます。 たとえば、 以下の各行には正確にただ 1 つのワードが含まれています:

word
!@#$%^&*()
1234567890
5!a

初心者によくある間違いは、 必要な空白を省略することです。 その結果、 ‘Undefined word’ のようなエラーが発生します。そのため、 このようなエラーが表示された場合は、 必要な場所に空白を入れてあるかどうかを確認してください。

." hello, world" \ correct
."hello, world"  \ gives an "Undefined word" error

Gforth および他のほとんどの Forth システムは、 大文字と小文字の違いを無視します(大文字と小文字は区別されません)。 つまり、 ‘word’ は ‘Word’ と同一です。 あなたのシステムで大文字と小文字が区別される場合は、 ここに示されているすべての例を大文字で入力する必要がある場合があります。

3.3 Crash Course ¶

Forth は、 自分の足を撃つような馬鹿げた事を妨げたりはしません。 以下のように Gforth をクラッシュさせるいくつかの方法を試してみましょう:

0 0 !
here execute
' catch >body 20 erase abort
' (quit1) >body 20 erase

最後の 2 つの例は、Gforth (および他のほとんどのシステム) の重要な部分を破壊することが保証されているため、 (Gforth が自動的に終了していない場合、) この後は Gforth を終了させたほうがよいでしょう。 一部のシステムでは、 外部から gforth を強制終了する必要がある場合があります(例: Unix系 では kill を使用します)。

これらの行が何を行うのか、 なぜクラッシュが発生するのかは後ほど分かります。

クラッシュを発生させる方法がわかったので(そして、 それは大したことがない事がわかったので)、 今度は意味のあるプログラムを作成する方法を学ぶとしましょう。

3.4 Stack ¶

Forth の最も明々白々な機能はスタックです。 数値を入力すると、 その数値がスタックにプッシュされます。 .s を使用してスタックの内容を表示できます。

1 2 .s
3 .s

.s はスタックの最上位(top-of-stack)が一番右になるように表示します。 つまり、 数値は入力時に表記されたとおりに .s 出力に表れます。

. を使用してスタックの最上位要素を出力できます。

1 2 3 . . .

一般に、 ワードはスタック引数を消費します(.s は例外です)。

研究課題(assignment): 5 6 7 . の後、 スタックには何が含まれていますか？

3.5 Arithmetics ¶

+ や - や * や / や mod というワードは、 常に頂上から見て 2 つのスタック項目に作用します:

2 2 .s
+ .s
.
2 1 - .
7 3 mod .

- や / や mod のオペランドは、 対応する中置式と同じ順序になります(これが Forth における一般的なケースです)。

ワードの順序によって評価の順序とオペランドが明確に決定されるため、 括弧は不要です(そして、 括弧は使用不可です):

3 4 + 5 * .
3 4 5 * + .

研究課題(assignment): 上記の Forth コードに対応する中置式はどうなるでしょうか？ また、 6-7*8+9 を Forth 表記で記述してください³。

符号を変更するには、 以下のように negate を使用します:

2 negate .

研究課題(assignment): ‘-(-3)*4-5‘ を Forth に変換してみましょう。

/mod は / と mod の両方を実行します。

7 3 /mod . .

詳しくはこちらを参照ください: Arithmetic

3.6 Stack Manipulation ¶

スタック操作ワードはスタックのデータを並べ替えます。

1 .s drop .s
1 .s dup .s drop drop .s
1 2 .s over .s drop drop drop
1 2 .s swap .s drop drop
1 2 3 .s rot .s drop drop drop

上記は最も重要なスタック操作ワードです。 以下のように2つペアでスタック項目を操作する亜種もあります:

1 2 3 4 .s 2swap .s 2drop 2drop

さらに 2 つ、 以下のスタック操作ワードがあります:

1 2 .s nip .s drop
1 2 .s tuck .s 2drop drop

研究課題(assignment): nip と tuck を他のスタック操作ワードの組み合わせに置き換えてみましょう。

以下の結果になるスタック操作を考えてみましょう
Given:          How do you get:
1 2 3           3 2 1
1 2 3           1 2 3 2
1 2 3           1 2 3 3
1 2 3           1 3 3
1 2 3           2 1 3
1 2 3 4         4 3 2 1
1 2 3           1 2 3 1 2 3
1 2 3 4         1 2 3 4 1 2
1 2 3
1 2 3           1 2 3 4
1 2 3           1 3

5 dup * . \ 5^2

研究課題(assignment): 17 を複数回書かずに、 Forth で 17^3 と 17^4 を書いてみましょう。 また、 スタック上の 2 つの数値 (a と b、 スタック頂上を b とする) を想定し、(a-b)(a+1) を計算する Forth コードを作成してみましょう。

こちらも参照してください: Stack Manipulation

3.7 Using files for Forth code ¶

Forth コマンド・ラインでの作業は、 1 行の例や短い 1 回限りのコードの場合には便利ですが、 あなたは編集や永続化に便利なように、 ソース・コードをファイルに保存したいと思うかもしれません。 お気に入りのエディター(なお、 Gforth には Emacs サポートがあります see Emacs and Gforth)を使用して file.fs を作成し以下のようにします

s" file.fs" included

こうすると、 file.fs ファイルを Forth システムにロードします。 私達は Forth ファイルの拡張子には ‘.fs’ を使っています。

以下のようにいくつかのファイルをロードして、 Gforth を簡単に開始できます:

gforth file1.fs file2.fs

これらのファイルのロード中にエラーが発生した場合、 Gforth は終了(terminate)しますが、 Gforth 内で INCLUDED 中にエラーが発生すると、 通常は Gforth コマンド・ラインになります。 Forth システムを毎回開始させれば、 あなたの以前の試行の結果に影響されることなく、 毎回クリーンな開始が可能になります。

私達は多くの場合、 すべてのテストをファイルに入れて、 それからそのコードをロードし以下のようにしてテストを実行します

gforth code.fs tests.fs -e bye

(多くの場合、 Emacs内 で C-x C-e を使用してこのコマンドを実行します。) -e bye により、 テスト後に Gforth が確実に終了(terminate)するので、 面倒なくこのコマンドを再度開始できます。

このアプローチの利点は、 プログラムが変更されるたびにテストを簡単に繰り返すことができ、 変更によって生じたバグを簡単に発見できることです。

こちらも参照してください: Forth source files

3.8 Comments ¶

\ これはコメントです。これは行末で終わります
( もう一つのコメント。 これはこのように閉じ丸括弧で終わります: )  .s

\ と ( は通常の Forth ワードであるため、 その後ろのテキストと空白(white space)で区切る必要があります。

\This gives an "Undefined word" error

最初にあらわれる ) が ( で始まるコメントを終了するため、 「( 型のコメント」を入れ子(nest)にすることはできません。 そして、 ( ... ) を使用して ) を含むテキストをコメントアウトすることはできません⁴。

私達は、 説明テキストや、 1 行以上のコードのコメントアウトに \ コメントを使用します。 ( コメントは、 スタック効果やスタックの内容を説明したり、 コードの下位部分をコメントアウトしたりするために使用します。

Emacs モード gforth.el (see Emacs and Gforth) は、 C-x \ でリージョンをコメントアウトし、 C-u C-x \ でリージョンのコメントを解除し、 \ でコメントされた領域を M-q でフィル(fill)します。

こちらも参照してください: Comments

3.9 Colon Definitions ¶

コロン定義(Colon Definitions)は、 他のプログラミング言語のプロシージャや関数に似ています。

: squared ( n -- n^2 )
   dup * ;
5 squared .
7 squared .

: はコロン定義を開始します。 その名前は squared です。 それに続くコメントは、 そのスタック効果について説明しています。 dup * というワードは実行はされませんが、 定義にコンパイルされます(compiled into the definition)。 ; はコロン定義を終了します。

新しく定義されたワードは、 他の定義での使用を含め、 他のワードと同様に使用できます:

: cubed ( n -- n^3 )
   dup squared * ;
-5 cubed .
: fourth-power ( n -- n^4 )
   squared squared ;
3 fourth-power .

研究課題(assignment): nip や tuck や negate や /mod のコロン定義を他の Forth ワードで記述し、 それらが機能するかどうかを確認してみましょう (ヒント: 最初にオリジナルであなたの作成したテストコードをテストして結果を確認してから、 その後あなたが定義して、 再度テストして結果を比較しましょう)。 ‘redefine’ メッセージに驚かないでください。 これらは単なる警告です。 (訳注: redefine; 同じ名前のワードを定義したという警告。 置き換えではなく追加となる。 これ以降の通訳(interpret)・コンパイルは新しい方のワードを参照するが、 通常は新しい方のワード定義後も、 既にコンパイル済みのワードは古い方のワードを参照しつづける。 詳しくはディクショナリー等の項目を参照)

こちらも参照してください: Colon Definitions

3.10 Decompilation ¶

see: を使用してコロン定義を逆コンパイルできます:

see squared
see cubed

Gforth では、 see は実行可能コードからソース・コードを再構築したものを示します。 ソースには存在するが、 実行可能コードには存在しない情報(コメントなど)は失われます。

最初から義済みのワードを逆コンパイルすることもできます:

see .
see +

3.11 Stack-Effect Comments ¶

慣例により、 定義名の後のコメントはスタック効果を説明します。 ‘--’ の前の部分は、 定義の実行前のスタックの状態、 つまりコロン定義に渡されるパラメータを説明します。 ‘--’ の後ろの部分は、 定義の実行後のスタックの状態、 つまり定義の実行結果です。 スタック・コメントには、 定義がアクセス、 または、変更する、 (訳注: 定義の外部から見える、 )スタック項目のみを記述します。

たとえ スタック効果が ( -- ) (訳注: スタックに何の効果も及ぼさない)であっても、 あなたは、 すべての定義に正しいスタック効果を記述するべきです。 また、 より複雑なワードには説明的なコメントを追加する必要があります(通常、 これは : の後ろに続けます)。 これを行わないと、 あなたコードの行動は解読不能になります(なぜなら、 とある定義を理解するためには、 全ての定義を辿るハメになるから)。

研究課題(assignment): 例えば swap のスタック効果は、 x1 x2 -- x2 x1 のように記述できます。 同様に、 - や drop や dup や over や rot や nip や tuck のスタック効果を書いてみましょう。 ヒント: 書けたら、 このマニュアルに書いてあるスタック効果と合っているかどうかチェックしましょう(see Word Index)。

プログラマーは、 コロン定義内のさまざまな場所に、 その場所のスタックの内容を説明するコメント(スタック・コメント)を挿入することがあります。 つまり、 スタック効果コメントの最初の部分のようなものです。 例えば以下のようなのです

: cubed ( n -- n^3 )
   dup squared  ( n n^2 ) * ;

この場合、 ワードが十分に単純であるため、 スタック・コメントは割と余計です。 あなたが、 読みやすさを高めるためにそのようなコメントを追加することが良いと思った場合、 ワードをいくつかの単純なワードにファクタリング(因数分解)することも検討する必要があります(see Factoring)。 ファクタリングにより、 通常はスタック・コメントが不要になります。 ただし、 あなたが結果としてリファクタリングしないことに決めた場合は、 そのようなコメントがある方が、 無いよりも良いです。

標準や、 このマニュアルや、 多くのプログラムの、 スタック効果およびスタック・コメント内のスタック項目の名前は、 Fortran やハンガリアン記法と同様に、 型プレフィックスによって型を指定します。 最も頻繁に使用されるプレフィックスは以下のとおりです:

n

符号付き整数

u

符号なし整数

c

文字(character)

f

二値フラグ(Boolean flags)。 つまり false または true

a-addr,a-

セル・アライメント・アドレス

c-addr,c-

文字(char)アライメント・アドレス(注意: Windows NT では文字(char)は 2 バイトになる場合があることに注意)

xt

実行トークン(Execution token)。 セルと同一サイズ

w,x

セル(cell)。 セルには整数またはアドレスを含めることができます。 通常は 32ビットまたは 64 ビットまたは 16 ビットを必要とします(プラットフォームと Forth システムによって異なります)。 cell は一般には machine word として知られていますが、 Forth では word という用語はすでに別の意味を持っています。

d

符号付き2倍長整数(signed double-cell integer)

ud

符号無し2倍長整数(unsigned double-cell integer)

r

浮動小数点数(Float)(FP スタック上に置かれる)

より完全なリストは Notation にあります。

研究課題(assignment): あなたがここまでで記述したすべての定義に対してスタック効果コメントを記述してみましょう。

3.12 Types ¶

Forth では、 演算子の名前はオーバーロードされません。 したがって、 異なる型に対する同様の演算には異なる名前が必要です。 たとえば、 + は整数の加算をしますが、 浮動小数点数を加算するには f+ を使用する必要があります。 以下のプレフィックスは、 さまざまな型の関連する演算によく使用されます:

(none)

符号付き整数

u

符号なし整数

c

文字(character)

d

符号付き2倍長整数(signed double-cell integer)

ud, du

符号無し2倍長整数(unsigned double-cell integer)

2

2 つのセル(必ずしも 2倍長整数(double-cell numbers)とは限りません)

m, um

単一セルとダブル・セルの混合操作

f

浮動小数点(注意: スタック・コメントでは、 ‘f’ はフラグを表し、 ‘r’ は FP 数値を表すことに注意してください。 また、 リテラル FP 数値には指数部分を含める必要があります see Floating Point)。

符号付きのバリエーションと符号なしのバリエーションに違いがない場合(例えば + の場合)、 プレフィックスのないバリエーションのみが存在します。

Forth は、 コンパイル・モード時もインタープリター・モード時も型チェックを実行しません。 以下のように間違った操作を行うと、 データが正しく通訳(interpret)されません:

-1 u.

あなたが、 これまで型チェック言語しか使用したことがなく、 型チェックがいかに重要であるかを聞いたことがある場合でも、 パニックに陥る必要はありません。 著者の経験(および他の Forth 利用者(Forthers)の経験)では、 Forth コードの型エラーは通常(慣れてしまえば)簡単に見つかります。 プログラマの警戒心が高まると、 ほとんどの型エラーに加えて、 より困難なエラーも発見される傾向があります。 型システムを回避する必要がまったくないため、 ほとんどの状況では型チェックがないことが利点であるようです(Forth に型チェックを追加するプロジェクトは普及していません)。

3.13 Factoring ¶

あなたが長ったらしい定義を書こうとすると、 スタックの内容を追跡するのがすぐに困難になることがわかります。 したがって、優れた Forth プログラマは短い定義 (たとえば 3 行)のみを記述する傾向があります。 意味のある短い定義を見つける技術は、 (多項式の因数分解(factoring polynomials)と同様に)ファクタリング(factoring)として知られています。

よくファクタリングされたプログラムには、 追加の利点もあります。 つまり、小さくて一般的なワードは、 大きくて特殊なワードよりもテストとデバッグが容易で、より再利用性に富みます。

したがって、 あなたが、 スタック管理に問題を抱えてるなら、 コードを記述するときにワードに意味のある要素を定義し、 それらの観点からワードを定義するようにしてください。 たった 2 つのワードしかしか含まれないような定義でも、 多くの場合役に立ちます。

上手なファクタリングは簡単ではなく、 コツを掴むにはある程度の練習が必要です。 しかし、経験豊富な Forth プログラマーであっても、 すぐには適切な解決策を見つけられないことが多く、 プログラムの書き直し時に見つかるのです。 したがって、 すぐに良い解決策が思い浮かばなくても、 絶望しないで試し続けてください。(訳注: 参考: 拙訳 Thinking Forth 第6章 ファクタリング https://thinking-forth-ja.readthedocs.io/ja/latest/chapter6.html)

3.14 Designing the stack effect ¶

他の言語では、 関数(function)のパラメーターに任意の順序を使用できます。 また、 結果は 1 つだけなので、 結果の順序を扱う必要もありません。

Forth (および他のスタック・ベースの言語、 たとえば PostScript)では、 定義のパラメーターの順序と結果の順序が重要であり、 適切に設計する必要があります。 一般的なガイドラインは、 ワードの実装が複雑になる場合でも、 ワードがほとんどの場合に簡単に使用できるようにスタック効果を設計することです。 いくつかの具体的なルールは以下のとおりです:

• ワードがパラメーターの全てを消費する(例: .)。
• パラメーターの順序に関する慣習がある場合(数学や他のプログラミング言語など)、 それに従ってください(例: -)。
• 1 つのパラメーターが通常短い計算のみを必要とする場合(たとえば、それが定数である場合)、 それをスタック頂上(top of stack;TOS)に渡します。 逆に、 通常、 計算に長いコード シーケンスが必要なパラメーターは、 スタック底(bottom) (つまり、最初の) パラメーターとして渡す必要があります。 これにより、 リーダーはコードの長いシーケンス(またはスタック操作)を通じてスタック底の項目(bottom item)を追跡する必要がなくなるため、 コードが読みやすくなります。 たとえば、 !(「ストア」 see Memory)は、 通常、 格納されている値よりも計算が簡単であるため、 スタック頂上にアドレスがあるのを期待します(多くの場合、 アドレスは単なる変数です)。
• 同様に、 通常すぐに消費される結果はスタック頂上(top of stack)に返されるべきですが、 長い計算でよく使用される結果はスタック底(bottom)の結果として渡される必要があります。 たとえば、 open-file のようなファイル・ワードは、スタック頂上にエラー・コードを返します。 これは、 通常、 throw によってすぐに消費されるためです。 さらに言えば、 他の結果に対して何かを行う前に、 エラー・コードをチェックする必要があります。

これらのルールは一般的なガイドラインに過ぎません。 ワードを使いやすくするという全体的な目標を見失わないでください。 例えば、 慣習のルールが計算長のルールと衝突する場合、 ワードがあまり使われない場合は慣習を優先するかもしれません。 一方、 ワードが頻繁に使われる場合は、 計算長のルールを優先するかもしれません(だからといって頻繁に使うと、 計算長のルールを破るコストが非常に高くなりますし、 頻繁に使うことで非慣習的な順序を覚えてしまいがちになります)。

3.15 Local Variables ¶

コロン定義内でローカル変数(local)を定義できます:

: swap { a b -- b a }
  b a ;
1 2 swap .s 2drop

(あなたの Forth システムがこの構文をサポートしていない場合は、 最初に compat/anslocal.fs をインクルードしてください)

この例では、 { a b -- b a } がローカル変数定義です。 スタックから 2 つのセルを取得し、 スタック頂上を b に入れ、 その次のスタック要素を a に入れます(訳注: a b はスタック上から取り除かれる)。 -- は } で終わるコメントを開始します。 ローカル変数の定義後、 ローカル変数の名前を使用すると、 その値がスタックに積まれます。 コメント部分(-- b a)は省略できます:

: swap ( x1 x2 -- x2 x1 )
  { a b } b a ;

Gforth では、 コロン定義内の任意の場所に複数のローカル変数定義を含めることができます。 対照的に、 標準Forthのプログラムでは、 コロン定義ごとにローカル変数定義を 1 つだけしか持つことができず、 そのローカル変数定義は制御構造の外側にある必要があります。

ローカル変数を使用すると、 スタックの問題に遭遇することなく、 少し長い定義を書くことができます。 ただし、重要な、ファクタリング技能を身につけるための演習として、 ローカル変数を使用せずにコロン定義を記述してみることをお勧めします。

研究課題(assignment): ここまでのあなたの定義をローカル変数を使って書き換えてみましょう。

こちらも参照下さい: Locals

3.16 Conditional execution ¶

Forth では、 コロン定義内でのみ制御構造を使用できます。 if 構造は以下のようになります:

: abs ( n1 -- +n2 )
    dup 0 < if
        negate
    endif ;
5 abs .
-5 abs .

if はスタックからフラグを取得します。 フラグがゼロ以外 (true) の場合は、 その次のコードが実行されます。 そうでない場合は、 endif (または else) の後から実行が続けられます。 < は、 頂上から 2 つのスタック要素を比較し、 フラグを生成します。

1 2 < .
2 1 < .
1 1 < .

実は、 endif の標準Forthでの名前は then です。 このチュートリアルでは、 endif を使用した例を示します。 なぜなら、 then が異なる意味を持つ他のプログラミング言語に慣れている人々にとっては、 endif を使用する方が混乱が少ないからです。 システムに endif がない場合は、 以下のように定義します

: endif postpone then ; immediate

あなたはオプションで else 部分を使用できます:

: min ( n1 n2 -- n )
  2dup < if
    drop
  else
    nip
  endif ;
2 3 min .
3 2 min .

研究課題(assignment): else 部分を付けずに min を記述してみましょう。 (ヒント: nip の定義は何ですか?)。

こちらも参照下さい: Selection

3.17 Flags and Comparisons ¶

false フラグはすべてのビットがクリアです(整数として通訳(interpret)される場合は 0)。 正規化された true フラグは、 すべてのビットがセットされています(2の補数の符号付き整数として -1)。 多くの文脈(例: if)では、ゼロ以外の値はすべて true フラグとして扱われます。

false .
true .
true hex u. decimal

比較ワードは正規化フラグを生成します:

1 1 = .
1 0= .
0 1 < .
0 0 < .
-1 1 u< . \ 型エラー。 u< は -1 を 大きな符号なし数として扱ってしまいます
-1 1 < .

Gforth は、接頭辞 0 u d d0 du f f0 (または「 接頭辞なし」)との比較 = <> < > <= >= のすべての組み合わせをサポートします。 これらの組み合わせの一部のみが標準Forthです (詳細については、標準Forth または Numeric comparison または Floating Point または Word Index を参照してください)。

and or xor invert を正規化フラグ用の演算子として使用できます。 実際には、 これらはビット単位演算です:

1 2 and .
1 2 or .
1 3 xor .
1 invert .

0<> を使用して ゼロ/非ゼロ フラグを正規化フラグに変換できます(そして、 その途中で 0= を使用して ゼロ/非ゼロ フラグの余数(complement)を取ります。 実際、 正規化フラグでは invert の代わりに 0= を使用するのが一般的です)。

1 0= .
1 0<> .

0<> 無しでも if で ゼロ/非ゼロ をテストすることはできますが、 ゼロ/非ゼロ 値を and or xor と組み合わせる場合、 and or xor はビット単位での操作なので、 0<> を使用する必要がある場合があります。 最も単純で、 エラーが少なく、 おそらく最も明確な方法は、 これらすべての場合に 0<> を使用することですが、 場合によっては、 使用する 0<> の数を減らすこともできます。 以下にいくつかのスタック効果を示します。 fc は正規化フラグ(canonical flag)を表し、 fz は ゼロ/非ゼロ を表します(すべての fc は fz としても機能します):

or  ( fz1 fz2 -- fz3 )
and ( fz1 fc  -- fz2 )
and ( fc  fz1 -- fz2 )

したがって、 以下のようなコードの場合:

( n1 n2 ) 0<> and if

これは、 n1 and n2 (n1 かつ n2)がゼロ以外であるかどうかをテストし、 イエスの場合は if の後のコードを実行します。 n1 を ゼロ/非ゼロ として扱い、 0<> を使用して n2 を正規化フラグに変換します。 and は fz を生成し、 それは if によって消費されます。

正規化フラグの全ビットセット機能とブール演算のビット単位の演算を使用して、 if を回避することもできます:

: foo ( n1 -- n2 )
  0= if
    14
  else
    0
  endif ;
0 foo .
1 foo .

: foo ( n1 -- n2 )
  0= 14 and ;
0 foo .
1 foo .

研究課題(assignment): min を if 無しで書いてみましょう。

こちらも参照下さい: Boolean Flags, Numeric comparison, Bitwise operations

3.18 General Loops ¶

無限ループは非常に単純です:

: endless ( -- )
  0 begin
    dup . 1+
  again ;
endless

(Gforth の場合、) Ctrl-C を押してこのループを終了します。 begin は実行時に何も行わず、 again は begin にジャンプします。

任意の場所に 1 つの出口があるループは以下のようになります:

: log2 ( +n1 -- n2 )
\ logarithmus dualis of n1>0, rounded down to the next integer
  assert( dup 0> )
  2/ 0 begin
    over 0> while
      1+ swap 2/ swap
  repeat
  nip ;
7 log2 .
8 log2 .

実行時には while はフラグを1つ消費します。 フラグが 0 の場合、 repeat の後ろへ飛んで実行が継続されます。 フラグがゼロ以外の場合、 実行は while の後ろから継続されます。 Repeat は、 again と全く同じように、 begin に戻ります。

Forth には、 1+ など、多数の 組み合わせ/省略形 があります。 しかし、 2/ は 組み合わせ/省略形 ではありません。 これは引数を 1 ビット右にシフトし、 Gforth の (Gforth 0.7 以降の) / と同様、 常に負の無限大方向に向かって小数点以下を丸める除算(フロア除算)と見なされますが、 他の多くの Forth システムの / とは異なります。

-5 2 / . \ -2 or -3
-5 2/ .  \ -3

assert( は標準Forthのワードではありませんが、 Gforth 以外のシステムでも compat/assert.fs を含めることで取得できます。 それが何をするかは、 以下のように試してみることで確認できます。

0 log2 .

以下は、 最後に出口があるループです:

: log2 ( +n1 -- n2 )
\ logarithmus dualis of n1>0, rounded down to the next integer
  assert( dup 0 > )
  -1 begin
    1+ swap 2/ swap
    over 0 <=
  until
  nip ;

Until はフラグを消費します。 フラグがゼロの場合は begin から実行が継続され、 それ以外の場合は until の後から実行が継続されます。

研究課題(assignment): 最大公約数を計算する定義を書いてみましょう。

こちらも参照ください: Simple Loops

3.19 Counted loops ¶

: ^ ( n1 u -- n )
\ n = the uth power of n1
  1 swap 0 u+do
    over *
  loop
  nip ;
3 2 ^ .
4 3 ^ .

U+do (あなたの Forth システムにない場合は compat/loops.fs をインクルードしてください)は、 ( u3 u4 -- ) 、 つまり、 スタックから 2 つの数値を取得し、 u+do と loop の間のコードを u3 - u4 回実行します( u3 - u4 < 0 の場合はまったく実行しません)。

ループ開始ワードのスタック効果を見れば、スタック効果の設計ルールが機能していることがわかります。 ループの開始値は終了値と比べて定数であることが多いため、 開始値はスタック頂上(top-of-stack)に渡されます。

i を使用して、 ループ・カウンターにアクセスできます:

: fac ( u -- u! )
  1 swap 1+ 1 u+do
    i *
  loop ;
5 fac .
7 fac .

+do もあります。 これは符号付きの数値を期待します(それはループに入るかどうかを決定するために重要です)。

研究課題(assignment): n 番目のフィボナッチ数を計算するための定義を記述してみましょう。

増分として 1 以外も使用できます:

: up2 ( n1 n2 -- )
  +do
    i .
  2 +loop ;
10 0 up2

: down2 ( n1 n2 -- )
  -do
    i .
  2 -loop ;
0 10 down2

こちらも参照ください: Counted Loops

3.20 Recursion ¶

通常、 定義の名前はその定義内に表れません。ただし、 それ以前の(同名の)定義は普通に表れます(訳注: 下記例は再帰呼出しではなくて、 ’/’ の古いバージョンを呼び出しているに過ぎない事に注意。同じ名前の古いバージョンが存在しなければエラーになるが、存在すればエラーにならないので注意。):

1 0 / . \ "Floating-point unidentified fault" in Gforth on some platforms
: / ( n1 n2 -- n )
  dup 0= if
    -10 throw \ report division by zero
  endif
  /           \ old version
;
1 0 /

再帰定義の場合は、 recursive (非標準) または recurse を使用できます:

: fac1 ( n -- n! ) recursive
 dup 0> if
   dup 1- fac1 *
 else
   drop 1
 endif ;
7 fac1 .

: fac2 ( n -- n! )
 dup 0> if
   dup 1- recurse *
 else
   drop 1
 endif ;
8 fac2 .

研究課題(assignment): n 番目のフィボナッチ数を計算するための再帰定義を記述してみましょう。

こちらも参照ください (間接再帰に関してもコチラ): See Calls and returns

3.21 Leaving definitions or loops ¶

EXIT は、 現在の定義をすぐに終了(exit)します。 EXIT の実行前に、 (残ったループ・カウンタ達を全て取り除くために、)ネストしたカウンタ付きループの数だけ UNLOOP を実行する必要があります(訳注: 下記例は1重のループなので unloop が1つ。 2重ループになったら unloop unloop と2つ必要):

: ...
 ... u+do
   ... if
     ... unloop exit
   endif
   ...
 loop
 ... ;

LEAVE は、 (LEAVE から見て)最も内側にあるカウンタ付きループを直ちに終了します:

: ...
 ... u+do
   ... if
     ... leave
   endif
   ...
 loop
 ... ;

こちらも参照ください: Calls and returns, Counted Loops

3.22 Return Stack ¶

データ・スタックに加えて、 Forth には 2 番目のスタックであるリターン・スタックもあります。 ほとんどの Forth システムは、プロシージャ呼び出しの戻りアドレスをそこに保存します(したがって、 リターン・スタックという名前が付けられています)。 プログラマもリターン・スタックを利用することができます。

: foo ( n1 n2 -- )
 .s
 >r .s
 r@ .
 >r .s
 r@ .
 r> .
 r@ .
 r> . ;
1 2 foo

>r はデータ・スタックから1つの要素を取得し、 それをリターン・スタックにプッシュします。 逆に、 r> は1つの要素をリターンからデータ・スタックに移動します。 r@ は、リターン・スタック頂上のコピーをデータ・スタックにプッシュします。

Forth プログラマーは通常、 データ・スタックのみを使用すると複雑すぎて、 かつ、 ファクタリングやローカル変数が選択肢に無い場合、 データを一時的に保存するためにリターン・スタックを使用します。

: 2swap ( x1 x2 x3 x4 -- x3 x4 x1 x2 )
 rot >r rot r> ;

定義のリターン・アドレスとカウント付きループのループ制御パラメーターは通常、 リターン・スタック上に存在するため、 コロン定義またはカウント付きループでリターン スタックにプッシュしたすべての項目を、定義の終了やループの終了の前にリターン・スタックから取得する必要があります。 ある定義の外側やループの外側でリターン・スタックにプッシュしたアイテムに、 ループの定義内からアクセスすることはできません。

リターン・スタック項目の数を間違えると、 通常はクラッシュします:

: crash ( n -- )
  >r ;
5 crash

ローカル変数の使用とリターン・スタックの使用を混在させることはできません(標準Forthの場合。 Gforth では問題ありません)。 ただし、 これらは同一の問題の解決なので、 問題にはなりません。

研究課題(assignment): リターン・スタックを使用して、 ここまでにあなたが書いた定義をより良い方法で書き直すことができるでしょうか？

こちらも参照ください: Return stack

3.23 Memory ¶

以下使用してグローバル変数 v を作成できます:

variable v ( -- addr )

v は、スタックにメモリー内の、とあるセルのアドレスをプッシュします。 このセルは variable によって予約されています。 !(ストア)を使用してスタックからこのセルに値を保存し、 @(フェッチ)を使用して値をメモリーからスタックにロードできます:

v .
5 v ! .s
v @ .

dump を使用すると、 メモリーの生のダンプ(メモリー・ダンプ)を確認できます:

v 1 cells .s dump

Cells ( n1 -- n2 ) は、 n1 個のセル が占めるバイト数(より一般的にはアドレス単位(address units)(aus))を与えます。 そして、 あなたは、 さらに多くのメモリーを予約することもできます:

create v2 20 cells allot
v2 20 cells dump

変数のようなワード v2 を作成し、 20 個の初期化されていないセルを予約します。 v2 によってプッシュされたアドレスは、 これら 20 個のセルの先頭を指します(see CREATE)。 あなたは、 アドレス演算を使用して、 これらのセルにアクセスできます:

3 v2 5 cells + !
v2 20 cells dump

, を使用してメモリーを予約 かつ 初期化できます:

create v3
  5 , 4 , 3 , 2 , 1 ,
v3 @ .
v3 cell+ @ .
v3 2 cells + @ .
v3 5 cells dump

研究課題(assignment): 最初のセルは addr 、 次のセルは addr cell+ などとして、 u 個のセルの値の合計を計算する定義 vsum ( addr u -- n ) を記述してみましょう。

variable と create の違いは、variable がセルを割り当てる(allots)ことと、 標準 Forth では変数(variable)に追加のメモリーを割り当てることができないことです。

新しいワードを作成せずにメモリーを予約することもできます:

here 10 cells allot .
here .

最初の here は(最初の here 時点の)ディクショナリー領域の後のアドレスをプッシュし、 メモリー領域の開始アドレスとして使い、 2 番目の here は(2 番目の here 時点の)ディクショナリー領域の後のアドレスをプッシュします。 この開始アドレスはどこかに保存する必要があります。 そうしないと、 あなたはこのメモリー領域を再度見つけるのが困難になります。

Allot はディクショナリー・メモリーを管理します。 ディクショナリー・メモリーには、 Gforth や他のほとんどの Forth システムの、 ワードなどのシステムのデータ構造が含まれています。 これはスタックのように管理されます。 あなたは以下のようにして割り当て(allot)したメモリーを解放できます:

-10 cells allot
here .

注意: その合間に新しいワードを作成した場合、 それを実行できないことに注意してください(allot で作成されたメモリーが、 もはやディクショナリー「スタック」の頂上ではなくなるため)。

その代わりに、 allocate や free を使用すると、 任意の順序でメモリを解放できます:

10 cells allocate throw .s
20 cells allocate throw .s
swap
free throw
free throw

throw はエラー(メモリー不足など)を処理します。

また、 ガベージ・コレクター なら、 メモリーを明示的に解放(free)する必要がなくなります。

こちらも参照ください: Memory

3.24 Characters and Strings ¶

スタック上では、 数と同様に文字がセルを占めます。 メモリー内では文字は独自のサイズ(ほとんどのシステムでは 8 ビットのバイト値)であるため、 メモリー・アクセスには文字独自のワードが必要です:

create v4 
  104 c, 97 c, 108 c, 108 c, 111 c,
v4 4 chars + c@ .
v4 5 chars dump

スタック上の文字列の推奨される表現は addr u-count です。ここで、addr は文字列の最初の文字のアドレスで、 u-count は文字列の文字数です。

v4 5 type

以下を使用すると文字列定数を取得できます

s" hello, world" .s
type

s" と文字列の間にスペースがあることを確かめてください。 s" は通常の Forth ワードであり、 空白(white space)で区切る必要があります(スペースを削除するとどうなるかを試してみましょう)。

ただし、 この s" のインタープリターでの使用(interpretive use)は非常に制限されています。 文字列は、 s" が次に呼び出されるまでの間だけ存在します(一部の Forth システムはこれらの文字列を複数保持しますが、 普通は未だ限られた寿命です)。

s" hello," s" world" .s
type
type

あなたは定義内で s" を使用することもでき、 (定義が続く限り、)その結果の文字列は永久に存続します:

: foo s" hello," s" world" ;
foo .s
type
type

研究課題(assignment): Emit ( c -- ) は c を(数値ではなく)文字として出力します。 これを使って type ( addr u -- ) を実装してみましょう。

こちらも参照ください: Memory Blocks

3.25 Alignment ¶

多くのプロセッサでは、 @ と ! を使用してセルにアクセスする場合、 メモリー内でセ​​ルをアライメントする必要があります (プロセッサがアライメントを必要としない場合でも、 アライメントされたセルへのアクセスは高速です)。

Create は here(つまり、 次の割り当てが行われる場所、 そしてcreateされたワードが指す場所)でアライメントします。 同様に、 allocateによって生成されたメモリーはアライメントしたアドレスから始まります。 アライメントしたアドレスに cells の数値 を足すと、 次のアライメントされたアドレスが生成されます。

ただし、 char+ および chars を含むアドレス演算では、セルにアライメントしていないアドレスが作成される可能性があります。 Aligned ( addr -- a-addr ) は、 その次のアライメントせされたアドレスを生成します:

v3 char+ aligned .s @ .
v3 char+ .s @ .

同様に、 align は here を次のアライメントされたアドレスに進めます:

create v5 97 c,
here .
align here .
1000 ,

注意: プログラムを移植可能にしたい場合は、 プロセッサがそれらを必要としない場合でも、 アライメントれたアドレスを使用する必要があることに注意してください。

こちらも参照ください: Address arithmetic

3.26 Floating Point ¶

Forth の浮動小数点(floating-point)(FP)の、 数値と算術演算は、 ほぼ期待された通りに機能しますが、 特筆すべき点がいくつかあります:

最初の点は Forth に固有のものではありませんが、 非常に重要で、 まだ広く知られていないため、 ここで言及します。 浮動小数点数は実数(real)ではありません。 実数(real)が持ち、 あらゆる種類の数値に期待される多くの性質(算術法則など)は、 浮動小数点数には当てはまりません。 浮動小数点演算したい場合、 浮動小数点演算の問題とその回避方法について学ぶ必要があります。 良い出発点は David Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic, ACM Computing Surveys 23(1):5−48, March 1991 です(訳注: https://docs.oracle.com/cd/E19957-01/806-4847/ncg_goldberg.html これが合ってるかどうか不明。一部文字化けあり2024/06現在)。

Forth ソース・コードでは、リテラル浮動小数点数には指数が必要です(例: 1e0)。これは、 1e のように短く書くことも、 +1.0e+0 のように長く書くこともでき、 その間にはさまざまなバリエーションがあります。 その理由は、 歴史的な理由により、 Forth は小数点のみ(例: 1.) の数を 2 セル整数を示すものとして通訳(interpret)するためです。 例:

2e 2e f+ f.

リテラル浮動小数点数のもう 1 つの要件は、 現在の基数が 10 進数であることです。 16 進数の 1e は整数として通訳(interpret)されます:

Forth には、Forth-2012 に準拠した浮動小数点数用の別個のスタックがあります。 このモデルの利点の 1 つは、 浮動小数点数にアクセスするときにセルが邪魔にならないこと、 またその逆も同様であることです。 Forth には、 浮動小数点スタック(FP スタック)を操作するためのワードのセットがあります: fdup fswap fdrop fover frot や (非標準の、) fnip ftuck fpick

FP 算術ワードには F という接頭辞が付きます。 通常の f+ f- f* f/ f** fnegate のほか、 他の、 関数用の多数のワード (例: fsqrt fsin fln fmin) があります。 期待されるワードの 1 つが f= ですが、 f= は標準にはありません。 浮動小数点数の計算結果は通常不正確であるため、 正確な比較は通常間違いであり、 近似的な比較を使用する必要があります。 残念ながら、この目的のための標準のワードである f~ は適切に設計されていないため、 Gforth では f~abs と f~rel も提供しています。

そしてもちろん、 メモリー内の浮動小数点数にアクセスするためのワード(f@ f!)や、 アドレス演算用のワード(floats float+ faligned)もあります。 メモリ内の IEEE 書式の単精度および倍精度数にアクセスするために、 sf および df プレフィックスを付けた、 これらのワードのバリエーションもあります。 その主な目的は、 外部浮動小数点数データ(ファイルから読み取られた、 またはファイルに書き込まれるデータなど)にアクセスすることです。

以下は、 ドット出力ワード(dot-product word)とその使用例です:

: v* ( f_addr1 nstride1 f_addr2 nstride2 ucount -- r )
  >r swap 2swap swap 0e r> 0 ?DO
    dup f@ over + 2swap dup f@ f* f+ over + 2swap
  LOOP
  2drop 2drop ;

create v 1.23e f, 4.56e f, 7.89e f,

v 1 floats  v 1 floats  3  v* f.

研究課題(assignment): 二次方程式を解くプログラムを作成してみましょう。 次に、 Henry G. Baker, You Could Learn a Lot from a Quadratic, ACM SIGPLAN Notices, 33(1):30−39, January 1998 を読んで、 そのプログラムを改善できるかどうか確認してください。 最後に、 元のバージョンと改良されたバージョンで異なる結果が生成されるテスト・ケースを探しましょう。

こちらも参照ください: Floating Point; Floating point stack; Number Conversion; Memory Access; Address arithmetic.

3.27 Files ¶

このセクションでは、 Forth 内でファイルを使用する方法について簡単に説明します。 それは 5 つの簡単なステップに分かれています:

1. 入力用に ASCII テキスト・ファイルを開きます
2. 出力用にファイルを開く
3. 文字列が一致する (または他の条件が満たされる) まで入力ファイルを読み取ります
4. 入力 (が変更されたかどうかに関係なく、) から数行を出力に書き込みます
5. ファイルを閉じます。

こちらも参照ください: General files

s" foo.in"  r/o open-file throw Value fd-in

s" foo.out" w/o create-file throw Value fd-out

0 Value fd-in
0 Value fd-out
: open-input ( addr u -- )  r/o open-file throw to fd-in ;
: open-output ( addr u -- )  w/o create-file throw to fd-out ;

s" foo.in" open-input
s" foo.out" open-output

256 Constant max-line
Create line-buffer  max-line 2 + allot

: scan-file ( addr u -- )
  begin
      line-buffer max-line fd-in read-line throw
  while
         >r 2dup line-buffer r> compare 0=
     until
  else
     drop
  then
  2drop ;

s" The text I search is here" scan-file

: copy-file ( -- )
  begin
      line-buffer max-line fd-in read-line throw
  while
      line-buffer swap fd-out write-line throw
  repeat 
  drop ;

fd-in close-file throw
fd-out close-file throw

: close-input ( -- )  fd-in close-file throw ;
: close-output ( -- )  fd-out close-file throw ;

3.28 Interpretation and Compilation Semantics and Immediacy ¶

ワードがコンパイルされる時と、 通訳(interpret)される時では異なる振る舞いをします。 たとえば、 + について考えてみましょう:

1 2 + .
: foo + ;

これらの 2 つの振る舞いは、 コンパイル機能(compilation semantics)とインタプリタ機能(interpretation semantics)として知られています。 通常のワード(例: +)の場合、 コンパイル機能は、 現在定義中のワード(上記の例では foo)にインタープリター機能を追加します。 つまり、 後で foo が実行されると、 + のインタープリター機能(interpretation semantics)(つまり、2 つの数値の加算)が実行されます。

ただし、 if のような制御フロー・ワードなど、 デフォルト以外のコンパイル機能を持つワードが存在します。 immediate を使用すると、 最後に定義されたワードのコンパイル機能をインタープリター機能と等しくなるように変更できます:

: [FOO] ( -- )
 5 . ; immediate

[FOO]
: bar ( -- )
  [FOO] ;
bar
see bar

デフォルト以外のコンパイル機能をもつワードだと知らしめる 2 つの慣習は、 名前を括弧で囲む(より頻繁に使用される)ことと、 名前をすべて大文字で記述する(あまり使用されない)ことです。

if などの一部のワードについては、 インタープリター機能を使用するのは通常間違いであるため、 それらを compile-only としてマークし、 インタープリター機能を使用すると警告が表示されます。

: flip ( -- )
 6 . ; compile-only \ but not immediate
flip

: flop ( -- )
 flip ;
flop

この例では、 最初に flip のインタープリター機能を使用します(警告が表示されます)。 flip の 2 番目の使用では、 コンパイル機能を使用します(警告は表示されません)。 この例では、 compile-only が実行時(run-time)ではなくテキスト・インタープリター時に評価される属性であることもわかります。

テキスト・インタープリターには 2 つの状態があります。 インタープリター・モード(interpret)は、 遭遇したワードのインタープリター機能(interpretation semantics)を実行します。 コンパイル・モードでは、 これらのワードのコンパイル機能(compilation semantics)が実行されます。

特に、 : はコンパイル状態に切り替え、 ; はインタープリター状態に戻します。 これらには、 状態を切り替えるだけの効果である ] (コンパイル状態に切り替える) と [ (インタープリター状態に切り替える) が含まれています。

: xxx ( -- )
  [ 5 . ]
;

xxx
see xxx

これらの角括弧(brackets)は、 上記の命名慣習の源でもあります。

こちらも参照ください: Interpretation and Compilation Semantics

3.29 Execution Tokens ¶

' word は、 ワードの実行トークン(execution token)(XT)を提供します。 XT は、 ワードのインタープリター機能(interpretation semantics)表すセルです。 これは execute で実行できます:

' + .s
1 2 rot execute .

XT は C の関数ポインターに似ています。 ただし、 パラメーターがスタックで渡されるため、もう少し柔軟になります:

: map-array ( ... addr u xt -- ... )
\ addr で始まり u 個の要素を含む配列のすべての要素に対して
\ xt ( ... x -- ... ) を実行します
  { xt }
  cells over + swap ?do
    i @ xt execute
  1 cells +loop ;

create a 3 , 4 , 2 , -1 , 4 ,
a 5 ' . map-array .s
0 a 5 ' + map-array .

s" max-n" environment? drop .s \ 下記比較初期値用に整数最大値を得る
a 5 ' min map-array . \ 最初の要素は、 environment? で取得した整数最大値と比較

生成するより消費する要素が 1 つ多いワードの XT に対して map-array を使用できます。 理論的には、他の XT でも使用できますが、 スタック効果は配列のサイズに依存するため、理解するのが困難です。

XT はセルサイズであるため、 メモリーに保存し、 他のセルと同様にスタック上で操作できます。 compile, を使用して XT をワードにコンパイルすることもできます:

: foo1 ( n1 n2 -- n )
   [ ' + compile, ] ;
see foo1

compile, は標準ではコンパイル機能(compilation semantics)がないため、 上記は標準ではないけれども、 良い Forth システムでは動作します。 うまくいかなかったモノついては、 以下を使用してください

: [compile,] compile, ; immediate

: foo1 ( n1 n2 -- n )
   [ ' + ] [compile,] ;
see foo1

' は、 デフォルトでコンパイル機能(compilation semantics)を持つワードです。 そのワードのインタープリター機能(interpretation semantics)を実行すると、 その次のワードを構文解析(parse)します。

: foo ( -- xt )
  ' ;
see foo
: bar ( ... "word" -- ... )
  ' execute ;
see bar
1 2 bar + .

コンパイル中にワードを解析(parse)し、 その XT をコンパイルして、 実行時にスタックにプッシュされるようにしたいことがよくあります。 ['] はこれを行います:

: xt-+ ( -- xt )
  ['] + ;
see xt-+
1 2 xt-+ execute .

多くのプログラマーは、 ' とそれが解析(parse)するワードを 1 つの単位として認識し、 コンパイル時に ['] のように動作することを期待し、 実際の動作に混乱する傾向があります。 あなたがもしそうなら、 Forth システムは ' を 1 つの単位として捉えているだけであり、 それが解析(parse)ワードであるとはまったく考えていないことを覚えておいてください(この問題でプログラマーの便宜を図る試みは、 通常、 さらにひどい落とし穴につながります。 State-smartness—Why it is evil and How to Exorcise it)。

XT の作成および実行は、 インタープリターの状態には影響を受けないことに注意してください。 つまり、 コンパイル状態で ' を実行した場合でも、 インタープリター機能(interpretation semantics)が得られます。 そして、 そこでの状態が何であれ、 execute は XT によって表されるコード(つまり、' で生成された XT の場合はインタープリター機能(interpretation semantics))を実行します。

こちらも参照ください: Tokens for Words

3.30 Exceptions ¶

throw ( n -- ) は、 n がゼロでない限り例外を引き起こします。

100 throw .s
0 throw .s

catch ( ... xt -- ... n ) は execute と同様に動作しますが、 例外をキャッチし、 スタック上に例外の数値(または XT が例外なしで実行された場合は 0)をプッシュします。 例外があった場合、 スタックの深さは catch の実行直前と同一です。

.s
3 0 ' / catch .s
3 2 ' / catch .s

研究課題(assignment): catch の代わりに execute を使用して同じことを試してみましょう。

throw は、常に動的に直近にこの throw を囲んでいる(定義の) catch にジャンプします、 たとえそのジャンプを達成するために複数の呼び出しレベルを飛び越す必要がある場合でもです:

: foo 100 throw ;
: foo1 foo ." after foo" ;
: bar ['] foo1 catch ;
bar .

多くの場合、 定義が例外によって終了した場合でも、 定義を終了したときに値を復元することが重要です。 以下のようにしてみるのはどうでしょうか:

: ...
   save-x
   ['] word-changing-x catch ( ... n )
   restore-x
   ( ... n ) throw ;

しかし、 これでも、 たとえば、catch と restore-x の間を実行中にユーザーが Ctrl-C を押すなどしたら安全ではありません。

Gforth は、そのような場合に対して安全な代替例外処理構文(alternative exception handling syntax) try ...restore ... endtry を提供します。 try と endtry の間のコードに例外があった場合、 スタックの深さが復元され、 例外数値がスタックにプッシュされ、 restore の直後から実行が続行されます。

以下は、 上記のコードと同等の、 より安全なコードです

: ...
  save-x
  try
    word-changing-x 0
  restore
    restore-x
  endtry
  throw ;

こちらも参照ください: Exception Handling

3.31 Defining Words ¶

これまでに出てきた : や create や variable は定義ワードです。 これらは他のワードを定義します。 Constant はもう一つの定義ワードです:

5 constant foo
foo .

variable や constant でも接頭辞 2 (2倍長セル) や f (浮動小数点) を使用することができます。

あなた独自の定義ワードを定義することもできます。 例:

: variable ( "name" -- )
  create 0 , ;

また、 単にアドレスを生成する以外のことを行うワードを作成する定義ワードを定義することもできます:

: constant ( n "name" -- )
  create ,
does> ( -- n )
  ( addr ) @ ;

5 constant foo
foo .

上記の constant の定義は does> で終了します。 つまり、 does> は ; を置き換えるのですが、 他のことも行います。 最後に定義されたワードを変更して、 ワード本体(body)のアドレスをプッシュし、 呼び出されるたびに does> の後のコードを実行します。

上の例では、 constant は , を使用して foo の本体に 5 を格納します。 foo が実行されると、 本体のアドレスがスタックにプッシュされ、 (does> の後のコードにより、)そこから 5 がフェッチされます。

does> の脇のスタック・コメントは、 does> の後のコードのスタック効果ではなく、 定義されたワードのスタック効果です(違いは、 does> の後のコードは does> の脇のスタック・コメントには書いてない、 ワード本体(body)のアドレスを期待している点です)。

これらの定義ワードを使用すると、 (他の)定義ワードが関係する場合にファクタリングを行うことができます。 たとえば、 フィールド・オフセットは常にアドレスに加算するものですが、 その代わりに以下を定義します

2 cells constant offset-field1

この offset-field1 は以下のように使います

( addr ) offset-field1 +

ここで、 あなたは以下のような定義ワードをを定義できます

: simple-field ( n "name" -- )
  create ,
does> ( n1 -- n1+n )
  ( addr ) @ + ;

フィールド・オフセットの定義と使用は以下のようになります:

2 cells simple-field field1
create mystruct 4 cells allot
mystruct .s field1 .s drop

does> の後のコードを実行せずに、 そのワードで何かをしたい場合は、 >body ( xt -- addr ) を使用すれば create したワードの本体(body)にアクセスできます:

: value ( n "name" -- )
  create ,
does> ( -- n1 )
  @ ;
: to ( n "name" -- )
  ' >body ! ;

5 value foo
foo .
7 to foo
foo .

研究課題(assignment): (abort の XT の先頭に、) XT を格納するワードを作成する、 defer ( "name" -- ) を定義し、 実行時に XT を execute で実行するようにしてみましょう。 間接再帰は defer の応用の 1 つです。

こちらも参照ください: User-defined Defining Words

3.32 Arrays and Records ¶

Forth には配列を定義するための標準ワードはありませんが、 アドレス演算に基づいて自分で配列を構築できます。 配列とレコードを定義するためのワードを定義することもできます(see Defining Words)。

Forth の初心者がワードの定義について学ぶときに最初に着手するプロジェクトの 1 つが配列定義ワード(ことによっては n 次元配列)です。 さぁあなたもやってみましょう。 あなたはそこから何かを学ぶでしょう。 ただし、 後からこれらのワードをほとんど使用しないことがわかってもがっかりしないでください(不適切に使用するとさらに悪いことになります)。 著者はまだ有用な配列ワードのセットを見つけられていません。 ニーズがあまりにも多様で、 (定義ワードを単純に使用した結果である、)名前付きのグローバル配列は、 柔軟性が十分ではないことがよくあります(たとえば、 どのようにしてパラメーターを渡すか、など)。 同様のプロジェクトのもう 1 つは、 文字列の処理に役立つワードのセットです。

その一方、 レコード・ワードには便利なセットがあり、 compat/struct.fs で定義されています。 これらのワードは Gforth で事前定義されています。 これらについては、 このマニュアルの他の場所で詳しく説明されています(see Structures 参照)。 上記の simple-field の例は、 このパッケージのフィールドの簡略化されたバリエーションです。

3.33 POSTPONE ¶

POSTPONE (訳注: (期限が定まってる)延期)を使用すると、 (そのワードのインタプリタ機能(interpretation semantics)をコンパイルする代わりに、) そのワードのコンパイル機能(compilation semantics)をコンパイルできます:

: MY-+ ( Compilation: -- ; Run-time of compiled code: n1 n2 -- n )
 POSTPONE + ; immediate
: foo ( n1 n2 -- n )
 MY-+ ;
1 2 foo .
see foo

foo の定義中に、 テキスト・インタープリターは MY-+ のコンパイル機能(compilation semantics)を実行し、 そのコンパイル機能が + のコンパイル機能を実行します。 つまり、 + を foo 内にコンパイルします。

この例では、 コンパイル機能(compilation semantics)とコンパイルされたコードのスタック効果について個別のスタック・コメントも表示します。 デフォルトのコンパイル機能を持つワードの場合、 通常、 これらのスタック効果は表示されません。 これらのワードのコンパイル機能のスタック効果は常に ( -- ) であり、 コンパイルされたコードのスタック効果はインタープリター機能(interpretation semantics)のスタック効果です。

注意: この方法でコンパイル機能(compilation semantics)を実行する場合、 インタプリタの状態には影響を受けないことに注意してください。 あなたはそれを対話的(interpretively)に実行することもできます。 例:

: foo2 ( n1 n2 -- n )
 [ MY-+ ] ;
1 2 foo2 .
see foo2

ただし、 これが常に機能するとは限らない、良くない Forth システムがいくつかあるため、 この方法は 1999 年に非標準となりました。

POSTPONE を使用する別の例を以下に示します:

: MY-- ( Compilation: -- ; Run-time of compiled code: n1 n2 -- n )
 POSTPONE negate POSTPONE + ; immediate compile-only
: bar ( n1 n2 -- n )
  MY-- ;
2 1 bar .
see bar

ENDIF は以下の方法で定義できます:

: ENDIF ( Compilation: orig -- )
  POSTPONE then ; immediate

研究課題(assignment): 2dup と同等のコンパイル機能(compilation semantics)を持つ MY-2DUP を作成しますが、 コンパイルされるのは over over になるようにしてみましょう。

3.34 Literal ¶

数値を POSTPONE することはできません:

: [FOO] POSTPONE 500 ; immediate

代わりに LITERAL (compilation: n --; run-time: -- n ) を使用します:

: [FOO] ( compilation: --; run-time: -- n )
  500 POSTPONE literal ; immediate

: flip [FOO] ;
flip .
see flip

LITERAL は、 コンパイル時(コンパイル機能(compilation semantics)が実行される時)に数値を消費し、 実行時(コンパイルされたコードが実行されるとき)にそれをプッシュします。 LITERAL のよくある使用法は、 コンパイル時に計算された数値を現在のワードにコンパイルすることです:

: bar ( -- n )
  [ 2 2 + ] literal ;
see bar

研究課題(assignment): 上記の例を : bar ( -- n ) [ 2 2 + ]L ; と記述できるような ]L を定義してみましょう。

3.35 Advanced macros ¶

Execution Tokens の map-array について再検討してみましょう。 map-array は execute を頻繁に実行しますが、 これは一部の Forth 実装では比較的高価な操作です。 compile, と POSTPONE を使用すると、 これらの execute を削除し、 直接実行されるワードを含むワードを生成できます:

: compile-map-array ( compilation: xt -- ; run-time: ... addr u -- ... )
\ at run-time, execute xt ( ... x -- ... ) for each element of the
\ array beginning at addr and containing u elements
  { xt }
  POSTPONE cells POSTPONE over POSTPONE + POSTPONE swap POSTPONE ?do
    POSTPONE i POSTPONE @ xt compile,
  1 cells POSTPONE literal POSTPONE +loop ;

: sum-array ( addr u -- n )
 0 rot rot [ ' + compile-map-array ] ;
see sum-array
a 5 sum-array .

コードの生成には Forth の機能を最大限に活用できます。 以下に、 コードがループ内で生成される例を示します:

: compile-vmul-step ( compilation: n --; run-time: n1 addr1 -- n2 addr2 )
\ n2=n1+(addr1)*n, addr2=addr1+cell
  POSTPONE tuck POSTPONE @
  POSTPONE literal POSTPONE * POSTPONE +
  POSTPONE swap POSTPONE cell+ ;

: compile-vmul ( compilation: addr1 u -- ; run-time: addr2 -- n )
\ n=v1*v2 (inner product), where the v_i are represented as addr_i u
  0 postpone literal postpone swap
  [ ' compile-vmul-step compile-map-array ]
  postpone drop ;
see compile-vmul

: a-vmul ( addr -- n )
\ n=a*v, where v is a vector that's as long as a and starts at addr
 [ a 5 compile-vmul ] ;
see a-vmul
a a-vmul .

この例では compile-map-array を使用していますが、 代わりに map-array を使用することもできます(是非試してみてください)。

この手法を使用すると、 巨大な行列を効率的に乗算できます。 行列の乗算では、 一方の行列のすべての行ともう一方の行列のすべての列を乗算します。 1 行のコードを 1 回生成し、 それをすべての列に使用できます。 この手法の唯一の欠点は、 生成されたコードによって消費されたメモリーを完了時に開放するのが面倒なことです(さらに複雑な場合は移植可能ではありません)。

3.36 Compilation Tokens ¶

このセクションは Gforth 固有です。 スキップしても構いません。

' word compile, はインタープリター機能(interpretation semantics)をコンパイルします。 デフォルトのコンパイル機能(compilation semantics)を持つワードの場合、 これはコンパイル機能を実行するのと同じです。 他のワードのコンパイル機能(インタープリター機能を持たない if などのワード)を表すために、 Gforth にはコンパイル・トークン(CTと略します。 2つのセルで構成)と、 ワード comp' と、 ワード [comp'] の概念があります。 execute を使用して、 CT によって表されるコンパイル機能を実行できます:

: foo2 ( n1 n2 -- n )
   [ comp' + execute ] ;
see foo2

postpone, を使用して、 CT によって表されるコンパイル機能をコンパイルできます:

: foo3 ( -- )
  [ comp' + postpone, ] ;
see foo3

[ comp' word postpone, ] POSTPONE word と同等です。 comp' は、 インタープリター・モード用のコードを持たないワードに対して特に役立ちます:

' if
comp' if .s 2drop

こちらも参照ください: Tokens for Words

3.37 Wordlists and Search Order ¶

ディクショナリー(辞書)は、 allot でメモリーを割り当てることができる、 単なるメモリー領域ではなく、 複数のワード・リスト(wordlist)上にある Forth ワード達も含まれています。 ワード・リスト内のワードを検索するとき、 概念的には、 最も新しいワードから検索を開始し、 古いワードに向かって進みます(実際には、 最近のほとんどのシステムはハッシュ・テーブルを使用します)。 つまり、 古いワードと同一の名前のワードを定義すると、 新しいワードが古いワードを隠します。

どのワードリストがどの順序で検索されるかは、 検索順序スタック(the search order)によって決まります。 order で検索順序を表示できます。 最初に検索されるワードリストから順に検索順序を表示し、 その次に、 新しく定義されるワードを含むワードリストを表示します。

wordlist ( -- wid ) を使用して、 新しい空のワード・リスト(wordlist)を作成できます:

wordlist constant mywords

Set-current ( wid -- ) は、 新しく定義されたワードを入れるワード・リストを設定します(the current wordlist):

mywords set-current
order

このワード・リストは wordlist を使用して匿名で作成されたため、 Gforth は mywords のワード・リスト名を表示しません。

get-current ( -- wid) で現在のワード・リストを取得できます。 現在のワード・リストに影響を与えずに、 指定のワード・リストに何かを入れたい場合、 通常は以下のようにします:

get-current mywords set-current ( wid )
create someword
( wid ) set-current

検索順序スタック(the search order)は set-order ( wid1 .. widn n -- ) で記述し、 get-order ( -- wid1 .. widn n ) で読み取ることができます。 ( n を除いて) もっとも TOS 側のワード・リストが最初に検索されます。

get-order mywords swap 1+ set-order
order

ええ、 order の出力内のワードリストの順序は、 スタック・コメントや .s の出力とは逆になっているため、 直感的ではありません。

研究課題(assignment): >order ( wid -- ) を定義して、 最初に検索されるワード・リスト(wordlist)として wid を検索順序スタック(the search order)に追加してみましょう。 previous ( -- ) を定義してみましょう。 これは、 最初に検索されたワードリスト(wordlist)を検索順序スタックから削除するものです。 定義したら、 境界条件を試してみましょう(クラッシュや、 そこから抜け出すことが困難または不可能な状況がいくつか見られる事でしょう)。

検索順序スタック(the search order)は、 Modula-2 モジュールや、 C++ の名前空間と同様の機能を提供するための強力な基盤です。 ただし、 この方法でプログラムをモジュール化しようとすると、 デバッグや 再利用/ファクタリング に関しては、 (大規模なプロジェクトの経験はありませんけれども、)著者の経験では利点を上回る欠点があります。 他の言語/プログラミング環境では、 デバッグや再利用がそれほど強力ではないため、 これらの欠点はそれほど目立ちません。

こしらも参照ください: Word Lists

4.1 Introducing the Text Interpreter ¶

Forth イメージを呼び出すと、 起動バナーが出力されますが、 他には何も表示されません (システムに Gforth がインストールされている場合は、 gforthRET と入力して今すぐ呼び出してみてください)。 今、 Forth は、 テキスト・インタープリター(Text Interpreter)と呼ばれるコマンド・ライン・インタプリタを実行しています(外部インタープリターとも呼ばれます;訳注: 別途存在する 内部インタープリター(inner interpreter)に対してこう呼ばれる)。 (この章を読み進ればテキスト・インタープリターについて多くのことを学ぶことができます。 詳細については see The Text Interpreter を参照してください)。

明白ではなくて分かりにくいですが、 今や Forth はユーザーの入力を待っています。 数字の 4 と 5 を入力し RET キーを押します:

45RET  ok

テキスト・インタープリターは、 次の入力を促すプロンプトを表示するのではなく、 入力行を処理した後に(改行無しで)ステータス・メッセージを出力します。 この場合のステータス・メッセージ(RET (「エンター」(リターン)キー押下)の後の ok )は、 テキスト・インタープリターがすべての入力を正常に処理できたことを示します。 それでは次に、 不正な文字列を入力してみましょう:

qwer341RET
*the terminal*:2: Undefined word
>>>qwer341<<<
Backtrace:
$2A95B42A20 throw 
$2A95B57FB8 no.extensions 

‘Undefined word‘ 以外の文章はシステムによって若干異なる場合がありますが、 意味は同じです。 テキスト・インタープリターがエラーを検出すると、 行に残っているテキストを破棄し、 特定の内部状態をリセットして、 エラー・メッセージを出力します。 エラー・メッセージの詳細な説明については、 Error messages を参照してください。

テキスト・インタープリターは、エンター・キー(リターン・キー)が押されるのを待ち、 その後入力行を処理します。 行頭から開始して、 行をスペースで区切られた文字のグループに分割します。 文字のグループごとに、 以下の順番で、 何かするために計 2 回の試みを行います:

• その文字のグループをコマンドとして扱おうとします。 これは、 名前ディクショナリ(name dictionary)を検索することによって行われます。 その文字のグループが名前ディクショナリーのエントリと一致する場合、 名前ディクショナリーは、 いくつかのアクションを実行できるようにする情報をテキスト・インタープリターに提供します。 Forth 流に言うと、文字のグループを「ワードの名前」といい、 ディクショナリー検索でワードの定義(definition)に対応する実行トークン(execution token;xt)が返され、 テキスト・インタープリターは xt を実行します。 多くの場合、「ワード」(word)と「定義」(definition)という用語は同じ意味で使用されます。
• テキスト・インタープリターが名前ディクショナリー内で一致するものを見つけられなかった場合、 文字のグループを現在の基数の数値として処理しようとします(Forth を起動したときの、 現在の基数は 10 です)。 文字のグループが正当な数値を表す場合、 テキスト・インタープリターはその数値をスタックにプッシュします(これについては次のセクションで詳しく説明します)。

テキスト・インタープリターが文字グループに対して上記のいずれも実行不可能な場合、 その文字グループと行の残りの部分が破棄され、 エラー・メッセージが出力されます。 テキスト・インタープリターがエラーなく行末に到達すると、 ステータス・メッセージ ok に続いて改行を出力します。

以下は、 テキスト・インタープリターに与えることができる最もシンプルなコマンドです:

RET  ok

ここで、 テキスト・インタープリターは、 私たちが要求したことをすべて(何もせずに)エラーなしで実行したため、 すべてが ok であると表示しました。 今度は少し長いコマンドを試して見ましょう:

12 dup fred dupRET
*the terminal*:3: Undefined word
12 dup >>>fred<<< dup
Backtrace:
$2A95B42A20 throw 
$2A95B57FB8 no.extensions 

エンター・キー(リターン・キー)を押すと、 テキスト・インタープリターが行に沿って動作を開始します:

• 2 の後のスペースに到達すると、 文字グループ 12 を取得し、 それらを名前ディクショナリーで検索します⁵。 名前ディクショナリにはこの文字グループに一致するものがないため、それらを数値として処理しようとし、 そして、 数値として処理するのは正常に実行できたので、 (それが何を意味するにせよ) 数値 12 を「スタック上」に置きます。
• テキスト・インタープリターは行のスキャンを再開し、 次の文字グループ ‘dup‘ を取得します。 ‘dup‘ を名前ディクショナリーで探し、 (これは著者の言葉を信じてもらうしかありませんが) ‘dup‘ を名前ディクショナリーで見付けて、 ワード dup を実行します(それが何を意味していても)。
• 更に再び、 テキスト・インタープリターは行のスキャンを再開し、 文字グループ fred を取得します。 名前ディクショナリーで調べますが、見つかりません。 それらを数値として扱おうとしますが、 正当な数値を表すものではありませんでした。

この時点で、 テキスト・インタープリターは諦めてエラー・メッセージを出力します。 エラー・メッセージには、 テキスト・インタープリターが行の処理でどこまで到達したかが正確に示されます。 これは、 特に、 テキスト・インタープリターが最後の文字グループ dup に対して何も行おうとしなかったことを示しています。 テキスト・インタプリタがそのワード dup を検索して、 一度はちゃんと実行されたのですから、 もう一度実行することに何の問題はないはずなのに、 です。

4.2 Stacks, postfix notation and parameter passing ¶

手続き型プログラミング言語(C や Pascal など)では、 プログラムの構成要素は関数(function)やプロシージャ(procedure)です。 これらの関数またはプロシージャは、 明示的なパラメーターを使用して呼び出されます。 たとえば、 C では以下のように記述できます:

total = total + new_volume(length,height,depth);

ここで、 new_volume は別のコード片への関数呼び出し(function-call)であり、 total, length, height, depth はすべて変数です。 length, height, depth は関数呼び出しのパラメーターです。

Forth では、 関数またはプロシージャに相当するのは「定義」(definition)であり、 パラメーターはプログラマから見える共有スタックを使用して定義間で暗黙的に渡されます。 Forth は変数をサポートしていますが、 スタックの存在は、 他のほとんどのプログラミング言語よりも変数が使用される頻度がはるかに低いことを意味します。 テキスト・インタープリターは数値を検出すると、 それをスタックに置きます(プッシュ)。 何種類かのスタックがあり(いくつあるかは実装依存です)、 操作に使用されるスタックは、 実行される操作によって明確に示されます。 すべての整数演算に使用されるスタックは「データ・スタック」と呼ばれ、 これが最も一般的に使用されるスタックであるため、 「データ・スタック」への参照は多くの場合「スタック」と省略されます。

スタックには後入れ先出し(last-in, first-out;LIFO)構成が採用されています。 以下のように打ち込むと:

1 2 3RET  ok

これはテキスト・インタープリターに 3 つの数値を (データ)スタック に配置するように指示します。 スタックの振る舞いはトランプの扱いに例えられます。 トランプの箱から、 (スートは何でもいいですが、) エース(1)のカードと2のカードと3のカードをテーブルの上の山に配ります。 3のカードは山の最後のカード (last-in)であり、 山からカードを 1 枚取ると、 あなたがシャッフルとか何もいじってない限り、 取り出すカードは 3のカードになります(first-out)。 スタックから最初に取り出されるであろう(スタック上の)数値はスタック頂上(スタック・トップ;top of stack)と呼ばれ、 多くの場合「TOS」と省略されます。

Forth でパラメーターがどのように渡されるかを理解するために、 定義 + (「プラス」と発音します) の振る舞いを見てみましょう。 あなたは、 この定義が加算を実行することを知っても驚かないでしょう。 より正確には、 これは 2 つの数値を加算して結果を生成します。 さて、 その 2 つの数値はどこから取得されるのでしょうか？ これはスタック頂上から上位 2 つの数値を取り除きます。 その結果はどこに配置されるのでしょうか？ それはスタックです。 あなたは以下のように、 トランプを使って + の振る舞いを演ずることができます。

• テーブル上の山(the steck)カードを 2 枚取り出します
• あなたは、 それらをじっと見つめて、 「これら 2 つの数字の合計は何であるか」を自問してください。
• 答えは 5 であると判明しました
• 2 枚のカードをシャッフルしてトランプの箱に戻し、 トランプの箱の中から 5のカード を見つけます
• テーブル上にある残りのエース(1)のカードの上に 5のカードを置きます。

トランプの箱はないですが、 Forth の実行中は、 定義 .s を使用して、 スタックに影響を与えることなく、 スタックの現在の状態を表示できます。 以下の様に打ち込みます:

clearstacks 1 2 3RET ok
.sRET <3> 1 2 3  ok

テキスト・インタープリターはワード clearstacks を検索して実行します。 スタック(データおよび浮動小数点スタック)を整理し、 以前の例の実行によってスタックに残された可能性のあるエントリをすべて削除します。 続けてテキスト・インタプリタは、 3 つの数値をそれぞれ順番にスタックにプッシュします。 最後に、 テキスト・インタープリターはワード .s を検索して実行します。 .s を実行すると、「<3>」 (スタック上の項目の合計数) に続いて、スタック上のすべての項目のリストが出力されます。 一番右側の項目が TOS です。

あなたは今や以下のように打ち込めます:

+ .sRET <2> 1 5  ok

現在スタックには 2 つの項目があり、 (そのうちの項目の1つである)加算の結果は 5 となっていれば正解です。

あなたが引き続きトランプで遊んでいるなら、 この結果に対して 2 回目の足し算を行ってみましょう。 2 枚のカードを手に取り、 その合計が 6 であることを計算し、手に取った2枚のカードをシャッフルして箱に入れ、 箱から 6のカード を探してテーブルに置きます。 これで、 スタックにはアイテムが 1 つだけになりました。 あなたが 3 回目の足し算を実行しようとするとどうなるでしょうか？ あなたは、 1枚目のカードを手に取り、 2枚目のカードを手に取ろうとします – ああ! でも 2枚目のカードはありません。 これは「スタック・アンダーフロー」と呼ばれ、エラーとなります。 Forth で同じことを行おうとすると、 多くの場合、 エラーが報告されます(おそらく、 スタック・アンダーフロー(Stack Underflow)エラー、 または、 無効なメモリーアクセス(Invalid Memory Address)エラー)。

スタック・アンダーフローの逆の状況が「スタック・オーバーフロー」です。 これは、 あなたがたが、 スタック用に予約されている有限量のストレージ・スペースがあることを単に受け入れるだけで済みます。 トランプの例えを拡張すると、 沢山の数のトランプのカードがあり、 それらのカードをテーブルに積み上げた場合、 天井にぶつかってしまい、 最終的には別のカードを追加できなくなります。 Gforth を使用すると、 スタックの最大サイズを設定できます。 一般に、 スタック・オーバーフローが発生するのは、 定義にバグがあり、 制御不能にスタック上にデータを生成している場合のみです。

トランプの例えには、 最後にもう 1 つ適用例があります。 トランプを使用してスタックをモデル化した場合、 スタック上のアイテムの最大数は 52 になります(ジョーカーを使用しなかったと仮定して)。 スタック上のアイテムの最大値は13(キング)です。 実際は、 使用できる数値は 1 ～ 13 の正の整数のみ(つまり、 13個の数)です。 (たとえば) 0や27や3.52や-2は使用できません。 そこで、 一部のカードについて考え方を変え、 さまざまな数値に対応できるようにします。 たとえば、ジャックは 0 を表し、 クイーンは -1 を表し、 キングは -2 を表すと見なします。 すると、 表現できる数値の幅は変更されません(合計 13 個の数値のみを表すことができます)が、 -2 から 10 の数値を表す事ができるようになりました。

この例えでは、 制限は 1 つのスタック・エントリが保持できる情報の量であり、 Forth にも同様の制限があります。 Forth では、 スタック・エントリのサイズは「セル」(cell)と呼ばれます。 セルの実際のサイズは実装に依存し、 スタック・エントリが保持できる最大値に影響します。 標準 Forth は少なくとも 16 ビットのセル・サイズを提供し、 ほとんどのデスクトップ・システムは 32 ビットのセル・サイズを使用します。

Forth は型チェックを一切行わないため、 スタック項目を自由に操作したり組み合わせたりできます。 スタック項目を 2 の補数の符号付き整数として扱う便利な方法は、 + などの標準ワードもやっています。 それゆえ、 以下のように入力できます:

-5 12 + .sRET <1> 7  ok

あなたが、 Forth を電卓にするために、 数値や + のような定義を使用すると、 それが通常の電卓とはかなり異なることがわかるでしょう。 あなたは 2 + 3 = と入力するのではなく、 2 3 + と入力する必要があります(ここでは、 結果を確認するには .s を使用する必要があるという事実は無視してください)。 この違いを説明するために使用される用語は、 電卓は「中置記法」(Infix Notation;パラメーターと演算子が混合されている)を使用するのに対し、 Forth は「後置記法」(Postfix Notation;パラメーターと演算子が分かれている)、 またの名を「逆ポーランド記法」(Reverse Polish Notation)と呼ばれるものを使用します。

後置記法は最初はわかりにくいように見えるかもしれませんが、 いくつかの重要な利点があります:

• 明白です
• より簡潔です
• スタックベースのシステムに自然に適合します

これらの主張をさらに詳しく調べるために、 以下の計算について見てみましょう:

6 + 5 * 4 =
4 * 5 + 6 =

あなたが、算数を勉強中の場合、 または算数が非常に苦手な場合は、 最初の答えは 44、 2 番目の答えは 26 になるでしょう。 あなたが算数に少し詳しい人なら、 乗算は加算よりも優先されるという法則を覚えているでしょう。 そして、 どちらの場合も答えは 26 になるでしょう。 答え 44 だと言った人に、 なぜ答えが 26 かを説明するには、 最初の計算を以下のように書き換えることになるでしょう:

6 + (5 * 4) =

あなたが、 もし、 乗算より優先して加算を実行したい場合は、 かっこを使用して強制的に加算させる必要があります。

上記 2 つの計算を電卓で計算する場合、 以下のキーストローク・シーケンスを使用して、 入力ミスしない限り、 おそらく正しい答えが得られるでしょう:

6 + 5 = * 4 =
4 * 5 = + 6 =

Postfix notation is unambiguous because the order that the operators are applied is always explicit; that also means that parentheses are never required後置記法では演算子が適用される順序は常に明示的です。 これは、 括弧が決して必要ないことも意味します。 演算子はアクティブです(演算子を引用する行為によって演算操作が実行されます)。 これにより、「=」が必要なくなります。

計算 6 + 5 * 4 は、 以下の 2 つの同等の方法で(後置表記で)書くことができます:

6 5 4 * +
または:
5 4 * 6 +

この表記法に関して注意すべき重要な点は、 数値の順番は変わらないことです。 10 から 2 を減算する場合は、 10 2 - と入力します。

Forth が後置表記を使用する理由は非常に簡単に説明できます。 これにより実装が非常に単純になり、 パラメーターを渡すためのメカニズムとしてスタックを使用することが自然な流れになります。 これについての別の考え方としては、 すべての Forth 定義がアクティブであると認識することです。 これらは、 テキスト・インタープリターによって検出されると実行されます。 この結果、 Forth の構文は何の努力も必要とせずシンプルになります。

4.3 Your first Forth definition ¶

これまで私たちが見てきた例はこまごまとしたものでした。 私たちは Forth を大きめの電卓として使用してきました。 また、 これまでに示した各計算は「1 回限り」のものです – それを繰り返すには、もう一度入力する必要があります⁶。 このセクションでは、 Forth の語彙(vocabulary)に新しいワードを追加する方法を説明します。

新しいワードを作成する最も簡単な方法は、「コロン定義」を使用することです。 それらがどのように機能するかについて思い悩む前に、 いくつか定義して試してみましょう。 以下の例を入力してみてください。 スペースを正確に反映するように注意してください:

: add-two 2 + . ;
: greet ." Hello and welcome" ;
: demo 5 add-two ;

この例を打ち込んだら、 すぐ試してみましょう:

greetRET Hello and welcome  ok
greet greetRET Hello and welcomeHello and welcome  ok
4 add-twoRET 6  ok
demoRET 7  ok
9 greet demo add-twoRET Hello and welcome7 11  ok

ここで導入した最初の新しいモノは、 : と ; というワードのペアです。 これらは、それぞれ新しい定義を開始および終了するために使用されます。 : の後の最初の単語(word)は、 新しい定義の名前です。

例からわかるように、 定義はすでに定義されているワードから構成されます。 Forth では、 システムの起動時に存在した定義と、 ユーザーが自分で定義した定義とを区別しません。

この例では、 . (ドット) や、 ." (ドット・クォート)や、 dup (デュープ) というワードも紹介しています。 ドットはスタック頂上から数詞を取得して表示します。 これは .s に似ていますが、 スタック頂上の項目のみを表示する点と破壊的である点が異なります。 実行後、スタック上にその数値は最早ありません。 数値の前はスペース無しで、 後ろには常に 1 つのスペースが表示されます。 ドット・クォートは、 ワードの実行時に出力される文字列(string)を定義します。 文字列には、 " を除く任意の印刷可能な文字を含めることができます。 " には特別な機能があります。 これは Forth ワードではありませんが、 区切り文字として機能します(区切り文字の仕組みについては次のセクションで説明します)。 最後に、 dup はスタック頂上の値を複製します。 5 dup .s と入力して、 dup がやることを確認してください。

あなたは、 既に、 テキスト・インタープリターが名前を見つけるためにディクショナリーを検索することを知っています。 あなたが上記の例の通りにした場合、 add-two という定義がすでにあるはずです。 それでは、 この定義に対して、 更に新しい定義を入力して変更してみるとしましょう:

: add-two dup . ." + 2 = " 2 + . ;RET redefined add-two  ok

Forth は、私たちがすでに存在するワードを定義しようとしていることを認識し、 それを警告するメッセージを出力しました。 さて、 それでは、 新しい定義を試してみましょう:

9 add-twoRET 9 + 2 = 11  ok

ただし、 ここで実際に行ったことは、 特定の名前を付けて新しい定義を作成することだけです。 同一の名前の定義がすでに存在するという事実は、 (Forth が警告メッセージを出力することを除いて、)新しい定義の作成方法に何の違いもありません。 add-two の古い定義はいまだ存在します(これが正しいかどうかを確認するには、 demo をもう一度試してください)。 add-two の新しい定義以降に定義するワードは add-two の新しい定義を利用しますが、 demo の定義は、 古い定義は demo をコンパイルする時点で既に存在していた add-two の古い定義のバージョンを引き続き使用します。

次のセクションに進む前に、 あなた自身のワードをいくつか定義したり再定義したりしてみましょう。

4.4 How does that work? ¶

ここで、 前のセクションの add-two の定義をもう一度見てみましょう。 テキスト・インタープリターの動作方法に関する知識から、 add-two を定義しようとしたとき、 私達は以下の結果を予期したかもしれません:

: add-two 2 + . ;RET
*the terminal*:4: Undefined word
: >>>add-two<<< 2 + . ;

しかし、 これが起こらなかった理由は、 : の動作方法に関係しています。 : というワードは 2 つの特別な働きをします。 1つ目の特別な機能は、 テキスト・インタープリターが add-two という文字を認識できないようにすることです。 テキスト・インタープリターは、 >IN (to-in;トゥーイン)という変数を使用して、 入力行のどこを追跡するかを保持し、 : というワードに遭遇すると、 他のワードの場合とまったく同じように動作します。 名前ディクショナリーでそれを検索し、 その xt を見つけて実行します。 実行される : は、 入力バッファーを調べてワード add-two を見つけ、 >IN の値をその後ろを指すように進めておきます。 次に、 新しい定義の作成に関連するその他の処理を実行します(名前ディクショナリーに add-two のエントリを作成する等)。 : の実行が完了すると、 制御はテキスト・インタープリターに戻ります。 テキスト・インタープリターは、 このトリックにより入力行の一部をスキップしていることに気づきません。

: のようなワード(>IN の値を進めて、 テキスト・インタープリターが入力行全体に作用するのを妨げるワード)は、 「構文解析ワード」(parsing words)と呼ばれます。

: が行う 2 つ目の特別な処理は、 state と呼ばれる変数の値を変更することです。 これは、 テキスト・インタープリターの振る舞いに影響します。 Gforth が起動するとき、 state の値は 0 であり、 テキスト・インタープリターはインタープリター状態(interpreting)であると言われます。 (: で始まる)コロン定義中 、 state は -1 に設定され、テキスト・インタープリターはコンパイル状態(compiling)と言われます。

この例では、 テキスト・インタープリターは文字列 “2 + . ;”。引き続き同じ方法で文字列を文字シーケンスに分割します。ただし、数値 2 をスタックにプッシュする代わりに、 数値 2 を取得する魔法を add-two の定義に組み込み(コンパイル)、 add-two が「実行」されたときスタックにプッシュされます。 同様に、 + と . の振る舞いも定義にコンパイルされます。

特定の種類のワードはコンパイルされません。 これらのいわゆる「即実行ワード」(immediate word)は、 テキスト・インタープリターがインタープリター状態であるかコンパイル状態であるかに関係なく、 実行されます(今、 直ちに実行されます)。 ; というワードは即実行ワードです。 定義にコンパイルされるのではなく、 実行されます。 その効果は、 state の値を 0 に戻すことを含む、 現在の定義を終了することです。

あなたが add-two を実行すると、 その定義の外で 2 + . RET と入力した場合とまったく同一の「実行時効果」(run-time effect) が生じます。

Forth では、 すべてのワードまたは数値は以下の 2 つの性質を持ちます:

• その インタープリター機能(interpretation semantics)は、 テキスト・インタープリターがインタープリター状態でどのように動作するかを記述します。 ワードのインタープリター機能は、 その「実行トークン」(execution token)(see Execution token)によって表されます。
• その コンパイル機能(compilation semantics)は、 テキスト・インタープリターがコンパイル状態でどのように動作するかを記述します。 ワードのコンパイル機能は、 その「コンパイル・トークン」(see Compilation token)によって表されます。

数値は常に決まった方法で処理されます:

• その数値が通訳(interpret)される場合、 その振る舞いは、 その数値をスタックにプッシュすることです。
• その数値がコンパイルされる場合、 実行時にその数値をプッシュするコードが現在の定義に追加されます。 (言い換えれば、 数値のコンパイル機能(compilation semantics)は、 コンパイルされる定義の実行時まで、 その数値のインタープリター機能(interpretation semantics)の実行を延期(postpone)します。)

ワードは常にこのような通常の振る舞いをするとは限りませんが、 ほとんどのワードにはデフォルトの機能(default semantics)があり、 以下のように振る舞うことを意味します:

• ワードのインタープリター機能(interpretation semantics)は、 何かしら役に立つことを行うことです。
• ワードのコンパイル機能(compilation semantics)は、 そのワードのインタープリター機能(interpretation semantics)を現在の定義に追加します(よって、 それは実行時に何かしら役に立つことを行います)。

特定のワードの実際の振る舞いは、 ワードの定義時に immediate や compile-only というワードを使用することで制御できます。 これらのワードは、 最後に定義されたワードの名前ディクショナリー・エントリにフラグを設定します。 これらのフラグは、 名前ディクショナリーでワードが見つかったときにテキスト・インタープリターによって取得されます。

immediate としてマークされたワードは、 そのインタープリター機能(interpretation semantics)と同じコンパイル機能(compilation semantics)を持ちます。 つまり、 以下のように振る舞います:

• ワードのインタープリター機能(interpretation semantics)は、 何かしら役に立つことを行うことです。
• このワードのコンパイル機能(compilation semantics)は、 何かしら役に立つことを行うことです(実際にはインタープリター機能と同一のことを行うことです)。 つまり、 このワードのコンパイル機能はコンパイル中に実行されます。

ワードを compile-only としてマークすると、 インタープリター状態(interpretation state)でこのワードを検出したときにテキスト・インタープリターが警告を生成することを意味します。 (' または ['] を使用して) ワードをティックすると、 警告が生成されます。

compile-only を使用する必要はありません(多くの実装によって提供されてはいますが、 標準 Forth の一部でもありません)が、 インタープリター態(interpret state)で正しく振る舞わないワードに compile-only を適用するのは良いエチケットです(そして予期しない副作用が発生する可能性があります)。 たとえば、 定義内で条件ワード IF を使用することのみが正当です。 これを忘れて別の場所で使用しようとすると、 (Gforth では) compile-only としてマークされているため、 テキスト・インタープリターが有用な警告を生成できます。

以下の例は、 即実行ワードと非即実行ワードの違いを示しています:

: show-state state @ . ;
: show-state-now show-state ; immediate
: word1 show-state ;
: word2 show-state-now ;

show-state-now の定義の後にあるワード immediate は、そのワードを即実行ワードにします。 これらの定義では、 @(「フェッチ」と発音します) という新しいワードが導入されています。 このワードは変数の値を取り出し(フェッチし)、 それをスタックに残します。 したがって、 show-state の振る舞いは、 state の現在の値を表す数値を出力することです。

word1 を実行すると、 システムがインタープリター状態であることを示す数値 0 が出力されます。 テキスト・インタープリターが word1 の定義をコンパイルしたときに、 コンパイル機能が現在の定義に実行時コードを追加する show-state に遭遇しました。 word1 を実行すると、 show-state のインタプリタ機能(interpretation semantics)が実行されます。 word1 (つまり show-state) が実行される時点で、 システムはインタープリター状態です。

word2 の定義を入力した後に RET を押すと、 数値 -1 が出力され、 その後に ok が表示されるはずです。 テキスト・インタープリターが word2 の定義をコンパイルすると、 即実行ワードである show-state-now が検出されたため、 そのコンパイル機能(compilation semantics)はインタプリタ機能(interpretation semantics)を実行します。 これは直ちにに実行されます(テキスト・インタープリターが次の文字グループ(この例では ;)の処理に移る前に)。 これを実行すると、 word2 の定義途中の state の値が表示されます。 -1 を出力するので、 システムがその時点でコンパイル状態であることがわかります。 もし あなたが word2 を「実行」しても何も行いません。

即実行ワードの話題を離れる前に、 前のセクションの greet の定義における ." の振る舞いについて検討してみましょう。 このワードは構文解析ワード(parsing word)でもあり、 かつ、 即実行ワードでもあります。 ." とそのテキストの先頭 Hello and welcome の間にはスペースがありますが、 welcome の最後の文字と " 文字の間にはスペースがありません。 これは、." が Forth ワードであるということです。 テキスト・インタープリターがその Forth ワード ." を識別できるように、 ." の後ろにスペースが必要です。 " は Forth ワードではなく、 区切り文字(delimiter)です。 先の例では、 文字列が表示されるときに、 H の前にも e の後ろにもスペースがないことを示しています。 ." は即実行ワードなので、 greet の定義中に実行されます。 実行されると、 入力行内を前方に走査して区切り文字を探します。 区切り文字が見つかると、 区切り文字の後ろを指すように >IN を更新します。 また、 いくつかのマジック・コード、 つまりテキスト文字列を出力する実行時コード xtを greet の定義にコンパイルします。 文字列 Hello and welcome をメモリーにコンパイルして、 後で出力できるようにします。 その後、 テキスト・インタープリターが制御を取得すると、 入力ストリーム内で次に検出されるワードは ; であるため、 greet の定義を終了します。

4.5 Forth is written in Forth ¶

あなたが Forth コンパイラーを起動すると、 すでに多数の定義が存在しています。 Forth では、 ボトムアップ・プログラミング手法を使って新しいアプリケーションを開発し、 既存の定義に基づいて定義される新しい定義を作成します。 作成した各定義は、 対話的にテストおよびデバッグできます。

この章の例を試したことがあるなら、 あなたは、それらをおそらく手動で入力したことがあるでしょう。 Gforth を終了すると、 あなたが定義したモノは失われてしまいます。 これを回避するには、 テキスト・エディタを使用して Forth ソース・コードをファイルに入力し、 include を使用してファイルからコードをロードします(see Forth source files)。 Forth のソース・ファイルは、 あたかも手入力したかのように、 テキスト・インタープリターによって処理されます⁷。

Gforth は、 プログラム入力 にテキスト・ファイルを使用する、 伝統的な Forth の代替手段もサポートしています(see Blocks)。

ほとんどというほどではないにしても、 多くの Forth コンパイラーと共通して、 Gforth のほとんどは実際には Forth で書かれています。 インストール・ディレクトリ⁸内のすべての .fs ファイルは Forth ソース・ファイルであり、 あなたは それらを Forth プログラミングの例として拝んで学ぶことができます。

Gforth は、 テキスト・インタープリターに入力したすべての行を記録する履歴(history)ファイルを維持します。 このファイルはセッションをまたいで維持され、 コマンドラインの呼び出し機能を提供するために使用されます。 長い定義を手動で入力した場合は、 テキスト・エディターを使用して履歴ファイルから後で再利用するために Forth ソース・ファイルに貼り付けることができます(詳細については see Command-line editing)。

4.6 Review - elements of a Forth system ¶

この章を要約すると:

• Forth プログラムはファクタリングを使用して、 問題を「ワード」または「定義」と呼ばれる小さな断片に分割します。
• Forth プログラムの開発は対話型のプロセスです。
• 入力を受け付け、 通訳(interpret)とコンパイルの両方を制御するメイン・コマンド・ループは、「テキスト・インタープリター」と呼ばれます(外部インタープリターとも呼ばれます)。
• Forth の構文は非常に単純で、 スペースまたは改行文字で区切られた単語(word)と数値で構成されます。 追加の構文は構文解析ワード(parsing words)によります。
• Forth はスタックを使用してワード間でパラメーターを渡します。 その結果、 後置記法が使用されます。
• 以前に定義されたワードを使用するために、 テキスト・インタープリターは「名前ディクショナリ」でそのワードを探します。
• ワードはインタープリター機能(interpretation semantics)とコンパイル機能(compilation semantics)を持っています。
• テキスト・インタープリターは、 state の値を使用して、 探し出したワードのインタプリタ機能(interpretation semantics)を使用するかコンパイル機能(compilation semantics)を使用するかを選択します。
• ワードのインタープリター機能(interpretation semantics)とコンパイル機能(compilation semantics)の関係は、 そのワードが定義された方法(たとえば、 それが「即実行ワード」(immediate word)であるかどうか)によって異なります。
• Forth 定義は、 Forth で実装(「高レベル定義」と呼ばれます)、 または、 その他のいくつかの方法(通常は低レベル言語で、 「低レベル定義」、「コード定義」、「プリミティブ」と呼ばれる事もある)で実装できます。
• 多くの Forth システムは主に Forth で記述されています。

4.7 Where To Go Next ¶

信じられないかもしれませんが、 あなたがここまで読んで(そして理解していれば)、 Forth システムの内部動作についての基本をほぼすべて知っていることになります。 あなたは今や確実に、 このマニュアルの残りの部分と標準 Forth ドキュメントを読んで理解し、 Forthの一般的な機能と、 特に Gforth が提供する機能について詳しく学ぶのに十分な知識を持っています。 更に恐るべきことに、 あなたは独自の Forth システムを実装するのにほぼ十分な知識を持っていますが、 独自の Forth システムを実装するには時期尚早かもしれません。 その前に、 あなたは Gforth でいくつかのプログラムを書いてみたほうがいいでしょう。

Forth には非常に豊富な語彙があるため、 学ぶにも、 どこから手を付ければいいかわからない場合があります。 このセクションでは、 小さいながらも有用なプログラムを作成するのに十分なワードのセットをいくつか提案します。 このドキュメントのワード索引を使用して各ワードについて詳しく学び、 それを試して、 それを使用して簡単な定義を書いてみてください。 まずは以下のワード達を試してみてください:

• 算術演算: + - * / /MOD */ ABS INVERT
• 比較: MIN MAX =
• 論理演算: AND OR XOR NOT
• スタック操作: DUP DROP SWAP OVER
• ループと条件判断: IF ELSE ENDIF ?DO I LOOP
• 入出力: . ." EMIT CR KEY
• 定義ワード: : ; CREATE
• メモリー割り当てワード: ALLOT ,
• ツール: SEE WORDS .S MARKER

上記をマスターできたら、 以下に進みましょう:

• さらなる 定義ワード いくつか: VARIABLE CONSTANT VALUE TO CREATE DOES>
• メモリー・アクセス: @ !

これらをマスターしたら、 あなたは、 このマニュアルのすべてに目を通し、 あなたのプログラムに欠けているものを探し出す必要があります。

4.8 Exercises ¶

TODO: すでに完了した内容やマニュアルの他のセクションにリンクされた一連のプログラミング演習を提供したい。 すべての演習に対する回答を、 ディストリビューション内の .fs ファイルで提供するようにしたいです。

6.1 Notation ¶

Forth のワードは、 以下にあるように、 Forth テキストのデファクトスタンダード(事実上の標準)となっている表記にて説明されます:

word     Stack effect   wordset   pronunciation

Description

word

ワード名。

Stack effect ¶

スタック効果(stack effect)は、 before -- after という表記で記述されます。 ここで、before と after は、 ワード実行前と実行後のスタック・エントリの頂上部を表します。 スタックの残りの部分にはワードは触れません。 スタックの頂上は右端です。 つまり、 スタック・シーケンスはあなたが入力したとおりに書き込まれます。 注意: Gforth は別個の浮動小数点スタックを使用しますが、 統一されたスタック表記法を使用することに注意してください。 また、 リターンスタック効果は「スタック効果」には表示されませんが、 「説明」(Description)に表示されます。 スタック項目の名前は、 項目の型や機能を説明します。 型の説明については、 下記を参照してください。

すべてのワードには、 コンパイル・モードのスタック効果とインタープリター・モードのスタック効果という 2 つのスタック効果があります。 ほとんどのワードのコンパイル・モードのスタック効果は – です。 ワードのコンパイル・モードのスタック効果がこの標準の振る舞いから逸脱している場合、 またはワードがコンパイル・モードに他の通常でない振る舞いを行う場合、 両方のスタック効果が表示されます。 それ以外の場合、 インタープリター・モードのスタック効果のみが表示されます。

また、 コード・テンプレートまたはサンプルでは、​​ その時点でのスタックの状態表示するコメントが括弧内にある場合があることにも注意してください。 これらのスタックの状態表示には -- はありません。 なぜなら前・後という状況が無いためです。

pronunciation ¶

ワードの発音

wordset ¶

ワードセット(wordset)は、 ワードが標準化されたものか、 または環境クエリ文字列であるか、 または Gforth 固有のワードであるかを指定します。 Gforth 固有のワードの場合、 ワードセット名には文字列 gforth が含まれており、 他のワードセット名は environment または標準のワードセット(standard word sets)を参照します。

Forth 標準はいくつかのワードセットに分かれています。 理論上、 標準システムはそれらすべてをサポートする必要はありませんが、 実際には、 組み込み用途な超小型のマシン以外の本格的なシステムは、 ほぼすべての標準化されたワードをサポートします(ただし、一部のシステムでは一部のワードセットを明示的にロードする必要があります)。 そのため、 実際のところはワードセットの使用をケチったところでその分移植性が上がる訳ではありません。

Gforth 固有のワードについては、 以下のカテゴリがあります:

gforth

gforth-<version>

我々はこのワードを Gforth で永続的にサポートするつもりであり、 Gforth <version> 以降で有効です(おそらくその <version> 時点ではサポートされていないワードです)。

gforth-experimental

このワードは現在のバージョンで使用できますが、 永続的なワードになるか、 Gforth の将来のリリースで削除されるか分かりません。 あなたのフィードバックをお待ちしています。

gforth-internal

このワードは内部用であり、 サポート対象のワードではないため、 Gforth の将来のリリースでは削除される可能性があります。

gforth-obsolete

このワードは、 Gforth の将来のリリースでは削除される予定です。

Description

そのワードの振る舞いを説明します。

スタック項目の型は、 以下のように、 スタック項目名のはじめの文字が何であるかによって指定されます:

f ¶

二値フラグ(Boolean flags)。 つまり false または true

c ¶

Char

w ¶

セル。 整数(an integer)やアドレス(an address)も格納可能。

n ¶

符号付き整数

u ¶

符号なし整数

d ¶

符号付き2倍長整数

ud ¶

符号無し2倍長整数

r ¶

浮動小数点数(Float)(FP スタック上に置かれる)

a- ¶

セル・アライメント・アドレス

c- ¶

文字(char)アライメント・アドレス(注意: Windows NT では文字(char)は 2 バイトになる場合があることに注意)

f- ¶

浮動小数点数アライメントのアドレス

df- ¶

IEEE倍精度浮動小数点数アライメントのアドレス

sf- ¶

IEEE単精度浮動小数点数アライメントのアドレス

xt ¶

実行トークン(Execution token)。 セルと同一サイズ

wid ¶

ワード・リストID。セルと同一サイズ

ior, wior ¶

セルサイズの入出力結果コード。 Gforth では iors を throw できます。

f83name ¶

名前構造体へのポインター

" ¶

(スタック上ではなく、)入力ストリーム内の文字列。 終端文字はデフォルトでは空白(a blank)です。 終端文字が空白でない場合は、 <> でクォートして表示します。

6.2 Case insensitivity ¶

Gforth では英大文字小文字を区別しません(case-insensitive)。 大文字、 小文字、 または大文字と小文字の混合を使用して、 定義を入力したり標準のワードを呼び出したりできます(ただし、 こちらも参照ください see Implementation-defined options)

標準 Forth では、 標準のワードが完全に大文字で入力された場合にのみ実装が認識する必要があります。 したがって、 標準のプログラムでは、 すべての標準ワードに大文字を使用する必要があります。 あなたの定義したワードには大文字と小文字を自由に使用できますが、 標準のプログラムでは、 ワードを定義したときと同じ大文字と小文字で使用する必要があります。

Gforth は、 cs-wordlist (英大文字小文字を区別する(case-sensitive)ワード・リスト see Word Lists) を通じて英大文字小文字の区別をサポートします。

何人かは Gforth を英大文字小文字を区別する(case-sensitive)ように変換する方法を質問しました。 これは悪い考え(bad idea)だとは思いますが、 すべてのワードリストを以下のようなテーブルに変更できます:

' table-find forth-wordlist wordlist-map  !

注意: このように、 Gforth を英大文字小文字を区別する(case-sensitive)ように変換した場合、 定義済みのワードは、 定義したときと同一の大文字と小文字の組み合わせで入力する必要があることに注意してください。 大文字と小文字は異なります。 この操作を実行する前に、 それらをあなた好みの大文字と小文字の組み合わせに変換するとよいでしょう(その方法については説明しません。 Gforth を英大文字小文字を区別する(case-sensitive)ように変換することを実行することを検討している場合でも、 すでに定義済みワードのワード名をあなた好みの大文字と小文字の組み合わせに変換するその方法を知っているくらいの Forth システムの知識があったほうがよいと思います)。

6.3 Comments ¶

Fors は 2 つのスタイルのコメントをサポートしています。 従来の行中コメントである ( と、 その現代的な親戚である、 行末までのコメント \ です。

( ( compilation ’ccc<close-paren>’ – ; run-time –  ) core,file “paren”

通常は次の ) までがコメントです。 「)」 が見つかるまで、 パース領域内の後続の文字をすべてパースして破棄します。 対話入力中は、 行末はコメント終了文字としても機能します。 ただし、 ファイル入力の場合はそうではありませんので、 「)」区切り文字のパース中にファイルの終わりに遭遇すると、 Gforth は警告を出します。

\ ( compilation ’ccc<newline>’ – ; run-time –  ) core-ext,block-ext “backslash”

行末までがコメントです。 ブロックからのロード中を除き、 パース領域内の残りの文字をすべてパースして破棄します。 ブロックからのロード中は、 1行64バイトと見なすので、 その 64 バイト行の残りの文字をすべてパースして破棄します。

\G ( compilation ’ccc<newline>’ – ; run-time –  ) gforth-0.2 “backslash-gee”

\ と同等ですが、 ドキュメントの定義コメントに注釈(annotate)を付けるためのタグとして使用されます。

6.4 Boolean Flags ¶

ブール値フラグはセル・サイズです。 すべてのビットがクリアされているセルはフラグ false を表し、 すべてのビットがセットされているセルはフラグ true を表します。 フラグをチェックするワード (IF など) は、 セルの任意のビットがセットされているものを true として扱います。

true ( – f  ) core-ext “true”

定数 – f は全てのビットがセットされたセルです。

false ( – f  ) core-ext “false”

定数 – f は全てのビットがクリアされたセルです。

on ( a-addr –  ) gforth-0.2 “on”

指定の a-addr の変数の値を true にセットする。

off ( a-addr –  ) gforth-0.2 “off”

指定の a-addr の変数の値を false にセットする。

select ( u1 u2 f – u ) gforth-1.0 “select”

f が false なら u2 を u として返し、 そうでなければ u1 を u として返す。

6.5 Arithmetic ¶

Forth の算術演算はチェックを行いません。 つまり、 加算または乗算での整数のオーバーフローについては問い詰められませんが、 運が良ければゼロによる除算については問い詰められることができるかもしれません。 演算子はオペランドの後に記述されますが、 オペランドは元の順序のままです。 つまり、 中置記法での 2-1 は 2 1 - に対応します。 Forth はさまざまな除算演算子を提供します。 あなたが、 潜在的に負になりうるオペランドを使用して除算を実行する場合、 実装により振る舞いが異なる / や /mod を使用せず、 たとえば、 /f や /modf や fm/mod を使用します(see Integer division)。

+ ( n1 n2 – n ) core “plus”

1+ ( n1 – n2 ) core “one-plus”

under+ ( n1 n2 n3 – n n2 ) gforth-0.3 “under-plus”

- ( n1 n2 – n ) core “minus”

1- ( n1 – n2 ) core “one-minus”

* ( n1 n2 – n ) core “star”

negate ( n1 – n2 ) core “negate”

abs ( n – u ) core “abs”

min ( n1 n2 – n ) core “min”

max ( n1 n2 – n ) core “max”

umin ( u1 u2 – u ) gforth-0.5 “umin”

umax ( u1 u2 – u ) gforth-1.0 “umax”

s>d ( n – d  ) core “s-to-d”

d>s ( d – n  ) double “d-to-s”

d+ ( ud1 ud2 – ud ) double “d-plus”

d- ( d1 d2 – d ) double “d-minus”

dnegate ( d1 – d2 ) double “d-negate”

dabs ( d – ud  ) double “d-abs”

dmin ( d1 d2 – d  ) double “d-min”

dmax ( d1 d2 – d  ) double “d-max”

m+ ( d1 n – d2 ) double “m-plus”

m* ( n1 n2 – d ) core “m-star”

um* ( u1 u2 – ud ) core “u-m-star”

                      floored          symmetric
割られる  割る数      余り 商            余り 商
    10      7           3   1              3   1
   -10      7           4  -2             -3  -1
    10     -7          -4  -2              3  -1
   -10     -7          -3   1             -3   1

/ ( n1 n2 – n  ) core “slash”

/s ( n1 n2 – n ) gforth-1.0 “slash-s”

/f ( n1 n2 – n ) gforth-1.0 “slash-f”

u/ ( u1 u2 – u ) gforth-1.0 “u-slash”

mod ( n1 n2 – n  ) core “mod”

mods ( n1 n2 – n ) gforth-1.0 “mod-s”

modf ( n1 n2 – n ) gforth-1.0 “modf”

umod ( u1 u2 – u ) gforth-1.0 “umod”

/mod ( n1 n2 – n3 n4  ) core “slash-mod”

/mods ( n1 n2 – n3 n4 ) gforth-1.0 “slash-mod-s”

/modf ( n1 n2 – n3 n4 ) gforth-1.0 “slash-mod-f”

u/mod ( u1 u2 – u3 u4 ) gforth-1.0 “u-slash-mod”

fm/mod ( d1 n1 – n2 n3 ) core “f-m-slash-mod”

sm/rem ( d1 n1 – n2 n3 ) core “s-m-slash-rem”

um/mod ( ud u1 – u2 u3 ) core “u-m-slash-mod”

du/mod ( d u – n u1 ) gforth-1.0 “du-slash-mod”

*/ ( ( n1 n2 n3 – n4  ) core “star-slash”

*/s ( n1 n2 n3 – n4 ) gforth-1.0 “star-slash-s”

*/f ( n1 n2 n3 – n4 ) gforth-1.0 “star-slash-f”

u*/ ( u1 u2 u3 – u4 ) gforth-1.0 “u-star-slash”

*/mod ( n1 n2 n3 – n4 n5  ) core “star-slash-mod”

*/mods ( n1 n2 n3 – n4 n5 ) gforth-1.0 “star-slash-mod-s”

*/modf ( n1 n2 n3 – n4 n5 ) gforth-1.0 “star-slash-mod-f”

u*/mod ( u1 u2 u3 – u4 u5 ) gforth-1.0 “u-star-slash-mod”

ud/mod ( ud1 u2 – urem udquot  ) gforth-0.2 “ud/mod”

m*/ ( d1 n2 u3 – dquot  ) double “m-star-slash”

: array/ ( addr u n -- )
  -rot cells bounds u+do
    i @ over / i !
  1 cells +loop
  drop ;

: array/ ( addr u n -- )
  {: | reci[ staged/-size ] :}
  reci[ /f-stage1m
  cells bounds u+do
    i @ reci[ /f-stage2m i !
  1 cells +loop ;

staged/-size ( – u  ) gforth-1.0 “staged-slash-size”

/f-stage1m ( n addr-reci –  ) gforth-1.0 “slash-f-stage1m”

/f-stage2m ( n1 a-reci – nquotient ) gforth-1.0 “slash-f-stage2m”

modf-stage2m ( n1 a-reci – umodulus ) gforth-1.0 “mod-f-stage2m”

/modf-stage2m ( n1 a-reci – umodulus nquotient ) gforth-1.0 “slash-mod-f-stage2m”

u/-stage1m ( u addr-reci –  ) gforth-1.0 “u-slash-stage1m”

u/-stage2m ( u1 a-reci – uquotient ) gforth-1.0 “u-slash-stage2m”

umod-stage2m ( u1 a-reci – umodulus ) gforth-1.0 “u-mod-stage2m”

u/mod-stage2m ( u1 a-reci – umodulus uquotient ) gforth-1.0 “u-slash-mod-stage2m”

staged/-divisor ( addr1 – addr2  ) gforth-1.0 “staged-slash-divisor”

intel Skylake       AMD Zen2
norm stg2           norm stg2
41.3 15.8 u/        35.2 21.4 u/
39.8 19.7 umod      36.9 25.8 umod
44.0 25.3 u/mod     43.0 33.9 u/mod
48.7 16.9 /f        36.2 22.5 /f
47.9 20.5 modf      37.9 27.1 modf
53.0 24.6 /modf     45.8 35.4 /modf
    227.2 u/stage1      101.9 u/stage1
    159.8 /fstage1       97.7 /fstage1

and ( w1 w2 – w ) core “and”

or ( w1 w2 – w ) core “or”

xor ( w1 w2 – w ) core “x-or”

invert ( w1 – w2 ) core “invert”

mux ( u1 u2 u3 – u ) gforth-1.0 “mux”

lshift ( u1 u – u2 ) core “l-shift”

rshift ( u1 u – u2 ) core “r-shift”

arshift ( n1 u – n2 ) gforth-1.0 “ar-shift”

dlshift ( ud1 u – ud2 ) gforth-1.0 “dlshift”

drshift ( ud1 u – ud2 ) gforth-1.0 “drshift”

darshift ( d1 u – d2 ) gforth-1.0 “darshift”

2* ( n1 – n2 ) core “two-star”

2/ ( n1 – n2 ) core “two-slash”

d2* ( d1 – d2 ) double “d-two-star”

d2/ ( d1 – d2 ) double “d-two-slash”

>pow2 ( u1 – u2 ) gforth-1.0 “to-pow2”

log2 ( u – n ) gforth-1.0 “log2”

pow2? ( u – f  ) gforth-1.0 “pow-two-query”

ctz ( x – u  ) gforth-1.0 “c-t-z”

wrol ( u1 u – u2 ) gforth-1.0 “wrol”

wror ( u1 u – u2 ) gforth-1.0 “wror”

lrol ( u1 u – u2 ) gforth-1.0 “lrol”

lror ( u1 u – u2 ) gforth-1.0 “lror”

rol ( u1 u – u2 ) gforth-1.0 “rol”

ror ( u1 u – u2 ) gforth-1.0 “ror”

drol ( ud1 u – ud2 ) gforth-1.0 “drol”

dror ( ud1 u – ud2 ) gforth-1.0 “dror”

< ( n1 n2 – f ) core “less-than”

<= ( n1 n2 – f ) gforth-0.2 “less-or-equal”

<> ( n1 n2 – f ) core-ext “not-equals”

= ( n1 n2 – f ) core “equals”

> ( n1 n2 – f ) core “greater-than”

>= ( n1 n2 – f ) gforth-0.2 “greater-or-equal”

0< ( n – f ) core “zero-less-than”

0<= ( n – f ) gforth-0.2 “zero-less-or-equal”

0<> ( n – f ) core-ext “zero-not-equals”

0= ( n – f ) core “zero-equals”

0> ( n – f ) core-ext “zero-greater-than”

0>= ( n – f ) gforth-0.2 “zero-greater-or-equal”

u< ( u1 u2 – f ) core “u-less-than”

u<= ( u1 u2 – f ) gforth-0.2 “u-less-or-equal”

u> ( u1 u2 – f ) core-ext “u-greater-than”

u>= ( u1 u2 – f ) gforth-0.2 “u-greater-or-equal”

within ( u1 u2 u3 – f ) core-ext “within”

d< ( d1 d2 – f ) double “d-less-than”

d<= ( d1 d2 – f ) gforth-0.2 “d-less-or-equal”

d<> ( d1 d2 – f ) gforth-0.2 “d-not-equals”

d= ( d1 d2 – f ) double “d-equals”

d> ( d1 d2 – f ) gforth-0.2 “d-greater-than”

d>= ( d1 d2 – f ) gforth-0.2 “d-greater-or-equal”

d0< ( d – f ) double “d-zero-less-than”

d0<= ( d – f ) gforth-0.2 “d-zero-less-or-equal”

d0<> ( d – f ) gforth-0.2 “d-zero-not-equals”

d0= ( d – f ) double “d-zero-equals”

d0> ( d – f ) gforth-0.2 “d-zero-greater-than”

d0>= ( d – f ) gforth-0.2 “d-zero-greater-or-equal”

du< ( ud1 ud2 – f ) double-ext “d-u-less-than”

du<= ( ud1 ud2 – f ) gforth-0.2 “d-u-less-or-equal”

du> ( ud1 ud2 – f ) gforth-0.2 “d-u-greater-than”

du>= ( ud1 ud2 – f ) gforth-0.2 “d-u-greater-or-equal”

s>f ( n – r ) floating-ext “s-to-f”

d>f ( d – r ) floating “d-to-f”

f>s ( r – n ) floating-ext “f-to-s”

f>d ( r – d ) floating “f-to-d”

f+ ( r1 r2 – r3 ) floating “f-plus”

f- ( r1 r2 – r3 ) floating “f-minus”

f* ( r1 r2 – r3 ) floating “f-star”

f/ ( r1 r2 – r3 ) floating “f-slash”

fnegate ( r1 – r2 ) floating “f-negate”

fabs ( r1 – r2 ) floating-ext “f-abs”

fcopysign ( r1 r2 – r3  ) gforth-1.0 “fcopysign”

fmax ( r1 r2 – r3 ) floating “f-max”

fmin ( r1 r2 – r3 ) floating “f-min”

floor ( r1 – r2 ) floating “floor”

fround ( r1 – r2 ) floating “f-round”

ftrunc ( r1 – r2  ) floating-ext “f-trunc”

f** ( r1 r2 – r3 ) floating-ext “f-star-star”

fsqrt ( r1 – r2 ) floating-ext “f-square-root”

fexp ( r1 – r2 ) floating-ext “f-e-x-p”

fexpm1 ( r1 – r2 ) floating-ext “f-e-x-p-m-one”

fln ( r1 – r2 ) floating-ext “f-l-n”

flnp1 ( r1 – r2 ) floating-ext “f-l-n-p-one”

flog ( r1 – r2 ) floating-ext “f-log”

falog ( r1 – r2 ) floating-ext “f-a-log”

f2* ( r1 – r2  ) gforth-0.2 “f2*”

f2/ ( r1 – r2  ) gforth-0.2 “f2/”

1/f ( r1 – r2  ) gforth-0.2 “1/f”

v* ( f-addr1 nstride1 f-addr2 nstride2 ucount – r ) gforth-0.5 “v-star”

faxpy ( ra f-x nstridex f-y nstridey ucount – ) gforth-0.5 “faxpy”

fsin ( r1 – r2 ) floating-ext “f-sine”

fcos ( r1 – r2 ) floating-ext “f-cos”

fsincos ( r1 – r2 r3 ) floating-ext “f-sine-cos”

ftan ( r1 – r2 ) floating-ext “f-tan”

fasin ( r1 – r2 ) floating-ext “f-a-sine”

facos ( r1 – r2 ) floating-ext “f-a-cos”

fatan ( r1 – r2 ) floating-ext “f-a-tan”

fatan2 ( r1 r2 – r3 ) floating-ext “f-a-tan-two”

fsinh ( r1 – r2 ) floating-ext “f-cinch”

fcosh ( r1 – r2 ) floating-ext “f-cosh”

ftanh ( r1 – r2 ) floating-ext “f-tan-h”

fasinh ( r1 – r2 ) floating-ext “f-a-cinch”

facosh ( r1 – r2 ) floating-ext “f-a-cosh”

fatanh ( r1 – r2 ) floating-ext “f-a-tan-h”

pi ( – r  ) gforth-0.2 “pi”

f~rel ( r1 r2 r3 – flag  ) gforth-0.5 “f~rel”

f~abs ( r1 r2 r3 – flag  ) gforth-0.5 “f~abs”

f~ ( r1 r2 r3 – flag  ) floating-ext “f-proximate”

f= ( r1 r2 – f ) gforth-0.2 “f-equals”

f<> ( r1 r2 – f ) gforth-0.2 “f-not-equals”

f< ( r1 r2 – f ) floating “f-less-than”

f<= ( r1 r2 – f ) gforth-0.2 “f-less-or-equal”

f> ( r1 r2 – f ) gforth-0.2 “f-greater-than”

f>= ( r1 r2 – f ) gforth-0.2 “f-greater-or-equal”

f0< ( r – f ) floating “f-zero-less-than”

f0<= ( r – f ) gforth-0.2 “f-zero-less-or-equal”

f0<> ( r – f ) gforth-0.2 “f-zero-not-equals”

f0= ( r – f ) floating “f-zero-equals”

f0> ( r – f ) gforth-0.2 “f-zero-greater-than”

f0>= ( r – f ) gforth-0.2 “f-zero-greater-or-equal”

infinity ( – r  ) gforth-1.0 “infinity”

-infinity ( – r  ) gforth-1.0 “-infinity”

NaN ( – r  ) gforth-1.0 “NaN”

6.6 Stack Manipulation ¶

Gforth は、 いくつかの個別のスタックを維持します:

• データ・スタック(「パラメーター・スタック」とも呼ばれます) – 文字(characters)と、 セル(cells)と、 アドレス(addresses)と、 2倍長セル(double cells) 用
• 浮動小数点スタック – 浮動小数点 (FP) 数を保持します。
• リターン・スタック – コロン定義およびその他の(FP 以外の)データのリターン・アドレスを保持します。
• ローカル・スタック – ローカル変数を保持します。

drop ( w – ) core “drop”

nip ( w1 w2 – w2 ) core-ext “nip”

dup ( w – w w ) core “dupe”

over ( w1 w2 – w1 w2 w1 ) core “over”

third ( w1 w2 w3 – w1 w2 w3 w1 ) gforth-1.0 “third”

fourth ( w1 w2 w3 w4 – w1 w2 w3 w4 w1 ) gforth-1.0 “fourth”

tuck ( w1 w2 – w2 w1 w2 ) core-ext “tuck”

swap ( w1 w2 – w2 w1 ) core “swap”

pick ( S:... u – S:... w ) core-ext “pick”

rot ( w1 w2 w3 – w2 w3 w1 ) core “rote”

-rot ( w1 w2 w3 – w3 w1 w2 ) gforth-0.2 “not-rote”

?dup ( w – S:... w ) core “question-dupe”

roll ( x0 x1 .. xn n – x1 .. xn x0  ) core-ext “roll”

2drop ( w1 w2 – ) core “two-drop”

2nip ( w1 w2 w3 w4 – w3 w4 ) gforth-0.2 “two-nip”

2dup ( w1 w2 – w1 w2 w1 w2 ) core “two-dupe”

2over ( w1 w2 w3 w4 – w1 w2 w3 w4 w1 w2 ) core “two-over”

2tuck ( w1 w2 w3 w4 – w3 w4 w1 w2 w3 w4 ) gforth-0.2 “two-tuck”

2swap ( w1 w2 w3 w4 – w3 w4 w1 w2 ) core “two-swap”

2rot ( w1 w2 w3 w4 w5 w6 – w3 w4 w5 w6 w1 w2 ) double-ext “two-rote”

fdrop ( r – ) floating “f-drop”

fnip ( r1 r2 – r2 ) gforth-0.2 “f-nip”

fdup ( r – r r ) floating “f-dupe”

fover ( r1 r2 – r1 r2 r1 ) floating “f-over”

fthird ( r1 r2 r3 – r1 r2 r3 r1 ) gforth-1.0 “fthird”

ffourth ( r1 r2 r3 r4 – r1 r2 r3 r4 r1 ) gforth-1.0 “ffourth”

ftuck ( r1 r2 – r2 r1 r2 ) gforth-0.2 “f-tuck”

fswap ( r1 r2 – r2 r1 ) floating “f-swap”

fpick ( f:... u – f:... r ) gforth-0.4 “fpick”

frot ( r1 r2 r3 – r2 r3 r1 ) floating “f-rote”

f-rot ( r1 r2 r3 – r3 r1 r2 ) floating “f-not-rote”

>r ( w – R:w ) core “to-r”

r> ( R:w – w ) core “r-from”

r@ ( – w ; R: w – w  ) core “r-fetch”

rdrop ( R:w – ) gforth-0.2 “rdrop”

2>r ( w1 w2 – R:w1 R:w2 ) core-ext “two-to-r”

2r> ( R:w1 R:w2 – w1 w2 ) core-ext “two-r-from”

2r@ ( R:w1 R:w2 – R:w1 R:w2 w1 w2 ) core-ext “two-r-fetch”

2rdrop ( R:w1 R:w2 – ) gforth-0.2 “two-r-drop”

n>r ( x1 .. xn n – r:xn..x1 r:n  ) tools-ext “n-to-r”

nr> ( r:xn..x1 r:n – x1 .. xn n  ) tools-ext “n-r-from”

sp0 ( – a-addr  ) gforth-0.4 “sp0”

sp@ ( S:... – a-addr ) gforth-0.2 “sp-fetch”

sp! ( a-addr – S:... ) gforth-0.2 “sp-store”

fp0 ( – a-addr  ) gforth-0.4 “fp0”

fp@ ( f:... – f-addr ) gforth-0.2 “fp-fetch”

fp! ( f-addr – f:... ) gforth-0.2 “fp-store”

rp0 ( – a-addr  ) gforth-0.4 “rp0”

rp@ ( – a-addr ) gforth-0.2 “rp-fetch”

rp! ( a-addr – ) gforth-0.2 “rp-store”

lp0 ( – a-addr  ) gforth-0.4 “lp0”

lp@ ( – c-addr ) gforth-0.2 “lp-fetch”

lp! ( c-addr – ) gforth-internal “lp-store”

6.7 Memory ¶

標準 Forth のメモリー割り当てワードに加えて ガベージ・コレクター(garbage collector) もあります。

here ( – addr  ) core “here”

unused ( – u  ) core-ext “unused”

allot ( n –  ) core “allot”

->here ( addr –  ) gforth-1.0 “to-here”

c, ( c –  ) core “c-comma”

f, ( f –  ) gforth-0.2 “f,”

, ( w –  ) core “comma”

2, ( w1 w2 –  ) gforth-0.2 “2,”

w, ( w –  ) gforth-1.0 “w-comma”

l, ( l –  ) gforth-1.0 “l-comma”

x, ( x –  ) gforth-1.0 “x-comma”

xd, ( xd –  ) gforth-1.0 “x-d-comma”

A, ( addr –  ) gforth-0.2 “A,”

mem, ( addr u –  ) gforth-0.6 “mem,”

align ( –  ) core “align”

falign ( –  ) floating “f-align”

sfalign ( –  ) floating-ext “s-f-align”

dfalign ( –  ) floating-ext “d-f-align”

maxalign ( –  ) gforth-0.2 “maxalign”

cfalign ( –  ) gforth-0.2 “cfalign”

allocate ( u – a-addr wior  ) memory “allocate”

free ( a-addr – wior  ) memory “free”

resize ( a-addr1 u – a-addr2 wior  ) memory “resize”

save-mem ( addr1 u – addr2 u  ) gforth-0.2 “save-mem”

free-mem-var ( addr –  ) gforth-experimental “free-mem-var”

extend-mem ( addr1 u1 u – addr addr2 u2  ) gforth-experimental “extend-mem”

buffer% ( – u1 u2  ) gforth-experimental “buffer%”

init-buffer ( addr –  ) gforth-experimental “init-buffer”

adjust-buffer ( u addr –  ) gforth-experimental “adjust-buffer”

create mybuf  buffer% %size allot  mybuf init-buffer
s" frobnicate" mybuf adjust-buffer  mybuf 2@ move
mybuf 2@ type
s" foo"        mybuf adjust-buffer  mybuf 2@ move
mybuf 2@ type

@ ( a-addr – w ) core “fetch”

! ( w a-addr – ) core “store”

+! ( n a-addr – ) core “plus-store”

c@ ( c-addr – c ) core “c-fetch”

c! ( c c-addr – ) core “c-store”

2@ ( a-addr – w1 w2 ) core “two-fetch”

2! ( w1 w2 a-addr – ) core “two-store”

f@ ( f-addr – r ) floating “f-fetch”

f! ( r f-addr – ) floating “f-store”

sf@ ( sf-addr – r ) floating-ext “s-f-fetch”

sf! ( r sf-addr – ) floating-ext “s-f-store”

df@ ( df-addr – r ) floating-ext “d-f-fetch”

df! ( r df-addr – ) floating-ext “d-f-store”

w@ ( c-addr – u ) gforth-0.5 “w-fetch”

w! ( w c-addr – ) gforth-0.7 “w-store”

l@ ( c-addr – u ) gforth-0.7 “l-fetch”

l! ( w c-addr – ) gforth-0.7 “l-store”

x@ ( c-addr – u ) gforth-1.0 “x-fetch”

x! ( w c-addr – ) gforth-1.0 “x-store”

xd@ ( c-addr – ud ) gforth-1.0 “x-d-fetch”

xd! ( ud c-addr – ) gforth-1.0 “x-d-store”

wbe ( u1 – u2  ) gforth-1.0 “wbe”

wle ( u1 – u2  ) gforth-1.0 “wle”

lbe ( u1 – u2  ) gforth-1.0 “lbe”

lle ( u1 – u2  ) gforth-1.0 “lle”

xbe ( u1 – u2  ) gforth-1.0 “xbe”

xle ( u1 – u2  ) gforth-1.0 “xle”

xdbe ( ud1 – ud2  ) gforth-1.0 “xdbe”

xdle ( ud1 – ud2  ) gforth-1.0 “xdle”

c>s ( x – n ) gforth-1.0 “c-to-s”

w>s ( x – n ) gforth-1.0 “w-to-s”

l>s ( x – n ) gforth-1.0 “l-to-s”

x>s ( x – n  ) gforth-1.0 “x>s”

xd>s ( xd – d  ) gforth-1.0 “xd>s”

w@ wbe w>s   \ 16ビット 非アライメント 符号付き ビッグ・エンディアン を取得し、
>r lle r> l!  \ 32-bit 非アライメント リトル・エンディアン として 格納

chars ( n1 – n2  ) core “chars”

char+ ( c-addr1 – c-addr2 ) core “char-plus”

char- ( c-addr1 – c-addr2  ) gforth-0.7 “char-minus”

cells ( n1 – n2 ) core “cells”

cell+ ( a-addr1 – a-addr2 ) core “cell-plus”

cell- ( a-addr1 – a-addr2 ) core “cell-minus”

cell/ ( n1 – n2 ) gforth-1.0 “cell-divide”

cell ( – u  ) gforth-0.2 “cell”

aligned ( c-addr – a-addr ) core “aligned”

floats ( n1 – n2 ) floating “floats”

float+ ( f-addr1 – f-addr2 ) floating “float-plus”

float ( – u  ) gforth-0.3 “float”

float/ ( n1 – n2 ) gforth-1.0 “float-divide”

faligned ( c-addr – f-addr ) floating “f-aligned”

sfloats ( n1 – n2 ) floating-ext “s-floats”

sfloat+ ( sf-addr1 – sf-addr2  ) floating-ext “s-float-plus”

sfloat/ ( n1 – n2 ) gforth-1.0 “dfloat-divide”

sfaligned ( c-addr – sf-addr ) floating-ext “s-f-aligned”

dfloats ( n1 – n2 ) floating-ext “d-floats”

dfloat+ ( df-addr1 – df-addr2  ) floating-ext “d-float-plus”

dfloat/ ( n1 – n2 ) gforth-1.0 “sfloat-divide”

dfaligned ( c-addr – df-addr ) floating-ext “d-f-aligned”

maxaligned ( addr1 – addr2  ) gforth-0.2 “maxaligned”

cfaligned ( addr1 – addr2  ) gforth-0.2 “cfaligned”

*aligned ( addr1 n – addr2  ) gforth-1.0 “*aligned”

*align ( n –  ) gforth-1.0 “*align”

waligned ( addr – addr’  ) gforth-1.0 “waligned”

walign ( –  ) gforth-1.0 “walign”

laligned ( addr – addr’  ) gforth-1.0 “laligned”

lalign ( –  ) gforth-1.0 “lalign”

xaligned ( addr – addr’  ) gforth-1.0 “xaligned”

xalign ( –  ) gforth-1.0 “xalign”

/w ( – u  ) gforth-0.7 “slash-w”

/l ( – u  ) gforth-0.7 “slash-l”

/x ( – u  ) gforth-1.0 “slash-x”

move ( c-from c-to ucount – ) core “move”

cmove ( c-from c-to u – ) string “c-move”

cmove> ( c-from c-to u – ) string “c-move-up”

fill ( c-addr u c – ) core “fill”

erase ( addr u –  ) core-ext “erase”

blank ( c-addr u –  ) string “blank”

insert ( string length buffer size –  ) gforth-0.7 “insert”

delete ( buffer size u –  ) gforth-0.7 “delete”

compare ( c-addr1 u1 c-addr2 u2 – n ) string “compare”

pad ( – c-addr  ) core-ext “pad”

6.8 Strings and Characters ¶

toupper ( c1 – c2 ) gforth-0.2 “toupper”

s\" ( compilation ’ccc"’ – ; run-time – c-addr u  ) core-ext,file-ext “s-backslash-quote”

S" ( compilation ’ccc"’ – ; run-time – c-addr u  ) core,file “s-quote”

char ( ’<spaces>ccc’ – c  ) core,xchar-ext “char”

[char] ( compilation ’<spaces>ccc’ – ; run-time – c  ) core,xchar-ext “bracket-char”

"C" type

'C' xemit

newline ( – c-addr u ) gforth-0.5 “newline”

bl ( – c-char  ) core “b-l”

#tab ( – c  ) gforth-0.2 “number-tab”

#lf ( – c  ) gforth-0.2 “number-l-f”

#cr ( – c  ) gforth-0.2 “number-c-r”

#ff ( – c  ) gforth-0.2 “number-f-f”

#bs ( – c  ) gforth-0.2 “number-b-s”

#del ( – c  ) gforth-0.2 “number-del”

#bell ( – c  ) gforth-0.2 “number-bell”

#esc ( – c  ) gforth-0.5 “number-esc”

#eof ( – c  ) gforth-0.7 “number-e-o-f”

str= ( c-addr1 u1 c-addr2 u2 – f  ) gforth-0.6 “str-equals”

str< ( c-addr1 u1 c-addr2 u2 – f  ) gforth-0.6 “str-less-than”

string-prefix? ( c-addr1 u1 c-addr2 u2 – f  ) gforth-0.6 “string-prefix-question”

string-suffix? ( c-addr1 u1 c-addr2 u2 – f  ) gforth-1.0 “string-suffix-question”

search ( c-addr1 u1 c-addr2 u2 – c-addr3 u3 flag  ) string “search”

scan ( c-addr1 u1 c – c-addr2 u2 ) gforth-0.2 “scan”

scan-back ( c-addr u1 c – c-addr u2  ) gforth-0.7 “scan-back”

skip ( c-addr1 u1 c – c-addr2 u2 ) gforth-0.2 “skip”

-trailing ( c_addr u1 – c_addr u2  ) string “dash-trailing”

/string ( c-addr1 u1 n – c-addr2 u2 ) string “slash-string”

safe/string ( c-addr1 u1 n – c-addr2 u2 ) gforth-1.0 “safe-slash-string”

cstring>sstring ( c-addr – c-addr u  ) gforth-0.2 “cstring-to-sstring”

capscompare ( c-addr1 u1 c-addr2 u2 – n ) gforth-0.7 “capscompare”

capsstring-prefix? ( c-addr1 u1 c-addr2 u2 – f  ) gforth-1.0 “capsstring-prefix?”

capssearch ( c-addr1 u1 c-addr2 u2 – c-addr3 u3 flag  ) gforth-1.0 “capssearch”

s+ ( c-addr1 u1 c-addr2 u2 – c-addr u  ) gforth-0.7 “s-plus”

append ( c-addr1 u1 c-addr2 u2 – c-addr u  ) gforth-0.7 “append”

>string-execute ( ... xt – ... addr u  ) gforth-1.0 “>string-execute”

$! ( addr1 u $addr –  ) gforth-0.7 “string-store”

$@ ( $addr – addr2 u  ) gforth-0.7 “string-fetch”

$@len ( $addr – u  ) gforth-0.7 “string-fetch-len”

$!len ( u $addr –  ) gforth-0.7 “string-store-len”

$+!len ( u $addr – addr  ) gforth-1.0 “string-plus-store-len”

$del ( addr off u –  ) gforth-0.7 “string-del”

$ins ( addr1 u $addr off –  ) gforth-0.7 “string-ins”

$+! ( addr1 u $addr –  ) gforth-0.7 “string-plus-store”

c$+! ( char $addr –  ) gforth-1.0 “c-string-plus-store”

$free ( $addr –  ) gforth-1.0 “string-free”

$init ( $addr –  ) gforth-1.0 “string-init”

$split ( addr u char – addr1 u1 addr2 u2  ) gforth-0.7 “string-split”

$iter ( .. $addr char xt – ..  ) gforth-0.7 “string-iter”

$over ( addr u $addr off –  ) gforth-1.0 “string-over”

$exec ( xt addr –  ) gforth-1.0 “string-exec”

$tmp ( xt – addr u  ) gforth-1.0 “string-t-m-p”

$. ( addr –  ) gforth-1.0 “string-dot”

$slurp ( fid addr –  ) gforth-1.0 “string-slurp”

$slurp-file ( c-addr u addr –  ) gforth-1.0 “string-slurp-file”

$+slurp ( fid addr –  ) gforth-1.0 “string-plus-slurp”

$+slurp-file ( c-addr u addr –  ) gforth-1.0 “string-plus+slurp-file”

$[] ( u $[]addr – addr’  ) gforth-1.0 “string-array”

$[]! ( c-addr u n $[]addr –  ) gforth-1.0 “string-array-store”

$[]+! ( c-addr u n $[]addr –  ) gforth-1.0 “string-array-plus-store”

$+[]! ( c-addr u $[]addr –  ) gforth-1.0 “string-append-array”

$[]@ ( n $[]addr – addr u  ) gforth-1.0 “string-array-fetch”

$[]# ( addr – len  ) gforth-1.0 “string-array-num”

$[]map ( addr xt –  ) gforth-1.0 “string-array-map”

$[]slurp ( fid addr –  ) gforth-1.0 “string-array-slurp”

$[]slurp-file ( addr u $addr –  ) gforth-1.0 “string-array-slurp-file”

$[]. ( addr –  ) gforth-1.0 “string-array-dot”

$[]free ( addr –  ) gforth-1.0 “string-array-free”

$save ( $addr –  ) gforth-1.0 “string-save”

$[]save ( addr –  ) gforth-1.0 “string-array-save”

$boot ( $addr –  ) gforth-1.0 “string-boot”

$[]boot ( addr –  ) gforth-1.0 “string-array-boot”

$saved ( addr –  ) gforth-1.0 “string-saved”

$[]saved ( addr –  ) gforth-1.0 “string-array-saved”

$Variable ( –  ) gforth-1.0 “string-variable”

$[]Variable ( –  ) gforth-1.0 “string-array-variable”

count ( c-addr1 – c-addr2 u ) core “count”