> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/ja/xiang-xi-ji-shi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md).

# \expandafter はどのように動作するか：基本原理からTeXのソースコードの探究まで

[第1部](/latex/ja/xiang-xi-ji-shi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [第2部](/latex/ja/xiang-xi-ji-shi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [第3部](/latex/ja/xiang-xi-ji-shi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [第4部](/latex/ja/xiang-xi-ji-shi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [第5部](/latex/ja/xiang-xi-ji-shi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [第6部](/latex/ja/xiang-xi-ji-shi/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)

## はじめに

これで、を完全に掘り下げるために必要な背景トピックを扱いました `\expandafter`:

* TeXのトークンの基本と、その計算方法;
* TeXの展開プロセスの背後にある原理;
* 文書処理中におけるTeXの一時トークン列の使用/生成;
* TeXが複数の入力ソース（臨時のトークン列を含む）をどのように使い、どのように“やりくり”するか。

この記事では、これらのトピック/概念をまとめて、TeXの `\expandafter` コマンドの基礎となる仕組み、要するにその動作の仕組みを説明します。

## それでは、\expandafterに

の背後にある考え方は `\expandafter` TeXが通常そうする前に、コマンド（トークン）の展開を強制することです。2つのトークンがあるとすると、 $$\mathrm{T\_1}$$ や $$\mathrm{T\_2}$$ の作用は `\expandafter` $$\mathrm{T\_1T\_2}$$ 結果としてTeXは $$\mathrm{T\_1}\text{<}$$の展開を処理します $$\mathrm{T\_2}\text{>}$$、ここで $$\text{<}\dots\text{>}$$ はトークンの列を示します。TeXは $$\mathrm{T\_2}$$ を前倒しで展開するので、トークン $$\mathrm{T\_1}$$ （たとえばプリミティブやマクロ）は、 $$\mathrm{T\_2}$$の展開から生じたトークンを見たり、それに対して処理を行ったりできます。もしトークン $$\mathrm{T\_2}$$ が、非アクティブ文字や（大半の）プリミティブのような展開不能な項目を表しているなら、 `\expandafter` の作用は何も変えません。TeXは通常どおりトークン $$\mathrm{T\_1T\_2}$$ の処理を続けます。

### \expandafterの使い方入門

もし `\expandafter`を使ったことがないなら、ここではプリミティブ `\uppercase{...}`と組み合わせた例を示します。メインの `.tex` 入力ファイル名を大文字で組版したいとしましょう。次のTeXプリミティブコマンドを知っているかもしれません。

* `\uppercase`: その名のとおり、文字トークンを対応する大文字形に変換します（存在する場合）;
* `\jobname`: これまで見たように、メインの名前に展開されます `.tex` ファイル内のキーと一致するすべての項目を探します。

TeXファイルの名前が `mycode.tex` なら、私たちは当然 `\uppercase{\jobname}` が組版されると期待するでしょう `MYCODE`. しかし実際には、 `mycode` と小文字のまま組版されます。何が“うまくいかなかった”のでしょうか?

\uppercaseの一般的な使い方を `\uppercase` として書くと

```
\uppercase{<トークン列>}
```

次のように言えます。 `\uppercase` は `<トークン列>` を調べ、そこで見つけた *文字トークン* に対してのみ（大文字/小文字の変換を）行います `<トークン列>`: それ以外のすべての非文字トークンは *無視されます* なぜなら `\uppercase` は非文字トークンの中を“見る”（展開する）ことはなく、その中身や表しているものを確認しないからです。トークンは単なる整数値なので、 `\uppercase` がしなければならないのは、トークン列を見渡して、 `<トークン列>` 内の各トークンの数値が文字トークンを示す値の範囲に入っているかどうかを確認することだけです。ちなみに、 `\uppercase` はまた *アクティブ文字の大文字/小文字を変えることもできます* 大文字のアクティブ文字を作りますが、それは依然としてアクティブなので、定義されている必要があります。そうでなければTeXは次のエラーを出します: `未定義の制御綴`、しかし話がそれました...

たとえば、単なるテキストだけのマクロを定義したとしても

```
\def\foo{some lower-case text}
```

すると `\uppercase{\foo}` でも組版されるのは `some lower-case text` であって `SOME LOWER-CASE TEXT` ではありません。望んだようにはならないのは、単に `\uppercase` の作用が `\foo` が何を表しているのかを判定しようとしないからです。これは `\foo` を制御綴トークンとして見て無視し、 `\jobname`.

### どう直せるでしょうか? \expandafterが助けになります

ファイル名の大文字版を組版するには、 `\uppercase{\jobname}` を修正して、TeXに `\jobname` をその展開結果（文字トークンの列）で置き換えさせる必要があります *より前に* `\uppercase` が働きます。ここでもやはり、展開は `\jobname` トークン（コマンド）を取り除き、その展開結果（文字トークンを含むトークン列）に置き換えるために使われています。したがって、次のように書けば

```
\uppercase\expandafter{\jobname}
```

うまくいきます: `MYCODE` が組版されることになります。実際には、TeXが `\uppercase` の処理を開始して、ただちに必須の開き中かっこ文字（`{`）を確認します。しかし、TeXは `\expandafter` コマンドを検出し、一時的に注意をそらして `\expandafter{\jobname}`.

を比べると

`\expandafter` $$\mathrm{T\_1T\_2}$$

私たちの例である

`\expandafter{\jobname}`

では、

* $$\mathrm{T\_1} =\space$$`{`<sub>トークン</sub>
* $$\mathrm{T\_2} =\space$$`\jobname`<sub>トークン</sub>

ここで `{`<sub>トークン</sub> や `\jobname`<sub>トークン</sub> とは、TeXが計算したトークン値を指します。下付き表記 <sub>トークン</sub> は、TeXが整数トークンの世界で動作していることを思い出すために使っています。

\uppercase{<トークン列>} と書くと `\uppercase\expandafter{\jobname}` うまくいくのは、概略としては（詳細は後述）、 `\expandafter` がTeXに次の作業をさせるからです:

1. 開き `{`<sub>トークン</sub>;
2. 次のトークンを読む: `\jobname`<sub>トークン</sub>. TeXは `\jobname`<sub>トークン</sub> が展開可能なコマンドを表していると認識し、展開します。 `\jobname`<sub>トークン</sub> はその展開結果、つまり一連の文字トークンに置き換えられます;
3. を展開したあと、 `\jobname` コマンドの `{`$$\_\mathrm{token}$$ を“入力に戻し”、 `\jobname` の展開から生じたトークン列を使って、TeXが `\uppercase{`<sub>トークン</sub>`<\jobnameの展開結果>`<sub>トークン列（文字）</sub>`}`を読むようにするので、望んだ結果が得られます。

次の図は、TeXが `\uppercase\expandafter{\jobname}`をどのように処理するかを示しています。図は下から上に読んで、処理の流れをたどってください。

![\expandafterの動作](/files/da9d51ab57e0cc4829406f8b54612eaf4ee40c76)

以下の注記が、処理の各段階を説明します。

1. TeXは `\uppercase` の処理を開始し、必須の開き中かっこ文字（`{`）を確認しますが、 `\expandafter` コマンド。
2. を比べると `\expandafter` $$\mathrm{T\_1T\_2}$$ への入力の中に `\expandafter{\jobname}` では、 $$\mathrm{T\_1} =$$`{`<sub>トークン</sub> や $$\mathrm{T\_2} =$$`\jobname`<sub>トークン</sub>を検出します。ここでは下付きの <sub>トークン</sub> を使って、TeXが整数トークン値を処理していることを示します。
3. `\expandafter` を読み取り、次に一時的に保存します `{`<sub>トークン</sub> その整数トークン値を内部変数に保存することで。後でTeXは、そのトークンを `\jobname` コマンド。
4. `\expandafter` を読み取り、次に `\jobname`<sub>トークン</sub>を展開します `\jobname` コマンド。
5. の展開は `\jobname` を作り出し、その中には `.tex` のファイル名を表す文字トークンの列が含まれます。 `\jobname` によって生成されるすべての文字トークンはカテゴリコード12を使って計算されることに注意してください。
6. 一度 `\jobname` が展開されると、TeXはステップ3で保存したトークン（`{`<sub>トークン</sub>）を再挿入して入力に戻します。TeXは、 *1つの* `{`<sub>トークン</sub>
7. の処理を終え、TeX入力のソースとして使える2つのトークン列が準備されたことになります。TeXはここで `\expandafter`の処理に戻りますが、入力を、 `\uppercase` によって作成された2つのトークン列が `\expandafter` のトークンの供給源になるように設定しています `\uppercase`—すると今や `\uppercase{`<sub>トークン</sub>`<\jobnameの展開結果>`<sub>トークン列（文字）</sub>`}`. `\uppercase` は文字トークンの列を見て、望んだ結果を生成できます。
8. によって生成されたすべての文字トークンを読み終えると、TeXは前の入力ソース（私たちの `\jobname`）からトークンを取得する状態に戻り、そこで次のトークンである閉じ `.tex` を読みます `}` これは、 `\uppercase`.

### \expandafterと内部トークン列

一時トークン列は *不可欠な* 要素です `\expandafter`の処理動作において: それらのトークン列の使用と存在を理解すると、 `\expandafter` がどのように結果を得ているのかを明確にする助けになります。特に、より複雑なトークン処理を実現するために複数の `\expandafter` コマンドを連続して使うマクロを書いたり理解したりするときに役立ちます: `\expandafter\expandafter\expandafter...`

もう1つの重要な要素は `\expandafter`の動作、特に複数の連続した `\expandafter` コマンドにおける *再帰* （TeXソフトウェア内部での）です。これはこの記事の後半で扱うトピックです。

一時トークン列の理解をさらに助けるために、もう1つ `\expandafter`の例を見てみましょう。今回は `\the` コマンド。

#### \expandafterと内部トークン列: 例2

この例では、 `\expandafter` を使って、トークンレジスタに保存されたトークンへ `\toks` コマンド経由でどのように影響を与えられるかを見ます。以下が使うTeXプリミティブです:

* `**\count** *register*=*number*`: TeXの位置 `*number*` に値 `*register*`;
* `**\toks** *register*={*token list*}`: トークンレジスタの位置 `*token list*` に `*register*`を保存するためのTeXプリミティブ; 後で使うために一連のトークンを保存する;
* `**\the** *token*`: 変換可能なTeXプリミティブコマンドで、 `*token*`を処理します。ただし、正確な結果は処理される `*token*` の性質によって異なります。 `\the` には多くの用途があります。その1つが、TeXのパラメータや変数（たとえばレジスタ）に保存された値を組版することです。 `\the` の他の用途としては、トークンレジスタに保存されたトークンのコピーを挿入することがあります。ここでは `\the` を使って、 `\count` レジスタに保存された値を組版します。

まず、次のTeXコードで値 `12345` をTeXの `\count` レジスタに保存します `99`:

```
\count99=12345
```

\count99に保存された値を組版したいなら `、` を使えます `\the\count99` （または `\number\count99`).

次に、 `\toks` コマンドを使って、トークンレジスタ `99`:

```
\toks99={\the\count99 }
```

にいくつかのトークンを保存します `99` トークンレジスタ

|                               |                                                                    |
| ----------------------------- | ------------------------------------------------------------------ |
| **に保存されたトークン列には、次のものが含まれます:** | **TeXトークン値**                                                       |
| 5382                          | `\the`                                                             |
| 7885                          | `\count`                                                           |
| 3129                          | `9` （カテゴリコード12の文字コード57）であり、トークン値は $$256 \times 12 + 57 = 3129$$    |
| 3129                          | `9` （カテゴリコード12の文字コード57）であり、トークン値は $$256 \times 12 + 57 = 3129$$    |
| 2592                          | `<空白>` （カテゴリコード10の文字コード32）であり、トークン値は $$256 \times 10 + 32 = 2592$$ |

によって作成されたトークン列に注意してください `\toks99` は *実際の* データ値を含んで `、` いません。なぜなら `\toks` コマンドは展開を行わないからです。単にトークンを作成して保存するだけです。私たちの例では、 `\the` は展開されないので `、`を処理しません。ここで `\the` は単にトークン（値5382）になり、トークン列に保存されるだけです。

もし `\toks99` トークン列に、 `、` に保存されたデータを表すトークンを入れたいなら、 `\toks` コマンドがそれらにアクセスできるように、それらのトークンを作成する（利用可能にする）方法が必要になります。そしてもちろん `\expandafter` ならそれができます。次のように書けば:

```
        \toks99=\expandafter{\the\count99 }
```

の作用/処理は `\toks` の間は“保留”されます `\expandafter` が `\the` の展開を（強制して）引き起こし、それがさらに `\count` に作用して、 `、`に保存されたデータを表す文字トークンを含む一時トークン列を生成します。小さいですが重要なのは、 `<空白>` が `99`の後ろにあることです: その `<空白>` 文字は、数値を探しているときにTeXの走査処理を終了させる役割を果たします。

ここでは、 `\expandafter` の作用は `\jobname` の例と非常によく似ています。

1. 開き `{`<sub>トークン</sub>.
2. 次のトークンを読む、 `\the`<sub>トークン</sub>。これは展開可能なコマンドを表しているので、TeXはそれを展開します。 `\expandafter` の展開を強制し `\the` その後 `、` に作用して、 `\count` レジスタに保存します `99` （数値12345）に保存されたデータを一時トークン列に変換します。その列には、数字 `1`, `2`, `3`, `4` や `5`—カテゴリコード12の文字トークン—を表す文字トークンが含まれます。
3. を展開して処理した後、 `\the`TeXは `{`<sub>トークン</sub> を“入力に戻し”、 `\the\count99` の展開から生じたトークン列を使って、TeXが `\toks99={`<sub>トークン</sub>`<\the\count99 の展開結果>`<sub>トークン列（文字）</sub>`}` の展開から生じたトークン列を使って、望んだ結果を得ます。

この一連の流れは次の図にまとめられています。図は下から上に読んで、処理の流れを追ってください。

![\expandafterの動作](/files/d333793f5988409b3a125f2c6f5b810e6ff10021)

1. TeXは `\toks`; そこでオプションの `=` 記号を見て、必須の開き中かっこ文字（`{`、またはカテゴリコード1の任意の文字）を確認し、それがトークン列の開始を示します。しかし、TeXは `\expandafter` コマンドを検出し、その代わりにそれを実行します。
2. を比べると `\expandafter` $$\mathrm{T\_1T\_2}$$ への入力の中に `\expandafter{\the\count99 }` では、 $$\mathrm{T\_1} =$$ `{`<sub>トークン</sub> や $$\mathrm{T\_2} =$$ `\the<sub>トークン</sub>`.
3. `\expandafter` を読み取り、次に一時的に保存します `{`<sub>トークン</sub> （TeXはその整数トークン値を内部変数に一時保存します）。後でTeXは、そのトークンを `\the`
4. `\expandafter` を読み取り、次に `\the`<sub>トークン</sub> を処理したあと、入力に再挿入します。
5. の展開は `\the` は、 `、`の処理から一時トークン列を作成します—そのトークン列には、 `\count` レジスタに保存します `99`.
6. 一度 `\the` が展開されると、TeXはステップ3で保存したトークン（`{`<sub>トークン</sub>に保存されたデータ値を表す一連の文字トークンが含まれます）を入力に戻します。TeXは、別のトークン列を作成することでそれを行います。そのトークン列には *1つの* トークン `{`<sub>トークン</sub>.
7. の処理を終え、TeX入力のソースとして使える2つのトークン列が準備されたことになります。TeXはここで `\expandafter` を含み、次の入力ソースとして使える2つのトークン列ができました。TeXは `\toks99=` の処理に戻りますが、今やTeXは入力を、 `\expandafter` のトークンの供給源になるように設定しています `\toks`—すると今や `{`<sub>トークン</sub>`<\the\count99 の展開結果>`<sub>トークン列（文字）</sub>`}`. `\toks` が保存されたデータ値（`12345`）を表す5個の文字トークン列を、アクセスして保存できるように設定しています `、`: これが私たちの望んだ結果です。
8. によって生成されたすべての文字トークンを読み終えたあと、 `\the\count99`）からトークンを取得する状態に戻り、そこで次のトークンである閉じ `.tex` を読みます `}` によって保存されるトークン列を終了するために必要な `\toks99={...}`.

## \expandafterは実際にはどう動くのか

この節では、TeXそのものの内部を“低レベル”で見ていきます。つまり、 `\expandafter`の動作を実装しているTeX内部のソースコード/関数を調べます。詳細は疑似Cコードで示しますが、他のプログラミング言語に慣れている人なら理解できるはずです。

次の注釈付き図は、TeXが `\expandafter` を、 `expand()`という、TeXの展開処理を駆動する中核関数の一部としてどのように実装しているかを説明します。 `\expandafter` では、 [*再帰的な* 動作](https://en.wikipedia.org/wiki/Recursion) では、 `expand()` 関数への別の呼び出しを使って、読み込まれた2つ目のトークン $$\mathrm{T\_2}$$を処理します。これは $$\mathrm{T\_2}$$ が展開可能な場合です。

このコードはKnuthのTeXエンジンに現れますが、この図で示されている基本原理はすべてのTeXエンジンに当てはまります。

![TeX内部で\expandafterはどう動くか](/files/e09a3e21f27dddc18e6f90c78cbd72b90df8509f)

の最初の仕事は `expand()` 展開されるコマンドがマクロかプリミティブかを判定することです。なぜなら、マクロには、 `macrocall()`.

展開されるコマンドがプリミティブなら、 `expand()` 関数は現在のコマンドコード値（グローバル変数 `curcmd`に保存されている）を使って、どのプリミティブを処理すべきかを特定します。これらの詳細は、 `expand()`:

```
    void expand(void)
    {
    //curcmdはグローバル変数
    if(curcmd != macro) // curcmd < 111
    {
      switch(curcmd)
      {
        case \expandafter: // \expandafter T1T2 コマンドを処理する
        {
            gettoken(); // トークン T1 を読み取る
            t = curtok; // トークン T1 をローカル変数 t に保存する
            gettoken(); // トークン T2 を読み取る
            if(curcmd > 100) // トークン T2 は展開可能か？
                expand();    // はい！T2 は展開可能：
                             // T2 の展開を
                             // expand() を再帰的に呼び出すことで行う
            else
                backinput(); // T2 は展開不可能：そのトークンを
                             // 入力に戻し、あとでもう一度読み取らせる

            curtok = t ;  // グローバル変数 curtok を保存しておいた T1 の値に復元する
            backinput() ; // トークン T1 を入力に戻す
                          // T2 の展開から生じるトークンの前に
        }
        break;

        // その他の展開可能なコマンドを処理するコード
        case “テキストに変換” コマンド: // \number, \string, \romannumeral,
                                        // \meaning, \fontname, \jobname のいずれか
                                        // これらは curcmd の同じ値を共有する
        break;

        case \noexpand: // 次のトークンの展開を抑制する
        ...
        break;

        case \csname:  //制御綴名を生成する。
        ...
        break;

        case \the: // いくつかのトークンを挿入する
        ....
        break;

        case “\if... test command” : // TeX の条件分岐の一つを処理する：
                                      // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode,
                                      // \ifhmode, \ifmmode, \ifinner, \ifvoid,
                                      // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse,
                                      // \ifcase, \ifdefined, \ifcsname, \iffontchar
        ...
        break;

        case “\fi or \else”: // 現在の条件分岐を終了する
        ...
        break;

        // など、TeX エンジンがサポートする他の展開可能な基本コマンドについても同様
        // TeX エンジン

        }

    }else // 展開可能な基本コマンドではない：それはマクロである
        {
             macrocall()
        }
        //... さらにコードが削除されています
    }
```

### TeX のグローバル変数への愛着

その年代や設計された時代を反映しているのかもしれませんが、TeX のソースコードでは、いわゆる [グローバル変数](https://en.wikipedia.org/wiki/Global_variable)— 実際には何百もあります。グローバル変数はその性質上、TeX のソースコードのどこからでも変更できます。Knuth の TeX では、それは 25,000 行を超えるコードと何百もの関数を含む単一の巨大なファイルです。TeX がどのように動作するかを理解するのは、常に সহজな仕事ではありません...

処理するには `\expandafter`、TeX は現在の入力から `gettoken()` という関数を使ってトークンを読み取り、その動作によってトークンを生成し、TeX のソースコード全体で使われるいくつかの重要なグローバル変数の値を設定します。次の 2 つの変数は、 `gettoken()`の動作によって更新され、 `\expandafter`:

* `curtok`: （現在のトークン）直前に読み取ったトークンの整数値；
* `curcmd`: （現在のコマンドコード）トークンで表されるコマンド（または文字）のコマンドコード `curtok`.

処理する際に `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX はトークン $$\mathrm{T\_1}$$ を読み取り、その値（整数）を一時的に `t`というローカル変数に保存します。次に TeX は $$\mathrm{T\_2}$$ を読み取り、そのトークンが展開可能なコマンドを表しているかどうかを、そのコマンドコード（`curcmd`）が 100 より大きいかで確認します。もしそうなら、TeX は $$\mathrm{T\_2}$$ で表されるコマンドを展開する必要があり、関数 `expand()`をもう一度呼び出します。これは *再帰* いません。なぜなら `expand()` 関数が自分自身を呼び出している例です。展開の再帰的な性質を意識すると、特に `\expandafter`を使うときに、連続する複数の `\expandafter` コマンド、すなわち `\expandafter\expandafter\expandafter...` がどのように効果を生み出すのかを理解しやすくなります。

トークン $$\mathrm{T\_2}$$ が展開可能であれば、展開が行われ、 `expand()` への再帰呼び出しが戻ると、 `\expandafter` の実装内のコードがトークン $$\mathrm{T\_1}$$ を入力に再挿入します。グローバル変数 `curtok` は、ローカル変数 `t`に保存されたトークンの値に再代入されます。これはトークン $$\mathrm{T\_1}$$の値であり、関数 `backinput() に呼び出しが行われます。`

#### 関数 backinput()

名前が示すとおり、この関数はトークンを「入力に戻す」働きをします。そのために TeX はグローバル変数 `curtok` の現在値を使って、単一のトークンを含むトークンリストを作成します（その整数値は `curtok`によって与えられます）。また TeX は入力処理を調整して、その単一トークンのリストが適切な時点で、後続の入力処理の一部として TeX によって再度読み取られるようにします。ここで注意すべきなのは、トークン $$\mathrm{T\_1}$$ が再挿入されるのは *展開が終わったあとである*ことです。これにより、TeX はその再挿入されたトークン *より前に* を、 $$\mathrm{T\_2}$$.

### マクロを処理する：macrocall() 関数

前述のとおり、すべてのマクロと一部の基本コマンドは展開可能であり、すべての展開処理は `expand()` 関数を通して行われます。しかし、 `expand()` は `curcmd` （現在のコマンド）の値を使って、展開可能な基本コマンドとマクロを区別する点に注意しています。なぜなら、マクロの展開処理は `macrocall()`という専用関数で扱われるからです。マクロには特別な展開処理が必要です。というのも、マクロの引数と区切りトークンは、非常に特定かつ厳密な方法で खोजる必要があるためです。したがって、その処理はそれを行うよう設計された関数に委ねられます： `macrocall()`.

#### マクロの展開とマクロの実行

マクロ *の展開* は、マクロ *の実行*とは同じ処理ではありません。マクロの展開は、TeX がマクロを *実行できるようにするために行う事前処理です。*。マクロの「実行」は、TeX がそのマクロの定義（置換テキスト）とその引数（パラメータ）に含まれるトークンを積極的に読み取り、処理しているときに起こります。

#### マクロの展開

マクロを展開するには、TeX はまずそのマクロが引数を取るかどうかを確認します。もし取るなら、 `macrocall()` 非常に注意深く入力を走査して、そのマクロの引数になる予定のトークンを探します。その処理には、マクロの元の定義で使われた区切りトークンがユーザー入力に含まれていないかを確認することも含まれます。マクロ呼び出しのトークンの並びは、保存されている定義に含まれるトークンの並びと完全に一致しなければなりません。ただし、区切りとして使われるトークンは TeX によって単に捨てられます。実質的には、TeX がマクロの引数になる実際のトークン、つまりユーザーがマクロで処理させたいトークンを判定するために使う一種の「句読点」にすぎません。区切りトークンの詳細については、 [TeX マクロの実際の動作](/latex/ja/sononotopikku/22-how-tex-macros-actually-work-part-4.md).

各パラメータ（`#1, #2...#9`）について、TeX は実際のマクロ呼び出しを走査して、ユーザーが提供したどのトークンが各パラメータに割り当てられるか（つまり、マクロの引数を形成するか）を特定します。その処理により、1 つ以上の小さなトークンリストが作成されます。マクロ引数ごとに 1 つです。

マクロ引数が検出され、そのトークンリストが準備されると、TeX はメモリに保存されているマクロの定義（置換テキスト）を取り出し、TeX がさらにトークンを読み取って処理する準備ができたときには常に、それらをマクロの置換テキストから読むように入力処理を整え、こうしてマクロを実行します。適切な時点で、マクロ実行の途中において、マクロ引数を表すトークンリストがマクロの置換テキスト内の正しい位置に流し込まれます。

繰り返しますが、マクロコマンドの展開とは *取り除き* 、そのマクロコマンド（トークン）を入力から *置き換える* ことであり、それをマクロの置換テキストとして保存されたトークンリストに差し替えることです。

TeX のマクロ処理を詳しく知るには、6 回連載の記事シリーズ [TeX マクロは実際にどのように動作するのか？](/latex/ja/sononotopikku/01-a-six-part-series-how-do-tex-macros-actually-work.md)

[第1部](/latex/ja/xiang-xi-ji-shi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [第2部](/latex/ja/xiang-xi-ji-shi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [第3部](/latex/ja/xiang-xi-ji-shi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [第4部](/latex/ja/xiang-xi-ji-shi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [第5部](/latex/ja/xiang-xi-ji-shi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [第6部](/latex/ja/xiang-xi-ji-shi/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://overleaf-pro.ayaka.space/latex/ja/xiang-xi-ji-shi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
