> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Cómo funciona \expandafter: desde los principios básicos hasta explorar el código fuente 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) ## Introducción Ahora hemos cubierto los temas de fondo necesarios para una exploración completa de `\\expandafter`: * los fundamentos de los tokens de TeX y cómo se calculan; * los principios detrás del proceso de expansión de TeX; * el uso/creación de listas temporales de tokens por parte de TeX durante el procesamiento del documento; * cómo TeX usa y “maneja” múltiples fuentes de entrada (incluidas las listas temporales de tokens). En este artículo reuniremos estos temas/conceptos para explicar los mecanismos subyacentes del `\\expandafter` comando: en resumen, cómo funciona. ## Y así, para \\\expandafter La idea detrás de `\\expandafter` es forzar la expansión de un comando (token) antes de que TeX lo hiciera normalmente. Dados dos tokens, $$\mathrm{T\_1}$$ y $$\mathrm{T\_2}$$ la acción de `\\expandafter` $$\mathrm{T\_1T\_2}$$ da como resultado que TeX procese $$\mathrm{T\_1}\text{<}$$la expansión de $$\mathrm{T\_2}\text{>}$$, donde $$\text{<}\dots\text{>}$$ indica una lista de tokens. TeX expande $$\mathrm{T\_2}$$ con anticipación para que el token $$\mathrm{T\_1}$$ (p. ej., una primitiva o una macro) pueda ver, o actuar sobre, los tokens resultantes de la expansión de $$\mathrm{T\_2}$$. Si el token $$\mathrm{T\_2}$$ representa un elemento no expandible, como un carácter no activo o (la mayoría de) las primitivas, la acción de `\\expandafter` no cambia nada: TeX continuaría procesando tokens $$\mathrm{T\_1T\_2}$$ de la manera normal. ### Introducción al uso de \\\expandafter Si no has usado `\\expandafter`, aquí hay un ejemplo usándolo con la primitiva `\\uppercase{...}`. Supongamos que quisiéramos componer el nombre de nuestro principal `.tex` archivo de entrada, pero en letras mayúsculas. Quizá conozcamos los siguientes comandos primitivos de TeX: * `\\uppercase`: hace lo que su nombre sugiere, convierte los tokens de caracteres a su equivalente en mayúsculas (donde exista); * `\\jobname`: como hemos visto, se expande para dar el nombre del principal `.tex` archivo. Suponiendo que nuestro archivo TeX se llama `mycode.tex` podríamos esperar razonablemente `\\uppercase{\\jobname}` que compusiera `MYCODE`. Pero no, compone `mycode` en minúsculas. ¿Qué salió “mal”? Si escribimos el uso general de `\\uppercase` como ``` \\uppercase{} ``` podemos decir que `\\uppercase` recorre `` y solo operará (cambiará la caja de) los *tokens de caracteres* que detecta dentro de la ``: todos los tokens que no son de caracteres son *ignorados* porque `\\uppercase` no “mirará dentro” (expandirá) de los tokens que no son de caracteres para ver qué contienen o representan. Como un token es simplemente un valor entero, todo lo que `\\uppercase` tiene que hacer es recorrer la lista de tokens para comprobar si el valor numérico de cada token en `` cae dentro del rango de valores que indican un token de carácter. Por cierto, `\\uppercase` también *cambiará la caja de los caracteres activos* para crear un carácter activo en mayúsculas que, como sigue siendo activo, también tendrá que haber sido definido; de lo contrario, TeX generará un error: `Secuencia de control indefinida`, pero nos desviamos... Por ejemplo, incluso si definimos una macro que es solo texto ``` \\def\\foo{some lower-case text} ``` entonces `\\uppercase{\\foo}` sigue componiendo `some lower-case text` y no `SOME LOWER-CASE TEXT` como esperaríamos, simplemente porque la acción de `\\uppercase` no intenta determinar qué `\\foo` representa: lo ve `\\foo` como un token de comando y lo ignora, igual que hizo con `\\jobname`. ### ¿Cómo podemos arreglar esto? \\\expandafter al rescate Para componer una versión en mayúsculas del nombre del archivo, necesitamos modificar `\\uppercase{\\jobname}` forzando a TeX a reemplazar `\\jobname` con su expansión (una secuencia de tokens de caracteres) *antes de que* `\\uppercase` entre en acción. Una vez más, se usa la expansión para eliminar el `\\jobname` token (comando) y reemplazarlo con el resultado de su expansión (una lista de tokens que contiene tokens de caracteres). Así que, si escribimos ``` \\uppercase\\expandafter{\\jobname} ``` entonces funciona: `MYCODE` se compondría. Lo que ocurre es que TeX empieza a procesar `\\uppercase` e inmediatamente comprueba el carácter obligatorio de llave de apertura (`{`); sin embargo, TeX detecta un `\\expandafter` comando, lo que hace que temporalmente “desvíe su atención” al procesar `\\expandafter{\\jobname}`. Si comparamos `\\expandafter` $$\mathrm{T\_1T\_2}$$ con nuestro ejemplo `\\expandafter{\\jobname}` podemos ver * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\\jobname`token Donde `{`token y `\\jobname`token se refieren a los valores de token calculados por TeX: la notación de subíndice token se usa para recordarnos que TeX trabaja en el mundo de los tokens enteros. Escribir `\\uppercase\\expandafter{\\jobname}` funciona porque, a grandes rasgos (los detalles vendrán después), `\\expandafter` hace que TeX realice las siguientes tareas: 1. leer y guardar la llave de apertura `{`token; 2. leer el siguiente token: `\\jobname`token. TeX reconoce que `\\jobname`token representa un comando expandible y lo expande. `\\jobname`token se reemplaza por su expansión: una serie de tokens de caracteres; 3. después de expandir el `\\jobname` comando, TeX pone el `{`$$\_\mathrm{token}$$ “de vuelta en la entrada” y usa la lista de tokens resultante de la expansión de `\\jobname` para que TeX lea `\\uppercase{`token``lista de tokens (caracteres)`}`, y esto produce el resultado deseado. El siguiente diagrama muestra cómo TeX procesa `\\uppercase\\expandafter{\\jobname}`—lee el gráfico desde abajo y avanza hacia arriba para seguir el flujo del proceso. ![Cómo funciona \\\expandafter](/files/44b0df747730a5943e571a38ea904f2e1cfe29db) Las siguientes notas explican las distintas etapas del procesamiento. 1. TeX empieza a procesar `\\uppercase` y comprueba el carácter obligatorio de llave de apertura (`{`) pero detecta un `\\expandafter` comando. 2. Si comparamos `\\expandafter` $$\mathrm{T\_1T\_2}$$ a nuestra entrada de `\\expandafter{\\jobname}` podemos ver $$\mathrm{T\_1} =$$`{`token y $$\mathrm{T\_2} =$$`\\jobname`token. Nótese que aquí usaremos el subíndice token para indicar que TeX está procesando valores enteros de tokens. 3. `\\expandafter` lee y luego guarda temporalmente el `{`token almacenando ese valor entero de token en una variable interna. Más adelante, TeX reinsertará ese token en la entrada, después de procesar el `\\jobname` comando. 4. `\\expandafter` lee el siguiente token, `\\jobname`token, y expande el `\\jobname` comando. 5. La expansión de `\\jobname` crea una lista temporal de tokens que contiene una secuencia de tokens de caracteres que representan el `.tex` nombre del archivo. Nótese que todos los tokens de caracteres generados por `\\jobname` se calculan usando el código de categoría 12. 6. Una vez que `\\jobname` ha sido expandido, TeX vuelve a insertar el token guardado en el paso 3 (`{`token) y lo vuelve a poner en la entrada. TeX hace eso creando otra lista de tokens que contiene el *único* `{`token 7. TeX ha terminado de procesar `\\expandafter`, dando como resultado dos listas de tokens listas para usarse como fuentes de entrada de TeX. TeX ahora vuelve a procesar `\\uppercase` pero ha configurado su entrada de modo que las dos listas de tokens creadas por `\\expandafter` se conviertan en la fuente de tokens para `\\uppercase`—que ahora ve `\\uppercase{`token``lista de tokens (caracteres)`}`. `\\uppercase` ahora ve una secuencia de tokens de caracteres y puede producir el resultado deseado. 8. Después de leer todos los tokens de caracteres producidos por `\\jobname`, TeX vuelve a obtener tokens de su fuente de entrada anterior (nuestro `.tex` archivo) desde donde leerá el siguiente token: la llave de cierre `}` requerida para terminar la lista de tokens que debe ser procesada por `\\uppercase`. ### \\\expandafter y listas internas de tokens Las listas temporales de tokens son un *vital* elemento del `\\expandafter`comportamiento de procesamiento: comprender el uso y la existencia de esas listas de tokens puede ayudar a aclarar cómo `\\expandafter` logra sus resultados, especialmente al intentar escribir, o entender, macros que hacen uso de múltiples `\\expandafter` comandos consecutivos para lograr formas más complejas de procesamiento de tokens: `\\expandafter\\expandafter\\expandafter...` Otro elemento clave del `\\expandafter`comportamiento, especialmente con múltiples `\\expandafter` comandos consecutivos, es el uso de *recursión* (dentro del propio software de TeX), un tema que consideraremos más adelante en este artículo. Para ayudar aún más a nuestra comprensión de las listas temporales de tokens, veremos un ejemplo más de `\\expandafter`, esta vez con el `\\the` comando. #### \\\expandafter y listas internas de tokens: ejemplo 2 En este ejemplo veremos cómo `\\expandafter` puede usarse para influir en tokens almacenados en un registro de tokens a través del `\\toks` comando. Estas son las primitivas de TeX que utilizaremos: * `**\\count** *registro*=*número*`: una primitiva de TeX utilizada para almacenar el valor `*número*` en la ubicación de TeX `*registro*`; * `**\\toks** *registro*={*lista de tokens*}`: una primitiva de TeX utilizada para almacenar `*lista de tokens*` en la ubicación del registro de tokens `*registro*`—guardando una secuencia de tokens para su uso posterior; * `**\\the** *token*`: un comando primitivo expandible de TeX que procesa `*token*`, aunque los resultados exactos dependen de la naturaleza del `*token*` que se esté procesando. `\\the` tiene varios usos: entre ellos, componer el valor almacenado en un parámetro o variable de TeX (p. ej., un registro). Otros usos de `\\the` incluyen insertar una copia de los tokens almacenados en un registro de tokens. Aquí usaremos `\\the` para componer el valor almacenado en un `\\count` registro. Empezaremos con el siguiente código TeX para almacenar el valor `12345` en el `\\count` registro `99`: ``` \\count99=12345 ``` Si queremos componer el valor almacenado en `\\count99` podemos usar `\\the\\count99` (o `\\number\\count99`). A continuación usaremos el `\\toks` comando para almacenar algunos tokens en el registro de tokens `99`: ``` \\toks99={\\the\\count99 } ``` La lista de tokens almacenada en el registro de tokens `99` contendría lo siguiente: | | | | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | | **Valor de token de TeX** | **Elemento representado** | | 5382 | `\\the` | | 7885 | `\\count` | | 3129 | `9` (código de carácter 57 con código de categoría 12), lo que da como resultado un valor de token de $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (código de carácter 57 con código de categoría 12), lo que da como resultado un valor de token de $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (código de carácter 32 con código de categoría 10), lo que da como resultado un valor de token de $$256 \times 10 + 32 = 2592$$ | Nótese que la lista de tokens creada por `\\toks99` sí *no* contiene el valor real de datos almacenado en `\\count99` porque el `\\toks` comando no realiza expansión: simplemente crea tokens y los almacena. En nuestro ejemplo, `\\the` no se expande, así que no procesa `\\count99`; aquí `\\the` simplemente se convierte en un token (valor 5382) y se almacena en la lista de tokens. Si queremos que la `\\toks99` lista de tokens contenga tokens que representen los datos almacenados en `\\count99` necesitaremos alguna forma de crear esos tokens (hacerlos disponibles) para que el `\\toks` comando pueda acceder a ellos. Y, por supuesto, `\\expandafter` puede hacer esto por nosotros. Si escribimos: ``` \\toks99=\\expandafter{\\the\\count99 } ``` la acción/procesamiento del `\\toks` comando quedará “en espera” mientras `\\expandafter` provoca (fuerza) la expansión de `\\the` que, a su vez, actúa sobre `\\count` para generar una lista temporal de tokens que contiene tokens de caracteres que representan los datos almacenados en `\\count99`. Un detalle pequeño pero importante es el `` carácter después de los dígitos `99`: ese `` carácter actúa para terminar el proceso de exploración de TeX cuando busca una cantidad numérica. Aquí, la acción de `\\expandafter` es muy similar al `\\jobname` ejemplo. 1. Lee y guarda la llave de apertura `{`token. 2. Lee el siguiente token, `\\the`token, que representa un comando expandible, así que TeX lo expande. `\\expandafter` fuerza la expansión de `\\the` que luego actúa sobre `\\count99` para convertir los datos almacenados en `\\count` registro `99` (el número 12345) en una lista temporal de tokens. Esa lista contendrá tokens de caracteres que representan los dígitos `1`, `2`, `3`, `4` y `5`—tokens de caracteres con código de categoría 12. 3. Después de expandir y procesar `\\the`, TeX pone el `{`token “de vuelta en la entrada” y usa la lista de tokens resultante de `\\the\\count99` para que TeX lea `\\toks99={`token``lista de tokens (caracteres)`}` y esto produce el resultado deseado. Esta secuencia de eventos se resume en el siguiente diagrama: lee el gráfico desde abajo y avanza hacia arriba para seguir el flujo del proceso. ![Cómo funciona \\\expandafter](/files/c8ff60a5e41b4fe6ebba86b2fefd921111a93cc2) 1. TeX empieza a procesar `\\toks`; ve el opcional `=` signo, luego comprueba el carácter obligatorio de llave de apertura (`{`, o cualquier carácter con código de categoría 1) utilizado para indicar el inicio de una lista de tokens. Sin embargo, TeX detecta un `\\expandafter` comando y procede a ejecutar eso en su lugar. 2. Si comparamos `\\expandafter` $$\mathrm{T\_1T\_2}$$ a nuestra entrada de `\\expandafter{\\the\\count99 }` podemos ver $$\mathrm{T\_1} =$$ `{`token y $$\mathrm{T\_2} =$$ `\\thetoken`. 3. `\\expandafter` lee y luego guarda temporalmente el `{`token (TeX almacena temporalmente ese valor entero de token en una variable interna). Más adelante, TeX reinsertará ese token en la entrada, después de procesar `\\the` 4. `\\expandafter` lee el siguiente token, `\\the`token y lo expande. 5. La expansión de `\\the` crea una lista temporal de tokens a partir del procesamiento de `\\count99`—esa lista de tokens contiene una secuencia de tokens de caracteres que representan el valor de datos almacenado en el `\\count` registro `99`. 6. Una vez que `\\the` ha sido expandido, TeX vuelve a insertar el token guardado en el paso 3 (`{`token) y pone ese token de vuelta en la entrada. TeX hace eso creando otra lista de tokens que contiene el *único* token `{`token. 7. TeX ha terminado de procesar `\\expandafter` y produjo dos listas de tokens listas para usarse como siguientes fuentes de entrada. TeX vuelve a procesar `\\toks99=` pero ahora TeX ha configurado su entrada de modo que las dos listas de tokens creadas por `\\expandafter` se conviertan en la fuente de tokens para `\\toks`—que ahora ve `{`token``lista de tokens (caracteres)`}`. `\\toks` ahora puede acceder, y almacenar, la secuencia de 5 tokens de caracteres que representan el valor de datos (`12345`) almacenado en `\\count99`: el resultado deseado. 8. Después de leer todos los tokens de caracteres producidos por `\\the\\count99`, TeX vuelve a obtener tokens de su fuente de entrada anterior (nuestro `.tex` archivo) desde donde leerá el siguiente token: la llave de cierre `}` requerido para terminar la lista de tokens que debe ser guardada por `\\toks99={...}`. ## Cómo funciona realmente \\\expandafter En esta sección echaremos un vistazo “de bajo nivel” al interior del propio TeX: explorando el código fuente/las funciones dentro de TeX que implementan el comportamiento de `\\expandafter`. Los detalles se expresan en un pseudocódigo tipo C, pero deberían ser accesibles para cualquiera familiarizado con otros lenguajes de programación. El siguiente diagrama anotado explica cómo TeX implementa `\\expandafter` como parte de una función más grande llamada `expand()`—la función central que impulsa el procesamiento de expansión de TeX. Dentro de la sección responsable de implementar `\\expandafter` podemos ver [*recursivo* comportamiento](https://en.wikipedia.org/wiki/Recursion) donde otra llamada a la `expand()` función se usa para procesar el segundo token leído, $$\mathrm{T\_2}$$, para aquellos casos en los que $$\mathrm{T\_2}$$ es expandible. Aunque este código aparece en el motor TeX de Knuth, los principios básicos descritos por este gráfico son aplicables a todos los motores TeX. ![Cómo funciona \\\expandafter dentro de TeX](/files/f0669a595eece0ccd2248e9a0a930b61af884a66) La primera tarea de `expand()` es determinar si el comando que se va a expandir es una macro o una primitiva, porque las macros tienen un proceso de expansión especializado que es manejado por una función llamada `macrocall()`. Si el comando que se va a expandir es una primitiva, la `expand()` función usa el valor actual del código de comando (almacenado en la variable global `curcmd`) para identificar qué primitiva en particular necesita ser procesada. Podemos ver estos detalles en un listado más completo de `expand()`: ``` void expand(void) { //curcmd es una variable global if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Procesar el comando \expandafter T1T2 { gettoken(); // Leer el token T1 t = curtok; // Guardar el token T1 en la variable local t gettoken(); // Leer el token T2 if(curcmd > 100) // ¿Es el token T2 expandible? expand(); // ¡Sí! T2 es expandible: // realizar la expansión de T2 // haciendo una llamada recursiva a la función expand() else backinput(); // T2 no es expandible: coloca ese token // de vuelta en la entrada para que se lea otra vez (más tarde) curtok = t ; // Restaurar la variable global curtok al valor guardado de T1 backinput() ; // Volver a poner el token T1 en la entrada // antes que los tokens que surgen de la expansión de T2 } break; // Código para procesar otros comandos expandibles case “convertir a texto” comando: // Cualquiera de \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Comparten el mismo valor de curcmd break; case \noexpand: // Suprimir la expansión del siguiente token ... break; case \csname: // Crear un nombre de secuencia de control. ... break; case \the: // Insertar algunos tokens .... break; case “\if... comando de prueba” : // Procesar uno de los condicionales de TeX: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi o \else”: // Terminar el condicional actual ... break; // etc. para cualquier otro comando primitivo expandible compatible con // el motor TeX } }else // No es una primitiva expandible: es una macro { macrocall() } //... se eliminó más código } ``` ### El amor de TeX por las variables globales Quizás reflejando su antigüedad y la época en que fue diseñado, el código fuente de TeX hace un uso extensivo de las llamadas [variables globales](https://en.wikipedia.org/wiki/Global_variable)—de hecho hay cientos de ellas. Por su propia naturaleza, las variables globales pueden cambiarse/modificarse desde cualquier lugar dentro del código fuente de TeX, que, en el TeX de Knuth, es un único archivo monolítico que contiene más de 25.000 líneas de código y cientos de funciones. Entender cómo funciona TeX no siempre es una tarea fácil... Para procesar `\\expandafter`, TeX lee tokens de su entrada actual usando una función llamada `gettoken()` cuya acción consiste en crear un token y establecer el valor de varias variables globales clave usadas en todo el código fuente de TeX. Dos de esas variables, actualizadas por la acción de `gettoken()`, se usan en la implementación de `\\expandafter`: * `curtok`: (token actual) el valor entero del token recién leído; * `curcmd`: (código de comando actual) el código de comando del comando (o carácter) representado por el token `curtok`. Al procesar `\\expandafter`$$\mathrm{T\_1T\_2}$$ TeX lee el token $$\mathrm{T\_1}$$ y guarda temporalmente su valor (un entero) en una variable local llamada `t`. Luego TeX lee $$\mathrm{T\_2}$$ y comprueba si ese token representa un comando expandible, verificando si su código de comando (`curcmd`) es > 100. Si es así, TeX necesita expandir el comando representado por $$\mathrm{T\_2}$$ y hace otra llamada a la función `expand()`: este es un ejemplo de *recursión* porque el `expand()` la función se llama a sí misma. Ser consciente de la naturaleza recursiva de la expansión, especialmente al usar `\\expandafter`, puede ayudar a entender cómo múltiples `\\expandafter` comandos consecutivos, es decir, `\\expandafter\\expandafter\\expandafter...` logran sus efectos. Si el token $$\mathrm{T\_2}$$ es expandible, la expansión tiene lugar y, cuando la llamada recursiva a `expand()` devuelve, el código dentro de la implementación de `\\expandafter` vuelve a insertar el token $$\mathrm{T\_1}$$ de vuelta en la entrada. La variable global `curtok` se reasigna al valor del token guardado —almacenado en la variable local `t`, que es el valor del token $$\mathrm{T\_1}$$—y se hace una llamada a la función `backinput().` #### La función backinput() Como su nombre sugiere, esta función pone un token “de vuelta en la entrada”. Para hacer eso, TeX usa el valor actual de la variable global `curtok` para crear una lista de tokens que contiene un único token (cuyo valor entero es proporcionado por `curtok`). TeX también organiza el manejo de su entrada para asegurar que esa lista de un solo token será, en el momento apropiado, leída de nuevo por TeX como parte de su posterior procesamiento de entrada. Nótese cuidadosamente que el token $$\mathrm{T\_1}$$ se vuelve a insertar *después de que la expansión haya terminado*, lo que asegura que TeX leerá ese token reinsertado *antes de que* cuando lea los tokens que surgen de la expansión de $$\mathrm{T\_2}$$. ### Procesamiento de macros: la función macrocall() Como se discutió anteriormente, todas las macros, junto con algunos comandos primitivos, son expandibles y todo el procesamiento de expansión pasa por la `expand()` función. Sin embargo, `expand()` tiene cuidado de usar el valor de `curcmd` (comando actual) para distinguir entre primitivas expandibles y macros porque el proceso de expansión de macros es manejado por una función dedicada llamada `macrocall()`. Las macros necesitan un proceso de expansión especializado porque los argumentos de la macro y los tokens delimitadores deben buscarse de una manera muy particular y rigurosa; en consecuencia, ese proceso se delega a una función diseñada para ello: `macrocall()`. #### Expansión de macros frente a ejecución de macros Macro *expansión* no es el mismo proceso que la *ejecución*: la expansión de una macro es el proceso previo a la ejecución que TeX realiza para dejar la macro *lista para su ejecución*. La “ejecución” de una macro ocurre cuando TeX está leyendo y procesando activamente los tokens contenidos en la definición de esa macro (texto de reemplazo) y sus argumentos (parámetros). #### Expansión de macros Para expandir una macro, TeX primero comprueba si la macro toma argumentos; si es así, `macrocall()` examina muy cuidadosamente la entrada buscando tokens destinados a convertirse en los argumentos de la macro. Ese proceso incluye comprobar la entrada del usuario para cualquier token delimitador usado en la definición original de la macro: el patrón de tokens usado en una llamada a macro debe coincidir exactamente con el patrón de tokens contenido en la definición almacenada. Sin embargo, los tokens usados como delimitadores son simplemente descartados por TeX: en efecto, no son más que una forma de “puntuación” que TeX usa para determinar los tokens reales destinados a convertirse en argumentos de la macro, es decir, tokens que el usuario pretende que procese la macro. Para más información sobre los tokens delimitadores, véase [Cómo funcionan realmente las macros de TeX](/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md). Para cada parámetro (`#1, #2...#9`) presente en la definición original de la macro, TeX examina la llamada real a la macro para identificar qué tokens proporcionados por el usuario están destinados a cada parámetro (es decir, forman los argumentos de la macro). Ese proceso produce una o más mini listas de tokens: una por cada argumento de la macro. Después de detectar cualquier argumento de la macro y preparar sus listas de tokens, TeX recupera la definición de la macro (texto de reemplazo) almacenada en su memoria y organiza su procesamiento de entrada de modo que, cuando TeX esté listo para leer/procesar más tokens, los leerá del texto de reemplazo de la macro, ejecutando así la macro. En el punto apropiado, durante la ejecución de la macro, las listas de tokens que representan los argumentos de la macro se insertarán en la ubicación correcta dentro del texto de reemplazo de la macro. Una vez más, la expansión de un comando de macro significa *eliminar* ese comando de macro (token) de la entrada y *reemplazar* lo con la lista de tokens almacenada como texto de reemplazo de la macro. Para una mirada en profundidad al procesamiento de macros de TeX, vea la serie de artículos de seis partes [¿Cómo funcionan realmente las macros de TeX?](/latex/es/mas-temas/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.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.