> 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/es/articulos-en-profundidad/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Cómo funciona \expandafter: el significado de la expansión
[Parte 1](/latex/es/articulos-en-profundidad/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/es/articulos-en-profundidad/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/es/articulos-en-profundidad/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/es/articulos-en-profundidad/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/es/articulos-en-profundidad/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/es/articulos-en-profundidad/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Introduciendo el concepto de «expansión» de TeX
Tras revisar [los tokens de TeX y las listas de tokens](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), el siguiente tema de fondo en nuestra lista para `\\expandafter` es el concepto de TeX de *expansión*: el proceso central de TeX `\\expandafter` está diseñado para trabajar con.
### Sobre el reto de explicar la expansión...
Para la mayoría de nosotros, el concepto de expansión de TeX, y las razones/mecanismos que lo sustentan, puede resultar confuso; no es fácil *plenamente* explicar de una manera simple y concisa. Muchas de las operaciones/procesos internos de TeX están interrelacionados de formas bastante complejas, lo que puede plantear dificultades al intentar «desmenuzar» ciertos aspectos de las operaciones de TeX: tratar de hablar de ellos aislados del programa en su conjunto. La expansión es sin duda un concepto que entra en esa categoría porque es un *fundamental* elemento del comportamiento de TeX, y está profundamente integrado en sus procesos internos. Sin embargo, este artículo intenta construir una explicación de la expansión, ofreciendo una base sobre la que los lectores puedan apoyarse.
Para explicar el mecanismo de expansión de TeX avanzaremos paso a paso, revisando una serie de temas relacionados/relevantes y enlazándolos para desarrollar una comprensión de este elemento crucial del comportamiento de TeX. Más adelante en el artículo, y para el lector más intrépido que disfrute del detalle, echamos un vistazo al interior de TeX en sí, resumiendo el código fuente clave que impulsa el proceso de expansión.
### Puntos clave sobre los tokens de TeX
A lo largo de la discusión siguiente es importante recordar que TeX puede obtener su siguiente elemento de entrada de dos fuentes:
1. **archivos de texto físicos**: generando *nuevos tokens* leyendo/examinando caracteres y comandos dentro de esos archivos, o
2. **listas de tokens**: obteniendo entrada leyendo de una lista de *tokens existentes,*preparados de antemano, almacenados en la memoria de TeX.
Recuerda también que TeX usa tokens como una forma conveniente de «empaquetar» de manera ordenada la información sobre cualquier elemento (carácter o comando) que ha leído.
Cuando TeX está generando *nuevos tokens* lo hará, *en el momento de producir el token*tener acceso inmediato a la información sobre el elemento cuyo valor de token está calculando. Por ejemplo, al generar nuevos tokens de comando, TeX calcula primero un valor llamado `curcs` que permite a TeX buscar información sobre el comando cuyo token está a punto de producir.
Sin embargo, si TeX está leyendo de listas de tokens (secuencias de *tokens almacenados*) primero tendría que «desempaquetar» cualquier token de esa lista antes de poder determinar qué representa cada token. Por ejemplo, TeX podría estar leyendo tokens almacenados como parte de una definición de macro: esos tokens habrían sido generados a partir de texto que ya fue leído hace tiempo, convertido en tokens y guardado. El tipo de token (carácter o comando) determina qué significa realmente el «desempaquetado» de TeX:
* para *tokens de comando* (valor del token > 4095): calcular `curcs` a través de $$\text{curcs}=\text{token value}-4095$$ y usar `curcs` para buscar información sobre el comando;
* para *tokens de caracteres* (valor del token < 4095): dividir el token de carácter en su par constituyente de (código de carácter, código de categoría).
### Al principio...
Para comenzar nuestra exploración de la expansión, veremos cómo los motores de TeX clasifican, o categorizan, el conjunto de comandos que pueden procesar. Por el momento, supón que «expandible» es simplemente alguna «propiedad» aún no explicada de un comando de TeX.
### La noción de comandos «expandibles»
Todos los programas de composición tipográfica basados en TeX («motores» de TeX) entienden dos «clases» principales de comandos:
* comandos integrados en el propio motor ejecutable: los llamados *primitivas*;
* comandos definidos por el usuario: los llamados *macros*.
Los motores de TeX también usan «ser expandible», un tipo de «comportamiento» de comando, como mecanismo para clasificar todos los comandos en dos grupos:
* comandos expandibles;
* comandos no expandibles.
Así que podemos considerar que el conjunto de todos los comandos (primitivos más macros) puede clasificarse como se muestra en la siguiente gráfica:
Aunque todavía no sabemos qué significa realmente expansión/expandible, es posible ver que:
* todas las macros se clasifican como comandos expandibles;
* algunos comandos primitivos (integrados) también se clasifican como expandibles (la gran mayoría no lo están).
**Nota sobre los caracteres activos**: además de los primitivos y las macros, existe una tercera clase de elemento «expandible»: los caracteres activos: cualquier carácter al que se le asigne el código de categoría 13 también se considera «expandible» porque se procesa como una «mini-macro».
#### ¿Cómo sabe TeX si un comando es «expandible»?
De nuestra [discusión sobre los tokens de TeX](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) sabemos que los tokens no son más que enteros que TeX calcula y usa para «empaquetar» información sobre un elemento de entrada: un carácter o un comando. También observamos que, dado cualquier valor de token (entero), TeX puede, si/cuando es necesario, invertir el proceso de tokenización para «desempaquetar» un token y revelar datos sobre el comando o carácter que representa.
Usando datos producidos cuando TeX crea un nuevo token, o datos extraídos de un token existente —por ejemplo, uno almacenado en una macro u otra lista de tokens—, TeX puede consultar sus tablas internas de almacenamiento de datos para encontrar información detallada sobre el comando (o carácter) representado por ese token. La siguiente gráfica resume el proceso de crear un token de comando («empaquetado») y luego, cuando TeX necesita alguna información, invertir el proceso («desempaquetar» el token) para obtener datos sobre el comando representado por un valor concreto de token.
### Códigos de comando
Parte de la información que TeX almacena sobre cada comando (primitivo o macro) es algo llamado su *código de comando*: un valor entero que los motores de TeX usan (internamente) para clasificar comandos; los comandos que tienen un comportamiento/funcionalidad similar comparten el mismo código de comando.
**Nota**: para un *no activos*carácter *código de categoría* individual, su código de comando es el
que se le asignó en el momento en que fue leído (examinado) por TeX. Ten en cuenta también que, salvo los caracteres, los códigos de comando son puramente internos a TeX: no son accesibles mediante macros ni comandos primitivos; para ver esos detalles tendrás que leer el código fuente de TeX.
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (y otros) se clasifican todos como comandos de «construcción de cajas» y comparten el código de comando 20;
* `\def`, `\edef`, `\gdef`, `\xdef` son todos comandos de «definición de macros» y comparten el código de comando 97;
* todas las macros se clasifican con uno de los códigos de comando 111, 112, 113 o 114: los distintos códigos de comando vienen determinados por el uso de `\long` o `\outer` al definir la macro:
* 111: código de comando para una macro no larga, no outer (p. ej., `\def\foo{...}`)
* 112: código de comando para una macro larga, no outer (p. ej., `\long\def\foo{...}`)
* 113: código de comando para una macro no larga, outer (p. ej., `\outer\def\foo{...}`)
* 114: código de comando para una macro larga, outer (p. ej., `\long\outer\def\foo{...}`)
TeX también usa códigos de comando para identificar el subconjunto de comandos clasificados como «expandibles». Para ello, TeX asocia los comandos expandibles con valores de código de comando que superan el valor umbral de 100 (el valor usado por el TeX original de Knuth, e-TeX y pdfTeX). En consecuencia:
* *no expandibles* los comandos (la gran mayoría) tienen un código de comando <= 100
* *expandibles* los comandos tienen un código de comando > 100
Por lo tanto, si TeX consulta los detalles de un comando concreto y detecta un código de comando > 100, TeX sabe de inmediato que es expandible. Todas las macros y un pequeño número de primitivos (comandos integrados) reciben un código de comando que indica que son expandibles: pero ¿por qué TeX se preocupa por esta clasificación «expandible»? Como quizá sospeches, simplemente significa que esos comandos son algo «especial»; es decir, pueden someterse al proceso de TeX de *expansión*.
**Nota (caracteres)**: salvo que un carácter haya sido definido como activo (código de categoría 13), todos los caracteres no son expandibles. Los caracteres activos pueden considerarse «mini macros» de una sola letra.
## Sí, sí, pero ¿qué es la expansión???
Observamos que los valores de token mayores que 4095 se usan para representar comandos; en consecuencia, TeX puede, si/cuando es necesario, «desempaquetar» ese token para acceder a la información sobre el comando de TeX representado por ese token. TeX puede buscar el valor del código de comando de ese comando para determinar si entra en la categoría especial de ser expandible. Pero, ¿qué hace TeX con esa información y qué significa realmente «ser expandible», es decir, la expansión, *realmente*?
### Expansión: un término general para un conjunto de operaciones
En ciertos puntos del procesamiento de TeX necesita saber si un token representa un comando expandible:
* **No**: si ese token de comando *no* entra en la categoría de expandibles, TeX simplemente lo «pasa» a la siguiente etapa del procesamiento.
* **Sí**: si ese token de comando *sí* entra en la categoría de expandibles, puedes pensar que TeX necesita tomar una acción que termina «filtrando» ese token concreto al realizar un proceso al que TeX se refiere como «expandir ese token» o realizar la expansión.
En esencia, la expansión implica que TeX *eliminar* retire ese token de su entrada y *reemplazar* lo sustituya por tokens que surgen del «proceso de expansión» específico de ese comando o grupo de comandos que comparten el mismo código de comando.
Se necesita práctica y experiencia para saber cuándo TeX está, y cuándo no está, realizando la expansión de tokens: la página 215 de The TeXbook enumera las situaciones en las que un token expandible no se expande. La realidad es que el proceso de expansión de TeX es complejo y matizado.
#### ¿Qué comandos son expandibles?
Si miras una lista de comandos primitivos (integrados) que los motores de TeX clasifican como expandibles (p. ej., páginas 212–215 de The TeXbook) se hace evidente que, en la práctica, la expansión es un término bastante general que TeX usa para describir el comportamiento de un grupo algo ecléctico de comandos. Los resultados de la expansión de un comando (expandible) concreto sí varían y esto puede verse enumerando un conjunto de comandos expandibles, agrupados por su funcionalidad. La semántica precisa de los comandos individuales no es importante aquí; lo que más interesa son las consecuencias generales de sus acciones: lo que su expansión realmente *hace o logra*.
| **Comando** | **Descripción** | **Comportamiento de expansión** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | Una secuencia almacenada de tokens de comando/carácter | En la práctica, la expansión de macros significa insertar una lista de tokens para que TeX la lea. Esto implica:
- crear listas de tokens para cualquier argumento de macro; ese proceso incluye identificar/absorber tokens delimitadores;
- recuperar una lista de tokens almacenados (la definición de macro) y prepararse para insertar (en la definición de macro) los tokens de parámetro creados en el primer paso.
En efecto, la expansión de una macro elimina el token de macro de la entrada y lo reemplaza por los tokens contenidos en la definición.
|
| | Cambiar el orden de expansión | Filtrado/redistribución de tokens |
| | Impedir la expansión (sí, sorprendentemente se clasifica como un comando expandible) | Retrasar la expansión (una especie de filtrado de tokens) |
| \input, \endinput, \scantokens
| Relacionado con introducir una nueva fuente de tokens mediante archivos fuente: sí, `\scantokens` entra en esta categoría debido a su uso de los llamados «pseudoarchivos» | Actuar como fuente de nuevos tokens |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Iniciar una expresión condicional | Iniciar el «filtrado» de tokens: decidir cuáles de los tokens siguientes procesar. |
| | Terminar una expresión condicional | Detener el «filtrado» de tokens: decidir qué tokens procesar |
| | Construir/generar un token de comando | Convertir una serie de tokens en un único token de comando |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Convertir algo en una secuencia de tokens | Generar algunos tokens (que representan una cantidad o valor interno) |
| \the, \unexpanded, \detokenize
| `\\the` tiene varios usos, incluida la inserción de tokens; `\detokenize` convierte una lista de tokens en una lista de tokens de carácter; `\unexpanded` impide la expansión de tokens | Insertar/generar algunos tokens o controlar la expansión |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Comandos para acceder a listas de tokens que tienen usos especializados | Acceder a una fuente de tokens almacenados (listas de tokens) |
Con base en la lista anterior, ¿es posible extraer algunos «comportamientos generales» de esta colección de comandos para afinar aún más nuestra comprensión de la expansión? Con bastante aproximación, los resultados de expandir un comando se reducen a unas pocas actividades clave:
* generación de tokens
* inserción de tokens
* filtrado de tokens
* cambiar/controlar la expansión del siguiente token
### Y por último: ¿el significado de la expansión?
Podemos considerar que la expansión de un token de comando (incluidos los caracteres activos) implica que TeX **eliminar** ese token de comando de la entrada y **reemplazar** ese token por otros tokens que surgen de su comportamiento de expansión: generar/insertar tokens, filtrar tokens o cambiar/controlar la expansión del siguiente token. Una vez que un token ha sido expandido, TeX seguiría leyendo/procesando los tokens que pudieran surgir del proceso de expansión. Exactamente cuándo o dónde TeX realizará la expansión es una cuestión muy distinta: debido a los matices y complejidades del procesamiento de TeX, no podemos esperar abordarla por completo en este artículo, pero sí podemos ofrecer una visión general del comportamiento principal de entrada de TeX.
## La expansión y la estructura de TeX
Probablemente, la mejor manera de ver cómo/dónde TeX distingue entre comandos expandibles y no expandibles es mirar el código fuente de TeX.
Internamente, TeX es una pieza de software extremadamente compleja; en consecuencia, no es práctico intentar una descripción completa de los muchos comportamientos matizados inherentes al funcionamiento de TeX. Como se señaló, exactamente cuándo o dónde TeX realizará realmente la expansión al leer tokens es «algo complejo»; por lo tanto, la discusión siguiente asume que TeX está en un estado que requiere que la expansión tenga lugar. Las situaciones en las que TeX estaría leyendo/creando tokens, pero sin realizar expansión, incluyen crear/almacenar tokens para el `\def` comando de definición de macro o almacenar tokens en un `\\toks` registro.
El siguiente diagrama ofrece una visión general simplificada de las partes centrales de la estructura de TeX que se ocupan de la entrada y el procesamiento de tokens: el objetivo es destacar la forma en que los tokens expandibles y no expandibles son «filtrados» durante el procesamiento de entrada de TeX. El lenguaje de programación C se usa para describir las diversas funciones clave, pero, con suerte, la estructura básica debería quedar clara aunque no estés familiarizado con el lenguaje C.
### Explicación del diagrama de la estructura de TeX
A grandes rasgos, el procesamiento de TeX está impulsado por una función llamada `maincontrol()` que, en el código fuente de TeX, Knuth denomina el «chief executive» y describe así:
> «Llegamos ahora a la `maincontrol` rutina, que contiene el interruptor maestro que hace que todas las distintas partes de TeX hagan lo que les corresponde, en el orden correcto… este es el gran clímax del programa… Ahora estamos en el centro de la red, el sistema nervioso central que toca la mayoría de las otras partes y las une.»
La siguiente descripción es algo simplificada, pero da una idea del entramado subyacente del software basado en TeX: cómo se identifican («interceptan») y se filtran los comandos expandibles durante el procesamiento de entrada de TeX.
En esencia, durante la etapa más temprana del procesamiento de entrada de TeX se usa el valor del código de comando del comando actual (token) para detectar comandos expandibles (macros, primitivos expandibles y caracteres activos); si se identifica uno, esos comandos son «interceptados» y «preprocesados» mediante su expansión. A través de este proceso de filtrado (expansión), TeX elimina los comandos expandibles de la entrada y los reemplaza por tokens que surgen de su comportamiento de expansión respectivo. Una vez completado el proceso de expansión, TeX leerá los tokens producidos por esa expansión. Solo los elementos no expandibles se pasan a la siguiente etapa del procesamiento de TeX: el «gran interruptor» donde TeX ejecutará todos los comandos primitivos no expandibles y compondrá los caracteres.
### Entender maincontrol()
El `maincontrol()` la función contiene una gran llamada [instrucción switch](https://en.wikipedia.org/wiki/Switch_statement)—Knuth la llama el «gran interruptor»— que TeX usa para ejecutar todos los *no expandibles* comandos primitivos: los que tienen un código de comando <=100.
Para ejecutar un comando (o carácter) concreto, esta instrucción del «gran interruptor» usa una combinación del modo actual de TeX:
* modo vertical interno/outer, o
* modo horizontal restringido/de párrafo, o
* modo matemático en línea/de exhibición
*más* el valor del código de comando de cada primitivo o carácter: el código de comando de un *no activos* carácter es su *código de categoría* valor. A modo de referencia, los 6 modos de TeX tienen asignado un valor entero que puede usarse para que TeX guarde y restaure su modo actual mientras alterna entre componer diversos constructos: matemáticas, párrafos, cajas, etc. Aquí están los enteros asignados a los distintos modos de TeX:
| | | |
| ----------------------------- | --------------------------------------------------------------------------------- | ------------------ |
| **Modo** | **Significado** | **Valor del modo** |
| Vertical externa | Entre párrafos (construyendo páginas) | 1 |
| Vertical interna | Inmediatamente dentro de una `\vbox{...}` | -1 |
| Horizontal | Al componer/construir párrafos | 102 |
| Horizontal restringida | Inmediatamente dentro de un `\hbox{...}` | -102 |
| Matemática en display | Composición tipográfica de *modo matemático de visualización* ecuaciones/fórmulas | 203 |
| Matemática en línea (fórmula) | Composición tipográfica de *modo matemático en línea* ecuaciones/fórmulas | -203 |
Observa el uso de valores negativos para el complemento de los distintos modos, como entre modo vertical interno y modo vertical externo. Al procesar comandos en `maincontrol()`TeX usa el valor absoluto del modo actual; es decir, ignora el signo negativo. Así que, por ejemplo, si TeX está en cualquiera de sus modos horizontales y necesita procesar un carácter con código de categoría 11, usaría la suma $$102 + 11 = 113$$ dentro de su «gran interruptor» para derivar al código que procesa esos caracteres en cualquiera de los modos horizontales (construyendo párrafos o dentro de un `\hbox`).
#### Obtener el siguiente token
El `maincontrol()` la función llama a la función `getxtoken()` para obtener el siguiente token de entrada; a su vez, `getxtoken()` llama a la función de entrada de nivel más bajo `getnext()`. Después de `getnext()` haber completado su trabajo y haber establecido el valor de las variables clave *variables globales*, `getxtoken()` comprueba si el elemento recién leído representa una macro o un primitivo expandible.
Algunas notas sobre `getnext()` y `getxtoken()`:
* **`getnext()`**: esta es la función de entrada central de TeX. Lee y procesa caracteres introducidos desde un archivo físico o lee tokens de una lista de tokens. Ten en cuenta que `getnext()` en realidad no calcula valores de token, pero sí establece una serie de variables globales clave *globales* variables (p. ej., el código de comando y `curcs`) que se usan más adelante en el procesamiento.
* **`getxtoken()`**: «get expanded token» usa `getnext()` para leer el siguiente elemento de entrada. Luego prueba el código de comando del elemento recién leído para comprobar si ese elemento representa un comando expandible: si es así, se expande o se llama a la macro. Para los elementos no expandibles, `getxtoken()` calcula un valor de token y estos detalles se pasan a la siguiente etapa del procesamiento: el «gran interruptor», donde se ejecutan los primitivos no expandibles y se componen los caracteres.
En esencia, es mediante `getxtoken()` que todos los elementos expandibles son «filtrados» antes de ser procesados en `maincontrol()`: esto hace que el «gran interruptor» de TeX solo procese comandos primitivos no expandibles.
Una vez más, subrayamos que el diagrama anterior es una simplificación porque otras áreas del procesamiento de TeX también harán que los tokens se expandan; por ejemplo:
* cuando TeX busca (escanea) valores numéricos activará la expansión en su búsqueda de enteros (llamando a `getxtoken()`) ;
* el comando primitivo `\romannumeral` provoca expansión: véase el artículo [Expansión usando `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) para un uso matizado de ese hecho;
* El `\edef` («definición expandida») el comando de definición de macro fuerza la expansión completa;
* TeX expandirá tokens en ciertos puntos al procesar el preámbulo de un `\halign` o `\valign` (ambos comandos están relacionados con los algoritmos de composición de tablas de TeX).
[Parte 1](/latex/es/articulos-en-profundidad/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/es/articulos-en-profundidad/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/es/articulos-en-profundidad/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/es/articulos-en-profundidad/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/es/articulos-en-profundidad/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/es/articulos-en-profundidad/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/es/articulos-en-profundidad/22-how-does-expandafter-work-the-meaning-of-expansion.md?ask=&goal=
```
`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.