> 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/mas-temas/24-how-tex-macros-actually-work-part-6.md).

# Cómo funcionan realmente las macros de TeX: Parte 6

[Parte 1](/latex/es/mas-temas/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/es/mas-temas/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/es/mas-temas/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/es/mas-temas/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/es/mas-temas/24-how-tex-macros-actually-work-part-6.md)

## Introducción y panorama general: La historia hasta ahora

A lo largo de las 5 partes anteriores de esta serie hemos visto:

* cómo TeX lee los caracteres dentro de un archivo de entrada y usa códigos de categoría para reconocer diferentes «clases» de caracteres y posteriormente convertirlos en tokens de caracteres y tokens de comando;
* que una macro, en efecto, se compone de cuatro secciones:

```
<primitiva de macro de TeX><nombre de macro><texto de parámetros>{<texto de reemplazo>}
```

donde:

* `<primitiva de macro de TeX>` = una de `\def`, `\edef`, `\gdef` o `\xdef`;
* `<nombre de macro>`=el nombre de tu macro, como `\\foo`;
* `<texto de parámetros>` puede ser “nulo” (no presente) o puede ser una cadena de tokens delimitadores y tokens de parámetros de macro;
* `<texto de reemplazo>` es el cuerpo real de tu macro: la sección que se “ejecuta” (se expande) cuando llamas a la macro.
* cómo la `<texto de parámetros>` sección puede contener una amplia gama de tokens y que TeX usa esta sección como una “plantilla de tokens” para hacer coincidir una llamada a macro con su definición original y averiguar los argumentos usados con la macro—y cómo TeX espera que tu uso de una macro coincida con su definición original;
* que, dentro de TeX, una definición de macro se almacena como una secuencia continua de tokens que representan las `<texto de parámetros>` y `<texto de reemplazo>` secciones.

Cuando usas un comando de macro, TeX primero comprobará si toma algún parámetro. Si es así, TeX entonces tiene que identificar los *argumentos* reales que se están usando en tu llamada a la macro. TeX tiene que probar tu llamada a la macro contra la definición de “plantilla de tokens” que ha almacenado en memoria. En concreto, TeX usa la definición interna (almacenada) de la `<texto de parámetros>` sección de tu macro como la plantilla *tokens* que son los argumentos reales, y que *tokens* están ahí solo para actuar como delimitadores.

## El significado de la expansión de macros

Ahora estamos, por fin, listos para pasar al tema más importante: cómo TeX procesa los argumentos de las macros y realmente ejecuta la macro: un proceso al que TeX se refiere como *expansión de macros*.

### Pero primero, un breve ejemplo: ¿algo raro?

Para “poner en contexto” la explicación del mecanismo por el cual TeX procesa macros y sus argumentos, usaremos un breve ejemplo para indicar los aspectos que debemos considerar.

#### Los argumentos primero se convierten en tokens

El siguiente ejemplo se basa en uno comentado en las páginas 114–5 de [The Advanced TeXbook](https://www.amazon.co.uk/Advanced-Texbook-David-Salomon/dp/0387945563) escrito por David Salomon. Se elige porque encapsula muy bien las ideas centrales dentro de una macro de TeX muy breve.

Durante las operaciones normales de TeX/LaTeX, el `$` signo tiene el código de categoría 3 (“math shift”), que conmuta TeX dentro/fuera del modo matemático en línea (`$...$`) o del modo matemático en display (`$$...$$`)—por supuesto, LaTeX usa `\(..\)` y `\[..\]` con los mismos propósitos.

Supongamos que queremos una macro que cambie el código de categoría de un `$` signo a, digamos, 11, para que podamos componerlo como cualquier carácter normal. Podemos usar el comando primitivo de TeX `\catcode` y nuestro primer intento de una macro así, `\docat`, podría ser

```
\def\docat #1{\catcode`\$=11 #1}
```

Sin embargo, cuando intentamos usarla, así:

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Pagué \docat{$90} por ese libro.
\end{document}
```

esperamos que TeX componga `Pagué $90 por ese libro.` pero falla con un mensaje de error:

```
! Falta un $ insertado.
<texto insertado>
                $
<para leer de nuevo>
                   \par
l.7
```

Por el error parece que el `$` usado en el argumento de nuestra macro sigue activando a TeX para componer matemáticas; claramente, TeX *no* cambió el código de categoría del `$` usado en el argumento de nuestra macro (`$90`). La pregunta es *por qué* ¿por qué TeX no cambió el código de categoría de `$` a 11 y lo compuso como un carácter normal? La respuesta corta es que TeX primero convierte los argumentos de macros en tokens **antes de que** antes de alimentarlos a la lista de tokens del `<texto de reemplazo>`—pero veremos los mecanismos subyacentes con mucho más detalle.

Lo que necesitamos recordar es que nuestra noción de que TeX usa texto/caracteres solo es relevante para el contenido del archivo que TeX está leyendo: en cuanto TeX ha leído cualquier carácter, estamos en el mundo de *tokens*. Las llamadas a macros de TeX funcionan con *tokens*, no con la representación *escrita/en texto* de los comandos de TeX/LaTeX—esto quedará más claro a medida que trabajemos el ejemplo.

Inicialmente, podríamos pensar que nuestro uso de la `\docat` macro en `Pagué \docat{$90} por ese libro.` es el mismo que escribir directamente el código equivalente de TeX (o LaTeX)—como el siguiente, que *sí* funciona:

```
\begin{document}
Pagué \catcode`\$=11 $90 por ese libro.
\end{document}
```

![Código de TeX en ejecución en Overleaf](/files/6aa30346edfd1d50929028d38ec04b711876eed7)

Sin embargo, como vimos arriba, la forma en que TeX procesa los argumentos de macros produce un resultado (`! Falta un $ insertado.`) que es bastante diferente de escribir el código de TeX: ahora exploraremos *por qué* lo que sucede.

### Macros y argumentos como listas de tokens

Para comprender plenamente el comportamiento de la `\docat` macro, y su argumento (`$90`), y por qué falla, de nuevo necesitamos visualizar la definición de la `\docat` macro y cualquier argumento usado (cuando se llama a \docat) como *listas de tokens*, no como una secuencia de caracteres.

A medida que TeX analiza tu texto de entrada, reconocería `\docat` como un comando de macro; después comprueba si toma algún parámetro—cómo hace TeX eso se explica en la siguiente sección para los lectores interesados en los detalles más finos.

#### Para quienes gustan de los detalles...

Después de llamar a la macro, TeX comprueba si el primer token (en la lista de tokens de la definición almacenada de la macro) es el **fin de coincidencia** token: si es así, TeX puede estar seguro de que la macro no toma ningún parámetro.

**Un ejemplo**

Los siguientes diagramas de listas de nodos comparan los conjuntos de tokens para dos macros:

* `\def\foo A#1B{#1}`: esto tiene `<texto de parámetros>` de `A#1B`, en consecuencia, el **fin de coincidencia** token es **no** el primer token, así que TeX procederá a buscar parámetros;
* `\def\foo{X}`: esto no tiene una `<texto de parámetros>` sección, en consecuencia, el **fin de coincidencia** token es el primero en la lista de tokens y TeX sabe que no debe buscar ningún parámetro.

![Cómo comprueba TeX si una macro toma parámetros](/files/c8baafc257c91d1bb76dbf2476f27b37074fa2db)

## Hacia el “gran final”: la expansión

Recordemos la pregunta: ¿por qué no funcionó la siguiente macro? Es decir, ¿por qué TeX no cambia el código de categoría de ningún `$` signo usado en el argumento de la `\docat` macro, como `\docat{$90}`?

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Pagué \docat{$90} por ese libro.
\end{document}
```

Como se explicó arriba, cuando TeX analiza tu entrada y reconoce un comando de macro—en un momento en que TeX va a ejecutarlo—TeX primero comprueba si esa macro toma algún parámetro. Si es así, TeX necesitará analizar más a fondo el archivo de entrada para identificar los *argumentos* reales que el usuario ha proporcionado para esta llamada concreta a la macro: TeX tiene que hacer esto **antes de que** antes de poder llamar al código real de la macro. Claramente, TeX necesita determinar los datos que el usuario quiere proporcionar a la macro.

Para identificar los argumentos presentes en la entrada (la llamada a la macro del usuario), TeX se guiará por la definición almacenada internamente de esa macro: concretamente, la `<texto de parámetros>` sección de la definición de macro almacenada (lista de tokens), que proporciona una especie de “plantilla de tokens”. Usando esa “plantilla de tokens”, TeX tiene que determinar cuáles *tokens* en la llamada a macro del usuario son solo *delimitadores* (esencialmente “puntuación”) y cuáles *tokens* forman parte de un *argumento*. Es cuando TeX encuentra un token **parámetro de coincidencia** en la definición de macro almacenada `<texto de parámetros>` sección (“plantilla de tokens”) que sabe que debe empezar a formar una *lista de tokens* para ese argumento en particular.

En cuanto TeX reconoce la necesidad de identificar el argumento del usuario, TeX analizará la entrada para generar tokens y comprobará con mucho cuidado, token por token, frente a la definición de macro almacenada. TeX sigue reuniendo tokens para un argumento hasta que detecta un token que en realidad es un delimitador, o si detecta el **fin de coincidencia** token: en cualquiera de los dos casos, TeX entonces sabe que ha llegado el momento de dejar de buscar tokens que formen parte de ese argumento.

### Por qué falló la macro \docat

Como se señaló, *antes de que* Para que TeX realmente pueda llamar a una macro, tiene que identificar y preparar cualquier argumento que vaya a usarse con esa macro. Sin embargo, para identificar el/los argumento(s), listo(s) para alimentar la macro, TeX tiene que generar cada argumento como una *lista de tokens*: y esa es la razón del `\docat`fallo de

En nuestro ejemplo, proporcionamos `\docat` a `$90` con un argumento de *pero ese argumento primero se* convierte en una lista de tokens *antes de que* a medida que TeX analiza la llamada a la macro —el argumento se convierte en tokens `$90`antes de que la macro se llame realmente. Aquí, para el argumento `$`, `9` y `0`.

, TeX generará tres tokens de caracteres: un token para cada uno de `$90`, antes de ser alimentados al cuerpo de la `\docat` macro:

![Lista de tokens de TeX generada para un argumento de macro](/files/10ab9ef6510a14b8ae05c8d49d9522e9b822a379)

En el gráfico anterior podemos ver claramente que la lista de tokens del argumento contiene el `$` como un token de carácter basado en un código de categoría de 3.

Como vimos en las Partes 1 a 3, los tokens de carácter se crean usando los valores de código de categoría *en vigor en el momento en que el carácter se lee*—es decir, en el momento en que se crea la lista de tokens del argumento (se convierte en tokens). En el momento en que se están tokenizando los argumentos, la `\docat` macro aún no se ha ejecutado, así que el cambio de código de categoría que pusimos en la llamada a la macro (``\catcode`\$=11``) *no* no afecta a los códigos de categoría que se están usando para generar los tokens del argumento.

Una vez que TeX ha generado una lista de tokens que representa el argumento de `$90`, esos tres tokens de carácter se introducen en la `<texto de reemplazo>`macro real `$` . Sin embargo, eso da como resultado que el *token de carácter* se introduzca como un `$` es *no* creado usando el código de categoría 3: “math on” y hemos visto que una vez que se forma un token de carácter, el código de categoría adjunto es permanente. El *introducido en la macro*no como un carácter *token de carácter* , sino como un `$` basado en el

### teniendo código de categoría 3.

TeX se refiere al proceso de “ejecutar” una macro como *expansión de macros*; un término que, en opinión de este autor, es un poco confuso, pero es la terminología aceptada así que seguiremos usándolo.

#### El verdadero significado de la expansión de macros

Después de que TeX detecta el `\docat` comando en la entrada del usuario, analiza los argumentos y genera una lista de tokens para su argumento(`$90`). Para ejecutar (expandir) la macro, TeX aparta su mirada del archivo de entrada del usuario y comienza a leer los tokens contenidos `\docat`de `<texto de reemplazo>` en la lista de tokens almacenada en la memoria de TeX.

A medida que TeX procesa la definición de `\docat`, entonces verá y ejecutará la serie de tokens originalmente usada para definir la macro (`**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**#1**`).

El siguiente gráfico muestra el proceso de expansión de la `\docat` macro: TeX deja de obtener tokens del archivo de entrada y comienza a leer tokens de la `<texto de reemplazo>` sección de la `\docat` definición de macro almacenada en memoria. TeX procede a ejecutar estos tokens ya preparados hasta que ve un **parámetro de salida** token que le indica a TeX que lea (“inyecte”) y “ejecute” los tokens del argumento en este punto. En nuestro ejemplo, esos son tres tokens de carácter que representan `$90` y eso da lugar a un error porque el token de carácter ya preparado para `$` tiene código de categoría 3. Como estamos tratando con tokens de carácter, no con caracteres, el `$` no se ve afectado por el cambio de código de categoría anterior causado por los tokens en ``\catcode`\$=11``.

![Mostrando el proceso de expansión de la macro \docat](/files/4159c1a06e2b295f6d665851a547617a8163ed77)

Después de que TeX ha procesado los tokens que representan ``\catcode`\$=11``a `$` el cambio de código de categoría para **parámetro de salida** ahora estará en vigor. Entonces TeX encuentra el “token especial” llamado **insertan** que le dice a TeX que *tokens*la lista de tokens del argumento. Sin embargo, esa lista de tokens es de tres `$` , el primero de los cuales es un token para un

### ¿Se puede arreglar la macro \docat?

A partir de las discusiones anteriores, queda claro que cualquier carácter que aparezca en los argumentos de macros se tokeniza usando los códigos de categoría en vigor en el momento en que tiene lugar la tokenización—que, en nuestro ejemplo, es *siempre* antes de que la `<texto de reemplazo>` del `\docat` macro se ejecute realmente. Entonces, ¿cómo podemos asegurarnos de que se cambien los códigos de categoría de los argumentos de una macro?

Una forma es modificar `\docat` para que sea una macro sin parámetros que solo haga el cambio de código de categoría —no tiene ningún argumento que tokenizar. Luego usamos una segunda macro, `\getarg`, que toma un único parámetro, y hacemos que ese macro tenga su argumento tokenizado cuando esté operativo el código de categoría apropiado para `$` .

```
\begin{document}
\def\docat{\catcode`\$=11 \getarg} % Sin parámetros, llama a una segunda macro \getarg
\def\getarg#1{#1} %1 parámetro cuyo argumento será tokenizado
Ahora puedes ejecutarlo así y funcionará:

Pagué \docat{$90} por ese libro.
\end{document}
```

Cuando usamos nuestra nueva versión de `\docat` (como esto `\docat{$90}`) *parece* como si el `$90` siguiera siendo usado como un argumento para la `\docat` macro. Sin embargo, como se discutió arriba, cuando TeX detecta `\docat` en la entrada comprueba si tiene algún argumento: ahora no lo tiene, así que TeX procede a ejecutarlo (expandirlo). La expansión de `\docat` es la secuencia de tokens `**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**espacio**`, `**getarg**` y esto tiene lugar *antes de que* TeX empieza a leer (tokenizar) los siguientes caracteres contenidos en el archivo de entrada —es decir, el grupo `{$90}`. Recuerda que cuando TeX expande una macro obtiene su siguiente entrada leyendo los tokens contenidos en la lista de tokens de la definición de esa macro; es decir, desde su `<texto de reemplazo>` sección almacenada en memoria.

TeX procesará y ejecutará la expansión de `\docat` y detectará la *token* **`getarg`**, reconociéndolo como un token que representa un comando que toma parámetros. En este punto, TeX buscará en el archivo de entrada el argumento de **`getarg`**: los caracteres: `{$90}`. Como siempre, estos se tokenizan, pero como TeX ha leído y procesado la expansión de `\docat`, los caracteres `$90` se tokenizan cuando el código de categoría de `$` se ha cambiado a 11. La definición (`<texto de reemplazo>`) de `\getarg` es simplemente `#1` lo que significa compone el argumento proporcionado, y eso es lo que sucede, dando como resultado un `$` con código de categoría 11 que se genera y se compone con seguridad.

## Observaciones finales: la historia en nodos

La secuencia de eventos que surge al reescribir `\docat` para usar la macro `\getarg` está contenida en el siguiente diagrama de listas de nodos anotado, que muestra el proceso de expansión de la macro `\docat`. Los lectores que deseen estudiar cuidadosamente este diagrama pueden descargar el gráfico como un archivo [PDF](https://assets.ctfassets.net/nrgyaltdicpt/7MOBdavza4WxAEQGISEEht/cabe5097d9063a6415bc553cd38237e6/newdocatexpansion.pdf) o [SVG](https://images.ctfassets.net/nrgyaltdicpt/2FIqqVRXjakdAzTpZsV0m9/10ccc1353741d42d3df18f1692d8aa84/newdocatexpansion--plain.svg) para uso sin conexión.

![Mostrando el proceso de expansión de la macro \docat modificada y de la macro \getarg](/files/a740c986aab86a2f35cb3eefcfd7a916f3b12302)

[Parte 1](/latex/es/mas-temas/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/es/mas-temas/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/es/mas-temas/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/es/mas-temas/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/es/mas-temas/24-how-tex-macros-actually-work-part-6.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/mas-temas/24-how-tex-macros-actually-work-part-6.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.