> 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/ko/in-depth-articles/22-how-does-expandafter-work-the-meaning-of-expansion.md).

# \expandafter는 어떻게 작동하나요: 확장의 의미

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

## TeX의 “전개” 개념 소개

살펴본 바와 같이 [TeX 토큰과 토큰 리스트](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true)에 관한 배경 주제 목록에서 다음은 `\\expandafter` 은 TeX의 *확장*: 핵심 TeX 처리 과정 `\\expandafter` 이 작업하도록 설계되어 있습니다.

### 전개를 설명하는 어려움에 대하여...

대부분의 사람들에게 TeX의 전개 개념과 그 배경에 있는 이유/메커니즘은 혼란스러울 수 있습니다. 그것들은 *완전히* 간단하고 간결한 방식으로 설명하기가 쉽지 않습니다. TeX의 내부 동작/과정들 중 상당수는 매우 복잡한 방식으로 서로 연결되어 있어, TeX 동작의 특정 측면을 “분해”하여 살펴보려 할 때 어려움이 생길 수 있습니다. 즉, 프로그램 전체와 분리해서 논하려 할 때 그렇습니다. 전개는 그런 범주에 속하는 개념으로, 그것은 *근본적인* TeX 동작의 한 요소이며, TeX의 내부 과정 전반에 깊숙이 내재해 있기 때문입니다. 그러나 이 글은 전개에 대한 설명을 구성하려 하며, 독자들이 그 위에 이해를 쌓아갈 수 있는 기반을 제공합니다.

TeX의 전개 메커니즘을 설명하기 위해 우리는 단계적으로 진행하면서 관련/중요한 주제들을 폭넓게 살펴보고, 그것들을 서로 맞춰 보며 TeX 동작의 이 핵심 요소에 대한 이해를 발전시켜 나갈 것입니다. 글의 후반부에서는, 세부 사항을 좋아하는 좀 더 모험적인 독자를 위해 TeX 내부를 들여다보며 전개 과정을 구동하는 핵심 소스 코드를 요약해 보겠습니다.

### TeX 토큰에 대한 핵심 사항

다음 논의 전반에서 TeX이 다음 입력 항목을 두 가지 출처에서 얻을 수 있다는 점을 기억하는 것이 중요합니다:

1. **물리적 텍스트 파일**을 생성하며 *새 토큰을 생성하는 것* 그 파일들 안의 문자와 명령을 읽고/스캔함으로써, 또는
2. **토큰 리스트**: 기존의 *미리 준비된*토큰, 즉 TeX 메모리에 저장된 토큰 리스트를 읽어 입력을 얻는 방식입니다.

또한 TeX은 읽어들인 어떤 항목(문자 또는 명령)에 대한 정보를 깔끔하게 “패키징”하는 편리한 방법으로 토큰을 사용한다는 점도 기억하십시오.

TeX이 *새 토큰을 생성하는 것* 를 생성할 때에는 *토큰이 생성되는 시점에*그 토큰 값을 계산하고 있는 항목에 대한 정보에 즉시 접근할 수 있습니다. 예를 들어 새 명령 토큰을 생성할 때 TeX은 먼저 `curcs` 라는 값을 계산하는데, 이를 통해 TeX은 방금 생성하려는 토큰이 나타내는 명령에 대한 정보를 조회할 수 있습니다.

그러나 TeX이 토큰 리스트(즉, *저장된 토큰들*)에서 읽고 있다면, 그 리스트 안의 어떤 토큰이 무엇을 나타내는지 알아내기 전에 먼저 그 토큰을 “언패키징”해야 합니다. 예를 들어 TeX은 매크로 정의의 일부로 저장된 토큰들을 읽을 수 있습니다. 그런 토큰들은 이미 오래전에 읽혀 토큰으로 변환된 뒤 저장된 텍스트에서 생성된 것입니다. 토큰의 유형(문자 또는 명령)은 TeX의 “언패키징”이 실제로 무엇을 뜻하는지를 결정합니다:

* 에는 *명령 토큰* (토큰 값이 4095보다 큼): `curcs` 를 통해 $$\text{curcs}=\text{token value}-4095$$ 을 계산하고 `curcs` 를 사용하여 해당 명령에 대한 정보를 조회한다;
* 에는 *문자 토큰* (토큰 값이 4095보다 작음): 문자 토큰을 그 구성 요소인 (문자 코드, 범주 코드) 쌍으로 분리한다.

### 처음에...

전개에 대한 탐구를 시작하기 위해, TeX 엔진이 처리할 수 있는 명령 집합을 어떻게 분류하거나 범주화하는지 살펴보겠습니다. 일단은 “전개 가능”이 아직 설명되지 않은, TeX 명령의 어떤 “속성”이라고 가정하십시오.

### “전개 가능” 명령이라는 개념

모든 TeX 기반 조판 프로그램(TeX “엔진”)은 두 가지 주요 “명령 부류”를 이해합니다:

* 실행 파일 엔진 자체에 내장된 명령: 이른바 *원시 명령*;
* 사용자가 정의한 명령: 이른바 *매크로*.

TeX 엔진은 또한 모든 명령을 두 그룹으로 분류하는 메커니즘으로서 “전개 가능함”, 즉 명령의 한 유형인 “동작”도 사용합니다:

* 전개 가능한 명령;
* 전개 불가능한 명령.

따라서 모든 명령 집합(프리미티브와 매크로 포함)은 다음 그림처럼 분류될 수 있다고 볼 수 있습니다:

![모든 TeX 명령의 분류를 보여 주는 도표](/files/05ed854f51622b1bdc3a34a95ca40e7795c2fe85)

아직 전개/전개 가능이 정확히 무엇인지 모르더라도, 다음을 볼 수 있습니다:

* 모든 매크로는 전개 가능한 명령으로 분류된다;
* 일부 프리미티브(내장) 명령도 전개 가능한 것으로 분류된다(대다수는 그렇지 않다).

**활성 문자에 대한 참고**: 프리미티브와 매크로 외에 “전개 가능” 항목의 세 번째 부류가 있습니다: 활성 문자—범주 코드 13이 할당된 모든 문자도 “전개 가능”으로 간주되는데, 이는 그것들이 “미니 매크로”로 처리되기 때문입니다.

#### TeX은 명령이 “전개 가능”한지 어떻게 아는가?

우리의 [TeX 토큰에 대한 논의](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) 에서 보았듯, 토큰은 TeX이 계산하여 입력 항목(문자 또는 명령)에 대한 정보를 “패키징”하는 데 사용하는 정수에 불과합니다. 또한 어떤 토큰(정수) 값이 주어지더라도 TeX은 필요할 경우 토큰화 과정을 되돌려 그 토큰을 “언패키징”하고, 그것이 나타내는 명령이나 문자에 대한 데이터를 드러낼 수 있다는 점도 언급했습니다.

TeX이 새 토큰을 만들 때 생성된 데이터나, 예를 들어 매크로나 다른 토큰 리스트에 저장된 기존 토큰에서 추출된 데이터를 사용하여, TeX은 내부 데이터 저장 테이블을 조회해 그 토큰이 나타내는 명령(또는 문자)에 대한 자세한 정보를 찾을 수 있습니다. 다음 그림은 명령 토큰을 생성하고(“패키징”) 그다음 TeX이 어떤 정보가 필요할 때 그 과정을 되돌려 특정 토큰 값이 나타내는 명령에 대한 데이터를 얻는 과정(토큰을 “언패키징”)을 요약합니다.

![TeX이 토큰을 패키징/언패키징하는 방식을 보여 주는 도표](/files/c9156ed1e175b7364299ec5f38ee8112b44b535b)

### 명령 코드

TeX이 모든 명령(프리미티브 또는 매크로)에 관해 저장하는 정보의 일부는 *명령 코드*라고 하는 것입니다. 이는 TeX 엔진이 명령을 분류하는 데 내부적으로 사용하는 정수 값으로, 비슷한 동작/기능을 가진 명령들은 같은 명령 코드를 공유합니다.

**참고**: 개별적인 *비활성*문자에 대해, 그 명령 코드는 *범주 코드* 입니다. 이는 TeX이 그 문자를 읽어들일(스캔할) 때 부여한 값입니다. 또한 문자들을 제외하면, 명령 코드는 TeX 내부 전용이라는 점에 유의하십시오. 매크로나 프리미티브 명령을 통해서는 그 세부 사항에 접근할 수 없습니다. 그런 세부 사항을 보려면 TeX 소스 코드를 읽어야 합니다!

다음은 명령 코드의 몇 가지 예입니다:

* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (및 다른 것들)은 모두 “박스 생성” 명령으로 분류되며 명령 코드 20을 공유한다;
* `\def`, `\edef`, `\gdef`, `\xdef` 는 모두 “매크로 정의” 명령이며 명령 코드 97을 공유한다;
* 모든 매크로는 명령 코드 111, 112, 113 또는 114 중 하나로 분류되는데, 서로 다른 명령 코드는 매크로를 정의할 때 `\long` 또는 `\outer` 의 사용에 따라 결정된다:
* 111: 비-long, 비-outer 매크로의 명령 코드(예: `\def\foo{...}`)
* 112: long, 비-outer 매크로의 명령 코드(예: `\long\def\foo{...}`)
* 113: 비-long, outer 매크로의 명령 코드(예: `\outer\def\foo{...}`)
* 114: long, outer 매크로의 명령 코드(예: `\long\outer\def\foo{...}`)

TeX은 또한 “전개 가능”으로 분류되는 명령의 하위 집합을 식별하는 데 명령 코드를 사용합니다. 이를 위해 TeX은 전개 가능한 명령을 100이라는 임계값을 넘는 명령 코드 값과 연결합니다(이 값은 Knuth의 원래 TeX, e-TeX, pdfTeX에서 사용됨). 따라서:

* *전개 불가능한* 명령들(대다수)은 명령 코드가 100 이하이고
* *전개 가능한* 명령들은 명령 코드가 100보다 큽니다

따라서 TeX이 특정 명령의 세부 사항을 조회해 명령 코드가 100보다 큰 것을 감지하면, TeX은 즉시 그것이 전개 가능하다는 것을 압니다. 모든 매크로와 소수의 프리미티브(내장 명령)에는 그것들이 전개 가능하다는 것을 나타내는 명령 코드가 할당되어 있습니다. 그런데 TeX은 왜 이 “전개 가능” 분류를 굳이 사용할까요? 짐작할 수 있듯, 이는 단지 그런 명령들이 다소 “특별”하다는 뜻입니다. 즉, TeX의 *확장*.

**참고 (문자)**: 문자가 활성(범주 코드 13)으로 정의되지 않은 한, 모든 문자는 전개 불가능합니다. 활성 문자는 한 글자짜리 “미니 매크로”라고 생각할 수 있습니다.

## 네, 네, 그런데 전개가 대체 뭐야???

우리는 토큰 값이 4095보다 크면 명령을 나타내는 데 사용된다는 것을 보았습니다. 따라서 TeX은 필요할 경우 그 토큰을 “언패키징”하여 해당 토큰이 나타내는 TeX 명령에 대한 정보에 접근할 수 있습니다. TeX은 그 명령의 명령 코드 값을 조회해 그것이 전개 가능이라는 특별 범주에 속하는지 확인할 수 있습니다. 그런데 TeX은 그 정보를 가지고 무엇을 하며, “전개 가능함”, 즉 전개란 *실제로 무엇을 의미할까요*?

### 전개: 한 묶음의 연산을 가리키는 일반 용어

TeX의 처리 중 특정 지점에서는 어떤 토큰이 전개 가능한 명령을 나타내는지 알아야 합니다:

* **아니오**: 만약 그 명령 토큰이 *작동하지* 전개 가능 범주에 속하지 않는다면, TeX은 단순히 그것을 다음 처리 단계로 “넘깁니다”.
* **예**: 만약 그 명령 토큰이 *실제로* 전개 가능 범주에 속한다면, TeX이 그 특정 토큰을 “걸러내는” 결과를 낳는 조치를 취해야 한다고 생각할 수 있습니다. TeX은 이를 “그 토큰을 전개한다”고 하거나 전개를 수행하는 과정이라고 부릅니다.

본질적으로 전개는 TeX이 *그 토큰을* 입력에서 제거하고 *그것을* 그 명령 또는 같은 명령 코드를 공유하는 명령군에 고유한 “전개 과정”에서 생겨나는 토큰으로 바꾸는 것을 포함합니다.

TeX이 토큰 전개를 언제 수행하고 언제 수행하지 않는지 아는 데는 연습과 경험이 필요합니다. The TeXbook 215쪽에는 전개 가능한 토큰이 전개되지 않는 상황이 나열되어 있습니다. 현실은 TeX의 전개 과정이 복잡하고 미묘하다는 것입니다.

#### 어떤 명령들이 전개 가능한가?

TeX 엔진이 전개 가능하다고 분류하는 프리미티브(내장) 명령 목록을 보면(예: The TeXbook 212\~215쪽), 실제로 전개는 TeX이 다소 이질적인 명령 집합의 동작을 설명하기 위해 사용하는 비교적 일반적인 용어라는 점이 분명해집니다. 특정(전개 가능한) 명령을 전개했을 때의 결과는 다양하며, 이를 전개 가능한 명령들을 기능별로 묶어 나열해 보면 알 수 있습니다. 개별 명령의 정확한 의미론은 여기서 중요하지 않습니다. 더 흥미로운 것은 그 동작의 일반적 결과들, 즉 전개가 실제로 *무엇을 하거나 달성하는가입니다*.

| **명령**                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **설명**                                                                                            | **전개 동작**                                                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>모든 매크로</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 저장된 명령/문자 토큰의 연속                                                                                  | <p>실제로 매크로 전개는 TeX이 읽을 토큰 리스트를 삽입하는 것을 뜻합니다. 여기에는 다음이 포함됩니다:</p><ul><li>모든 매크로 인자에 대한 토큰 리스트를 생성하는 것—그 과정에는 구분자 토큰을 식별/흡수하는 작업이 포함된다;</li><li>저장된 토큰 리스트(매크로 정의)를 가져오고, 첫 단계에서 생성된 매개변수 토큰을 그 매크로 정의에 삽입할 준비를 하는 것.</li></ul><p>사실상 매크로 전개는 <em>매크로 토큰을 제거하고</em> 를 입력에서 제거하고 <em>그것을</em> 정의에 들어 있는 토큰으로 대체합니다.</p> |
| <ul><li><code>\expandafter</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                | 전개 순서를 바꾸기                                                                                        | 토큰 필터링/섞기                                                                                                                                                                                                                                                                                                            |
| <ul><li><code>\noexpand</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                   | 전개를 방지하기(네, 놀랍게도 이것도 전개 가능한 명령으로 분류됩니다)                                                           | 전개를 지연하기(일종의 토큰 필터링)                                                                                                                                                                                                                                                                                                 |
| <ul><li><code>\input</code>, <code>\endinput</code>, <code>\scantokens</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                    | 소스 파일을 통해 새로운 토큰 소스를 입력하는 것과 관련됨—예, `\scantokens` 소위 “의사 파일”을 사용하기 때문에 이 범주에 속한다                  | 새 토큰의 소스로 작동하기                                                                                                                                                                                                                                                                                                       |
| <ul><li><code>\if</code>, <code>\ifcat</code>, <code>\ifnum</code>, <code>\ifdim</code>, <code>\ifodd</code>, <code>\ifvmode</code>, <code>\ifhmode</code>, <code>\ifmmode</code>, <code>\ifinner</code>, <code>\ifvoid</code>, <code>\ifhbox</code>, <code>\ifvbox</code>, <code>\ifx</code>, <code>\ifeof</code>, <code>\iftrue</code>, <code>\iffalse</code>, <code>\ifcase</code>, <code>\ifdefined</code>, <code>\ifcsname</code>, <code>\iffontchar</code></li></ul> | 조건식 시작                                                                                            | 토큰 “필터링” 시작: 다음에 나오는 토큰들 중 무엇을 처리할지 결정한다.                                                                                                                                                                                                                                                                            |
| <ul><li><code>\fi</code>, <code>\or</code>, <code>\else</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                                   | 조건식 종료                                                                                            | 토큰 “필터링” 중지: 어떤 토큰을 처리할지 결정한다                                                                                                                                                                                                                                                                                        |
| <ul><li><code>\csname</code>… <code>\endcsname</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                                            | 명령 토큰을 구성/생성한다                                                                                    | 토큰들의 연속을 하나의 명령 토큰으로 변환한다                                                                                                                                                                                                                                                                                            |
| <ul><li><code>\number</code>, <code>\romannumeral</code>, <code>\string</code>, <code>\meaning</code>, <code>\fontname</code>, <code>\jobname</code>, <code>\eTeXrevision</code></li></ul>                                                                                                                                                                                                                                                                                 | 무언가를 토큰의 연속으로 변환한다                                                                                | 일부 토큰을 생성한다(내부 양이나 값을 나타내는)                                                                                                                                                                                                                                                                                          |
| <ul><li><code>\the</code>, <code>\unexpanded</code>, <code>\detokenize</code></li></ul>                                                                                                                                                                                                                                                                                                                                                                                    | `\the` 토큰 삽입을 포함하여 여러 용도로 사용된다; `\detokenize` 토큰 리스트를 문자 토큰 리스트로 변환한다; `\unexpanded` 토큰의 전개를 방지한다 | 일부 토큰을 삽입/생성하거나 전개를 제어한다                                                                                                                                                                                                                                                                                             |
| <ul><li><code>\topmark</code>, <code>\firstmark</code>, <code>\botmark</code>, <code>\splitfirstmark</code>, <code>\splitbotmark</code>, <code>\topmarks</code>, <code>\firstmarks</code>, <code>\botmarks</code>, <code>\splitfirstmarks</code>, <code>\splitbotmarks</code></li></ul>                                                                                                                                                                                    | 특수한 용도를 가진 토큰 리스트에 접근하는 명령                                                                        | 저장된 토큰의 소스(토큰 리스트)에 접근한다                                                                                                                                                                                                                                                                                             |

위 목록을 바탕으로, 이 명령 집합에서 어떤 “일반적 동작”을 추출할 수 있을까요—전개에 대한 우리의 이해를 더 다듬기 위해서요? 대체로 명령을 전개한 결과는 몇 가지 핵심 활동으로 나뉩니다:

* 토큰 생성
* 토큰 삽입
* 토큰 필터링
* 다음 토큰의 전개를 변경/제어

### 그리고 마지막으로: 전개의 의미는?

활성 문자를 포함한 명령 토큰의 전개는 TeX이 **그 토큰을** 그 명령 토큰을 입력에서 제거하고 **그것을** 그 토큰을 그 전개 동작에서 발생한 다른 토큰들로 대체하는 것을 포함한다고 볼 수 있습니다: 토큰을 생성/삽입하거나, 토큰을 필터링하거나, 다음 토큰의 전개를 변경/제어하는 것 말입니다. 토큰이 한 번 전개되면 TeX은 그 전개 과정에서 생겨날 수 있는 토큰들을 계속 읽고/처리합니다. TeX이 정확히 언제 또는 어디서 전개를 수행할지는 전혀 다른 문제입니다. TeX 처리의 미묘함과 복잡성 때문에 이 글에서 완전히 다루기를 기대할 수는 없지만, TeX의 주요 입력 처리 동작에 대한 개요는 제공할 수 있습니다.

## 전개와 TeX의 구조

TeX이 전개 가능과 전개 불가능 명령을 어디서/어떻게 구분하는지 보는 가장 좋은 방법은 TeX의 소스 코드를 살펴보는 것이라고 해도 무방합니다.

내부적으로 TeX은 매우 복잡한 소프트웨어입니다. 따라서 TeX 작동에 본질적인 수많은 미묘한 동작을 완전히 설명하려는 시도는 비현실적입니다. 앞서 언급했듯이, TeX이 토큰을 읽으면서 실제로 언제 어디서 전개를 수행하는지는 “다소 복잡”합니다. 따라서 다음 논의는 TeX이 전개를 수행해야 하는 상태에 있다고 가정합니다. TeX이 토큰을 읽거나 생성하지만 전개는 수행하지 않는 상황에는 `\def` 매크로 정의 명령의 토큰을 생성/저장하는 경우나 토큰을 `\toks` 레지스터에 저장하는 경우가 포함됩니다.

다음 도표는 토큰의 입력과 처리를 다루는 TeX 구조의 핵심 부분을 단순화하여 개괄한 것입니다. 목적은 TeX의 입력 처리 중에 전개 가능한 토큰과 전개 불가능한 토큰이 어떻게 “필터링”되는지를 강조하는 데 있습니다. 여러 핵심 함수를 설명하기 위해 C 프로그래밍 언어가 사용되지만, 아마도 C 언어에 익숙하지 않더라도 기본 구조는 충분히 이해될 것입니다.

![](/files/0b0a7643c7b5e962e6c510d973ce11a32491c983)

### TeX 구조 도표 설명

개략적으로 말하면, TeX의 처리는 `maincontrol()` 이라는 함수에 의해 구동되며, TeX의 소스 코드에서 Knuth는 이를 “chief executive”라고 부르고 다음과 같이 설명합니다:

> “이제 우리는 `maincontrol` 루틴에 도달했습니다. 이 루틴에는 TeX의 여러 부분이 모두 제자리를 찾아 일을 하게 만드는 마스터 스위치가 들어 있습니다... 이것이 프로그램의 대단원입니다... 우리는 이제 거미줄의 중심, 대부분의 다른 부분을 건드리고 그것들을 연결하는 중추 신경계에 와 있습니다.”

다음 설명은 다소 단순화된 것이지만, TeX 기반 소프트웨어의 기본 구조가 어떤 느낌인지 보여 줍니다: 전개 가능한 명령이 어떻게 식별되고(“가로채지고”) TeX의 입력 처리 중에 걸러지는지 말입니다.

본질적으로 TeX의 초기 입력 처리 단계에서 TeX은 현재 명령(토큰)의 명령 코드 값을 사용해 전개 가능한 명령(매크로, 전개 가능한 프리미티브, 활성 문자)을 감지합니다. 그런 명령이 식별되면, 그것들은 “가로채져” “사전 처리”되는데, 즉 전개됩니다. 이 필터링(전개) 과정을 통해 TeX은 전개 가능한 명령을 입력에서 제거하고, 그에 해당하는 전개 동작에서 생겨난 토큰으로 대체합니다. 전개 과정이 끝나면 TeX은 그 전개에서 생성된 토큰들을 읽습니다. 전개 불가능한 항목만이 TeX 처리의 다음 단계인 “빅 스위치”로 넘어가며, 그곳에서 TeX은 모든 전개 불가능한 프리미티브 명령을 실행하고 문자를 조판합니다.

### maincontrol() 이해하기

다음 `maincontrol()` 함수에는 이른바 큰 [switch 문](https://en.wikipedia.org/wiki/Switch_statement)—Knuth는 이를 “big switch”라고 부릅니다—이 들어 있으며, TeX은 이를 사용해 모든 *전개 불가능한* 프리미티브 명령: 즉, 명령 코드가 100 이하인 것들을 처리합니다.

특정 명령(또는 문자)을 처리하기 위해 이 “big switch” 문은 TeX의 현재 모드와 다음의 조합을 사용합니다:

* 내부/외부 수직 모드, 또는
* 제한/문단 수평 모드, 또는
* 인라인/디스플레이 수학 모드

*와* 각 프리미티브 또는 문자의 명령 코드 값—문자의 명령 코드는 *비활성* 그 *범주 코드* 값입니다. 참고로 TeX의 6개 모드 모두에는 정수 값이 할당되어 있으며, TeX은 이를 사용해 다양한 구성 요소를 조판하는 사이에 현재 모드를 저장하고 복원할 수 있습니다—수식, 문단, 박스 등입니다. TeX의 각 모드에 할당된 정수는 다음과 같습니다:

|            |                     |          |
| ---------- | ------------------- | -------- |
| **모드**     | **의미**              | **모드 값** |
| 외부 수직      | 문단 사이(페이지 생성)       | 1        |
| 내부 수직      | 즉시 내부의 `\vbox{...}` | -1       |
| 수평         | 문단을 조판/작성할 때        | 102      |
| 제한 수평      | 즉시 내부의 `\hbox{...}` | -102     |
| 디스플레이 수학   | 조판 *표시하는* 방정식/수식    | 203      |
| 인라인(수식) 수학 | 조판 *인라인으로* 방정식/수식   | -203     |

내부 대 외부 수직 모드처럼 여러 모드의 보수(complement)에 음수를 사용하는 점에 주목하십시오. 명령을 `maincontrol()`에서 처리할 때, TeX은 현재 모드의 절댓값을 사용합니다—즉, 음수 기호는 무시합니다. 예를 들어 TeX이 두 수평 모드 중 하나에 있고 범주 코드 11인 문자를 처리해야 한다면, $$102 + 11 = 113$$ 를 사용해 빅 스위치 내부에서 분기하여, 두 수평 모드(문단 작성 또는 `\hbox`).

#### 다음 토큰 가져오기

다음 `maincontrol()` 함수는 `getxtoken()` 함수를 호출해 다음 입력 토큰을 가져오고, 이어서 `getxtoken()` 가 가장 낮은 수준의 입력 함수인 `getnext()`를 호출합니다. 이후 `getnext()` 가 작업을 완료하고 핵심 *전역 변수들*, `getxtoken()` 의 값을 설정한 뒤, 방금 읽어들인 항목이 매크로인지 전개 가능한 프리미티브인지 검사합니다.

에 대한 몇 가지 메모 `getnext()` 및 `getxtoken()`:

* **`getnext()`**: 이것은 TeX의 핵심 입력 함수입니다. 물리적 파일에서 입력된 문자들을 읽고 처리하거나, 토큰 리스트에서 토큰을 읽습니다. 참고로 `getnext()` 는 실제로 토큰 값을 계산하지는 않지만 여러 핵심 *전역* 변수(예: 명령 코드와 `curcs`)를 설정하며, 이 값들은 이후 처리에서 사용됩니다.
* **`getxtoken()`**: “확장된 토큰 얻기”는 `getnext()` 를 사용해 다음 입력 항목을 읽습니다. 그런 다음 방금 읽은 항목의 명령 코드를 검사하여 그 항목이 전개 가능한 명령을 나타내는지 확인합니다. 만약 그렇다면 그것은 전개되거나 매크로가 호출됩니다. 전개 불가능한 항목의 경우, `getxtoken()` 가 토큰 값을 계산하고 이 세부 정보는 다음 처리 단계인 “빅 스위치”로 전달되어 전개 불가능한 프리미티브는 실행되고 문자는 조판됩니다.

본질적으로 `getxtoken()` 를 통해 `maincontrol()`에서 처리되기 전에 모든 전개 가능한 항목이 “걸러집니다”. 그 결과 TeX의 “빅 스위치”는 전개 불가능한 프리미티브 명령만 처리하게 됩니다.

다시 한 번 강조하자면 위의 도표는 단순화된 것입니다. TeX의 다른 처리 영역들도 토큰 전개를 일으키기 때문입니다. 예를 들어:

* TeX이 숫자 값을 찾을 때(스캔할 때) 정수 탐색 과정에서 전개를 유발합니다( `getxtoken()`) ;
* 프리미티브 명령 `\romannumeral` 은 전개를 일으킨다—그 사실의 미묘한 사용법은 글 [에서 보라 `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) ;
* 다음 `\edef` (“전개된 정의”) 매크로 정의 명령은 전체 전개를 강제한다;
* TeX은 `\halign` 또는 `\valign` 의 프리앰블을 처리할 때 특정 지점에서 토큰을 전개한다(두 명령 모두 TeX의 표 조판 알고리즘과 관련되어 있다).

[1부](/latex/ko/in-depth-articles/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [2부](/latex/ko/in-depth-articles/22-how-does-expandafter-work-the-meaning-of-expansion.md) [3부](/latex/ko/in-depth-articles/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [4부](/latex/ko/in-depth-articles/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [5부](/latex/ko/in-depth-articles/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [6부](/latex/ko/in-depth-articles/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/ko/in-depth-articles/22-how-does-expandafter-work-the-meaning-of-expansion.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.
